xmloff/source/text/XMLIndexTOCContext.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 "XMLIndexTOCContext.hxx"
  21 #include <com/sun/star/frame/XModel.hpp>
  22 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  23 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  24 #include <com/sun/star/uno/XInterface.hpp>
  25 #include <com/sun/star/text/XTextContent.hpp>
  26 #include <com/sun/star/beans/XPropertySet.hpp>
  27 #include <sax/tools/converter.hxx>
  28 #include "XMLIndexTOCSourceContext.hxx"
  29 #include "XMLIndexObjectSourceContext.hxx"
  30 #include "XMLIndexAlphabeticalSourceContext.hxx"
  31 #include "XMLIndexUserSourceContext.hxx"
  32 #include "XMLIndexBibliographySourceContext.hxx"
  33 #include "XMLIndexTableSourceContext.hxx"
  34 #include "XMLIndexIllustrationSourceContext.hxx"
  35 #include "XMLIndexBodyContext.hxx"
  36 #include <xmloff/xmlictxt.hxx>
  37 #include <xmloff/xmlimp.hxx>
  38 #include <xmloff/txtimp.hxx>
  39 #include <xmloff/namespacemap.hxx>
  40 #include <xmloff/xmlnamespace.hxx>
  41 #include <xmloff/xmltoken.hxx>
  42 #include <xmloff/prstylei.hxx>
  43 #include <xmloff/xmlerror.hxx>
  44 #include <xmloff/xmluconv.hxx>
  45 #include <xmloff/xmlement.hxx>
  46 #include <rtl/ustring.hxx>
  47 #include <osl/diagnose.h>
  48
  49
  50 using namespace ::com::sun::star::uno;
  51 using namespace ::com::sun::star::text;
  52 using namespace ::xmloff::token;
  53
  54 using ::com::sun::star::beans::XPropertySet;
  55 using ::com::sun::star::uno::Reference;
  56 using ::com::sun::star::xml::sax::XAttributeList;
  57 using ::com::sun::star::lang::XMultiServiceFactory;
  58 using ::com::sun::star::lang::IllegalArgumentException;
  59
  60
  61 static const char* aIndexServiceMap[] =
  62 {
  63     "com.sun.star.text.ContentIndex",
  64     "com.sun.star.text.DocumentIndex",
  65     "com.sun.star.text.TableIndex",
  66     "com.sun.star.text.ObjectIndex",
  67     "com.sun.star.text.Bibliography",
  68     "com.sun.star.text.UserIndex",
  69     "com.sun.star.text.IllustrationsIndex"
  70 };
  71
  72 const XMLTokenEnum aIndexSourceElementMap[] =
  73 {
  74     XML_TABLE_OF_CONTENT_SOURCE,
  75     XML_ALPHABETICAL_INDEX_SOURCE,
  76     XML_TABLE_INDEX_SOURCE,
  77     XML_OBJECT_INDEX_SOURCE,
  78     XML_BIBLIOGRAPHY_SOURCE,
  79     XML_USER_INDEX_SOURCE,
  80     XML_ILLUSTRATION_INDEX_SOURCE
  81 };
  82
  83 SvXMLEnumMapEntry<IndexTypeEnum> const aIndexTypeMap[] =
  84 {
  85     { XML_TABLE_OF_CONTENT,     TEXT_INDEX_TOC },
  86     { XML_ALPHABETICAL_INDEX,   TEXT_INDEX_ALPHABETICAL },
  87     { XML_TABLE_INDEX,          TEXT_INDEX_TABLE },
  88     { XML_OBJECT_INDEX,         TEXT_INDEX_OBJECT },
  89     { XML_BIBLIOGRAPHY,         TEXT_INDEX_BIBLIOGRAPHY },
  90     { XML_USER_INDEX,           TEXT_INDEX_USER },
  91     { XML_ILLUSTRATION_INDEX,   TEXT_INDEX_ILLUSTRATION },
  92     { XML_TOKEN_INVALID,        IndexTypeEnum(0) }
  93 };
  94
  95
  96 XMLIndexTOCContext::XMLIndexTOCContext(SvXMLImport& rImport,
  97     sal_uInt16 nPrfx, const OUString& rLocalName)
  98     : SvXMLImportContext(rImport, nPrfx, rLocalName)
  99     , eIndexType(TEXT_INDEX_UNKNOWN)
 100     , bValid(false)
 101 {
 102     if (XML_NAMESPACE_TEXT == nPrfx)
 103     {
 104         if (SvXMLUnitConverter::convertEnum(eIndexType, rLocalName, aIndexTypeMap))
 105         {
 106             // check for array index:
 107             OSL_ENSURE(unsigned(eIndexType) < (SAL_N_ELEMENTS(aIndexServiceMap)), "index out of range");
 108             OSL_ENSURE(SAL_N_ELEMENTS(aIndexServiceMap) ==
 109                        SAL_N_ELEMENTS(aIndexSourceElementMap),
 110                        "service and source element maps must be same size");
 111             bValid = true;
 112         }
 113     }
 114 }
 115
 116 XMLIndexTOCContext::~XMLIndexTOCContext()
 117 {
 118 }
 119
 120 void XMLIndexTOCContext::StartElement(
 121     const Reference<XAttributeList> & xAttrList)
 122 {
 123     if (!bValid)
 124         return;
 125
 126     // find text:style-name attribute and set section style
 127     // find text:protected and set value
 128     // find text:name and set value (if not empty)
 129     sal_Int16 nCount = xAttrList->getLength();
 130     bool bProtected = false;
 131     OUString sIndexName;
 132     OUString sXmlId;
 133     XMLPropStyleContext* pStyle(nullptr);
 134     for(sal_Int16 nAttr = 0; nAttr < nCount; nAttr++)
 135     {
 136         OUString sLocalName;
 137         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
 138             GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
 139                               &sLocalName );
 140         if ( XML_NAMESPACE_TEXT == nPrefix)
 141         {
 142             if ( IsXMLToken( sLocalName, XML_STYLE_NAME ) )
 143             {
 144                 pStyle = GetImport().GetTextImport()->FindSectionStyle(
 145                             xAttrList->getValueByIndex(nAttr));
 146             }
 147             else if ( IsXMLToken( sLocalName, XML_PROTECTED ) )
 148             {
 149                 bool bTmp(false);
 150                 if (::sax::Converter::convertBool(
 151                      bTmp, xAttrList->getValueByIndex(nAttr)))
 152                 {
 153                     bProtected = bTmp;
 154                 }
 155             }
 156             else if ( IsXMLToken( sLocalName, XML_NAME ) )
 157             {
 158                 sIndexName = xAttrList->getValueByIndex(nAttr);
 159             }
 160         }
 161         else if ( XML_NAMESPACE_XML == nPrefix)
 162         {
 163             if ( IsXMLToken( sLocalName, XML_ID ) )
 164             {
 165                 sXmlId = xAttrList->getValueByIndex(nAttr);
 166             }
 167         }
 168     }
 169
 170     // create table of content (via MultiServiceFactory)
 171     Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),
 172                                              UNO_QUERY);
 173     if( xFactory.is() )
 174     {
 175         Reference<XInterface> xIfc =
 176             xFactory->createInstance(
 177                 OUString::createFromAscii(aIndexServiceMap[eIndexType]));
 178         if( xIfc.is() )
 179         {
 180             // get Property set
 181             Reference<XPropertySet> xPropSet(xIfc, UNO_QUERY);
 182             xTOCPropertySet = xPropSet;
 183
 184             // insert section
 185             // a) insert section
 186             //    The inserted index consists of an empty paragraph
 187             //    only, as well as an empty paragraph *after* the index
 188             // b) insert marker after index, and put Cursor inside of the
 189             //    index
 190
 191             // preliminaries
 192 #ifndef DBG_UTIL
 193             OUString const sMarker(" ");
 194 #else
 195             OUString const sMarker("Y");
 196 #endif
 197             rtl::Reference<XMLTextImportHelper> rImport =
 198                 GetImport().GetTextImport();
 199
 200             // a) insert index
 201             Reference<XTextContent> xTextContent(xIfc, UNO_QUERY);
 202             try
 203             {
 204                 GetImport().GetTextImport()->InsertTextContent(
 205                     xTextContent);
 206             }
 207             catch(const IllegalArgumentException& e)
 208             {
 209                 // illegal argument? Then we can't accept indices here!
 210                 Sequence<OUString> aSeq { GetLocalName() };
 211                 GetImport().SetError(
 212                     XMLERROR_FLAG_ERROR | XMLERROR_NO_INDEX_ALLOWED_HERE,
 213                     aSeq, e.Message, nullptr );
 214
 215                 // set bValid to false, and return prematurely
 216                 bValid = false;
 217                 return;
 218             }
 219
 220             // xml:id for RDF metadata
 221             GetImport().SetXmlId(xIfc, sXmlId);
 222
 223             // b) insert marker and move cursor
 224             rImport->InsertString(sMarker);
 225             rImport->GetCursor()->goLeft(2, false);
 226         }
 227     }
 228
 229     // finally, check for redlines that should start at
 230     // the section start node
 231     if( bValid )
 232         GetImport().GetTextImport()->RedlineAdjustStartNodeCursor();
 233
 234     if (pStyle != nullptr)
 235     {
 236         pStyle->FillPropertySet( xTOCPropertySet );
 237     }
 238
 239     xTOCPropertySet->setPropertyValue( "IsProtected", Any(bProtected) );
 240
 241     if (!sIndexName.isEmpty())
 242     {
 243         xTOCPropertySet->setPropertyValue( "Name", Any(sIndexName) );
 244     }
 245
 246 }
 247
 248 void XMLIndexTOCContext::endFastElement(sal_Int32 )
 249 {
 250     // complete import of index by removing the markers (if the index
 251     // was actually inserted, that is)
 252     if( bValid )
 253     {
 254         // preliminaries
 255         rtl::Reference<XMLTextImportHelper> rHelper= GetImport().GetTextImport();
 256
 257         // get rid of last paragraph (unless it's the only paragraph)
 258         rHelper->GetCursor()->goRight(1, false);
 259         if( xBodyContextRef.is() && xBodyContextRef->HasContent() )
 260         {
 261             rHelper->GetCursor()->goLeft(1, true);
 262             rHelper->GetText()->insertString(rHelper->GetCursorAsRange(),
 263                                              "", true);
 264         }
 265
 266         // and delete second marker
 267         rHelper->GetCursor()->goRight(1, true);
 268         rHelper->GetText()->insertString(rHelper->GetCursorAsRange(),
 269                                          "", true);
 270
 271         // check for Redlines on our end node
 272         GetImport().GetTextImport()->RedlineAdjustStartNodeCursor();
 273     }
 274 }
 275
 276 SvXMLImportContextRef XMLIndexTOCContext::CreateChildContext(
 277     sal_uInt16 nPrefix,
 278     const OUString& rLocalName,
 279     const Reference<XAttributeList> & /*xAttrList*/ )
 280 {
 281     SvXMLImportContextRef xContext;
 282
 283     if (bValid)
 284     {
 285         if (XML_NAMESPACE_TEXT == nPrefix)
 286         {
 287             if ( IsXMLToken( rLocalName, XML_INDEX_BODY ) )
 288             {
 289                 rtl::Reference<XMLIndexBodyContext> xNewBodyContext = new XMLIndexBodyContext(GetImport(), nPrefix,
 290                                                    rLocalName);
 291                 xContext = xNewBodyContext;
 292                 if ( !xBodyContextRef.is() || !xBodyContextRef->HasContent() )
 293                 {
 294                     xBodyContextRef = xNewBodyContext;
 295                 }
 296             }
 297             else if (IsXMLToken(rLocalName, aIndexSourceElementMap[eIndexType]))
 298             {
 299                 // instantiate source context for the appropriate index type
 300                 switch (eIndexType)
 301                 {
 302                     case TEXT_INDEX_TOC:
 303                         xContext = new XMLIndexTOCSourceContext(
 304                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 305                         break;
 306
 307                     case TEXT_INDEX_OBJECT:
 308                         xContext = new XMLIndexObjectSourceContext(
 309                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 310                         break;
 311
 312                     case TEXT_INDEX_ALPHABETICAL:
 313                         xContext = new XMLIndexAlphabeticalSourceContext(
 314                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 315                         break;
 316
 317                     case TEXT_INDEX_USER:
 318                         xContext = new XMLIndexUserSourceContext(
 319                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 320                         break;
 321
 322                     case TEXT_INDEX_BIBLIOGRAPHY:
 323                         xContext = new XMLIndexBibliographySourceContext(
 324                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 325                         break;
 326
 327                     case TEXT_INDEX_TABLE:
 328                         xContext = new XMLIndexTableSourceContext(
 329                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 330                         break;
 331
 332                     case TEXT_INDEX_ILLUSTRATION:
 333                         xContext = new XMLIndexIllustrationSourceContext(
 334                             GetImport(), nPrefix, rLocalName, xTOCPropertySet);
 335                         break;
 336
 337                     default:
 338                         OSL_FAIL("index type not implemented");
 339                         break;
 340                 }
 341             }
 342             // else: ignore
 343         }
 344         // else: no text: namespace -> ignore
 345     }
 346     // else: not valid -> ignore
 347
 348     return xContext;
 349 }
 350
 351 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */