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