writerfilter/source/ooxml/OOXMLFactory.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 <rtl/instance.hxx>
  21 #include <sax/fastattribs.hxx>
  22 #include "OOXMLFactory.hxx"
  23 #include "OOXMLFastHelper.hxx"
  24
  25 namespace writerfilter {
  26 namespace ooxml {
  27
  28 using namespace com::sun::star;
  29
  30 // class OOXMLFactory_ns
  31
  32 OOXMLFactory_ns::~OOXMLFactory_ns()
  33 {
  34 }
  35
  36 // class OOXMLFactory
  37
  38 void OOXMLFactory::attributes(OOXMLFastContextHandler * pHandler,
  39                               const uno::Reference< xml::sax::XFastAttributeList > & xAttribs)
  40 {
  41     Id nDefine = pHandler->getDefine();
  42     OOXMLFactory_ns::Pointer_t pFactory = getFactoryForNamespace(nDefine);
  43
  44     if (pFactory.get() == nullptr)
  45         return;
  46
  47     sax_fastparser::FastAttributeList *pAttribs =
  48             sax_fastparser::FastAttributeList::castToFastAttributeList( xAttribs );
  49
  50     const AttributeInfo *pAttr = pFactory->getAttributeInfoArray(nDefine);
  51     if (!pAttr)
  52         return;
  53
  54     for (; pAttr->m_nToken != -1; ++pAttr)
  55     {
  56         sal_Int32 nToken = pAttr->m_nToken;
  57         sal_Int32 nAttrIndex = pAttribs->getAttributeIndex(nToken);
  58         if (nAttrIndex == -1)
  59             continue;
  60
  61         Id nId = pFactory->getResourceId(nDefine, nToken);
  62
  63         switch (pAttr->m_nResource)
  64         {
  65         case ResourceType::Boolean:
  66             {
  67                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
  68                 OOXMLValue::Pointer_t xValue(OOXMLBooleanValue::Create(pValue));
  69                 pHandler->newProperty(nId, xValue);
  70                 pFactory->attributeAction(pHandler, nToken, xValue);
  71             }
  72             break;
  73         case ResourceType::String:
  74             {
  75                 OUString aValue(pAttribs->getValueByIndex(nAttrIndex));
  76                 OOXMLValue::Pointer_t xValue(new OOXMLStringValue(aValue));
  77                 pHandler->newProperty(nId, xValue);
  78                 pFactory->attributeAction(pHandler, nToken, xValue);
  79             }
  80             break;
  81         case ResourceType::Integer:
  82             {
  83                 sal_Int32 nValue = pAttribs->getAsIntegerByIndex(nAttrIndex);
  84                 OOXMLValue::Pointer_t xValue = OOXMLIntegerValue::Create(nValue);
  85                 pHandler->newProperty(nId, xValue);
  86                 pFactory->attributeAction(pHandler, nToken, xValue);
  87             }
  88             break;
  89         case ResourceType::Hex:
  90             {
  91                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
  92                 OOXMLValue::Pointer_t xValue(new OOXMLHexValue(pValue));
  93                 pHandler->newProperty(nId, xValue);
  94                 pFactory->attributeAction(pHandler, nToken, xValue);
  95             }
  96             break;
  97         case ResourceType::HexColor:
  98             {
  99                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
 100                 OOXMLValue::Pointer_t xValue(new OOXMLHexColorValue(pValue));
 101                 pHandler->newProperty(nId, xValue);
 102                 pFactory->attributeAction(pHandler, nToken, xValue);
 103             }
 104             break;
 105         case ResourceType::TwipsMeasure_asSigned:
 106         case ResourceType::TwipsMeasure_asZero:
 107             {
 108                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
 109                 OOXMLValue::Pointer_t xValue(new OOXMLTwipsMeasureValue(pValue));
 110                 if ( xValue->getInt() < 0 )
 111                 {
 112                     if ( pAttr->m_nResource == ResourceType::TwipsMeasure_asZero )
 113                         xValue = OOXMLIntegerValue::Create(0);
 114                 }
 115                 pHandler->newProperty(nId, xValue);
 116                 pFactory->attributeAction(pHandler, nToken, xValue);
 117             }
 118             break;
 119         case ResourceType::HpsMeasure:
 120             {
 121                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
 122                 OOXMLValue::Pointer_t xValue(new OOXMLHpsMeasureValue(pValue));
 123                 pHandler->newProperty(nId, xValue);
 124                 pFactory->attributeAction(pHandler, nToken, xValue);
 125             }
 126         break;
 127         case ResourceType::MeasurementOrPercent:
 128             {
 129                 const char *pValue = pAttribs->getAsCharByIndex(nAttrIndex);
 130                 OOXMLValue::Pointer_t xValue(new OOXMLMeasurementOrPercentValue(pValue));
 131                 pHandler->newProperty(nId, xValue);
 132                 pFactory->attributeAction(pHandler, nToken, xValue);
 133             }
 134             break;
 135         case ResourceType::List:
 136             {
 137                 sal_uInt32 nValue;
 138                 if (pFactory->getListValue(pAttr->m_nRef, pAttribs->getValueByIndex(nAttrIndex), nValue))
 139                 {
 140                     OOXMLValue::Pointer_t xValue = OOXMLIntegerValue::Create(nValue);
 141                     pHandler->newProperty(nId, xValue);
 142                     pFactory->attributeAction(pHandler, nToken, xValue);
 143                 }
 144             }
 145             break;
 146         default:
 147             break;
 148         }
 149     }
 150 }
 151
 152 uno::Reference< xml::sax::XFastContextHandler>
 153 OOXMLFactory::createFastChildContext(OOXMLFastContextHandler * pHandler,
 154                                      Token_t Element)
 155 {
 156     Id nDefine = pHandler->getDefine();
 157
 158     OOXMLFactory_ns::Pointer_t pFactory = getFactoryForNamespace(nDefine);
 159
 160     uno::Reference< xml::sax::XFastContextHandler> ret;
 161
 162     //Avoid handling unknown tokens and recursing to death
 163     if ((Element & 0xffff) < oox::XML_TOKEN_COUNT)
 164         ret = createFastChildContextFromFactory(pHandler, pFactory, Element);
 165
 166     return ret;
 167 }
 168
 169 void OOXMLFactory::characters(OOXMLFastContextHandler * pHandler,
 170                               const OUString & rString)
 171 {
 172     Id nDefine = pHandler->getDefine();
 173     OOXMLFactory_ns::Pointer_t pFactory = getFactoryForNamespace(nDefine);
 174
 175     if (pFactory.get() != nullptr)
 176     {
 177         pFactory->charactersAction(pHandler, rString);
 178     }
 179 }
 180
 181 void OOXMLFactory::startAction(OOXMLFastContextHandler * pHandler)
 182 {
 183     Id nDefine = pHandler->getDefine();
 184     OOXMLFactory_ns::Pointer_t pFactory = getFactoryForNamespace(nDefine);
 185
 186     if (pFactory.get() != nullptr)
 187     {
 188         pFactory->startAction(pHandler);
 189     }
 190 }
 191
 192 void OOXMLFactory::endAction(OOXMLFastContextHandler * pHandler)
 193 {
 194     Id nDefine = pHandler->getDefine();
 195     OOXMLFactory_ns::Pointer_t pFactory = getFactoryForNamespace(nDefine);
 196
 197     if (pFactory.get() != nullptr)
 198     {
 199         pFactory->endAction(pHandler);
 200     }
 201 }
 202
 203 void OOXMLFactory_ns::startAction(OOXMLFastContextHandler *)
 204 {
 205 }
 206
 207 void OOXMLFactory_ns::endAction(OOXMLFastContextHandler *)
 208 {
 209 }
 210
 211 void OOXMLFactory_ns::charactersAction(OOXMLFastContextHandler *, const OUString &)
 212 {
 213 }
 214
 215 void OOXMLFactory_ns::attributeAction(OOXMLFastContextHandler *, Token_t, const OOXMLValue::Pointer_t&)
 216 {
 217 }
 218
 219 }
 220 }
 221
 222 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */