uui/source/iahndl.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 <memory>
  21
  22 #include <com/sun/star/awt/XWindow.hpp>
  23 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  24 #include <com/sun/star/configuration/backend/MergeRecoveryRequest.hpp>
  25 #include <com/sun/star/configuration/backend/StratumCreationException.hpp>
  26 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  27 #include <com/sun/star/document/BrokenPackageRequest.hpp>
  28 #include <com/sun/star/document/ExoticFileLoadException.hpp>
  29 #include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp>
  30 #include <com/sun/star/java/WrongJavaVersionException.hpp>
  31 #include <com/sun/star/lang/XInitialization.hpp>
  32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  33 #include <com/sun/star/script/ModuleSizeExceededRequest.hpp>
  34 #include <com/sun/star/task/ErrorCodeIOException.hpp>
  35 #include <com/sun/star/task/ErrorCodeRequest2.hpp>
  36 #include <com/sun/star/task/InteractionHandler.hpp>
  37 #include <com/sun/star/task/XInteractionAbort.hpp>
  38 #include <com/sun/star/task/XInteractionApprove.hpp>
  39 #include <com/sun/star/task/XInteractionDisapprove.hpp>
  40 #include <com/sun/star/task/XInteractionHandler2.hpp>
  41 #include <com/sun/star/task/XInteractionRequest.hpp>
  42 #include <com/sun/star/ucb/AuthenticationFallbackRequest.hpp>
  43 #include <com/sun/star/ucb/InteractiveAppException.hpp>
  44 #include <com/sun/star/ucb/InteractiveLockingLockedException.hpp>
  45 #include <com/sun/star/ucb/InteractiveLockingNotLockedException.hpp>
  46 #include <com/sun/star/ucb/InteractiveLockingLockExpiredException.hpp>
  47 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
  48 #include <com/sun/star/ucb/InteractiveNetworkOffLineException.hpp>
  49 #include <com/sun/star/ucb/InteractiveNetworkReadException.hpp>
  50 #include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp>
  51 #include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp>
  52 #include <com/sun/star/ucb/InteractiveWrongMediumException.hpp>
  53 #include <com/sun/star/ucb/NameClashException.hpp>
  54 #include <com/sun/star/ucb/NameClashResolveRequest.hpp>
  55 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
  56 #include <com/sun/star/ucb/XInteractionReplaceExistingData.hpp>
  57 #include <com/sun/star/ucb/XInteractionSupplyName.hpp>
  58 #include <com/sun/star/xforms/InvalidDataOnSubmitException.hpp>
  59 #include <com/sun/star/loader/CannotActivateFactoryException.hpp>
  60
  61 #include <sal/log.hxx>
  62 #include <rtl/ustrbuf.hxx>
  63 #include <osl/conditn.hxx>
  64 #include <unotools/resmgr.hxx>
  65 #include <utility>
  66 #include <vcl/errinf.hxx>
  67 #include <vcl/svapp.hxx>
  68 #include <vcl/weld.hxx>
  69 #include <comphelper/diagnose_ex.hxx>
  70 #include <comphelper/documentconstants.hxx>
  71 #include <comphelper/propertysequence.hxx>
  72 #include <svtools/sfxecode.hxx>
  73 #include <unotools/configmgr.hxx>
  74 #include <comphelper/namedvaluecollection.hxx>
  75 #include <typelib/typedescription.hxx>
  76 #include <unotools/confignode.hxx>
  77
  78 #include <ids.hxx>
  79 #include <ids.hrc>
  80 #include <strings.hrc>
  81
  82 #include "getcontinuations.hxx"
  83 #include "secmacrowarnings.hxx"
  84
  85 #include "iahndl.hxx"
  86 #include "nameclashdlg.hxx"
  87 #include <comphelper/string.hxx>
  88
  89 using ::com::sun::star::uno::Sequence;
  90 using ::com::sun::star::uno::UNO_QUERY;
  91 using ::com::sun::star::uno::Reference;
  92 using ::com::sun::star::task::XInteractionContinuation;
  93 using ::com::sun::star::task::XInteractionAbort;
  94 using ::com::sun::star::task::XInteractionApprove;
  95 using ::com::sun::star::uno::XInterface;
  96 using ::com::sun::star::lang::XInitialization;
  97 using ::com::sun::star::uno::UNO_QUERY_THROW;
  98 using ::com::sun::star::task::InteractionHandler;
  99 using ::com::sun::star::task::XInteractionHandler2;
 100 using ::com::sun::star::uno::Exception;
 101 using ::com::sun::star::uno::Any;
 102 using ::com::sun::star::task::XInteractionRequest;
 103 using ::com::sun::star::lang::XMultiServiceFactory;
 104
 105 using namespace ::com::sun::star;
 106
 107 namespace {
 108
 109 class HandleData : public osl::Condition
 110 {
 111 public:
 112     explicit HandleData(
 113         uno::Reference< task::XInteractionRequest > xRequest)
 114         : m_rRequest(std::move(xRequest)),
 115           bHandled( false )
 116     {
 117     }
 118     uno::Reference< task::XInteractionRequest > m_rRequest;
 119     bool                                        bHandled;
 120     beans::Optional< OUString >            m_aResult;
 121 };
 122
 123 } /* namespace */
 124
 125 UUIInteractionHelper::UUIInteractionHelper(
 126     uno::Reference< uno::XComponentContext > xContext)
 127     :  m_xContext(std::move(xContext))
 128 {
 129 }
 130
 131 UUIInteractionHelper::~UUIInteractionHelper()
 132 {
 133 }
 134
 135 void UUIInteractionHelper::handlerequest(
 136     void* pHandleData, void* pInteractionHelper)
 137 {
 138     HandleData* pHND
 139         = static_cast< HandleData * >(pHandleData);
 140     UUIInteractionHelper* pUUI
 141         = static_cast< UUIInteractionHelper * >(pInteractionHelper);
 142     bool bDummy = false;
 143     OUString aDummy;
 144     try
 145     {
 146         pHND->bHandled
 147             = pUUI->handleRequest_impl(pHND->m_rRequest, false, bDummy, aDummy);
 148         pHND->set();
 149     }
 150     catch (css::uno::Exception&)
 151     {
 152         TOOLS_WARN_EXCEPTION("uui", "");
 153     }
 154 }
 155
 156 bool
 157 UUIInteractionHelper::handleRequest(
 158     uno::Reference< task::XInteractionRequest > const & rRequest)
 159 {
 160     if(!Application::IsMainThread() && GetpApp())
 161     {
 162         // we are not in the main thread, let it handle that stuff
 163         HandleData aHD(rRequest);
 164         Link<void*,void> aLink(&aHD,handlerequest);
 165         Application::PostUserEvent(aLink,this);
 166         comphelper::SolarMutex& rSolarMutex = Application::GetSolarMutex();
 167         sal_uInt32 nLockCount = (rSolarMutex.IsCurrentThread()) ? rSolarMutex.release(true) : 0;
 168         aHD.wait();
 169         if (nLockCount)
 170             rSolarMutex.acquire(nLockCount);
 171         return aHD.bHandled;
 172     }
 173     else
 174     {
 175         bool bDummy = false;
 176         OUString aDummy;
 177         return handleRequest_impl(rRequest, false, bDummy, aDummy);
 178     }
 179 }
 180
 181 void UUIInteractionHelper::getstringfromrequest(
 182     void* pHandleData,void* pInteractionHelper)
 183 {
 184     HandleData* pHND = static_cast<HandleData*>(pHandleData);
 185     UUIInteractionHelper* pUUI = static_cast<UUIInteractionHelper*>(pInteractionHelper);
 186     pHND->m_aResult = pUUI->getStringFromRequest_impl(pHND->m_rRequest);
 187     pHND->set();
 188 }
 189
 190 beans::Optional< OUString >
 191 UUIInteractionHelper::getStringFromRequest_impl(
 192     uno::Reference< task::XInteractionRequest > const & rRequest)
 193 {
 194     bool bSuccess = false;
 195     OUString aMessage;
 196     handleRequest_impl(rRequest, true, bSuccess, aMessage);
 197
 198     OSL_ENSURE(bSuccess ||
 199                !isInformationalErrorMessageRequest(
 200                    rRequest->getContinuations()),
 201                "Interaction request is a candidate for a string representation."
 202                "Please implement!");
 203
 204     return beans::Optional< OUString >(bSuccess, aMessage);
 205 }
 206
 207 beans::Optional< OUString >
 208 UUIInteractionHelper::getStringFromRequest(
 209     uno::Reference< task::XInteractionRequest > const & rRequest)
 210 {
 211     if(!Application::IsMainThread() && GetpApp())
 212     {
 213         // we are not in the main thread, let it handle that stuff
 214         HandleData aHD(rRequest);
 215         Link<void*,void> aLink(&aHD,getstringfromrequest);
 216         Application::PostUserEvent(aLink,this);
 217         comphelper::SolarMutex& rSolarMutex = Application::GetSolarMutex();
 218         sal_uInt32 nLockCount = (rSolarMutex.IsCurrentThread()) ? rSolarMutex.release(true) : 0;
 219         aHD.wait();
 220         if (nLockCount)
 221             rSolarMutex.acquire(nLockCount);
 222         return aHD.m_aResult;
 223     }
 224     else
 225         return getStringFromRequest_impl(rRequest);
 226 }
 227
 228 OUString
 229 UUIInteractionHelper::replaceMessageWithArguments(
 230     const OUString& _aMessage,
 231     std::vector< OUString > const & rArguments )
 232 {
 233     OUString aMessage = _aMessage;
 234
 235     SAL_WARN_IF(rArguments.empty(), "uui", "replaceMessageWithArguments: No arguments passed!");
 236     for (size_t i = 0; i < rArguments.size(); ++i)
 237     {
 238         const OUString sReplaceTemplate = "$(ARG" + OUString::number(i+1) + ")";
 239         aMessage = aMessage.replaceAll(sReplaceTemplate, rArguments[i]);
 240     }
 241
 242     return aMessage;
 243 }
 244
 245 bool
 246 UUIInteractionHelper::isInformationalErrorMessageRequest(
 247     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
 248         rContinuations)
 249 {
 250     // Only requests with a single continuation (user has no choice, request
 251     // is just informational)
 252     if (rContinuations.getLength() != 1 )
 253         return false;
 254
 255     // user can only abort or approve, all other continuations are not
 256     // considered to be informational.
 257     uno::Reference< task::XInteractionApprove > xApprove(
 258         rContinuations[0], uno::UNO_QUERY);
 259     if (xApprove.is())
 260         return true;
 261
 262     uno::Reference< task::XInteractionAbort > xAbort(
 263         rContinuations[0], uno::UNO_QUERY);
 264     return xAbort.is();
 265 }
 266
 267 namespace
 268 {
 269
 270     bool lcl_matchesRequest( const Any& i_rRequest, const OUString& i_rTypeName, std::u16string_view i_rPropagation )
 271     {
 272         const css::uno::TypeDescription aTypeDesc( i_rTypeName );
 273         const typelib_TypeDescription* pTypeDesc = aTypeDesc.get();
 274         if ( !pTypeDesc || !pTypeDesc->pWeakRef )
 275         {
 276             SAL_WARN( "uui","no type found for '" << i_rTypeName << "'" );
 277             return false;
 278         }
 279         const css::uno::Type aType( pTypeDesc->pWeakRef );
 280
 281         const bool bExactMatch = i_rPropagation == u"named-only";
 282         if ( bExactMatch )
 283             return i_rRequest.getValueType().equals( aType );
 284
 285         return i_rRequest.isExtractableTo( aType );
 286     }
 287 }
 288
 289
 290 bool UUIInteractionHelper::handleCustomRequest( const Reference< XInteractionRequest >& i_rRequest, const OUString& i_rServiceName ) const
 291 {
 292     try
 293     {
 294         Reference< XInteractionHandler2 > xHandler( m_xContext->getServiceManager()->createInstanceWithContext( i_rServiceName, m_xContext ), UNO_QUERY_THROW );
 295
 296         Reference< XInitialization > xHandlerInit( xHandler, UNO_QUERY );
 297         if ( xHandlerInit.is() )
 298         {
 299             ::comphelper::NamedValueCollection aInitArgs;
 300             aInitArgs.put( "Parent", getParentXWindow() );
 301             xHandlerInit->initialize( aInitArgs.getWrappedPropertyValues() );
 302         }
 303
 304         if ( xHandler->handleInteractionRequest( i_rRequest ) )
 305             return true;
 306     }
 307     catch( const Exception& )
 308     {
 309         DBG_UNHANDLED_EXCEPTION("uui");
 310     }
 311     return false;
 312 }
 313
 314
 315 bool UUIInteractionHelper::handleTypedHandlerImplementations( Reference< XInteractionRequest > const & rRequest )
 316 {
 317     // the request
 318     const Any aRequest( rRequest->getRequest() );
 319
 320     const StringHashMap::const_iterator aCacheHitTest = m_aTypedCustomHandlers.find( aRequest.getValueTypeName() );
 321     if ( aCacheHitTest != m_aTypedCustomHandlers.end() )
 322         return handleCustomRequest( rRequest, aCacheHitTest->second );
 323
 324     // the base registration node for "typed" interaction handlers
 325     const ::utl::OConfigurationTreeRoot aConfigRoot( ::utl::OConfigurationTreeRoot::createWithComponentContext(
 326         m_xContext,
 327         "/org.openoffice.Interaction/InteractionHandlers",
 328         -1,
 329         ::utl::OConfigurationTreeRoot::CM_READONLY
 330     ) );
 331
 332     // loop through all registered implementations
 333     const Sequence< OUString > aRegisteredHandlers( aConfigRoot.getNodeNames() );
 334     for ( auto const & handlerName : aRegisteredHandlers )
 335     {
 336         const ::utl::OConfigurationNode aHandlerNode( aConfigRoot.openNode( handlerName ) );
 337         const ::utl::OConfigurationNode aTypesNode( aHandlerNode.openNode( "HandledRequestTypes" ) );
 338
 339         // loop through all the types which the current handler is registered for
 340         const Sequence< OUString > aHandledTypes( aTypesNode.getNodeNames() );
 341         for ( auto const & type : aHandledTypes )
 342         {
 343             // the UNO type is the node name
 344             ::utl::OConfigurationNode aType( aTypesNode.openNode( type ) );
 345             // and there's a child denoting how the responsibility propagates
 346             OUString sPropagation;
 347             OSL_VERIFY( aType.getNodeValue( "Propagation" ) >>= sPropagation );
 348             if ( lcl_matchesRequest( aRequest, type, sPropagation ) )
 349             {
 350                 // retrieve the service/implementation name of the handler
 351                 OUString sServiceName;
 352                 OSL_VERIFY( aHandlerNode.getNodeValue( "ServiceName" ) >>= sServiceName );
 353                 // cache the information who feels responsible for requests of this type
 354                 m_aTypedCustomHandlers[ aRequest.getValueTypeName() ] = sServiceName;
 355                 // actually handle the request
 356                 return handleCustomRequest( rRequest, sServiceName );
 357             }
 358         }
 359     }
 360
 361     return false;
 362 }
 363
 364 bool
 365 UUIInteractionHelper::handleRequest_impl(
 366     uno::Reference< task::XInteractionRequest > const & rRequest,
 367     bool bObtainErrorStringOnly,
 368     bool & bHasErrorString,
 369     OUString & rErrorString)
 370 {
 371     try
 372     {
 373         if (!rRequest.is())
 374             return false;
 375
 376         uno::Any aAnyRequest(rRequest->getRequest());
 377
 378         script::ModuleSizeExceededRequest aModSizeException;
 379         if (aAnyRequest >>= aModSizeException )
 380         {
 381             std::vector< OUString > aArguments;
 382             aArguments.push_back(
 383                 comphelper::string::convertCommaSeparated(aModSizeException.Names));
 384             handleErrorHandlerRequest( task::InteractionClassification_WARNING,
 385                                        ERRCODE_UUI_IO_MODULESIZEEXCEEDED,
 386                                        aArguments,
 387                                        rRequest->getContinuations(),
 388                                        bObtainErrorStringOnly,
 389                                        bHasErrorString,
 390                                        rErrorString);
 391             return true;
 392         }
 393
 394         document::ExoticFileLoadException aExoticFileLoadException;
 395         if (aAnyRequest >>= aExoticFileLoadException)
 396         {
 397             std::vector< OUString > aArguments;
 398
 399             if( !aExoticFileLoadException.URL.isEmpty() )
 400             {
 401                 aArguments.push_back( aExoticFileLoadException.URL );
 402             }
 403             if( !aExoticFileLoadException.FilterUIName.isEmpty() )
 404             {
 405                 aArguments.push_back( aExoticFileLoadException.FilterUIName );
 406             }
 407
 408             handleErrorHandlerRequest( task::InteractionClassification_WARNING,
 409                                        ERRCODE_UUI_IO_EXOTICFILEFORMAT,
 410                                        aArguments,
 411                                        rRequest->getContinuations(),
 412                                        bObtainErrorStringOnly,
 413                                        bHasErrorString,
 414                                        rErrorString);
 415             return true;
 416         }
 417
 418         ucb::NameClashException aNCException;
 419         if (aAnyRequest >>= aNCException)
 420         {
 421             ErrCode nErrorCode = ERRCODE_UUI_IO_TARGETALREADYEXISTS;
 422             std::vector< OUString > aArguments;
 423
 424             if( !aNCException.Name.isEmpty() )
 425             {
 426                 nErrorCode = ERRCODE_UUI_IO_ALREADYEXISTS;
 427                 aArguments.push_back( aNCException.Name );
 428             }
 429
 430             handleErrorHandlerRequest( aNCException.Classification,
 431                                        nErrorCode,
 432                                        aArguments,
 433                                        rRequest->getContinuations(),
 434                                        bObtainErrorStringOnly,
 435                                        bHasErrorString,
 436                                        rErrorString);
 437             return true;
 438         }
 439
 440         ucb::UnsupportedNameClashException aUORequest;
 441         if (aAnyRequest >>= aUORequest)
 442         {
 443
 444             uno::Reference< task::XInteractionApprove > xApprove;
 445             uno::Reference< task::XInteractionDisapprove > xDisapprove;
 446             getContinuations(
 447                 rRequest->getContinuations(), &xApprove, &xDisapprove);
 448
 449             if ( xApprove.is() && xDisapprove.is() )
 450             {
 451                 std::vector< OUString > aArguments;
 452                 handleErrorHandlerRequest( task::InteractionClassification_QUERY,
 453                                            ERRCODE_UUI_IO_UNSUPPORTEDOVERWRITE,
 454                                            aArguments,
 455                                            rRequest->getContinuations(),
 456                                            bObtainErrorStringOnly,
 457                                            bHasErrorString,
 458                                            rErrorString);
 459             }
 460             return true;
 461         }
 462
 463         if ( handleInteractiveIOException( rRequest,
 464                                            bObtainErrorStringOnly,
 465                                            bHasErrorString,
 466                                            rErrorString ) )
 467             return true;
 468
 469         ucb::InteractiveAppException aAppException;
 470         if (aAnyRequest >>= aAppException)
 471         {
 472             std::vector< OUString > aArguments;
 473             handleErrorHandlerRequest( aAppException.Classification,
 474                                        ErrCode(aAppException.Code),
 475                                        aArguments,
 476                                        rRequest->getContinuations(),
 477                                        bObtainErrorStringOnly,
 478                                        bHasErrorString,
 479                                        rErrorString);
 480             return true;
 481         }
 482
 483         ucb::InteractiveNetworkException aNetworkException;
 484         if (aAnyRequest >>= aNetworkException)
 485         {
 486             ErrCode nErrorCode;
 487             std::vector< OUString > aArguments;
 488             ucb::InteractiveNetworkOffLineException aOffLineException;
 489             ucb::InteractiveNetworkResolveNameException aResolveNameException;
 490             ucb::InteractiveNetworkConnectException aConnectException;
 491             ucb::InteractiveNetworkReadException aReadException;
 492             ucb::InteractiveNetworkWriteException aWriteException;
 493             if (aAnyRequest >>= aOffLineException)
 494                 nErrorCode = ERRCODE_INET_OFFLINE;
 495             else if (aAnyRequest >>= aResolveNameException)
 496             {
 497                 nErrorCode = ERRCODE_INET_NAME_RESOLVE;
 498                 aArguments.push_back(aResolveNameException.Server);
 499             }
 500             else if (aAnyRequest >>= aConnectException)
 501             {
 502                 nErrorCode = ERRCODE_INET_CONNECT;
 503                 aArguments.push_back(aConnectException.Server);
 504             }
 505             else if (aAnyRequest >>= aReadException)
 506             {
 507                 nErrorCode = ERRCODE_INET_READ;
 508                 aArguments.push_back(aReadException.Diagnostic);
 509             }
 510             else if (aAnyRequest >>= aWriteException)
 511             {
 512                 nErrorCode = ERRCODE_INET_WRITE;
 513                 aArguments.push_back(aWriteException.Diagnostic);
 514             }
 515             else
 516                 nErrorCode = ERRCODE_INET_GENERAL;
 517
 518             handleErrorHandlerRequest(aNetworkException.Classification,
 519                                       nErrorCode,
 520                                       aArguments,
 521                                       rRequest->getContinuations(),
 522                                       bObtainErrorStringOnly,
 523                                       bHasErrorString,
 524                                       rErrorString);
 525             return true;
 526         }
 527
 528         ucb::InteractiveWrongMediumException aWrongMediumException;
 529         if (aAnyRequest >>= aWrongMediumException)
 530         {
 531             sal_Int32 nMedium = 0;
 532             aWrongMediumException.Medium >>= nMedium;
 533             std::vector< OUString > aArguments { OUString::number(nMedium + 1) };
 534             handleErrorHandlerRequest(aWrongMediumException.Classification,
 535                                       ERRCODE_UUI_WRONGMEDIUM,
 536                                       aArguments,
 537                                       rRequest->getContinuations(),
 538                                       bObtainErrorStringOnly,
 539                                       bHasErrorString,
 540                                       rErrorString);
 541             return true;
 542         }
 543
 544         java::WrongJavaVersionException aWrongJavaVersionException;
 545         if (aAnyRequest >>= aWrongJavaVersionException)
 546         {
 547             ErrCode nErrorCode;
 548             std::vector< OUString > aArguments;
 549             if (aWrongJavaVersionException.DetectedVersion.isEmpty())
 550                 if (aWrongJavaVersionException.LowestSupportedVersion.isEmpty())
 551                     nErrorCode = ERRCODE_UUI_WRONGJAVA;
 552                 else
 553                 {
 554                     nErrorCode = ERRCODE_UUI_WRONGJAVA_MIN;
 555                     aArguments.push_back(aWrongJavaVersionException.LowestSupportedVersion);
 556                 }
 557             else if (aWrongJavaVersionException.LowestSupportedVersion.isEmpty())
 558             {
 559                 nErrorCode = ERRCODE_UUI_WRONGJAVA_VERSION;
 560                 aArguments.push_back(aWrongJavaVersionException.DetectedVersion);
 561             }
 562             else
 563             {
 564                 nErrorCode = ERRCODE_UUI_WRONGJAVA_VERSION_MIN;
 565                 aArguments.reserve(2);
 566                 aArguments.push_back(aWrongJavaVersionException.DetectedVersion);
 567                 aArguments.push_back(aWrongJavaVersionException.LowestSupportedVersion);
 568             }
 569             handleErrorHandlerRequest(task::InteractionClassification_ERROR,
 570                                       nErrorCode,
 571                                       aArguments,
 572                                       rRequest->getContinuations(),
 573                                       bObtainErrorStringOnly,
 574                                       bHasErrorString,
 575                                       rErrorString);
 576             return true;
 577         }
 578
 579         configuration::backend::MergeRecoveryRequest aMergeRecoveryRequest;
 580         if (aAnyRequest >>= aMergeRecoveryRequest)
 581         {
 582             ErrCode nErrorCode = aMergeRecoveryRequest.IsRemovalRequest
 583                 ? ERRCODE_UUI_CONFIGURATION_BROKENDATA_WITHREMOVE
 584                 : ERRCODE_UUI_CONFIGURATION_BROKENDATA_NOREMOVE;
 585
 586             std::vector< OUString > aArguments { aMergeRecoveryRequest.ErrorLayerId };
 587
 588             handleErrorHandlerRequest(task::InteractionClassification_ERROR,
 589                                       nErrorCode,
 590                                       aArguments,
 591                                       rRequest->getContinuations(),
 592                                       bObtainErrorStringOnly,
 593                                       bHasErrorString,
 594                                       rErrorString);
 595             return true;
 596         }
 597
 598         configuration::backend::StratumCreationException
 599             aStratumCreationException;
 600
 601         if (aAnyRequest >>= aStratumCreationException)
 602         {
 603             const ErrCode nErrorCode = ERRCODE_UUI_CONFIGURATION_BACKENDMISSING;
 604
 605             OUString aStratum = aStratumCreationException.StratumData;
 606             if (aStratum.isEmpty())
 607                 aStratum = aStratumCreationException.StratumService;
 608
 609             std::vector< OUString > aArguments { aStratum };
 610
 611             handleErrorHandlerRequest(task::InteractionClassification_ERROR,
 612                                       nErrorCode,
 613                                       aArguments,
 614                                       rRequest->getContinuations(),
 615                                       bObtainErrorStringOnly,
 616                                       bHasErrorString,
 617                                       rErrorString);
 618             return true;
 619         }
 620
 621         xforms::InvalidDataOnSubmitException aInvalidDataOnSubmitException;
 622         if (aAnyRequest >>= aInvalidDataOnSubmitException)
 623         {
 624             const ErrCode nErrorCode =
 625                 ERRCODE_UUI_INVALID_XFORMS_SUBMISSION_DATA;
 626
 627             std::vector< OUString > aArguments;
 628
 629             handleErrorHandlerRequest(task::InteractionClassification_QUERY,
 630                                       nErrorCode,
 631                                       aArguments,
 632                                       rRequest->getContinuations(),
 633                                       bObtainErrorStringOnly,
 634                                       bHasErrorString,
 635                                       rErrorString);
 636             return true;
 637         }
 638
 639         ucb::InteractiveLockingLockedException aLLException;
 640         if (aAnyRequest >>= aLLException)
 641         {
 642             ErrCode nErrorCode = aLLException.SelfOwned
 643                 ? ERRCODE_UUI_LOCKING_LOCKED_SELF : ERRCODE_UUI_LOCKING_LOCKED;
 644             std::vector< OUString > aArguments { aLLException.Url };
 645
 646             handleErrorHandlerRequest( aLLException.Classification,
 647                                        nErrorCode,
 648                                        aArguments,
 649                                        rRequest->getContinuations(),
 650                                        bObtainErrorStringOnly,
 651                                        bHasErrorString,
 652                                        rErrorString );
 653             return true;
 654         }
 655
 656         ucb::InteractiveLockingNotLockedException aLNLException;
 657         if (aAnyRequest >>= aLNLException)
 658         {
 659             std::vector< OUString > aArguments { aLNLException.Url };
 660
 661             handleErrorHandlerRequest( aLNLException.Classification,
 662                                        ERRCODE_UUI_LOCKING_NOT_LOCKED,
 663                                        aArguments,
 664                                        rRequest->getContinuations(),
 665                                        bObtainErrorStringOnly,
 666                                        bHasErrorString,
 667                                        rErrorString );
 668             return true;
 669         }
 670
 671         ucb::InteractiveLockingLockExpiredException aLLEException;
 672         if (aAnyRequest >>= aLLEException)
 673         {
 674             std::vector< OUString > aArguments { aLLEException.Url };
 675
 676             handleErrorHandlerRequest( aLLEException.Classification,
 677                                        ERRCODE_UUI_LOCKING_LOCK_EXPIRED,
 678                                        aArguments,
 679                                        rRequest->getContinuations(),
 680                                        bObtainErrorStringOnly,
 681                                        bHasErrorString,
 682                                        rErrorString );
 683             return true;
 684         }
 685
 686         document::BrokenPackageRequest aBrokenPackageRequest;
 687         if (aAnyRequest >>= aBrokenPackageRequest)
 688         {
 689             std::vector< OUString > aArguments;
 690
 691             if( !aBrokenPackageRequest.aName.isEmpty() )
 692                 aArguments.push_back( aBrokenPackageRequest.aName );
 693
 694             handleBrokenPackageRequest( aArguments,
 695                                         rRequest->getContinuations(),
 696                                         bObtainErrorStringOnly,
 697                                         bHasErrorString,
 698                                         rErrorString );
 699             return true;
 700         }
 701
 702         task::ErrorCodeRequest2 aErrorCodeRequest2;
 703         if (aAnyRequest >>= aErrorCodeRequest2)
 704         {
 705             handleGenericErrorRequest(
 706                     ErrCodeMsg(ErrCode(aErrorCodeRequest2.ErrCode), aErrorCodeRequest2.Arg1, aErrorCodeRequest2.Arg2, static_cast<DialogMask>(aErrorCodeRequest2.DialogMask)),
 707                     rRequest->getContinuations(),
 708                     bObtainErrorStringOnly,
 709                     bHasErrorString,
 710                     rErrorString);
 711             return true;
 712         }
 713         task::ErrorCodeRequest aErrorCodeRequest;
 714         if (aAnyRequest >>= aErrorCodeRequest)
 715         {
 716             handleGenericErrorRequest( ErrCode(aErrorCodeRequest.ErrCode),
 717                     rRequest->getContinuations(),
 718                     bObtainErrorStringOnly,
 719                     bHasErrorString,
 720                     rErrorString);
 721             return true;
 722         }
 723
 724         task::ErrorCodeIOException aErrorCodeIOException;
 725         if (aAnyRequest >>= aErrorCodeIOException)
 726         {
 727             handleGenericErrorRequest( ErrCode(aErrorCodeIOException.ErrCode),
 728                                        rRequest->getContinuations(),
 729                                        bObtainErrorStringOnly,
 730                                        bHasErrorString,
 731                                        rErrorString);
 732             return true;
 733         }
 734
 735         loader::CannotActivateFactoryException aCannotActivateFactoryException;
 736         if (aAnyRequest >>= aCannotActivateFactoryException)
 737         {
 738             std::vector< OUString > aArguments { aCannotActivateFactoryException.Message };
 739
 740             handleErrorHandlerRequest( task::InteractionClassification_ERROR,
 741                                        ERRCODE_UUI_CANNOT_ACTIVATE_FACTORY,
 742                                        aArguments,
 743                                        rRequest->getContinuations(),
 744                                        bObtainErrorStringOnly,
 745                                        bHasErrorString,
 746                                        rErrorString );
 747             return true;
 748         }
 749
 750
 751         // Handle requests which do not have a plain string representation.
 752
 753         if (!bObtainErrorStringOnly)
 754         {
 755             ucb::AuthenticationFallbackRequest anAuthFallbackRequest;
 756             if ( aAnyRequest >>= anAuthFallbackRequest )
 757             {
 758                 handleAuthFallbackRequest( anAuthFallbackRequest.instructions,
 759                         anAuthFallbackRequest.url, rRequest->getContinuations() );
 760                 return true;
 761             }
 762
 763             if ( handleAuthenticationRequest( rRequest ) )
 764                 return true;
 765
 766             if ( handleCertificateValidationRequest( rRequest ) )
 767                 return true;
 768
 769             ucb::NameClashResolveRequest aNameClashResolveRequest;
 770             if (aAnyRequest >>= aNameClashResolveRequest)
 771             {
 772                 handleNameClashResolveRequest(aNameClashResolveRequest,
 773                                               rRequest->getContinuations());
 774                 return true;
 775             }
 776
 777             if ( handleMasterPasswordRequest( rRequest ) )
 778                 return true;
 779
 780             if ( handlePasswordRequest( rRequest ) )
 781                 return true;
 782
 783             if ( handleNoSuchFilterRequest( rRequest ) )
 784                 return true;
 785
 786             if ( handleFilterOptionsRequest( rRequest ) )
 787                 return true;
 788
 789             if ( handleLockedDocumentRequest( rRequest ) )
 790                 return true;
 791
 792             if ( handleChangedByOthersRequest( rRequest ) )
 793                 return true;
 794
 795             if ( handleLockFileProblemRequest( rRequest ) )
 796                 return true;
 797
 798             if ( handleReloadEditableRequest( rRequest ) )
 799                 return true;
 800
 801             task::DocumentMacroConfirmationRequest aMacroConfirmRequest;
 802             if (aAnyRequest >>= aMacroConfirmRequest)
 803             {
 804                 handleMacroConfirmRequest(
 805                     aMacroConfirmRequest.DocumentURL,
 806                     aMacroConfirmRequest.DocumentStorage,
 807                     !aMacroConfirmRequest.DocumentVersion.isEmpty() ? aMacroConfirmRequest.DocumentVersion : ODFVER_013_TEXT,
 808                     aMacroConfirmRequest.DocumentSignatureInformation,
 809                     rRequest->getContinuations());
 810                 return true;
 811             }
 812
 813             OUString aFileName;
 814             beans::NamedValue aLoadReadOnlyRequest;
 815             if ((aAnyRequest >>= aLoadReadOnlyRequest) &&
 816                 aLoadReadOnlyRequest.Name == "LoadReadOnlyRequest" &&
 817                 (aLoadReadOnlyRequest.Value >>= aFileName))
 818             {
 819                 handleLoadReadOnlyRequest(aFileName,
 820                                           rRequest->getContinuations());
 821                 return true;
 822             }
 823
 824             // Last chance: interaction handlers registered in the configuration
 825
 826
 827             // typed InteractionHandlers (ooo.Interactions)
 828             if ( handleTypedHandlerImplementations( rRequest ) )
 829                 return true;
 830         }
 831
 832         // Not handled.
 833         return false;
 834     }
 835     catch( const uno::RuntimeException& )
 836     {
 837         throw;  // allowed to leave here
 838     }
 839     catch( const uno::Exception& )
 840     {
 841         DBG_UNHANDLED_EXCEPTION("uui");
 842     }
 843     return false;
 844 }
 845
 846 const uno::Reference< awt::XWindow>&
 847 UUIInteractionHelper::getParentXWindow() const
 848 {
 849     return m_xWindowParam;
 850 }
 851
 852 uno::Reference< task::XInteractionHandler2 >
 853 UUIInteractionHelper::getInteractionHandler() const
 854 {
 855     return InteractionHandler::createWithParentAndContext(
 856         m_xContext, m_xWindowParam,
 857         m_aContextParam);
 858 }
 859
 860 namespace {
 861
 862 DialogMask
 863 executeMessageBox(
 864     weld::Window * pParent,
 865     OUString const & rTitle,
 866     OUString const & rMessage,
 867     VclMessageType eMessageType)
 868 {
 869     SolarMutexGuard aGuard;
 870
 871     std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent, eMessageType,
 872         eMessageType == VclMessageType::Question ? VclButtonsType::YesNo : VclButtonsType::Ok, rMessage, GetpApp()));
 873     xBox->set_title(rTitle);
 874
 875     short nMessResult = xBox->run();
 876     DialogMask aResult = DialogMask::NONE;
 877     switch (nMessResult)
 878     {
 879         case RET_OK:
 880             aResult = DialogMask::ButtonsOk;
 881             break;
 882         case RET_CANCEL:
 883             aResult = DialogMask::ButtonsCancel;
 884             break;
 885         case RET_YES:
 886             aResult = DialogMask::ButtonsYes;
 887             break;
 888         case RET_NO:
 889             aResult = DialogMask::ButtonsNo;
 890             break;
 891         default:
 892             assert(false);
 893     }
 894
 895     return aResult;
 896 }
 897
 898 NameClashResolveDialogResult executeSimpleNameClashResolveDialog(weld::Window *pParent,
 899                                                                  OUString const & rTargetFolderURL,
 900                                                                  OUString const & rClashingName,
 901                                                                  OUString & rProposedNewName,
 902                                                                  bool bAllowOverwrite)
 903 {
 904     std::locale aResLocale = Translate::Create("uui");
 905     NameClashDialog aDialog(pParent, aResLocale, rTargetFolderURL,
 906                             rClashingName, rProposedNewName, bAllowOverwrite);
 907
 908     NameClashResolveDialogResult eResult = static_cast<NameClashResolveDialogResult>(aDialog.run());
 909     rProposedNewName = aDialog.getNewName();
 910     return eResult;
 911 }
 912
 913 } // namespace
 914
 915 void
 916 UUIInteractionHelper::handleNameClashResolveRequest(
 917     ucb::NameClashResolveRequest const & rRequest,
 918     uno::Sequence< uno::Reference<
 919         task::XInteractionContinuation > > const & rContinuations)
 920 {
 921     OSL_ENSURE(!rRequest.TargetFolderURL.isEmpty(),
 922         "NameClashResolveRequest must not contain empty TargetFolderURL" );
 923
 924     OSL_ENSURE(!rRequest.ClashingName.isEmpty(),
 925         "NameClashResolveRequest must not contain empty ClashingName" );
 926
 927     uno::Reference< task::XInteractionAbort > xAbort;
 928     uno::Reference< ucb::XInteractionSupplyName > xSupplyName;
 929     uno::Reference< ucb::XInteractionReplaceExistingData > xReplaceExistingData;
 930     getContinuations(
 931         rContinuations, &xAbort, &xSupplyName, &xReplaceExistingData);
 932
 933     OSL_ENSURE( xAbort.is(),
 934         "NameClashResolveRequest must contain Abort continuation" );
 935
 936     OSL_ENSURE( xSupplyName.is(),
 937         "NameClashResolveRequest must contain SupplyName continuation" );
 938
 939     NameClashResolveDialogResult eResult = ABORT;
 940     OUString aProposedNewName( rRequest.ProposedNewName );
 941
 942     uno::Reference<awt::XWindow> xParent = getParentXWindow();
 943     eResult = executeSimpleNameClashResolveDialog(Application::GetFrameWeld(xParent),
 944                     rRequest.TargetFolderURL,
 945                     rRequest.ClashingName,
 946                     aProposedNewName,
 947                     xReplaceExistingData.is());
 948
 949     switch ( eResult )
 950     {
 951     case ABORT:
 952         xAbort->select();
 953         break;
 954
 955     case RENAME:
 956         xSupplyName->setName( aProposedNewName );
 957         xSupplyName->select();
 958         break;
 959
 960     case OVERWRITE:
 961         OSL_ENSURE(
 962             xReplaceExistingData.is(),
 963             "Invalid NameClashResolveDialogResult: OVERWRITE - "
 964             "No ReplaceExistingData continuation available!" );
 965         xReplaceExistingData->select();
 966         break;
 967     }
 968 }
 969
 970 void
 971 UUIInteractionHelper::handleGenericErrorRequest(
 972     ErrCodeMsg nErrorCode,
 973     uno::Sequence< uno::Reference<
 974         task::XInteractionContinuation > > const & rContinuations,
 975     bool bObtainErrorStringOnly,
 976     bool & bHasErrorString,
 977     OUString & rErrorString)
 978 {
 979     if (bObtainErrorStringOnly)
 980     {
 981         bHasErrorString = isInformationalErrorMessageRequest(rContinuations);
 982         if (bHasErrorString)
 983         {
 984             OUString aErrorString;
 985             ErrorHandler::GetErrorString(nErrorCode, aErrorString);
 986             rErrorString = aErrorString;
 987         }
 988     }
 989     else
 990     {
 991         uno::Reference< task::XInteractionAbort > xAbort;
 992         uno::Reference< task::XInteractionApprove > xApprove;
 993         getContinuations(rContinuations, &xApprove, &xAbort);
 994
 995         // Note: It's important to convert the transported long to the
 996         // required  unsigned long value. Otherwise using as flag field
 997         // can fail ...
 998         bool bWarning = !nErrorCode.IgnoreWarning();
 999
1000         if ( nErrorCode == ERRCODE_SFX_INCOMPLETE_ENCRYPTION )
1001         {
1002             // the security warning box needs a special title
1003             OUString aErrorString;
1004             ErrorHandler::GetErrorString( nErrorCode, aErrorString );
1005
1006             std::locale aResLocale = Translate::Create("uui");
1007             OUString aTitle( utl::ConfigManager::getProductName() );
1008
1009             OUString aErrTitle = Translate::get(STR_WARNING_INCOMPLETE_ENCRYPTION_TITLE, aResLocale);
1010
1011             if ( !aTitle.isEmpty() && !aErrTitle.isEmpty() )
1012                 aTitle += " - " ;
1013             aTitle += aErrTitle;
1014
1015             uno::Reference<awt::XWindow> xParent = getParentXWindow();
1016             executeMessageBox(Application::GetFrameWeld(xParent), aTitle, aErrorString, VclMessageType::Error);
1017         }
1018         else
1019         {
1020             uno::Reference<awt::XWindow> xParent = getParentXWindow();
1021             ErrorHandler::HandleError(nErrorCode, Application::GetFrameWeld(xParent));
1022         }
1023
1024         if (xApprove.is() && bWarning)
1025             xApprove->select();
1026         else if (xAbort.is())
1027             xAbort->select();
1028     }
1029 }
1030
1031 void
1032 UUIInteractionHelper::handleMacroConfirmRequest(
1033     const OUString& aDocumentURL,
1034     const uno::Reference< embed::XStorage >& xZipStorage,
1035     const OUString& aDocumentVersion,
1036     const uno::Sequence< security::DocumentSignatureInformation >& aSignInfo,
1037     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
1038         rContinuations )
1039 {
1040     uno::Reference< task::XInteractionAbort > xAbort;
1041     uno::Reference< task::XInteractionApprove > xApprove;
1042     getContinuations( rContinuations, &xApprove, &xAbort );
1043
1044     bool bApprove = false;
1045
1046     bool bShowSignatures = aSignInfo.hasElements();
1047     uno::Reference<awt::XWindow> xParent = getParentXWindow();
1048     MacroWarning aWarning(Application::GetFrameWeld(xParent), bShowSignatures);
1049
1050     aWarning.SetDocumentURL(aDocumentURL);
1051     if ( aSignInfo.getLength() > 1 )
1052     {
1053         aWarning.SetStorage(xZipStorage, aDocumentVersion, aSignInfo);
1054     }
1055     else if ( aSignInfo.getLength() == 1 )
1056     {
1057         aWarning.SetCertificate(aSignInfo[0].Signer);
1058     }
1059
1060     bApprove = aWarning.run() == RET_OK;
1061
1062     if ( bApprove && xApprove.is() )
1063         xApprove->select();
1064     else if ( xAbort.is() )
1065         xAbort->select();
1066 }
1067
1068 void
1069 UUIInteractionHelper::handleBrokenPackageRequest(
1070     std::vector< OUString > const & rArguments,
1071     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
1072         rContinuations,
1073     bool bObtainErrorStringOnly,
1074     bool & bHasErrorString,
1075     OUString & rErrorString)
1076 {
1077     if (bObtainErrorStringOnly)
1078     {
1079         bHasErrorString = isInformationalErrorMessageRequest(rContinuations);
1080         if (!bHasErrorString)
1081             return;
1082     }
1083
1084     uno::Reference< task::XInteractionApprove > xApprove;
1085     uno::Reference< task::XInteractionDisapprove > xDisapprove;
1086     uno::Reference< task::XInteractionAbort > xAbort;
1087     getContinuations(rContinuations, &xApprove, &xDisapprove, &xAbort);
1088
1089     ErrCode nErrorCode;
1090     if( xApprove.is() && xDisapprove.is() )
1091     {
1092         nErrorCode = ERRCODE_UUI_IO_BROKENPACKAGE;
1093     }
1094     else if ( xAbort.is() )
1095     {
1096         nErrorCode = ERRCODE_UUI_IO_BROKENPACKAGE_CANTREPAIR;
1097     }
1098     else
1099         return;
1100
1101     OUString aMessage;
1102     {
1103         std::locale aResLocale = Translate::Create("uui");
1104         ErrorResource aErrorResource(RID_UUI_ERRHDL, aResLocale);
1105         if (!aErrorResource.getString(nErrorCode, aMessage))
1106             return;
1107     }
1108
1109     aMessage = replaceMessageWithArguments( aMessage, rArguments );
1110
1111     if (bObtainErrorStringOnly)
1112     {
1113         rErrorString = aMessage;
1114         return;
1115     }
1116
1117     VclMessageType eMessageType;
1118     if( xApprove.is() && xDisapprove.is() )
1119         eMessageType = VclMessageType::Question;
1120     else if ( xAbort.is() )
1121         eMessageType = VclMessageType::Warning;
1122     else
1123         return;
1124
1125     OUString title(
1126         utl::ConfigManager::getProductName() +
1127         " " +
1128         utl::ConfigManager::getProductVersion() );
1129
1130     uno::Reference<awt::XWindow> xParent = getParentXWindow();
1131     switch (executeMessageBox(Application::GetFrameWeld(xParent), title, aMessage, eMessageType))
1132     {
1133     case DialogMask::ButtonsOk:
1134         OSL_ENSURE( xAbort.is(), "unexpected situation" );
1135         if (xAbort.is())
1136             xAbort->select();
1137         break;
1138
1139     case DialogMask::ButtonsNo:
1140         OSL_ENSURE(xDisapprove.is(), "unexpected situation");
1141         if (xDisapprove.is())
1142             xDisapprove->select();
1143         break;
1144
1145     case DialogMask::ButtonsYes:
1146         OSL_ENSURE(xApprove.is(), "unexpected situation");
1147         if (xApprove.is())
1148             xApprove->select();
1149         break;
1150
1151     default: break;
1152     }
1153 }
1154
1155 // ErrorResource Implementation
1156 bool ErrorResource::getString(ErrCode nErrorCode, OUString &rString) const
1157 {
1158     for (const std::pair<TranslateId, ErrCode>* pStringArray = m_pStringArray; pStringArray->first; ++pStringArray)
1159     {
1160         if (nErrorCode.StripWarning() == pStringArray->second.StripWarning())
1161         {
1162             rString = Translate::get(pStringArray->first, m_rResLocale);
1163             return true;
1164         }
1165     }
1166     return false;
1167 }
1168
1169 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */