svx/source/dialog/docrecovery.cxx

   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 <svx/dialmgr.hxx>
  21 #include <svx/strings.hrc>
  22 #include <bitmaps.hlst>
  23 #include <docrecovery.hxx>
  24
  25 #include <comphelper/propertyvalue.hxx>
  26 #include <comphelper/sequenceashashmap.hxx>
  27 #include <comphelper/string.hxx>
  28 #include <svtools/imagemgr.hxx>
  29 #include <sfx2/filedlghelper.hxx>
  30 #include <tools/urlobj.hxx>
  31 #include <utility>
  32 #include <vcl/weld.hxx>
  33 #include <vcl/svapp.hxx>
  34
  35 #include <com/sun/star/util/URL.hpp>
  36 #include <com/sun/star/util/XURLTransformer.hpp>
  37 #include <com/sun/star/frame/theAutoRecovery.hpp>
  38 #include <com/sun/star/ui/dialogs/XFolderPicker2.hpp>
  39 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  40 #include <com/sun/star/util/URLTransformer.hpp>
  41 #include <osl/diagnose.h>
  42 #include <osl/file.hxx>
  43 #include <unotools/pathoptions.hxx>
  44
  45 namespace svx::DocRecovery
  46 {
  47
  48 using namespace ::osl;
  49
  50 #define COLUMN_STANDARDIMAGE -1
  51 #define COLUMN_DISPLAYNAME 0
  52 #define COLUMN_STATUSIMAGE 1
  53 #define COLUMN_STATUSTEXT 2
  54
  55 RecoveryCore::RecoveryCore(css::uno::Reference< css::uno::XComponentContext > xContext,
  56                                  bool                                            bUsedForSaving)
  57     : m_xContext        (std::move( xContext    ))
  58     , m_pListener       ( nullptr            )
  59     , m_bListenForSaving(bUsedForSaving)
  60 {
  61     impl_startListening();
  62 }
  63
  64
  65 RecoveryCore::~RecoveryCore()
  66 {
  67     impl_stopListening();
  68 }
  69
  70
  71 const css::uno::Reference< css::uno::XComponentContext >& RecoveryCore::getComponentContext() const
  72 {
  73     return m_xContext;
  74 }
  75
  76
  77 TURLList& RecoveryCore::getURLListAccess()
  78 {
  79     return m_lURLs;
  80 }
  81
  82
  83 bool RecoveryCore::isBrokenTempEntry(const TURLInfo& rInfo)
  84 {
  85     if (rInfo.TempURL.isEmpty())
  86         return false;
  87
  88     // Note: If the original files was recovery ... but a temp file
  89     // exists ... an error inside the temp file exists!
  90     if (
  91         (rInfo.RecoveryState != E_RECOVERY_FAILED            ) &&
  92         (rInfo.RecoveryState != E_ORIGINAL_DOCUMENT_RECOVERED)
  93        )
  94        return false;
  95
  96     return true;
  97 }
  98
  99
 100 void RecoveryCore::saveBrokenTempEntries(const OUString& rPath)
 101 {
 102     if (rPath.isEmpty())
 103         return;
 104
 105     if (!m_xRealCore.is())
 106         return;
 107
 108     // prepare all needed parameters for the following dispatch() request.
 109     css::util::URL aCopyURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_BACKUP);
 110     css::uno::Sequence< css::beans::PropertyValue > lCopyArgs(3);
 111     auto plCopyArgs = lCopyArgs.getArray();
 112     plCopyArgs[0].Name    = PROP_DISPATCHASYNCHRON;
 113     plCopyArgs[0].Value <<= false;
 114     plCopyArgs[1].Name    = PROP_SAVEPATH;
 115     plCopyArgs[1].Value <<= rPath;
 116     plCopyArgs[2].Name    = PROP_ENTRYID;
 117     // lCopyArgs[2].Value will be changed during next loop...
 118
 119     // work on a copied list only...
 120     // Reason: We will get notifications from the core for every
 121     // changed or removed element. And that will change our m_lURLs list.
 122     // That's not a good idea, if we use a stl iterator inbetween .-)
 123     TURLList lURLs = m_lURLs;
 124     for (const TURLInfo& rInfo : lURLs)
 125     {
 126         if (!RecoveryCore::isBrokenTempEntry(rInfo))
 127             continue;
 128
 129         plCopyArgs[2].Value <<= rInfo.ID;
 130         m_xRealCore->dispatch(aCopyURL, lCopyArgs);
 131     }
 132 }
 133
 134
 135 void RecoveryCore::saveAllTempEntries(const OUString& rPath)
 136 {
 137     if (rPath.isEmpty())
 138         return;
 139
 140     if (!m_xRealCore.is())
 141         return;
 142
 143     // prepare all needed parameters for the following dispatch() request.
 144     css::util::URL aCopyURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_BACKUP);
 145     css::uno::Sequence< css::beans::PropertyValue > lCopyArgs(3);
 146     auto plCopyArgs = lCopyArgs.getArray();
 147     plCopyArgs[0].Name    = PROP_DISPATCHASYNCHRON;
 148     plCopyArgs[0].Value <<= false;
 149     plCopyArgs[1].Name    = PROP_SAVEPATH;
 150     plCopyArgs[1].Value <<= rPath;
 151     plCopyArgs[2].Name    = PROP_ENTRYID;
 152     // lCopyArgs[2].Value will be changed during next loop ...
 153
 154     // work on a copied list only ...
 155     // Reason: We will get notifications from the core for every
 156     // changed or removed element. And that will change our m_lURLs list.
 157     // That's not a good idea, if we use a stl iterator inbetween .-)
 158     TURLList lURLs = m_lURLs;
 159     for (const TURLInfo& rInfo : lURLs)
 160     {
 161         if (rInfo.TempURL.isEmpty())
 162             continue;
 163
 164         plCopyArgs[2].Value <<= rInfo.ID;
 165         m_xRealCore->dispatch(aCopyURL, lCopyArgs);
 166     }
 167 }
 168
 169
 170 void RecoveryCore::forgetBrokenTempEntries()
 171 {
 172     if (!m_xRealCore.is())
 173         return;
 174
 175     css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP);
 176     css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2);
 177     auto plRemoveArgs = lRemoveArgs.getArray();
 178     plRemoveArgs[0].Name    = PROP_DISPATCHASYNCHRON;
 179     plRemoveArgs[0].Value <<= false;
 180     plRemoveArgs[1].Name    = PROP_ENTRYID;
 181     // lRemoveArgs[1].Value will be changed during next loop ...
 182
 183     // work on a copied list only ...
 184     // Reason: We will get notifications from the core for every
 185     // changed or removed element. And that will change our m_lURLs list.
 186     // That's not a good idea, if we use a stl iterator inbetween .-)
 187     TURLList lURLs = m_lURLs;
 188     for (const TURLInfo& rInfo : lURLs)
 189     {
 190         if (!RecoveryCore::isBrokenTempEntry(rInfo))
 191             continue;
 192
 193         plRemoveArgs[1].Value <<= rInfo.ID;
 194         m_xRealCore->dispatch(aRemoveURL, lRemoveArgs);
 195     }
 196 }
 197
 198 // should only be called with valid m_xRealCore
 199 void RecoveryCore::forgetAllRecoveryEntriesMarkedForDiscard()
 200 {
 201     assert(m_xRealCore);
 202
 203     // potential to move in a separate function
 204     css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP);
 205     css::uno::Sequence<css::beans::PropertyValue> lRemoveArgs(2);
 206     auto plRemoveArgs = lRemoveArgs.getArray();
 207     plRemoveArgs[0].Name = PROP_DISPATCHASYNCHRON;
 208     plRemoveArgs[0].Value <<= false;
 209     plRemoveArgs[1].Name = PROP_ENTRYID;
 210
 211     // work on a copied list only ...
 212     // Reason: We will get notifications from the core for every
 213     // changed or removed element. And that will change our m_lURLs list.
 214     // That's not a good idea, if we use a stl iterator inbetween .-)
 215     TURLList lURLs = m_lURLs;
 216     for (const TURLInfo& rInfo : lURLs)
 217     {
 218         if (!rInfo.ShouldDiscard)
 219             continue;
 220
 221         plRemoveArgs[1].Value <<= rInfo.ID;
 222         m_xRealCore->dispatch(aRemoveURL, lRemoveArgs);
 223     }
 224 }
 225
 226 void RecoveryCore::forgetAllRecoveryEntries()
 227 {
 228     if (!m_xRealCore.is())
 229         return;
 230
 231     css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP);
 232     css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2);
 233     auto plRemoveArgs = lRemoveArgs.getArray();
 234     plRemoveArgs[0].Name    = PROP_DISPATCHASYNCHRON;
 235     plRemoveArgs[0].Value <<= false;
 236     plRemoveArgs[1].Name    = PROP_ENTRYID;
 237     // lRemoveArgs[1].Value will be changed during next loop ...
 238
 239     // work on a copied list only ...
 240     // Reason: We will get notifications from the core for every
 241     // changed or removed element. And that will change our m_lURLs list.
 242     // That's not a good idea, if we use a stl iterator inbetween .-)
 243     TURLList lURLs = m_lURLs;
 244     for (const TURLInfo& rInfo : lURLs)
 245     {
 246         plRemoveArgs[1].Value <<= rInfo.ID;
 247         m_xRealCore->dispatch(aRemoveURL, lRemoveArgs);
 248     }
 249 }
 250
 251
 252 void RecoveryCore::forgetBrokenRecoveryEntries()
 253 {
 254     if (!m_xRealCore.is())
 255         return;
 256
 257     css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP);
 258     css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2);
 259     auto plRemoveArgs = lRemoveArgs.getArray();
 260     plRemoveArgs[0].Name    = PROP_DISPATCHASYNCHRON;
 261     plRemoveArgs[0].Value <<= false;
 262     plRemoveArgs[1].Name    = PROP_ENTRYID;
 263     // lRemoveArgs[1].Value will be changed during next loop ...
 264
 265     // work on a copied list only ...
 266     // Reason: We will get notifications from the core for every
 267     // changed or removed element. And that will change our m_lURLs list.
 268     // That's not a good idea, if we use a stl iterator inbetween .-)
 269     TURLList lURLs = m_lURLs;
 270     for (const TURLInfo& rInfo : lURLs)
 271     {
 272         if (!RecoveryCore::isBrokenTempEntry(rInfo))
 273             continue;
 274
 275         plRemoveArgs[1].Value <<= rInfo.ID;
 276         m_xRealCore->dispatch(aRemoveURL, lRemoveArgs);
 277     }
 278 }
 279
 280
 281 void RecoveryCore::setProgressHandler(const css::uno::Reference< css::task::XStatusIndicator >& xProgress)
 282 {
 283     m_xProgress = xProgress;
 284 }
 285
 286
 287 void RecoveryCore::setUpdateListener(IRecoveryUpdateListener* pListener)
 288 {
 289     m_pListener = pListener;
 290 }
 291
 292
 293 void RecoveryCore::doEmergencySavePrepare()
 294 {
 295     if (!m_xRealCore.is())
 296         return;
 297
 298     css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_PREPARE_EMERGENCY_SAVE);
 299
 300     css::uno::Sequence< css::beans::PropertyValue > lArgs{ comphelper::makePropertyValue(
 301         PROP_DISPATCHASYNCHRON, false) };
 302
 303     m_xRealCore->dispatch(aURL, lArgs);
 304 }
 305
 306
 307 void RecoveryCore::doEmergencySave()
 308 {
 309     if (!m_xRealCore.is())
 310         return;
 311
 312     css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_EMERGENCY_SAVE);
 313
 314     css::uno::Sequence< css::beans::PropertyValue > lArgs{
 315         comphelper::makePropertyValue(PROP_STATUSINDICATOR, m_xProgress),
 316         comphelper::makePropertyValue(PROP_DISPATCHASYNCHRON, true)
 317     };
 318
 319     m_xRealCore->dispatch(aURL, lArgs);
 320 }
 321
 322
 323 void RecoveryCore::doRecovery()
 324 {
 325     if (!m_xRealCore.is())
 326         return;
 327
 328     forgetAllRecoveryEntriesMarkedForDiscard();
 329
 330     css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_RECOVERY);
 331
 332     css::uno::Sequence< css::beans::PropertyValue > lArgs{
 333         comphelper::makePropertyValue(PROP_STATUSINDICATOR, m_xProgress),
 334         comphelper::makePropertyValue(PROP_DISPATCHASYNCHRON, true)
 335     };
 336
 337     m_xRealCore->dispatch(aURL, lArgs);
 338 }
 339
 340
 341 ERecoveryState RecoveryCore::mapDocState2RecoverState(EDocStates eDocState)
 342 {
 343     // ???
 344     ERecoveryState eRecState = E_NOT_RECOVERED_YET;
 345
 346     /* Attention:
 347         Some of the following states can occur at the
 348         same time. So we have to check for the "worst case" first!
 349
 350         DAMAGED -> INCOMPLETE -> HANDLED
 351      */
 352
 353     // running ...
 354     if (
 355         (eDocState & EDocStates::TryLoadBackup  ) ||
 356         (eDocState & EDocStates::TryLoadOriginal)
 357        )
 358         eRecState = E_RECOVERY_IS_IN_PROGRESS;
 359     // red
 360     else if (eDocState & EDocStates::Damaged)
 361         eRecState = E_RECOVERY_FAILED;
 362     // yellow
 363     else if (eDocState & EDocStates::Incomplete)
 364         eRecState = E_ORIGINAL_DOCUMENT_RECOVERED;
 365     // green
 366     else if (eDocState & EDocStates::Succeeded)
 367         eRecState = E_SUCCESSFULLY_RECOVERED;
 368
 369     return eRecState;
 370 }
 371
 372
 373 void SAL_CALL RecoveryCore::statusChanged(const css::frame::FeatureStateEvent& aEvent)
 374 {
 375     // a) special notification about start/stop async dispatch!
 376     //    FeatureDescriptor = "start" || "stop"
 377     if (aEvent.FeatureDescriptor == RECOVERY_OPERATIONSTATE_START)
 378     {
 379         return;
 380     }
 381
 382     if (aEvent.FeatureDescriptor == RECOVERY_OPERATIONSTATE_STOP)
 383     {
 384         if (m_pListener)
 385             m_pListener->end();
 386         return;
 387     }
 388
 389     // b) normal notification about changed items
 390     //    FeatureDescriptor = "Update"
 391     //    State             = List of information [seq< NamedValue >]
 392     if (aEvent.FeatureDescriptor != RECOVERY_OPERATIONSTATE_UPDATE)
 393         return;
 394
 395     ::comphelper::SequenceAsHashMap lInfo(aEvent.State);
 396     TURLInfo                        aNew;
 397
 398     aNew.ID          = lInfo.getUnpackedValueOrDefault(STATEPROP_ID         , sal_Int32(0)     );
 399     aNew.DocState    = static_cast<EDocStates>(lInfo.getUnpackedValueOrDefault(STATEPROP_STATE      , sal_Int32(0)     ));
 400     aNew.OrgURL      = lInfo.getUnpackedValueOrDefault(STATEPROP_ORGURL     , OUString());
 401     aNew.TempURL     = lInfo.getUnpackedValueOrDefault(STATEPROP_TEMPURL    , OUString());
 402     aNew.FactoryURL  = lInfo.getUnpackedValueOrDefault(STATEPROP_FACTORYURL , OUString());
 403     aNew.TemplateURL = lInfo.getUnpackedValueOrDefault(STATEPROP_TEMPLATEURL, OUString());
 404     aNew.DisplayName = lInfo.getUnpackedValueOrDefault(STATEPROP_TITLE      , OUString());
 405     aNew.Module      = lInfo.getUnpackedValueOrDefault(STATEPROP_MODULE     , OUString());
 406
 407     if (aNew.OrgURL.isEmpty()) {
 408         // If there is no file URL, the window title is used for the display name.
 409         // Remove any unwanted elements such as " - LibreOffice Writer".
 410         sal_Int32 i = aNew.DisplayName.indexOf(" - ");
 411         if (i > 0)
 412             aNew.DisplayName = aNew.DisplayName.copy(0, i);
 413     } else {
 414         // If there is a file URL, parse out the filename part as the display name.
 415         INetURLObject aOrgURL(aNew.OrgURL);
 416         aNew.DisplayName = aOrgURL.getName(INetURLObject::LAST_SEGMENT, true,
 417                                            INetURLObject::DecodeMechanism::WithCharset);
 418     }
 419
 420     // search for already existing items and update her nState value ...
 421     for (TURLInfo& aOld : m_lURLs)
 422     {
 423         if (aOld.ID == aNew.ID)
 424         {
 425             // change existing
 426             aOld.DocState      = aNew.DocState;
 427             aOld.RecoveryState = RecoveryCore::mapDocState2RecoverState(aOld.DocState);
 428             if (m_pListener)
 429             {
 430                 m_pListener->updateItems();
 431                 m_pListener->stepNext(&aOld);
 432             }
 433             return;
 434         }
 435     }
 436
 437     // append as new one
 438     // TODO think about matching Module name to a corresponding icon
 439     OUString sURL = aNew.OrgURL;
 440     if (sURL.isEmpty())
 441         sURL = aNew.FactoryURL;
 442     if (sURL.isEmpty())
 443         sURL = aNew.TempURL;
 444     if (sURL.isEmpty())
 445         sURL = aNew.TemplateURL;
 446     INetURLObject aURL(sURL);
 447     aNew.StandardImageId = SvFileInformationManager::GetFileImageId(aURL);
 448
 449     /* set the right UI state for this item to NOT_RECOVERED_YET... because nDocState shows the state of
 450        the last emergency save operation before and is interesting for the used recovery core service only...
 451        for now! But if there is a further notification for this item (see lines above!) we must
 452        map the doc state to an UI state. */
 453     aNew.RecoveryState = E_NOT_RECOVERED_YET;
 454
 455     m_lURLs.push_back(aNew);
 456
 457     if (m_pListener)
 458         m_pListener->updateItems();
 459 }
 460
 461
 462 void SAL_CALL RecoveryCore::disposing(const css::lang::EventObject& /*aEvent*/)
 463 {
 464     m_xRealCore.clear();
 465 }
 466
 467
 468 void RecoveryCore::impl_startListening()
 469 {
 470     // listening already initialized ?
 471     if (m_xRealCore.is())
 472         return;
 473     m_xRealCore = css::frame::theAutoRecovery::get(m_xContext);
 474
 475     css::util::URL aURL;
 476     if (m_bListenForSaving)
 477         aURL.Complete = RECOVERY_CMD_DO_EMERGENCY_SAVE;
 478     else
 479         aURL.Complete = RECOVERY_CMD_DO_RECOVERY;
 480     css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext));
 481     xParser->parseStrict(aURL);
 482
 483     /* Note: addStatusListener() call us synchronous back ... so we
 484              will get the complete list of currently open documents! */
 485     m_xRealCore->addStatusListener(static_cast< css::frame::XStatusListener* >(this), aURL);
 486 }
 487
 488
 489 void RecoveryCore::impl_stopListening()
 490 {
 491     // Ignore it, if this instance doesn't listen currently
 492     if (!m_xRealCore.is())
 493         return;
 494
 495     css::util::URL aURL;
 496     if (m_bListenForSaving)
 497         aURL.Complete = RECOVERY_CMD_DO_EMERGENCY_SAVE;
 498     else
 499         aURL.Complete = RECOVERY_CMD_DO_RECOVERY;
 500     css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext));
 501     xParser->parseStrict(aURL);
 502
 503     m_xRealCore->removeStatusListener(static_cast< css::frame::XStatusListener* >(this), aURL);
 504     m_xRealCore.clear();
 505 }
 506
 507
 508 css::util::URL RecoveryCore::impl_getParsedURL(const OUString& sURL)
 509 {
 510     css::util::URL aURL;
 511     aURL.Complete = sURL;
 512
 513     css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext));
 514     xParser->parseStrict(aURL);
 515
 516     return aURL;
 517 }
 518
 519 PluginProgress::PluginProgress(weld::ProgressBar* pProgressBar)
 520     : m_pProgressBar(pProgressBar)
 521     , m_nRange(100)
 522 {
 523 }
 524
 525 PluginProgress::~PluginProgress()
 526 {
 527 }
 528
 529 void SAL_CALL PluginProgress::dispose()
 530 {
 531     m_pProgressBar = nullptr;
 532 }
 533
 534 void SAL_CALL PluginProgress::addEventListener(const css::uno::Reference< css::lang::XEventListener >& )
 535 {
 536 }
 537
 538 void SAL_CALL PluginProgress::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& )
 539 {
 540 }
 541
 542 void SAL_CALL PluginProgress::start(const OUString&, sal_Int32 nRange)
 543 {
 544     m_nRange = nRange;
 545     if (m_pProgressBar)
 546         m_pProgressBar->set_percentage(0);
 547 }
 548
 549 void SAL_CALL PluginProgress::end()
 550 {
 551     if (m_pProgressBar)
 552         m_pProgressBar->set_percentage(m_nRange);
 553 }
 554
 555 void SAL_CALL PluginProgress::setText(const OUString& rText)
 556 {
 557     if (m_pProgressBar)
 558         m_pProgressBar->set_text(rText);
 559 }
 560
 561 void SAL_CALL PluginProgress::setValue(sal_Int32 nValue)
 562 {
 563     if (m_pProgressBar)
 564         m_pProgressBar->set_percentage((nValue * 100) / m_nRange);
 565 }
 566
 567 void SAL_CALL PluginProgress::reset()
 568 {
 569     if (m_pProgressBar)
 570         m_pProgressBar->set_percentage(0);
 571 }
 572
 573 SaveDialog::SaveDialog(weld::Window* pParent, RecoveryCore* pCore)
 574     : GenericDialogController(pParent, u"svx/ui/docrecoverysavedialog.ui"_ustr, u"DocRecoverySaveDialog"_ustr)
 575     , m_pCore(pCore)
 576     , m_xFileListLB(m_xBuilder->weld_tree_view(u"filelist"_ustr))
 577     , m_xOkBtn(m_xBuilder->weld_button(u"ok"_ustr))
 578 {
 579     m_xFileListLB->set_size_request(-1, m_xFileListLB->get_height_rows(10));
 580
 581     // Prepare the office for the following crash save step.
 582     // E.g. hide all open windows so the user can't influence our
 583     // operation .-)
 584     m_pCore->doEmergencySavePrepare();
 585
 586     m_xOkBtn->connect_clicked(LINK(this, SaveDialog, OKButtonHdl));
 587
 588     // fill listbox with current open documents
 589
 590     TURLList&                rURLs = m_pCore->getURLListAccess();
 591
 592     for (const TURLInfo& rInfo : rURLs)
 593     {
 594         m_xFileListLB->append(u""_ustr, rInfo.DisplayName, rInfo.StandardImageId);
 595     }
 596 }
 597
 598 SaveDialog::~SaveDialog()
 599 {
 600 }
 601
 602 IMPL_LINK_NOARG(SaveDialog, OKButtonHdl, weld::Button&, void)
 603 {
 604     // start crash-save with progress
 605     std::unique_ptr<SaveProgressDialog> xProgress(new SaveProgressDialog(m_xDialog.get(), m_pCore));
 606     short nResult = xProgress->run();
 607     xProgress.reset();
 608
 609     // if "CANCEL" => return "CANCEL"
 610     // if "OK"     => request a restart always!
 611     if (nResult == DLG_RET_OK)
 612         nResult = DLG_RET_OK_AUTOLAUNCH;
 613
 614     m_xDialog->response(nResult);
 615 }
 616
 617 SaveProgressDialog::SaveProgressDialog(weld::Window* pParent, RecoveryCore* pCore)
 618     : GenericDialogController(pParent, u"svx/ui/docrecoveryprogressdialog.ui"_ustr, u"DocRecoveryProgressDialog"_ustr)
 619     , m_pCore(pCore)
 620     , m_xProgressBar(m_xBuilder->weld_progress_bar(u"progress"_ustr))
 621 {
 622     m_xProgressBar->set_size_request(m_xProgressBar->get_approximate_digit_width() * 50, -1);
 623     m_xProgress = new PluginProgress(m_xProgressBar.get());
 624 }
 625
 626 SaveProgressDialog::~SaveProgressDialog()
 627 {
 628     if (m_xProgress)
 629         m_xProgress->dispose();
 630 }
 631
 632 short SaveProgressDialog::run()
 633 {
 634     ::SolarMutexGuard aLock;
 635
 636     m_pCore->setProgressHandler(m_xProgress);
 637     m_pCore->setUpdateListener(this);
 638     m_pCore->doEmergencySave();
 639     short nRet = DialogController::run();
 640     m_pCore->setUpdateListener(nullptr);
 641     return nRet;
 642 }
 643
 644 void SaveProgressDialog::updateItems()
 645 {
 646 }
 647
 648 void SaveProgressDialog::stepNext(TURLInfo* )
 649 {
 650     /* TODO
 651
 652        if m_pCore would have a member m_mCurrentItem, you could see,
 653        who is current, who is next ... You can show this information
 654        in progress report FixText
 655     */
 656 }
 657
 658 void SaveProgressDialog::end()
 659 {
 660     m_xDialog->response(DLG_RET_OK);
 661 }
 662
 663 static short impl_askUserForWizardCancel(weld::Widget* pParent, TranslateId pRes)
 664 {
 665     std::unique_ptr<weld::MessageDialog> xQuery(Application::CreateMessageDialog(pParent,
 666                                                 VclMessageType::Question, VclButtonsType::YesNo, SvxResId(pRes)));
 667     if (xQuery->run() == RET_YES)
 668         return DLG_RET_OK;
 669     else
 670         return DLG_RET_CANCEL;
 671 }
 672
 673 RecoveryDialog::RecoveryDialog(weld::Window* pParent, RecoveryCore* pCore)
 674     : GenericDialogController(pParent, u"svx/ui/docrecoveryrecoverdialog.ui"_ustr, u"DocRecoveryRecoverDialog"_ustr)
 675     , m_aTitleRecoveryInProgress(SvxResId(RID_SVXSTR_RECOVERY_INPROGRESS))
 676     , m_aRecoveryOnlyFinish (SvxResId(RID_SVXSTR_RECOVERYONLY_FINISH))
 677     , m_aRecoveryOnlyFinishDescr(SvxResId(RID_SVXSTR_RECOVERYONLY_FINISH_DESCR))
 678     , m_pCore(pCore)
 679     , m_eRecoveryState(RecoveryDialog::E_RECOVERY_PREPARED)
 680     , m_bWaitForCore(false)
 681     , m_bWasRecoveryStarted(false)
 682 //    , m_aColumnOffset(0)
 683     , m_aToggleCount(0)
 684     , m_aSuccessRecovStr(SvxResId(RID_SVXSTR_SUCCESSRECOV))
 685     , m_aOrigDocRecovStr(SvxResId(RID_SVXSTR_ORIGDOCRECOV))
 686     , m_aRecovFailedStr(SvxResId(RID_SVXSTR_RECOVFAILED))
 687     , m_aRecovInProgrStr(SvxResId(RID_SVXSTR_RECOVINPROGR))
 688     , m_aNotRecovYetStr(SvxResId(RID_SVXSTR_NOTRECOVYET))
 689     , m_aWillBeDiscStr(SvxResId(RID_SVXSTR_WILLDISCARD))
 690     , m_xDescrFT(m_xBuilder->weld_label(u"desc"_ustr))
 691     , m_xProgressBar(m_xBuilder->weld_progress_bar(u"progress"_ustr))
 692     , m_xFileListLB(m_xBuilder->weld_tree_view(u"filelist"_ustr))
 693     , m_xNextBtn(m_xBuilder->weld_button(u"next"_ustr))
 694     , m_xCancelBtn(m_xBuilder->weld_button(u"cancel"_ustr))
 695 {
 696     const auto nWidth = m_xFileListLB->get_approximate_digit_width() * 80;
 697     m_xFileListLB->set_size_request(nWidth, m_xFileListLB->get_height_rows(10));
 698     m_xProgressBar->set_size_request(m_xProgressBar->get_approximate_digit_width() * 50, -1);
 699     m_xProgress = new PluginProgress(m_xProgressBar.get());
 700
 701     std::vector<int> aWidths;
 702     aWidths.push_back(60 * nWidth / 100);
 703     aWidths.push_back(5 * nWidth / 100);
 704     m_xFileListLB->set_column_fixed_widths(aWidths);
 705     m_xFileListLB->enable_toggle_buttons(weld::ColumnToggleType::Check);
 706     m_xFileListLB->connect_toggled( LINK(this, RecoveryDialog, ToggleRowHdl) );
 707
 708     m_xNextBtn->set_sensitive(true);
 709     m_xNextBtn->connect_clicked( LINK( this, RecoveryDialog, NextButtonHdl ) );
 710     m_xCancelBtn->connect_clicked( LINK( this, RecoveryDialog, CancelButtonHdl ) );
 711
 712     // fill list box first time
 713     TURLList& rURLList = m_pCore->getURLListAccess();
 714     for (size_t i = 0, nCount = rURLList.size(); i < nCount; ++i)
 715     {
 716         const TURLInfo& rInfo = rURLList[i];
 717         m_xFileListLB->append();
 718         m_xFileListLB->set_toggle(i, TRISTATE_TRUE);
 719         m_xFileListLB->set_id(i, weld::toId(&rInfo));
 720         m_xFileListLB->set_image(i, rInfo.StandardImageId, COLUMN_STANDARDIMAGE);
 721         m_xFileListLB->set_text(i, rInfo.DisplayName, COLUMN_DISPLAYNAME);
 722         m_xFileListLB->set_image(i, impl_getStatusImage(rInfo), COLUMN_STATUSIMAGE);
 723         m_xFileListLB->set_text(i, impl_getStatusString(rInfo), COLUMN_STATUSTEXT);
 724         m_aToggleCount++;
 725     }
 726
 727     // mark first item
 728     if (m_xFileListLB->n_children())
 729         m_xFileListLB->set_cursor(0);
 730 }
 731
 732 RecoveryDialog::~RecoveryDialog()
 733 {
 734     if (m_xProgress)
 735         m_xProgress->dispose();
 736 }
 737
 738 bool RecoveryDialog::allSuccessfullyRecovered()
 739 {
 740     const int c = m_xFileListLB->n_children();
 741     for (int i = 0; i < c; ++i)
 742     {
 743         TURLInfo* pInfo = weld::fromId<TURLInfo*>(m_xFileListLB->get_id(i));
 744         if (!pInfo)
 745             continue;
 746
 747         if (pInfo->RecoveryState != E_SUCCESSFULLY_RECOVERED)
 748             return false;
 749     }
 750     return true;
 751 }
 752
 753 short RecoveryDialog::execute()
 754 {
 755     ::SolarMutexGuard aSolarLock;
 756
 757     switch (m_eRecoveryState)
 758     {
 759         case RecoveryDialog::E_RECOVERY_IN_PROGRESS :
 760              {
 761                 // user decided to start recovery ...
 762                 m_bWasRecoveryStarted = true;
 763                 // do it asynchronous (to allow repaints)
 764                 // and wait for this asynchronous operation.
 765                 m_xDescrFT->set_label( m_aTitleRecoveryInProgress );
 766                 m_xNextBtn->set_sensitive(false);
 767                 m_xCancelBtn->set_sensitive(false);
 768                 m_pCore->setProgressHandler(m_xProgress);
 769                 m_pCore->setUpdateListener(this);
 770                 m_pCore->doRecovery();
 771
 772                 m_bWaitForCore = true;
 773                 while(m_bWaitForCore && !Application::IsQuit())
 774                     Application::Yield();
 775
 776                 m_pCore->setUpdateListener(nullptr);
 777
 778                 // Skip FINISH button if everything was successfully recovered
 779                 if (allSuccessfullyRecovered())
 780                     m_eRecoveryState = RecoveryDialog::E_RECOVERY_DONE;
 781                 else
 782                     m_eRecoveryState = RecoveryDialog::E_RECOVERY_CORE_DONE;
 783                 return execute();
 784              }
 785
 786         case RecoveryDialog::E_RECOVERY_CORE_DONE :
 787              {
 788                  // the core finished it's task.
 789                  // let the user decide the next step.
 790                  m_xDescrFT->set_label(m_aRecoveryOnlyFinishDescr);
 791                  m_xNextBtn->set_label(m_aRecoveryOnlyFinish);
 792                  m_xNextBtn->set_sensitive(true);
 793                  m_xCancelBtn->set_sensitive(false);
 794                  return 0;
 795              }
 796
 797         case RecoveryDialog::E_RECOVERY_DONE :
 798              {
 799                  // All documents were recovered.
 800                  // User decided to step to the "next" wizard page.
 801                  // Do it ... but check first, if there exist some
 802                  // failed recovery documents. They must be saved to
 803                  // a user selected directory.
 804                  short                 nRet                  = DLG_RET_UNKNOWN;
 805                  BrokenRecoveryDialog aBrokenRecoveryDialog(m_xDialog.get(), m_pCore, !m_bWasRecoveryStarted);
 806                  OUString sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); // get the default dir
 807                  if (aBrokenRecoveryDialog.isExecutionNeeded())
 808                  {
 809                      nRet = aBrokenRecoveryDialog.run();
 810                      sSaveDir = aBrokenRecoveryDialog.getSaveDirURL();
 811                  }
 812
 813                  switch(nRet)
 814                  {
 815                      // no broken temp files exists
 816                      // step to the next wizard page
 817                      case DLG_RET_UNKNOWN :
 818                           {
 819                               m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED;
 820                               return DLG_RET_OK;
 821                           }
 822
 823                      // user decided to save the broken temp files
 824                      // do and forget it
 825                      // step to the next wizard page
 826                      case DLG_RET_OK :
 827                           {
 828                               m_pCore->saveBrokenTempEntries(sSaveDir);
 829                               m_pCore->forgetBrokenTempEntries();
 830                               m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED;
 831                               return DLG_RET_OK;
 832                           }
 833
 834                      // user decided to ignore broken temp files.
 835                      // Ask it again ... may be this decision was wrong.
 836                      // Results:
 837                      //     IGNORE => remove broken temp files
 838                      //            => step to the next wizard page
 839                      //     CANCEL => step back to the recovery page
 840                      case DLG_RET_CANCEL :
 841                           {
 842                               // TODO ask user ...
 843                               m_pCore->forgetBrokenTempEntries();
 844                               m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED;
 845                               return DLG_RET_OK;
 846                           }
 847                  }
 848
 849                  m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED;
 850                  return DLG_RET_OK;
 851              }
 852
 853         case RecoveryDialog::E_RECOVERY_CANCELED :
 854              {
 855                  // "YES" => break recovery
 856                  // But there exist different states, where "cancel" can be called.
 857                  // Handle it different.
 858                  if (m_bWasRecoveryStarted)
 859                      m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED_AFTERWARDS;
 860                  else
 861                      m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED_BEFORE;
 862                  return execute();
 863              }
 864
 865         case RecoveryDialog::E_RECOVERY_CANCELED_BEFORE :
 866         case RecoveryDialog::E_RECOVERY_CANCELED_AFTERWARDS :
 867              {
 868                  // We have to check if there exists some temp. files.
 869                  // They should be saved to a user defined location.
 870                  // If no temp files exists or user decided to ignore it ...
 871                  // we have to remove all recovery/session data anyway!
 872                  short nRet = DLG_RET_UNKNOWN;
 873                  BrokenRecoveryDialog aBrokenRecoveryDialog(m_xDialog.get(), m_pCore, !m_bWasRecoveryStarted);
 874                  OUString sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); // get the default save location
 875
 876                  // dialog itself checks if there is a need to copy files for this mode.
 877                  // It uses the information m_bWasRecoveryStarted doing so.
 878                  if (aBrokenRecoveryDialog.isExecutionNeeded())
 879                  {
 880                      nRet     = aBrokenRecoveryDialog.run();
 881                      sSaveDir = aBrokenRecoveryDialog.getSaveDirURL();
 882                  }
 883
 884                  // Possible states:
 885                  // a) nRet == DLG_RET_UNKNOWN
 886                  //         dialog was not shown ...
 887                  //         because there exists no temp file for copy.
 888                  //         => remove all recovery data
 889                  // b) nRet == DLG_RET_OK
 890                  //         dialog was shown ...
 891                  //         user decided to save temp files
 892                  //         => save all OR broken temp files (depends from the time, where cancel was called)
 893                  //         => remove all recovery data
 894                  // c) nRet == DLG_RET_CANCEL
 895                  //         dialog was shown ...
 896                  //         user decided to ignore temp files
 897                  //         => remove all recovery data
 898                  // => a)/c) are the same ... b) has one additional operation
 899
 900                  // b)
 901                  if (nRet == DLG_RET_OK)
 902                  {
 903                      if (m_bWasRecoveryStarted)
 904                          m_pCore->saveBrokenTempEntries(sSaveDir);
 905                      else
 906                          m_pCore->saveAllTempEntries(sSaveDir);
 907                  }
 908
 909                  // a,b,c)
 910                  if (m_bWasRecoveryStarted)
 911                     m_pCore->forgetBrokenRecoveryEntries();
 912                  else
 913                     m_pCore->forgetAllRecoveryEntries();
 914                  m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED;
 915
 916                  // THERE IS NO WAY BACK. see impl_askUserForWizardCancel()!
 917                  return DLG_RET_CANCEL;
 918              }
 919     }
 920
 921     // should never be reached .-)
 922     OSL_FAIL("Should never be reached!");
 923     return DLG_RET_OK;
 924 }
 925
 926 void RecoveryDialog::updateItems()
 927 {
 928     int c = m_xFileListLB->n_children();
 929     for (int i = 0; i < c; ++i)
 930     {
 931         TURLInfo* pInfo = weld::fromId<TURLInfo*>(m_xFileListLB->get_id(i));
 932         if ( !pInfo )
 933             continue;
 934
 935         m_xFileListLB->set_image(i, impl_getStatusImage(*pInfo), COLUMN_STATUSIMAGE);
 936         OUString sStatus = impl_getStatusString( *pInfo );
 937         if (!sStatus.isEmpty())
 938             m_xFileListLB->set_text(i, sStatus, COLUMN_STATUSTEXT);
 939     }
 940 }
 941
 942 void RecoveryDialog::stepNext(TURLInfo* pItem)
 943 {
 944     int c = m_xFileListLB->n_children();
 945     for (int i=0; i < c; ++i)
 946     {
 947         TURLInfo* pInfo = weld::fromId<TURLInfo*>(m_xFileListLB->get_id(i));
 948         if (pInfo->ID != pItem->ID)
 949             continue;
 950
 951         m_xFileListLB->set_cursor(i);
 952         m_xFileListLB->scroll_to_row(i);
 953         break;
 954     }
 955 }
 956
 957 void RecoveryDialog::end()
 958 {
 959     m_bWaitForCore = false;
 960 }
 961
 962 IMPL_LINK_NOARG(RecoveryDialog, NextButtonHdl, weld::Button&, void)
 963 {
 964     switch (m_eRecoveryState)
 965     {
 966         case RecoveryDialog::E_RECOVERY_PREPARED:
 967             m_eRecoveryState = RecoveryDialog::E_RECOVERY_IN_PROGRESS;
 968             execute();
 969         break;
 970         case RecoveryDialog::E_RECOVERY_CORE_DONE:
 971             m_eRecoveryState = RecoveryDialog::E_RECOVERY_DONE;
 972             execute();
 973         break;
 974     }
 975
 976     if (m_eRecoveryState == RecoveryDialog::E_RECOVERY_HANDLED)
 977     {
 978         m_xDialog->response(DLG_RET_OK);
 979     }
 980 }
 981
 982 IMPL_LINK_NOARG(RecoveryDialog, CancelButtonHdl, weld::Button&, void)
 983 {
 984     switch (m_eRecoveryState)
 985     {
 986         case RecoveryDialog::E_RECOVERY_PREPARED:
 987             if (impl_askUserForWizardCancel(m_xDialog.get(), RID_SVXSTR_QUERY_EXIT_RECOVERY) != DLG_RET_CANCEL)
 988             {
 989                 m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED;
 990                 execute();
 991             }
 992             break;
 993         case RecoveryDialog::E_RECOVERY_CORE_DONE:
 994             m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED;
 995             execute();
 996             break;
 997     }
 998
 999     if (m_eRecoveryState == RecoveryDialog::E_RECOVERY_HANDLED)
1000     {
1001         m_xDialog->response(RET_CANCEL);
1002     }
1003 }
1004
1005 IMPL_LINK_NOARG(RecoveryDialog, ToggleRowHdl, const weld::TreeView::iter_col&, void)
1006 {
1007     int aIndex = m_xFileListLB->get_selected_index();
1008     TriState eState = m_xFileListLB->get_toggle(aIndex);
1009
1010     if (m_bWasRecoveryStarted)
1011     {
1012         switch (eState)
1013         {
1014             case TRISTATE_FALSE:
1015                  eState = TRISTATE_TRUE;
1016                 break;
1017             case TRISTATE_TRUE:
1018                 eState = TRISTATE_FALSE;
1019                 break;
1020             default:
1021                 // should never happen
1022                 assert(false);
1023                 break;
1024         }
1025
1026         // revert toggle
1027         m_xFileListLB->set_toggle(aIndex, eState);
1028     }
1029     else
1030     {
1031         impl_updateItemDescription(aIndex, eState);
1032
1033         switch (eState)
1034         {
1035             case TRISTATE_FALSE:
1036                 m_aToggleCount--;
1037                 break;
1038             case TRISTATE_TRUE:
1039                 m_aToggleCount++;
1040                 break;
1041             default:
1042                 // should never happen
1043                 assert(false);
1044                 break;
1045         }
1046
1047         m_xNextBtn->set_sensitive(m_aToggleCount != 0);
1048     }
1049 }
1050
1051 OUString RecoveryDialog::impl_getStatusString( const TURLInfo& rInfo ) const
1052 {
1053     OUString sStatus;
1054     switch ( rInfo.RecoveryState )
1055     {
1056         case E_SUCCESSFULLY_RECOVERED :
1057             sStatus = m_aSuccessRecovStr;
1058             break;
1059         case E_ORIGINAL_DOCUMENT_RECOVERED :
1060             sStatus = m_aOrigDocRecovStr;
1061             break;
1062         case E_RECOVERY_FAILED :
1063             sStatus = m_aRecovFailedStr;
1064             break;
1065         case E_RECOVERY_IS_IN_PROGRESS :
1066             sStatus = m_aRecovInProgrStr;
1067             break;
1068         case E_NOT_RECOVERED_YET :
1069             sStatus = m_aNotRecovYetStr;
1070             break;
1071         case E_WILL_BE_DISCARDED:
1072             sStatus = m_aWillBeDiscStr;
1073             break;
1074         default:
1075             break;
1076     }
1077     return sStatus;
1078 }
1079
1080 OUString RecoveryDialog::impl_getStatusImage( const TURLInfo& rInfo )
1081 {
1082     OUString sStatus;
1083     switch ( rInfo.RecoveryState )
1084     {
1085         case E_SUCCESSFULLY_RECOVERED :
1086             sStatus = RID_SVXBMP_GREENCHECK;
1087             break;
1088         case E_ORIGINAL_DOCUMENT_RECOVERED :
1089             sStatus = RID_SVXBMP_YELLOWCHECK;
1090             break;
1091         case E_RECOVERY_FAILED :
1092             sStatus = RID_SVXBMP_REDCROSS;
1093             break;
1094         default:
1095             break;
1096     }
1097     return sStatus;
1098 }
1099
1100 void RecoveryDialog::impl_updateItemDescription(int row, const TriState& rState)
1101 {
1102     TURLInfo* pInfo = reinterpret_cast<TURLInfo*>(m_xFileListLB->get_id(row).toInt64());
1103     if (!pInfo)
1104         return;
1105
1106     switch (rState)
1107     {
1108         case TRISTATE_FALSE:
1109             pInfo->RecoveryState = ERecoveryState::E_WILL_BE_DISCARDED;
1110             pInfo->ShouldDiscard = true;
1111             break;
1112         case TRISTATE_TRUE:
1113             pInfo->RecoveryState = ERecoveryState::E_NOT_RECOVERED_YET;
1114             pInfo->ShouldDiscard = false;
1115             break;
1116         default:
1117             // should never happen
1118             assert(false);
1119             break;
1120     }
1121
1122     OUString sStatus = impl_getStatusString(*pInfo);
1123     if (!sStatus.isEmpty())
1124         m_xFileListLB->set_text(row, sStatus, COLUMN_STATUSTEXT);
1125 }
1126
1127 BrokenRecoveryDialog::BrokenRecoveryDialog(weld::Window* pParent,
1128                                            RecoveryCore* pCore,
1129                                            bool bBeforeRecovery)
1130     : GenericDialogController(pParent, u"svx/ui/docrecoverybrokendialog.ui"_ustr, u"DocRecoveryBrokenDialog"_ustr)
1131     , m_pCore(pCore)
1132     , m_bBeforeRecovery(bBeforeRecovery)
1133     , m_bExecutionNeeded(false)
1134     , m_xFileListLB(m_xBuilder->weld_tree_view(u"filelist"_ustr))
1135     , m_xSaveDirED(m_xBuilder->weld_entry(u"savedir"_ustr))
1136     , m_xSaveDirBtn(m_xBuilder->weld_button(u"change"_ustr))
1137     , m_xOkBtn(m_xBuilder->weld_button(u"ok"_ustr))
1138     , m_xCancelBtn(m_xBuilder->weld_button(u"cancel"_ustr))
1139 {
1140     m_xSaveDirBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, SaveButtonHdl ) );
1141     m_xOkBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, OkButtonHdl ) );
1142     m_xCancelBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, CancelButtonHdl ) );
1143
1144     m_sSavePath = SvtPathOptions().GetWorkPath();
1145     INetURLObject aObj( m_sSavePath );
1146     OUString sPath;
1147     osl::FileBase::getSystemPathFromFileURL(aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), sPath);
1148     m_xSaveDirED->set_text(sPath);
1149
1150     impl_refresh();
1151 }
1152
1153 BrokenRecoveryDialog::~BrokenRecoveryDialog()
1154 {
1155 }
1156
1157 void BrokenRecoveryDialog::impl_refresh()
1158 {
1159     m_bExecutionNeeded = false;
1160     TURLList& rURLList = m_pCore->getURLListAccess();
1161     for (const TURLInfo& rInfo : rURLList)
1162     {
1163         if (m_bBeforeRecovery)
1164         {
1165             // "Cancel" before recovery ->
1166             // search for any temp files!
1167             if (rInfo.TempURL.isEmpty())
1168                 continue;
1169         }
1170         else
1171         {
1172             // "Cancel" after recovery ->
1173             // search for broken temp files
1174             if (!RecoveryCore::isBrokenTempEntry(rInfo))
1175                 continue;
1176         }
1177
1178         m_bExecutionNeeded = true;
1179
1180         m_xFileListLB->append(weld::toId(&rInfo), rInfo.DisplayName, rInfo.StandardImageId);
1181     }
1182     m_sSavePath.clear();
1183     m_xOkBtn->grab_focus();
1184 }
1185
1186 bool BrokenRecoveryDialog::isExecutionNeeded() const
1187 {
1188     return m_bExecutionNeeded;
1189 }
1190
1191 const OUString& BrokenRecoveryDialog::getSaveDirURL() const
1192 {
1193     return m_sSavePath;
1194 }
1195
1196 IMPL_LINK_NOARG(BrokenRecoveryDialog, OkButtonHdl, weld::Button&, void)
1197 {
1198     OUString sPhysicalPath = comphelper::string::strip(m_xSaveDirED->get_text(), ' ');
1199     OUString sURL;
1200     osl::FileBase::getFileURLFromSystemPath( sPhysicalPath, sURL );
1201     m_sSavePath = sURL;
1202     while (m_sSavePath.isEmpty())
1203         impl_askForSavePath();
1204
1205     m_xDialog->response(DLG_RET_OK);
1206 }
1207
1208 IMPL_LINK_NOARG(BrokenRecoveryDialog, CancelButtonHdl, weld::Button&, void)
1209 {
1210     m_xDialog->response(RET_CANCEL);
1211 }
1212
1213 IMPL_LINK_NOARG(BrokenRecoveryDialog, SaveButtonHdl, weld::Button&, void)
1214 {
1215     impl_askForSavePath();
1216 }
1217
1218 void BrokenRecoveryDialog::impl_askForSavePath()
1219 {
1220     css::uno::Reference< css::ui::dialogs::XFolderPicker2 > xFolderPicker =
1221         sfx2::createFolderPicker(m_pCore->getComponentContext(), m_xDialog.get());
1222
1223     INetURLObject aURL(m_sSavePath, INetProtocol::File);
1224     xFolderPicker->setDisplayDirectory(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
1225     short nRet = xFolderPicker->execute();
1226     if (nRet == css::ui::dialogs::ExecutableDialogResults::OK)
1227     {
1228         m_sSavePath = xFolderPicker->getDirectory();
1229         OUString sPath;
1230         osl::FileBase::getSystemPathFromFileURL(m_sSavePath, sPath);
1231         m_xSaveDirED->set_text(sPath);
1232     }
1233 }
1234
1235 }
1236
1237 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */