xmloff/source/script/xmlbasicscript.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include "xmlbasicscript.hxx"
  23 #include <sal/log.hxx>
  24 #include <utility>
  25 #include <xmloff/xmlnamespace.hxx>
  26 #include <xmloff/xmltoken.hxx>
  27 #include <com/sun/star/beans/XPropertySet.hpp>
  28 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  29 #include <com/sun/star/xml/sax/SAXException.hpp>
  30 #include <comphelper/diagnose_ex.hxx>
  31
  32 using namespace ::com::sun::star;
  33 using namespace ::com::sun::star::lang;
  34 using namespace ::com::sun::star::uno;
  35 using namespace ::com::sun::star::xml::sax;
  36 using namespace ::xmloff::token;
  37
  38 namespace xmloff
  39 {
  40 // BasicElementBase
  41
  42 BasicElementBase::BasicElementBase(SvXMLImport& rImport)
  43     : SvXMLImportContext(rImport)
  44 {
  45 }
  46
  47 bool BasicElementBase::getBoolAttr(bool* pRet, sal_Int32 nToken,
  48                                    const Reference<XFastAttributeList>& xAttributes)
  49 {
  50     OUString aValue = xAttributes->getOptionalValue(nToken);
  51     if (!aValue.isEmpty())
  52     {
  53         if (aValue == "true")
  54         {
  55             *pRet = true;
  56             return true;
  57         }
  58         else if (aValue == "false")
  59         {
  60             *pRet = false;
  61             return true;
  62         }
  63         else
  64         {
  65             throw xml::sax::SAXException(SvXMLImport::getNameFromToken(nToken)
  66                                              + ": no boolean value (true|false)!",
  67                                          Reference<XInterface>(), Any());
  68         }
  69     }
  70     return false;
  71 }
  72
  73 // BasicLibrariesElement
  74
  75 BasicLibrariesElement::BasicLibrariesElement(SvXMLImport& rImport,
  76                                              const css::uno::Reference<css::frame::XModel>& rxModel)
  77     : BasicElementBase(rImport)
  78 {
  79     // try the XEmbeddedScripts interface
  80     Reference<document::XEmbeddedScripts> xDocumentScripts(rxModel, UNO_QUERY_THROW);
  81     m_xLibContainer = xDocumentScripts->getBasicLibraries();
  82
  83     if (!m_xLibContainer.is())
  84     {
  85         // try the "BasicLibraries" property (old-style, for compatibility)
  86         Reference<beans::XPropertySet> xPSet(rxModel, UNO_QUERY);
  87         if (xPSet.is())
  88             xPSet->getPropertyValue(u"BasicLibraries"_ustr) >>= m_xLibContainer;
  89     }
  90
  91     SAL_WARN_IF(!m_xLibContainer.is(), "xmlscript.xmlflat",
  92                 "BasicImport::startRootElement: nowhere to import to!");
  93
  94     if (!m_xLibContainer.is())
  95     {
  96         throw xml::sax::SAXException(u"nowhere to import to"_ustr, Reference<XInterface>(), Any());
  97     }
  98 }
  99
 100 // XElement
 101
 102 Reference<XFastContextHandler>
 103 BasicLibrariesElement::createFastChildContext(sal_Int32 nElement,
 104                                               const Reference<XFastAttributeList>& xAttributes)
 105 {
 106     if (!IsTokenInNamespace(nElement, XML_NAMESPACE_OOO))
 107     {
 108         throw xml::sax::SAXException(u"illegal namespace!"_ustr, Reference<XInterface>(), Any());
 109     }
 110     else if ((nElement & TOKEN_MASK) == XML_LIBRARY_LINKED)
 111     {
 112         OUString aName = xAttributes->getValue(NAMESPACE_TOKEN(XML_NAMESPACE_OOO) | XML_NAME);
 113
 114         OUString aStorageURL = xAttributes->getValue(XML_ELEMENT(XLINK, XML_HREF));
 115
 116         bool bReadOnly = false;
 117         getBoolAttr(&bReadOnly, NAMESPACE_TOKEN(XML_NAMESPACE_OOO) | XML_READONLY, xAttributes);
 118
 119         if (m_xLibContainer.is())
 120         {
 121             try
 122             {
 123                 Reference<container::XNameAccess> xLib(
 124                     m_xLibContainer->createLibraryLink(aName, aStorageURL, bReadOnly));
 125                 if (xLib.is())
 126                     return new BasicElementBase(GetImport());
 127             }
 128             catch (const container::ElementExistException&)
 129             {
 130                 TOOLS_INFO_EXCEPTION("xmlscript.xmlflat",
 131                                      "BasicLibrariesElement::startChildElement");
 132             }
 133             catch (const lang::IllegalArgumentException&)
 134             {
 135                 TOOLS_INFO_EXCEPTION("xmlscript.xmlflat",
 136                                      "BasicLibrariesElement::startChildElement");
 137             }
 138         }
 139     }
 140     else if ((nElement & TOKEN_MASK) == XML_LIBRARY_EMBEDDED)
 141     {
 142         // TODO: create password protected libraries
 143
 144         OUString aName = xAttributes->getValue(NAMESPACE_TOKEN(XML_NAMESPACE_OOO) | XML_NAME);
 145
 146         bool bReadOnly = false;
 147         getBoolAttr(&bReadOnly, NAMESPACE_TOKEN(XML_NAMESPACE_OOO) | XML_READONLY, xAttributes);
 148
 149         if (m_xLibContainer.is())
 150         {
 151             try
 152             {
 153                 Reference<container::XNameContainer> xLib;
 154                 if (m_xLibContainer->hasByName(aName))
 155                 {
 156                     // Standard library
 157                     m_xLibContainer->getByName(aName) >>= xLib;
 158                 }
 159                 else
 160                 {
 161                     xLib.set(m_xLibContainer->createLibrary(aName));
 162                 }
 163
 164                 if (xLib.is())
 165                     return new BasicEmbeddedLibraryElement(GetImport(), m_xLibContainer, aName,
 166                                                            bReadOnly);
 167             }
 168             catch (const lang::IllegalArgumentException&)
 169             {
 170                 TOOLS_INFO_EXCEPTION("xmlscript.xmlflat",
 171                                      "BasicLibrariesElement::startChildElement");
 172             }
 173         }
 174     }
 175     else
 176     {
 177         throw xml::sax::SAXException(u"expected library-linked or library-embedded element!"_ustr,
 178                                      Reference<XInterface>(), Any());
 179     }
 180
 181     return nullptr;
 182 }
 183
 184 // BasicEmbeddedLibraryElement
 185
 186 BasicEmbeddedLibraryElement::BasicEmbeddedLibraryElement(
 187     SvXMLImport& rImport, const Reference<script::XLibraryContainer2>& rxLibContainer,
 188     OUString aLibName, bool bReadOnly)
 189     : BasicElementBase(rImport)
 190     , m_xLibContainer(rxLibContainer)
 191     , m_aLibName(std::move(aLibName))
 192     , m_bReadOnly(bReadOnly)
 193 {
 194     try
 195     {
 196         if (m_xLibContainer.is() && m_xLibContainer->hasByName(m_aLibName))
 197             m_xLibContainer->getByName(m_aLibName) >>= m_xLib;
 198     }
 199     catch (const lang::WrappedTargetException&)
 200     {
 201         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicEmbeddedLibraryElement::CTOR:");
 202     }
 203 }
 204
 205 Reference<XFastContextHandler> BasicEmbeddedLibraryElement::createFastChildContext(
 206     sal_Int32 nElement, const Reference<XFastAttributeList>& xAttributes)
 207 {
 208     if (!IsTokenInNamespace(nElement, XML_NAMESPACE_OOO))
 209     {
 210         throw xml::sax::SAXException(u"illegal namespace!"_ustr, Reference<XInterface>(), Any());
 211     }
 212     else if ((nElement & TOKEN_MASK) == XML_MODULE)
 213     {
 214         OUString aName = xAttributes->getValue(NAMESPACE_TOKEN(XML_NAMESPACE_OOO) | XML_NAME);
 215
 216         if (m_xLib.is() && !aName.isEmpty())
 217             return new BasicModuleElement(GetImport(), m_xLib, aName);
 218     }
 219     else
 220     {
 221         throw xml::sax::SAXException(u"expected module element!"_ustr, Reference<XInterface>(),
 222                                      Any());
 223     }
 224
 225     return nullptr;
 226 }
 227
 228 void BasicEmbeddedLibraryElement::endFastElement(sal_Int32)
 229 {
 230     if (m_xLibContainer.is() && m_xLibContainer->hasByName(m_aLibName) && m_bReadOnly)
 231         m_xLibContainer->setLibraryReadOnly(m_aLibName, m_bReadOnly);
 232 }
 233
 234 // BasicModuleElement
 235
 236 BasicModuleElement::BasicModuleElement(SvXMLImport& rImport,
 237                                        const Reference<container::XNameContainer>& rxLib,
 238                                        OUString aName)
 239     : BasicElementBase(rImport)
 240     , m_xLib(rxLib)
 241     , m_aName(std::move(aName))
 242 {
 243 }
 244
 245 Reference<XFastContextHandler>
 246 BasicModuleElement::createFastChildContext(sal_Int32 nElement,
 247                                            const Reference<XFastAttributeList>& xAttributes)
 248 {
 249     // TODO: <byte-code>
 250
 251     if (!IsTokenInNamespace(nElement, XML_NAMESPACE_OOO))
 252     {
 253         throw xml::sax::SAXException(u"illegal namespace!"_ustr, Reference<XInterface>(), Any());
 254     }
 255     else if ((nElement & TOKEN_MASK) == XML_SOURCE_CODE)
 256     {
 257         // TODO: password protected libraries
 258
 259         if (xAttributes.is())
 260         {
 261             if (m_xLib.is() && !m_aName.isEmpty())
 262                 return new BasicSourceCodeElement(GetImport(), m_xLib, m_aName);
 263         }
 264     }
 265     else
 266     {
 267         throw xml::sax::SAXException(u"expected source-code element!"_ustr, Reference<XInterface>(),
 268                                      Any());
 269     }
 270
 271     return nullptr;
 272 }
 273
 274 // BasicSourceCodeElement
 275
 276 BasicSourceCodeElement::BasicSourceCodeElement(SvXMLImport& rImport,
 277                                                const Reference<container::XNameContainer>& rxLib,
 278                                                OUString rName)
 279     : BasicElementBase(rImport)
 280     , m_xLib(rxLib)
 281     , m_aName(std::move(rName))
 282 {
 283 }
 284
 285 // XElement
 286
 287 void BasicSourceCodeElement::characters(const OUString& rChars) { m_aBuffer.append(rChars); }
 288
 289 void BasicSourceCodeElement::endFastElement(sal_Int32)
 290 {
 291     try
 292     {
 293         if (m_xLib.is() && !m_aName.isEmpty())
 294         {
 295             Any aElement;
 296             aElement <<= m_aBuffer.makeStringAndClear();
 297             m_xLib->insertByName(m_aName, aElement);
 298         }
 299     }
 300     catch (const container::ElementExistException&)
 301     {
 302         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement");
 303     }
 304     catch (const lang::IllegalArgumentException&)
 305     {
 306         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement");
 307     }
 308     catch (const lang::WrappedTargetException&)
 309     {
 310         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement");
 311     }
 312 }
 313 }
 314
 315 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */