/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#include "precompiled_sd.hxx"
#include "framework/ResourceId.hxx"
#include "framework/FrameworkHelper.hxx"
#include "tools/SdGlobalResourceContainer.hxx"
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <comphelper/processfactory.hxx>
#include <rtl/ref.hxx>
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::drawing::framework;
using ::rtl::OUString;
/** When the USE_OPTIMIZATIONS symbol is defined then at some optimizations
are activated that work only together with XResourceId objects that are
implemented by the ResourceId class. For other implementations of when
the USE_OPTIMIZATIONS symbol is not defined then alternative code is
used instead.
*/
#define USE_OPTIMIZATIONS
namespace sd { namespace framework {
Reference<XInterface> SAL_CALL ResourceId_createInstance (
const Reference<XComponentContext>& rxContext)
{
(void)rxContext;
return Reference<XInterface>(static_cast<XWeak*>(new ::sd::framework::ResourceId()));
}
::rtl::OUString ResourceId_getImplementationName (void) throw(RuntimeException)
{
return ::rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.Draw.framework.ResourceId"));
}
Sequence<rtl::OUString> SAL_CALL ResourceId_getSupportedServiceNames (void)
throw (RuntimeException)
{
static const ::rtl::OUString sServiceName(
::rtl::OUString::createFromAscii("com.sun.star.drawing.framework.ResourceId"));
return Sequence<rtl::OUString>(&sServiceName, 1);
}
//===== ResourceId ============================================================
WeakReference<util::XURLTransformer> ResourceId::mxURLTransformerWeak;
ResourceId::ResourceId (void)
: ResourceIdInterfaceBase(),
maResourceURLs(0),
mpURL()
{
}
ResourceId::ResourceId (
const std::vector<OUString>& rResourceURLs)
: ResourceIdInterfaceBase(),
maResourceURLs(rResourceURLs),
mpURL()
{
ParseResourceURL();
}
ResourceId::ResourceId (
const OUString& rsResourceURL)
: ResourceIdInterfaceBase(),
maResourceURLs(1, rsResourceURL),
mpURL()
{
// Handle the special case of an empty resource URL.
if (rsResourceURL.getLength() == 0)
maResourceURLs.clear();
ParseResourceURL();
}
ResourceId::ResourceId (
const OUString& rsResourceURL,
const OUString& rsAnchorURL)
: ResourceIdInterfaceBase(),
maResourceURLs(2),
mpURL()
{
maResourceURLs[0] = rsResourceURL;
maResourceURLs[1] = rsAnchorURL;
ParseResourceURL();
}
ResourceId::ResourceId (
const OUString& rsResourceURL,
const ::std::vector<OUString>& rAnchorURLs)
: ResourceIdInterfaceBase(),
maResourceURLs(1+rAnchorURLs.size()),
mpURL()
{
maResourceURLs[0] = rsResourceURL;
for (sal_uInt32 nIndex=0; nIndex<rAnchorURLs.size(); ++nIndex)
maResourceURLs[nIndex+1] = rAnchorURLs[nIndex];
ParseResourceURL();
}
ResourceId::ResourceId (
const OUString& rsResourceURL,
const OUString& rsFirstAnchorURL,
const Sequence<OUString>& rAnchorURLs)
: ResourceIdInterfaceBase(),
maResourceURLs(2+rAnchorURLs.getLength()),
mpURL()
{
maResourceURLs[0] = rsResourceURL;
maResourceURLs[1] = rsFirstAnchorURL;
for (sal_Int32 nIndex=0; nIndex<rAnchorURLs.getLength(); ++nIndex)
maResourceURLs[nIndex+2] = rAnchorURLs[nIndex];
ParseResourceURL();
}
ResourceId::~ResourceId (void)
{
mpURL.reset();
}
OUString SAL_CALL
ResourceId::getResourceURL (void)
throw(com::sun::star::uno::RuntimeException)
{
if (!maResourceURLs.empty())
return maResourceURLs[0];
else
return OUString();
}
util::URL SAL_CALL
ResourceId::getFullResourceURL (void)
throw(com::sun::star::uno::RuntimeException)
{
if (mpURL.get() != NULL)
return *mpURL;
Reference<util::XURLTransformer> xURLTransformer (mxURLTransformerWeak);
if (xURLTransformer.is() && !maResourceURLs.empty() )
{
mpURL.reset(new util::URL);
mpURL->Complete = maResourceURLs[0];
xURLTransformer->parseStrict(*mpURL);
return *mpURL;
}
util::URL aURL;
if (!maResourceURLs.empty())
aURL.Complete = maResourceURLs[0];
return aURL;
}
sal_Bool SAL_CALL
ResourceId::hasAnchor (void)
throw (RuntimeException)
{
return maResourceURLs.size()>1;
}
Reference<XResourceId> SAL_CALL
ResourceId::getAnchor (void)
throw (RuntimeException)
{
::rtl::Reference<ResourceId> rResourceId (new ResourceId());
const sal_Int32 nAnchorCount (maResourceURLs.size()-1);
if (nAnchorCount > 0)
{
rResourceId->maResourceURLs.resize(nAnchorCount);
for (sal_Int32 nIndex=0; nIndex<nAnchorCount; ++nIndex)
rResourceId->maResourceURLs[nIndex] = maResourceURLs[nIndex+1];
}
return Reference<XResourceId>(rResourceId.get());
}
Sequence<OUString> SAL_CALL
ResourceId::getAnchorURLs (void)
throw (RuntimeException)
{
const sal_Int32 nAnchorCount (maResourceURLs.size() - 1);
if (nAnchorCount > 0)
{
Sequence<OUString> aAnchorURLs (nAnchorCount);
for (sal_Int32 nIndex=0; nIndex<nAnchorCount; ++nIndex)
aAnchorURLs[nIndex] = maResourceURLs[nIndex+1];
return aAnchorURLs;
}
else
return Sequence<OUString>();
}
OUString SAL_CALL
ResourceId::getResourceTypePrefix (void)
throw (RuntimeException)
{
if (!maResourceURLs.empty() )
{
// Return the "private:resource/<type>/" prefix.
// Get the the prefix that ends with the second "/".
const OUString& rsResourceURL (maResourceURLs[0]);
sal_Int32 nPrefixEnd (rsResourceURL.indexOf(sal_Unicode('/'), 0));
if (nPrefixEnd >= 0)
nPrefixEnd = rsResourceURL.indexOf(sal_Unicode('/'), nPrefixEnd+1) + 1;
else
nPrefixEnd = 0;
return rsResourceURL.copy(0,nPrefixEnd);
}
else
return OUString();
}
sal_Int16 SAL_CALL
ResourceId::compareTo (const Reference<XResourceId>& rxResourceId)
throw (RuntimeException)
{
sal_Int16 nResult (0);
if ( ! rxResourceId.is())
{
// The empty reference is interpreted as empty resource id object.
if (!maResourceURLs.empty())
nResult = +1;
else
nResult = 0;
}
else
{
ResourceId* pId = NULL;
#ifdef USE_OPTIMIZATIONS
pId = dynamic_cast<ResourceId*>(rxResourceId.get());
#endif
if (pId != NULL)
{
// We have direct access to the implementation of the given
// resource id object.
nResult = CompareToLocalImplementation(*pId);
}
else
{
// We have to do the comparison via the UNO interface of the
// given resource id object.
nResult = CompareToExternalImplementation(rxResourceId);
}
}
return nResult;
}
sal_Int16 ResourceId::CompareToLocalImplementation (const ResourceId& rId) const
{
sal_Int16 nResult (0);
const sal_uInt32 nLocalURLCount (maResourceURLs.size());
const sal_uInt32 nURLCount(rId.maResourceURLs.size());
// Start comparison with the top most anchors.
for (sal_Int32 nIndex=nURLCount-1,nLocalIndex=nLocalURLCount-1;
nIndex>=0 && nLocalIndex>=0;
--nIndex,--nLocalIndex)
{
const OUString sLocalURL (maResourceURLs[nLocalIndex]);
const OUString sURL (rId.maResourceURLs[nIndex]);
const sal_Int32 nLocalResult (sURL.compareTo(sLocalURL));
if (nLocalResult != 0)
{
if (nLocalResult < 0)
nResult = -1;
else
nResult = +1;
break;
}
}
if (nResult == 0)
{
// No difference found yet. When the lengths are the same then the
// two resource ids are equivalent. Otherwise the shorter comes
// first.
if (nLocalURLCount != nURLCount)
{
if (nLocalURLCount < nURLCount)
nResult = -1;
else
nResult = +1;
}
}
return nResult;
}
sal_Int16 ResourceId::CompareToExternalImplementation (const Reference<XResourceId>& rxId) const
{
sal_Int16 nResult (0);
const Sequence<OUString> aAnchorURLs (rxId->getAnchorURLs());
const sal_uInt32 nLocalURLCount (maResourceURLs.size());
const sal_uInt32 nURLCount(1+aAnchorURLs.getLength());
// Start comparison with the top most anchors.
sal_Int32 nLocalResult (0);
for (sal_Int32 nIndex=nURLCount-1,nLocalIndex=nLocalURLCount-1;
nIndex>=0&&nLocalIndex>=0;
--nIndex,--nLocalIndex)
{
if (nIndex == 0 )
nLocalResult = maResourceURLs[nIndex].compareTo(rxId->getResourceURL());
else
nLocalResult = maResourceURLs[nIndex].compareTo(aAnchorURLs[nIndex-1]);
if (nLocalResult != 0)
{
if (nLocalResult < 0)
nResult = -1;
else
nResult = +1;
break;
}
}
if (nResult == 0)
{
// No difference found yet. When the lengths are the same then the
// two resource ids are equivalent. Otherwise the shorter comes
// first.
if (nLocalURLCount != nURLCount)
{
if (nLocalURLCount < nURLCount)
nResult = -1;
else
nResult = +1;
}
}
return nResult;
}
sal_Bool SAL_CALL
ResourceId::isBoundTo (
const Reference<XResourceId>& rxResourceId,
AnchorBindingMode eMode)
throw (RuntimeException)
{
if ( ! rxResourceId.is())
{
// An empty reference is interpreted as empty resource id.
return IsBoundToAnchor(NULL, NULL, eMode);
}
ResourceId* pId = NULL;
#ifdef USE_OPTIMIZATIONS
pId = dynamic_cast<ResourceId*>(rxResourceId.get());
#endif
if (pId != NULL)
{
return IsBoundToAnchor(pId->maResourceURLs, eMode);
}
else
{
const OUString sResourceURL (rxResourceId->getResourceURL());
const Sequence<OUString> aAnchorURLs (rxResourceId->getAnchorURLs());
return IsBoundToAnchor(&sResourceURL, &aAnchorURLs, eMode);
}
}
sal_Bool SAL_CALL
ResourceId::isBoundToURL (
const OUString& rsAnchorURL,
AnchorBindingMode eMode)
throw (RuntimeException)
{
return IsBoundToAnchor(&rsAnchorURL, NULL, eMode);
}
Reference<XResourceId> SAL_CALL
ResourceId::clone (void)
throw(RuntimeException)
{
return new ResourceId(maResourceURLs);
}
//----- XInitialization -------------------------------------------------------
void SAL_CALL ResourceId::initialize (const Sequence<Any>& aArguments)
throw (RuntimeException)
{
sal_uInt32 nCount (aArguments.getLength());
for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)
{
OUString sResourceURL;
if (aArguments[nIndex] >>= sResourceURL)
maResourceURLs.push_back(sResourceURL);
else
{
Reference<XResourceId> xAnchor;
if (aArguments[nIndex] >>= xAnchor)
{
if (xAnchor.is())
{
maResourceURLs.push_back(xAnchor->getResourceURL());
Sequence<OUString> aAnchorURLs (xAnchor->getAnchorURLs());
for (sal_Int32 nURLIndex=0; nURLIndex<aAnchorURLs.getLength(); ++nURLIndex)
{
maResourceURLs.push_back(aAnchorURLs[nURLIndex]);
}
}
}
}
}
ParseResourceURL();
}
//-----------------------------------------------------------------------------
/** When eMode is DIRECTLY then the anchor of the called object and the
anchor represented by the given sequence of anchor URLs have to be
identical. When eMode is RECURSIVE then the anchor of the called
object has to start with the given anchor URLs.
*/
bool ResourceId::IsBoundToAnchor (
const OUString* psFirstAnchorURL,
const Sequence<OUString>* paAnchorURLs,
AnchorBindingMode eMode) const
{
const sal_uInt32 nLocalAnchorURLCount (maResourceURLs.size() - 1);
const bool bHasFirstAnchorURL (psFirstAnchorURL!=NULL);
const sal_uInt32 nAnchorURLCount ((bHasFirstAnchorURL?1:0)
+ (paAnchorURLs!=NULL ? paAnchorURLs->getLength() : 0));
// Check the lengths.
if (nLocalAnchorURLCount<nAnchorURLCount ||
(eMode==AnchorBindingMode_DIRECT && nLocalAnchorURLCount!=nAnchorURLCount))
{
return false;
}
// Compare the nAnchorURLCount bottom-most anchor URLs of this resource
// id and the given anchor.
sal_uInt32 nOffset = 0;
if (paAnchorURLs != NULL)
{
sal_uInt32 nCount = paAnchorURLs->getLength();
while (nOffset < nCount)
{
if ( ! maResourceURLs[nLocalAnchorURLCount - nOffset].equals(
(*paAnchorURLs)[nCount - 1 - nOffset]))
{
return false;
}
++nOffset;
}
}
if (bHasFirstAnchorURL)
{
if ( ! psFirstAnchorURL->equals(maResourceURLs[nLocalAnchorURLCount - nOffset]))
return false;
}
return true;
}
bool ResourceId::IsBoundToAnchor (
const ::std::vector<OUString>& rAnchorURLs,
AnchorBindingMode eMode) const
{
const sal_uInt32 nLocalAnchorURLCount (maResourceURLs.size() - 1);
const sal_uInt32 nAnchorURLCount (rAnchorURLs.size());
// Check the lengths.
if (nLocalAnchorURLCount<nAnchorURLCount ||
(eMode==AnchorBindingMode_DIRECT && nLocalAnchorURLCount!=nAnchorURLCount))
{
return false;
}
// Compare the nAnchorURLCount bottom-most anchor URLs of this resource
// id and the given anchor.
for (sal_uInt32 nOffset=0; nOffset<nAnchorURLCount; ++nOffset)
{
if ( ! maResourceURLs[nLocalAnchorURLCount - nOffset].equals(
rAnchorURLs[nAnchorURLCount - 1 - nOffset]))
{
return false;
}
}
return true;
}
void ResourceId::ParseResourceURL (void)
{
::osl::Guard< ::osl::Mutex > aGuard (::osl::Mutex::getGlobalMutex());
Reference<util::XURLTransformer> xURLTransformer (mxURLTransformerWeak);
if ( ! xURLTransformer.is())
{
// Create the URL transformer.
Reference<lang::XMultiServiceFactory> xServiceManager (
::comphelper::getProcessServiceFactory());
xURLTransformer = Reference<util::XURLTransformer>(
xServiceManager->createInstance(
OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.util.URLTransformer"))),
UNO_QUERY);
mxURLTransformerWeak = xURLTransformer;
SdGlobalResourceContainer::Instance().AddResource(
Reference<XInterface>(xURLTransformer,UNO_QUERY));
}
if (xURLTransformer.is() && !maResourceURLs.empty() )
{
mpURL.reset(new util::URL);
mpURL->Complete = maResourceURLs[0];
xURLTransformer->parseStrict(*mpURL);
if (mpURL->Main == maResourceURLs[0])
mpURL.reset();
else
maResourceURLs[0] = mpURL->Main;
}
}
} } // end of namespace sd::framework