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