xmloff/source/text/txtparai.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 <xmloff/unointerfacetouniqueidentifiermapper.hxx>
  21 #include <rtl/ustring.hxx>
  22 #include <rtl/ustrbuf.hxx>
  23 #include <boost/ptr_container/ptr_vector.hpp>
  24
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <com/sun/star/text/XTextFrame.hpp>
  27 #include <com/sun/star/text/XTextCursor.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  30 #include <com/sun/star/text/ControlCharacter.hpp>
  31 #include <com/sun/star/container/XIndexReplace.hpp>
  32 #include <com/sun/star/drawing/XShapes.hpp>
  33 #include <com/sun/star/container/XEnumerationAccess.hpp>
  34 #include <com/sun/star/rdf/XMetadatable.hpp>
  35
  36 #include <sax/tools/converter.hxx>
  37
  38 #include <xmloff/xmlictxt.hxx>
  39 #include <xmloff/xmlimp.hxx>
  40 #include <xmloff/xmltoken.hxx>
  41 #include <xmloff/nmspmap.hxx>
  42 #include <xmloff/xmlnmspe.hxx>
  43 #include <xmloff/txtimp.hxx>
  44 #include "txtparai.hxx"
  45 #include "txtfldi.hxx"
  46 #include "XMLFootnoteImportContext.hxx"
  47 #include "XMLTextMarkImportContext.hxx"
  48 #include "XMLTextFrameContext.hxx"
  49 #include <xmloff/XMLCharContext.hxx>
  50 #include "XMLTextFrameHyperlinkContext.hxx"
  51 #include <xmloff/XMLEventsImportContext.hxx>
  52 #include "XMLChangeImportContext.hxx"
  53 #include "txtlists.hxx"
  54
  55 #include <txtparaimphint.hxx>
  56 class XMLHints_Impl : public boost::ptr_vector<XMLHint_Impl> {};
  57
  58 using namespace ::com::sun::star;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::text;
  61 using namespace ::com::sun::star::drawing;
  62 using namespace ::com::sun::star::beans;
  63 using namespace ::xmloff::token;
  64 using ::com::sun::star::container::XEnumerationAccess;
  65 using ::com::sun::star::container::XEnumeration;
  66
  67 TYPEINIT1( XMLCharContext, SvXMLImportContext );
  68
  69 XMLCharContext::XMLCharContext(
  70         SvXMLImport& rImport,
  71         sal_uInt16 nPrfx,
  72         const OUString& rLName,
  73         const Reference< xml::sax::XAttributeList > & xAttrList,
  74         sal_Unicode c,
  75         bool bCount ) :
  76     SvXMLImportContext( rImport, nPrfx, rLName )
  77     ,m_nControl(0)
  78     ,m_nCount(1)
  79     ,m_c(c)
  80 {
  81     if( bCount )
  82     {
  83         const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap();
  84         sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
  85         for( sal_Int16 i=0; i < nAttrCount; i++ )
  86         {
  87             const OUString& rAttrName = xAttrList->getNameByIndex( i );
  88
  89             OUString aLocalName;
  90             sal_uInt16 nPrefix =rMap.GetKeyByAttrName( rAttrName,&aLocalName );
  91             if( XML_NAMESPACE_TEXT == nPrefix &&
  92                 IsXMLToken( aLocalName, XML_C ) )
  93             {
  94                 sal_Int32 nTmp = xAttrList->getValueByIndex(i).toInt32();
  95                 if( nTmp > 0L )
  96                 {
  97                     if( nTmp > USHRT_MAX )
  98                         m_nCount = USHRT_MAX;
  99                     else
 100                         m_nCount = (sal_uInt16)nTmp;
 101                 }
 102             }
 103         }
 104     }
 105 }
 106
 107 XMLCharContext::XMLCharContext(
 108         SvXMLImport& rImp,
 109         sal_uInt16 nPrfx,
 110         const OUString& rLName,
 111         const Reference< xml::sax::XAttributeList > &,
 112         sal_Int16 nControl ) :
 113     SvXMLImportContext( rImp, nPrfx, rLName )
 114     ,m_nControl(nControl)
 115     ,m_nCount(0)
 116     ,m_c(0)
 117 {
 118 }
 119
 120 XMLCharContext::~XMLCharContext()
 121 {
 122 }
 123 void XMLCharContext::EndElement()
 124 {
 125     if ( !m_nCount )
 126         InsertControlCharacter( m_nControl );
 127     else
 128     {
 129         if( 1U == m_nCount )
 130         {
 131             OUString sBuff( &m_c, 1 );
 132             InsertString(sBuff);
 133         }
 134         else
 135         {
 136             OUStringBuffer sBuff(static_cast<int>(m_nCount));
 137             while( m_nCount-- )
 138                 sBuff.append( &m_c, 1 );
 139
 140             InsertString(sBuff.makeStringAndClear() );
 141         }
 142     }
 143 }
 144 void XMLCharContext::InsertControlCharacter(sal_Int16   _nControl)
 145 {
 146     GetImport().GetTextImport()->InsertControlCharacter( _nControl );
 147 }
 148 void XMLCharContext::InsertString(const OUString& _sString)
 149 {
 150     GetImport().GetTextImport()->InsertString( _sString );
 151 }
 152
 153 /** import start of reference (<text:reference-start>) */
 154 class XMLStartReferenceContext_Impl : public SvXMLImportContext
 155 {
 156 public:
 157     TYPEINFO_OVERRIDE();
 158
 159     // Do everything in constructor. Well ...
 160     XMLStartReferenceContext_Impl (
 161         SvXMLImport& rImport,
 162         sal_uInt16 nPrefix,
 163         const OUString& rLocalName,
 164         XMLHints_Impl& rHnts,
 165         const Reference<xml::sax::XAttributeList> & xAttrList);
 166
 167     static bool FindName(
 168         SvXMLImport& rImport,
 169         const Reference<xml::sax::XAttributeList> & xAttrList,
 170         OUString& rName);
 171 };
 172
 173 TYPEINIT1( XMLStartReferenceContext_Impl, SvXMLImportContext );
 174
 175 XMLStartReferenceContext_Impl::XMLStartReferenceContext_Impl(
 176     SvXMLImport& rImport,
 177     sal_uInt16 nPrefix,
 178     const OUString& rLocalName,
 179     XMLHints_Impl& rHints,
 180     const Reference<xml::sax::XAttributeList> & xAttrList) :
 181         SvXMLImportContext(rImport, nPrefix, rLocalName)
 182 {
 183     OUString sName;
 184
 185     if (FindName(GetImport(), xAttrList, sName))
 186     {
 187         XMLHint_Impl* pHint = new XMLReferenceHint_Impl(
 188             sName, rImport.GetTextImport()->GetCursor()->getStart() );
 189
 190         // degenerates to point reference, if no end is found!
 191         pHint->SetEnd(rImport.GetTextImport()->GetCursor()->getStart() );
 192
 193         rHints.push_back(pHint);
 194     }
 195 }
 196
 197 bool XMLStartReferenceContext_Impl::FindName(
 198     SvXMLImport& rImport,
 199     const Reference<xml::sax::XAttributeList> & xAttrList,
 200     OUString& rName)
 201 {
 202     bool bNameOK( false );
 203
 204     // find name attribute first
 205     const sal_Int16 nLength( xAttrList->getLength() );
 206     for (sal_Int16 nAttr = 0; nAttr < nLength; nAttr++)
 207     {
 208         OUString sLocalName;
 209         const sal_uInt16 nPrefix = rImport.GetNamespaceMap().
 210             GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
 211                               &sLocalName );
 212
 213         if ( (XML_NAMESPACE_TEXT == nPrefix) &&
 214              IsXMLToken(sLocalName, XML_NAME)   )
 215         {
 216             rName = xAttrList->getValueByIndex(nAttr);
 217             bNameOK = true;
 218         }
 219     }
 220
 221     return bNameOK;
 222 }
 223
 224 /** import end of reference (<text:reference-end>) */
 225 class XMLEndReferenceContext_Impl : public SvXMLImportContext
 226 {
 227 public:
 228     TYPEINFO_OVERRIDE();
 229
 230     // Do everything in constructor. Well ...
 231     XMLEndReferenceContext_Impl(
 232         SvXMLImport& rImport,
 233         sal_uInt16 nPrefix,
 234         const OUString& rLocalName,
 235         XMLHints_Impl& rHnts,
 236         const Reference<xml::sax::XAttributeList> & xAttrList);
 237 };
 238
 239 TYPEINIT1( XMLEndReferenceContext_Impl, SvXMLImportContext );
 240
 241 XMLEndReferenceContext_Impl::XMLEndReferenceContext_Impl(
 242     SvXMLImport& rImport,
 243     sal_uInt16 nPrefix,
 244     const OUString& rLocalName,
 245     XMLHints_Impl& rHints,
 246     const Reference<xml::sax::XAttributeList> & xAttrList) :
 247         SvXMLImportContext(rImport, nPrefix, rLocalName)
 248 {
 249     OUString sName;
 250
 251     // borrow from XMLStartReferenceContext_Impl
 252     if (XMLStartReferenceContext_Impl::FindName(GetImport(), xAttrList, sName))
 253     {
 254         // search for reference start
 255         sal_uInt16 nCount = rHints.size();
 256         for(sal_uInt16 nPos = 0; nPos < nCount; nPos++)
 257         {
 258             XMLHint_Impl *pHint = &rHints[nPos];
 259             if ( pHint->IsReference() &&
 260                  sName.equals( static_cast<XMLReferenceHint_Impl *>(pHint)->GetRefName()) )
 261             {
 262                 // set end and stop searching
 263                 pHint->SetEnd(GetImport().GetTextImport()->
 264                                      GetCursor()->getStart() );
 265                 break;
 266             }
 267         }
 268         // else: no start (in this paragraph) -> ignore
 269     }
 270 }
 271
 272 class XMLImpSpanContext_Impl : public SvXMLImportContext
 273 {
 274     XMLHints_Impl&      rHints;
 275     XMLStyleHint_Impl   *pHint;
 276
 277     bool&                rIgnoreLeadingSpace;
 278
 279     sal_uInt8            nStarFontsConvFlags;
 280
 281 public:
 282
 283     TYPEINFO_OVERRIDE();
 284
 285     XMLImpSpanContext_Impl(
 286             SvXMLImport& rImport,
 287             sal_uInt16 nPrfx,
 288             const OUString& rLName,
 289             const Reference< xml::sax::XAttributeList > & xAttrList,
 290             XMLHints_Impl& rHnts,
 291             bool& rIgnLeadSpace,
 292             sal_uInt8 nSFConvFlags
 293                           );
 294
 295     virtual ~XMLImpSpanContext_Impl();
 296
 297     static SvXMLImportContext *CreateChildContext(
 298             SvXMLImport& rImport,
 299             sal_uInt16 nPrefix, const OUString& rLocalName,
 300             const Reference< xml::sax::XAttributeList > & xAttrList,
 301             sal_uInt16 nToken, XMLHints_Impl& rHnts,
 302             bool& rIgnLeadSpace,
 303             sal_uInt8 nStarFontsConvFlags = 0
 304              );
 305     virtual SvXMLImportContext *CreateChildContext(
 306             sal_uInt16 nPrefix, const OUString& rLocalName,
 307             const Reference< xml::sax::XAttributeList > & xAttrList ) SAL_OVERRIDE;
 308
 309     virtual void Characters( const OUString& rChars ) SAL_OVERRIDE;
 310 };
 311
 312 class XMLImpHyperlinkContext_Impl : public SvXMLImportContext
 313 {
 314     XMLHints_Impl&  mrHints;
 315     XMLHyperlinkHint_Impl   *mpHint;
 316
 317     bool&       mrbIgnoreLeadingSpace;
 318
 319 public:
 320
 321     TYPEINFO_OVERRIDE();
 322
 323     XMLImpHyperlinkContext_Impl(
 324             SvXMLImport& rImport,
 325             sal_uInt16 nPrfx,
 326             const OUString& rLName,
 327             const Reference< xml::sax::XAttributeList > & xAttrList,
 328             XMLHints_Impl& rHnts,
 329             bool& rIgnLeadSpace );
 330
 331     virtual ~XMLImpHyperlinkContext_Impl();
 332
 333     virtual SvXMLImportContext *CreateChildContext(
 334             sal_uInt16 nPrefix, const OUString& rLocalName,
 335             const Reference< xml::sax::XAttributeList > & xAttrList ) SAL_OVERRIDE;
 336
 337     virtual void Characters( const OUString& rChars ) SAL_OVERRIDE;
 338 };
 339
 340 TYPEINIT1( XMLImpHyperlinkContext_Impl, SvXMLImportContext );
 341
 342 XMLImpHyperlinkContext_Impl::XMLImpHyperlinkContext_Impl(
 343     SvXMLImport& rImport,
 344     sal_uInt16 nPrfx,
 345     const OUString& rLName,
 346     const Reference< xml::sax::XAttributeList > & xAttrList,
 347     XMLHints_Impl& rHnts,
 348     bool& rIgnLeadSpace )
 349     : SvXMLImportContext( rImport, nPrfx, rLName )
 350     , mrHints( rHnts )
 351     , mpHint( new XMLHyperlinkHint_Impl( GetImport().GetTextImport()->GetCursorAsRange()->getStart() ) )
 352     , mrbIgnoreLeadingSpace( rIgnLeadSpace )
 353 {
 354     OUString sShow;
 355     const SvXMLTokenMap& rTokenMap = GetImport().GetTextImport()->GetTextHyperlinkAttrTokenMap();
 356
 357     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 358     for ( sal_Int16 i = 0; i < nAttrCount; i++ )
 359     {
 360         const OUString& rAttrName = xAttrList->getNameByIndex( i );
 361         const OUString& rValue = xAttrList->getValueByIndex( i );
 362
 363         OUString aLocalName;
 364         const sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName );
 365         switch (rTokenMap.Get( nPrefix, aLocalName ))
 366         {
 367         case XML_TOK_TEXT_HYPERLINK_HREF:
 368             mpHint->SetHRef( GetImport().GetAbsoluteReference( rValue ) );
 369             break;
 370         case XML_TOK_TEXT_HYPERLINK_NAME:
 371             mpHint->SetName( rValue );
 372             break;
 373         case XML_TOK_TEXT_HYPERLINK_TARGET_FRAME:
 374             mpHint->SetTargetFrameName( rValue );
 375             break;
 376         case XML_TOK_TEXT_HYPERLINK_SHOW:
 377             sShow = rValue;
 378             break;
 379         case XML_TOK_TEXT_HYPERLINK_STYLE_NAME:
 380             mpHint->SetStyleName( rValue );
 381             break;
 382         case XML_TOK_TEXT_HYPERLINK_VIS_STYLE_NAME:
 383             mpHint->SetVisitedStyleName( rValue );
 384             break;
 385         }
 386     }
 387
 388     if( !sShow.isEmpty() && mpHint->GetTargetFrameName().isEmpty() )
 389     {
 390         if( IsXMLToken( sShow, XML_NEW ) )
 391             mpHint->SetTargetFrameName(
 392                     OUString( "_blank"  ) );
 393         else if( IsXMLToken( sShow, XML_REPLACE ) )
 394             mpHint->SetTargetFrameName(
 395                     OUString( "_self"  ) );
 396     }
 397
 398     if ( mpHint->GetHRef().isEmpty() )
 399     {
 400         // hyperlink without an URL is not imported.
 401         delete mpHint;
 402         mpHint = NULL;
 403     }
 404     else
 405     {
 406         mrHints.push_back( mpHint );
 407     }
 408 }
 409
 410 XMLImpHyperlinkContext_Impl::~XMLImpHyperlinkContext_Impl()
 411 {
 412     if( mpHint != NULL )
 413         mpHint->SetEnd( GetImport().GetTextImport()
 414                             ->GetCursorAsRange()->getStart() );
 415 }
 416
 417 SvXMLImportContext *XMLImpHyperlinkContext_Impl::CreateChildContext(
 418         sal_uInt16 nPrefix, const OUString& rLocalName,
 419         const Reference< xml::sax::XAttributeList > & xAttrList )
 420 {
 421     if ( (nPrefix == XML_NAMESPACE_OFFICE) &&
 422          IsXMLToken(rLocalName, XML_EVENT_LISTENERS) )
 423     {
 424         XMLEventsImportContext* pCtxt = new XMLEventsImportContext(
 425             GetImport(), nPrefix, rLocalName);
 426         mpHint->SetEventsContext(pCtxt);
 427         return pCtxt;
 428     }
 429     else
 430     {
 431         const SvXMLTokenMap& rTokenMap =
 432             GetImport().GetTextImport()->GetTextPElemTokenMap();
 433         sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
 434
 435         return XMLImpSpanContext_Impl::CreateChildContext(
 436             GetImport(), nPrefix, rLocalName, xAttrList,
 437             nToken, mrHints, mrbIgnoreLeadingSpace );
 438     }
 439 }
 440
 441 void XMLImpHyperlinkContext_Impl::Characters( const OUString& rChars )
 442 {
 443     GetImport().GetTextImport()->InsertString( rChars, mrbIgnoreLeadingSpace );
 444 }
 445
 446 class XMLImpRubyBaseContext_Impl : public SvXMLImportContext
 447 {
 448     XMLHints_Impl&  rHints;
 449
 450     bool&       rIgnoreLeadingSpace;
 451
 452 public:
 453
 454     TYPEINFO_OVERRIDE();
 455
 456     XMLImpRubyBaseContext_Impl(
 457             SvXMLImport& rImport,
 458             sal_uInt16 nPrfx,
 459             const OUString& rLName,
 460             const Reference< xml::sax::XAttributeList > & xAttrList,
 461             XMLHints_Impl& rHnts,
 462             bool& rIgnLeadSpace );
 463
 464     virtual ~XMLImpRubyBaseContext_Impl();
 465
 466     virtual SvXMLImportContext *CreateChildContext(
 467             sal_uInt16 nPrefix, const OUString& rLocalName,
 468             const Reference< xml::sax::XAttributeList > & xAttrList ) SAL_OVERRIDE;
 469
 470     virtual void Characters( const OUString& rChars ) SAL_OVERRIDE;
 471 };
 472
 473 TYPEINIT1( XMLImpRubyBaseContext_Impl, SvXMLImportContext );
 474
 475 XMLImpRubyBaseContext_Impl::XMLImpRubyBaseContext_Impl(
 476         SvXMLImport& rImport,
 477         sal_uInt16 nPrfx,
 478         const OUString& rLName,
 479         const Reference< xml::sax::XAttributeList > &,
 480         XMLHints_Impl& rHnts,
 481         bool& rIgnLeadSpace ) :
 482     SvXMLImportContext( rImport, nPrfx, rLName ),
 483     rHints( rHnts ),
 484     rIgnoreLeadingSpace( rIgnLeadSpace )
 485 {
 486 }
 487
 488 XMLImpRubyBaseContext_Impl::~XMLImpRubyBaseContext_Impl()
 489 {
 490 }
 491
 492 SvXMLImportContext *XMLImpRubyBaseContext_Impl::CreateChildContext(
 493         sal_uInt16 nPrefix, const OUString& rLocalName,
 494         const Reference< xml::sax::XAttributeList > & xAttrList )
 495 {
 496     const SvXMLTokenMap& rTokenMap =
 497         GetImport().GetTextImport()->GetTextPElemTokenMap();
 498     sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
 499
 500     return XMLImpSpanContext_Impl::CreateChildContext( GetImport(), nPrefix,
 501                                                        rLocalName, xAttrList,
 502                                nToken, rHints, rIgnoreLeadingSpace );
 503 }
 504
 505 void XMLImpRubyBaseContext_Impl::Characters( const OUString& rChars )
 506 {
 507     GetImport().GetTextImport()->InsertString( rChars, rIgnoreLeadingSpace );
 508 }
 509
 510 class XMLImpRubyContext_Impl : public SvXMLImportContext
 511 {
 512     XMLHints_Impl&  rHints;
 513
 514     bool&       rIgnoreLeadingSpace;
 515
 516     Reference < XTextRange > m_xStart;
 517     OUString        m_sStyleName;
 518     OUString        m_sTextStyleName;
 519     OUString        m_sText;
 520
 521 public:
 522
 523     TYPEINFO_OVERRIDE();
 524
 525     XMLImpRubyContext_Impl(
 526             SvXMLImport& rImport,
 527             sal_uInt16 nPrfx,
 528             const OUString& rLName,
 529             const Reference< xml::sax::XAttributeList > & xAttrList,
 530             XMLHints_Impl& rHnts,
 531             bool& rIgnLeadSpace );
 532
 533     virtual ~XMLImpRubyContext_Impl();
 534
 535     virtual SvXMLImportContext *CreateChildContext(
 536             sal_uInt16 nPrefix, const OUString& rLocalName,
 537             const Reference< xml::sax::XAttributeList > & xAttrList ) SAL_OVERRIDE;
 538
 539     void SetTextStyleName( const OUString& s ) { m_sTextStyleName = s; }
 540     void AppendText( const OUString& s ) { m_sText += s; }
 541 };
 542
 543 class XMLImpRubyTextContext_Impl : public SvXMLImportContext
 544 {
 545     XMLImpRubyContext_Impl & m_rRubyContext;
 546
 547 public:
 548
 549     TYPEINFO_OVERRIDE();
 550
 551     XMLImpRubyTextContext_Impl(
 552             SvXMLImport& rImport,
 553             sal_uInt16 nPrfx,
 554             const OUString& rLName,
 555             const Reference< xml::sax::XAttributeList > & xAttrList,
 556             XMLImpRubyContext_Impl & rParent );
 557
 558     virtual ~XMLImpRubyTextContext_Impl();
 559
 560     virtual void Characters( const OUString& rChars ) SAL_OVERRIDE;
 561 };
 562
 563 TYPEINIT1( XMLImpRubyTextContext_Impl, SvXMLImportContext );
 564
 565 XMLImpRubyTextContext_Impl::XMLImpRubyTextContext_Impl(
 566         SvXMLImport& rImport,
 567         sal_uInt16 nPrfx,
 568         const OUString& rLName,
 569         const Reference< xml::sax::XAttributeList > & xAttrList,
 570         XMLImpRubyContext_Impl & rParent )
 571     : SvXMLImportContext( rImport, nPrfx, rLName )
 572     , m_rRubyContext( rParent )
 573 {
 574     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 575     for( sal_Int16 i=0; i < nAttrCount; i++ )
 576     {
 577         const OUString& rAttrName = xAttrList->getNameByIndex( i );
 578         const OUString& rValue = xAttrList->getValueByIndex( i );
 579
 580         OUString aLocalName;
 581         sal_uInt16 nPrefix =
 582             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
 583                                                             &aLocalName );
 584         if( XML_NAMESPACE_TEXT == nPrefix &&
 585             IsXMLToken( aLocalName, XML_STYLE_NAME ) )
 586         {
 587             m_rRubyContext.SetTextStyleName( rValue );
 588             break;
 589         }
 590     }
 591 }
 592
 593 XMLImpRubyTextContext_Impl::~XMLImpRubyTextContext_Impl()
 594 {
 595 }
 596
 597 void XMLImpRubyTextContext_Impl::Characters( const OUString& rChars )
 598 {
 599     m_rRubyContext.AppendText( rChars );
 600 }
 601
 602 TYPEINIT1( XMLImpRubyContext_Impl, SvXMLImportContext );
 603
 604 XMLImpRubyContext_Impl::XMLImpRubyContext_Impl(
 605         SvXMLImport& rImport,
 606         sal_uInt16 nPrfx,
 607         const OUString& rLName,
 608         const Reference< xml::sax::XAttributeList > & xAttrList,
 609         XMLHints_Impl& rHnts,
 610         bool& rIgnLeadSpace ) :
 611     SvXMLImportContext( rImport, nPrfx, rLName ),
 612     rHints( rHnts ),
 613     rIgnoreLeadingSpace( rIgnLeadSpace )
 614     , m_xStart( GetImport().GetTextImport()->GetCursorAsRange()->getStart() )
 615 {
 616     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 617     for( sal_Int16 i=0; i < nAttrCount; i++ )
 618     {
 619         const OUString& rAttrName = xAttrList->getNameByIndex( i );
 620         const OUString& rValue = xAttrList->getValueByIndex( i );
 621
 622         OUString aLocalName;
 623         sal_uInt16 nPrefix =
 624             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
 625                                                             &aLocalName );
 626         if( XML_NAMESPACE_TEXT == nPrefix &&
 627             IsXMLToken( aLocalName, XML_STYLE_NAME ) )
 628         {
 629             m_sStyleName = rValue;
 630             break;
 631         }
 632     }
 633 }
 634
 635 XMLImpRubyContext_Impl::~XMLImpRubyContext_Impl()
 636 {
 637     const rtl::Reference < XMLTextImportHelper > xTextImport(
 638         GetImport().GetTextImport());
 639     const Reference < XTextCursor > xAttrCursor(
 640         xTextImport->GetText()->createTextCursorByRange( m_xStart ));
 641     xAttrCursor->gotoRange(xTextImport->GetCursorAsRange()->getStart(),
 642             sal_True);
 643     xTextImport->SetRuby( GetImport(), xAttrCursor,
 644          m_sStyleName, m_sTextStyleName, m_sText );
 645 }
 646
 647 SvXMLImportContext *XMLImpRubyContext_Impl::CreateChildContext(
 648         sal_uInt16 nPrefix, const OUString& rLocalName,
 649         const Reference< xml::sax::XAttributeList > & xAttrList )
 650 {
 651     SvXMLImportContext *pContext;
 652     if( XML_NAMESPACE_TEXT == nPrefix )
 653     {
 654         if( IsXMLToken( rLocalName, XML_RUBY_BASE ) )
 655             pContext = new XMLImpRubyBaseContext_Impl( GetImport(), nPrefix,
 656                                                        rLocalName,
 657                                                        xAttrList,
 658                                                        rHints,
 659                                                        rIgnoreLeadingSpace );
 660         else if( IsXMLToken( rLocalName, XML_RUBY_TEXT ) )
 661             pContext = new XMLImpRubyTextContext_Impl( GetImport(), nPrefix,
 662                                                        rLocalName,
 663                                                        xAttrList,
 664                                                        *this );
 665         else
 666             pContext = new SvXMLImportContext(
 667                 GetImport(), nPrefix, rLocalName );
 668     }
 669     else
 670         pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName,
 671                                                             xAttrList );
 672
 673     return pContext;
 674 }
 675
 676 /** for text:meta and text:meta-field
 677  */
 678 class XMLMetaImportContextBase : public SvXMLImportContext
 679 {
 680     XMLHints_Impl&    m_rHints;
 681
 682     bool& m_rIgnoreLeadingSpace;
 683
 684     /// start position
 685     Reference<XTextRange> m_xStart;
 686
 687 protected:
 688     OUString m_XmlId;
 689
 690 public:
 691     TYPEINFO_OVERRIDE();
 692
 693     XMLMetaImportContextBase(
 694         SvXMLImport& i_rImport,
 695         const sal_uInt16 i_nPrefix,
 696         const OUString& i_rLocalName,
 697         XMLHints_Impl& i_rHints,
 698         bool & i_rIgnoreLeadingSpace );
 699
 700     virtual ~XMLMetaImportContextBase();
 701
 702     virtual void StartElement(
 703             const Reference<xml::sax::XAttributeList> & i_xAttrList) SAL_OVERRIDE;
 704
 705     virtual void EndElement() SAL_OVERRIDE;
 706
 707     virtual SvXMLImportContext *CreateChildContext(
 708             sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
 709             const Reference< xml::sax::XAttributeList > & i_xAttrList) SAL_OVERRIDE;
 710
 711     virtual void Characters( const OUString& i_rChars ) SAL_OVERRIDE;
 712
 713     virtual void ProcessAttribute(sal_uInt16 const i_nPrefix,
 714         OUString const & i_rLocalName, OUString const & i_rValue);
 715
 716     virtual void InsertMeta(const Reference<XTextRange> & i_xInsertionRange)
 717         = 0;
 718 };
 719
 720 TYPEINIT1( XMLMetaImportContextBase, SvXMLImportContext );
 721
 722 XMLMetaImportContextBase::XMLMetaImportContextBase(
 723         SvXMLImport& i_rImport,
 724         const sal_uInt16 i_nPrefix,
 725         const OUString& i_rLocalName,
 726         XMLHints_Impl& i_rHints,
 727         bool & i_rIgnoreLeadingSpace )
 728     : SvXMLImportContext( i_rImport, i_nPrefix, i_rLocalName )
 729     , m_rHints( i_rHints )
 730     , m_rIgnoreLeadingSpace( i_rIgnoreLeadingSpace )
 731     , m_xStart( GetImport().GetTextImport()->GetCursorAsRange()->getStart() )
 732 {
 733 }
 734
 735 XMLMetaImportContextBase::~XMLMetaImportContextBase()
 736 {
 737 }
 738
 739 void XMLMetaImportContextBase::StartElement(
 740         const Reference<xml::sax::XAttributeList> & i_xAttrList)
 741 {
 742     const sal_Int16 nAttrCount(i_xAttrList.is() ? i_xAttrList->getLength() : 0);
 743     for ( sal_Int16 i = 0; i < nAttrCount; ++i )
 744     {
 745         const OUString& rAttrName( i_xAttrList->getNameByIndex( i ) );
 746         const OUString& rValue( i_xAttrList->getValueByIndex( i ) );
 747
 748         OUString sLocalName;
 749         const sal_uInt16 nPrefix(
 750             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
 751                                                             &sLocalName ));
 752         ProcessAttribute(nPrefix, sLocalName, rValue);
 753     }
 754 }
 755
 756 void XMLMetaImportContextBase::EndElement()
 757 {
 758     SAL_WARN_IF(!m_xStart.is(), "xmloff.text", "no mxStart?");
 759     if (!m_xStart.is()) return;
 760
 761     const Reference<XTextRange> xEndRange(
 762         GetImport().GetTextImport()->GetCursorAsRange()->getStart() );
 763
 764     // create range for insertion
 765     const Reference<XTextCursor> xInsertionCursor(
 766         GetImport().GetTextImport()->GetText()->createTextCursorByRange(
 767             xEndRange) );
 768     xInsertionCursor->gotoRange(m_xStart, sal_True);
 769
 770     InsertMeta(xInsertionCursor);
 771 }
 772
 773 SvXMLImportContext * XMLMetaImportContextBase::CreateChildContext(
 774             sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
 775             const Reference< xml::sax::XAttributeList > & i_xAttrList )
 776 {
 777     const SvXMLTokenMap& rTokenMap(
 778         GetImport().GetTextImport()->GetTextPElemTokenMap() );
 779     const sal_uInt16 nToken( rTokenMap.Get( i_nPrefix, i_rLocalName ) );
 780
 781     return XMLImpSpanContext_Impl::CreateChildContext( GetImport(), i_nPrefix,
 782         i_rLocalName, i_xAttrList, nToken, m_rHints, m_rIgnoreLeadingSpace );
 783 }
 784
 785 void XMLMetaImportContextBase::Characters( const OUString& i_rChars )
 786 {
 787     GetImport().GetTextImport()->InsertString(i_rChars, m_rIgnoreLeadingSpace);
 788 }
 789
 790 void XMLMetaImportContextBase::ProcessAttribute(sal_uInt16 const i_nPrefix,
 791     OUString const & i_rLocalName, OUString const & i_rValue)
 792 {
 793     if ( (XML_NAMESPACE_XML == i_nPrefix) && IsXMLToken(i_rLocalName, XML_ID) )
 794     {
 795         m_XmlId = i_rValue;
 796     }
 797 }
 798
 799 /** text:meta */
 800 class XMLMetaImportContext : public XMLMetaImportContextBase
 801 {
 802     // RDFa
 803     bool m_bHaveAbout;
 804     OUString m_sAbout;
 805     OUString m_sProperty;
 806     OUString m_sContent;
 807     OUString m_sDatatype;
 808
 809 public:
 810     TYPEINFO_OVERRIDE();
 811
 812     XMLMetaImportContext(
 813         SvXMLImport& i_rImport,
 814         const sal_uInt16 i_nPrefix,
 815         const OUString& i_rLocalName,
 816         XMLHints_Impl& i_rHints,
 817         bool & i_rIgnoreLeadingSpace );
 818
 819     virtual void ProcessAttribute(sal_uInt16 const i_nPrefix,
 820         OUString const & i_rLocalName, OUString const & i_rValue) SAL_OVERRIDE;
 821
 822     virtual void InsertMeta(const Reference<XTextRange> & i_xInsertionRange) SAL_OVERRIDE;
 823 };
 824
 825 TYPEINIT1( XMLMetaImportContext, XMLMetaImportContextBase );
 826
 827 XMLMetaImportContext::XMLMetaImportContext(
 828         SvXMLImport& i_rImport,
 829         const sal_uInt16 i_nPrefix,
 830         const OUString& i_rLocalName,
 831         XMLHints_Impl& i_rHints,
 832         bool & i_rIgnoreLeadingSpace )
 833     : XMLMetaImportContextBase( i_rImport, i_nPrefix, i_rLocalName,
 834             i_rHints, i_rIgnoreLeadingSpace )
 835     , m_bHaveAbout(false)
 836 {
 837 }
 838
 839 void XMLMetaImportContext::ProcessAttribute(sal_uInt16 const i_nPrefix,
 840     OUString const & i_rLocalName, OUString const & i_rValue)
 841 {
 842     if ( XML_NAMESPACE_XHTML == i_nPrefix )
 843     {
 844         // RDFa
 845         if ( IsXMLToken( i_rLocalName, XML_ABOUT) )
 846         {
 847             m_sAbout = i_rValue;
 848             m_bHaveAbout = true;
 849         }
 850         else if ( IsXMLToken( i_rLocalName, XML_PROPERTY) )
 851         {
 852             m_sProperty = i_rValue;
 853         }
 854         else if ( IsXMLToken( i_rLocalName, XML_CONTENT) )
 855         {
 856             m_sContent = i_rValue;
 857         }
 858         else if ( IsXMLToken( i_rLocalName, XML_DATATYPE) )
 859         {
 860             m_sDatatype = i_rValue;
 861         }
 862     }
 863     else
 864     {
 865         XMLMetaImportContextBase::ProcessAttribute(
 866             i_nPrefix, i_rLocalName, i_rValue);
 867     }
 868 }
 869
 870 void XMLMetaImportContext::InsertMeta(
 871     const Reference<XTextRange> & i_xInsertionRange)
 872 {
 873     SAL_WARN_IF(m_bHaveAbout == m_sProperty.isEmpty(), "xmloff.text", "XMLMetaImportContext::InsertMeta: invalid RDFa?");
 874     if (!m_XmlId.isEmpty() || (m_bHaveAbout && !m_sProperty.isEmpty()))
 875     {
 876         // insert mark
 877         const uno::Reference<rdf::XMetadatable> xMeta(
 878             XMLTextMarkImportContext::CreateAndInsertMark(
 879                 GetImport(),
 880                 OUString("com.sun.star.text.InContentMetadata"),
 881                 OUString(),
 882                 i_xInsertionRange, m_XmlId),
 883             uno::UNO_QUERY);
 884         SAL_WARN_IF(!xMeta.is(), "xmloff.text", "cannot insert Meta?");
 885
 886         if (xMeta.is() && m_bHaveAbout)
 887         {
 888             GetImport().AddRDFa(xMeta,
 889                 m_sAbout, m_sProperty, m_sContent, m_sDatatype);
 890         }
 891     }
 892     else
 893     {
 894         SAL_INFO("xmloff.text", "invalid <text:meta>: no xml:id, no valid RDFa");
 895     }
 896 }
 897
 898 /** text:meta-field */
 899 class XMLMetaFieldImportContext : public XMLMetaImportContextBase
 900 {
 901     OUString m_DataStyleName;
 902
 903 public:
 904     TYPEINFO_OVERRIDE();
 905
 906     XMLMetaFieldImportContext(
 907         SvXMLImport& i_rImport,
 908         const sal_uInt16 i_nPrefix,
 909         const OUString& i_rLocalName,
 910         XMLHints_Impl& i_rHints,
 911         bool & i_rIgnoreLeadingSpace );
 912
 913     virtual void ProcessAttribute(sal_uInt16 const i_nPrefix,
 914         OUString const & i_rLocalName, OUString const & i_rValue) SAL_OVERRIDE;
 915
 916     virtual void InsertMeta(const Reference<XTextRange> & i_xInsertionRange) SAL_OVERRIDE;
 917 };
 918
 919 TYPEINIT1( XMLMetaFieldImportContext, XMLMetaImportContextBase );
 920
 921 XMLMetaFieldImportContext::XMLMetaFieldImportContext(
 922         SvXMLImport& i_rImport,
 923         const sal_uInt16 i_nPrefix,
 924         const OUString& i_rLocalName,
 925         XMLHints_Impl& i_rHints,
 926         bool & i_rIgnoreLeadingSpace )
 927     : XMLMetaImportContextBase( i_rImport, i_nPrefix, i_rLocalName,
 928             i_rHints, i_rIgnoreLeadingSpace )
 929 {
 930 }
 931
 932 void XMLMetaFieldImportContext::ProcessAttribute(sal_uInt16 const i_nPrefix,
 933     OUString const & i_rLocalName, OUString const & i_rValue)
 934 {
 935     if ( XML_NAMESPACE_STYLE == i_nPrefix &&
 936          IsXMLToken( i_rLocalName, XML_DATA_STYLE_NAME ) )
 937     {
 938         m_DataStyleName = i_rValue;
 939     }
 940     else
 941     {
 942         XMLMetaImportContextBase::ProcessAttribute(
 943             i_nPrefix, i_rLocalName, i_rValue);
 944     }
 945 }
 946
 947 void XMLMetaFieldImportContext::InsertMeta(
 948     const Reference<XTextRange> & i_xInsertionRange)
 949 {
 950     if (!m_XmlId.isEmpty()) // valid?
 951     {
 952         // insert mark
 953         const Reference<XPropertySet> xPropertySet(
 954             XMLTextMarkImportContext::CreateAndInsertMark(
 955                 GetImport(),
 956                 OUString("com.sun.star.text.textfield.MetadataField"),
 957                 OUString(),
 958                 i_xInsertionRange, m_XmlId),
 959             UNO_QUERY);
 960         SAL_WARN_IF(!xPropertySet.is(), "xmloff.text", "cannot insert MetaField?");
 961         if (!xPropertySet.is()) return;
 962
 963         if (!m_DataStyleName.isEmpty())
 964         {
 965             bool isDefaultLanguage(true);
 966
 967             const sal_Int32 nKey( GetImport().GetTextImport()->GetDataStyleKey(
 968                                    m_DataStyleName, & isDefaultLanguage) );
 969
 970             if (-1 != nKey)
 971             {
 972                 static OUString sPropertyIsFixedLanguage(
 973                     OUString("IsFixedLanguage") );
 974                 Any any;
 975                 any <<= nKey;
 976                 xPropertySet->setPropertyValue(
 977                     OUString("NumberFormat"), any);
 978                 if ( xPropertySet->getPropertySetInfo()->
 979                         hasPropertyByName( sPropertyIsFixedLanguage ) )
 980                 {
 981                     any <<= static_cast<bool>(!isDefaultLanguage);
 982                     xPropertySet->setPropertyValue( sPropertyIsFixedLanguage,
 983                         any );
 984                 }
 985             }
 986         }
 987     }
 988     else
 989     {
 990         SAL_INFO("xmloff.text", "invalid <text:meta-field>: no xml:id");
 991     }
 992 }
 993
 994 /**
 995  * Process index marks.
 996  *
 997  * All *-mark-end index marks should instantiate *this* class (because
 998  * it doesn't process attributes other than ID), while the *-mark and
 999  * *-mark-start classes should instantiate the apporpiate subclasses.
1000  */
1001 class XMLIndexMarkImportContext_Impl : public SvXMLImportContext
1002 {
1003     const OUString sAlternativeText;
1004
1005     XMLHints_Impl& rHints;
1006     const enum XMLTextPElemTokens eToken;
1007     OUString sID;
1008
1009 public:
1010     TYPEINFO_OVERRIDE();
1011
1012     XMLIndexMarkImportContext_Impl(
1013         SvXMLImport& rImport,
1014         sal_uInt16 nPrefix,
1015         const OUString& rLocalName,
1016         enum XMLTextPElemTokens nTok,
1017         XMLHints_Impl& rHnts);
1018
1019     void StartElement(const Reference<xml::sax::XAttributeList> & xAttrList) SAL_OVERRIDE;
1020
1021 protected:
1022
1023     /// process all attributes
1024     void ProcessAttributes(const Reference<xml::sax::XAttributeList> & xAttrList,
1025                            Reference<beans::XPropertySet>& rPropSet);
1026
1027     /**
1028      * All marks can be created immediately. Since we don't care about
1029      * the element content, ProcessAttribute should set the properties
1030      * immediately.
1031      *
1032      * This method tolerates an empty PropertySet; subclasses however
1033      * are not expected to.
1034      */
1035     virtual void ProcessAttribute(sal_uInt16 nNamespace,
1036                                   const OUString& sLocalName,
1037                                   const OUString& sValue,
1038                                   Reference<beans::XPropertySet>& rPropSet);
1039
1040     static void GetServiceName(OUString& sServiceName,
1041                                enum XMLTextPElemTokens nToken);
1042
1043     bool CreateMark(Reference<beans::XPropertySet>& rPropSet,
1044                         const OUString& rServiceName);
1045 };
1046
1047 TYPEINIT1( XMLIndexMarkImportContext_Impl, SvXMLImportContext );
1048
1049 XMLIndexMarkImportContext_Impl::XMLIndexMarkImportContext_Impl(
1050     SvXMLImport& rImport,
1051     sal_uInt16 nPrefix,
1052     const OUString& rLocalName,
1053     enum XMLTextPElemTokens eTok,
1054     XMLHints_Impl& rHnts) :
1055         SvXMLImportContext(rImport, nPrefix, rLocalName),
1056         sAlternativeText("AlternativeText"),
1057         rHints(rHnts),
1058         eToken(eTok)
1059 {
1060 }
1061
1062 void XMLIndexMarkImportContext_Impl::StartElement(
1063     const Reference<xml::sax::XAttributeList> & xAttrList)
1064 {
1065     // get Cursor position (needed for all cases)
1066     Reference<XTextRange> xPos(
1067         GetImport().GetTextImport()->GetCursor()->getStart());
1068     Reference<beans::XPropertySet> xMark;
1069
1070     switch (eToken)
1071     {
1072         case XML_TOK_TEXT_TOC_MARK:
1073         case XML_TOK_TEXT_USER_INDEX_MARK:
1074         case XML_TOK_TEXT_ALPHA_INDEX_MARK:
1075         {
1076             // single mark: create mark and insert
1077             OUString sService;
1078             GetServiceName(sService, eToken);
1079             if (CreateMark(xMark, sService))
1080             {
1081                 ProcessAttributes(xAttrList, xMark);
1082                 XMLHint_Impl* pHint = new XMLIndexMarkHint_Impl(xMark, xPos);
1083                 rHints.push_back(pHint);
1084             }
1085             // else: can't create mark -> ignore
1086             break;
1087         }
1088
1089         case XML_TOK_TEXT_TOC_MARK_START:
1090         case XML_TOK_TEXT_USER_INDEX_MARK_START:
1091         case XML_TOK_TEXT_ALPHA_INDEX_MARK_START:
1092         {
1093             // start: create mark and insert (if ID is found)
1094             OUString sService;
1095             GetServiceName(sService, eToken);
1096             if (CreateMark(xMark, sService))
1097             {
1098                 ProcessAttributes(xAttrList, xMark);
1099                 if (!sID.isEmpty())
1100                 {
1101                     // process only if we find an ID
1102                     XMLHint_Impl* pHint =
1103                         new XMLIndexMarkHint_Impl(xMark, xPos, sID);
1104                     rHints.push_back(pHint);
1105                 }
1106                 // else: no ID -> we'll never find the end -> ignore
1107             }
1108             // else: can't create mark -> ignore
1109             break;
1110         }
1111
1112         case XML_TOK_TEXT_TOC_MARK_END:
1113         case XML_TOK_TEXT_USER_INDEX_MARK_END:
1114         case XML_TOK_TEXT_ALPHA_INDEX_MARK_END:
1115         {
1116             // end: search for ID and set end of mark
1117
1118             // call process attributes with empty XPropertySet:
1119             ProcessAttributes(xAttrList, xMark);
1120             if (!sID.isEmpty())
1121             {
1122                 // if we have an ID, find the hint and set the end position
1123                 sal_uInt16 nCount = rHints.size();
1124                 for(sal_uInt16 nPos = 0; nPos < nCount; nPos++)
1125                 {
1126                     XMLHint_Impl *pHint = &rHints[nPos];
1127                     if ( pHint->IsIndexMark() &&
1128                          sID.equals(
1129                              static_cast<XMLIndexMarkHint_Impl *>(pHint)->GetID()) )
1130                     {
1131                         // set end and stop searching
1132                         pHint->SetEnd(xPos);
1133                         break;
1134                     }
1135                 }
1136             }
1137             // else: no ID -> ignore
1138             break;
1139         }
1140
1141         default:
1142             SAL_WARN("xmloff.text", "unknown index mark type!");
1143             break;
1144     }
1145 }
1146
1147 void XMLIndexMarkImportContext_Impl::ProcessAttributes(
1148     const Reference<xml::sax::XAttributeList> & xAttrList,
1149     Reference<beans::XPropertySet>& rPropSet)
1150 {
1151     // process attributes
1152     sal_Int16 nLength = xAttrList->getLength();
1153     for(sal_Int16 i=0; i<nLength; i++)
1154     {
1155         OUString sLocalName;
1156         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
1157             GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
1158
1159         ProcessAttribute(nPrefix, sLocalName,
1160                          xAttrList->getValueByIndex(i),
1161                          rPropSet);
1162     }
1163 }
1164
1165 void XMLIndexMarkImportContext_Impl::ProcessAttribute(
1166     sal_uInt16 nNamespace,
1167     const OUString& sLocalName,
1168     const OUString& sValue,
1169     Reference<beans::XPropertySet>& rPropSet)
1170 {
1171     // we only know ID + string-value attribute;
1172     // (former: marks, latter: -start + -end-marks)
1173     // the remainder is handled in sub-classes
1174     switch (eToken)
1175     {
1176         case XML_TOK_TEXT_TOC_MARK:
1177         case XML_TOK_TEXT_USER_INDEX_MARK:
1178         case XML_TOK_TEXT_ALPHA_INDEX_MARK:
1179             if ( (XML_NAMESPACE_TEXT == nNamespace) &&
1180                  IsXMLToken( sLocalName, XML_STRING_VALUE ) )
1181             {
1182                 rPropSet->setPropertyValue(sAlternativeText, uno::makeAny(sValue));
1183             }
1184             // else: ignore!
1185             break;
1186
1187         case XML_TOK_TEXT_TOC_MARK_START:
1188         case XML_TOK_TEXT_USER_INDEX_MARK_START:
1189         case XML_TOK_TEXT_ALPHA_INDEX_MARK_START:
1190         case XML_TOK_TEXT_TOC_MARK_END:
1191         case XML_TOK_TEXT_USER_INDEX_MARK_END:
1192         case XML_TOK_TEXT_ALPHA_INDEX_MARK_END:
1193             if ( (XML_NAMESPACE_TEXT == nNamespace) &&
1194                  IsXMLToken( sLocalName, XML_ID ) )
1195             {
1196                 sID = sValue;
1197             }
1198             // else: ignore
1199             break;
1200
1201         default:
1202             SAL_WARN("xmloff.text", "unknown index mark type!");
1203             break;
1204     }
1205 }
1206
1207 static const sal_Char sAPI_com_sun_star_text_ContentIndexMark[] =
1208         "com.sun.star.text.ContentIndexMark";
1209 static const sal_Char sAPI_com_sun_star_text_UserIndexMark[] =
1210         "com.sun.star.text.UserIndexMark";
1211 static const sal_Char sAPI_com_sun_star_text_DocumentIndexMark[] =
1212         "com.sun.star.text.DocumentIndexMark";
1213
1214 void XMLIndexMarkImportContext_Impl::GetServiceName(
1215     OUString& sServiceName,
1216     enum XMLTextPElemTokens eToken)
1217 {
1218     switch (eToken)
1219     {
1220         case XML_TOK_TEXT_TOC_MARK:
1221         case XML_TOK_TEXT_TOC_MARK_START:
1222         case XML_TOK_TEXT_TOC_MARK_END:
1223         {
1224             OUString sTmp(
1225                 sAPI_com_sun_star_text_ContentIndexMark);
1226             sServiceName = sTmp;
1227             break;
1228         }
1229
1230         case XML_TOK_TEXT_USER_INDEX_MARK:
1231         case XML_TOK_TEXT_USER_INDEX_MARK_START:
1232         case XML_TOK_TEXT_USER_INDEX_MARK_END:
1233         {
1234             OUString sTmp(
1235                 sAPI_com_sun_star_text_UserIndexMark);
1236             sServiceName = sTmp;
1237             break;
1238         }
1239
1240         case XML_TOK_TEXT_ALPHA_INDEX_MARK:
1241         case XML_TOK_TEXT_ALPHA_INDEX_MARK_START:
1242         case XML_TOK_TEXT_ALPHA_INDEX_MARK_END:
1243         {
1244             OUString sTmp(
1245                 sAPI_com_sun_star_text_DocumentIndexMark);
1246             sServiceName = sTmp;
1247             break;
1248         }
1249
1250         default:
1251         {
1252             SAL_WARN("xmloff.text", "unknown index mark type!");
1253             OUString sTmp;
1254             sServiceName = sTmp;
1255             break;
1256         }
1257     }
1258 }
1259
1260 bool XMLIndexMarkImportContext_Impl::CreateMark(
1261     Reference<beans::XPropertySet>& rPropSet,
1262     const OUString& rServiceName)
1263 {
1264     Reference<lang::XMultiServiceFactory>
1265         xFactory(GetImport().GetModel(), UNO_QUERY);
1266
1267     if( xFactory.is() )
1268     {
1269         Reference<beans::XPropertySet> xPropSet( xFactory->createInstance(rServiceName), UNO_QUERY );
1270         if (xPropSet.is())
1271             rPropSet = xPropSet;
1272         return true;
1273     }
1274
1275     return false;
1276 }
1277
1278 class XMLTOCMarkImportContext_Impl : public XMLIndexMarkImportContext_Impl
1279 {
1280     const OUString sLevel;
1281
1282 public:
1283     TYPEINFO_OVERRIDE();
1284
1285     XMLTOCMarkImportContext_Impl(
1286         SvXMLImport& rImport,
1287         sal_uInt16 nPrefix,
1288         const OUString& rLocalName,
1289         enum XMLTextPElemTokens nTok,
1290         XMLHints_Impl& rHnts);
1291
1292 protected:
1293
1294     /** process outline level */
1295     virtual void ProcessAttribute(sal_uInt16 nNamespace,
1296                                   const OUString& sLocalName,
1297                                   const OUString& sValue,
1298                                   Reference<beans::XPropertySet>& rPropSet) SAL_OVERRIDE;
1299 };
1300
1301 TYPEINIT1( XMLTOCMarkImportContext_Impl, XMLIndexMarkImportContext_Impl );
1302
1303 XMLTOCMarkImportContext_Impl::XMLTOCMarkImportContext_Impl(
1304     SvXMLImport& rImport, sal_uInt16 nPrefix, const OUString& rLocalName,
1305     enum XMLTextPElemTokens nTok, XMLHints_Impl& rHnts) :
1306         XMLIndexMarkImportContext_Impl(rImport, nPrefix, rLocalName,
1307                                        nTok, rHnts),
1308         sLevel("Level")
1309 {
1310 }
1311
1312 void XMLTOCMarkImportContext_Impl::ProcessAttribute(
1313     sal_uInt16 nNamespace,
1314     const OUString& sLocalName,
1315     const OUString& sValue,
1316     Reference<beans::XPropertySet>& rPropSet)
1317 {
1318     SAL_WARN_IF(!rPropSet.is(), "xmloff.text", "need PropertySet");
1319
1320     if ((XML_NAMESPACE_TEXT == nNamespace) &&
1321         IsXMLToken( sLocalName, XML_OUTLINE_LEVEL ) )
1322     {
1323         // ouline level: set Level property
1324         sal_Int32 nTmp;
1325         if (::sax::Converter::convertNumber( nTmp, sValue )
1326              && nTmp >= 1
1327              && nTmp < GetImport().GetTextImport()->
1328                               GetChapterNumbering()->getCount() )
1329         {
1330             rPropSet->setPropertyValue(sLevel, uno::makeAny((sal_Int16)(nTmp - 1)));
1331         }
1332         // else: value out of range -> ignore
1333     }
1334     else
1335     {
1336         // else: delegate to superclass
1337         XMLIndexMarkImportContext_Impl::ProcessAttribute(
1338             nNamespace, sLocalName, sValue, rPropSet);
1339     }
1340 }
1341
1342 class XMLUserIndexMarkImportContext_Impl : public XMLIndexMarkImportContext_Impl
1343 {
1344     const OUString sUserIndexName;
1345     const OUString sLevel;
1346
1347 public:
1348     TYPEINFO_OVERRIDE();
1349
1350     XMLUserIndexMarkImportContext_Impl(
1351         SvXMLImport& rImport,
1352         sal_uInt16 nPrefix,
1353         const OUString& rLocalName,
1354         enum XMLTextPElemTokens nTok,
1355         XMLHints_Impl& rHnts);
1356
1357 protected:
1358
1359     /** process index name */
1360     virtual void ProcessAttribute(sal_uInt16 nNamespace,
1361                                   const OUString& sLocalName,
1362                                   const OUString& sValue,
1363                                   Reference<beans::XPropertySet>& rPropSet) SAL_OVERRIDE;
1364 };
1365
1366 TYPEINIT1( XMLUserIndexMarkImportContext_Impl, XMLIndexMarkImportContext_Impl);
1367
1368 XMLUserIndexMarkImportContext_Impl::XMLUserIndexMarkImportContext_Impl(
1369     SvXMLImport& rImport, sal_uInt16 nPrefix, const OUString& rLocalName,
1370     enum XMLTextPElemTokens nTok, XMLHints_Impl& rHnts) :
1371         XMLIndexMarkImportContext_Impl(rImport, nPrefix, rLocalName,
1372                                        nTok, rHnts),
1373         sUserIndexName("UserIndexName"),
1374         sLevel("Level")
1375 {
1376 }
1377
1378 void XMLUserIndexMarkImportContext_Impl::ProcessAttribute(
1379     sal_uInt16 nNamespace, const OUString& sLocalName, const OUString& sValue,
1380     Reference<beans::XPropertySet>& rPropSet)
1381 {
1382     if ( XML_NAMESPACE_TEXT == nNamespace )
1383     {
1384         if ( IsXMLToken( sLocalName, XML_INDEX_NAME ) )
1385         {
1386             rPropSet->setPropertyValue(sUserIndexName, uno::makeAny(sValue));
1387         }
1388         else if ( IsXMLToken( sLocalName, XML_OUTLINE_LEVEL ) )
1389         {
1390             // ouline level: set Level property
1391             sal_Int32 nTmp;
1392             if (::sax::Converter::convertNumber(
1393                 nTmp, sValue, 0,
1394                GetImport().GetTextImport()->GetChapterNumbering()->getCount()))
1395             {
1396                 rPropSet->setPropertyValue(sLevel, uno::makeAny(static_cast<sal_Int16>(nTmp - 1)));
1397             }
1398             // else: value out of range -> ignore
1399         }
1400         else
1401         {
1402             // else: unknown text property: delegate to super class
1403             XMLIndexMarkImportContext_Impl::ProcessAttribute(
1404                 nNamespace, sLocalName, sValue, rPropSet);
1405         }
1406     }
1407     else
1408     {
1409         // else: unknown namespace: delegate to super class
1410         XMLIndexMarkImportContext_Impl::ProcessAttribute(
1411             nNamespace, sLocalName, sValue, rPropSet);
1412     }
1413 }
1414
1415 class XMLAlphaIndexMarkImportContext_Impl : public XMLIndexMarkImportContext_Impl
1416 {
1417     const OUString sPrimaryKey;
1418     const OUString sSecondaryKey;
1419     const OUString sTextReading;
1420     const OUString sPrimaryKeyReading;
1421     const OUString sSecondaryKeyReading;
1422     const OUString sMainEntry;
1423
1424 public:
1425     TYPEINFO_OVERRIDE();
1426
1427     XMLAlphaIndexMarkImportContext_Impl(
1428         SvXMLImport& rImport,
1429         sal_uInt16 nPrefix,
1430         const OUString& rLocalName,
1431         enum XMLTextPElemTokens nTok,
1432         XMLHints_Impl& rHnts);
1433
1434 protected:
1435
1436     /** process primary + secondary keys */
1437     virtual void ProcessAttribute(sal_uInt16 nNamespace,
1438                                   const OUString& sLocalName,
1439                                   const OUString& sValue,
1440                                   Reference<beans::XPropertySet>& rPropSet) SAL_OVERRIDE;
1441 };
1442
1443 TYPEINIT1( XMLAlphaIndexMarkImportContext_Impl,
1444            XMLIndexMarkImportContext_Impl );
1445
1446 XMLAlphaIndexMarkImportContext_Impl::XMLAlphaIndexMarkImportContext_Impl(
1447     SvXMLImport& rImport, sal_uInt16 nPrefix, const OUString& rLocalName,
1448     enum XMLTextPElemTokens nTok, XMLHints_Impl& rHnts) :
1449         XMLIndexMarkImportContext_Impl(rImport, nPrefix, rLocalName,
1450                                        nTok, rHnts),
1451         sPrimaryKey("PrimaryKey"),
1452         sSecondaryKey("SecondaryKey"),
1453         sTextReading("TextReading"),
1454         sPrimaryKeyReading("PrimaryKeyReading"),
1455         sSecondaryKeyReading("SecondaryKeyReading"),
1456         sMainEntry("IsMainEntry")
1457 {
1458 }
1459
1460 void XMLAlphaIndexMarkImportContext_Impl::ProcessAttribute(
1461     sal_uInt16 nNamespace, const OUString& sLocalName, const OUString& sValue,
1462     Reference<beans::XPropertySet>& rPropSet)
1463 {
1464     if (XML_NAMESPACE_TEXT == nNamespace)
1465     {
1466         if ( IsXMLToken( sLocalName, XML_KEY1 ) )
1467         {
1468             rPropSet->setPropertyValue(sPrimaryKey, uno::makeAny(sValue));
1469         }
1470         else if ( IsXMLToken( sLocalName, XML_KEY2 ) )
1471         {
1472             rPropSet->setPropertyValue(sSecondaryKey, uno::makeAny(sValue));
1473         }
1474         else if ( IsXMLToken( sLocalName, XML_KEY1_PHONETIC ) )
1475         {
1476             rPropSet->setPropertyValue(sPrimaryKeyReading, uno::makeAny(sValue));
1477         }
1478         else if ( IsXMLToken( sLocalName, XML_KEY2_PHONETIC ) )
1479         {
1480             rPropSet->setPropertyValue(sSecondaryKeyReading, uno::makeAny(sValue));
1481         }
1482         else if ( IsXMLToken( sLocalName, XML_STRING_VALUE_PHONETIC ) )
1483         {
1484             rPropSet->setPropertyValue(sTextReading, uno::makeAny(sValue));
1485         }
1486         else if ( IsXMLToken( sLocalName, XML_MAIN_ENTRY ) )
1487         {
1488             bool bMainEntry = false;
1489             bool bTmp(false);
1490
1491             if (::sax::Converter::convertBool(bTmp, sValue))
1492                 bMainEntry = bTmp;
1493
1494             rPropSet->setPropertyValue(sMainEntry, uno::makeAny(bMainEntry));
1495         }
1496         else
1497         {
1498             XMLIndexMarkImportContext_Impl::ProcessAttribute(
1499                 nNamespace, sLocalName, sValue, rPropSet);
1500         }
1501     }
1502     else
1503     {
1504         XMLIndexMarkImportContext_Impl::ProcessAttribute(
1505             nNamespace, sLocalName, sValue, rPropSet);
1506     }
1507 }
1508
1509 TYPEINIT1( XMLImpSpanContext_Impl, SvXMLImportContext );
1510
1511 XMLImpSpanContext_Impl::XMLImpSpanContext_Impl(
1512         SvXMLImport& rImport,
1513         sal_uInt16 nPrfx,
1514         const OUString& rLName,
1515         const Reference< xml::sax::XAttributeList > & xAttrList,
1516         XMLHints_Impl& rHnts,
1517         bool& rIgnLeadSpace,
1518         sal_uInt8 nSFConvFlags
1519                                               )
1520 :   SvXMLImportContext( rImport, nPrfx, rLName )
1521 ,   rHints( rHnts )
1522 ,   pHint( 0  )
1523 ,   rIgnoreLeadingSpace( rIgnLeadSpace )
1524 ,   nStarFontsConvFlags( nSFConvFlags & (CONV_FROM_STAR_BATS|CONV_FROM_STAR_MATH) )
1525 {
1526     OUString aStyleName;
1527
1528     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
1529     for( sal_Int16 i=0; i < nAttrCount; i++ )
1530     {
1531         const OUString& rAttrName = xAttrList->getNameByIndex( i );
1532
1533         OUString aLocalName;
1534         sal_uInt16 nPrefix =
1535             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
1536                                                             &aLocalName );
1537         if( XML_NAMESPACE_TEXT == nPrefix &&
1538             IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1539             aStyleName = xAttrList->getValueByIndex( i );
1540     }
1541
1542     if( !aStyleName.isEmpty() )
1543     {
1544         pHint = new XMLStyleHint_Impl( aStyleName,
1545                   GetImport().GetTextImport()->GetCursorAsRange()->getStart() );
1546             rHints.push_back( pHint );
1547     }
1548 }
1549
1550 XMLImpSpanContext_Impl::~XMLImpSpanContext_Impl()
1551 {
1552     if( pHint )
1553         pHint->SetEnd( GetImport().GetTextImport()
1554                             ->GetCursorAsRange()->getStart() );
1555 }
1556
1557 SvXMLImportContext *XMLImpSpanContext_Impl::CreateChildContext(
1558         SvXMLImport& rImport,
1559         sal_uInt16 nPrefix, const OUString& rLocalName,
1560         const Reference< xml::sax::XAttributeList > & xAttrList,
1561         sal_uInt16 nToken,
1562         XMLHints_Impl& rHints,
1563         bool& rIgnoreLeadingSpace,
1564         sal_uInt8 nStarFontsConvFlags
1565      )
1566 {
1567     SvXMLImportContext *pContext = 0;
1568
1569     switch( nToken )
1570     {
1571     case XML_TOK_TEXT_SPAN:
1572         pContext = new XMLImpSpanContext_Impl( rImport, nPrefix,
1573                                                rLocalName, xAttrList,
1574                                                rHints,
1575                                                rIgnoreLeadingSpace
1576                                                ,nStarFontsConvFlags
1577                                              );
1578         break;
1579
1580     case XML_TOK_TEXT_TAB_STOP:
1581         pContext = new XMLCharContext( rImport, nPrefix,
1582                                                rLocalName, xAttrList,
1583                                                0x0009, false );
1584         rIgnoreLeadingSpace = false;
1585         break;
1586
1587     case XML_TOK_TEXT_LINE_BREAK:
1588         pContext = new XMLCharContext( rImport, nPrefix,
1589                                                rLocalName, xAttrList,
1590                                                ControlCharacter::LINE_BREAK );
1591         rIgnoreLeadingSpace = false;
1592         break;
1593
1594     case XML_TOK_TEXT_S:
1595         pContext = new XMLCharContext( rImport, nPrefix,
1596                                                rLocalName, xAttrList,
1597                                                0x0020, true );
1598         break;
1599
1600     case XML_TOK_TEXT_HYPERLINK:
1601     {
1602         // test for HyperLinkURL property. If present, insert link as
1603         // text property (StarWriter), else try to insert as text
1604         // field (StarCalc, StarDraw, ...)
1605         Reference< beans::XPropertySet > xPropSet( rImport.GetTextImport()->GetCursor(), UNO_QUERY );
1606
1607         const OUString sHyperLinkURL("HyperLinkURL");
1608
1609         if ( xPropSet->getPropertySetInfo()->hasPropertyByName( sHyperLinkURL ) )
1610         {
1611             pContext = new XMLImpHyperlinkContext_Impl(
1612                     rImport,
1613                     nPrefix,
1614                     rLocalName,
1615                     xAttrList,
1616                     rHints,
1617                     rIgnoreLeadingSpace );
1618         }
1619         else
1620         {
1621             pContext = new XMLUrlFieldImportContext( rImport, *rImport.GetTextImport().get(), nPrefix, rLocalName );
1622             //whitespace handling like other fields
1623             rIgnoreLeadingSpace = false;
1624
1625         }
1626         break;
1627     }
1628
1629     case XML_TOK_TEXT_RUBY:
1630         pContext = new XMLImpRubyContext_Impl( rImport, nPrefix,
1631                                                rLocalName, xAttrList,
1632                                                rHints,
1633                                                rIgnoreLeadingSpace );
1634         break;
1635
1636     case XML_TOK_TEXT_NOTE:
1637         if (rImport.GetTextImport()->IsInFrame())
1638         {
1639             // we must not insert footnotes into text frames
1640             pContext = new SvXMLImportContext( rImport, nPrefix,
1641                                                rLocalName );
1642         }
1643         else
1644         {
1645             pContext = new XMLFootnoteImportContext( rImport,
1646                                                      *rImport.GetTextImport().get(),
1647                                                      nPrefix, rLocalName );
1648         }
1649         rIgnoreLeadingSpace = false;
1650         break;
1651
1652     case XML_TOK_TEXT_REFERENCE:
1653     case XML_TOK_TEXT_BOOKMARK:
1654     case XML_TOK_TEXT_BOOKMARK_START:
1655     case XML_TOK_TEXT_BOOKMARK_END:
1656         pContext = new XMLTextMarkImportContext( rImport,
1657                                                  *rImport.GetTextImport().get(),
1658                                                  nPrefix, rLocalName );
1659         break;
1660
1661     case XML_TOK_TEXT_FIELDMARK:
1662     case XML_TOK_TEXT_FIELDMARK_START:
1663     case XML_TOK_TEXT_FIELDMARK_END:
1664         pContext = new XMLTextMarkImportContext( rImport,
1665                                                  *rImport.GetTextImport().get(),
1666                                                  nPrefix, rLocalName );
1667         break;
1668
1669     case XML_TOK_TEXT_REFERENCE_START:
1670         pContext = new XMLStartReferenceContext_Impl( rImport,
1671                                                       nPrefix, rLocalName,
1672                                                       rHints, xAttrList );
1673         break;
1674
1675     case XML_TOK_TEXT_REFERENCE_END:
1676         pContext = new XMLEndReferenceContext_Impl( rImport,
1677                                                     nPrefix, rLocalName,
1678                                                     rHints, xAttrList );
1679         break;
1680
1681     case XML_TOK_TEXT_FRAME:
1682         {
1683             Reference < XTextRange > xAnchorPos =
1684                 rImport.GetTextImport()->GetCursor()->getStart();
1685             XMLTextFrameContext *pTextFrameContext =
1686                 new XMLTextFrameContext( rImport, nPrefix,
1687                                          rLocalName, xAttrList,
1688                                          TextContentAnchorType_AS_CHARACTER );
1689             // Remove check for text content. (#i33242#)
1690             // Check for text content is done on the processing of the hint
1691             if( TextContentAnchorType_AT_CHARACTER ==
1692                                             pTextFrameContext->GetAnchorType() )
1693             {
1694                 rHints.push_back( new XMLTextFrameHint_Impl(
1695                     pTextFrameContext, xAnchorPos ) );
1696             }
1697             pContext = pTextFrameContext;
1698             rIgnoreLeadingSpace = false;
1699         }
1700         break;
1701     case XML_TOK_DRAW_A:
1702         {
1703             Reference < XTextRange > xAnchorPos(rImport.GetTextImport()->GetCursor()->getStart());
1704             pContext =
1705                 new XMLTextFrameHyperlinkContext( rImport, nPrefix,
1706                                         rLocalName, xAttrList,
1707                                         TextContentAnchorType_AS_CHARACTER );
1708             XMLTextFrameHint_Impl *pHint =
1709                 new XMLTextFrameHint_Impl( pContext, xAnchorPos);
1710             rHints.push_back( pHint );
1711         }
1712         break;
1713
1714     case XML_TOK_TEXT_TOC_MARK:
1715     case XML_TOK_TEXT_TOC_MARK_START:
1716         pContext = new XMLTOCMarkImportContext_Impl(
1717             rImport, nPrefix, rLocalName,
1718             (enum XMLTextPElemTokens)nToken, rHints);
1719         break;
1720
1721     case XML_TOK_TEXT_USER_INDEX_MARK:
1722     case XML_TOK_TEXT_USER_INDEX_MARK_START:
1723         pContext = new XMLUserIndexMarkImportContext_Impl(
1724             rImport, nPrefix, rLocalName,
1725             (enum XMLTextPElemTokens)nToken, rHints);
1726         break;
1727
1728     case XML_TOK_TEXT_ALPHA_INDEX_MARK:
1729     case XML_TOK_TEXT_ALPHA_INDEX_MARK_START:
1730         pContext = new XMLAlphaIndexMarkImportContext_Impl(
1731             rImport, nPrefix, rLocalName,
1732             (enum XMLTextPElemTokens)nToken, rHints);
1733         break;
1734
1735     case XML_TOK_TEXT_TOC_MARK_END:
1736     case XML_TOK_TEXT_USER_INDEX_MARK_END:
1737     case XML_TOK_TEXT_ALPHA_INDEX_MARK_END:
1738         pContext = new XMLIndexMarkImportContext_Impl(
1739             rImport, nPrefix, rLocalName, (enum XMLTextPElemTokens)nToken,
1740             rHints);
1741         break;
1742
1743     case XML_TOK_TEXTP_CHANGE_START:
1744     case XML_TOK_TEXTP_CHANGE_END:
1745     case XML_TOK_TEXTP_CHANGE:
1746         pContext = new XMLChangeImportContext(
1747             rImport, nPrefix, rLocalName,
1748             (nToken != XML_TOK_TEXTP_CHANGE_END),
1749             (nToken != XML_TOK_TEXTP_CHANGE_START),
1750             false);
1751         break;
1752
1753     case XML_TOK_TEXT_META:
1754         pContext = new XMLMetaImportContext(rImport, nPrefix, rLocalName,
1755             rHints, rIgnoreLeadingSpace );
1756         break;
1757
1758     case XML_TOK_TEXT_META_FIELD:
1759         pContext = new XMLMetaFieldImportContext(rImport, nPrefix, rLocalName,
1760             rHints, rIgnoreLeadingSpace );
1761         break;
1762
1763     default:
1764         // none of the above? then it's probably  a text field!
1765         pContext =
1766             XMLTextFieldImportContext::CreateTextFieldImportContext(
1767                 rImport, *rImport.GetTextImport().get(), nPrefix, rLocalName,
1768                 nToken);
1769         // #108784# import draw elements (except control shapes in headers)
1770         if( pContext == NULL &&
1771             !( rImport.GetTextImport()->IsInHeaderFooter() &&
1772                nPrefix == XML_NAMESPACE_DRAW &&
1773                IsXMLToken( rLocalName, XML_CONTROL ) ) )
1774         {
1775             Reference < XShapes > xShapes;
1776             SvXMLShapeContext* pShapeContext = rImport.GetShapeImport()->CreateGroupChildContext(
1777                 rImport, nPrefix, rLocalName, xAttrList, xShapes );
1778             pContext = pShapeContext;
1779             // OD 2004-04-20 #i26791# - keep shape in a text frame hint to
1780             // adjust its anchor position, if its at-character anchored
1781             Reference < XTextRange > xAnchorPos =
1782                 rImport.GetTextImport()->GetCursor()->getStart();
1783             rHints.push_back( new XMLDrawHint_Impl( pShapeContext, xAnchorPos ) );
1784         }
1785         if( !pContext )
1786         {
1787             // ignore unknown content
1788             pContext =
1789                 new SvXMLImportContext( rImport, nPrefix, rLocalName );
1790         }
1791         // Behind fields, shapes and any unknown content blanks aren't ignored
1792         rIgnoreLeadingSpace = false;
1793     }
1794
1795     return pContext;
1796 }
1797
1798 SvXMLImportContext *XMLImpSpanContext_Impl::CreateChildContext(
1799         sal_uInt16 nPrefix, const OUString& rLocalName,
1800         const Reference< xml::sax::XAttributeList > & xAttrList )
1801 {
1802     const SvXMLTokenMap& rTokenMap =
1803         GetImport().GetTextImport()->GetTextPElemTokenMap();
1804     sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
1805
1806     return CreateChildContext( GetImport(), nPrefix, rLocalName, xAttrList,
1807                                nToken, rHints, rIgnoreLeadingSpace
1808                                ,nStarFontsConvFlags
1809                              );
1810 }
1811
1812 void XMLImpSpanContext_Impl::Characters( const OUString& rChars )
1813 {
1814     OUString sStyleName;
1815     if( pHint )
1816         sStyleName = pHint->GetStyleName();
1817     OUString sChars =
1818         GetImport().GetTextImport()->ConvertStarFonts( rChars, sStyleName,
1819                                                        nStarFontsConvFlags,
1820                                                        false, GetImport() );
1821     GetImport().GetTextImport()->InsertString( sChars, rIgnoreLeadingSpace );
1822 }
1823
1824 TYPEINIT1( XMLParaContext, SvXMLImportContext );
1825
1826 XMLParaContext::XMLParaContext(
1827         SvXMLImport& rImport,
1828         sal_uInt16 nPrfx,
1829         const OUString& rLName,
1830         const Reference< xml::sax::XAttributeList > & xAttrList,
1831         bool bHead ) :
1832     SvXMLImportContext( rImport, nPrfx, rLName ),
1833     xStart( rImport.GetTextImport()->GetCursorAsRange()->getStart() ),
1834     m_bHaveAbout(false),
1835     nOutlineLevel( IsXMLToken( rLName, XML_H ) ? 1 : -1 ),
1836     pHints( 0 ),
1837     // Lost outline numbering in master document (#i73509#)
1838     mbOutlineLevelAttrFound( false ),
1839     bIgnoreLeadingSpace( true ),
1840     bHeading( bHead ),
1841     bIsListHeader( false ),
1842     bIsRestart (false),
1843     nStartValue(0),
1844     nStarFontsConvFlags( 0 )
1845 {
1846     const SvXMLTokenMap& rTokenMap =
1847         GetImport().GetTextImport()->GetTextPAttrTokenMap();
1848
1849     bool bHaveXmlId( false );
1850     OUString aCondStyleName, sClassNames;
1851
1852     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
1853     for( sal_Int16 i=0; i < nAttrCount; i++ )
1854     {
1855         const OUString& rAttrName = xAttrList->getNameByIndex( i );
1856         const OUString& rValue = xAttrList->getValueByIndex( i );
1857
1858         OUString aLocalName;
1859         sal_uInt16 nPrefix =
1860             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
1861                                                             &aLocalName );
1862         switch( rTokenMap.Get( nPrefix, aLocalName ) )
1863         {
1864         case XML_TOK_TEXT_P_XMLID:
1865             m_sXmlId = rValue;
1866             bHaveXmlId = true;
1867             break;
1868         case XML_TOK_TEXT_P_ABOUT:
1869             m_sAbout = rValue;
1870             m_bHaveAbout = true;
1871             break;
1872         case XML_TOK_TEXT_P_PROPERTY:
1873             m_sProperty = rValue;
1874             break;
1875         case XML_TOK_TEXT_P_CONTENT:
1876             m_sContent = rValue;
1877             break;
1878         case XML_TOK_TEXT_P_DATATYPE:
1879             m_sDatatype = rValue;
1880             break;
1881         case XML_TOK_TEXT_P_TEXTID:
1882             if (!bHaveXmlId) { m_sXmlId = rValue; }
1883             break;
1884         case XML_TOK_TEXT_P_STYLE_NAME:
1885             sStyleName = rValue;
1886             break;
1887         case XML_TOK_TEXT_P_CLASS_NAMES:
1888             sClassNames = rValue;
1889             break;
1890         case XML_TOK_TEXT_P_COND_STYLE_NAME:
1891             aCondStyleName = rValue;
1892             break;
1893         case XML_TOK_TEXT_P_LEVEL:
1894             {
1895                 sal_Int32 nTmp = rValue.toInt32();
1896                 if( nTmp > 0L )
1897                 {
1898                     if( nTmp > 127 )
1899                         nTmp = 127;
1900                     nOutlineLevel = (sal_Int8)nTmp;
1901                 }
1902                 // Lost outline numbering in master document (#i73509#)
1903                 mbOutlineLevelAttrFound = true;
1904             }
1905             break;
1906         case XML_TOK_TEXT_P_IS_LIST_HEADER:
1907             {
1908                 bool bBool(false);
1909                 if( ::sax::Converter::convertBool( bBool, rValue ) )
1910                 {
1911                     bIsListHeader = bBool;
1912                 }
1913             }
1914             break;
1915         case XML_TOK_TEXT_P_RESTART_NUMBERING:
1916             {
1917                 bool bBool(false);
1918                 if (::sax::Converter::convertBool(bBool, rValue))
1919                 {
1920                     bIsRestart = bBool;
1921                 }
1922             }
1923             break;
1924         case XML_TOK_TEXT_P_START_VALUE:
1925             {
1926                 nStartValue = sal::static_int_cast< sal_Int16 >(
1927                     rValue.toInt32());
1928             }
1929             break;
1930         }
1931     }
1932
1933     if( !aCondStyleName.isEmpty() )
1934         sStyleName = aCondStyleName;
1935     else if( !sClassNames.isEmpty() )
1936     {
1937         sal_Int32 nDummy = 0;
1938         sStyleName = sClassNames.getToken( 0, ' ', nDummy );
1939     }
1940 }
1941
1942 XMLParaContext::~XMLParaContext()
1943 {
1944     rtl::Reference < XMLTextImportHelper > xTxtImport(
1945         GetImport().GetTextImport());
1946     Reference < XTextRange > xCrsrRange( xTxtImport->GetCursorAsRange() );
1947     if( !xCrsrRange.is() )
1948         return; // Robust (defect file)
1949     Reference < XTextRange > xEnd(xCrsrRange->getStart());
1950
1951     // if we have an id set for this paragraph, get a cursor for this
1952     // paragraph and register it with the given identifier
1953     // FIXME: this is just temporary, and should be removed when
1954     // EditEngine paragraphs implement XMetadatable!
1955     if (!m_sXmlId.isEmpty())
1956     {
1957         Reference < XTextCursor > xIdCursor( xTxtImport->GetText()->createTextCursorByRange( xStart ) );
1958         if( xIdCursor.is() )
1959         {
1960             xIdCursor->gotoRange( xEnd, sal_True );
1961             GetImport().getInterfaceToIdentifierMapper().registerReference(
1962                 m_sXmlId, Reference<XInterface>( xIdCursor, UNO_QUERY ));
1963         }
1964     }
1965
1966     // insert a paragraph break
1967     xTxtImport->InsertControlCharacter( ControlCharacter::APPEND_PARAGRAPH );
1968
1969     // create a cursor that select the whole last paragraph
1970     Reference < XTextCursor > xAttrCursor;
1971     try {
1972         xAttrCursor = xTxtImport->GetText()->createTextCursorByRange( xStart );
1973         if( !xAttrCursor.is() )
1974             return; // Robust (defect file)
1975     } catch (const uno::Exception &) {
1976         // createTextCursorByRange() likes to throw runtime exception, even
1977         // though it just means 'we were unable to create the cursor'
1978         return;
1979     }
1980     xAttrCursor->gotoRange( xEnd, sal_True );
1981
1982     // xml:id for RDF metadata
1983     if (!m_sXmlId.isEmpty() || m_bHaveAbout || !m_sProperty.isEmpty())
1984     {
1985         try {
1986             const uno::Reference<container::XEnumerationAccess> xEA
1987                 (xAttrCursor, uno::UNO_QUERY_THROW);
1988             const uno::Reference<container::XEnumeration> xEnum(
1989                 xEA->createEnumeration(), uno::UNO_QUERY_THROW);
1990             SAL_WARN_IF(!xEnum->hasMoreElements(), "xmloff.text", "xml:id: no paragraph?");
1991             if (xEnum->hasMoreElements()) {
1992                 uno::Reference<rdf::XMetadatable> xMeta;
1993                 xEnum->nextElement() >>= xMeta;
1994                 SAL_WARN_IF(!xMeta.is(), "xmloff.text", "xml:id: not XMetadatable");
1995                 GetImport().SetXmlId(xMeta, m_sXmlId);
1996                 if (m_bHaveAbout)
1997                 {
1998                     GetImport().AddRDFa(xMeta,
1999                         m_sAbout, m_sProperty, m_sContent, m_sDatatype);
2000                 }
2001                 SAL_WARN_IF(xEnum->hasMoreElements(), "xmloff.text", "xml:id: > 1 paragraph?");
2002             }
2003         } catch (const uno::Exception &) {
2004             SAL_INFO("xmloff.text", "XMLParaContext::~XMLParaContext: exception");
2005         }
2006     }
2007
2008     OUString const sCellParaStyleName(xTxtImport->GetCellParaStyleDefault());
2009     if( !sCellParaStyleName.isEmpty() )
2010     {
2011         /* Suppress handling of outline and list attributes,
2012            because of side effects of method <SetStyleAndAttrs(..)> (#i80724#)
2013         */
2014         xTxtImport->SetStyleAndAttrs( GetImport(), xAttrCursor,
2015                                       sCellParaStyleName,
2016                                       true,
2017                                       false, -1, // suppress outline handling
2018                                       false );   // suppress list attributes handling
2019     }
2020
2021     // #103445# for headings without style name, find the proper style
2022     if( bHeading && sStyleName.isEmpty() )
2023         xTxtImport->FindOutlineStyleName( sStyleName, nOutlineLevel );
2024
2025     // set style and hard attributes at the previous paragraph
2026     // Add parameter <mbOutlineLevelAttrFound> (#i73509#)
2027     sStyleName = xTxtImport->SetStyleAndAttrs( GetImport(), xAttrCursor,
2028                                                sStyleName,
2029                                                true,
2030                                                mbOutlineLevelAttrFound,
2031                                                bHeading ? nOutlineLevel : -1 );
2032
2033     // handle list style header
2034     if (bHeading && (bIsListHeader || bIsRestart))
2035     {
2036         Reference<XPropertySet> xPropSet( xAttrCursor, UNO_QUERY );
2037
2038         if (xPropSet.is())
2039         {
2040             if (bIsListHeader)
2041             {
2042                 OUString sNumberingIsNumber
2043                     ("NumberingIsNumber");
2044                 if(xPropSet->getPropertySetInfo()->
2045                    hasPropertyByName(sNumberingIsNumber))
2046                 {
2047                     xPropSet->setPropertyValue
2048                         (sNumberingIsNumber, makeAny( false ) );
2049                 }
2050             }
2051             if (bIsRestart)
2052             {
2053                 OUString sParaIsNumberingRestart
2054                     ("ParaIsNumberingRestart");
2055                 OUString sNumberingStartValue
2056                     ("NumberingStartValue");
2057                 if (xPropSet->getPropertySetInfo()->
2058                     hasPropertyByName(sParaIsNumberingRestart))
2059                 {
2060                     xPropSet->setPropertyValue
2061                         (sParaIsNumberingRestart, makeAny(true));
2062                 }
2063
2064                 if (xPropSet->getPropertySetInfo()->
2065                     hasPropertyByName(sNumberingStartValue))
2066                 {
2067                     xPropSet->setPropertyValue
2068                         (sNumberingStartValue, makeAny(nStartValue));
2069                 }
2070             }
2071
2072         }
2073     }
2074
2075     if( pHints && !pHints->empty() )
2076     {
2077         for( sal_uInt16 i=0; i<pHints->size(); i++ )
2078         {
2079             XMLHint_Impl *pHint = &(*pHints)[i];
2080             xAttrCursor->gotoRange( pHint->GetStart(), sal_False );
2081             xAttrCursor->gotoRange( pHint->GetEnd(), sal_True );
2082             switch( pHint->GetType() )
2083             {
2084             case XML_HINT_STYLE:
2085                 {
2086                     const OUString& rStyleName =
2087                             static_cast<XMLStyleHint_Impl *>(pHint)->GetStyleName();
2088                     if( !rStyleName.isEmpty() )
2089                         xTxtImport->SetStyleAndAttrs( GetImport(),
2090                                                       xAttrCursor, rStyleName,
2091                                                       false );
2092                 }
2093                 break;
2094             case XML_HINT_REFERENCE:
2095                 {
2096                     const OUString& rRefName =
2097                             static_cast<XMLReferenceHint_Impl *>(pHint)->GetRefName();
2098                     if( !rRefName.isEmpty() )
2099                     {
2100                         if( !pHint->GetEnd().is() )
2101                             pHint->SetEnd(xEnd);
2102
2103                         // reference name uses rStyleName member
2104                         // borrow from XMLTextMarkImportContext
2105                         XMLTextMarkImportContext::CreateAndInsertMark(
2106                             GetImport(),
2107                             OUString( "com.sun.star.text.ReferenceMark"),
2108                             rRefName,
2109                             xAttrCursor);
2110                     }
2111                 }
2112                 break;
2113             case XML_HINT_HYPERLINK:
2114                 {
2115                     const XMLHyperlinkHint_Impl *pHHint =
2116                         static_cast<const XMLHyperlinkHint_Impl *>(pHint);
2117                     xTxtImport->SetHyperlink( GetImport(),
2118                                               xAttrCursor,
2119                                               pHHint->GetHRef(),
2120                                               pHHint->GetName(),
2121                                               pHHint->GetTargetFrameName(),
2122                                               pHHint->GetStyleName(),
2123                                               pHHint->GetVisitedStyleName(),
2124                                               pHHint->GetEventsContext() );
2125                 }
2126                 break;
2127             case XML_HINT_INDEX_MARK:
2128                 {
2129                     Reference<beans::XPropertySet> xMark(
2130                         static_cast<const XMLIndexMarkHint_Impl *>(pHint)->GetMark());
2131                     Reference<XTextContent> xContent(xMark, UNO_QUERY);
2132                     xTxtImport->GetText()->insertTextContent(
2133                         xAttrCursor, xContent, sal_True );
2134                 }
2135                 break;
2136             case XML_HINT_TEXT_FRAME:
2137                 {
2138                     const XMLTextFrameHint_Impl *pFHint =
2139                         static_cast<const XMLTextFrameHint_Impl *>(pHint);
2140                     // Check for text content (#i33242#)
2141                     Reference < XTextContent > xTextContent =
2142                                                     pFHint->GetTextContent();
2143                     if ( xTextContent.is() )
2144                     {
2145                         /* Core impl. of the unification of drawing objects and
2146                            Writer fly frames (#i26791#)
2147                         */
2148                         if ( pFHint->IsBoundAtChar() )
2149                         {
2150                             xTextContent->attach( xAttrCursor );
2151                         }
2152                     }
2153                     /* Consider, that hint can also contain a shape -
2154                        e.g. drawing object of type 'Text'. (#i33242#)
2155                     */
2156                     else
2157                     {
2158                         Reference < XShape > xShape = pFHint->GetShape();
2159                         if ( xShape.is() )
2160                         {
2161                             // determine anchor type
2162                             Reference < XPropertySet > xPropSet( xShape, UNO_QUERY );
2163                             TextContentAnchorType eAnchorType =
2164                                             TextContentAnchorType_AT_PARAGRAPH;
2165                             {
2166                                 OUString sAnchorType( "AnchorType"  );
2167                                 Any aAny = xPropSet->getPropertyValue( sAnchorType );
2168                                 aAny >>= eAnchorType;
2169                             }
2170                             if ( TextContentAnchorType_AT_CHARACTER == eAnchorType )
2171                             {
2172                                 // set anchor position for at-character anchored objects
2173                                 Reference<XTextRange> xRange(xAttrCursor, UNO_QUERY);
2174                                 Any aPos;
2175                                 aPos <<= xRange;
2176                                 OUString sTextRange( "TextRange"  );
2177                                 xPropSet->setPropertyValue(sTextRange, aPos);
2178                             }
2179                         }
2180                     }
2181                 }
2182                 break;
2183             /* Core impl. of the unification of drawing objects and
2184                Writer fly frames (#i26791#)
2185             */
2186             case XML_HINT_DRAW:
2187                 {
2188                     const XMLDrawHint_Impl *pDHint =
2189                         static_cast<const XMLDrawHint_Impl*>(pHint);
2190                     // Improvement: hint directly provides the shape. (#i33242#)
2191                     Reference < XShape > xShape = pDHint->GetShape();
2192                     if ( xShape.is() )
2193                     {
2194                         // determine anchor type
2195                         Reference < XPropertySet > xPropSet( xShape, UNO_QUERY );
2196                         TextContentAnchorType eAnchorType = TextContentAnchorType_AT_PARAGRAPH;
2197                         {
2198                             OUString sAnchorType( "AnchorType"  );
2199                             Any aAny = xPropSet->getPropertyValue( sAnchorType );
2200                             aAny >>= eAnchorType;
2201                         }
2202                         if ( TextContentAnchorType_AT_CHARACTER == eAnchorType )
2203                         {
2204                             // set anchor position for at-character anchored objects
2205                             Reference<XTextRange> xRange(xAttrCursor, UNO_QUERY);
2206                             Any aPos;
2207                             aPos <<= xRange;
2208                             OUString sTextRange( "TextRange"  );
2209                             xPropSet->setPropertyValue(sTextRange, aPos);
2210                         }
2211                     }
2212                 }
2213                 break;
2214             default:
2215                 SAL_WARN( "xmloff.text", "What's this" );
2216                 break;
2217             }
2218         }
2219     }
2220     delete pHints;
2221 }
2222
2223 SvXMLImportContext *XMLParaContext::CreateChildContext(
2224         sal_uInt16 nPrefix, const OUString& rLocalName,
2225         const Reference< xml::sax::XAttributeList > & xAttrList )
2226 {
2227     const SvXMLTokenMap& rTokenMap =
2228         GetImport().GetTextImport()->GetTextPElemTokenMap();
2229     sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
2230     if( !pHints )
2231         pHints = new XMLHints_Impl;
2232     return XMLImpSpanContext_Impl::CreateChildContext(
2233                                 GetImport(), nPrefix, rLocalName, xAttrList,
2234                                    nToken, *pHints, bIgnoreLeadingSpace
2235                                 , nStarFontsConvFlags
2236                                                      );
2237 }
2238
2239 void XMLParaContext::Characters( const OUString& rChars )
2240 {
2241     OUString sChars =
2242         GetImport().GetTextImport()->ConvertStarFonts( rChars, sStyleName,
2243                                                        nStarFontsConvFlags,
2244                                                        true, GetImport() );
2245     GetImport().GetTextImport()->InsertString( sChars, bIgnoreLeadingSpace );
2246 }
2247
2248 TYPEINIT1( XMLNumberedParaContext, SvXMLImportContext );
2249
2250 XMLNumberedParaContext::XMLNumberedParaContext(
2251         SvXMLImport& i_rImport,
2252         sal_uInt16 i_nPrefix,
2253         const OUString& i_rLocalName,
2254         const Reference< xml::sax::XAttributeList > & i_xAttrList ) :
2255     SvXMLImportContext( i_rImport, i_nPrefix, i_rLocalName ),
2256     m_Level(0),
2257     m_StartValue(-1),
2258     m_ListId(),
2259     m_xNumRules()
2260 {
2261     OUString StyleName;
2262
2263     const SvXMLTokenMap& rTokenMap(
2264         i_rImport.GetTextImport()->GetTextNumberedParagraphAttrTokenMap() );
2265
2266     const sal_Int16 nAttrCount( i_xAttrList.is() ?
2267         i_xAttrList->getLength() : 0 );
2268     for ( sal_Int16 i=0; i < nAttrCount; i++ )
2269     {
2270         const OUString& rAttrName( i_xAttrList->getNameByIndex( i )  );
2271         const OUString& rValue   ( i_xAttrList->getValueByIndex( i ) );
2272
2273         OUString aLocalName;
2274         const sal_uInt16 nPrefix(
2275             GetImport().GetNamespaceMap().GetKeyByAttrName(
2276                 rAttrName, &aLocalName ) );
2277         switch( rTokenMap.Get( nPrefix, aLocalName ) )
2278         {
2279             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_XMLID:
2280                 m_XmlId = rValue;
2281 //FIXME: there is no UNO API for lists
2282                 break;
2283             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_LIST_ID:
2284                 m_ListId = rValue;
2285                 break;
2286             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_LEVEL:
2287                 {
2288                     sal_Int32 nTmp = rValue.toInt32();
2289                     if ( nTmp >= 1 && nTmp <= SHRT_MAX ) {
2290                         m_Level = static_cast<sal_uInt16>(nTmp) - 1;
2291                     }
2292                 }
2293                 break;
2294             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_STYLE_NAME:
2295                 StyleName = rValue;
2296                 break;
2297             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_CONTINUE_NUMBERING:
2298                 // this attribute is deprecated
2299 //                ContinuteNumbering = IsXMLToken(rValue, XML_TRUE);
2300                 break;
2301             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_START_VALUE:
2302                 {
2303                     sal_Int32 nTmp = rValue.toInt32();
2304                     if ( nTmp >= 0 && nTmp <= SHRT_MAX ) {
2305                         m_StartValue = static_cast<sal_Int16>(nTmp);
2306                     }
2307                 }
2308                 break;
2309         }
2310     }
2311
2312     XMLTextListsHelper& rTextListsHelper(
2313         i_rImport.GetTextImport()->GetTextListHelper() );
2314     if (m_ListId.isEmpty())
2315       {
2316         SAL_WARN_IF( i_rImport.GetODFVersion() == "1.2", "xmloff.text", "invalid numbered-paragraph: no list-id (1.2)" );
2317         m_ListId = rTextListsHelper.GetNumberedParagraphListId(m_Level,
2318             StyleName);
2319         SAL_WARN_IF(m_ListId.isEmpty(), "xmloff.text", "numbered-paragraph: no ListId");
2320         if (m_ListId.isEmpty()) {
2321             return;
2322         }
2323     }
2324     m_xNumRules = rTextListsHelper.EnsureNumberedParagraph( i_rImport,
2325         m_ListId, m_Level, StyleName);
2326
2327     SAL_WARN_IF(!m_xNumRules.is(), "xmloff.text", "numbered-paragraph: no NumRules");
2328
2329     i_rImport.GetTextImport()->GetTextListHelper().PushListContext( this );
2330 }
2331
2332 XMLNumberedParaContext::~XMLNumberedParaContext()
2333 {
2334 }
2335
2336 void XMLNumberedParaContext::EndElement()
2337 {
2338     if (!m_ListId.isEmpty()) {
2339         GetImport().GetTextImport()->PopListContext();
2340     }
2341 }
2342
2343 SvXMLImportContext *XMLNumberedParaContext::CreateChildContext(
2344     sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
2345     const Reference< xml::sax::XAttributeList > & i_xAttrList )
2346 {
2347     SvXMLImportContext *pContext( 0 );
2348
2349     if ( XML_NAMESPACE_TEXT == i_nPrefix ||
2350             XML_NAMESPACE_LO_EXT == i_nPrefix )
2351     {
2352         bool bIsHeader( IsXMLToken( i_rLocalName, XML_H ) );
2353         if ( bIsHeader || IsXMLToken( i_rLocalName, XML_P ) )
2354         {
2355             pContext = new XMLParaContext( GetImport(),
2356                 i_nPrefix, i_rLocalName, i_xAttrList, bIsHeader );
2357 // ignore text:number       } else if (IsXMLToken( i_rLocalName, XML_NUMBER )) {
2358         }
2359     }
2360
2361     if (!pContext) {
2362         pContext = SvXMLImportContext::CreateChildContext(
2363             i_nPrefix, i_rLocalName, i_xAttrList );
2364     }
2365
2366     return pContext;
2367 }
2368
2369 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */