Line data Source code
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 :
21 : #include "framework/ResourceId.hxx"
22 : #include "framework/FrameworkHelper.hxx"
23 : #include "tools/SdGlobalResourceContainer.hxx"
24 : #include <com/sun/star/lang/IllegalArgumentException.hpp>
25 : #include <com/sun/star/uno/XComponentContext.hpp>
26 : #include <com/sun/star/util/URLTransformer.hpp>
27 : #include <comphelper/processfactory.hxx>
28 : #include <rtl/ref.hxx>
29 :
30 : using namespace ::com::sun::star;
31 : using namespace ::com::sun::star::uno;
32 : using namespace ::com::sun::star::lang;
33 : using namespace ::com::sun::star::drawing::framework;
34 : using ::rtl::OUString;
35 :
36 : /** When the USE_OPTIMIZATIONS symbol is defined then at some optimizations
37 : are activated that work only together with XResourceId objects that are
38 : implemented by the ResourceId class. For other implementations of when
39 : the USE_OPTIMIZATIONS symbol is not defined then alternative code is
40 : used instead.
41 : */
42 : #define USE_OPTIMIZATIONS
43 :
44 : namespace sd { namespace framework {
45 :
46 0 : Reference<XInterface> SAL_CALL ResourceId_createInstance (
47 : const Reference<XComponentContext>& rxContext)
48 : {
49 : (void)rxContext;
50 0 : return Reference<XInterface>(static_cast<XWeak*>(new ::sd::framework::ResourceId()));
51 : }
52 :
53 :
54 :
55 :
56 2 : ::rtl::OUString ResourceId_getImplementationName (void) throw(RuntimeException)
57 : {
58 2 : return ::rtl::OUString("com.sun.star.comp.Draw.framework.ResourceId");
59 : }
60 :
61 :
62 :
63 :
64 0 : Sequence<rtl::OUString> SAL_CALL ResourceId_getSupportedServiceNames (void)
65 : throw (RuntimeException)
66 : {
67 0 : static const ::rtl::OUString sServiceName("com.sun.star.drawing.framework.ResourceId");
68 0 : return Sequence<rtl::OUString>(&sServiceName, 1);
69 : }
70 :
71 :
72 :
73 :
74 : //===== ResourceId ============================================================
75 :
76 3 : WeakReference<util::XURLTransformer> ResourceId::mxURLTransformerWeak;
77 :
78 0 : ResourceId::ResourceId (void)
79 : : ResourceIdInterfaceBase(),
80 : maResourceURLs(0),
81 0 : mpURL()
82 : {
83 0 : }
84 :
85 :
86 :
87 :
88 0 : ResourceId::ResourceId (
89 : const std::vector<OUString>& rResourceURLs)
90 : : ResourceIdInterfaceBase(),
91 : maResourceURLs(rResourceURLs),
92 0 : mpURL()
93 : {
94 0 : ParseResourceURL();
95 0 : }
96 :
97 :
98 :
99 :
100 0 : ResourceId::ResourceId (
101 : const OUString& rsResourceURL)
102 : : ResourceIdInterfaceBase(),
103 : maResourceURLs(1, rsResourceURL),
104 0 : mpURL()
105 : {
106 : // Handle the special case of an empty resource URL.
107 0 : if (rsResourceURL.isEmpty())
108 0 : maResourceURLs.clear();
109 0 : ParseResourceURL();
110 0 : }
111 :
112 :
113 :
114 :
115 0 : ResourceId::ResourceId (
116 : const OUString& rsResourceURL,
117 : const OUString& rsAnchorURL)
118 : : ResourceIdInterfaceBase(),
119 : maResourceURLs(2),
120 0 : mpURL()
121 : {
122 0 : maResourceURLs[0] = rsResourceURL;
123 0 : maResourceURLs[1] = rsAnchorURL;
124 0 : ParseResourceURL();
125 0 : }
126 :
127 :
128 :
129 :
130 0 : ResourceId::ResourceId (
131 : const OUString& rsResourceURL,
132 : const ::std::vector<OUString>& rAnchorURLs)
133 : : ResourceIdInterfaceBase(),
134 0 : maResourceURLs(1+rAnchorURLs.size()),
135 0 : mpURL()
136 : {
137 0 : maResourceURLs[0] = rsResourceURL;
138 0 : for (sal_uInt32 nIndex=0; nIndex<rAnchorURLs.size(); ++nIndex)
139 0 : maResourceURLs[nIndex+1] = rAnchorURLs[nIndex];
140 0 : ParseResourceURL();
141 0 : }
142 :
143 :
144 :
145 :
146 0 : ResourceId::ResourceId (
147 : const OUString& rsResourceURL,
148 : const OUString& rsFirstAnchorURL,
149 : const Sequence<OUString>& rAnchorURLs)
150 : : ResourceIdInterfaceBase(),
151 0 : maResourceURLs(2+rAnchorURLs.getLength()),
152 0 : mpURL()
153 : {
154 0 : maResourceURLs[0] = rsResourceURL;
155 0 : maResourceURLs[1] = rsFirstAnchorURL;
156 0 : for (sal_Int32 nIndex=0; nIndex<rAnchorURLs.getLength(); ++nIndex)
157 0 : maResourceURLs[nIndex+2] = rAnchorURLs[nIndex];
158 0 : ParseResourceURL();
159 0 : }
160 :
161 :
162 :
163 :
164 0 : ResourceId::~ResourceId (void)
165 : {
166 0 : mpURL.reset();
167 0 : }
168 :
169 :
170 :
171 :
172 : OUString SAL_CALL
173 0 : ResourceId::getResourceURL (void)
174 : throw(com::sun::star::uno::RuntimeException)
175 : {
176 0 : if (!maResourceURLs.empty())
177 0 : return maResourceURLs[0];
178 : else
179 0 : return OUString();
180 : }
181 :
182 :
183 :
184 :
185 : util::URL SAL_CALL
186 0 : ResourceId::getFullResourceURL (void)
187 : throw(com::sun::star::uno::RuntimeException)
188 : {
189 0 : if (mpURL.get() != NULL)
190 0 : return *mpURL;
191 :
192 0 : Reference<util::XURLTransformer> xURLTransformer (mxURLTransformerWeak);
193 0 : if (xURLTransformer.is() && !maResourceURLs.empty() )
194 : {
195 0 : mpURL.reset(new util::URL);
196 0 : mpURL->Complete = maResourceURLs[0];
197 0 : xURLTransformer->parseStrict(*mpURL);
198 0 : return *mpURL;
199 : }
200 :
201 0 : util::URL aURL;
202 0 : if (!maResourceURLs.empty())
203 0 : aURL.Complete = maResourceURLs[0];
204 0 : return aURL;
205 : }
206 :
207 :
208 :
209 :
210 : sal_Bool SAL_CALL
211 0 : ResourceId::hasAnchor (void)
212 : throw (RuntimeException)
213 : {
214 0 : return maResourceURLs.size()>1;
215 : }
216 :
217 :
218 :
219 :
220 : Reference<XResourceId> SAL_CALL
221 0 : ResourceId::getAnchor (void)
222 : throw (RuntimeException)
223 : {
224 0 : ::rtl::Reference<ResourceId> rResourceId (new ResourceId());
225 0 : const sal_Int32 nAnchorCount (maResourceURLs.size()-1);
226 0 : if (nAnchorCount > 0)
227 : {
228 0 : rResourceId->maResourceURLs.resize(nAnchorCount);
229 0 : for (sal_Int32 nIndex=0; nIndex<nAnchorCount; ++nIndex)
230 0 : rResourceId->maResourceURLs[nIndex] = maResourceURLs[nIndex+1];
231 : }
232 0 : return Reference<XResourceId>(rResourceId.get());
233 : }
234 :
235 :
236 :
237 :
238 : Sequence<OUString> SAL_CALL
239 0 : ResourceId::getAnchorURLs (void)
240 : throw (RuntimeException)
241 : {
242 0 : const sal_Int32 nAnchorCount (maResourceURLs.size() - 1);
243 0 : if (nAnchorCount > 0)
244 : {
245 0 : Sequence<OUString> aAnchorURLs (nAnchorCount);
246 0 : for (sal_Int32 nIndex=0; nIndex<nAnchorCount; ++nIndex)
247 0 : aAnchorURLs[nIndex] = maResourceURLs[nIndex+1];
248 0 : return aAnchorURLs;
249 : }
250 : else
251 0 : return Sequence<OUString>();
252 : }
253 :
254 :
255 :
256 :
257 : OUString SAL_CALL
258 0 : ResourceId::getResourceTypePrefix (void)
259 : throw (RuntimeException)
260 : {
261 0 : if (!maResourceURLs.empty() )
262 : {
263 : // Return the "private:resource/<type>/" prefix.
264 :
265 : // Get the the prefix that ends with the second "/".
266 0 : const OUString& rsResourceURL (maResourceURLs[0]);
267 0 : sal_Int32 nPrefixEnd (rsResourceURL.indexOf(sal_Unicode('/'), 0));
268 0 : if (nPrefixEnd >= 0)
269 0 : nPrefixEnd = rsResourceURL.indexOf(sal_Unicode('/'), nPrefixEnd+1) + 1;
270 : else
271 0 : nPrefixEnd = 0;
272 :
273 0 : return rsResourceURL.copy(0,nPrefixEnd);
274 : }
275 : else
276 0 : return OUString();
277 : }
278 :
279 :
280 :
281 :
282 : sal_Int16 SAL_CALL
283 0 : ResourceId::compareTo (const Reference<XResourceId>& rxResourceId)
284 : throw (RuntimeException)
285 : {
286 0 : sal_Int16 nResult (0);
287 :
288 0 : if ( ! rxResourceId.is())
289 : {
290 : // The empty reference is interpreted as empty resource id object.
291 0 : if (!maResourceURLs.empty())
292 0 : nResult = +1;
293 : else
294 0 : nResult = 0;
295 : }
296 : else
297 : {
298 0 : ResourceId* pId = NULL;
299 : #ifdef USE_OPTIMIZATIONS
300 0 : pId = dynamic_cast<ResourceId*>(rxResourceId.get());
301 : #endif
302 0 : if (pId != NULL)
303 : {
304 : // We have direct access to the implementation of the given
305 : // resource id object.
306 0 : nResult = CompareToLocalImplementation(*pId);
307 : }
308 : else
309 : {
310 : // We have to do the comparison via the UNO interface of the
311 : // given resource id object.
312 0 : nResult = CompareToExternalImplementation(rxResourceId);
313 : }
314 : }
315 :
316 0 : return nResult;
317 : }
318 :
319 :
320 :
321 :
322 0 : sal_Int16 ResourceId::CompareToLocalImplementation (const ResourceId& rId) const
323 : {
324 0 : sal_Int16 nResult (0);
325 :
326 0 : const sal_uInt32 nLocalURLCount (maResourceURLs.size());
327 0 : const sal_uInt32 nURLCount(rId.maResourceURLs.size());
328 :
329 : // Start comparison with the top most anchors.
330 0 : for (sal_Int32 nIndex=nURLCount-1,nLocalIndex=nLocalURLCount-1;
331 : nIndex>=0 && nLocalIndex>=0;
332 : --nIndex,--nLocalIndex)
333 : {
334 0 : const OUString sLocalURL (maResourceURLs[nLocalIndex]);
335 0 : const OUString sURL (rId.maResourceURLs[nIndex]);
336 0 : const sal_Int32 nLocalResult (sURL.compareTo(sLocalURL));
337 0 : if (nLocalResult != 0)
338 : {
339 0 : if (nLocalResult < 0)
340 0 : nResult = -1;
341 : else
342 0 : nResult = +1;
343 : break;
344 : }
345 0 : }
346 :
347 0 : if (nResult == 0)
348 : {
349 : // No difference found yet. When the lengths are the same then the
350 : // two resource ids are equivalent. Otherwise the shorter comes
351 : // first.
352 0 : if (nLocalURLCount != nURLCount)
353 : {
354 0 : if (nLocalURLCount < nURLCount)
355 0 : nResult = -1;
356 : else
357 0 : nResult = +1;
358 : }
359 : }
360 :
361 0 : return nResult;
362 : }
363 :
364 :
365 :
366 :
367 0 : sal_Int16 ResourceId::CompareToExternalImplementation (const Reference<XResourceId>& rxId) const
368 : {
369 0 : sal_Int16 nResult (0);
370 :
371 0 : const Sequence<OUString> aAnchorURLs (rxId->getAnchorURLs());
372 0 : const sal_uInt32 nLocalURLCount (maResourceURLs.size());
373 0 : const sal_uInt32 nURLCount(1+aAnchorURLs.getLength());
374 :
375 : // Start comparison with the top most anchors.
376 0 : sal_Int32 nLocalResult (0);
377 0 : for (sal_Int32 nIndex=nURLCount-1,nLocalIndex=nLocalURLCount-1;
378 : nIndex>=0&&nLocalIndex>=0;
379 : --nIndex,--nLocalIndex)
380 : {
381 0 : if (nIndex == 0 )
382 0 : nLocalResult = maResourceURLs[nIndex].compareTo(rxId->getResourceURL());
383 : else
384 0 : nLocalResult = maResourceURLs[nIndex].compareTo(aAnchorURLs[nIndex-1]);
385 0 : if (nLocalResult != 0)
386 : {
387 0 : if (nLocalResult < 0)
388 0 : nResult = -1;
389 : else
390 0 : nResult = +1;
391 0 : break;
392 : }
393 : }
394 :
395 0 : if (nResult == 0)
396 : {
397 : // No difference found yet. When the lengths are the same then the
398 : // two resource ids are equivalent. Otherwise the shorter comes
399 : // first.
400 0 : if (nLocalURLCount != nURLCount)
401 : {
402 0 : if (nLocalURLCount < nURLCount)
403 0 : nResult = -1;
404 : else
405 0 : nResult = +1;
406 : }
407 : }
408 :
409 0 : return nResult;
410 : }
411 :
412 :
413 :
414 :
415 : sal_Bool SAL_CALL
416 0 : ResourceId::isBoundTo (
417 : const Reference<XResourceId>& rxResourceId,
418 : AnchorBindingMode eMode)
419 : throw (RuntimeException)
420 : {
421 0 : if ( ! rxResourceId.is())
422 : {
423 : // An empty reference is interpreted as empty resource id.
424 0 : return IsBoundToAnchor(NULL, NULL, eMode);
425 : }
426 :
427 0 : ResourceId* pId = NULL;
428 : #ifdef USE_OPTIMIZATIONS
429 0 : pId = dynamic_cast<ResourceId*>(rxResourceId.get());
430 : #endif
431 0 : if (pId != NULL)
432 : {
433 0 : return IsBoundToAnchor(pId->maResourceURLs, eMode);
434 : }
435 : else
436 : {
437 0 : const OUString sResourceURL (rxResourceId->getResourceURL());
438 0 : const Sequence<OUString> aAnchorURLs (rxResourceId->getAnchorURLs());
439 0 : return IsBoundToAnchor(&sResourceURL, &aAnchorURLs, eMode);
440 : }
441 : }
442 :
443 :
444 :
445 :
446 : sal_Bool SAL_CALL
447 0 : ResourceId::isBoundToURL (
448 : const OUString& rsAnchorURL,
449 : AnchorBindingMode eMode)
450 : throw (RuntimeException)
451 : {
452 0 : return IsBoundToAnchor(&rsAnchorURL, NULL, eMode);
453 : }
454 :
455 :
456 :
457 :
458 : Reference<XResourceId> SAL_CALL
459 0 : ResourceId::clone (void)
460 : throw(RuntimeException)
461 : {
462 0 : return new ResourceId(maResourceURLs);
463 : }
464 :
465 :
466 :
467 :
468 : //----- XInitialization -------------------------------------------------------
469 :
470 0 : void SAL_CALL ResourceId::initialize (const Sequence<Any>& aArguments)
471 : throw (RuntimeException)
472 : {
473 0 : sal_uInt32 nCount (aArguments.getLength());
474 0 : for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)
475 : {
476 0 : OUString sResourceURL;
477 0 : if (aArguments[nIndex] >>= sResourceURL)
478 0 : maResourceURLs.push_back(sResourceURL);
479 : else
480 : {
481 0 : Reference<XResourceId> xAnchor;
482 0 : if (aArguments[nIndex] >>= xAnchor)
483 : {
484 0 : if (xAnchor.is())
485 : {
486 0 : maResourceURLs.push_back(xAnchor->getResourceURL());
487 0 : Sequence<OUString> aAnchorURLs (xAnchor->getAnchorURLs());
488 0 : for (sal_Int32 nURLIndex=0; nURLIndex<aAnchorURLs.getLength(); ++nURLIndex)
489 : {
490 0 : maResourceURLs.push_back(aAnchorURLs[nURLIndex]);
491 0 : }
492 : }
493 0 : }
494 : }
495 0 : }
496 0 : ParseResourceURL();
497 0 : }
498 :
499 :
500 :
501 :
502 : //-----------------------------------------------------------------------------
503 :
504 : /** When eMode is DIRECTLY then the anchor of the called object and the
505 : anchor represented by the given sequence of anchor URLs have to be
506 : identical. When eMode is RECURSIVE then the anchor of the called
507 : object has to start with the given anchor URLs.
508 : */
509 0 : bool ResourceId::IsBoundToAnchor (
510 : const OUString* psFirstAnchorURL,
511 : const Sequence<OUString>* paAnchorURLs,
512 : AnchorBindingMode eMode) const
513 : {
514 0 : const sal_uInt32 nLocalAnchorURLCount (maResourceURLs.size() - 1);
515 0 : const bool bHasFirstAnchorURL (psFirstAnchorURL!=NULL);
516 : const sal_uInt32 nAnchorURLCount ((bHasFirstAnchorURL?1:0)
517 0 : + (paAnchorURLs!=NULL ? paAnchorURLs->getLength() : 0));
518 :
519 : // Check the lengths.
520 0 : if (nLocalAnchorURLCount<nAnchorURLCount ||
521 : (eMode==AnchorBindingMode_DIRECT && nLocalAnchorURLCount!=nAnchorURLCount))
522 : {
523 0 : return false;
524 : }
525 :
526 : // Compare the nAnchorURLCount bottom-most anchor URLs of this resource
527 : // id and the given anchor.
528 0 : sal_uInt32 nOffset = 0;
529 0 : if (paAnchorURLs != NULL)
530 : {
531 0 : sal_uInt32 nCount = paAnchorURLs->getLength();
532 0 : while (nOffset < nCount)
533 : {
534 0 : if ( ! maResourceURLs[nLocalAnchorURLCount - nOffset].equals(
535 0 : (*paAnchorURLs)[nCount - 1 - nOffset]))
536 : {
537 0 : return false;
538 : }
539 0 : ++nOffset;
540 : }
541 : }
542 0 : if (bHasFirstAnchorURL)
543 : {
544 0 : if ( ! psFirstAnchorURL->equals(maResourceURLs[nLocalAnchorURLCount - nOffset]))
545 0 : return false;
546 : }
547 :
548 0 : return true;
549 : }
550 :
551 :
552 :
553 :
554 0 : bool ResourceId::IsBoundToAnchor (
555 : const ::std::vector<OUString>& rAnchorURLs,
556 : AnchorBindingMode eMode) const
557 : {
558 0 : const sal_uInt32 nLocalAnchorURLCount (maResourceURLs.size() - 1);
559 0 : const sal_uInt32 nAnchorURLCount (rAnchorURLs.size());
560 :
561 : // Check the lengths.
562 0 : if (nLocalAnchorURLCount<nAnchorURLCount ||
563 : (eMode==AnchorBindingMode_DIRECT && nLocalAnchorURLCount!=nAnchorURLCount))
564 : {
565 0 : return false;
566 : }
567 :
568 : // Compare the nAnchorURLCount bottom-most anchor URLs of this resource
569 : // id and the given anchor.
570 0 : for (sal_uInt32 nOffset=0; nOffset<nAnchorURLCount; ++nOffset)
571 : {
572 0 : if ( ! maResourceURLs[nLocalAnchorURLCount - nOffset].equals(
573 0 : rAnchorURLs[nAnchorURLCount - 1 - nOffset]))
574 : {
575 0 : return false;
576 : }
577 : }
578 :
579 0 : return true;
580 : }
581 :
582 :
583 :
584 :
585 0 : void ResourceId::ParseResourceURL (void)
586 : {
587 0 : ::osl::Guard< ::osl::Mutex > aGuard (::osl::Mutex::getGlobalMutex());
588 0 : Reference<util::XURLTransformer> xURLTransformer (mxURLTransformerWeak);
589 0 : if ( ! xURLTransformer.is())
590 : {
591 : // Create the URL transformer.
592 0 : Reference<uno::XComponentContext> xContext(::comphelper::getProcessComponentContext());
593 0 : xURLTransformer = Reference<util::XURLTransformer>(util::URLTransformer::create(xContext));
594 0 : mxURLTransformerWeak = xURLTransformer;
595 0 : SdGlobalResourceContainer::Instance().AddResource(
596 0 : Reference<XInterface>(xURLTransformer,UNO_QUERY));
597 : }
598 :
599 0 : if (xURLTransformer.is() && !maResourceURLs.empty() )
600 : {
601 0 : mpURL.reset(new util::URL);
602 0 : mpURL->Complete = maResourceURLs[0];
603 0 : xURLTransformer->parseStrict(*mpURL);
604 0 : if (mpURL->Main == maResourceURLs[0])
605 0 : mpURL.reset();
606 : else
607 0 : maResourceURLs[0] = mpURL->Main;
608 0 : }
609 0 : }
610 :
611 :
612 9 : } } // end of namespace sd::framework
613 :
614 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
