?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 24.04.3.4
[LibreOffice.git] / fpicker / source / office / fileview.cxx
blob1fa1c4dafcd3154fafb2b4f895c3489d49b1e84a
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21 #include <sal/log.hxx>
22 #include <osl/diagnose.h>
23 #include <svtools/svtresid.hxx>
24 #include <svtools/imagemgr.hxx>
25 #include <svtools/querydelete.hxx>
26 #include <svtools/strings.hrc>
27 #include <bitmaps.hlst>
28 #include "contentenumeration.hxx"
29 #include <com/sun/star/task/InteractionHandler.hpp>
30 #include <com/sun/star/ucb/XProgressHandler.hpp>
31 #include <com/sun/star/ucb/XContent.hpp>
32 #include <com/sun/star/container/XChild.hpp>
33 #include <com/sun/star/ucb/CommandAbortedException.hpp>
34 #include <com/sun/star/ucb/XCommandInfo.hpp>
35 #include <com/sun/star/beans/XPropertySetInfo.hpp>
36 #include <com/sun/star/beans/PropertyAttribute.hpp>
37
38 #include <algorithm>
39 #include <string_view>
40 #include <vector>
41 #include <tools/debug.hxx>
42 #include <tools/urlobj.hxx>
43 #include <comphelper/processfactory.hxx>
44 #include <comphelper/string.hxx>
45 #include <ucbhelper/content.hxx>
46 #include <ucbhelper/commandenvironment.hxx>
47 #include <rtl/math.hxx>
48 #include <o3tl/safeint.hxx>
49 #include <o3tl/typed_flags_set.hxx>
50 #include <o3tl/string_view.hxx>
51 #include <osl/mutex.hxx>
52 #include <osl/conditn.hxx>
53 #include <salhelper/timer.hxx>
54 #include <svtools/urlfilter.hxx>
55 #include <unotools/collatorwrapper.hxx>
56 #include <unotools/localedatawrapper.hxx>
57 #include <unotools/intlwrapper.hxx>
58 #include <unotools/syslocale.hxx>
59 #include <vcl/svapp.hxx>
60 #include <vcl/commandevent.hxx>
61 #include <vcl/event.hxx>
62 #include <vcl/settings.hxx>
63 #include <vcl/timer.hxx>
64 #include <memory>
65 #include "fileview.hxx"
66
67 using namespace ::com::sun::star::lang;
68 using namespace ::com::sun::star::sdbc;
69 using namespace ::com::sun::star::task;
70 using namespace ::com::sun::star::ucb;
71 using namespace ::com::sun::star::uno;
72 using namespace ::com::sun::star::io;
73 using namespace ::com::sun::star::beans;
74 using namespace ::comphelper;
75 using ::svt::SortingData_Impl;
76 using ::svt::FolderDescriptor;
77
78 constexpr OUStringLiteral ALL_FILES_FILTER = u"*.*";
79
80 #define COLUMN_TITLE 1
81 #define COLUMN_TYPE 2
82 #define COLUMN_SIZE 3
83 #define COLUMN_DATE 4
84
85 #define QUICK_SEARCH_TIMEOUT 1500 // time in mSec before the quicksearch string will be reset
86
87 namespace {
88
89 enum class FileViewFlags
90 {
91 NONE = 0x00,
92 MULTISELECTION = 0x02,
93 SHOW_TYPE = 0x04,
94 SHOW_NONE = 0x20,
95 };
96
97 }
98
99 namespace o3tl
100 {
101 template<> struct typed_flags<FileViewFlags> : is_typed_flags<FileViewFlags, 0x26> {};
102 }
103
104 namespace
105 {
106
107 //= CallbackTimer
108
109 class CallbackTimer : public ::salhelper::Timer
110 {
111 protected:
112 SvtFileView_Impl* const m_pTimeoutHandler;
113
114 public:
115 explicit CallbackTimer( SvtFileView_Impl* _pHandler ) : m_pTimeoutHandler( _pHandler ) { }
116
117 protected:
118 virtual void SAL_CALL onShot() override;
119 };
120
121 class ViewTabListBox_Impl
122 {
123 private:
124 Reference< XCommandEnvironment > mxCmdEnv;
125 std::unique_ptr<weld::TreeView> mxTreeView;
126 std::unique_ptr<weld::TreeIter> mxScratchIter;
127
128 ::osl::Mutex maMutex;
129 SvtFileView_Impl* mpParent;
130 Timer maResetQuickSearch { "fpicker SvtFileView_Impl maResetQuickSearch" };
131 OUString maQuickSearchText;
132 sal_uInt32 mnSearchIndex;
133 bool mbEnableDelete;
134 bool mbEditing;
135 bool const mbShowType;
136
137 void DeleteEntries();
138 void DoQuickSearch( sal_Unicode rChar );
139 bool Kill( const OUString& rURL );
140
141 public:
142 ViewTabListBox_Impl(std::unique_ptr<weld::TreeView> xTreeView, weld::Window* pTopLevel, SvtFileView_Impl* pParent, FileViewFlags nFlags);
143
144 std::unique_ptr<weld::TreeIter> make_iterator() const { return mxTreeView->make_iterator(); }
145 void insert(const OUString &rEntry, const OUString& rId, const OUString& rImage, weld::TreeIter& rIter)
146 {
147 mxTreeView->insert(nullptr, -1, &rEntry, &rId, nullptr, nullptr, false, &rIter);
148 mxTreeView->set_image(rIter, rImage);
149 }
150 void append(const OUString& rId, const OUString& rStr, const OUString& rType, const OUString& rSize, const OUString& rDate, const OUString& rImage)
151 {
152 mxTreeView->insert(nullptr, -1, &rStr, &rId, nullptr, nullptr, false, mxScratchIter.get());
153 mxTreeView->set_image(*mxScratchIter, rImage);
154 int nCol = 1;
155 if (mbShowType)
156 mxTreeView->set_text(*mxScratchIter, rType, nCol++);
157 mxTreeView->set_text(*mxScratchIter, rSize, nCol++);
158 mxTreeView->set_text(*mxScratchIter, rDate, nCol++);
159 }
160
161 void scroll_to_row(const weld::TreeIter& rIter) { mxTreeView->scroll_to_row(rIter); }
162 void set_cursor(int nPos) { mxTreeView->set_cursor(nPos); }
163 void set_cursor(const weld::TreeIter& rIter) { mxTreeView->set_cursor(rIter); }
164 bool get_cursor(weld::TreeIter* pIter) const { return mxTreeView->get_cursor(pIter); }
165 bool get_iter_first(weld::TreeIter& rIter) const { return mxTreeView->get_iter_first(rIter); }
166 bool get_selected(weld::TreeIter* pIter) const { return mxTreeView->get_selected(pIter); }
167
168 OUString get_selected_text() const
169 {
170 // tdf#131898 only care about column 0
171 int nIndex = mxTreeView->get_selected_index();
172 return nIndex != -1 ? mxTreeView->get_text(nIndex, 0) : OUString();
173 }
174
175 void unselect_all() { mxTreeView->unselect_all(); }
176
177 OUString get_id(const weld::TreeIter& rIter) { return mxTreeView->get_id(rIter); }
178
179 void connect_row_activated(const Link<weld::TreeView&, bool>& rLink) { mxTreeView->connect_row_activated(rLink); }
180 void connect_changed(const Link<weld::TreeView&, void>& rLink) { mxTreeView->connect_changed(rLink); }
181
182 int n_children() const { return mxTreeView->n_children(); }
183
184 void freeze() { mxTreeView->freeze(); }
185 void thaw() { mxTreeView->thaw(); }
186
187 void show() { mxTreeView->show(); }
188 void hide() { mxTreeView->hide(); }
189 bool get_visible() const { return mxTreeView->get_visible(); }
190
191 int count_selected_rows() const { return mxTreeView->count_selected_rows(); }
192
193 void grab_focus() { mxTreeView->grab_focus(); }
194 bool has_focus() const { return mxTreeView->has_focus(); }
195
196 void set_help_id(const OUString& rHelpId) { mxTreeView->set_help_id(rHelpId); }
197 OUString get_help_id() const { return mxTreeView->get_help_id(); }
198
199 bool IsEditingActive() const { return mbEditing; }
200
201 void end_editing()
202 {
203 mxTreeView->end_editing();
204 mxTreeView->connect_editing(Link<const weld::TreeIter&, bool>(), Link<const IterString&, bool>());
205 mbEditing = false;
206 }
207
208 void selected_foreach(const std::function<bool(weld::TreeIter&)>& func)
209 {
210 mxTreeView->selected_foreach(func);
211 }
212
213 weld::TreeView* getWidget() const
214 {
215 return mxTreeView.get();
216 }
217
218 void clear() { mxTreeView->clear(); }
219
220 void EnableDelete( bool bEnable ) { mbEnableDelete = bEnable; }
221 bool TypeColumnVisible() const { return mbShowType; }
222
223 const Reference< XCommandEnvironment >& GetCommandEnvironment() const { return mxCmdEnv; }
224
225 DECL_LINK(ResetQuickSearch_Impl, Timer *, void);
226 DECL_LINK(CommandHdl, const CommandEvent&, bool);
227 DECL_LINK(EditingEntryHdl, const weld::TreeIter&, bool);
228 typedef std::pair<const weld::TreeIter&, OUString> IterString;
229 DECL_LINK(EditedEntryHdl, const IterString&, bool);
230 DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
231
232 void ExecuteContextMenuAction(std::u16string_view rSelectedPopentry);
233 };
234
235 }
236
237 //= SvtFileView_Impl
238 class SvtFileView_Impl :public ::svt::IEnumerationResultHandler
239 {
240 protected:
241 SvtFileView* m_pAntiImpl;
242 Link<SvtFileView*,void> m_aSelectHandler;
243
244 ::rtl::Reference< ::svt::FileViewContentEnumerator >
245 m_xContentEnumerator;
246 Link<void*,void> m_aCurrentAsyncActionHandler;
247 ::osl::Condition m_aAsyncActionFinished;
248 ::rtl::Reference< ::salhelper::Timer > m_xCancelAsyncTimer;
249 ::svt::EnumerationResult m_eAsyncActionResult;
250 bool m_bRunningAsyncAction;
251 bool m_bAsyncActionCancelled;
252
253 public:
254
255 ::std::vector<std::unique_ptr<SortingData_Impl>> maContent;
256 ::std::vector<std::unique_ptr<SvtContentEntry>> maEntries;
257 ::osl::Mutex maMutex;
258
259 weld::Window* m_pTopLevel;
260 std::unique_ptr<ViewTabListBox_Impl> mxView;
261 std::unique_ptr<weld::IconView> mxIconView;
262 sal_uInt16 mnSortColumn;
263 bool mbAscending : 1;
264 bool const mbOnlyFolder : 1;
265 sal_Int16 mnSuspendSelectCallback : 1;
266 bool mbIsFirstResort : 1;
267
268 IntlWrapper const aIntlWrapper;
269
270 OUString maViewURL;
271 OUString maCurrentFilter;
272 OUString maFolderImage;
273 Link<SvtFileView*,void> maOpenDoneLink;
274 Link<SvtFileView*,bool> maDoubleClickHandler;
275
276 Reference< XCommandEnvironment > mxCmdEnv;
277
278 SvtFileView_Impl(SvtFileView* pAntiImpl, weld::Window* pTopLevel,
279 std::unique_ptr<weld::TreeView> xTreeView,
280 std::unique_ptr<weld::IconView> xIconView,
281 Reference < XCommandEnvironment > const & xEnv,
282 FileViewFlags nFlags,
283 bool bOnlyFolder);
284
285 virtual ~SvtFileView_Impl();
286
287 void Clear();
288
289 FileViewResult GetFolderContent_Impl(
290 std::u16string_view rFolder,
291 const FileViewAsyncAction* pAsyncDescriptor,
292 const css::uno::Sequence< OUString >& rDenyList );
293
294 FileViewResult GetFolderContent_Impl(
295 const FolderDescriptor& _rFolder,
296 const FileViewAsyncAction* pAsyncDescriptor,
297 const css::uno::Sequence< OUString >& rDenyList );
298 void FilterFolderContent_Impl( std::u16string_view rFilter );
299 void CancelRunningAsyncAction();
300
301 void OpenFolder_Impl();
302 static OUString ReplaceTabWithString(const OUString& rValue);
303 void CreateDisplayText_Impl();
304 void SortFolderContent_Impl();
305
306 void EntryRemoved( std::u16string_view rURL );
307 void EntryRenamed( OUString& rURL,
308 const OUString& rName );
309 const SortingData_Impl& FolderInserted( const OUString& rURL,
310 const OUString& rTitle );
311
312 int GetEntryPos( std::u16string_view rURL );
313
314 void SetViewMode( FileViewMode eMode );
315
316 inline void EnableDelete( bool bEnable );
317
318 void Resort_Impl( sal_Int16 nColumn, bool bAscending );
319 bool SearchNextEntry( sal_uInt32 &nIndex,
320 std::u16string_view rTitle,
321 bool bWrapAround );
322
323 void SetSelectHandler( const Link<SvtFileView*,void>& rHdl );
324 void SetDoubleClickHandler(const Link<SvtFileView*,bool>& rHdl);
325
326 void ResetCursor();
327
328 void EndEditing()
329 {
330 if (mxView->IsEditingActive())
331 mxView->end_editing();
332 }
333
334 void onTimeout();
335
336 void grab_focus()
337 {
338 if (mxView->get_visible())
339 mxView->grab_focus();
340 else
341 mxIconView->grab_focus();
342 }
343
344 bool has_focus() const
345 {
346 return mxView->has_focus() || mxIconView->has_focus();
347 }
348
349 int GetSortColumn() const
350 {
351 sal_uInt16 nOldSortID = mnSortColumn;
352 // skip "TYPE"
353 if (!mxView->TypeColumnVisible() && nOldSortID != COLUMN_TITLE)
354 --nOldSortID;
355 return nOldSortID - 1;
356 }
357
358 protected:
359 DECL_LINK(ChangedHdl, weld::TreeView&, void);
360 DECL_LINK(SelectionChangedHdl, weld::IconView&, void);
361 DECL_LINK(RowActivatedHdl, weld::TreeView&, bool);
362 DECL_LINK(ItemActivatedHdl, weld::IconView&, bool);
363
364 // IEnumerationResultHandler overridables
365 virtual void enumerationDone( ::svt::EnumerationResult eResult ) override;
366 void implEnumerationSuccess();
367 };
368
369 inline void SvtFileView_Impl::EnableDelete( bool bEnable )
370 {
371 mxView->EnableDelete( bEnable );
372 }
373
374 namespace
375 {
376 // functions -------------------------------------------------------------
377
378 OUString CreateExactSizeText( sal_Int64 nSize )
379 {
380 double fSize( static_cast<double>(nSize) );
381 int nDec;
382
383 tools::Long nMega = 1024 * 1024;
384 tools::Long nGiga = nMega * 1024;
385
386 OUString aUnitStr(' ');
387
388 if ( nSize < 10000 )
389 {
390 aUnitStr += SvtResId(STR_SVT_BYTES );
391 nDec = 0;
392 }
393 else if ( nSize < nMega )
394 {
395 fSize /= 1024;
396 aUnitStr += SvtResId(STR_SVT_KB);
397 nDec = 1;
398 }
399 else if ( nSize < nGiga )
400 {
401 fSize /= nMega;
402 aUnitStr += SvtResId(STR_SVT_MB);
403 nDec = 2;
404 }
405 else
406 {
407 fSize /= nGiga;
408 aUnitStr += SvtResId(STR_SVT_GB);
409 nDec = 3;
410 }
411
412 OUString aSizeStr =
413 ::rtl::math::doubleToUString( fSize,
414 rtl_math_StringFormat_F, nDec,
415 SvtSysLocale().GetLocaleData().getNumDecimalSep()[0]) +
416 aUnitStr;
417
418 return aSizeStr;
419 }
420 }
421
422 ViewTabListBox_Impl::ViewTabListBox_Impl(std::unique_ptr<weld::TreeView> xTreeView,
423 weld::Window* pTopLevel,
424 SvtFileView_Impl* pParent,
425 FileViewFlags nFlags)
426 : mxTreeView(std::move(xTreeView))
427 , mxScratchIter(mxTreeView->make_iterator())
428 , mpParent( pParent )
429 , mnSearchIndex( 0 )
430 , mbEnableDelete( false )
431 , mbEditing( false )
432 , mbShowType(nFlags & FileViewFlags::SHOW_TYPE)
433 {
434 std::vector<int> aWidths { 180 };
435 if (nFlags & FileViewFlags::SHOW_TYPE)
436 aWidths.push_back(140);
437 aWidths.push_back(80);
438 mxTreeView->set_column_fixed_widths(aWidths);
439
440 if (nFlags & FileViewFlags::MULTISELECTION)
441 mxTreeView->set_selection_mode(SelectionMode::Multiple);
442
443 maResetQuickSearch.SetTimeout( QUICK_SEARCH_TIMEOUT );
444 maResetQuickSearch.SetInvokeHandler( LINK( this, ViewTabListBox_Impl, ResetQuickSearch_Impl ) );
445
446 Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
447 Reference< XInteractionHandler > xInteractionHandler(
448 InteractionHandler::createWithParent(xContext, pTopLevel->GetXWindow()), UNO_QUERY_THROW);
449
450 mxCmdEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, Reference< XProgressHandler >() );
451
452 mxTreeView->connect_popup_menu(LINK(this, ViewTabListBox_Impl, CommandHdl));
453 mxTreeView->connect_key_press(LINK(this, ViewTabListBox_Impl, KeyInputHdl));
454 }
455
456 IMPL_LINK_NOARG(ViewTabListBox_Impl, EditingEntryHdl, const weld::TreeIter&, bool)
457 {
458 return mbEditing;
459 }
460
461 IMPL_LINK_NOARG(ViewTabListBox_Impl, ResetQuickSearch_Impl, Timer *, void)
462 {
463 ::osl::MutexGuard aGuard( maMutex );
464
465 maQuickSearchText.clear();
466 mnSearchIndex = 0;
467 }
468
469 IMPL_LINK(ViewTabListBox_Impl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
470 {
471 if (mbEditing)
472 return false;
473
474 bool bHandled = false;
475
476 const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
477 if ( 0 == rKeyCode.GetModifier() )
478 {
479 if ( ( rKeyCode.GetCode() == KEY_DELETE ) &&
480 mbEnableDelete )
481 {
482 ResetQuickSearch_Impl( nullptr );
483 DeleteEntries();
484 bHandled = true;
485 }
486 else if ( ( rKEvt.GetKeyCode().GetGroup() == KEYGROUP_NUM ) ||
487 ( rKEvt.GetKeyCode().GetGroup() == KEYGROUP_ALPHA ) )
488 {
489 DoQuickSearch( rKEvt.GetCharCode() );
490 bHandled = true;
491 }
492 }
493
494 if (!bHandled)
495 ResetQuickSearch_Impl( nullptr );
496 return bHandled;
497 }
498
499 IMPL_LINK(ViewTabListBox_Impl, CommandHdl, const CommandEvent&, rCEvt, bool)
500 {
501 if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
502 return false;
503
504 bool bEnableDelete = mbEnableDelete;
505 bool bEnableRename = true;
506
507 int nCount = 0;
508 mxTreeView->selected_foreach([this, &nCount, &bEnableDelete, &bEnableRename](weld::TreeIter& rEntry){
509 ++nCount;
510
511 ::ucbhelper::Content aCnt;
512 try
513 {
514 OUString aURL(weld::fromId<SvtContentEntry*>(
515 mxTreeView->get_id(rEntry))->maURL);
516 aCnt = ::ucbhelper::Content( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
517 }
518 catch( Exception const & )
519 {
520 bEnableDelete = bEnableRename = false;
521 }
522
523 if ( bEnableDelete )
524 {
525 try
526 {
527 Reference< XCommandInfo > aCommands = aCnt.getCommands();
528 if ( aCommands.is() )
529 bEnableDelete = aCommands->hasCommandByName( "delete" );
530 else
531 bEnableDelete = false;
532 }
533 catch( Exception const & )
534 {
535 bEnableDelete = false;
536 }
537 }
538
539 if ( bEnableRename )
540 {
541 try
542 {
543 Reference< XPropertySetInfo > aProps = aCnt.getProperties();
544 if ( aProps.is() )
545 {
546 Property aProp = aProps->getPropertyByName("Title");
547 bEnableRename
548 = !( aProp.Attributes & PropertyAttribute::READONLY );
549 }
550 else
551 bEnableRename = false;
552 }
553 catch( Exception const & )
554 {
555 bEnableRename = false;
556 }
557 }
558
559 bool bStop = !bEnableDelete && !bEnableRename;
560 return bStop;
561 });
562
563 if (nCount == 0)
564 bEnableDelete = false;
565 if (nCount != 1)
566 bEnableRename = false;
567
568 if (bEnableDelete || bEnableRename)
569 {
570 std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(mxTreeView.get(), "svt/ui/fileviewmenu.ui"));
571 auto xContextMenu = xBuilder->weld_menu("menu");
572 xContextMenu->set_visible("delete", bEnableDelete);
573 xContextMenu->set_visible("rename", bEnableRename);
574 OUString sCommand(xContextMenu->popup_at_rect(mxTreeView.get(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1))));
575 ExecuteContextMenuAction(sCommand);
576 }
577
578 return true;
579 }
580
581 void ViewTabListBox_Impl::ExecuteContextMenuAction(std::u16string_view rSelectedPopupEntry)
582 {
583 if (rSelectedPopupEntry == u"delete")
584 DeleteEntries();
585 else if (rSelectedPopupEntry == u"rename")
586 {
587 std::unique_ptr<weld::TreeIter> xEntry = mxTreeView->make_iterator();
588 if (mxTreeView->get_selected(xEntry.get()))
589 {
590 mbEditing = true;
591
592 mxTreeView->connect_editing(LINK(this, ViewTabListBox_Impl, EditingEntryHdl),
593 LINK(this, ViewTabListBox_Impl, EditedEntryHdl));
594
595 mxTreeView->start_editing(*xEntry);
596 }
597 }
598 }
599
600 void ViewTabListBox_Impl::DeleteEntries()
601 {
602 short eResult = svtools::QUERYDELETE_YES;
603
604 mxTreeView->selected_foreach([this, &eResult](weld::TreeIter& rCurEntry){
605 OUString aURL;
606 if (!mxTreeView->get_id(rCurEntry).isEmpty())
607 aURL = weld::fromId<SvtContentEntry*>(mxTreeView->get_id(rCurEntry))->maURL;
608 if (aURL.isEmpty())
609 {
610 mxTreeView->unselect(rCurEntry);
611 return false;
612 }
613
614 bool canDelete = true;
615 try
616 {
617 ::ucbhelper::Content aCnt( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
618 Reference< XCommandInfo > aCommands = aCnt.getCommands();
619 if ( aCommands.is() )
620 canDelete = aCommands->hasCommandByName( "delete" );
621 else
622 canDelete = false;
623 }
624 catch( Exception const & )
625 {
626 canDelete = false;
627 }
628
629 if (!canDelete)
630 {
631 mxTreeView->unselect(rCurEntry);
632 return false; // process next entry
633 }
634
635 if ( eResult != svtools::QUERYDELETE_ALL )
636 {
637 INetURLObject aObj( aURL );
638 svtools::QueryDeleteDlg_Impl aDlg(
639 mxTreeView.get(), aObj.GetLastName(INetURLObject::DecodeMechanism::WithCharset));
640
641 if (mxTreeView->count_selected_rows() > 1)
642 aDlg.EnableAllButton();
643
644 eResult = aDlg.run();
645 }
646
647 bool bDeleted = false;
648
649 if (eResult == svtools::QUERYDELETE_ALL || eResult == svtools::QUERYDELETE_YES)
650 {
651 if ( Kill( aURL ) )
652 {
653 mpParent->EntryRemoved( aURL );
654 bDeleted = true;
655 }
656 }
657
658 if (!bDeleted)
659 mxTreeView->unselect(rCurEntry);
660
661 return false;
662 });
663
664 mxTreeView->remove_selection();
665 }
666
667 IMPL_LINK(ViewTabListBox_Impl, EditedEntryHdl, const IterString&, rIterString, bool)
668 {
669 mbEditing = false;
670
671 mxTreeView->connect_editing(Link<const weld::TreeIter&, bool>(), Link<const IterString&, bool>());
672
673 const weld::TreeIter& rEntry = rIterString.first;
674 OUString sNewText = rIterString.second;
675
676 if (sNewText.isEmpty())
677 return false;
678
679 bool bRet = false;
680
681 OUString aURL;
682 SvtContentEntry* pData = weld::fromId<SvtContentEntry*>(mxTreeView->get_id(rEntry));
683
684 if ( pData )
685 aURL = pData->maURL;
686
687 if ( aURL.isEmpty() )
688 return bRet;
689
690 try
691 {
692 OUString aPropName( "Title" );
693 bool canRename = true;
694 ::ucbhelper::Content aContent( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
695
696 try
697 {
698 Reference< XPropertySetInfo > aProps = aContent.getProperties();
699 if ( aProps.is() )
700 {
701 Property aProp = aProps->getPropertyByName( aPropName );
702 canRename = !( aProp.Attributes & PropertyAttribute::READONLY );
703 }
704 else
705 {
706 canRename = false;
707 }
708 }
709 catch ( Exception const & )
710 {
711 canRename = false;
712 }
713
714 if ( canRename )
715 {
716 Any aValue;
717 aValue <<= sNewText;
718 aContent.setPropertyValue( aPropName, aValue );
719 mpParent->EntryRenamed(aURL, sNewText);
720
721 if (pData)
722 pData->maURL = aURL;
723
724 mxTreeView->set_id(rEntry, weld::toId(pData));
725
726 bRet = true;
727 }
728 }
729 catch( Exception const & )
730 {
731 }
732
733 return bRet;
734 }
735
736 void ViewTabListBox_Impl::DoQuickSearch( sal_Unicode rChar )
737 {
738 ::osl::MutexGuard aGuard( maMutex );
739
740 maResetQuickSearch.Stop();
741
742 OUString aLastText = maQuickSearchText;
743 sal_uInt32 aLastPos = mnSearchIndex;
744
745 maQuickSearchText += OUString(rChar).toAsciiLowerCase();
746
747 bool bFound = mpParent->SearchNextEntry( mnSearchIndex, maQuickSearchText, false );
748
749 if ( !bFound && ( aLastText.getLength() == 1 ) &&
750 ( aLastText == OUStringChar(rChar) ) )
751 {
752 mnSearchIndex = aLastPos + 1;
753 maQuickSearchText = aLastText;
754 bFound = mpParent->SearchNextEntry( mnSearchIndex, maQuickSearchText, true );
755 }
756
757 if (bFound)
758 {
759 mxTreeView->unselect_all();
760 mxTreeView->select(mnSearchIndex);
761 mxTreeView->set_cursor(mnSearchIndex);
762 mxTreeView->scroll_to_row(mnSearchIndex);
763 }
764
765 maResetQuickSearch.Start();
766 }
767
768 bool ViewTabListBox_Impl::Kill( const OUString& rContent )
769 {
770 bool bRet = true;
771
772 try
773 {
774 ::ucbhelper::Content aCnt( rContent, mxCmdEnv, comphelper::getProcessComponentContext() );
775 aCnt.executeCommand( "delete", Any( true ) );
776 }
777 catch( css::ucb::CommandAbortedException const & )
778 {
779 SAL_INFO( "svtools.contnr", "CommandAbortedException" );
780 bRet = false;
781 }
782 catch( Exception const & )
783 {
784 SAL_INFO( "svtools.contnr", "Any other exception" );
785 bRet = false;
786 }
787
788 return bRet;
789 }
790
791 SvtFileView::SvtFileView(weld::Window* pTopLevel,
792 std::unique_ptr<weld::TreeView> xTreeView,
793 std::unique_ptr<weld::IconView> xIconView,
794 bool bOnlyFolder, bool bMultiSelection, bool bShowType )
795 {
796 FileViewFlags nFlags = FileViewFlags::NONE;
797 if ( bMultiSelection )
798 nFlags |= FileViewFlags::MULTISELECTION;
799 if ( bShowType )
800 nFlags |= FileViewFlags::SHOW_TYPE;
801
802 Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
803 Reference< XInteractionHandler > xInteractionHandler(
804 InteractionHandler::createWithParent(xContext, pTopLevel->GetXWindow()), UNO_QUERY_THROW);
805 Reference < XCommandEnvironment > xCmdEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, Reference< XProgressHandler >() );
806
807 mpImpl.reset(new SvtFileView_Impl(this, pTopLevel, std::move(xTreeView), std::move(xIconView), xCmdEnv, nFlags, bOnlyFolder));
808
809 weld::TreeView* pView = mpImpl->mxView->getWidget();
810 pView->connect_column_clicked(LINK(this, SvtFileView, HeaderSelect_Impl));
811 }
812
813 void SvtFileView::grab_focus()
814 {
815 mpImpl->grab_focus();
816 }
817
818 bool SvtFileView::has_focus() const
819 {
820 return mpImpl->has_focus();
821 }
822
823 SvtFileView::~SvtFileView()
824 {
825 }
826
827 void SvtFileView::SetViewMode( FileViewMode eMode )
828 {
829 mpImpl->SetViewMode( eMode );
830 }
831
832 OUString SvtFileView::GetURL(const weld::TreeIter& rEntry) const
833 {
834 SvtContentEntry* pEntry;
835 if (mpImpl->mxView->get_visible())
836 pEntry = weld::fromId<SvtContentEntry*>(mpImpl->mxView->get_id(rEntry));
837 else
838 pEntry = weld::fromId<SvtContentEntry*>(mpImpl->mxIconView->get_id(rEntry));
839 if (pEntry)
840 return pEntry->maURL;
841 return OUString();
842 }
843
844 OUString SvtFileView::GetCurrentURL() const
845 {
846 SvtContentEntry* pEntry = nullptr;
847 OUString aURL;
848 if (mpImpl->mxView->get_visible())
849 {
850 std::unique_ptr<weld::TreeIter> xEntry = mpImpl->mxView->make_iterator();
851 if (mpImpl->mxView->get_selected(xEntry.get()))
852 pEntry = weld::fromId<SvtContentEntry*>(mpImpl->mxView->get_id(*xEntry));
853 }
854 else
855 {
856 std::unique_ptr<weld::TreeIter> xEntry = mpImpl->mxIconView->make_iterator();
857 if (mpImpl->mxIconView->get_selected(xEntry.get()))
858 pEntry = weld::fromId<SvtContentEntry*>(mpImpl->mxIconView->get_id(*xEntry));
859 }
860 if (pEntry)
861 aURL = pEntry->maURL;
862 return aURL;
863 }
864
865 void SvtFileView::CreatedFolder( const OUString& rUrl, const OUString& rNewFolder )
866 {
867 const SortingData_Impl& rEntry = mpImpl->FolderInserted( rUrl, rNewFolder );
868
869 mpImpl->maEntries.emplace_back(std::make_unique<SvtContentEntry>(rUrl, true));
870 OUString sId(weld::toId(mpImpl->maEntries.back().get()));
871
872 std::unique_ptr<weld::TreeIter> xEntry = mpImpl->mxView->make_iterator();
873 mpImpl->mxView->insert(rEntry.maDisplayName, sId, mpImpl->maFolderImage, *xEntry);
874 mpImpl->mxView->scroll_to_row(*xEntry);
875
876 std::unique_ptr<weld::TreeIter> xIconEntry = mpImpl->mxIconView->make_iterator();
877 mpImpl->mxIconView->insert(-1, &rEntry.maDisplayName, &sId, &mpImpl->maFolderImage, xIconEntry.get());
878 mpImpl->mxIconView->scroll_to_item(*xIconEntry);
879 }
880
881 FileViewResult SvtFileView::PreviousLevel( const FileViewAsyncAction* pAsyncDescriptor )
882 {
883 FileViewResult eResult = eFailure;
884
885 OUString sParentURL;
886 if ( GetParentURL( sParentURL ) )
887 eResult = Initialize( sParentURL, mpImpl->maCurrentFilter, pAsyncDescriptor, maDenyList );
888
889 return eResult;
890 }
891
892 bool SvtFileView::GetParentURL( OUString& rParentURL ) const
893 {
894 bool bRet = false;
895 try
896 {
897 ::ucbhelper::Content aCnt( mpImpl->maViewURL, mpImpl->mxCmdEnv, comphelper::getProcessComponentContext() );
898 Reference< XContent > xContent( aCnt.get() );
899 Reference< css::container::XChild > xChild( xContent, UNO_QUERY );
900 if ( xChild.is() )
901 {
902 Reference< XContent > xParent( xChild->getParent(), UNO_QUERY );
903 if ( xParent.is() )
904 {
905 rParentURL = xParent->getIdentifier()->getContentIdentifier();
906 bRet = !rParentURL.isEmpty() && rParentURL != mpImpl->maViewURL;
907 }
908 }
909 }
910 catch( Exception const & )
911 {
912 // perhaps an unknown url protocol (e.g. "private:newdoc")
913 }
914
915 return bRet;
916 }
917
918 OUString SvtFileView::get_help_id() const
919 {
920 return mpImpl->mxView->get_help_id();
921 }
922
923 void SvtFileView::set_help_id(const OUString& rHelpId)
924 {
925 mpImpl->mxView->set_help_id(rHelpId);
926 }
927
928 OUString SvtFileView::get_selected_text() const
929 {
930 if (mpImpl->mxView->get_visible())
931 return mpImpl->mxView->get_selected_text();
932 return mpImpl->mxIconView->get_selected_text();
933 }
934
935 FileViewResult SvtFileView::Initialize(
936 const OUString& rURL,
937 const OUString& rFilter,
938 const FileViewAsyncAction* pAsyncDescriptor,
939 const css::uno::Sequence< OUString >& rDenyList )
940 {
941 weld::WaitObject aWaitCursor(mpImpl->m_pTopLevel);
942 maDenyList = rDenyList;
943
944 OUString sPushURL( mpImpl->maViewURL );
945
946 mpImpl->maViewURL = rURL;
947 FileViewResult eResult = ExecuteFilter( rFilter, pAsyncDescriptor );
948 switch ( eResult )
949 {
950 case eFailure:
951 case eTimeout:
952 mpImpl->maViewURL = sPushURL;
953 return eResult;
954
955 case eStillRunning:
956 OSL_ENSURE( pAsyncDescriptor, "SvtFileView::Initialize: we told it to read synchronously!" );
957 [[fallthrough]];
958 case eSuccess:
959 return eResult;
960 }
961
962 OSL_FAIL( "SvtFileView::Initialize: unreachable!" );
963 return eFailure;
964 }
965
966 FileViewResult SvtFileView::ExecuteFilter( const OUString& rFilter, const FileViewAsyncAction* pAsyncDescriptor )
967 {
968 mpImpl->maCurrentFilter = rFilter.toAsciiLowerCase();
969
970 mpImpl->Clear();
971 FileViewResult eResult = mpImpl->GetFolderContent_Impl(mpImpl->maViewURL, pAsyncDescriptor, maDenyList);
972 OSL_ENSURE( ( eResult != eStillRunning ) || pAsyncDescriptor, "SvtFileView::ExecuteFilter: we told it to read synchronously!" );
973 return eResult;
974 }
975
976 void SvtFileView::CancelRunningAsyncAction()
977 {
978 mpImpl->CancelRunningAsyncAction();
979 }
980
981 void SvtFileView::SetNoSelection()
982 {
983 mpImpl->mxView->unselect_all();
984 mpImpl->mxIconView->unselect_all();
985 }
986
987 void SvtFileView::SetSelectHdl(const Link<SvtFileView*,void>& rHdl)
988 {
989 mpImpl->SetSelectHandler(rHdl);
990 }
991
992 void SvtFileView::SetDoubleClickHdl(const Link<SvtFileView*,bool>& rHdl)
993 {
994 mpImpl->SetDoubleClickHandler(rHdl);
995 }
996
997 sal_uInt32 SvtFileView::GetSelectionCount() const
998 {
999 if (mpImpl->mxView->get_visible())
1000 return mpImpl->mxView->count_selected_rows();
1001 return mpImpl->mxIconView->count_selected_items();
1002 }
1003
1004 SvtContentEntry* SvtFileView::FirstSelected() const
1005 {
1006 if (mpImpl->mxView->get_visible())
1007 {
1008 SvtContentEntry* pRet = nullptr;
1009 std::unique_ptr<weld::TreeIter> xEntry = mpImpl->mxView->make_iterator();
1010 if (mpImpl->mxView->get_selected(xEntry.get()))
1011 pRet = weld::fromId<SvtContentEntry*>(mpImpl->mxView->get_id(*xEntry));
1012 return pRet;
1013 }
1014
1015 SvtContentEntry* pRet = nullptr;
1016 std::unique_ptr<weld::TreeIter> xEntry = mpImpl->mxIconView->make_iterator();
1017 if (mpImpl->mxIconView->get_selected(xEntry.get()))
1018 pRet = weld::fromId<SvtContentEntry*>(mpImpl->mxIconView->get_id(*xEntry));
1019 return pRet;
1020 }
1021
1022 const OUString& SvtFileView::GetViewURL() const
1023 {
1024 return mpImpl->maViewURL;
1025 }
1026
1027 void SvtFileView::SetOpenDoneHdl( const Link<SvtFileView*,void>& rHdl )
1028 {
1029 mpImpl->maOpenDoneLink = rHdl;
1030 }
1031
1032 void SvtFileView::EnableDelete( bool bEnable )
1033 {
1034 mpImpl->EnableDelete( bEnable );
1035 }
1036
1037 void SvtFileView::EndInplaceEditing()
1038 {
1039 return mpImpl->EndEditing();
1040 }
1041
1042 IMPL_LINK(SvtFileView, HeaderSelect_Impl, int, nColumn, void)
1043 {
1044 sal_uInt16 nItemID = nColumn + 1;
1045 // skip "TYPE"
1046 if (!mpImpl->mxView->TypeColumnVisible() && nItemID != COLUMN_TITLE)
1047 ++nItemID;
1048
1049 weld::TreeView* pView = mpImpl->mxView->getWidget();
1050 bool bSortAtoZ = mpImpl->mbAscending;
1051
1052 //set new arrow positions in headerbar
1053 if (nItemID != mpImpl->mnSortColumn)
1054 {
1055 // remove old indicator, new will be created in OpenFolder_Impl
1056 pView->set_sort_indicator(TRISTATE_INDET, mpImpl->GetSortColumn());
1057 }
1058 else
1059 bSortAtoZ = !bSortAtoZ;
1060
1061 mpImpl->Resort_Impl(nItemID, bSortAtoZ);
1062 }
1063
1064 OUString SvtFileView::GetConfigString() const
1065 {
1066 // sort order
1067 OUString sRet = OUString::number( mpImpl->mnSortColumn ) + ";";
1068
1069 bool bUp = mpImpl->mbAscending;
1070 sRet += OUString::Concat(bUp ? std::u16string_view(u"1") : std::u16string_view(u"0")) + ";";
1071
1072 weld::TreeView* pView = mpImpl->mxView->getWidget();
1073 sal_uInt16 nCount = mpImpl->mxView->TypeColumnVisible() ? 4 : 3;
1074 for (sal_uInt16 i = 0; i < nCount; ++i)
1075 {
1076 sal_uInt16 nId = i + 1;
1077 // skip "TYPE"
1078 if (!mpImpl->mxView->TypeColumnVisible() && nId != COLUMN_TITLE)
1079 ++nId;
1080
1081 sRet += OUString::number( nId )
1082 + ";"
1083 + OUString::number(pView->get_column_width(i))
1084 + ";";
1085 }
1086
1087 return comphelper::string::stripEnd(sRet, ';');
1088 }
1089
1090 ::std::vector< SvtContentEntry > SvtFileView::GetContent()
1091 {
1092 ::std::vector< SvtContentEntry > aContent;
1093
1094 for(auto const& elem : mpImpl->maContent)
1095 {
1096 SvtContentEntry aEntry( elem->maTargetURL, elem->mbIsFolder );
1097 aContent.push_back( aEntry );
1098 }
1099
1100 return aContent;
1101 }
1102
1103 void SvtFileView::SetConfigString(std::u16string_view rCfgStr)
1104 {
1105 sal_Int32 nIdx = 0;
1106 sal_uInt16 nSortColumn = static_cast<sal_uInt16>(o3tl::toInt32(o3tl::getToken(rCfgStr, 0, ';', nIdx )));
1107 bool bAscending = static_cast<bool>(static_cast<sal_uInt16>(o3tl::toInt32(o3tl::getToken(rCfgStr, 0, ';', nIdx ))));
1108
1109 std::vector<int> aWidths(mpImpl->mxView->TypeColumnVisible() ? 4 : 3, -1);
1110
1111 while ( nIdx != -1 )
1112 {
1113 sal_uInt16 nItemId = static_cast<sal_uInt16>(o3tl::toInt32(o3tl::getToken(rCfgStr, 0, ';', nIdx )));
1114
1115 int nWidth = o3tl::toInt32(o3tl::getToken(rCfgStr, 0, ';', nIdx ));
1116
1117 // skip "TYPE"
1118 if (!mpImpl->mxView->TypeColumnVisible() && nItemId != COLUMN_TITLE)
1119 --nItemId;
1120 int nColumn = nItemId - 1;
1121
1122 if (nColumn >= 0 && o3tl::make_unsigned(nColumn) < aWidths.size())
1123 aWidths[nColumn] = nWidth;
1124 }
1125
1126 weld::TreeView* pView = mpImpl->mxView->getWidget();
1127 pView->set_column_fixed_widths(aWidths);
1128 if (mpImpl->mnSortColumn != nSortColumn)
1129 pView->set_sort_indicator(TRISTATE_INDET, mpImpl->GetSortColumn());
1130 mpImpl->Resort_Impl(nSortColumn, bAscending);
1131 }
1132
1133 SvtFileView_Impl::SvtFileView_Impl(SvtFileView* pAntiImpl, weld::Window* pTopLevel,
1134 std::unique_ptr<weld::TreeView> xTreeView,
1135 std::unique_ptr<weld::IconView> xIconView,
1136 Reference < XCommandEnvironment > const & xEnv,
1137 FileViewFlags nFlags, bool bOnlyFolder)
1138 : m_pAntiImpl ( pAntiImpl )
1139 , m_eAsyncActionResult ( ::svt::EnumerationResult::ERROR )
1140 , m_bRunningAsyncAction ( false )
1141 , m_bAsyncActionCancelled ( false )
1142 , m_pTopLevel ( pTopLevel )
1143 , mxView(new ViewTabListBox_Impl(std::move(xTreeView), pTopLevel, this, nFlags))
1144 , mxIconView(std::move(xIconView))
1145 , mnSortColumn ( COLUMN_TITLE )
1146 , mbAscending ( true )
1147 , mbOnlyFolder ( bOnlyFolder )
1148 , mnSuspendSelectCallback ( 0 )
1149 , mbIsFirstResort ( true )
1150 , aIntlWrapper ( Application::GetSettings().GetLanguageTag() )
1151 , maFolderImage (RID_BMP_FOLDER)
1152 , mxCmdEnv ( xEnv )
1153 {
1154 weld::TreeView* pWidget = mxView->getWidget();
1155
1156 // set the width to something small so it's the parent that decides the final
1157 // width
1158 Size aSize(42, pWidget->get_height_rows(7));
1159 pWidget->set_size_request(aSize.Width(), aSize.Height());
1160 mxIconView->set_size_request(aSize.Width(), aSize.Height());
1161 }
1162
1163 SvtFileView_Impl::~SvtFileView_Impl()
1164 {
1165 Clear();
1166 }
1167
1168 void SvtFileView_Impl::Clear()
1169 {
1170 ::osl::MutexGuard aGuard( maMutex );
1171
1172 maContent.clear();
1173 }
1174
1175 FileViewResult SvtFileView_Impl::GetFolderContent_Impl(
1176 std::u16string_view rFolder,
1177 const FileViewAsyncAction* pAsyncDescriptor,
1178 const css::uno::Sequence< OUString >& rDenyList )
1179 {
1180 ::osl::ClearableMutexGuard aGuard( maMutex );
1181 INetURLObject aFolderObj( rFolder );
1182 DBG_ASSERT( aFolderObj.GetProtocol() != INetProtocol::NotValid, "Invalid URL!" );
1183
1184 FolderDescriptor aFolder( aFolderObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
1185
1186 aGuard.clear();
1187 return GetFolderContent_Impl( aFolder, pAsyncDescriptor, rDenyList );
1188 }
1189
1190 FileViewResult SvtFileView_Impl::GetFolderContent_Impl(
1191 const FolderDescriptor& _rFolder,
1192 const FileViewAsyncAction* pAsyncDescriptor,
1193 const css::uno::Sequence< OUString >& rDenyList )
1194 {
1195 DBG_TESTSOLARMUTEX();
1196 ::osl::ClearableMutexGuard aGuard( maMutex );
1197
1198 OSL_ENSURE( !m_xContentEnumerator.is(), "SvtFileView_Impl::GetFolderContent_Impl: still running another enumeration!" );
1199 m_xContentEnumerator.set(new ::svt::FileViewContentEnumerator(
1200 mxView->GetCommandEnvironment(), maContent, maMutex));
1201 // TODO: should we cache and re-use this thread?
1202
1203 if ( !pAsyncDescriptor )
1204 {
1205 ::svt::EnumerationResult eResult = m_xContentEnumerator->enumerateFolderContentSync( _rFolder, rDenyList );
1206 if ( ::svt::EnumerationResult::SUCCESS == eResult )
1207 {
1208 implEnumerationSuccess();
1209 m_xContentEnumerator.clear();
1210 return eSuccess;
1211 }
1212 m_xContentEnumerator.clear();
1213 return eFailure;
1214 }
1215
1216 m_bRunningAsyncAction = true;
1217 m_bAsyncActionCancelled = false;
1218 m_eAsyncActionResult = ::svt::EnumerationResult::ERROR;
1219 m_aAsyncActionFinished.reset();
1220
1221 // don't (yet) set m_aCurrentAsyncActionHandler to pTimeout->aFinishHandler.
1222 // By definition, this handler *only* gets called when the result cannot be obtained
1223 // during the minimum wait time, so it is only set below, when needed.
1224 m_aCurrentAsyncActionHandler = Link<void*,void>();
1225
1226 // minimum time to wait
1227 TimeValue aTimeout;
1228 sal_Int32 nMinTimeout = pAsyncDescriptor->nMinTimeout;
1229 OSL_ENSURE( nMinTimeout > 0, "SvtFileView_Impl::GetFolderContent_Impl: invalid minimum timeout!" );
1230 if ( nMinTimeout <= 0 )
1231 nMinTimeout = sal_Int32( 1000 );
1232 aTimeout.Seconds = nMinTimeout / 1000;
1233 aTimeout.Nanosec = ( nMinTimeout % 1000 ) * 1000000;
1234
1235 m_xContentEnumerator->enumerateFolderContent( _rFolder, this );
1236
1237 // wait until the enumeration is finished
1238 // for this, release our own mutex (which is used by the enumerator thread)
1239 aGuard.clear();
1240
1241 ::osl::Condition::Result eResult = ::osl::Condition::result_ok;
1242 {
1243 // also release the SolarMutex. Not all code which is needed during the enumeration
1244 // is Solar-Thread-Safe, in particular there is some code which needs to access
1245 // string resources (and our resource system relies on the SolarMutex :()
1246 SolarMutexReleaser aSolarRelease;
1247
1248 // now wait. Note that if we didn't get a pAsyncDescriptor, then this is an infinite wait.
1249 eResult = m_aAsyncActionFinished.wait( &aTimeout );
1250 }
1251
1252 ::osl::MutexGuard aGuard2( maMutex );
1253 if ( ::osl::Condition::result_timeout == eResult )
1254 {
1255 // maximum time to wait
1256 OSL_ENSURE(!m_xCancelAsyncTimer,
1257 "SvtFileView_Impl::GetFolderContent_Impl: there's still a previous timer!");
1258 m_xCancelAsyncTimer.set(new CallbackTimer(this));
1259 sal_Int32 nMaxTimeout = pAsyncDescriptor->nMaxTimeout;
1260 OSL_ENSURE( nMaxTimeout > nMinTimeout,
1261 "SvtFileView_Impl::GetFolderContent_Impl: invalid maximum timeout!" );
1262 if ( nMaxTimeout <= nMinTimeout )
1263 nMaxTimeout = nMinTimeout + 5000;
1264 m_xCancelAsyncTimer->setRemainingTime( salhelper::TTimeValue( nMaxTimeout - nMinTimeout ) );
1265 // we already waited for nMinTimeout milliseconds, so take this into account
1266 m_xCancelAsyncTimer->start();
1267
1268 m_aCurrentAsyncActionHandler = pAsyncDescriptor->aFinishHandler;
1269 DBG_ASSERT( m_aCurrentAsyncActionHandler.IsSet(), "SvtFileView_Impl::GetFolderContent_Impl: nobody interested when it's finished?" );
1270 maEntries.clear();
1271 mxView->clear();
1272 mxIconView->clear();
1273 return eStillRunning;
1274 }
1275
1276 m_bRunningAsyncAction = false;
1277 switch ( m_eAsyncActionResult )
1278 {
1279 case ::svt::EnumerationResult::SUCCESS:
1280 return eSuccess;
1281
1282 case ::svt::EnumerationResult::ERROR:
1283 return eFailure;
1284 }
1285
1286 SAL_WARN( "svtools.contnr", "SvtFileView_Impl::GetFolderContent_Impl: unreachable!" );
1287 return eFailure;
1288 }
1289
1290 void SvtFileView_Impl::FilterFolderContent_Impl( std::u16string_view rFilter )
1291 {
1292 if ( rFilter.empty() || ( rFilter == ALL_FILES_FILTER ) )
1293 // when replacing names, there is always something to filter (no view of ".nametranslation.table")
1294 return;
1295
1296 ::osl::MutexGuard aGuard( maMutex );
1297
1298 if ( maContent.empty() )
1299 return;
1300
1301 // collect the filter tokens
1302 ::std::vector< WildCard > aFilters;
1303 FilterMatch::createWildCardFilterList(rFilter,aFilters);
1304
1305
1306 // do the filtering
1307 std::erase_if(maContent,
1308 [&aFilters](const std::unique_ptr<SortingData_Impl>& rxContent) {
1309 if (rxContent->mbIsFolder)
1310 return false;
1311 // normalize the content title (we always match case-insensitive)
1312 // 91872 - 11.09.2001 - frank.schoenheit@sun.com
1313 OUString sCompareString = rxContent->GetFileName(); // filter works on file name, not on title!
1314 return std::none_of(aFilters.begin(), aFilters.end(), FilterMatch(sCompareString));
1315 });
1316 }
1317
1318 IMPL_LINK_NOARG(SvtFileView_Impl, ChangedHdl, weld::TreeView&, void)
1319 {
1320 if (!mnSuspendSelectCallback)
1321 m_aSelectHandler.Call(m_pAntiImpl);
1322 }
1323
1324 IMPL_LINK_NOARG(SvtFileView_Impl, SelectionChangedHdl, weld::IconView&, void)
1325 {
1326 if (!mnSuspendSelectCallback)
1327 m_aSelectHandler.Call(m_pAntiImpl);
1328 }
1329
1330 void SvtFileView_Impl::SetSelectHandler(const Link<SvtFileView*,void>& rHdl)
1331 {
1332 m_aSelectHandler = rHdl;
1333
1334 mxView->connect_changed(LINK(this, SvtFileView_Impl, ChangedHdl));
1335 mxIconView->connect_selection_changed(LINK(this, SvtFileView_Impl, SelectionChangedHdl));
1336 }
1337
1338 IMPL_LINK_NOARG(SvtFileView_Impl, RowActivatedHdl, weld::TreeView&, bool)
1339 {
1340 return maDoubleClickHandler.Call(m_pAntiImpl);
1341 }
1342
1343 IMPL_LINK_NOARG(SvtFileView_Impl, ItemActivatedHdl, weld::IconView&, bool)
1344 {
1345 return maDoubleClickHandler.Call(m_pAntiImpl);
1346 }
1347
1348 void SvtFileView_Impl::SetDoubleClickHandler(const Link<SvtFileView*,bool>& rHdl)
1349 {
1350 maDoubleClickHandler = rHdl;
1351
1352 mxView->connect_row_activated(LINK(this, SvtFileView_Impl, RowActivatedHdl));
1353 mxIconView->connect_item_activated(LINK(this, SvtFileView_Impl, ItemActivatedHdl));
1354 }
1355
1356 void SvtFileView_Impl::OpenFolder_Impl()
1357 {
1358 ::osl::MutexGuard aGuard( maMutex );
1359
1360 mxView->freeze();
1361 mxIconView->freeze();
1362 maEntries.clear();
1363 mxView->clear();
1364 mxIconView->clear();
1365
1366 for (auto const& elem : maContent)
1367 {
1368 if (mbOnlyFolder && !elem->mbIsFolder)
1369 continue;
1370
1371 // insert entry and set user data
1372 maEntries.emplace_back(std::make_unique<SvtContentEntry>(elem->maTargetURL, elem->mbIsFolder));
1373 OUString sId(weld::toId(maEntries.back().get()));
1374 mxView->append(sId, elem->maDisplayName, elem->maType, elem->maDisplaySize, elem->maDisplayDate, elem->maImage);
1375 mxIconView->append(sId, elem->maDisplayName, elem->maImage);
1376 }
1377
1378 ++mnSuspendSelectCallback;
1379 mxView->thaw();
1380
1381 //set sort indicator
1382 weld::TreeView* pView = mxView->getWidget();
1383 pView->set_sort_indicator(mbAscending ? TRISTATE_TRUE : TRISTATE_FALSE, GetSortColumn());
1384
1385 mxIconView->thaw();
1386 --mnSuspendSelectCallback;
1387
1388 ResetCursor();
1389 }
1390
1391 void SvtFileView_Impl::ResetCursor()
1392 {
1393 if (mxView->get_visible())
1394 {
1395 std::unique_ptr<weld::TreeIter> xFirst = mxView->make_iterator();
1396 if (mxView->get_iter_first(*xFirst))
1397 {
1398 // set cursor to the first entry
1399 mxView->set_cursor(*xFirst);
1400 }
1401 // deselect
1402 mxView->unselect_all();
1403 }
1404 else
1405 {
1406 std::unique_ptr<weld::TreeIter> xFirst = mxIconView->make_iterator();
1407 if (mxIconView->get_iter_first(*xFirst))
1408 {
1409 // set cursor to the first entry
1410 mxIconView->set_cursor(*xFirst);
1411 }
1412 // deselect
1413 mxIconView->unselect_all();
1414 }
1415 }
1416
1417 void SvtFileView_Impl::CancelRunningAsyncAction()
1418 {
1419 DBG_TESTSOLARMUTEX();
1420 ::osl::MutexGuard aGuard( maMutex );
1421 if ( !m_xContentEnumerator.is() )
1422 return;
1423
1424 m_bAsyncActionCancelled = true;
1425 m_xContentEnumerator->cancel();
1426 m_bRunningAsyncAction = false;
1427
1428 m_xContentEnumerator.clear();
1429 if ( m_xCancelAsyncTimer.is() && m_xCancelAsyncTimer->isTicking() )
1430 m_xCancelAsyncTimer->stop();
1431 m_xCancelAsyncTimer.clear();
1432 }
1433
1434
1435 void SvtFileView_Impl::onTimeout()
1436 {
1437 SolarMutexGuard aSolarGuard;
1438 ::osl::MutexGuard aGuard( maMutex );
1439 if ( !m_bRunningAsyncAction )
1440 // there might have been a race condition while we waited for the mutex
1441 return;
1442
1443 CancelRunningAsyncAction();
1444
1445 if ( m_aCurrentAsyncActionHandler.IsSet() )
1446 {
1447 Application::PostUserEvent( m_aCurrentAsyncActionHandler, reinterpret_cast< void* >( eTimeout ) );
1448 m_aCurrentAsyncActionHandler = Link<void*,void>();
1449 }
1450 }
1451
1452
1453 void SvtFileView_Impl::enumerationDone( ::svt::EnumerationResult eResult )
1454 {
1455 SolarMutexGuard aSolarGuard;
1456 ::osl::MutexGuard aGuard( maMutex );
1457
1458 m_xContentEnumerator.clear();
1459 if ( m_xCancelAsyncTimer.is() && m_xCancelAsyncTimer->isTicking() )
1460 m_xCancelAsyncTimer->stop();
1461 m_xCancelAsyncTimer.clear();
1462
1463 if ( m_bAsyncActionCancelled )
1464 // this is to prevent race conditions
1465 return;
1466
1467 m_eAsyncActionResult = eResult;
1468 m_bRunningAsyncAction = false;
1469
1470 m_aAsyncActionFinished.set();
1471
1472 if ( svt::EnumerationResult::SUCCESS == eResult )
1473 implEnumerationSuccess();
1474
1475 if ( m_aCurrentAsyncActionHandler.IsSet() )
1476 {
1477 Application::PostUserEvent( m_aCurrentAsyncActionHandler, reinterpret_cast< void* >( m_eAsyncActionResult ) );
1478 m_aCurrentAsyncActionHandler = Link<void*,void>();
1479 }
1480 }
1481
1482
1483 void SvtFileView_Impl::implEnumerationSuccess()
1484 {
1485 FilterFolderContent_Impl( maCurrentFilter );
1486 SortFolderContent_Impl();
1487 CreateDisplayText_Impl();
1488 OpenFolder_Impl();
1489 maOpenDoneLink.Call( m_pAntiImpl );
1490 }
1491
1492 OUString SvtFileView_Impl::ReplaceTabWithString(const OUString& rValue)
1493 {
1494 return rValue.replaceAll(u"\t", u"%09");
1495 }
1496
1497 void SvtFileView_Impl::CreateDisplayText_Impl()
1498 {
1499 ::osl::MutexGuard aGuard( maMutex );
1500
1501 for (auto const& elem : maContent)
1502 {
1503 // title, type, size, date
1504 elem->maDisplayName = ReplaceTabWithString(elem->GetTitle());
1505 // folders don't have a size
1506 if ( ! elem->mbIsFolder )
1507 elem->maDisplaySize = CreateExactSizeText( elem->maSize );
1508 // set the date, but volumes have no date
1509 if ( ! elem->mbIsFolder || ! elem->mbIsVolume )
1510 {
1511 SvtSysLocale aSysLocale;
1512 const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
1513 elem->maDisplayDate = rLocaleData.getDate( elem->maModDate )
1514 + ", "
1515 + rLocaleData.getTime( elem->maModDate, false );
1516 }
1517
1518 // detect image
1519 if ( elem->mbIsFolder )
1520 {
1521 ::svtools::VolumeInfo aVolInfo( elem->mbIsVolume, elem->mbIsRemote,
1522 elem->mbIsRemoveable, elem->mbIsFloppy,
1523 elem->mbIsCompactDisc );
1524 elem->maImage = SvFileInformationManager::GetFolderImageId(aVolInfo);
1525 }
1526 else
1527 elem->maImage = SvFileInformationManager::GetFileImageId(INetURLObject(elem->maTargetURL));
1528 }
1529 }
1530
1531 void SvtFileView_Impl::Resort_Impl( sal_Int16 nColumn, bool bAscending )
1532 {
1533 // TODO: IconView ()
1534 ::osl::MutexGuard aGuard( maMutex );
1535
1536 if ( ( nColumn == mnSortColumn ) &&
1537 ( bAscending == mbAscending ) )
1538 return;
1539
1540 // reset the quick search index
1541 mxView->ResetQuickSearch_Impl( nullptr );
1542
1543 std::unique_ptr<weld::TreeIter> xEntry(mxView->make_iterator());
1544 bool bEntry = mxView->get_cursor(xEntry.get());
1545
1546 OUString aEntryURL;
1547 if (bEntry && !mxView->get_id(*xEntry).isEmpty())
1548 aEntryURL = weld::fromId<SvtContentEntry*>(mxView->get_id(*xEntry))->maURL;
1549
1550 mnSortColumn = nColumn;
1551 mbAscending = bAscending;
1552
1553 SortFolderContent_Impl();
1554 OpenFolder_Impl();
1555
1556 if ( !mbIsFirstResort )
1557 {
1558 int nPos = GetEntryPos( aEntryURL );
1559 if (nPos != -1 && nPos < mxView->n_children())
1560 {
1561 ++mnSuspendSelectCallback; // #i15668#
1562 mxView->set_cursor(nPos);
1563 --mnSuspendSelectCallback;
1564 }
1565 }
1566 else
1567 mbIsFirstResort = false;
1568 }
1569
1570 static bool gbAscending = true;
1571 static sal_Int16 gnColumn = COLUMN_TITLE;
1572 static const CollatorWrapper* pCollatorWrapper = nullptr;
1573
1574 /* this function returns true, if aOne is less than aTwo
1575 */
1576 static bool CompareSortingData_Impl( std::unique_ptr<SortingData_Impl> const & aOne, std::unique_ptr<SortingData_Impl> const & aTwo )
1577 {
1578 DBG_ASSERT( pCollatorWrapper, "*CompareSortingData_Impl(): Can't work this way!" );
1579
1580 sal_Int32 nComp;
1581 bool bRet = false;
1582 bool bEqual = false;
1583
1584 if ( aOne->mbIsFolder != aTwo->mbIsFolder )
1585 {
1586 bRet = aOne->mbIsFolder;
1587
1588 // !!! pb: #100376# folder always on top
1589 if ( !gbAscending )
1590 bRet = !bRet;
1591 }
1592 else
1593 {
1594 switch ( gnColumn )
1595 {
1596 case COLUMN_TITLE:
1597 // compare case insensitive first
1598 nComp = pCollatorWrapper->compareString( aOne->GetLowerTitle(), aTwo->GetLowerTitle() );
1599
1600 if ( nComp == 0 )
1601 nComp = pCollatorWrapper->compareString( aOne->GetTitle(), aTwo->GetTitle() );
1602
1603 if ( nComp < 0 )
1604 bRet = true;
1605 else if ( nComp > 0 )
1606 bRet = false;
1607 else
1608 bEqual = true;
1609 break;
1610 case COLUMN_TYPE:
1611 nComp = pCollatorWrapper->compareString( aOne->maType, aTwo->maType );
1612 if ( nComp < 0 )
1613 bRet = true;
1614 else if ( nComp > 0 )
1615 bRet = false;
1616 else
1617 bEqual = true;
1618 break;
1619 case COLUMN_SIZE:
1620 if ( aOne->maSize < aTwo->maSize )
1621 bRet = true;
1622 else if ( aOne->maSize > aTwo->maSize )
1623 bRet = false;
1624 else
1625 bEqual = true;
1626 break;
1627 case COLUMN_DATE:
1628 if ( aOne->maModDate < aTwo->maModDate )
1629 bRet = true;
1630 else if ( aOne->maModDate > aTwo->maModDate )
1631 bRet = false;
1632 else
1633 bEqual = true;
1634 break;
1635 default:
1636 SAL_INFO( "svtools.contnr", "CompareSortingData_Impl: Compare unknown type!" );
1637 bRet = false;
1638 }
1639 }
1640
1641 // when the two elements are equal, we must not return sal_True (which would
1642 // happen if we just return ! ( a < b ) when not sorting ascending )
1643 if ( bEqual )
1644 return false;
1645
1646 return gbAscending ? bRet : !bRet;
1647 }
1648
1649
1650 void SvtFileView_Impl::SortFolderContent_Impl()
1651 {
1652 ::osl::MutexGuard aGuard( maMutex );
1653
1654 if ( maContent.size() > 1 )
1655 {
1656 gbAscending = mbAscending;
1657 gnColumn = mnSortColumn;
1658 pCollatorWrapper = aIntlWrapper.getCaseCollator();
1659
1660 std::stable_sort( maContent.begin(), maContent.end(), CompareSortingData_Impl );
1661
1662 pCollatorWrapper = nullptr;
1663 }
1664 }
1665
1666
1667 void SvtFileView_Impl::EntryRemoved( std::u16string_view rURL )
1668 {
1669 ::osl::MutexGuard aGuard( maMutex );
1670
1671 maContent.erase(std::find_if(maContent.begin(), maContent.end(),
1672 [&](const std::unique_ptr<SortingData_Impl> & data) { return data->maTargetURL == rURL; }));
1673 }
1674
1675
1676 void SvtFileView_Impl::EntryRenamed( OUString& rURL,
1677 const OUString& rTitle )
1678 {
1679 ::osl::MutexGuard aGuard( maMutex );
1680
1681 auto aFoundElem = std::find_if(maContent.begin(), maContent.end(),
1682 [&](const std::unique_ptr<SortingData_Impl> & data) { return data->maTargetURL == rURL; });
1683 if (aFoundElem != maContent.end())
1684 {
1685 (*aFoundElem)->SetNewTitle( rTitle );
1686 (*aFoundElem)->maDisplayName = ReplaceTabWithString(rTitle);
1687
1688 INetURLObject aURLObj( rURL );
1689 aURLObj.setName( rTitle, INetURLObject::EncodeMechanism::All );
1690
1691 rURL = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
1692
1693 (*aFoundElem)->maTargetURL = rURL;
1694 }
1695 }
1696
1697 const SortingData_Impl& SvtFileView_Impl::FolderInserted( const OUString& rURL, const OUString& rTitle )
1698 {
1699 ::osl::MutexGuard aGuard( maMutex );
1700
1701 std::unique_ptr<SortingData_Impl> pData(new SortingData_Impl);
1702
1703 pData->SetNewTitle( rTitle );
1704 pData->maSize = 0;
1705 pData->mbIsFolder = true;
1706 pData->maTargetURL = rURL;
1707
1708 ::svtools::VolumeInfo aVolInfo;
1709 pData->maType = SvFileInformationManager::GetFolderDescription( aVolInfo );
1710 pData->maImage = SvFileInformationManager::GetFolderImageId( aVolInfo );
1711
1712 // title, type, size, date
1713 pData->maDisplayName = ReplaceTabWithString(pData->GetTitle());
1714 // set the date
1715 SvtSysLocale aSysLocale;
1716 const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
1717 pData->maDisplayDate = rLocaleData.getDate( pData->maModDate )
1718 + ", "
1719 + rLocaleData.getTime( pData->maModDate );
1720
1721 maContent.push_back( std::move(pData) );
1722
1723 return *maContent.back();
1724 }
1725
1726 int SvtFileView_Impl::GetEntryPos(std::u16string_view rURL)
1727 {
1728 ::osl::MutexGuard aGuard( maMutex );
1729
1730 auto aFoundElem = std::find_if(maContent.begin(), maContent.end(),
1731 [&](const std::unique_ptr<SortingData_Impl> & data) { return data->maTargetURL == rURL; });
1732 return aFoundElem != maContent.end() ? std::distance(maContent.begin(), aFoundElem) : -1;
1733 }
1734
1735 void SvtFileView_Impl::SetViewMode( FileViewMode eMode )
1736 {
1737 switch ( eMode )
1738 {
1739 case eDetailedList:
1740 mxView->show();
1741 mxIconView->hide();
1742 break;
1743
1744 case eIcon:
1745 mxView->hide();
1746 mxIconView->show();
1747 break;
1748
1749 default:
1750 mxView->show();
1751 mxIconView->hide();
1752 };
1753 }
1754
1755 bool SvtFileView_Impl::SearchNextEntry( sal_uInt32& nIndex, std::u16string_view rTitle, bool bWrapAround )
1756 {
1757 ::osl::MutexGuard aGuard( maMutex );
1758
1759 sal_uInt32 nEnd = maContent.size();
1760 sal_uInt32 nStart = nIndex;
1761 while ( nIndex < nEnd )
1762 {
1763 SortingData_Impl* pData = maContent[ nIndex ].get();
1764 if ( pData->GetLowerTitle().startsWith( rTitle ) )
1765 return true;
1766 ++nIndex;
1767 }
1768
1769 if ( bWrapAround )
1770 {
1771 nIndex = 0;
1772 while ( nIndex < nEnd && nIndex <= nStart )
1773 {
1774 SortingData_Impl* pData = maContent[ nIndex ].get();
1775 if ( pData->GetLowerTitle().startsWith( rTitle ) )
1776 return true;
1777 ++nIndex;
1778 }
1779 }
1780
1781 return false;
1782 }
1783
1784 namespace {
1785 void SAL_CALL CallbackTimer::onShot()
1786 {
1787 OSL_ENSURE( m_pTimeoutHandler, "CallbackTimer::onShot: nobody interested in?" );
1788 SvtFileView_Impl* pHandler( m_pTimeoutHandler );
1789 if ( pHandler )
1790 pHandler->onTimeout();
1791 }
1792 }
1793
1794 void SvtFileView::selected_foreach(const std::function<bool(weld::TreeIter&)>& func)
1795 {
1796 if (mpImpl->mxView->get_visible())
1797 mpImpl->mxView->selected_foreach(func);
1798 else
1799 mpImpl->mxIconView->selected_foreach(func);
1800 }
1801
1802 weld::Widget* SvtFileView::identifier() const
1803 {
1804 return mpImpl->mxView->getWidget();
1805 }
1806
1807 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE