sd/source/ui/framework/configuration/ResourceId.cxx

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