1*859212d1SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*859212d1SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*859212d1SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*859212d1SAndrew Rist * distributed with this work for additional information
6*859212d1SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*859212d1SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*859212d1SAndrew Rist * "License"); you may not use this file except in compliance
9*859212d1SAndrew Rist * with the License. You may obtain a copy of the License at
10*859212d1SAndrew Rist *
11*859212d1SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*859212d1SAndrew Rist *
13*859212d1SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*859212d1SAndrew Rist * software distributed under the License is distributed on an
15*859212d1SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*859212d1SAndrew Rist * KIND, either express or implied. See the License for the
17*859212d1SAndrew Rist * specific language governing permissions and limitations
18*859212d1SAndrew Rist * under the License.
19*859212d1SAndrew Rist *
20*859212d1SAndrew Rist *************************************************************/
21*859212d1SAndrew Rist
22*859212d1SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include <memory>
25cdf0e10cSrcweir
26cdf0e10cSrcweir #include "com/sun/star/awt/XWindow.hpp"
27cdf0e10cSrcweir #include "com/sun/star/beans/PropertyValue.hpp"
28cdf0e10cSrcweir #include "com/sun/star/configuration/backend/MergeRecoveryRequest.hpp"
29cdf0e10cSrcweir #include "com/sun/star/configuration/backend/StratumCreationException.hpp"
30cdf0e10cSrcweir #include "com/sun/star/container/XHierarchicalNameAccess.hpp"
31cdf0e10cSrcweir #include "com/sun/star/document/BrokenPackageRequest.hpp"
32cdf0e10cSrcweir #include "com/sun/star/task/DocumentMacroConfirmationRequest.hpp"
33cdf0e10cSrcweir #include "com/sun/star/java/WrongJavaVersionException.hpp"
34cdf0e10cSrcweir #include "com/sun/star/lang/XInitialization.hpp"
35cdf0e10cSrcweir #include "com/sun/star/lang/XMultiServiceFactory.hpp"
36cdf0e10cSrcweir #include "com/sun/star/script/ModuleSizeExceededRequest.hpp"
37cdf0e10cSrcweir #include "com/sun/star/sync2/BadPartnershipException.hpp"
38cdf0e10cSrcweir #include "com/sun/star/task/ErrorCodeIOException.hpp"
39cdf0e10cSrcweir #include "com/sun/star/task/ErrorCodeRequest.hpp"
40cdf0e10cSrcweir #include "com/sun/star/task/FutureDocumentVersionProductUpdateRequest.hpp"
41cdf0e10cSrcweir #include "com/sun/star/task/XInteractionAbort.hpp"
42cdf0e10cSrcweir #include "com/sun/star/task/XInteractionApprove.hpp"
43cdf0e10cSrcweir #include "com/sun/star/task/XInteractionAskLater.hpp"
44cdf0e10cSrcweir #include "com/sun/star/task/XInteractionDisapprove.hpp"
45cdf0e10cSrcweir #include "com/sun/star/task/XInteractionHandler2.hpp"
46cdf0e10cSrcweir #include "com/sun/star/task/XInteractionRequest.hpp"
47cdf0e10cSrcweir #include "com/sun/star/task/XInteractionRetry.hpp"
48cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveAppException.hpp"
49cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveCHAOSException.hpp"
50cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveLockingLockedException.hpp"
51cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveLockingNotLockedException.hpp"
52cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveLockingLockExpiredException.hpp"
53cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveNetworkConnectException.hpp"
54cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveNetworkOffLineException.hpp"
55cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveNetworkReadException.hpp"
56cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp"
57cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveNetworkWriteException.hpp"
58cdf0e10cSrcweir #include "com/sun/star/ucb/InteractiveWrongMediumException.hpp"
59cdf0e10cSrcweir #include "com/sun/star/ucb/NameClashException.hpp"
60cdf0e10cSrcweir #include "com/sun/star/ucb/NameClashResolveRequest.hpp"
61cdf0e10cSrcweir #include "com/sun/star/ucb/UnsupportedNameClashException.hpp"
62cdf0e10cSrcweir #include "com/sun/star/ucb/XInteractionReplaceExistingData.hpp"
63cdf0e10cSrcweir #include "com/sun/star/ucb/XInteractionSupplyName.hpp"
64cdf0e10cSrcweir #include "com/sun/star/xforms/InvalidDataOnSubmitException.hpp"
65cdf0e10cSrcweir
66cdf0e10cSrcweir #include "osl/conditn.hxx"
67cdf0e10cSrcweir #include "tools/rcid.h" // RSC_STRING
68cdf0e10cSrcweir #include "tools/errinf.hxx" // ErrorHandler, ErrorContext, ...
69cdf0e10cSrcweir #include "vos/mutex.hxx"
70cdf0e10cSrcweir #include "tools/diagnose_ex.h"
71cdf0e10cSrcweir #include "comphelper/documentconstants.hxx" // ODFVER_012_TEXT
72cdf0e10cSrcweir #include "svtools/sfxecode.hxx" // ERRCODE_SFX_*
73cdf0e10cSrcweir #include "vcl/msgbox.hxx"
74cdf0e10cSrcweir #include "vcl/svapp.hxx"
75cdf0e10cSrcweir #include "unotools/configmgr.hxx"
76cdf0e10cSrcweir #include "toolkit/helper/vclunohelper.hxx"
77cdf0e10cSrcweir #include "comphelper/namedvaluecollection.hxx"
78cdf0e10cSrcweir #include "typelib/typedescription.hxx"
79cdf0e10cSrcweir #include "unotools/confignode.hxx"
80cdf0e10cSrcweir
81cdf0e10cSrcweir #include "ids.hrc"
82cdf0e10cSrcweir
83cdf0e10cSrcweir #include "getcontinuations.hxx"
84cdf0e10cSrcweir #include "secmacrowarnings.hxx"
85cdf0e10cSrcweir #include "newerverwarn.hxx"
86cdf0e10cSrcweir
87cdf0e10cSrcweir #include "iahndl.hxx"
88cdf0e10cSrcweir #include "nameclashdlg.hxx"
89cdf0e10cSrcweir
90cdf0e10cSrcweir /** === begin UNO using === **/
91cdf0e10cSrcweir using ::com::sun::star::uno::Sequence;
92cdf0e10cSrcweir using ::com::sun::star::uno::UNO_QUERY;
93cdf0e10cSrcweir using ::com::sun::star::uno::Reference;
94cdf0e10cSrcweir using ::com::sun::star::task::XInteractionContinuation;
95cdf0e10cSrcweir using ::com::sun::star::task::XInteractionAbort;
96cdf0e10cSrcweir using ::com::sun::star::task::XInteractionApprove;
97cdf0e10cSrcweir using ::com::sun::star::task::XInteractionAskLater;
98cdf0e10cSrcweir using ::com::sun::star::task::FutureDocumentVersionProductUpdateRequest;
99cdf0e10cSrcweir using ::com::sun::star::uno::XInterface;
100cdf0e10cSrcweir using ::com::sun::star::lang::XInitialization;
101cdf0e10cSrcweir using ::com::sun::star::uno::UNO_QUERY_THROW;
102cdf0e10cSrcweir using ::com::sun::star::task::XInteractionHandler2;
103cdf0e10cSrcweir using ::com::sun::star::uno::Exception;
104cdf0e10cSrcweir using ::com::sun::star::uno::Any;
105cdf0e10cSrcweir using ::com::sun::star::task::XInteractionRequest;
106cdf0e10cSrcweir using ::com::sun::star::lang::XMultiServiceFactory;
107cdf0e10cSrcweir /** === end UNO using === **/
108cdf0e10cSrcweir
109cdf0e10cSrcweir using namespace ::com::sun::star;
110cdf0e10cSrcweir
111cdf0e10cSrcweir namespace {
112cdf0e10cSrcweir
113cdf0e10cSrcweir class HandleData : public osl::Condition
114cdf0e10cSrcweir {
115cdf0e10cSrcweir public:
HandleData(uno::Reference<task::XInteractionRequest> const & rRequest)116cdf0e10cSrcweir HandleData(
117cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest)
118cdf0e10cSrcweir : osl::Condition(),
119cdf0e10cSrcweir m_rRequest(rRequest),
120cdf0e10cSrcweir bHandled( false )
121cdf0e10cSrcweir {
122cdf0e10cSrcweir }
123cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > m_rRequest;
124cdf0e10cSrcweir bool bHandled;
125cdf0e10cSrcweir beans::Optional< rtl::OUString > m_aResult;
126cdf0e10cSrcweir };
127cdf0e10cSrcweir
128cdf0e10cSrcweir } /* namespace */
129cdf0e10cSrcweir
UUIInteractionHelper(uno::Reference<lang::XMultiServiceFactory> const & rServiceFactory,uno::Sequence<uno::Any> const & rArguments)130cdf0e10cSrcweir UUIInteractionHelper::UUIInteractionHelper(
131cdf0e10cSrcweir uno::Reference< lang::XMultiServiceFactory > const & rServiceFactory,
132cdf0e10cSrcweir uno::Sequence< uno::Any > const & rArguments)
133cdf0e10cSrcweir SAL_THROW(()):
134cdf0e10cSrcweir m_xServiceFactory(rServiceFactory),
135cdf0e10cSrcweir m_aProperties(rArguments)
136cdf0e10cSrcweir {
137cdf0e10cSrcweir }
138cdf0e10cSrcweir
UUIInteractionHelper(uno::Reference<lang::XMultiServiceFactory> const & rServiceFactory)139cdf0e10cSrcweir UUIInteractionHelper::UUIInteractionHelper(
140cdf0e10cSrcweir uno::Reference< lang::XMultiServiceFactory > const & rServiceFactory)
141cdf0e10cSrcweir SAL_THROW(()):
142cdf0e10cSrcweir m_xServiceFactory(rServiceFactory)
143cdf0e10cSrcweir {
144cdf0e10cSrcweir }
145cdf0e10cSrcweir
~UUIInteractionHelper()146cdf0e10cSrcweir UUIInteractionHelper::~UUIInteractionHelper()
147cdf0e10cSrcweir {
148cdf0e10cSrcweir }
149cdf0e10cSrcweir
150cdf0e10cSrcweir long
handlerequest(void * pHandleData,void * pInteractionHelper)151cdf0e10cSrcweir UUIInteractionHelper::handlerequest(
152cdf0e10cSrcweir void* pHandleData, void* pInteractionHelper)
153cdf0e10cSrcweir {
154cdf0e10cSrcweir HandleData* pHND
155cdf0e10cSrcweir = static_cast< HandleData * >(pHandleData);
156cdf0e10cSrcweir UUIInteractionHelper* pUUI
157cdf0e10cSrcweir = static_cast< UUIInteractionHelper * >(pInteractionHelper);
158cdf0e10cSrcweir bool bDummy = false;
159cdf0e10cSrcweir rtl::OUString aDummy;
160cdf0e10cSrcweir pHND->bHandled
161cdf0e10cSrcweir = pUUI->handleRequest_impl(pHND->m_rRequest, false, bDummy, aDummy);
162cdf0e10cSrcweir pHND->set();
163cdf0e10cSrcweir return 0;
164cdf0e10cSrcweir }
165cdf0e10cSrcweir
166cdf0e10cSrcweir bool
handleRequest(uno::Reference<task::XInteractionRequest> const & rRequest)167cdf0e10cSrcweir UUIInteractionHelper::handleRequest(
168cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest)
169cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
170cdf0e10cSrcweir {
171cdf0e10cSrcweir Application* pApp = 0;
172cdf0e10cSrcweir if(
173cdf0e10cSrcweir // be aware,it is the same type
174cdf0e10cSrcweir static_cast< oslThreadIdentifier >(
175cdf0e10cSrcweir Application::GetMainThreadIdentifier())
176cdf0e10cSrcweir != osl_getThreadIdentifier(NULL)
177cdf0e10cSrcweir &&
178cdf0e10cSrcweir (pApp = GetpApp())
179cdf0e10cSrcweir != 0
180cdf0e10cSrcweir ) {
181cdf0e10cSrcweir // we are not in the main thread, let it handle that stuff
182cdf0e10cSrcweir HandleData aHD(rRequest);
183cdf0e10cSrcweir Link aLink(&aHD,handlerequest);
184cdf0e10cSrcweir pApp->PostUserEvent(aLink,this);
185cdf0e10cSrcweir sal_uLong locks = Application::ReleaseSolarMutex();
186cdf0e10cSrcweir aHD.wait();
187cdf0e10cSrcweir Application::AcquireSolarMutex(locks);
188cdf0e10cSrcweir return aHD.bHandled;
189cdf0e10cSrcweir }
190cdf0e10cSrcweir else
191cdf0e10cSrcweir {
192cdf0e10cSrcweir bool bDummy = false;
193cdf0e10cSrcweir rtl::OUString aDummy;
194cdf0e10cSrcweir return handleRequest_impl(rRequest, false, bDummy, aDummy);
195cdf0e10cSrcweir }
196cdf0e10cSrcweir }
197cdf0e10cSrcweir
198cdf0e10cSrcweir long
getstringfromrequest(void * pHandleData,void * pInteractionHelper)199cdf0e10cSrcweir UUIInteractionHelper::getstringfromrequest(
200cdf0e10cSrcweir void* pHandleData,void* pInteractionHelper)
201cdf0e10cSrcweir {
202cdf0e10cSrcweir HandleData* pHND = (HandleData*) pHandleData;
203cdf0e10cSrcweir UUIInteractionHelper* pUUI = (UUIInteractionHelper*) pInteractionHelper;
204cdf0e10cSrcweir pHND->m_aResult = pUUI->getStringFromRequest_impl(pHND->m_rRequest);
205cdf0e10cSrcweir pHND->set();
206cdf0e10cSrcweir return 0;
207cdf0e10cSrcweir }
208cdf0e10cSrcweir
209cdf0e10cSrcweir beans::Optional< rtl::OUString >
getStringFromRequest_impl(uno::Reference<task::XInteractionRequest> const & rRequest)210cdf0e10cSrcweir UUIInteractionHelper::getStringFromRequest_impl(
211cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest)
212cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
213cdf0e10cSrcweir {
214cdf0e10cSrcweir bool bSuccess = false;
215cdf0e10cSrcweir rtl::OUString aMessage;
216cdf0e10cSrcweir handleRequest_impl(rRequest, true, bSuccess, aMessage);
217cdf0e10cSrcweir
218cdf0e10cSrcweir OSL_ENSURE(bSuccess ||
219cdf0e10cSrcweir !isInformationalErrorMessageRequest(
220cdf0e10cSrcweir rRequest->getContinuations()),
221cdf0e10cSrcweir "Interaction request is a candidate for a string representation."
222cdf0e10cSrcweir "Please implement!");
223cdf0e10cSrcweir
224cdf0e10cSrcweir return beans::Optional< rtl::OUString >(bSuccess, aMessage);
225cdf0e10cSrcweir }
226cdf0e10cSrcweir
227cdf0e10cSrcweir beans::Optional< rtl::OUString >
getStringFromRequest(uno::Reference<task::XInteractionRequest> const & rRequest)228cdf0e10cSrcweir UUIInteractionHelper::getStringFromRequest(
229cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest)
230cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
231cdf0e10cSrcweir {
232cdf0e10cSrcweir Application* pApp = 0;
233cdf0e10cSrcweir if(
234cdf0e10cSrcweir // be aware,it is the same type
235cdf0e10cSrcweir static_cast< oslThreadIdentifier >(
236cdf0e10cSrcweir Application::GetMainThreadIdentifier())
237cdf0e10cSrcweir != osl_getThreadIdentifier(NULL)
238cdf0e10cSrcweir &&
239cdf0e10cSrcweir (pApp = GetpApp())
240cdf0e10cSrcweir != 0
241cdf0e10cSrcweir ) {
242cdf0e10cSrcweir // we are not in the main thread, let it handle that stuff
243cdf0e10cSrcweir HandleData aHD(rRequest);
244cdf0e10cSrcweir Link aLink(&aHD,getstringfromrequest);
245cdf0e10cSrcweir pApp->PostUserEvent(aLink,this);
246cdf0e10cSrcweir sal_uLong locks = Application::ReleaseSolarMutex();
247cdf0e10cSrcweir aHD.wait();
248cdf0e10cSrcweir Application::AcquireSolarMutex(locks);
249cdf0e10cSrcweir return aHD.m_aResult;
250cdf0e10cSrcweir }
251cdf0e10cSrcweir else
252cdf0e10cSrcweir return getStringFromRequest_impl(rRequest);
253cdf0e10cSrcweir }
254cdf0e10cSrcweir
255cdf0e10cSrcweir ::rtl::OUString
replaceMessageWithArguments(::rtl::OUString aMessage,std::vector<rtl::OUString> const & rArguments)256cdf0e10cSrcweir UUIInteractionHelper::replaceMessageWithArguments(
257cdf0e10cSrcweir ::rtl::OUString aMessage,
258cdf0e10cSrcweir std::vector< rtl::OUString > const & rArguments )
259cdf0e10cSrcweir {
260cdf0e10cSrcweir for (sal_Int32 i = 0;;)
261cdf0e10cSrcweir {
262cdf0e10cSrcweir i = aMessage.
263cdf0e10cSrcweir indexOf(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("$(ARG")), i);
264cdf0e10cSrcweir if (i == -1)
265cdf0e10cSrcweir break;
266cdf0e10cSrcweir if (aMessage.getLength() - i >= RTL_CONSTASCII_LENGTH("$(ARGx)")
267cdf0e10cSrcweir && aMessage.getStr()[i + RTL_CONSTASCII_LENGTH("$(ARGx")] == ')')
268cdf0e10cSrcweir {
269cdf0e10cSrcweir sal_Unicode c
270cdf0e10cSrcweir = aMessage.getStr()[i + RTL_CONSTASCII_LENGTH("$(ARG")];
271cdf0e10cSrcweir if (c >= '1' && c <= '2')
272cdf0e10cSrcweir {
273cdf0e10cSrcweir std::vector< rtl::OUString >::size_type nIndex
274cdf0e10cSrcweir = static_cast< std::vector< rtl::OUString >::size_type >(
275cdf0e10cSrcweir c - '1');
276cdf0e10cSrcweir if (nIndex < rArguments.size())
277cdf0e10cSrcweir {
278cdf0e10cSrcweir aMessage
279cdf0e10cSrcweir = aMessage.replaceAt(i,
280cdf0e10cSrcweir RTL_CONSTASCII_LENGTH("$(ARGx)"),
281cdf0e10cSrcweir rArguments[nIndex]);
282cdf0e10cSrcweir i += rArguments[nIndex].getLength();
283cdf0e10cSrcweir continue;
284cdf0e10cSrcweir }
285cdf0e10cSrcweir }
286cdf0e10cSrcweir }
287cdf0e10cSrcweir ++i;
288cdf0e10cSrcweir }
289cdf0e10cSrcweir
290cdf0e10cSrcweir return aMessage;
291cdf0e10cSrcweir }
292cdf0e10cSrcweir
293cdf0e10cSrcweir bool
isInformationalErrorMessageRequest(uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations)294cdf0e10cSrcweir UUIInteractionHelper::isInformationalErrorMessageRequest(
295cdf0e10cSrcweir uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
296cdf0e10cSrcweir rContinuations)
297cdf0e10cSrcweir {
298cdf0e10cSrcweir // Only requests with a single continuation (user has no choice, request
299cdf0e10cSrcweir // is just informational)
300cdf0e10cSrcweir if (rContinuations.getLength() != 1 )
301cdf0e10cSrcweir return false;
302cdf0e10cSrcweir
303cdf0e10cSrcweir // user can only abort or approve, all other continuations are not
304cdf0e10cSrcweir // considered to be informational.
305cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove(
306cdf0e10cSrcweir rContinuations[0], uno::UNO_QUERY);
307cdf0e10cSrcweir if (xApprove.is())
308cdf0e10cSrcweir return true;
309cdf0e10cSrcweir
310cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort(
311cdf0e10cSrcweir rContinuations[0], uno::UNO_QUERY);
312cdf0e10cSrcweir if (xAbort.is())
313cdf0e10cSrcweir return true;
314cdf0e10cSrcweir
315cdf0e10cSrcweir return false;
316cdf0e10cSrcweir }
317cdf0e10cSrcweir
318cdf0e10cSrcweir bool
tryOtherInteractionHandler(uno::Reference<task::XInteractionRequest> const & rRequest)319cdf0e10cSrcweir UUIInteractionHelper::tryOtherInteractionHandler(
320cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest)
321cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
322cdf0e10cSrcweir {
323cdf0e10cSrcweir InteractionHandlerDataList dataList;
324cdf0e10cSrcweir getInteractionHandlerList(dataList);
325cdf0e10cSrcweir
326cdf0e10cSrcweir InteractionHandlerDataList::const_iterator aEnd(dataList.end());
327cdf0e10cSrcweir for (InteractionHandlerDataList::const_iterator aIt(dataList.begin());
328cdf0e10cSrcweir aIt != aEnd;
329cdf0e10cSrcweir ++aIt)
330cdf0e10cSrcweir {
331cdf0e10cSrcweir if ( handleCustomRequest( rRequest, aIt->ServiceName ) )
332cdf0e10cSrcweir return true;
333cdf0e10cSrcweir }
334cdf0e10cSrcweir return false;
335cdf0e10cSrcweir }
336cdf0e10cSrcweir
337cdf0e10cSrcweir namespace
338cdf0e10cSrcweir {
339cdf0e10cSrcweir // .................................................................................................................
lcl_matchesRequest(const Any & i_rRequest,const::rtl::OUString & i_rTypeName,const::rtl::OUString & i_rPropagation)340cdf0e10cSrcweir static bool lcl_matchesRequest( const Any& i_rRequest, const ::rtl::OUString& i_rTypeName, const ::rtl::OUString& i_rPropagation )
341cdf0e10cSrcweir {
342cdf0e10cSrcweir const ::com::sun::star::uno::TypeDescription aTypeDesc( i_rTypeName );
343cdf0e10cSrcweir const typelib_TypeDescription* pTypeDesc = aTypeDesc.get();
344cdf0e10cSrcweir if ( !pTypeDesc || !pTypeDesc->pWeakRef )
345cdf0e10cSrcweir {
346cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 0
347cdf0e10cSrcweir ::rtl::OStringBuffer aMessage;
348cdf0e10cSrcweir aMessage.append( "no type found for '" );
349cdf0e10cSrcweir aMessage.append( ::rtl::OUStringToOString( i_rTypeName, RTL_TEXTENCODING_UTF8 ) );
350cdf0e10cSrcweir aMessage.append( "'" );
351cdf0e10cSrcweir OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
352cdf0e10cSrcweir #endif
353cdf0e10cSrcweir return false;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir const ::com::sun::star::uno::Type aType( pTypeDesc->pWeakRef );
356cdf0e10cSrcweir
357cdf0e10cSrcweir const bool bExactMatch = ( i_rPropagation.compareToAscii( "named-only" ) == 0 );
358cdf0e10cSrcweir if ( bExactMatch )
359cdf0e10cSrcweir return i_rRequest.getValueType().equals( aType );
360cdf0e10cSrcweir
361cdf0e10cSrcweir return i_rRequest.isExtractableTo( aType );
362cdf0e10cSrcweir }
363cdf0e10cSrcweir }
364cdf0e10cSrcweir
365cdf0e10cSrcweir // ---------------------------------------------------------------------------------------------------------------------
handleCustomRequest(const Reference<XInteractionRequest> & i_rRequest,const::rtl::OUString & i_rServiceName) const366cdf0e10cSrcweir bool UUIInteractionHelper::handleCustomRequest( const Reference< XInteractionRequest >& i_rRequest, const ::rtl::OUString& i_rServiceName ) const
367cdf0e10cSrcweir {
368cdf0e10cSrcweir try
369cdf0e10cSrcweir {
370cdf0e10cSrcweir Reference< XInteractionHandler2 > xHandler( m_xServiceFactory->createInstance( i_rServiceName ), UNO_QUERY_THROW );
371cdf0e10cSrcweir
372cdf0e10cSrcweir Reference< XInitialization > xHandlerInit( xHandler, UNO_QUERY );
373cdf0e10cSrcweir if ( xHandlerInit.is() )
374cdf0e10cSrcweir {
375cdf0e10cSrcweir ::comphelper::NamedValueCollection aInitArgs;
376cdf0e10cSrcweir aInitArgs.put( "Parent", getParentXWindow() );
377cdf0e10cSrcweir xHandlerInit->initialize( aInitArgs.getWrappedPropertyValues() );
378cdf0e10cSrcweir }
379cdf0e10cSrcweir
380cdf0e10cSrcweir if ( xHandler->handleInteractionRequest( i_rRequest ) )
381cdf0e10cSrcweir return true;
382cdf0e10cSrcweir }
383cdf0e10cSrcweir catch( const Exception& )
384cdf0e10cSrcweir {
385cdf0e10cSrcweir DBG_UNHANDLED_EXCEPTION();
386cdf0e10cSrcweir }
387cdf0e10cSrcweir return false;
388cdf0e10cSrcweir }
389cdf0e10cSrcweir
390cdf0e10cSrcweir // ---------------------------------------------------------------------------------------------------------------------
handleTypedHandlerImplementations(Reference<XInteractionRequest> const & rRequest)391cdf0e10cSrcweir bool UUIInteractionHelper::handleTypedHandlerImplementations( Reference< XInteractionRequest > const & rRequest )
392cdf0e10cSrcweir {
393cdf0e10cSrcweir // the request
394cdf0e10cSrcweir const Any aRequest( rRequest->getRequest() );
395cdf0e10cSrcweir
396cdf0e10cSrcweir const StringHashMap::const_iterator aCacheHitTest = m_aTypedCustomHandlers.find( aRequest.getValueTypeName() );
397cdf0e10cSrcweir if ( aCacheHitTest != m_aTypedCustomHandlers.end() )
398cdf0e10cSrcweir return handleCustomRequest( rRequest, aCacheHitTest->second );
399cdf0e10cSrcweir
400cdf0e10cSrcweir // the base registration node for "typed" interaction handlers
401cdf0e10cSrcweir const ::utl::OConfigurationTreeRoot aConfigRoot( ::utl::OConfigurationTreeRoot::createWithServiceFactory(
402cdf0e10cSrcweir m_xServiceFactory,
403cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Interaction/InteractionHandlers" ) ),
404cdf0e10cSrcweir -1,
405cdf0e10cSrcweir ::utl::OConfigurationTreeRoot::CM_READONLY
406cdf0e10cSrcweir ) );
407cdf0e10cSrcweir
408cdf0e10cSrcweir // loop through all registered implementations
409cdf0e10cSrcweir const Sequence< ::rtl::OUString > aRegisteredHandlers( aConfigRoot.getNodeNames() );
410cdf0e10cSrcweir const ::rtl::OUString* pHandlerName = aRegisteredHandlers.getConstArray();
411cdf0e10cSrcweir const ::rtl::OUString* pHandlersEnd = aRegisteredHandlers.getConstArray() + aRegisteredHandlers.getLength();
412cdf0e10cSrcweir for ( ; pHandlerName != pHandlersEnd; ++pHandlerName )
413cdf0e10cSrcweir {
414cdf0e10cSrcweir const ::utl::OConfigurationNode aHandlerNode( aConfigRoot.openNode( *pHandlerName ) );
415cdf0e10cSrcweir const ::utl::OConfigurationNode aTypesNode( aHandlerNode.openNode( "HandledRequestTypes" ) );
416cdf0e10cSrcweir
417cdf0e10cSrcweir // loop through all the types which the current handler is registered for
418cdf0e10cSrcweir const Sequence< ::rtl::OUString > aHandledTypes( aTypesNode.getNodeNames() );
419cdf0e10cSrcweir const ::rtl::OUString* pType = aHandledTypes.getConstArray();
420cdf0e10cSrcweir const ::rtl::OUString* pTypesEnd = aHandledTypes.getConstArray() + aHandledTypes.getLength();
421cdf0e10cSrcweir for ( ; pType != pTypesEnd; ++pType )
422cdf0e10cSrcweir {
423cdf0e10cSrcweir // the UNO type is the node name
424cdf0e10cSrcweir ::utl::OConfigurationNode aType( aTypesNode.openNode( *pType ) );
425cdf0e10cSrcweir // and there's a child denoting how the responsibility propagates
426cdf0e10cSrcweir ::rtl::OUString sPropagation;
427cdf0e10cSrcweir OSL_VERIFY( aType.getNodeValue( "Propagation" ) >>= sPropagation );
428cdf0e10cSrcweir if ( lcl_matchesRequest( aRequest, *pType, sPropagation ) )
429cdf0e10cSrcweir {
430cdf0e10cSrcweir // retrieve the service/implementation name of the handler
431cdf0e10cSrcweir ::rtl::OUString sServiceName;
432cdf0e10cSrcweir OSL_VERIFY( aHandlerNode.getNodeValue( "ServiceName" ) >>= sServiceName );
433cdf0e10cSrcweir // cache the information who feels responsible for requests of this type
434cdf0e10cSrcweir m_aTypedCustomHandlers[ aRequest.getValueTypeName() ] = sServiceName;
435cdf0e10cSrcweir // actually handle the request
436cdf0e10cSrcweir return handleCustomRequest( rRequest, sServiceName );
437cdf0e10cSrcweir }
438cdf0e10cSrcweir }
439cdf0e10cSrcweir }
440cdf0e10cSrcweir
441cdf0e10cSrcweir return false;
442cdf0e10cSrcweir }
443cdf0e10cSrcweir
444cdf0e10cSrcweir bool
handleRequest_impl(uno::Reference<task::XInteractionRequest> const & rRequest,bool bObtainErrorStringOnly,bool & bHasErrorString,rtl::OUString & rErrorString)445cdf0e10cSrcweir UUIInteractionHelper::handleRequest_impl(
446cdf0e10cSrcweir uno::Reference< task::XInteractionRequest > const & rRequest,
447cdf0e10cSrcweir bool bObtainErrorStringOnly,
448cdf0e10cSrcweir bool & bHasErrorString,
449cdf0e10cSrcweir rtl::OUString & rErrorString)
450cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
451cdf0e10cSrcweir {
452cdf0e10cSrcweir try
453cdf0e10cSrcweir {
454cdf0e10cSrcweir if (!rRequest.is())
455cdf0e10cSrcweir return false;
456cdf0e10cSrcweir
457cdf0e10cSrcweir uno::Any aAnyRequest(rRequest->getRequest());
458cdf0e10cSrcweir
459cdf0e10cSrcweir script::ModuleSizeExceededRequest aModSizeException;
460cdf0e10cSrcweir if (aAnyRequest >>= aModSizeException )
461cdf0e10cSrcweir {
462cdf0e10cSrcweir ErrCode nErrorCode = ERRCODE_UUI_IO_MODULESIZEEXCEEDED;
463cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
464cdf0e10cSrcweir uno::Sequence< rtl::OUString > sModules
465cdf0e10cSrcweir = aModSizeException.Names;
466cdf0e10cSrcweir if ( sModules.getLength() )
467cdf0e10cSrcweir {
468cdf0e10cSrcweir rtl::OUString aName;
469cdf0e10cSrcweir for ( sal_Int32 index=0; index< sModules.getLength(); ++index )
470cdf0e10cSrcweir {
471cdf0e10cSrcweir if ( index )
472cdf0e10cSrcweir aName = aName + rtl::OUString( ',' ) + sModules[index];
473cdf0e10cSrcweir else
474cdf0e10cSrcweir aName = sModules[index]; // 1st name
475cdf0e10cSrcweir }
476cdf0e10cSrcweir aArguments.push_back( aName );
477cdf0e10cSrcweir }
478cdf0e10cSrcweir handleErrorHandlerRequest( task::InteractionClassification_WARNING,
479cdf0e10cSrcweir nErrorCode,
480cdf0e10cSrcweir aArguments,
481cdf0e10cSrcweir rRequest->getContinuations(),
482cdf0e10cSrcweir bObtainErrorStringOnly,
483cdf0e10cSrcweir bHasErrorString,
484cdf0e10cSrcweir rErrorString);
485cdf0e10cSrcweir return true;
486cdf0e10cSrcweir }
487cdf0e10cSrcweir
488cdf0e10cSrcweir ucb::NameClashException aNCException;
489cdf0e10cSrcweir if (aAnyRequest >>= aNCException)
490cdf0e10cSrcweir {
491cdf0e10cSrcweir ErrCode nErrorCode = ERRCODE_UUI_IO_TARGETALREADYEXISTS;
492cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
493cdf0e10cSrcweir
494cdf0e10cSrcweir if( aNCException.Name.getLength() )
495cdf0e10cSrcweir {
496cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_IO_ALREADYEXISTS;
497cdf0e10cSrcweir aArguments.push_back( aNCException.Name );
498cdf0e10cSrcweir }
499cdf0e10cSrcweir
500cdf0e10cSrcweir handleErrorHandlerRequest( aNCException.Classification,
501cdf0e10cSrcweir nErrorCode,
502cdf0e10cSrcweir aArguments,
503cdf0e10cSrcweir rRequest->getContinuations(),
504cdf0e10cSrcweir bObtainErrorStringOnly,
505cdf0e10cSrcweir bHasErrorString,
506cdf0e10cSrcweir rErrorString);
507cdf0e10cSrcweir return true;
508cdf0e10cSrcweir }
509cdf0e10cSrcweir
510cdf0e10cSrcweir ucb::UnsupportedNameClashException aUORequest;
511cdf0e10cSrcweir if (aAnyRequest >>= aUORequest)
512cdf0e10cSrcweir {
513cdf0e10cSrcweir ErrCode nErrorCode = ERRCODE_UUI_IO_UNSUPPORTEDOVERWRITE;
514cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
515cdf0e10cSrcweir
516cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove;
517cdf0e10cSrcweir uno::Reference< task::XInteractionDisapprove > xDisapprove;
518cdf0e10cSrcweir getContinuations(
519cdf0e10cSrcweir rRequest->getContinuations(), &xApprove, &xDisapprove);
520cdf0e10cSrcweir
521cdf0e10cSrcweir if ( xApprove.is() && xDisapprove.is() )
522cdf0e10cSrcweir {
523cdf0e10cSrcweir handleErrorHandlerRequest( task::InteractionClassification_QUERY,
524cdf0e10cSrcweir nErrorCode,
525cdf0e10cSrcweir aArguments,
526cdf0e10cSrcweir rRequest->getContinuations(),
527cdf0e10cSrcweir bObtainErrorStringOnly,
528cdf0e10cSrcweir bHasErrorString,
529cdf0e10cSrcweir rErrorString);
530cdf0e10cSrcweir }
531cdf0e10cSrcweir return true;
532cdf0e10cSrcweir }
533cdf0e10cSrcweir
534cdf0e10cSrcweir if ( handleInteractiveIOException( rRequest,
535cdf0e10cSrcweir bObtainErrorStringOnly,
536cdf0e10cSrcweir bHasErrorString,
537cdf0e10cSrcweir rErrorString ) )
538cdf0e10cSrcweir return true;
539cdf0e10cSrcweir
540cdf0e10cSrcweir ucb::InteractiveAppException aAppException;
541cdf0e10cSrcweir if (aAnyRequest >>= aAppException)
542cdf0e10cSrcweir {
543cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
544cdf0e10cSrcweir handleErrorHandlerRequest( aAppException.Classification,
545cdf0e10cSrcweir aAppException.Code,
546cdf0e10cSrcweir aArguments,
547cdf0e10cSrcweir rRequest->getContinuations(),
548cdf0e10cSrcweir bObtainErrorStringOnly,
549cdf0e10cSrcweir bHasErrorString,
550cdf0e10cSrcweir rErrorString);
551cdf0e10cSrcweir return true;
552cdf0e10cSrcweir }
553cdf0e10cSrcweir
554cdf0e10cSrcweir ucb::InteractiveNetworkException aNetworkException;
555cdf0e10cSrcweir if (aAnyRequest >>= aNetworkException)
556cdf0e10cSrcweir {
557cdf0e10cSrcweir ErrCode nErrorCode;
558cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
559cdf0e10cSrcweir ucb::InteractiveNetworkOffLineException aOffLineException;
560cdf0e10cSrcweir ucb::InteractiveNetworkResolveNameException aResolveNameException;
561cdf0e10cSrcweir ucb::InteractiveNetworkConnectException aConnectException;
562cdf0e10cSrcweir ucb::InteractiveNetworkReadException aReadException;
563cdf0e10cSrcweir ucb::InteractiveNetworkWriteException aWriteException;
564cdf0e10cSrcweir if (aAnyRequest >>= aOffLineException)
565cdf0e10cSrcweir nErrorCode = ERRCODE_INET_OFFLINE;
566cdf0e10cSrcweir else if (aAnyRequest >>= aResolveNameException)
567cdf0e10cSrcweir {
568cdf0e10cSrcweir nErrorCode = ERRCODE_INET_NAME_RESOLVE;
569cdf0e10cSrcweir aArguments.push_back(aResolveNameException.Server);
570cdf0e10cSrcweir }
571cdf0e10cSrcweir else if (aAnyRequest >>= aConnectException)
572cdf0e10cSrcweir {
573cdf0e10cSrcweir nErrorCode = ERRCODE_INET_CONNECT;
574cdf0e10cSrcweir aArguments.push_back(aConnectException.Server);
575cdf0e10cSrcweir }
576cdf0e10cSrcweir else if (aAnyRequest >>= aReadException)
577cdf0e10cSrcweir {
578cdf0e10cSrcweir nErrorCode = ERRCODE_INET_READ;
579cdf0e10cSrcweir aArguments.push_back(aReadException.Diagnostic);
580cdf0e10cSrcweir }
581cdf0e10cSrcweir else if (aAnyRequest >>= aWriteException)
582cdf0e10cSrcweir {
583cdf0e10cSrcweir nErrorCode = ERRCODE_INET_WRITE;
584cdf0e10cSrcweir aArguments.push_back(aWriteException.Diagnostic);
585cdf0e10cSrcweir }
586cdf0e10cSrcweir else
587cdf0e10cSrcweir nErrorCode = ERRCODE_INET_GENERAL;
588cdf0e10cSrcweir
589cdf0e10cSrcweir handleErrorHandlerRequest(aNetworkException.Classification,
590cdf0e10cSrcweir nErrorCode,
591cdf0e10cSrcweir aArguments,
592cdf0e10cSrcweir rRequest->getContinuations(),
593cdf0e10cSrcweir bObtainErrorStringOnly,
594cdf0e10cSrcweir bHasErrorString,
595cdf0e10cSrcweir rErrorString);
596cdf0e10cSrcweir return true;
597cdf0e10cSrcweir }
598cdf0e10cSrcweir
599cdf0e10cSrcweir ucb::InteractiveCHAOSException aChaosException;
600cdf0e10cSrcweir if (aAnyRequest >>= aChaosException)
601cdf0e10cSrcweir {
602cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
603cdf0e10cSrcweir sal_Int32 nCount
604cdf0e10cSrcweir = std::min< sal_Int32 >(aChaosException.Arguments.getLength(),
605cdf0e10cSrcweir 2);
606cdf0e10cSrcweir aArguments.
607cdf0e10cSrcweir reserve(static_cast< std::vector< rtl::OUString >::size_type >(
608cdf0e10cSrcweir nCount));
609cdf0e10cSrcweir for (sal_Int32 i = 0; i < nCount; ++i)
610cdf0e10cSrcweir aArguments.push_back(aChaosException.Arguments[i]);
611cdf0e10cSrcweir handleErrorHandlerRequest(aChaosException.Classification,
612cdf0e10cSrcweir aChaosException.ID,
613cdf0e10cSrcweir aArguments,
614cdf0e10cSrcweir rRequest->getContinuations(),
615cdf0e10cSrcweir bObtainErrorStringOnly,
616cdf0e10cSrcweir bHasErrorString,
617cdf0e10cSrcweir rErrorString);
618cdf0e10cSrcweir return true;
619cdf0e10cSrcweir }
620cdf0e10cSrcweir
621cdf0e10cSrcweir ucb::InteractiveWrongMediumException aWrongMediumException;
622cdf0e10cSrcweir if (aAnyRequest >>= aWrongMediumException)
623cdf0e10cSrcweir {
624cdf0e10cSrcweir sal_Int32 nMedium = 0;
625cdf0e10cSrcweir aWrongMediumException.Medium >>= nMedium;
626cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
627cdf0e10cSrcweir aArguments.push_back(UniString::CreateFromInt32(nMedium + 1));
628cdf0e10cSrcweir handleErrorHandlerRequest(aWrongMediumException.Classification,
629cdf0e10cSrcweir ERRCODE_UUI_WRONGMEDIUM,
630cdf0e10cSrcweir aArguments,
631cdf0e10cSrcweir rRequest->getContinuations(),
632cdf0e10cSrcweir bObtainErrorStringOnly,
633cdf0e10cSrcweir bHasErrorString,
634cdf0e10cSrcweir rErrorString);
635cdf0e10cSrcweir return true;
636cdf0e10cSrcweir }
637cdf0e10cSrcweir
638cdf0e10cSrcweir java::WrongJavaVersionException aWrongJavaVersionException;
639cdf0e10cSrcweir if (aAnyRequest >>= aWrongJavaVersionException)
640cdf0e10cSrcweir {
641cdf0e10cSrcweir ErrCode nErrorCode;
642cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
643cdf0e10cSrcweir if (aWrongJavaVersionException.DetectedVersion.getLength() == 0)
644cdf0e10cSrcweir if (aWrongJavaVersionException.LowestSupportedVersion.
645cdf0e10cSrcweir getLength()
646cdf0e10cSrcweir == 0)
647cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_WRONGJAVA;
648cdf0e10cSrcweir else
649cdf0e10cSrcweir {
650cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_WRONGJAVA_MIN;
651cdf0e10cSrcweir aArguments.push_back(aWrongJavaVersionException.
652cdf0e10cSrcweir LowestSupportedVersion);
653cdf0e10cSrcweir }
654cdf0e10cSrcweir else if (aWrongJavaVersionException.LowestSupportedVersion.
655cdf0e10cSrcweir getLength()
656cdf0e10cSrcweir == 0)
657cdf0e10cSrcweir {
658cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_WRONGJAVA_VERSION;
659cdf0e10cSrcweir aArguments.push_back(aWrongJavaVersionException.
660cdf0e10cSrcweir DetectedVersion);
661cdf0e10cSrcweir }
662cdf0e10cSrcweir else
663cdf0e10cSrcweir {
664cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_WRONGJAVA_VERSION_MIN;
665cdf0e10cSrcweir aArguments.reserve(2);
666cdf0e10cSrcweir aArguments.push_back(aWrongJavaVersionException.
667cdf0e10cSrcweir DetectedVersion);
668cdf0e10cSrcweir aArguments.push_back(aWrongJavaVersionException.
669cdf0e10cSrcweir LowestSupportedVersion);
670cdf0e10cSrcweir }
671cdf0e10cSrcweir handleErrorHandlerRequest(task::InteractionClassification_ERROR,
672cdf0e10cSrcweir nErrorCode,
673cdf0e10cSrcweir aArguments,
674cdf0e10cSrcweir rRequest->getContinuations(),
675cdf0e10cSrcweir bObtainErrorStringOnly,
676cdf0e10cSrcweir bHasErrorString,
677cdf0e10cSrcweir rErrorString);
678cdf0e10cSrcweir return true;
679cdf0e10cSrcweir }
680cdf0e10cSrcweir
681cdf0e10cSrcweir sync2::BadPartnershipException aBadPartnershipException;
682cdf0e10cSrcweir if (aAnyRequest >>= aBadPartnershipException)
683cdf0e10cSrcweir {
684cdf0e10cSrcweir ErrCode nErrorCode;
685cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
686cdf0e10cSrcweir if (aBadPartnershipException.Partnership.getLength() == 0)
687cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_BADPARTNERSHIP;
688cdf0e10cSrcweir else
689cdf0e10cSrcweir {
690cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_BADPARTNERSHIP_NAME;
691cdf0e10cSrcweir aArguments.push_back(aBadPartnershipException.Partnership);
692cdf0e10cSrcweir }
693cdf0e10cSrcweir handleErrorHandlerRequest(task::InteractionClassification_ERROR,
694cdf0e10cSrcweir nErrorCode,
695cdf0e10cSrcweir aArguments,
696cdf0e10cSrcweir rRequest->getContinuations(),
697cdf0e10cSrcweir bObtainErrorStringOnly,
698cdf0e10cSrcweir bHasErrorString,
699cdf0e10cSrcweir rErrorString);
700cdf0e10cSrcweir return true;
701cdf0e10cSrcweir }
702cdf0e10cSrcweir
703cdf0e10cSrcweir configuration::backend::MergeRecoveryRequest aMergeRecoveryRequest;
704cdf0e10cSrcweir if (aAnyRequest >>= aMergeRecoveryRequest)
705cdf0e10cSrcweir {
706cdf0e10cSrcweir ErrCode nErrorCode = aMergeRecoveryRequest.IsRemovalRequest
707cdf0e10cSrcweir ? ERRCODE_UUI_CONFIGURATION_BROKENDATA_WITHREMOVE
708cdf0e10cSrcweir : ERRCODE_UUI_CONFIGURATION_BROKENDATA_NOREMOVE;
709cdf0e10cSrcweir
710cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
711cdf0e10cSrcweir aArguments.push_back(aMergeRecoveryRequest.ErrorLayerId);
712cdf0e10cSrcweir
713cdf0e10cSrcweir handleErrorHandlerRequest(task::InteractionClassification_ERROR,
714cdf0e10cSrcweir nErrorCode,
715cdf0e10cSrcweir aArguments,
716cdf0e10cSrcweir rRequest->getContinuations(),
717cdf0e10cSrcweir bObtainErrorStringOnly,
718cdf0e10cSrcweir bHasErrorString,
719cdf0e10cSrcweir rErrorString);
720cdf0e10cSrcweir return true;
721cdf0e10cSrcweir }
722cdf0e10cSrcweir
723cdf0e10cSrcweir configuration::backend::StratumCreationException
724cdf0e10cSrcweir aStratumCreationException;
725cdf0e10cSrcweir
726cdf0e10cSrcweir if (aAnyRequest >>= aStratumCreationException)
727cdf0e10cSrcweir {
728cdf0e10cSrcweir const ErrCode nErrorCode = ERRCODE_UUI_CONFIGURATION_BACKENDMISSING;
729cdf0e10cSrcweir
730cdf0e10cSrcweir rtl::OUString aStratum = aStratumCreationException.StratumData;
731cdf0e10cSrcweir if (aStratum.getLength() == 0)
732cdf0e10cSrcweir aStratum = aStratumCreationException.StratumService;
733cdf0e10cSrcweir
734cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
735cdf0e10cSrcweir aArguments.push_back(aStratum);
736cdf0e10cSrcweir
737cdf0e10cSrcweir handleErrorHandlerRequest(task::InteractionClassification_ERROR,
738cdf0e10cSrcweir nErrorCode,
739cdf0e10cSrcweir aArguments,
740cdf0e10cSrcweir rRequest->getContinuations(),
741cdf0e10cSrcweir bObtainErrorStringOnly,
742cdf0e10cSrcweir bHasErrorString,
743cdf0e10cSrcweir rErrorString);
744cdf0e10cSrcweir return true;
745cdf0e10cSrcweir }
746cdf0e10cSrcweir
747cdf0e10cSrcweir xforms::InvalidDataOnSubmitException aInvalidDataOnSubmitException;
748cdf0e10cSrcweir if (aAnyRequest >>= aInvalidDataOnSubmitException)
749cdf0e10cSrcweir {
750cdf0e10cSrcweir const ErrCode nErrorCode =
751cdf0e10cSrcweir ERRCODE_UUI_INVALID_XFORMS_SUBMISSION_DATA;
752cdf0e10cSrcweir
753cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
754cdf0e10cSrcweir
755cdf0e10cSrcweir handleErrorHandlerRequest(task::InteractionClassification_QUERY,
756cdf0e10cSrcweir nErrorCode,
757cdf0e10cSrcweir aArguments,
758cdf0e10cSrcweir rRequest->getContinuations(),
759cdf0e10cSrcweir bObtainErrorStringOnly,
760cdf0e10cSrcweir bHasErrorString,
761cdf0e10cSrcweir rErrorString);
762cdf0e10cSrcweir return true;
763cdf0e10cSrcweir }
764cdf0e10cSrcweir
765cdf0e10cSrcweir ucb::InteractiveLockingLockedException aLLException;
766cdf0e10cSrcweir if (aAnyRequest >>= aLLException)
767cdf0e10cSrcweir {
768cdf0e10cSrcweir ErrCode nErrorCode = aLLException.SelfOwned
769cdf0e10cSrcweir ? ERRCODE_UUI_LOCKING_LOCKED_SELF : ERRCODE_UUI_LOCKING_LOCKED;
770cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
771cdf0e10cSrcweir aArguments.push_back( aLLException.Url );
772cdf0e10cSrcweir
773cdf0e10cSrcweir handleErrorHandlerRequest( aLLException.Classification,
774cdf0e10cSrcweir nErrorCode,
775cdf0e10cSrcweir aArguments,
776cdf0e10cSrcweir rRequest->getContinuations(),
777cdf0e10cSrcweir bObtainErrorStringOnly,
778cdf0e10cSrcweir bHasErrorString,
779cdf0e10cSrcweir rErrorString );
780cdf0e10cSrcweir return true;
781cdf0e10cSrcweir }
782cdf0e10cSrcweir
783cdf0e10cSrcweir ucb::InteractiveLockingNotLockedException aLNLException;
784cdf0e10cSrcweir if (aAnyRequest >>= aLNLException)
785cdf0e10cSrcweir {
786cdf0e10cSrcweir ErrCode nErrorCode = ERRCODE_UUI_LOCKING_NOT_LOCKED;
787cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
788cdf0e10cSrcweir aArguments.push_back( aLNLException.Url );
789cdf0e10cSrcweir
790cdf0e10cSrcweir handleErrorHandlerRequest( aLNLException.Classification,
791cdf0e10cSrcweir nErrorCode,
792cdf0e10cSrcweir aArguments,
793cdf0e10cSrcweir rRequest->getContinuations(),
794cdf0e10cSrcweir bObtainErrorStringOnly,
795cdf0e10cSrcweir bHasErrorString,
796cdf0e10cSrcweir rErrorString );
797cdf0e10cSrcweir return true;
798cdf0e10cSrcweir }
799cdf0e10cSrcweir
800cdf0e10cSrcweir ucb::InteractiveLockingLockExpiredException aLLEException;
801cdf0e10cSrcweir if (aAnyRequest >>= aLLEException)
802cdf0e10cSrcweir {
803cdf0e10cSrcweir ErrCode nErrorCode = ERRCODE_UUI_LOCKING_LOCK_EXPIRED;
804cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
805cdf0e10cSrcweir aArguments.push_back( aLLEException.Url );
806cdf0e10cSrcweir
807cdf0e10cSrcweir handleErrorHandlerRequest( aLLEException.Classification,
808cdf0e10cSrcweir nErrorCode,
809cdf0e10cSrcweir aArguments,
810cdf0e10cSrcweir rRequest->getContinuations(),
811cdf0e10cSrcweir bObtainErrorStringOnly,
812cdf0e10cSrcweir bHasErrorString,
813cdf0e10cSrcweir rErrorString );
814cdf0e10cSrcweir return true;
815cdf0e10cSrcweir }
816cdf0e10cSrcweir
817cdf0e10cSrcweir document::BrokenPackageRequest aBrokenPackageRequest;
818cdf0e10cSrcweir if (aAnyRequest >>= aBrokenPackageRequest)
819cdf0e10cSrcweir {
820cdf0e10cSrcweir std::vector< rtl::OUString > aArguments;
821cdf0e10cSrcweir
822cdf0e10cSrcweir if( aBrokenPackageRequest.aName.getLength() )
823cdf0e10cSrcweir aArguments.push_back( aBrokenPackageRequest.aName );
824cdf0e10cSrcweir
825cdf0e10cSrcweir handleBrokenPackageRequest( aArguments,
826cdf0e10cSrcweir rRequest->getContinuations(),
827cdf0e10cSrcweir bObtainErrorStringOnly,
828cdf0e10cSrcweir bHasErrorString,
829cdf0e10cSrcweir rErrorString );
830cdf0e10cSrcweir return true;
831cdf0e10cSrcweir }
832cdf0e10cSrcweir
833cdf0e10cSrcweir task::ErrorCodeRequest aErrorCodeRequest;
834cdf0e10cSrcweir if (aAnyRequest >>= aErrorCodeRequest)
835cdf0e10cSrcweir {
836cdf0e10cSrcweir handleGenericErrorRequest( aErrorCodeRequest.ErrCode,
837cdf0e10cSrcweir rRequest->getContinuations(),
838cdf0e10cSrcweir bObtainErrorStringOnly,
839cdf0e10cSrcweir bHasErrorString,
840cdf0e10cSrcweir rErrorString);
841cdf0e10cSrcweir return true;
842cdf0e10cSrcweir }
843cdf0e10cSrcweir
844cdf0e10cSrcweir task::ErrorCodeIOException aErrorCodeIOException;
845cdf0e10cSrcweir if (aAnyRequest >>= aErrorCodeIOException)
846cdf0e10cSrcweir {
847cdf0e10cSrcweir handleGenericErrorRequest( aErrorCodeIOException.ErrCode,
848cdf0e10cSrcweir rRequest->getContinuations(),
849cdf0e10cSrcweir bObtainErrorStringOnly,
850cdf0e10cSrcweir bHasErrorString,
851cdf0e10cSrcweir rErrorString);
852cdf0e10cSrcweir return true;
853cdf0e10cSrcweir }
854cdf0e10cSrcweir
855cdf0e10cSrcweir
856cdf0e10cSrcweir ///////////////////////////////////////////////////////////////////
857cdf0e10cSrcweir // Handle requests which do not have a plain string representation.
858cdf0e10cSrcweir ///////////////////////////////////////////////////////////////////
859cdf0e10cSrcweir if (!bObtainErrorStringOnly)
860cdf0e10cSrcweir {
861cdf0e10cSrcweir if ( handleAuthenticationRequest( rRequest ) )
862cdf0e10cSrcweir return true;
863cdf0e10cSrcweir
864cdf0e10cSrcweir if ( handleCertificateValidationRequest( rRequest ) )
865cdf0e10cSrcweir return true;
866cdf0e10cSrcweir
867cdf0e10cSrcweir ucb::NameClashResolveRequest aNameClashResolveRequest;
868cdf0e10cSrcweir if (aAnyRequest >>= aNameClashResolveRequest)
869cdf0e10cSrcweir {
870cdf0e10cSrcweir handleNameClashResolveRequest(aNameClashResolveRequest,
871cdf0e10cSrcweir rRequest->getContinuations());
872cdf0e10cSrcweir return true;
873cdf0e10cSrcweir }
874cdf0e10cSrcweir
875cdf0e10cSrcweir if ( handleMasterPasswordRequest( rRequest ) )
876cdf0e10cSrcweir return true;
877cdf0e10cSrcweir
878cdf0e10cSrcweir if ( handlePasswordRequest( rRequest ) )
879cdf0e10cSrcweir return true;
880cdf0e10cSrcweir
881cdf0e10cSrcweir if ( handleCookiesRequest( rRequest ) )
882cdf0e10cSrcweir return true;
883cdf0e10cSrcweir
884cdf0e10cSrcweir if ( handleNoSuchFilterRequest( rRequest ) )
885cdf0e10cSrcweir return true;
886cdf0e10cSrcweir
887cdf0e10cSrcweir if ( handleAmbigousFilterRequest( rRequest ) )
888cdf0e10cSrcweir return true;
889cdf0e10cSrcweir
890cdf0e10cSrcweir if ( handleFilterOptionsRequest( rRequest ) )
891cdf0e10cSrcweir return true;
892cdf0e10cSrcweir
893cdf0e10cSrcweir if ( handleLockedDocumentRequest( rRequest ) )
894cdf0e10cSrcweir return true;
895cdf0e10cSrcweir
896cdf0e10cSrcweir if ( handleChangedByOthersRequest( rRequest ) )
897cdf0e10cSrcweir return true;
898cdf0e10cSrcweir
899cdf0e10cSrcweir if ( handleLockFileIgnoreRequest( rRequest ) )
900cdf0e10cSrcweir return true;
901cdf0e10cSrcweir
902cdf0e10cSrcweir task::DocumentMacroConfirmationRequest aMacroConfirmRequest;
903cdf0e10cSrcweir if (aAnyRequest >>= aMacroConfirmRequest)
904cdf0e10cSrcweir {
905cdf0e10cSrcweir handleMacroConfirmRequest(
906cdf0e10cSrcweir aMacroConfirmRequest.DocumentURL,
907cdf0e10cSrcweir aMacroConfirmRequest.DocumentStorage,
908cdf0e10cSrcweir aMacroConfirmRequest.DocumentVersion.getLength() ? aMacroConfirmRequest.DocumentVersion : ODFVER_012_TEXT,
909cdf0e10cSrcweir aMacroConfirmRequest.DocumentSignatureInformation,
910cdf0e10cSrcweir rRequest->getContinuations());
911cdf0e10cSrcweir return true;
912cdf0e10cSrcweir }
913cdf0e10cSrcweir
914cdf0e10cSrcweir task::FutureDocumentVersionProductUpdateRequest
915cdf0e10cSrcweir aProductUpdateRequest;
916cdf0e10cSrcweir if (aAnyRequest >>= aProductUpdateRequest)
917cdf0e10cSrcweir {
918cdf0e10cSrcweir handleFutureDocumentVersionUpdateRequest(
919cdf0e10cSrcweir aProductUpdateRequest,
920cdf0e10cSrcweir rRequest->getContinuations());
921cdf0e10cSrcweir return true;
922cdf0e10cSrcweir }
923cdf0e10cSrcweir
924cdf0e10cSrcweir ///////////////////////////////////////////////////////////////
925cdf0e10cSrcweir // Last chance: interaction handlers registered in the configuration
926cdf0e10cSrcweir ///////////////////////////////////////////////////////////////
927cdf0e10cSrcweir
928cdf0e10cSrcweir // typed InteractionHandlers (ooo.Interactions)
929cdf0e10cSrcweir if ( handleTypedHandlerImplementations( rRequest ) )
930cdf0e10cSrcweir return true;
931cdf0e10cSrcweir
932cdf0e10cSrcweir // legacy configuration (ooo.ucb.InteractionHandlers)
933cdf0e10cSrcweir if (tryOtherInteractionHandler( rRequest ))
934cdf0e10cSrcweir return true;
935cdf0e10cSrcweir }
936cdf0e10cSrcweir
937cdf0e10cSrcweir // Not handled.
938cdf0e10cSrcweir return false;
939cdf0e10cSrcweir }
940cdf0e10cSrcweir catch (std::bad_alloc const &)
941cdf0e10cSrcweir {
942cdf0e10cSrcweir throw uno::RuntimeException(
943cdf0e10cSrcweir rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("out of memory")),
944cdf0e10cSrcweir uno::Reference< uno::XInterface >());
945cdf0e10cSrcweir }
946cdf0e10cSrcweir catch( const uno::RuntimeException& )
947cdf0e10cSrcweir {
948cdf0e10cSrcweir throw; // allowed to leave here
949cdf0e10cSrcweir }
950cdf0e10cSrcweir catch( const uno::Exception& )
951cdf0e10cSrcweir {
952cdf0e10cSrcweir DBG_UNHANDLED_EXCEPTION();
953cdf0e10cSrcweir }
954cdf0e10cSrcweir return false;
955cdf0e10cSrcweir }
956cdf0e10cSrcweir
957cdf0e10cSrcweir void
getInteractionHandlerList(InteractionHandlerDataList & rdataList)958cdf0e10cSrcweir UUIInteractionHelper::getInteractionHandlerList(
959cdf0e10cSrcweir InteractionHandlerDataList &rdataList)
960cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
961cdf0e10cSrcweir {
962cdf0e10cSrcweir try
963cdf0e10cSrcweir {
964cdf0e10cSrcweir uno::Reference< lang::XMultiServiceFactory > xConfigProv(
965cdf0e10cSrcweir m_xServiceFactory->createInstance(
966cdf0e10cSrcweir rtl::OUString::createFromAscii(
967cdf0e10cSrcweir "com.sun.star.configuration.ConfigurationProvider" ) ),
968cdf0e10cSrcweir uno::UNO_QUERY );
969cdf0e10cSrcweir
970cdf0e10cSrcweir if ( !xConfigProv.is() )
971cdf0e10cSrcweir throw uno::RuntimeException(
972cdf0e10cSrcweir rtl::OUString(
973cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
974cdf0e10cSrcweir "unable to instanciate config provider service")),
975cdf0e10cSrcweir uno::Reference< uno::XInterface >());
976cdf0e10cSrcweir
977cdf0e10cSrcweir rtl::OUStringBuffer aFullPath;
978cdf0e10cSrcweir aFullPath.appendAscii(
979cdf0e10cSrcweir "/org.openoffice.ucb.InteractionHandler/InteractionHandlers" );
980cdf0e10cSrcweir
981cdf0e10cSrcweir uno::Sequence< uno::Any > aArguments( 1 );
982cdf0e10cSrcweir beans::PropertyValue aProperty;
983cdf0e10cSrcweir aProperty.Name
984cdf0e10cSrcweir = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ) );
985cdf0e10cSrcweir aProperty.Value <<= aFullPath.makeStringAndClear();
986cdf0e10cSrcweir aArguments[ 0 ] <<= aProperty;
987cdf0e10cSrcweir
988cdf0e10cSrcweir uno::Reference< uno::XInterface > xInterface(
989cdf0e10cSrcweir xConfigProv->createInstanceWithArguments(
990cdf0e10cSrcweir rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
991cdf0e10cSrcweir "com.sun.star.configuration.ConfigurationAccess" ) ),
992cdf0e10cSrcweir aArguments ) );
993cdf0e10cSrcweir
994cdf0e10cSrcweir if ( !xInterface.is() )
995cdf0e10cSrcweir throw uno::RuntimeException(
996cdf0e10cSrcweir rtl::OUString(
997cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
998cdf0e10cSrcweir "unable to instanciate config access")),
999cdf0e10cSrcweir uno::Reference< uno::XInterface >());
1000cdf0e10cSrcweir
1001cdf0e10cSrcweir uno::Reference< container::XNameAccess > xNameAccess(
1002cdf0e10cSrcweir xInterface, uno::UNO_QUERY );
1003cdf0e10cSrcweir if ( !xNameAccess.is() )
1004cdf0e10cSrcweir throw uno::RuntimeException(
1005cdf0e10cSrcweir rtl::OUString(
1006cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
1007cdf0e10cSrcweir "config access does not implement XNameAccess")),
1008cdf0e10cSrcweir uno::Reference< uno::XInterface >());
1009cdf0e10cSrcweir
1010cdf0e10cSrcweir uno::Sequence< rtl::OUString > aElems = xNameAccess->getElementNames();
1011cdf0e10cSrcweir const rtl::OUString* pElems = aElems.getConstArray();
1012cdf0e10cSrcweir sal_Int32 nCount = aElems.getLength();
1013cdf0e10cSrcweir
1014cdf0e10cSrcweir if ( nCount > 0 )
1015cdf0e10cSrcweir {
1016cdf0e10cSrcweir uno::Reference< container::XHierarchicalNameAccess >
1017cdf0e10cSrcweir xHierNameAccess( xInterface, uno::UNO_QUERY );
1018cdf0e10cSrcweir
1019cdf0e10cSrcweir if ( !xHierNameAccess.is() )
1020cdf0e10cSrcweir throw uno::RuntimeException(
1021cdf0e10cSrcweir rtl::OUString(
1022cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
1023cdf0e10cSrcweir "config access does not implement XHierarchicalNameAccess")),
1024cdf0e10cSrcweir uno::Reference< uno::XInterface >());
1025cdf0e10cSrcweir
1026cdf0e10cSrcweir // Iterate over children.
1027cdf0e10cSrcweir for ( sal_Int32 n = 0; n < nCount; ++n )
1028cdf0e10cSrcweir {
1029cdf0e10cSrcweir rtl::OUStringBuffer aElemBuffer;
1030cdf0e10cSrcweir aElemBuffer.appendAscii( "['" );
1031cdf0e10cSrcweir aElemBuffer.append( pElems[ n ] );
1032cdf0e10cSrcweir
1033cdf0e10cSrcweir try
1034cdf0e10cSrcweir {
1035cdf0e10cSrcweir InteractionHandlerData aInfo;
1036cdf0e10cSrcweir
1037cdf0e10cSrcweir // Obtain service name.
1038cdf0e10cSrcweir rtl::OUStringBuffer aKeyBuffer = aElemBuffer;
1039cdf0e10cSrcweir aKeyBuffer.appendAscii( "']/ServiceName" );
1040cdf0e10cSrcweir
1041cdf0e10cSrcweir rtl::OUString aValue;
1042cdf0e10cSrcweir if ( !( xHierNameAccess->getByHierarchicalName(
1043cdf0e10cSrcweir aKeyBuffer.makeStringAndClear() ) >>= aValue ) )
1044cdf0e10cSrcweir {
1045cdf0e10cSrcweir OSL_ENSURE( false,
1046cdf0e10cSrcweir "GetInteractionHandlerList - "
1047cdf0e10cSrcweir "Error getting item value!" );
1048cdf0e10cSrcweir continue;
1049cdf0e10cSrcweir }
1050cdf0e10cSrcweir
1051cdf0e10cSrcweir aInfo.ServiceName = aValue;
1052cdf0e10cSrcweir
1053cdf0e10cSrcweir // Append info to list.
1054cdf0e10cSrcweir rdataList.push_back( aInfo );
1055cdf0e10cSrcweir }
1056cdf0e10cSrcweir catch ( container::NoSuchElementException& )
1057cdf0e10cSrcweir {
1058cdf0e10cSrcweir // getByHierarchicalName
1059cdf0e10cSrcweir
1060cdf0e10cSrcweir OSL_ENSURE( false,
1061cdf0e10cSrcweir "GetInteractionHandlerList - "
1062cdf0e10cSrcweir "caught NoSuchElementException!" );
1063cdf0e10cSrcweir }
1064cdf0e10cSrcweir }
1065cdf0e10cSrcweir }
1066cdf0e10cSrcweir }
1067cdf0e10cSrcweir catch ( uno::RuntimeException const & )
1068cdf0e10cSrcweir {
1069cdf0e10cSrcweir throw;
1070cdf0e10cSrcweir }
1071cdf0e10cSrcweir catch ( uno::Exception const & )
1072cdf0e10cSrcweir {
1073cdf0e10cSrcweir OSL_ENSURE( false, "GetInteractionHandlerList - Caught Exception!" );
1074cdf0e10cSrcweir }
1075cdf0e10cSrcweir }
1076cdf0e10cSrcweir
1077cdf0e10cSrcweir Window *
getParentProperty()1078cdf0e10cSrcweir UUIInteractionHelper::getParentProperty()
1079cdf0e10cSrcweir SAL_THROW(())
1080cdf0e10cSrcweir {
1081cdf0e10cSrcweir uno::Reference< awt::XWindow > xWindow = getParentXWindow();
1082cdf0e10cSrcweir if ( xWindow.is() )
1083cdf0e10cSrcweir return VCLUnoHelper::GetWindow(xWindow);
1084cdf0e10cSrcweir
1085cdf0e10cSrcweir return 0;
1086cdf0e10cSrcweir }
1087cdf0e10cSrcweir
1088cdf0e10cSrcweir uno::Reference< awt::XWindow>
getParentXWindow() const1089cdf0e10cSrcweir UUIInteractionHelper::getParentXWindow() const
1090cdf0e10cSrcweir SAL_THROW(())
1091cdf0e10cSrcweir {
1092cdf0e10cSrcweir osl::MutexGuard aGuard(m_aPropertyMutex);
1093cdf0e10cSrcweir ::comphelper::NamedValueCollection aProperties( m_aProperties );
1094cdf0e10cSrcweir if ( aProperties.has( "Parent" ) )
1095cdf0e10cSrcweir {
1096cdf0e10cSrcweir uno::Reference< awt::XWindow > xWindow;
1097cdf0e10cSrcweir OSL_VERIFY( aProperties.get( "Parent" ) >>= xWindow );
1098cdf0e10cSrcweir return xWindow;
1099cdf0e10cSrcweir }
1100cdf0e10cSrcweir return 0;
1101cdf0e10cSrcweir }
1102cdf0e10cSrcweir
1103cdf0e10cSrcweir rtl::OUString
getContextProperty()1104cdf0e10cSrcweir UUIInteractionHelper::getContextProperty()
1105cdf0e10cSrcweir SAL_THROW(())
1106cdf0e10cSrcweir {
1107cdf0e10cSrcweir osl::MutexGuard aGuard(m_aPropertyMutex);
1108cdf0e10cSrcweir for (sal_Int32 i = 0; i < m_aProperties.getLength(); ++i)
1109cdf0e10cSrcweir {
1110cdf0e10cSrcweir beans::PropertyValue aProperty;
1111cdf0e10cSrcweir if ((m_aProperties[i] >>= aProperty)
1112cdf0e10cSrcweir && aProperty.
1113cdf0e10cSrcweir Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("Context")))
1114cdf0e10cSrcweir {
1115cdf0e10cSrcweir rtl::OUString aContext;
1116cdf0e10cSrcweir aProperty.Value >>= aContext;
1117cdf0e10cSrcweir return aContext;
1118cdf0e10cSrcweir }
1119cdf0e10cSrcweir }
1120cdf0e10cSrcweir return rtl::OUString();
1121cdf0e10cSrcweir }
1122cdf0e10cSrcweir
1123cdf0e10cSrcweir uno::Reference< task::XInteractionHandler >
getInteractionHandler()1124cdf0e10cSrcweir UUIInteractionHelper::getInteractionHandler()
1125cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1126cdf0e10cSrcweir {
1127cdf0e10cSrcweir uno::Reference< task::XInteractionHandler > xIH;
1128cdf0e10cSrcweir try
1129cdf0e10cSrcweir {
1130cdf0e10cSrcweir xIH.set(m_xServiceFactory->createInstanceWithArguments(
1131cdf0e10cSrcweir rtl::OUString(
1132cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
1133cdf0e10cSrcweir "com.sun.star.task.InteractionHandler")),
1134cdf0e10cSrcweir m_aProperties),
1135cdf0e10cSrcweir uno::UNO_QUERY);
1136cdf0e10cSrcweir }
1137cdf0e10cSrcweir catch (uno::Exception const &)
1138cdf0e10cSrcweir {}
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir if (!xIH.is())
1141cdf0e10cSrcweir throw uno::RuntimeException(
1142cdf0e10cSrcweir rtl::OUString(
1143cdf0e10cSrcweir RTL_CONSTASCII_USTRINGPARAM(
1144cdf0e10cSrcweir "unable to instanciate Interaction Handler service")),
1145cdf0e10cSrcweir uno::Reference< uno::XInterface >());
1146cdf0e10cSrcweir return xIH;
1147cdf0e10cSrcweir }
1148cdf0e10cSrcweir
1149cdf0e10cSrcweir namespace {
1150cdf0e10cSrcweir
1151cdf0e10cSrcweir sal_uInt16
executeMessageBox(Window * pParent,rtl::OUString const & rTitle,rtl::OUString const & rMessage,WinBits nButtonMask)1152cdf0e10cSrcweir executeMessageBox(
1153cdf0e10cSrcweir Window * pParent,
1154cdf0e10cSrcweir rtl::OUString const & rTitle,
1155cdf0e10cSrcweir rtl::OUString const & rMessage,
1156cdf0e10cSrcweir WinBits nButtonMask )
1157cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1158cdf0e10cSrcweir {
1159cdf0e10cSrcweir vos::OGuard aGuard(Application::GetSolarMutex());
1160cdf0e10cSrcweir
1161cdf0e10cSrcweir MessBox xBox( pParent, nButtonMask, rTitle, rMessage );
1162cdf0e10cSrcweir
1163cdf0e10cSrcweir sal_uInt16 aResult = xBox.Execute();
1164cdf0e10cSrcweir switch( aResult )
1165cdf0e10cSrcweir {
1166cdf0e10cSrcweir case BUTTONID_OK:
1167cdf0e10cSrcweir aResult = ERRCODE_BUTTON_OK;
1168cdf0e10cSrcweir break;
1169cdf0e10cSrcweir case BUTTONID_CANCEL:
1170cdf0e10cSrcweir aResult = ERRCODE_BUTTON_CANCEL;
1171cdf0e10cSrcweir break;
1172cdf0e10cSrcweir case BUTTONID_YES:
1173cdf0e10cSrcweir aResult = ERRCODE_BUTTON_YES;
1174cdf0e10cSrcweir break;
1175cdf0e10cSrcweir case BUTTONID_NO:
1176cdf0e10cSrcweir aResult = ERRCODE_BUTTON_NO;
1177cdf0e10cSrcweir break;
1178cdf0e10cSrcweir case BUTTONID_RETRY:
1179cdf0e10cSrcweir aResult = ERRCODE_BUTTON_RETRY;
1180cdf0e10cSrcweir break;
1181cdf0e10cSrcweir }
1182cdf0e10cSrcweir
1183cdf0e10cSrcweir return aResult;
1184cdf0e10cSrcweir }
1185cdf0e10cSrcweir
executeSimpleNameClashResolveDialog(Window * pParent,rtl::OUString const & rTargetFolderURL,rtl::OUString const & rClashingName,rtl::OUString & rProposedNewName,bool bAllowOverwrite)1186cdf0e10cSrcweir NameClashResolveDialogResult executeSimpleNameClashResolveDialog( Window *pParent,
1187cdf0e10cSrcweir rtl::OUString const & rTargetFolderURL,
1188cdf0e10cSrcweir rtl::OUString const & rClashingName,
1189cdf0e10cSrcweir rtl::OUString & rProposedNewName,
1190cdf0e10cSrcweir bool bAllowOverwrite )
1191cdf0e10cSrcweir {
1192cdf0e10cSrcweir std::auto_ptr< ResMgr > xManager( ResMgr::CreateResMgr( CREATEVERSIONRESMGR_NAME( uui ) ) );
1193cdf0e10cSrcweir if ( !xManager.get() )
1194cdf0e10cSrcweir return ABORT;
1195cdf0e10cSrcweir
1196cdf0e10cSrcweir NameClashDialog aDialog( pParent, xManager.get(), rTargetFolderURL,
1197cdf0e10cSrcweir rClashingName, rProposedNewName, bAllowOverwrite );
1198cdf0e10cSrcweir
1199cdf0e10cSrcweir NameClashResolveDialogResult eResult = (NameClashResolveDialogResult) aDialog.Execute();
1200cdf0e10cSrcweir rProposedNewName = aDialog.getNewName();
1201cdf0e10cSrcweir return eResult;
1202cdf0e10cSrcweir }
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir } // namespace
1205cdf0e10cSrcweir
1206cdf0e10cSrcweir void
handleNameClashResolveRequest(ucb::NameClashResolveRequest const & rRequest,uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations)1207cdf0e10cSrcweir UUIInteractionHelper::handleNameClashResolveRequest(
1208cdf0e10cSrcweir ucb::NameClashResolveRequest const & rRequest,
1209cdf0e10cSrcweir uno::Sequence< uno::Reference<
1210cdf0e10cSrcweir task::XInteractionContinuation > > const & rContinuations)
1211cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1212cdf0e10cSrcweir {
1213cdf0e10cSrcweir OSL_ENSURE(
1214cdf0e10cSrcweir rRequest.TargetFolderURL.getLength() > 0,
1215cdf0e10cSrcweir "NameClashResolveRequest must not contain empty TargetFolderURL" );
1216cdf0e10cSrcweir
1217cdf0e10cSrcweir OSL_ENSURE(
1218cdf0e10cSrcweir rRequest.ClashingName.getLength() > 0,
1219cdf0e10cSrcweir "NameClashResolveRequest must not contain empty ClashingName" );
1220cdf0e10cSrcweir
1221cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort;
1222cdf0e10cSrcweir uno::Reference< ucb::XInteractionSupplyName > xSupplyName;
1223cdf0e10cSrcweir uno::Reference< ucb::XInteractionReplaceExistingData > xReplaceExistingData;
1224cdf0e10cSrcweir getContinuations(
1225cdf0e10cSrcweir rContinuations, &xAbort, &xSupplyName, &xReplaceExistingData);
1226cdf0e10cSrcweir
1227cdf0e10cSrcweir OSL_ENSURE( xAbort.is(),
1228cdf0e10cSrcweir "NameClashResolveRequest must contain Abort continuation" );
1229cdf0e10cSrcweir
1230cdf0e10cSrcweir OSL_ENSURE( xSupplyName.is(),
1231cdf0e10cSrcweir "NameClashResolveRequest must contain SupplyName continuation" );
1232cdf0e10cSrcweir
1233cdf0e10cSrcweir NameClashResolveDialogResult eResult = ABORT;
1234cdf0e10cSrcweir rtl::OUString aProposedNewName( rRequest.ProposedNewName );
1235cdf0e10cSrcweir
1236cdf0e10cSrcweir eResult = executeSimpleNameClashResolveDialog( getParentProperty(),
1237cdf0e10cSrcweir rRequest.TargetFolderURL,
1238cdf0e10cSrcweir rRequest.ClashingName,
1239cdf0e10cSrcweir aProposedNewName,
1240cdf0e10cSrcweir xReplaceExistingData.is() );
1241cdf0e10cSrcweir
1242cdf0e10cSrcweir switch ( eResult )
1243cdf0e10cSrcweir {
1244cdf0e10cSrcweir case ABORT:
1245cdf0e10cSrcweir xAbort->select();
1246cdf0e10cSrcweir break;
1247cdf0e10cSrcweir
1248cdf0e10cSrcweir case RENAME:
1249cdf0e10cSrcweir xSupplyName->setName( aProposedNewName );
1250cdf0e10cSrcweir xSupplyName->select();
1251cdf0e10cSrcweir break;
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir case OVERWRITE:
1254cdf0e10cSrcweir OSL_ENSURE(
1255cdf0e10cSrcweir xReplaceExistingData.is(),
1256cdf0e10cSrcweir "Invalid NameClashResolveDialogResult: OVERWRITE - "
1257cdf0e10cSrcweir "No ReplaceExistingData continuation available!" );
1258cdf0e10cSrcweir xReplaceExistingData->select();
1259cdf0e10cSrcweir break;
1260cdf0e10cSrcweir }
1261cdf0e10cSrcweir }
1262cdf0e10cSrcweir
1263cdf0e10cSrcweir void
handleGenericErrorRequest(sal_Int32 nErrorCode,uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations,bool bObtainErrorStringOnly,bool & bHasErrorString,rtl::OUString & rErrorString)1264cdf0e10cSrcweir UUIInteractionHelper::handleGenericErrorRequest(
1265cdf0e10cSrcweir sal_Int32 nErrorCode,
1266cdf0e10cSrcweir uno::Sequence< uno::Reference<
1267cdf0e10cSrcweir task::XInteractionContinuation > > const & rContinuations,
1268cdf0e10cSrcweir bool bObtainErrorStringOnly,
1269cdf0e10cSrcweir bool & bHasErrorString,
1270cdf0e10cSrcweir rtl::OUString & rErrorString)
1271cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1272cdf0e10cSrcweir {
1273cdf0e10cSrcweir if (bObtainErrorStringOnly)
1274cdf0e10cSrcweir {
1275cdf0e10cSrcweir bHasErrorString = isInformationalErrorMessageRequest(rContinuations);
1276cdf0e10cSrcweir if (bHasErrorString)
1277cdf0e10cSrcweir {
1278cdf0e10cSrcweir String aErrorString;
1279cdf0e10cSrcweir ErrorHandler::GetErrorString(nErrorCode, aErrorString);
1280cdf0e10cSrcweir rErrorString = aErrorString;
1281cdf0e10cSrcweir }
1282cdf0e10cSrcweir }
1283cdf0e10cSrcweir else
1284cdf0e10cSrcweir {
1285cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort;
1286cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove;
1287cdf0e10cSrcweir getContinuations(rContinuations, &xApprove, &xAbort);
1288cdf0e10cSrcweir
1289cdf0e10cSrcweir // Note: It's important to convert the transported long to the
1290cdf0e10cSrcweir // required unsigned long value. Otherwhise using as flag field
1291cdf0e10cSrcweir // can fail ...
1292cdf0e10cSrcweir ErrCode nError = static_cast< ErrCode >(nErrorCode);
1293cdf0e10cSrcweir sal_Bool bWarning = !ERRCODE_TOERROR(nError);
1294cdf0e10cSrcweir
1295cdf0e10cSrcweir if ( nError == ERRCODE_SFX_BROKENSIGNATURE
1296cdf0e10cSrcweir || nError == ERRCODE_SFX_INCOMPLETE_ENCRYPTION )
1297cdf0e10cSrcweir {
1298cdf0e10cSrcweir // the security warning box needs a special title
1299cdf0e10cSrcweir String aErrorString;
1300cdf0e10cSrcweir ErrorHandler::GetErrorString( nErrorCode, aErrorString );
1301cdf0e10cSrcweir
1302cdf0e10cSrcweir std::auto_ptr< ResMgr > xManager(
1303cdf0e10cSrcweir ResMgr::CreateResMgr( CREATEVERSIONRESMGR_NAME( uui ) ) );
1304cdf0e10cSrcweir ::rtl::OUString aTitle;
1305cdf0e10cSrcweir
1306cdf0e10cSrcweir try
1307cdf0e10cSrcweir {
1308cdf0e10cSrcweir uno::Any aProductNameAny =
1309cdf0e10cSrcweir ::utl::ConfigManager::GetConfigManager()
1310cdf0e10cSrcweir ->GetDirectConfigProperty(
1311cdf0e10cSrcweir ::utl::ConfigManager::PRODUCTNAME );
1312cdf0e10cSrcweir aProductNameAny >>= aTitle;
1313cdf0e10cSrcweir }
1314cdf0e10cSrcweir catch( uno::Exception& )
1315cdf0e10cSrcweir {
1316cdf0e10cSrcweir }
1317cdf0e10cSrcweir
1318cdf0e10cSrcweir ::rtl::OUString aErrTitle
1319cdf0e10cSrcweir = String( ResId( nError == ERRCODE_SFX_BROKENSIGNATURE
1320cdf0e10cSrcweir ? STR_WARNING_BROKENSIGNATURE_TITLE
1321cdf0e10cSrcweir : STR_WARNING_INCOMPLETE_ENCRYPTION_TITLE,
1322cdf0e10cSrcweir *xManager.get() ) );
1323cdf0e10cSrcweir
1324cdf0e10cSrcweir if ( aTitle.getLength() && aErrTitle.getLength() )
1325cdf0e10cSrcweir aTitle += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " - " ) );
1326cdf0e10cSrcweir aTitle += aErrTitle;
1327cdf0e10cSrcweir
1328cdf0e10cSrcweir executeMessageBox(
1329cdf0e10cSrcweir getParentProperty(), aTitle, aErrorString, WB_OK );
1330cdf0e10cSrcweir }
1331cdf0e10cSrcweir else
1332cdf0e10cSrcweir ErrorHandler::HandleError(nErrorCode);
1333cdf0e10cSrcweir
1334cdf0e10cSrcweir if (xApprove.is() && bWarning)
1335cdf0e10cSrcweir xApprove->select();
1336cdf0e10cSrcweir else if (xAbort.is())
1337cdf0e10cSrcweir xAbort->select();
1338cdf0e10cSrcweir }
1339cdf0e10cSrcweir }
1340cdf0e10cSrcweir
1341cdf0e10cSrcweir void
handleMacroConfirmRequest(const::rtl::OUString & aDocumentURL,const uno::Reference<embed::XStorage> & xZipStorage,const::rtl::OUString & aDocumentVersion,const uno::Sequence<security::DocumentSignatureInformation> aSignInfo,uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations)1342cdf0e10cSrcweir UUIInteractionHelper::handleMacroConfirmRequest(
1343cdf0e10cSrcweir const ::rtl::OUString& aDocumentURL,
1344cdf0e10cSrcweir const uno::Reference< embed::XStorage >& xZipStorage,
1345cdf0e10cSrcweir const ::rtl::OUString& aDocumentVersion,
1346cdf0e10cSrcweir const uno::Sequence< security::DocumentSignatureInformation > aSignInfo,
1347cdf0e10cSrcweir uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
1348cdf0e10cSrcweir rContinuations )
1349cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1350cdf0e10cSrcweir {
1351cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort;
1352cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove;
1353cdf0e10cSrcweir getContinuations( rContinuations, &xApprove, &xAbort );
1354cdf0e10cSrcweir
1355cdf0e10cSrcweir bool bApprove = false;
1356cdf0e10cSrcweir
1357cdf0e10cSrcweir std::auto_ptr< ResMgr > pResMgr(
1358cdf0e10cSrcweir ResMgr::CreateResMgr( CREATEVERSIONRESMGR_NAME( uui ) ) );
1359cdf0e10cSrcweir if ( pResMgr.get() )
1360cdf0e10cSrcweir {
1361cdf0e10cSrcweir bool bShowSignatures = aSignInfo.getLength() > 0;
1362cdf0e10cSrcweir MacroWarning aWarning(
1363cdf0e10cSrcweir getParentProperty(), bShowSignatures, *pResMgr.get() );
1364cdf0e10cSrcweir
1365cdf0e10cSrcweir aWarning.SetDocumentURL( aDocumentURL );
1366cdf0e10cSrcweir if ( aSignInfo.getLength() > 1 )
1367cdf0e10cSrcweir {
1368cdf0e10cSrcweir aWarning.SetStorage( xZipStorage, aDocumentVersion, aSignInfo );
1369cdf0e10cSrcweir }
1370cdf0e10cSrcweir else if ( aSignInfo.getLength() == 1 )
1371cdf0e10cSrcweir {
1372cdf0e10cSrcweir aWarning.SetCertificate( aSignInfo[ 0 ].Signer );
1373cdf0e10cSrcweir }
1374cdf0e10cSrcweir
1375cdf0e10cSrcweir bApprove = aWarning.Execute() == RET_OK;
1376cdf0e10cSrcweir }
1377cdf0e10cSrcweir
1378cdf0e10cSrcweir if ( bApprove && xApprove.is() )
1379cdf0e10cSrcweir xApprove->select();
1380cdf0e10cSrcweir else if ( xAbort.is() )
1381cdf0e10cSrcweir xAbort->select();
1382cdf0e10cSrcweir }
1383cdf0e10cSrcweir
1384cdf0e10cSrcweir void
handleFutureDocumentVersionUpdateRequest(const task::FutureDocumentVersionProductUpdateRequest & _rRequest,uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations)1385cdf0e10cSrcweir UUIInteractionHelper::handleFutureDocumentVersionUpdateRequest(
1386cdf0e10cSrcweir const task::FutureDocumentVersionProductUpdateRequest& _rRequest,
1387cdf0e10cSrcweir uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
1388cdf0e10cSrcweir rContinuations )
1389cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1390cdf0e10cSrcweir {
1391cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort;
1392cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove;
1393cdf0e10cSrcweir uno::Reference< task::XInteractionAskLater > xAskLater;
1394cdf0e10cSrcweir getContinuations( rContinuations, &xApprove, &xAbort, &xAskLater );
1395cdf0e10cSrcweir
1396cdf0e10cSrcweir short nResult = RET_CANCEL;
1397cdf0e10cSrcweir
1398cdf0e10cSrcweir static bool s_bDeferredToNextSession = false;
1399cdf0e10cSrcweir // TODO: this static variable is somewhat hacky. Formerly (before the dialog was moved from SFX2 to the
1400cdf0e10cSrcweir // interaction handler implementation), this was stored in SFX_APP()'s impl structure, in member
1401cdf0e10cSrcweir // bODFVersionWarningLater. Of course, we do not have access to it here.
1402cdf0e10cSrcweir //
1403cdf0e10cSrcweir // A proper solution which I would envision would be:
1404cdf0e10cSrcweir // - There's a central implementation (this one here) of css.task.InteractionHandler
1405cdf0e10cSrcweir // - There's a configuration which maps UNO names to service names
1406cdf0e10cSrcweir // - If the handler is confronted with a request, it tries to find the name of the UNO structure describing
1407cdf0e10cSrcweir // the request in the said configuration.
1408cdf0e10cSrcweir // - If an entry is found, then
1409cdf0e10cSrcweir // - the respective service is instantiated
1410cdf0e10cSrcweir // - the component is queried for css.task.XInteractionHandler, and the request is delegated
1411cdf0e10cSrcweir // - if no entry is found, then the request is silenced (with calling the AbortContinuation, if possible)
1412cdf0e10cSrcweir // This way, the FutureDocumentVersionProductUpdateRequest could be handled in SFX (or any other
1413cdf0e10cSrcweir // suitable place), again, and we would only have one place where we remember the s_bDeferredToNextSession
1414cdf0e10cSrcweir // flag.
1415cdf0e10cSrcweir //
1416cdf0e10cSrcweir // Note: The above pattern has been implemented in CWS autorecovery. Now the remaining task is to move the
1417cdf0e10cSrcweir // handling of this interaction to SFX, again.
1418cdf0e10cSrcweir
1419cdf0e10cSrcweir if ( !s_bDeferredToNextSession )
1420cdf0e10cSrcweir {
1421cdf0e10cSrcweir std::auto_ptr< ResMgr > pResMgr(
1422cdf0e10cSrcweir ResMgr::CreateResMgr( CREATEVERSIONRESMGR_NAME( uui ) ) );
1423cdf0e10cSrcweir if ( pResMgr.get() )
1424cdf0e10cSrcweir {
1425cdf0e10cSrcweir ::uui::NewerVersionWarningDialog aDialog(
1426cdf0e10cSrcweir getParentProperty(),
1427cdf0e10cSrcweir _rRequest.DocumentODFVersion,
1428cdf0e10cSrcweir *pResMgr.get() );
1429cdf0e10cSrcweir nResult = aDialog.Execute();
1430cdf0e10cSrcweir }
1431cdf0e10cSrcweir }
1432cdf0e10cSrcweir
1433cdf0e10cSrcweir switch ( nResult )
1434cdf0e10cSrcweir {
1435cdf0e10cSrcweir case RET_OK:
1436cdf0e10cSrcweir if ( xApprove.is() )
1437cdf0e10cSrcweir xApprove->select();
1438cdf0e10cSrcweir break;
1439cdf0e10cSrcweir case RET_CANCEL:
1440cdf0e10cSrcweir if ( xAbort.is() )
1441cdf0e10cSrcweir xAbort->select();
1442cdf0e10cSrcweir break;
1443cdf0e10cSrcweir case RET_ASK_LATER:
1444cdf0e10cSrcweir if ( xAskLater.is() )
1445cdf0e10cSrcweir xAskLater->select();
1446cdf0e10cSrcweir s_bDeferredToNextSession = true;
1447cdf0e10cSrcweir break;
1448cdf0e10cSrcweir default:
1449cdf0e10cSrcweir OSL_ENSURE( false,
1450cdf0e10cSrcweir "UUIInteractionHelper::handleFutureDocumentVersionUpdateRequest: "
1451cdf0e10cSrcweir "unexpected dialog return value!" );
1452cdf0e10cSrcweir break;
1453cdf0e10cSrcweir }
1454cdf0e10cSrcweir }
1455cdf0e10cSrcweir
1456cdf0e10cSrcweir void
handleBrokenPackageRequest(std::vector<rtl::OUString> const & rArguments,uno::Sequence<uno::Reference<task::XInteractionContinuation>> const & rContinuations,bool bObtainErrorStringOnly,bool & bHasErrorString,rtl::OUString & rErrorString)1457cdf0e10cSrcweir UUIInteractionHelper::handleBrokenPackageRequest(
1458cdf0e10cSrcweir std::vector< rtl::OUString > const & rArguments,
1459cdf0e10cSrcweir uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
1460cdf0e10cSrcweir rContinuations,
1461cdf0e10cSrcweir bool bObtainErrorStringOnly,
1462cdf0e10cSrcweir bool & bHasErrorString,
1463cdf0e10cSrcweir rtl::OUString & rErrorString)
1464cdf0e10cSrcweir SAL_THROW((uno::RuntimeException))
1465cdf0e10cSrcweir {
1466cdf0e10cSrcweir if (bObtainErrorStringOnly)
1467cdf0e10cSrcweir {
1468cdf0e10cSrcweir bHasErrorString = isInformationalErrorMessageRequest(rContinuations);
1469cdf0e10cSrcweir if (!bHasErrorString)
1470cdf0e10cSrcweir return;
1471cdf0e10cSrcweir }
1472cdf0e10cSrcweir
1473cdf0e10cSrcweir uno::Reference< task::XInteractionApprove > xApprove;
1474cdf0e10cSrcweir uno::Reference< task::XInteractionDisapprove > xDisapprove;
1475cdf0e10cSrcweir uno::Reference< task::XInteractionAbort > xAbort;
1476cdf0e10cSrcweir getContinuations(rContinuations, &xApprove, &xDisapprove, &xAbort);
1477cdf0e10cSrcweir
1478cdf0e10cSrcweir ErrCode nErrorCode;
1479cdf0e10cSrcweir if( xApprove.is() && xDisapprove.is() )
1480cdf0e10cSrcweir {
1481cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_IO_BROKENPACKAGE;
1482cdf0e10cSrcweir }
1483cdf0e10cSrcweir else if ( xAbort.is() )
1484cdf0e10cSrcweir {
1485cdf0e10cSrcweir nErrorCode = ERRCODE_UUI_IO_BROKENPACKAGE_CANTREPAIR;
1486cdf0e10cSrcweir }
1487cdf0e10cSrcweir else
1488cdf0e10cSrcweir return;
1489cdf0e10cSrcweir
1490cdf0e10cSrcweir ::rtl::OUString aMessage;
1491cdf0e10cSrcweir {
1492cdf0e10cSrcweir vos::OGuard aGuard(Application::GetSolarMutex());
1493cdf0e10cSrcweir std::auto_ptr< ResMgr > xManager(
1494cdf0e10cSrcweir ResMgr::CreateResMgr(CREATEVERSIONRESMGR_NAME(uui)));
1495cdf0e10cSrcweir if (!xManager.get())
1496cdf0e10cSrcweir return;
1497cdf0e10cSrcweir
1498cdf0e10cSrcweir ResId aResId( RID_UUI_ERRHDL, *xManager.get() );
1499cdf0e10cSrcweir if ( !ErrorResource(aResId).getString(nErrorCode, &aMessage) )
1500cdf0e10cSrcweir return;
1501cdf0e10cSrcweir }
1502cdf0e10cSrcweir
1503cdf0e10cSrcweir aMessage = replaceMessageWithArguments( aMessage, rArguments );
1504cdf0e10cSrcweir
1505cdf0e10cSrcweir if (bObtainErrorStringOnly)
1506cdf0e10cSrcweir {
1507cdf0e10cSrcweir rErrorString = aMessage;
1508cdf0e10cSrcweir return;
1509cdf0e10cSrcweir }
1510cdf0e10cSrcweir
1511cdf0e10cSrcweir WinBits nButtonMask;
1512cdf0e10cSrcweir if( xApprove.is() && xDisapprove.is() )
1513cdf0e10cSrcweir {
1514cdf0e10cSrcweir nButtonMask = WB_YES_NO | WB_DEF_YES;
1515cdf0e10cSrcweir }
1516cdf0e10cSrcweir else if ( xAbort.is() )
1517cdf0e10cSrcweir {
1518cdf0e10cSrcweir nButtonMask = WB_OK;
1519cdf0e10cSrcweir }
1520cdf0e10cSrcweir else
1521cdf0e10cSrcweir return;
1522cdf0e10cSrcweir
1523cdf0e10cSrcweir uno::Any aProductNameAny =
1524cdf0e10cSrcweir ::utl::ConfigManager::GetConfigManager()->GetDirectConfigProperty(
1525cdf0e10cSrcweir ::utl::ConfigManager::PRODUCTNAME );
1526cdf0e10cSrcweir uno::Any aProductVersionAny =
1527cdf0e10cSrcweir ::utl::ConfigManager::GetConfigManager()->GetDirectConfigProperty(
1528cdf0e10cSrcweir ::utl::ConfigManager::PRODUCTVERSION );
1529cdf0e10cSrcweir ::rtl::OUString aProductName, aProductVersion;
1530cdf0e10cSrcweir if ( !( aProductNameAny >>= aProductName ) )
1531cdf0e10cSrcweir aProductName
1532cdf0e10cSrcweir = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("StarOffice") );
1533cdf0e10cSrcweir
1534cdf0e10cSrcweir ::rtl::OUString aTitle( aProductName );
1535cdf0e10cSrcweir if( aProductVersionAny >>= aProductVersion )
1536cdf0e10cSrcweir {
1537cdf0e10cSrcweir aTitle += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(" ") );
1538cdf0e10cSrcweir aTitle += aProductVersion;
1539cdf0e10cSrcweir }
1540cdf0e10cSrcweir
1541cdf0e10cSrcweir switch ( executeMessageBox( getParentProperty(),
1542cdf0e10cSrcweir aTitle,
1543cdf0e10cSrcweir aMessage,
1544cdf0e10cSrcweir nButtonMask ))
1545cdf0e10cSrcweir {
1546cdf0e10cSrcweir case ERRCODE_BUTTON_OK:
1547cdf0e10cSrcweir OSL_ENSURE( xAbort.is(), "unexpected situation" );
1548cdf0e10cSrcweir if (xAbort.is())
1549cdf0e10cSrcweir xAbort->select();
1550cdf0e10cSrcweir break;
1551cdf0e10cSrcweir
1552cdf0e10cSrcweir case ERRCODE_BUTTON_NO:
1553cdf0e10cSrcweir OSL_ENSURE(xDisapprove.is(), "unexpected situation");
1554cdf0e10cSrcweir if (xDisapprove.is())
1555cdf0e10cSrcweir xDisapprove->select();
1556cdf0e10cSrcweir break;
1557cdf0e10cSrcweir
1558cdf0e10cSrcweir case ERRCODE_BUTTON_YES:
1559cdf0e10cSrcweir OSL_ENSURE(xApprove.is(), "unexpected situation");
1560cdf0e10cSrcweir if (xApprove.is())
1561cdf0e10cSrcweir xApprove->select();
1562cdf0e10cSrcweir break;
1563cdf0e10cSrcweir }
1564cdf0e10cSrcweir }
1565cdf0e10cSrcweir
1566cdf0e10cSrcweir //=========================================================================
1567cdf0e10cSrcweir // ErrorResource Implementation
1568cdf0e10cSrcweir //=========================================================================
1569cdf0e10cSrcweir
1570cdf0e10cSrcweir bool
getString(ErrCode nErrorCode,rtl::OUString * pString) const1571cdf0e10cSrcweir ErrorResource::getString(ErrCode nErrorCode, rtl::OUString * pString)
1572cdf0e10cSrcweir const SAL_THROW(())
1573cdf0e10cSrcweir {
1574cdf0e10cSrcweir OSL_ENSURE(pString, "specification violation");
1575cdf0e10cSrcweir ResId aResId(static_cast< sal_uInt16 >(nErrorCode & ERRCODE_RES_MASK),
1576cdf0e10cSrcweir *m_pResMgr);
1577cdf0e10cSrcweir aResId.SetRT(RSC_STRING);
1578cdf0e10cSrcweir if (!IsAvailableRes(aResId))
1579cdf0e10cSrcweir return false;
1580cdf0e10cSrcweir aResId.SetAutoRelease(false);
1581cdf0e10cSrcweir *pString = UniString(aResId);
1582cdf0e10cSrcweir m_pResMgr->PopContext();
1583cdf0e10cSrcweir return true;
1584cdf0e10cSrcweir }
1585