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