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