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