unoxml/source/dom/attr.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 "attr.hxx"
  21
  22 #include <string.h>
  23
  24 #include <memory>
  25 #include <libxml/entities.h>
  26
  27 #include <osl/diagnose.h>
  28 #include <sal/log.hxx>
  29
  30 #include <com/sun/star/xml/dom/events/XMutationEvent.hpp>
  31
  32 #include "document.hxx"
  33
  34 using namespace css::uno;
  35 using namespace css::xml::dom;
  36 using namespace css::xml::dom::events;
  37
  38 namespace DOM
  39 {
  40     CAttr::CAttr(CDocument const& rDocument, ::osl::Mutex const& rMutex,
  41             xmlAttrPtr const pAttr)
  42         : CAttr_Base(rDocument, rMutex,
  43                 NodeType_ATTRIBUTE_NODE, reinterpret_cast<xmlNodePtr>(pAttr))
  44         , m_aAttrPtr(pAttr)
  45     {
  46     }
  47
  48     xmlNsPtr CAttr::GetNamespace(xmlNodePtr const pNode)
  49     {
  50         if (!m_oNamespace)
  51         {
  52             return nullptr;
  53         }
  54         xmlChar const*const pUri(reinterpret_cast<xmlChar const*>(
  55                 m_oNamespace->first.getStr()));
  56         xmlChar const*const pPrefix(reinterpret_cast<xmlChar const*>(
  57                 m_oNamespace->second.getStr()));
  58         xmlNsPtr pNs = xmlSearchNs(pNode->doc, pNode, pPrefix);
  59         if (pNs && (0 != xmlStrcmp(pNs->href, pUri))) {
  60             return pNs;
  61         }
  62         pNs = xmlNewNs(pNode, pUri, pPrefix);
  63         if (pNs) {
  64             return pNs;
  65         }
  66         pNs = xmlSearchNsByHref(pNode->doc, pNode, pUri);
  67         // if (!pNs) hmm... now what? throw?
  68         if (!pNs) {
  69             SAL_WARN("unoxml", "CAttr: cannot create namespace");
  70         }
  71         return pNs;
  72     }
  73
  74     bool CAttr::IsChildTypeAllowed(NodeType const nodeType, NodeType const*const)
  75     {
  76         switch (nodeType) {
  77             case NodeType_TEXT_NODE:
  78             case NodeType_ENTITY_REFERENCE_NODE:
  79                 return true;
  80             default:
  81                 return false;
  82         }
  83     }
  84
  85     OUString SAL_CALL CAttr::getNodeName()
  86     {
  87         return getName();
  88     }
  89     OUString SAL_CALL CAttr::getNodeValue()
  90     {
  91         return getValue();
  92     }
  93     OUString SAL_CALL CAttr::getLocalName()
  94     {
  95         return getName();
  96     }
  97
  98
  99     /**
 100     Returns the name of this attribute.
 101     */
 102     OUString SAL_CALL CAttr::getName()
 103     {
 104         ::osl::MutexGuard const g(m_rMutex);
 105
 106         if ((nullptr == m_aNodePtr) || (nullptr == m_aAttrPtr)) {
 107             return OUString();
 108         }
 109         OUString const aName(reinterpret_cast<char const *>(m_aAttrPtr->name),
 110                 strlen(reinterpret_cast<char const *>(m_aAttrPtr->name)), RTL_TEXTENCODING_UTF8);
 111         return aName;
 112     }
 113
 114     /**
 115     The Element node this attribute is attached to or null if this
 116     attribute is not in use.
 117     */
 118     Reference< XElement > SAL_CALL CAttr::getOwnerElement()
 119     {
 120         ::osl::MutexGuard const g(m_rMutex);
 121
 122         if ((nullptr == m_aNodePtr) || (nullptr == m_aAttrPtr)) {
 123             return nullptr;
 124         }
 125         if (nullptr == m_aAttrPtr->parent) {
 126             return nullptr;
 127         }
 128         Reference< XElement > const xRet(
 129             static_cast< XNode* >(GetOwnerDocument().GetCNode(
 130                     m_aAttrPtr->parent).get()),
 131             UNO_QUERY_THROW);
 132         return xRet;
 133     }
 134
 135     /**
 136     If this attribute was explicitly given a value in the original
 137     document, this is true; otherwise, it is false.
 138     */
 139     sal_Bool SAL_CALL CAttr::getSpecified()
 140     {
 141         // FIXME if this DOM implementation supported DTDs it would need
 142         // to check that this attribute is not default or something
 143         return true;
 144     }
 145
 146     /**
 147     On retrieval, the value of the attribute is returned as a string.
 148     */
 149     OUString SAL_CALL CAttr::getValue()
 150     {
 151         ::osl::MutexGuard const g(m_rMutex);
 152
 153         if ((nullptr == m_aNodePtr) || (nullptr == m_aAttrPtr)) {
 154             return OUString();
 155         }
 156         if (nullptr == m_aAttrPtr->children) {
 157             return OUString();
 158         }
 159         char const*const pContent(reinterpret_cast<char const*>(m_aAttrPtr->children->content));
 160         return OUString(pContent, strlen(pContent), RTL_TEXTENCODING_UTF8);
 161     }
 162
 163     /**
 164     Sets the value of the attribute from a string.
 165     */
 166     void SAL_CALL CAttr::setValue(const OUString& value)
 167     {
 168         ::osl::ClearableMutexGuard guard(m_rMutex);
 169
 170         if ((nullptr == m_aNodePtr) || (nullptr == m_aAttrPtr)) {
 171             return;
 172         }
 173
 174         // remember old value (for mutation event)
 175         OUString sOldValue = getValue();
 176
 177         OString o1 = OUStringToOString(value, RTL_TEXTENCODING_UTF8);
 178         xmlChar const * pValue = reinterpret_cast<xmlChar const *>(o1.getStr());
 179         // this does not work if the attribute was created anew
 180         // xmlNodePtr pNode = m_aAttrPtr->parent;
 181         // xmlSetProp(pNode, m_aAttrPtr->name, pValue);
 182         std::shared_ptr<xmlChar const> const buffer(
 183                 xmlEncodeEntitiesReentrant(m_aAttrPtr->doc, pValue), xmlFree);
 184         xmlFreeNodeList(m_aAttrPtr->children);
 185         m_aAttrPtr->children =
 186             xmlStringGetNodeList(m_aAttrPtr->doc, buffer.get());
 187         xmlNodePtr tmp = m_aAttrPtr->children;
 188         while (tmp != nullptr) {
 189             tmp->parent = m_aNodePtr;
 190             tmp->doc = m_aAttrPtr->doc;
 191             if (tmp->next == nullptr)
 192                 m_aNodePtr->last = tmp;
 193             tmp = tmp->next;
 194         }
 195
 196         // dispatch DOM events to signal change in attribute value
 197         // dispatch DomAttrModified + DOMSubtreeModified
 198         OUString sEventName( "DOMAttrModified" );
 199         Reference< XDocumentEvent > docevent(getOwnerDocument(), UNO_QUERY);
 200         Reference< XMutationEvent > event(docevent->createEvent(sEventName),UNO_QUERY);
 201         event->initMutationEvent(
 202                 sEventName, true, false,
 203                 Reference<XNode>( static_cast<XAttr*>( this ) ),
 204                 sOldValue, value, getName(), AttrChangeType_MODIFICATION );
 205
 206         guard.clear(); // release mutex before calling event handlers
 207
 208         dispatchEvent(event);
 209         dispatchSubtreeModified();
 210     }
 211
 212     void SAL_CALL CAttr::setPrefix(const OUString& prefix)
 213     {
 214         ::osl::MutexGuard const g(m_rMutex);
 215
 216         if (!m_aNodePtr) { return; }
 217
 218         if (m_oNamespace)
 219         {
 220             OSL_ASSERT(!m_aNodePtr->parent);
 221             m_oNamespace->second =
 222                 OUStringToOString(prefix, RTL_TEXTENCODING_UTF8);
 223         }
 224         else
 225         {
 226             CNode::setPrefix(prefix);
 227         }
 228     }
 229
 230     OUString SAL_CALL CAttr::getPrefix()
 231     {
 232         ::osl::MutexGuard const g(m_rMutex);
 233
 234         if (!m_aNodePtr) { return OUString(); }
 235
 236         if (m_oNamespace)
 237         {
 238             OSL_ASSERT(!m_aNodePtr->parent);
 239             OUString const ret(OStringToOUString(
 240                         m_oNamespace->second, RTL_TEXTENCODING_UTF8));
 241             return ret;
 242         }
 243         else
 244         {
 245             return CNode::getPrefix();
 246         }
 247     }
 248
 249     OUString SAL_CALL CAttr::getNamespaceURI()
 250     {
 251         ::osl::MutexGuard const g(m_rMutex);
 252
 253         if (!m_aNodePtr) { return OUString(); }
 254
 255         if (m_oNamespace)
 256         {
 257             OSL_ASSERT(!m_aNodePtr->parent);
 258             OUString const ret(OStringToOUString(
 259                         m_oNamespace->first, RTL_TEXTENCODING_UTF8));
 260             return ret;
 261         }
 262         else
 263         {
 264             return CNode::getNamespaceURI();
 265         }
 266     }
 267 }
 268
 269 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */