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