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