Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/debug.hxx>
21 : #include <rtl/ustrbuf.hxx>
22 : #include <tools/fontenum.hxx>
23 : #include <com/sun/star/uno/Any.hxx>
24 : #include <com/sun/star/style/DropCapFormat.hpp>
25 : #include <com/sun/star/text/FontRelief.hpp>
26 : #include <com/sun/star/text/WrapTextMode.hpp>
27 : #include <com/sun/star/text/XTextColumns.hpp>
28 : #include <com/sun/star/text/TextColumn.hpp>
29 : #include <com/sun/star/text/RelOrientation.hpp>
30 : #include <com/sun/star/text/HoriOrientation.hpp>
31 : #include <com/sun/star/text/VertOrientation.hpp>
32 : #include <com/sun/star/text/RubyAdjust.hpp>
33 : #include <com/sun/star/text/FontEmphasis.hpp>
34 : #include <com/sun/star/text/ParagraphVertAlign.hpp>
35 : #include <sax/tools/converter.hxx>
36 : #include <xmloff/xmltypes.hxx>
37 : #include <xmloff/xmluconv.hxx>
38 : #include <xmloff/xmltoken.hxx>
39 : #include "XMLAnchorTypePropHdl.hxx"
40 : #include <xmloff/XMLConstantsPropertyHandler.hxx>
41 : #include "XMLClipPropertyHandler.hxx"
42 : #include "XMLTextColumnsPropertyHandler.hxx"
43 : #include <xmloff/NamedBoolPropertyHdl.hxx>
44 : #include "txtprhdl.hxx"
45 : // OD 2004-05-05 #i28701#
46 : #include <com/sun/star/text/WrapInfluenceOnPosition.hpp>
47 :
48 :
49 : using ::rtl::OUString;
50 : using ::rtl::OUStringBuffer;
51 :
52 : using namespace ::com::sun::star::uno;
53 : using namespace ::com::sun::star::style;
54 : using namespace ::com::sun::star::text;
55 : using namespace ::xmloff::token;
56 :
57 : // ---------------------------------------------------------------------------
58 :
59 : SvXMLEnumMapEntry const pXML_HoriPos_Enum[] =
60 : {
61 : { XML_FROM_LEFT, HoriOrientation::NONE },
62 : { XML_FROM_INSIDE, HoriOrientation::NONE }, // import only
63 : { XML_LEFT, HoriOrientation::LEFT },
64 : { XML_INSIDE, HoriOrientation::LEFT }, // import only
65 : { XML_CENTER, HoriOrientation::CENTER },
66 : { XML_RIGHT, HoriOrientation::RIGHT },
67 : { XML_OUTSIDE, HoriOrientation::RIGHT }, // import only
68 : { XML_TOKEN_INVALID, 0 }
69 : };
70 :
71 : SvXMLEnumMapEntry const pXML_HoriPosMirrored_Enum[] =
72 : {
73 : { XML_FROM_INSIDE, HoriOrientation::NONE },
74 : { XML_INSIDE, HoriOrientation::LEFT },
75 : { XML_CENTER, HoriOrientation::CENTER },
76 : { XML_OUTSIDE, HoriOrientation::RIGHT },
77 : { XML_TOKEN_INVALID, 0 }
78 : };
79 :
80 : SvXMLEnumMapEntry const pXML_HoriRel_Enum[] =
81 : {
82 : { XML_PARAGRAPH, RelOrientation::FRAME },
83 : { XML_PARAGRAPH_CONTENT, RelOrientation::PRINT_AREA },
84 : { XML_PAGE, RelOrientation::PAGE_FRAME },
85 : { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA },
86 : { XML_PARAGRAPH_START_MARGIN, RelOrientation::FRAME_LEFT },
87 : { XML_PARAGRAPH_END_MARGIN, RelOrientation::FRAME_RIGHT },
88 : { XML_PAGE_START_MARGIN, RelOrientation::PAGE_LEFT },
89 : { XML_PAGE_END_MARGIN, RelOrientation::PAGE_RIGHT },
90 : { XML_CHAR, RelOrientation::CHAR },
91 : { XML_FRAME, RelOrientation::FRAME }, // import only
92 : { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, // import only
93 : { XML_FRAME_START_MARGIN, RelOrientation::FRAME_LEFT }, // import only
94 : { XML_FRAME_END_MARGIN, RelOrientation::FRAME_RIGHT }, // import only
95 : { XML_TOKEN_INVALID, 0 }
96 : };
97 :
98 : SvXMLEnumMapEntry const pXML_HoriRelFrame_Enum[] =
99 : {
100 : { XML_FRAME, RelOrientation::FRAME },
101 : { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA },
102 : { XML_PAGE, RelOrientation::PAGE_FRAME },
103 : { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA },
104 : { XML_FRAME_START_MARGIN, RelOrientation::FRAME_LEFT },
105 : { XML_FRAME_END_MARGIN, RelOrientation::FRAME_RIGHT },
106 : { XML_PAGE_START_MARGIN, RelOrientation::PAGE_LEFT },
107 : { XML_PAGE_END_MARGIN, RelOrientation::PAGE_RIGHT },
108 : { XML_CHAR, RelOrientation::CHAR },
109 : { XML_TOKEN_INVALID, 0 }
110 : };
111 :
112 : SvXMLEnumMapEntry const pXML_HoriMirror_Enum[] =
113 : {
114 : { XML_FROM_LEFT, sal_False },
115 : { XML_FROM_INSIDE, sal_True },
116 : { XML_LEFT, sal_False },
117 : { XML_INSIDE, sal_True },
118 : { XML_CENTER, sal_False },
119 : { XML_RIGHT, sal_False },
120 : { XML_OUTSIDE, sal_True },
121 : { XML_TOKEN_INVALID, 0 }
122 : };
123 :
124 : SvXMLEnumMapEntry const pXML_VertPos_Enum[] =
125 : {
126 : { XML_FROM_TOP, VertOrientation::NONE },
127 : { XML_TOP, VertOrientation::TOP },
128 : { XML_TOP, VertOrientation::CHAR_TOP }, // export only
129 : { XML_TOP, VertOrientation::LINE_TOP }, // export only
130 : { XML_MIDDLE, VertOrientation::CENTER },
131 : { XML_MIDDLE, VertOrientation::CHAR_CENTER }, // export only
132 : { XML_MIDDLE, VertOrientation::LINE_CENTER }, // export only
133 : { XML_BOTTOM, VertOrientation::BOTTOM },
134 : { XML_BOTTOM, VertOrientation::CHAR_BOTTOM }, // export only
135 : { XML_BOTTOM, VertOrientation::LINE_BOTTOM }, // export only
136 : { XML_BELOW, VertOrientation::CHAR_BOTTOM }, // import only
137 : { XML_TOKEN_INVALID, 0 }
138 : };
139 :
140 : SvXMLEnumMapEntry const pXML_VertPosAtChar_Enum[] =
141 : {
142 : { XML_FROM_TOP, VertOrientation::NONE },
143 : { XML_TOP, VertOrientation::TOP },
144 : { XML_TOP, VertOrientation::CHAR_TOP }, // export only
145 : { XML_TOP, VertOrientation::LINE_TOP }, // export only
146 : { XML_MIDDLE, VertOrientation::CENTER },
147 : { XML_MIDDLE, VertOrientation::CHAR_CENTER }, // export only
148 : { XML_MIDDLE, VertOrientation::LINE_CENTER }, // export only
149 : { XML_BOTTOM, VertOrientation::BOTTOM },
150 : { XML_BELOW, VertOrientation::CHAR_BOTTOM }, // export only
151 : { XML_BOTTOM, VertOrientation::LINE_BOTTOM }, // export only
152 : { XML_TOKEN_INVALID, 0 }
153 : };
154 :
155 : SvXMLEnumMapEntry const pXML_VertRel_Enum[] =
156 : {
157 : { XML_PARAGRAPH, RelOrientation::FRAME },
158 : { XML_PARAGRAPH_CONTENT, RelOrientation::PRINT_AREA },
159 : { XML_CHAR, RelOrientation::CHAR },
160 : // DVO, OD 17.09.2003 #i18732# - allow vertical alignment at page
161 : { XML_PAGE, RelOrientation::PAGE_FRAME },
162 : { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA },
163 : { XML_FRAME, RelOrientation::FRAME }, // import only
164 : { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, // import only
165 : // OD 13.11.2003 #i22341# - new vertical alignment at top of line
166 : { XML_LINE, RelOrientation::TEXT_LINE },
167 : { XML_TOKEN_INVALID, 0 }
168 : };
169 :
170 : SvXMLEnumMapEntry const pXML_VertRelPage_Enum[] =
171 : {
172 : { XML_PAGE, RelOrientation::FRAME },
173 : { XML_PAGE_CONTENT, RelOrientation::PRINT_AREA },
174 : { XML_PAGE, RelOrientation::PAGE_FRAME },
175 : { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA },
176 : { XML_TOKEN_INVALID, 0 }
177 : };
178 :
179 : SvXMLEnumMapEntry const pXML_VertRelFrame_Enum[] =
180 : {
181 : { XML_FRAME, RelOrientation::FRAME },
182 : { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA },
183 : { XML_TOKEN_INVALID, 0 }
184 : };
185 :
186 : SvXMLEnumMapEntry const pXML_VertRelAsChar_Enum[] =
187 : {
188 : { XML_BASELINE, VertOrientation::TOP },
189 : { XML_BASELINE, VertOrientation::CENTER }, // export only
190 : { XML_BASELINE, VertOrientation::BOTTOM }, // export only
191 : { XML_TEXT, VertOrientation::CHAR_TOP },
192 : { XML_TEXT, VertOrientation::CHAR_CENTER }, // export only
193 : { XML_TEXT, VertOrientation::CHAR_BOTTOM }, // export only
194 : { XML_LINE, VertOrientation::LINE_TOP },
195 : { XML_LINE, VertOrientation::LINE_CENTER }, // export only
196 : { XML_LINE, VertOrientation::LINE_BOTTOM }, // export only
197 : { XML_TOKEN_INVALID, 0 }
198 : };
199 :
200 : SvXMLEnumMapEntry const pXML_RubyAdjust_Enum[] =
201 : {
202 : { XML_LEFT, RubyAdjust_LEFT },
203 : { XML_CENTER, RubyAdjust_CENTER },
204 : { XML_RIGHT, RubyAdjust_RIGHT },
205 : { XML_DISTRIBUTE_LETTER, RubyAdjust_BLOCK },
206 : { XML_DISTRIBUTE_SPACE, RubyAdjust_INDENT_BLOCK },
207 : { XML_TOKEN_INVALID, 0 }
208 : };
209 :
210 : SvXMLEnumMapEntry const pXML_FontRelief_Enum[] =
211 : {
212 : { XML_NONE, FontRelief::NONE },
213 : { XML_ENGRAVED, FontRelief::ENGRAVED },
214 : { XML_EMBOSSED, FontRelief::EMBOSSED },
215 : { XML_TOKEN_INVALID, 0 }
216 : };
217 :
218 : SvXMLEnumMapEntry const pXML_VerticalAlign_Enum[] =
219 : {
220 : { XML_TOP, ParagraphVertAlign::TOP },
221 : { XML_MIDDLE, ParagraphVertAlign::CENTER },
222 : { XML_BOTTOM, ParagraphVertAlign::BOTTOM },
223 : { XML_BASELINE, ParagraphVertAlign::BASELINE },
224 : { XML_AUTO, ParagraphVertAlign::AUTOMATIC },
225 : { XML_TOKEN_INVALID, 0 }
226 : };
227 :
228 : // OD 2004-05-05 #i28701#
229 : SvXMLEnumMapEntry const pXML_WrapInfluenceOnPosition_Enum[] =
230 : {
231 : // Tokens have been renamed and <XML_ITERATIVE> has been added (#i35017#)
232 : { XML_ONCE_SUCCESSIVE, WrapInfluenceOnPosition::ONCE_SUCCESSIVE },
233 : { XML_ONCE_CONCURRENT, WrapInfluenceOnPosition::ONCE_CONCURRENT },
234 : { XML_ITERATIVE, WrapInfluenceOnPosition::ITERATIVE },
235 : { XML_TOKEN_INVALID, 0 }
236 : };
237 :
238 : // ---------------------------------------------------------------------------
239 :
240 352 : class XMLDropCapPropHdl_Impl : public XMLPropertyHandler
241 : {
242 : public:
243 : virtual ~XMLDropCapPropHdl_Impl ();
244 :
245 : virtual bool equals(
246 : const ::com::sun::star::uno::Any& r1,
247 : const ::com::sun::star::uno::Any& r2 ) const;
248 :
249 : /// TabStops will be imported/exported as XML-Elements. So the Import/Export-work must be done at another place.
250 : virtual sal_Bool importXML(
251 : const ::rtl::OUString& rStrImpValue,
252 : ::com::sun::star::uno::Any& rValue,
253 : const SvXMLUnitConverter& ) const;
254 : virtual sal_Bool exportXML(
255 : ::rtl::OUString& rStrExpValue,
256 : const ::com::sun::star::uno::Any& rValue,
257 : const SvXMLUnitConverter& ) const;
258 : };
259 :
260 704 : XMLDropCapPropHdl_Impl::~XMLDropCapPropHdl_Impl ()
261 : {
262 704 : }
263 :
264 0 : bool XMLDropCapPropHdl_Impl::equals(
265 : const Any& r1,
266 : const Any& r2 ) const
267 : {
268 0 : DropCapFormat aFormat1, aFormat2;
269 0 : r1 >>= aFormat1;
270 0 : r2 >>= aFormat2;
271 :
272 : return (aFormat1.Lines <=1 && aFormat2.Lines <=1) ||
273 : (aFormat1.Lines == aFormat2.Lines &&
274 : aFormat1.Count == aFormat2.Count &&
275 0 : aFormat1.Distance == aFormat2.Distance);
276 : }
277 :
278 0 : sal_Bool XMLDropCapPropHdl_Impl::importXML(
279 : const OUString&,
280 : Any&,
281 : const SvXMLUnitConverter& ) const
282 : {
283 : DBG_ASSERT( !this, "drop caps are an element import property" );
284 0 : return sal_False;
285 : }
286 :
287 0 : sal_Bool XMLDropCapPropHdl_Impl::exportXML(
288 : OUString&,
289 : const Any&,
290 : const SvXMLUnitConverter& ) const
291 : {
292 : DBG_ASSERT( !this, "drop caps are an element export property" );
293 0 : return sal_False;
294 : }
295 :
296 : // ---------------------------------------------------------------------------
297 :
298 173 : class XMLOpaquePropHdl_Impl : public XMLPropertyHandler
299 : {
300 : public:
301 : virtual ~XMLOpaquePropHdl_Impl ();
302 :
303 : virtual sal_Bool importXML(
304 : const ::rtl::OUString& rStrImpValue,
305 : ::com::sun::star::uno::Any& rValue,
306 : const SvXMLUnitConverter& ) const;
307 : virtual sal_Bool exportXML(
308 : ::rtl::OUString& rStrExpValue,
309 : const ::com::sun::star::uno::Any& rValue,
310 : const SvXMLUnitConverter& ) const;
311 : };
312 :
313 1 : sal_Bool XMLOpaquePropHdl_Impl::importXML(
314 : const OUString& rStrImpValue,
315 : Any& rValue,
316 : const SvXMLUnitConverter& ) const
317 : {
318 1 : sal_Bool bRet = sal_True;
319 1 : sal_Bool bVal = sal_False;
320 1 : if( IsXMLToken( rStrImpValue, XML_FOREGROUND ) )
321 1 : bVal = sal_True;
322 0 : else if( !IsXMLToken( rStrImpValue, XML_BACKGROUND ) )
323 0 : bRet = sal_False;
324 :
325 1 : if( bRet )
326 1 : rValue.setValue( &bVal, ::getBooleanCppuType() );
327 :
328 1 : return bRet;
329 : }
330 :
331 0 : sal_Bool XMLOpaquePropHdl_Impl::exportXML(
332 : OUString& rStrExpValue,
333 : const Any& rValue,
334 : const SvXMLUnitConverter& ) const
335 : {
336 0 : if( *(sal_Bool *)rValue.getValue() )
337 0 : rStrExpValue = GetXMLToken( XML_FOREGROUND );
338 : else
339 0 : rStrExpValue = GetXMLToken( XML_BACKGROUND );
340 :
341 0 : return sal_True;
342 : }
343 :
344 346 : XMLOpaquePropHdl_Impl::~XMLOpaquePropHdl_Impl ()
345 : {
346 346 : }
347 :
348 : // ---------------------------------------------------------------------------
349 :
350 173 : class XMLContourModePropHdl_Impl : public XMLPropertyHandler
351 : {
352 : public:
353 : virtual ~XMLContourModePropHdl_Impl ();
354 :
355 : virtual sal_Bool importXML(
356 : const ::rtl::OUString& rStrImpValue,
357 : ::com::sun::star::uno::Any& rValue,
358 : const SvXMLUnitConverter& ) const;
359 : virtual sal_Bool exportXML(
360 : ::rtl::OUString& rStrExpValue,
361 : const ::com::sun::star::uno::Any& rValue,
362 : const SvXMLUnitConverter& ) const;
363 : };
364 :
365 0 : sal_Bool XMLContourModePropHdl_Impl::importXML(
366 : const OUString& rStrImpValue,
367 : Any& rValue,
368 : const SvXMLUnitConverter& ) const
369 : {
370 0 : sal_Bool bRet = sal_True;
371 0 : sal_Bool bVal = sal_False;
372 0 : if( IsXMLToken( rStrImpValue, XML_OUTSIDE ) )
373 0 : bVal = sal_True;
374 0 : else if( ! IsXMLToken( rStrImpValue, XML_FULL ) )
375 0 : bRet = sal_False;
376 :
377 0 : if( bRet )
378 0 : rValue.setValue( &bVal, ::getBooleanCppuType() );
379 :
380 0 : return bRet;
381 : }
382 :
383 0 : sal_Bool XMLContourModePropHdl_Impl::exportXML(
384 : OUString& rStrExpValue,
385 : const Any& rValue,
386 : const SvXMLUnitConverter& ) const
387 : {
388 0 : if( *(sal_Bool *)rValue.getValue() )
389 0 : rStrExpValue = GetXMLToken( XML_OUTSIDE );
390 : else
391 0 : rStrExpValue = GetXMLToken( XML_FULL );
392 :
393 0 : return sal_True;
394 : }
395 :
396 346 : XMLContourModePropHdl_Impl::~XMLContourModePropHdl_Impl()
397 : {
398 346 : }
399 :
400 : // ---------------------------------------------------------------------------
401 :
402 173 : class XMLParagraphOnlyPropHdl_Impl : public XMLPropertyHandler
403 : {
404 : public:
405 : virtual ~XMLParagraphOnlyPropHdl_Impl ();
406 :
407 : virtual sal_Bool importXML(
408 : const ::rtl::OUString& rStrImpValue,
409 : ::com::sun::star::uno::Any& rValue,
410 : const SvXMLUnitConverter& ) const;
411 : virtual sal_Bool exportXML(
412 : ::rtl::OUString& rStrExpValue,
413 : const ::com::sun::star::uno::Any& rValue,
414 : const SvXMLUnitConverter& ) const;
415 : };
416 :
417 3 : sal_Bool XMLParagraphOnlyPropHdl_Impl::importXML(
418 : const OUString& rStrImpValue,
419 : Any& rValue,
420 : const SvXMLUnitConverter& ) const
421 : {
422 3 : sal_Bool bRet = sal_True;
423 3 : sal_Bool bVal = sal_False;
424 :
425 3 : if( ! IsXMLToken( rStrImpValue, XML_NO_LIMIT ) )
426 : {
427 0 : sal_Int32 nValue = 0;
428 0 : bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
429 0 : bVal = 1 == nValue;
430 : }
431 :
432 3 : if( bRet )
433 3 : rValue.setValue( &bVal, ::getBooleanCppuType() );
434 :
435 3 : return bRet;
436 : }
437 :
438 0 : sal_Bool XMLParagraphOnlyPropHdl_Impl::exportXML(
439 : OUString& rStrExpValue,
440 : const Any& rValue,
441 : const SvXMLUnitConverter& ) const
442 : {
443 0 : if( *(sal_Bool *)rValue.getValue() )
444 0 : rStrExpValue = GetXMLToken( XML_1 );
445 : else
446 0 : rStrExpValue = GetXMLToken( XML_NO_LIMIT );
447 :
448 0 : return sal_True;
449 : }
450 :
451 346 : XMLParagraphOnlyPropHdl_Impl::~XMLParagraphOnlyPropHdl_Impl()
452 : {
453 346 : }
454 :
455 : // ---------------------------------------------------------------------------
456 :
457 : SvXMLEnumMapEntry const pXML_Wrap_Enum[] =
458 : {
459 : { XML_NONE, WrapTextMode_NONE },
460 : { XML_RUN_THROUGH, WrapTextMode_THROUGHT },
461 : { XML_PARALLEL, WrapTextMode_PARALLEL },
462 : { XML_DYNAMIC, WrapTextMode_DYNAMIC },
463 : { XML_LEFT, WrapTextMode_LEFT },
464 : { XML_RIGHT, WrapTextMode_RIGHT },
465 : { XML_TOKEN_INVALID, 0 }
466 : };
467 :
468 173 : class XMLWrapPropHdl_Impl : public XMLPropertyHandler
469 : {
470 : public:
471 : virtual ~XMLWrapPropHdl_Impl ();
472 :
473 : virtual sal_Bool importXML(
474 : const ::rtl::OUString& rStrImpValue,
475 : ::com::sun::star::uno::Any& rValue,
476 : const SvXMLUnitConverter& ) const;
477 : virtual sal_Bool exportXML(
478 : ::rtl::OUString& rStrExpValue,
479 : const ::com::sun::star::uno::Any& rValue,
480 : const SvXMLUnitConverter& ) const;
481 : };
482 :
483 4 : sal_Bool XMLWrapPropHdl_Impl::importXML(
484 : const OUString& rStrImpValue,
485 : Any& rValue,
486 : const SvXMLUnitConverter& ) const
487 : {
488 : sal_uInt16 nWrap;
489 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( nWrap, rStrImpValue,
490 4 : pXML_Wrap_Enum );
491 :
492 4 : if( bRet )
493 4 : rValue <<= (WrapTextMode)nWrap;
494 :
495 4 : return bRet;
496 : }
497 :
498 0 : sal_Bool XMLWrapPropHdl_Impl::exportXML(
499 : OUString& rStrExpValue,
500 : const Any& rValue,
501 : const SvXMLUnitConverter& ) const
502 : {
503 0 : OUStringBuffer aOut;
504 : WrapTextMode eVal;
505 :
506 0 : rValue >>= eVal;
507 :
508 0 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( aOut, eVal, pXML_Wrap_Enum, XML_NONE );
509 :
510 0 : rStrExpValue = aOut.makeStringAndClear();
511 :
512 0 : return bRet;
513 : }
514 :
515 346 : XMLWrapPropHdl_Impl::~XMLWrapPropHdl_Impl ()
516 : {
517 346 : }
518 :
519 : // ---------------------------------------------------------------------------
520 :
521 : class XMLFrameProtectPropHdl_Impl : public XMLPropertyHandler
522 : {
523 : const OUString sVal;
524 : public:
525 507 : XMLFrameProtectPropHdl_Impl( enum XMLTokenEnum eVal ) :
526 507 : sVal( GetXMLToken(eVal) ) {}
527 : virtual ~XMLFrameProtectPropHdl_Impl ();
528 :
529 : virtual sal_Bool importXML(
530 : const ::rtl::OUString& rStrImpValue,
531 : ::com::sun::star::uno::Any& rValue,
532 : const SvXMLUnitConverter& ) const;
533 : virtual sal_Bool exportXML(
534 : ::rtl::OUString& rStrExpValue,
535 : const ::com::sun::star::uno::Any& rValue,
536 : const SvXMLUnitConverter& ) const;
537 : };
538 :
539 0 : sal_Bool XMLFrameProtectPropHdl_Impl::importXML(
540 : const OUString& rStrImpValue,
541 : Any& rValue,
542 : const SvXMLUnitConverter& ) const
543 : {
544 0 : sal_Bool bRet = sal_True;
545 0 : sal_Bool bVal = sal_False;
546 0 : if( ! IsXMLToken( rStrImpValue, XML_NONE ) )
547 : {
548 0 : bRet = sal_False;
549 0 : SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
550 0 : OUString aToken;
551 0 : while( aTokenEnum.getNextToken( aToken ) )
552 : {
553 0 : bRet = sal_True;
554 0 : if( aToken == sVal )
555 : {
556 0 : bVal = sal_True;
557 0 : break;
558 : }
559 0 : }
560 : }
561 :
562 0 : if( bRet )
563 0 : rValue.setValue( &bVal, ::getBooleanCppuType() );
564 :
565 0 : return bRet;
566 : }
567 :
568 0 : sal_Bool XMLFrameProtectPropHdl_Impl::exportXML(
569 : OUString& rStrExpValue,
570 : const Any& rValue,
571 : const SvXMLUnitConverter& ) const
572 : {
573 0 : if( *(sal_Bool *)rValue.getValue() )
574 : {
575 0 : if( rStrExpValue.isEmpty() ||
576 0 : IsXMLToken( rStrExpValue, XML_NONE ) )
577 : {
578 0 : rStrExpValue = sVal;
579 : }
580 : else
581 : {
582 0 : OUStringBuffer aOut( rStrExpValue.getLength() + 1 +
583 0 : sVal.getLength() );
584 0 : aOut.append( rStrExpValue );
585 0 : aOut.append( (sal_Unicode)' ' );
586 0 : aOut.append( sVal );
587 0 : rStrExpValue = aOut.makeStringAndClear();
588 : }
589 : }
590 0 : else if( rStrExpValue.isEmpty() )
591 : {
592 0 : rStrExpValue = GetXMLToken( XML_NONE );
593 : }
594 :
595 0 : return sal_True;
596 : }
597 :
598 1014 : XMLFrameProtectPropHdl_Impl::~XMLFrameProtectPropHdl_Impl()
599 : {
600 1014 : }
601 :
602 : // ---------------------------------------------------------------------------
603 :
604 : SvXMLEnumMapEntry const pXML_Anchor_Enum[] =
605 : {
606 : { XML_CHAR, TextContentAnchorType_AT_CHARACTER },
607 : { XML_PAGE, TextContentAnchorType_AT_PAGE },
608 : { XML_FRAME, TextContentAnchorType_AT_FRAME },
609 : { XML_PARAGRAPH, TextContentAnchorType_AT_PARAGRAPH },
610 : { XML_AS_CHAR, TextContentAnchorType_AS_CHARACTER },
611 : { XML_TOKEN_INVALID, 0 }
612 : };
613 :
614 :
615 3 : sal_Bool XMLAnchorTypePropHdl::importXML(
616 : const OUString& rStrImpValue,
617 : Any& rValue,
618 : const SvXMLUnitConverter& ) const
619 : {
620 : sal_uInt16 nAnchor;
621 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( nAnchor, rStrImpValue,
622 3 : pXML_Anchor_Enum );
623 :
624 3 : if( bRet )
625 3 : rValue <<= (TextContentAnchorType)nAnchor;
626 :
627 3 : return bRet;
628 : }
629 :
630 0 : sal_Bool XMLAnchorTypePropHdl::exportXML(
631 : OUString& rStrExpValue,
632 : const Any& rValue,
633 : const SvXMLUnitConverter& ) const
634 : {
635 0 : OUStringBuffer aOut;
636 : TextContentAnchorType eVal;
637 :
638 0 : rValue >>= eVal;
639 :
640 0 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( aOut, eVal, pXML_Anchor_Enum, XML_PARAGRAPH );
641 :
642 0 : rStrExpValue = aOut.makeStringAndClear();
643 :
644 0 : return bRet;
645 : }
646 :
647 322 : XMLAnchorTypePropHdl::~XMLAnchorTypePropHdl()
648 : {
649 322 : }
650 :
651 9 : sal_Bool XMLAnchorTypePropHdl::convert( const OUString& rStrImpValue,
652 : TextContentAnchorType& rType )
653 : {
654 : sal_uInt16 nAnchor;
655 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( nAnchor, rStrImpValue,
656 9 : pXML_Anchor_Enum );
657 9 : if( bRet )
658 9 : rType = (TextContentAnchorType)nAnchor;
659 9 : return bRet;
660 : }
661 :
662 : // ---------------------------------------------------------------------------
663 :
664 :
665 678 : XMLTextColumnsPropertyHandler::~XMLTextColumnsPropertyHandler ()
666 : {
667 678 : }
668 :
669 0 : bool XMLTextColumnsPropertyHandler::equals(
670 : const Any& r1,
671 : const Any& r2 ) const
672 : {
673 0 : Reference < XTextColumns > xColumns1;
674 0 : r1 >>= xColumns1;
675 :
676 0 : Reference < XTextColumns > xColumns2;
677 0 : r2 >>= xColumns2;
678 :
679 0 : if( xColumns1->getColumnCount() != xColumns2->getColumnCount() ||
680 0 : xColumns1->getReferenceValue() != xColumns2->getReferenceValue() )
681 0 : return sal_False;
682 :
683 0 : Sequence < TextColumn > aColumns1 = xColumns1->getColumns();
684 0 : Sequence < TextColumn > aColumns2 = xColumns2->getColumns();
685 0 : sal_Int32 nCount = aColumns1.getLength();
686 0 : if( aColumns2.getLength() != nCount )
687 0 : return sal_False;
688 :
689 0 : const TextColumn *pColumns1 = aColumns1.getArray();
690 0 : const TextColumn *pColumns2 = aColumns2.getArray();
691 :
692 0 : while( nCount-- )
693 : {
694 0 : if( pColumns1->Width != pColumns2->Width ||
695 : pColumns1->LeftMargin != pColumns2->LeftMargin ||
696 : pColumns1->RightMargin != pColumns2->RightMargin )
697 0 : return sal_False;
698 :
699 0 : pColumns1++;
700 0 : pColumns2++;
701 : }
702 :
703 0 : return sal_True;
704 : }
705 :
706 0 : sal_Bool XMLTextColumnsPropertyHandler::importXML(
707 : const OUString&,
708 : Any&,
709 : const SvXMLUnitConverter& ) const
710 : {
711 : DBG_ASSERT( !this, "columns are an element import property" );
712 0 : return sal_False;
713 : }
714 :
715 0 : sal_Bool XMLTextColumnsPropertyHandler::exportXML(
716 : OUString&,
717 : const Any&,
718 : const SvXMLUnitConverter& ) const
719 : {
720 : DBG_ASSERT( !this, "columns are an element export property" );
721 0 : return sal_False;
722 : }
723 :
724 : // ---------------------------------------------------------------------------
725 :
726 173 : class XMLHoriMirrorPropHdl_Impl : public XMLPropertyHandler
727 : {
728 : public:
729 : virtual ~XMLHoriMirrorPropHdl_Impl ();
730 :
731 : virtual sal_Bool importXML(
732 : const ::rtl::OUString& rStrImpValue,
733 : ::com::sun::star::uno::Any& rValue,
734 : const SvXMLUnitConverter& ) const;
735 : virtual sal_Bool exportXML(
736 : ::rtl::OUString& rStrExpValue,
737 : const ::com::sun::star::uno::Any& rValue,
738 : const SvXMLUnitConverter& ) const;
739 : };
740 :
741 7 : sal_Bool XMLHoriMirrorPropHdl_Impl::importXML(
742 : const OUString& rStrImpValue,
743 : Any& rValue,
744 : const SvXMLUnitConverter& ) const
745 : {
746 : sal_uInt16 nHoriMirror;
747 : sal_Bool bRet = SvXMLUnitConverter::convertEnum( nHoriMirror, rStrImpValue,
748 7 : pXML_HoriMirror_Enum );
749 :
750 7 : if( bRet )
751 : {
752 7 : sal_Bool bTmp = nHoriMirror != 0;
753 7 : rValue.setValue( &bTmp, ::getBooleanCppuType() );
754 : }
755 :
756 7 : return bRet;
757 : }
758 :
759 0 : sal_Bool XMLHoriMirrorPropHdl_Impl::exportXML(
760 : OUString&,
761 : const Any&,
762 : const SvXMLUnitConverter& ) const
763 : {
764 : DBG_ASSERT( !this, "HorMirror properyt shouldn't be exported" );
765 :
766 0 : return sal_False;
767 : }
768 :
769 346 : XMLHoriMirrorPropHdl_Impl::~XMLHoriMirrorPropHdl_Impl ()
770 : {
771 346 : }
772 :
773 : // ---------------------------------------------------------------------------
774 :
775 : class XMLGrfMirrorPropHdl_Impl : public XMLPropertyHandler
776 : {
777 : const OUString sVal;
778 : sal_Bool bHori;
779 :
780 : public:
781 507 : XMLGrfMirrorPropHdl_Impl( enum XMLTokenEnum eVal, sal_Bool bH ) :
782 507 : sVal( GetXMLToken( eVal ) ),
783 1014 : bHori( bH ) {}
784 : virtual ~XMLGrfMirrorPropHdl_Impl ();
785 :
786 : virtual sal_Bool importXML(
787 : const ::rtl::OUString& rStrImpValue,
788 : ::com::sun::star::uno::Any& rValue,
789 : const SvXMLUnitConverter& ) const;
790 : virtual sal_Bool exportXML(
791 : ::rtl::OUString& rStrExpValue,
792 : const ::com::sun::star::uno::Any& rValue,
793 : const SvXMLUnitConverter& ) const;
794 : };
795 :
796 0 : sal_Bool XMLGrfMirrorPropHdl_Impl::importXML(
797 : const OUString& rStrImpValue,
798 : Any& rValue,
799 : const SvXMLUnitConverter& ) const
800 : {
801 0 : sal_Bool bRet = sal_True;
802 0 : sal_Bool bVal = sal_False;
803 0 : if( ! IsXMLToken( rStrImpValue, XML_NONE ) )
804 : {
805 0 : bRet = sal_False;
806 0 : SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
807 0 : OUString aToken;
808 0 : while( aTokenEnum.getNextToken( aToken ) )
809 : {
810 0 : bRet = sal_True;
811 0 : if( aToken == sVal ||
812 0 : (bHori && IsXMLToken( aToken, XML_HORIZONTAL ) ) )
813 : {
814 0 : bVal = sal_True;
815 0 : break;
816 : }
817 0 : }
818 : }
819 :
820 0 : if( bRet )
821 0 : rValue.setValue( &bVal, ::getBooleanCppuType() );
822 :
823 0 : return bRet;
824 : }
825 :
826 0 : sal_Bool XMLGrfMirrorPropHdl_Impl::exportXML(
827 : OUString& rStrExpValue,
828 : const Any& rValue,
829 : const SvXMLUnitConverter& ) const
830 : {
831 0 : if( *(sal_Bool *)rValue.getValue() )
832 : {
833 0 : if( rStrExpValue.isEmpty() ||
834 0 : IsXMLToken( rStrExpValue, XML_NONE ) )
835 : {
836 0 : rStrExpValue = sVal;
837 : }
838 0 : else if( bHori &&
839 : /* XML_HORIZONTAL_ON_LEFT_PAGES and XML_HORIZONTAL_ON_RIGHT_PAGES
840 : are replaced by XML_HORIZONTAL_ON_EVEN and XML_HORIZONTAL_ON_ODD.
841 : (#i49139#)
842 : */
843 0 : ( IsXMLToken( rStrExpValue, XML_HORIZONTAL_ON_EVEN ) ||
844 0 : IsXMLToken( rStrExpValue, XML_HORIZONTAL_ON_ODD ) ))
845 : {
846 0 : rStrExpValue = GetXMLToken( XML_HORIZONTAL );
847 : }
848 : else
849 : {
850 0 : OUStringBuffer aOut( rStrExpValue.getLength() + 1 +
851 0 : sVal.getLength() );
852 0 : aOut.append( rStrExpValue );
853 0 : aOut.append( (sal_Unicode)' ' );
854 0 : aOut.append( sVal );
855 0 : rStrExpValue = aOut.makeStringAndClear();
856 : }
857 : }
858 0 : else if( rStrExpValue.isEmpty() )
859 : {
860 0 : rStrExpValue = GetXMLToken( XML_NONE );
861 : }
862 :
863 0 : return sal_True;
864 : }
865 :
866 1014 : XMLGrfMirrorPropHdl_Impl::~XMLGrfMirrorPropHdl_Impl()
867 : {
868 1014 : }
869 :
870 : // ---------------------------------------------------------------------------
871 :
872 : SvXMLEnumMapEntry const pXML_Emphasize_Enum[] =
873 : {
874 : { XML_NONE, FontEmphasis::NONE },
875 : { XML_DOT, FontEmphasis::DOT_ABOVE },
876 : { XML_CIRCLE, FontEmphasis::CIRCLE_ABOVE },
877 : { XML_DISC, FontEmphasis::DISK_ABOVE },
878 : { XML_ACCENT, FontEmphasis::ACCENT_ABOVE },
879 : { XML_TOKEN_INVALID, 0 }
880 : };
881 : class XMLTextEmphasizePropHdl_Impl : public XMLPropertyHandler
882 : {
883 : public:
884 481 : XMLTextEmphasizePropHdl_Impl() {}
885 : virtual ~XMLTextEmphasizePropHdl_Impl();
886 :
887 : virtual sal_Bool importXML(
888 : const ::rtl::OUString& rStrImpValue,
889 : ::com::sun::star::uno::Any& rValue,
890 : const SvXMLUnitConverter& ) const;
891 : virtual sal_Bool exportXML(
892 : ::rtl::OUString& rStrExpValue,
893 : const ::com::sun::star::uno::Any& rValue,
894 : const SvXMLUnitConverter& ) const;
895 : };
896 :
897 6 : sal_Bool XMLTextEmphasizePropHdl_Impl::importXML(
898 : const OUString& rStrImpValue,
899 : Any& rValue,
900 : const SvXMLUnitConverter& ) const
901 : {
902 6 : sal_Bool bRet = sal_True;
903 6 : sal_uInt16 nVal = FontEmphasis::NONE;
904 6 : sal_Bool bBelow = sal_False;
905 6 : sal_Bool bHasPos = sal_False, bHasType = sal_False;
906 6 : OUString aToken;
907 :
908 6 : SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
909 18 : while( aTokenEnum.getNextToken( aToken ) )
910 : {
911 6 : if( !bHasPos && IsXMLToken( aToken, XML_ABOVE ) )
912 : {
913 0 : bBelow = sal_False;
914 0 : bHasPos = sal_True;
915 : }
916 6 : else if( !bHasPos && IsXMLToken( aToken, XML_BELOW ) )
917 : {
918 0 : bBelow = sal_True;
919 0 : bHasPos = sal_True;
920 : }
921 12 : else if( !bHasType &&
922 : SvXMLUnitConverter::convertEnum( nVal, aToken,
923 6 : pXML_Emphasize_Enum ))
924 : {
925 6 : bHasType = sal_True;
926 : }
927 : else
928 : {
929 0 : bRet = sal_False;
930 0 : break;
931 : }
932 : }
933 :
934 6 : if( bRet )
935 : {
936 6 : if( FontEmphasis::NONE != nVal && bBelow )
937 0 : nVal += 10;
938 6 : rValue <<= (sal_Int16)nVal;
939 : }
940 :
941 6 : return bRet;
942 : }
943 :
944 0 : sal_Bool XMLTextEmphasizePropHdl_Impl::exportXML(
945 : OUString& rStrExpValue,
946 : const Any& rValue,
947 : const SvXMLUnitConverter& ) const
948 : {
949 0 : OUStringBuffer aOut( 15 );
950 0 : sal_Bool bRet = sal_True;
951 0 : sal_Int16 nType = sal_Int16();
952 0 : if( rValue >>= nType )
953 : {
954 0 : sal_Bool bBelow = sal_False;
955 0 : if( nType > 10 )
956 : {
957 0 : bBelow = sal_True;
958 0 : nType -= 10;
959 : }
960 : bRet = SvXMLUnitConverter::convertEnum( aOut, nType,
961 : pXML_Emphasize_Enum,
962 0 : XML_DOT );
963 0 : if( bRet )
964 : {
965 0 : if( nType != 0 )
966 : {
967 0 : enum XMLTokenEnum ePos = bBelow ? XML_BELOW : XML_ABOVE;
968 0 : aOut.append( (sal_Unicode)' ' );
969 0 : aOut.append( GetXMLToken(ePos) );
970 : }
971 0 : rStrExpValue = aOut.makeStringAndClear();
972 : }
973 : }
974 :
975 0 : return bRet;
976 : }
977 :
978 962 : XMLTextEmphasizePropHdl_Impl::~XMLTextEmphasizePropHdl_Impl()
979 : {
980 962 : }
981 :
982 :
983 : // ---------------------------------------------------------------------------
984 :
985 : class XMLTextCombineCharPropHdl_Impl : public XMLPropertyHandler
986 : {
987 : public:
988 481 : XMLTextCombineCharPropHdl_Impl() {}
989 : virtual ~XMLTextCombineCharPropHdl_Impl();
990 :
991 : virtual sal_Bool importXML(
992 : const ::rtl::OUString& rStrImpValue,
993 : ::com::sun::star::uno::Any& rValue,
994 : const SvXMLUnitConverter& ) const;
995 : virtual sal_Bool exportXML(
996 : ::rtl::OUString& rStrExpValue,
997 : const ::com::sun::star::uno::Any& rValue,
998 : const SvXMLUnitConverter& ) const;
999 : };
1000 :
1001 0 : sal_Bool XMLTextCombineCharPropHdl_Impl::importXML(
1002 : const OUString& rStrImpValue,
1003 : Any& rValue,
1004 : const SvXMLUnitConverter& ) const
1005 : {
1006 0 : if( !rStrImpValue.isEmpty() )
1007 0 : rValue <<= rStrImpValue.copy( 0, 1 );
1008 : else
1009 0 : rValue <<= rStrImpValue;
1010 :
1011 0 : return sal_True;
1012 : }
1013 :
1014 0 : sal_Bool XMLTextCombineCharPropHdl_Impl::exportXML(
1015 : OUString& rStrExpValue,
1016 : const Any& rValue,
1017 : const SvXMLUnitConverter& ) const
1018 : {
1019 0 : rValue >>= rStrExpValue;
1020 :
1021 : // #i114107# attribute of type "character": export only if length is 1
1022 0 : return (1 == rStrExpValue.getLength()) ? sal_True : sal_False;
1023 : }
1024 :
1025 962 : XMLTextCombineCharPropHdl_Impl::~XMLTextCombineCharPropHdl_Impl()
1026 : {
1027 962 : }
1028 :
1029 : // ---------------------------------------------------------------------------
1030 :
1031 : class XMLTextRelWidthHeightPropHdl_Impl : public XMLPropertyHandler
1032 : {
1033 : public:
1034 161 : XMLTextRelWidthHeightPropHdl_Impl() {}
1035 : virtual ~XMLTextRelWidthHeightPropHdl_Impl();
1036 :
1037 : virtual sal_Bool importXML(
1038 : const ::rtl::OUString& rStrImpValue,
1039 : ::com::sun::star::uno::Any& rValue,
1040 : const SvXMLUnitConverter& ) const;
1041 : virtual sal_Bool exportXML(
1042 : ::rtl::OUString& rStrExpValue,
1043 : const ::com::sun::star::uno::Any& rValue,
1044 : const SvXMLUnitConverter& ) const;
1045 : };
1046 :
1047 2 : sal_Bool XMLTextRelWidthHeightPropHdl_Impl::importXML(
1048 : const OUString& rStrImpValue,
1049 : Any& rValue,
1050 : const SvXMLUnitConverter& ) const
1051 : {
1052 : sal_Int32 nValue;
1053 2 : bool const bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
1054 2 : if( bRet )
1055 0 : rValue <<= (sal_Int16)nValue;
1056 :
1057 2 : return bRet;
1058 : }
1059 :
1060 0 : sal_Bool XMLTextRelWidthHeightPropHdl_Impl::exportXML(
1061 : OUString& rStrExpValue,
1062 : const Any& rValue,
1063 : const SvXMLUnitConverter& ) const
1064 : {
1065 0 : sal_Bool bRet = sal_False;
1066 0 : sal_Int16 nValue = sal_Int16();
1067 0 : if( (rValue >>= nValue) && nValue > 0 )
1068 : {
1069 0 : OUStringBuffer aOut;
1070 0 : ::sax::Converter::convertPercent( aOut, nValue );
1071 0 : rStrExpValue = aOut.makeStringAndClear();
1072 :
1073 0 : bRet = sal_True;
1074 : }
1075 :
1076 0 : return bRet;
1077 : }
1078 :
1079 322 : XMLTextRelWidthHeightPropHdl_Impl::~XMLTextRelWidthHeightPropHdl_Impl()
1080 : {
1081 322 : }
1082 :
1083 : // ---------------------------------------------------------------------------
1084 :
1085 : class XMLTextSyncWidthHeightPropHdl_Impl : public XMLPropertyHandler
1086 : {
1087 : const OUString sValue;
1088 :
1089 : public:
1090 0 : XMLTextSyncWidthHeightPropHdl_Impl( enum XMLTokenEnum eValue ) :
1091 0 : sValue( GetXMLToken(eValue) ) {}
1092 : virtual ~XMLTextSyncWidthHeightPropHdl_Impl();
1093 :
1094 : virtual sal_Bool importXML(
1095 : const ::rtl::OUString& rStrImpValue,
1096 : ::com::sun::star::uno::Any& rValue,
1097 : const SvXMLUnitConverter& ) const;
1098 : virtual sal_Bool exportXML(
1099 : ::rtl::OUString& rStrExpValue,
1100 : const ::com::sun::star::uno::Any& rValue,
1101 : const SvXMLUnitConverter& ) const;
1102 : };
1103 :
1104 0 : sal_Bool XMLTextSyncWidthHeightPropHdl_Impl::importXML(
1105 : const OUString& rStrImpValue,
1106 : Any& rValue,
1107 : const SvXMLUnitConverter& ) const
1108 : {
1109 0 : sal_Bool bValue = (rStrImpValue == sValue );
1110 0 : rValue.setValue( &bValue, ::getBooleanCppuType() );
1111 :
1112 0 : return sal_True;
1113 : }
1114 :
1115 0 : sal_Bool XMLTextSyncWidthHeightPropHdl_Impl::exportXML(
1116 : OUString& rStrExpValue,
1117 : const Any& rValue,
1118 : const SvXMLUnitConverter& ) const
1119 : {
1120 0 : sal_Bool bRet = sal_False;
1121 0 : if( *(sal_Bool *)rValue.getValue() )
1122 : {
1123 0 : rStrExpValue = sValue;
1124 0 : bRet = sal_True;
1125 : }
1126 :
1127 0 : return bRet;
1128 : }
1129 :
1130 0 : XMLTextSyncWidthHeightPropHdl_Impl::~XMLTextSyncWidthHeightPropHdl_Impl()
1131 : {
1132 0 : }
1133 :
1134 : // ---------------------------------------------------------------------------
1135 :
1136 : class XMLTextRotationAnglePropHdl_Impl : public XMLPropertyHandler
1137 : {
1138 :
1139 : public:
1140 481 : XMLTextRotationAnglePropHdl_Impl() {}
1141 : virtual ~XMLTextRotationAnglePropHdl_Impl();
1142 :
1143 : virtual sal_Bool importXML(
1144 : const ::rtl::OUString& rStrImpValue,
1145 : ::com::sun::star::uno::Any& rValue,
1146 : const SvXMLUnitConverter& ) const;
1147 : virtual sal_Bool exportXML(
1148 : ::rtl::OUString& rStrExpValue,
1149 : const ::com::sun::star::uno::Any& rValue,
1150 : const SvXMLUnitConverter& ) const;
1151 : };
1152 :
1153 0 : sal_Bool XMLTextRotationAnglePropHdl_Impl::importXML(
1154 : const OUString& rStrImpValue,
1155 : Any& rValue,
1156 : const SvXMLUnitConverter& ) const
1157 : {
1158 : sal_Int32 nValue;
1159 0 : bool const bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
1160 0 : if( bRet )
1161 : {
1162 0 : nValue = (nValue % 360 );
1163 0 : if( nValue < 0 )
1164 0 : nValue = 360 + nValue;
1165 : sal_Int16 nAngle;
1166 0 : if( nValue < 45 || nValue > 315 )
1167 0 : nAngle = 0;
1168 0 : else if( nValue < 180 )
1169 0 : nAngle = 900;
1170 : else /* if nValalue <= 315 ) */
1171 0 : nAngle = 2700;
1172 0 : rValue <<= nAngle;
1173 : }
1174 :
1175 0 : return bRet;
1176 : }
1177 :
1178 0 : sal_Bool XMLTextRotationAnglePropHdl_Impl::exportXML(
1179 : OUString& rStrExpValue,
1180 : const Any& rValue,
1181 : const SvXMLUnitConverter& ) const
1182 : {
1183 0 : sal_Int16 nAngle = sal_Int16();
1184 0 : sal_Bool bRet = ( rValue >>= nAngle );
1185 0 : if( bRet )
1186 : {
1187 0 : OUStringBuffer aOut;
1188 0 : ::sax::Converter::convertNumber( aOut, nAngle / 10 );
1189 0 : rStrExpValue = aOut.makeStringAndClear();
1190 : }
1191 : OSL_ENSURE( bRet, "illegal rotation angle" );
1192 :
1193 0 : return bRet;
1194 : }
1195 :
1196 962 : XMLTextRotationAnglePropHdl_Impl::~XMLTextRotationAnglePropHdl_Impl()
1197 : {
1198 962 : }
1199 : // ---------------------------------------------------------------------------
1200 : class XMLNumber8OneBasedHdl : public XMLPropertyHandler
1201 : {
1202 :
1203 : public:
1204 352 : XMLNumber8OneBasedHdl() {}
1205 704 : virtual ~XMLNumber8OneBasedHdl() {};
1206 :
1207 : virtual sal_Bool importXML(
1208 : const ::rtl::OUString& rStrImpValue,
1209 : ::com::sun::star::uno::Any& rValue,
1210 : const SvXMLUnitConverter& ) const;
1211 : virtual sal_Bool exportXML(
1212 : ::rtl::OUString& rStrExpValue,
1213 : const ::com::sun::star::uno::Any& rValue,
1214 : const SvXMLUnitConverter& ) const;
1215 : };
1216 :
1217 0 : sal_Bool XMLNumber8OneBasedHdl::importXML(
1218 : const OUString& rStrImpValue,
1219 : Any& rValue,
1220 : const SvXMLUnitConverter& ) const
1221 : {
1222 0 : sal_Int32 nValue = 0;
1223 0 : bool const bRet = ::sax::Converter::convertNumber(nValue, rStrImpValue);
1224 0 : if( bRet )
1225 0 : rValue <<= static_cast<sal_Int8>( nValue - 1 );
1226 0 : return bRet;
1227 : }
1228 :
1229 0 : sal_Bool XMLNumber8OneBasedHdl::exportXML(
1230 : OUString& rStrExpValue,
1231 : const Any& rValue,
1232 : const SvXMLUnitConverter& ) const
1233 : {
1234 0 : sal_Int8 nValue = sal_Int8();
1235 0 : sal_Bool bRet = ( rValue >>= nValue );
1236 0 : if( bRet )
1237 : {
1238 0 : OUStringBuffer aOut;
1239 0 : ::sax::Converter::convertNumber( aOut, nValue + 1 );
1240 0 : rStrExpValue = aOut.makeStringAndClear();
1241 : }
1242 0 : return bRet;
1243 : }
1244 : // ---------------------------------------------------------------------------
1245 : class XMLTextPropertyHandlerFactory_Impl
1246 : {
1247 : public:
1248 : const XMLPropertyHandler *GetPropertyHandler( sal_Int32 nType ) const;
1249 :
1250 : XMLTextPropertyHandlerFactory_Impl();
1251 : ~XMLTextPropertyHandlerFactory_Impl();
1252 : };
1253 :
1254 11499 : const XMLPropertyHandler *XMLTextPropertyHandlerFactory_Impl::GetPropertyHandler
1255 : ( sal_Int32 nType ) const
1256 : {
1257 11499 : const XMLPropertyHandler* pHdl = 0;
1258 11499 : switch( nType )
1259 : {
1260 : case XML_TYPE_TEXT_DROPCAP:
1261 352 : pHdl = new XMLDropCapPropHdl_Impl;
1262 352 : break;
1263 : case XML_TYPE_TEXT_WRAP:
1264 173 : pHdl = new XMLWrapPropHdl_Impl;
1265 173 : break;
1266 : case XML_TYPE_TEXT_PARAGRAPH_ONLY:
1267 173 : pHdl = new XMLParagraphOnlyPropHdl_Impl;
1268 173 : break;
1269 : case XML_TYPE_TEXT_WRAP_OUTSIDE:
1270 173 : pHdl = new XMLContourModePropHdl_Impl;
1271 173 : break;
1272 : case XML_TYPE_TEXT_OPAQUE:
1273 173 : pHdl = new XMLOpaquePropHdl_Impl;
1274 173 : break;
1275 : case XML_TYPE_TEXT_PROTECT_CONTENT:
1276 169 : pHdl = new XMLFrameProtectPropHdl_Impl( XML_CONTENT );
1277 169 : break;
1278 : case XML_TYPE_TEXT_PROTECT_SIZE:
1279 169 : pHdl = new XMLFrameProtectPropHdl_Impl( XML_SIZE );
1280 169 : break;
1281 : case XML_TYPE_TEXT_PROTECT_POSITION:
1282 169 : pHdl = new XMLFrameProtectPropHdl_Impl( XML_POSITION );
1283 169 : break;
1284 : case XML_TYPE_TEXT_ANCHOR_TYPE:
1285 161 : pHdl = new XMLAnchorTypePropHdl;
1286 161 : break;
1287 : case XML_TYPE_TEXT_COLUMNS:
1288 296 : pHdl = new XMLTextColumnsPropertyHandler;
1289 296 : break;
1290 : case XML_TYPE_TEXT_HORIZONTAL_POS:
1291 173 : pHdl = new XMLConstantsPropertyHandler( pXML_HoriPos_Enum, XML_TOKEN_INVALID );
1292 173 : break;
1293 : case XML_TYPE_TEXT_HORIZONTAL_POS_MIRRORED:
1294 173 : pHdl = new XMLConstantsPropertyHandler( pXML_HoriPosMirrored_Enum, XML_TOKEN_INVALID );
1295 173 : break;
1296 : case XML_TYPE_TEXT_HORIZONTAL_REL:
1297 173 : pHdl = new XMLConstantsPropertyHandler( pXML_HoriRel_Enum, XML_TOKEN_INVALID );
1298 173 : break;
1299 : case XML_TYPE_TEXT_HORIZONTAL_REL_FRAME:
1300 173 : pHdl = new XMLConstantsPropertyHandler( pXML_HoriRelFrame_Enum, XML_TOKEN_INVALID );
1301 173 : break;
1302 : case XML_TYPE_TEXT_HORIZONTAL_MIRROR:
1303 173 : pHdl = new XMLHoriMirrorPropHdl_Impl;
1304 173 : break;
1305 : case XML_TYPE_TEXT_VERTICAL_POS:
1306 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertPos_Enum, XML_TOKEN_INVALID );
1307 173 : break;
1308 : case XML_TYPE_TEXT_VERTICAL_POS_AT_CHAR:
1309 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertPosAtChar_Enum, XML_TOKEN_INVALID );
1310 173 : break;
1311 : case XML_TYPE_TEXT_VERTICAL_REL:
1312 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertRel_Enum, XML_TOKEN_INVALID );
1313 173 : break;
1314 : case XML_TYPE_TEXT_VERTICAL_REL_PAGE:
1315 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertRelPage_Enum, XML_TOKEN_INVALID );
1316 173 : break;
1317 : case XML_TYPE_TEXT_VERTICAL_REL_FRAME:
1318 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertRelFrame_Enum, XML_TOKEN_INVALID );
1319 173 : break;
1320 : case XML_TYPE_TEXT_VERTICAL_REL_AS_CHAR:
1321 173 : pHdl = new XMLConstantsPropertyHandler( pXML_VertRelAsChar_Enum, XML_TOKEN_INVALID );
1322 173 : break;
1323 : case XML_TYPE_TEXT_MIRROR_VERTICAL:
1324 169 : pHdl = new XMLGrfMirrorPropHdl_Impl( XML_VERTICAL, sal_False );
1325 169 : break;
1326 : case XML_TYPE_TEXT_MIRROR_HORIZONTAL_LEFT:
1327 : // XML_HORIZONTAL_ON_LEFT_PAGES is replaced by XML_HORIZONTAL_ON_EVEN. (#i49139#)
1328 169 : pHdl = new XMLGrfMirrorPropHdl_Impl( XML_HORIZONTAL_ON_EVEN, sal_True );
1329 169 : break;
1330 : case XML_TYPE_TEXT_MIRROR_HORIZONTAL_RIGHT:
1331 : // XML_HORIZONTAL_ON_RIGHT_PAGES is replaced by XML_HORIZONTAL_ON_ODD. (#i49139#)
1332 169 : pHdl = new XMLGrfMirrorPropHdl_Impl( XML_HORIZONTAL_ON_ODD, sal_True );
1333 169 : break;
1334 : case XML_TYPE_TEXT_CLIP:
1335 169 : pHdl = new XMLClipPropertyHandler( sal_False );
1336 169 : break;
1337 : case XML_TYPE_TEXT_CLIP11:
1338 169 : pHdl = new XMLClipPropertyHandler( sal_True );
1339 169 : break;
1340 : case XML_TYPE_TEXT_EMPHASIZE:
1341 481 : pHdl = new XMLTextEmphasizePropHdl_Impl;
1342 481 : break;
1343 : case XML_TYPE_TEXT_COMBINE:
1344 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_LINES ),
1345 481 : GetXMLToken( XML_NONE ) );
1346 481 : break;
1347 : case XML_TYPE_TEXT_COMBINE_CHARACTERS:
1348 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_LETTERS ),
1349 129 : GetXMLToken( XML_NONE ) );
1350 129 : break;
1351 : case XML_TYPE_TEXT_COMBINECHAR:
1352 481 : pHdl = new XMLTextCombineCharPropHdl_Impl;
1353 481 : break;
1354 : case XML_TYPE_TEXT_AUTOSPACE:
1355 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_IDEOGRAPH_ALPHA ),
1356 481 : GetXMLToken( XML_NONE ) );
1357 481 : break;
1358 : case XML_TYPE_TEXT_PUNCTUATION_WRAP:
1359 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_HANGING ),
1360 481 : GetXMLToken( XML_SIMPLE ) );
1361 481 : break;
1362 : case XML_TYPE_TEXT_LINE_BREAK:
1363 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_STRICT ),
1364 481 : GetXMLToken( XML_NORMAL ) );
1365 481 : break;
1366 : case XML_TYPE_TEXT_REL_WIDTH_HEIGHT:
1367 161 : pHdl = new XMLTextRelWidthHeightPropHdl_Impl;
1368 161 : break;
1369 : case XML_TYPE_TEXT_SYNC_WIDTH_HEIGHT:
1370 0 : pHdl = new XMLTextSyncWidthHeightPropHdl_Impl( XML_SCALE );
1371 0 : break;
1372 : case XML_TYPE_TEXT_SYNC_WIDTH_HEIGHT_MIN:
1373 0 : pHdl = new XMLTextSyncWidthHeightPropHdl_Impl( XML_SCALE_MIN );
1374 0 : break;
1375 : case XML_TYPE_TEXT_RUBY_ADJUST:
1376 127 : pHdl = new XMLConstantsPropertyHandler( pXML_RubyAdjust_Enum, XML_TOKEN_INVALID );
1377 127 : break;
1378 : case XML_TYPE_TEXT_FONT_RELIEF:
1379 481 : pHdl = new XMLConstantsPropertyHandler( pXML_FontRelief_Enum, XML_TOKEN_INVALID );
1380 481 : break;
1381 : case XML_TYPE_TEXT_ROTATION_ANGLE:
1382 481 : pHdl = new XMLTextRotationAnglePropHdl_Impl;
1383 481 : break;
1384 : case XML_TYPE_TEXT_ROTATION_SCALE:
1385 : pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_FIXED ),
1386 481 : GetXMLToken( XML_LINE_HEIGHT ) );
1387 481 : break;
1388 : case XML_TYPE_TEXT_VERTICAL_ALIGN:
1389 352 : pHdl = new XMLConstantsPropertyHandler( pXML_VerticalAlign_Enum, XML_TOKEN_INVALID );
1390 352 : break;
1391 : case XML_TYPE_TEXT_RUBY_POSITION:
1392 : pHdl = new XMLNamedBoolPropertyHdl( ::xmloff::token::XML_ABOVE,
1393 127 : ::xmloff::token::XML_BELOW );
1394 127 : break;
1395 : // OD 2004-05-05 #i28701#
1396 : case XML_TYPE_WRAP_INFLUENCE_ON_POSITION:
1397 : pHdl = new XMLConstantsPropertyHandler( pXML_WrapInfluenceOnPosition_Enum,
1398 261 : XML_TOKEN_INVALID );
1399 261 : break;
1400 : case XML_TYPE_BORDER_MODEL:
1401 : pHdl = new XMLNamedBoolPropertyHdl( xmloff::token::XML_COLLAPSING,
1402 36 : xmloff::token::XML_SEPARATING );
1403 36 : break;
1404 : case XML_TYPE_TEXT_LINE_MODE:
1405 : pHdl = new XMLNamedBoolPropertyHdl(
1406 : ::xmloff::token::XML_SKIP_WHITE_SPACE,
1407 481 : ::xmloff::token::XML_CONTINUOUS);
1408 481 : break;
1409 : case XML_TYPE_TEXT_KEEP:
1410 : pHdl = new XMLNamedBoolPropertyHdl(
1411 : ::xmloff::token::XML_ALWAYS,
1412 352 : ::xmloff::token::XML_AUTO);
1413 352 : break;
1414 : case XML_TYPE_TEXT_NKEEP:
1415 : pHdl = new XMLNamedBoolPropertyHdl(
1416 : ::xmloff::token::XML_AUTO,
1417 36 : ::xmloff::token::XML_ALWAYS);
1418 36 : break;
1419 : case XML_TYPE_TEXT_NUMBER8_ONE_BASED:
1420 352 : pHdl = new XMLNumber8OneBasedHdl();
1421 352 : break;
1422 : }
1423 :
1424 11499 : return pHdl;
1425 : }
1426 :
1427 1068 : XMLTextPropertyHandlerFactory_Impl::XMLTextPropertyHandlerFactory_Impl()
1428 : {
1429 1068 : }
1430 :
1431 1068 : XMLTextPropertyHandlerFactory_Impl::~XMLTextPropertyHandlerFactory_Impl()
1432 : {
1433 1068 : }
1434 :
1435 : // ----------------------------------------------------------------------------
1436 :
1437 1068 : XMLTextPropertyHandlerFactory::XMLTextPropertyHandlerFactory() :
1438 : XMLPropertyHandlerFactory(),
1439 1068 : pImpl( new XMLTextPropertyHandlerFactory_Impl )
1440 : {
1441 1068 : }
1442 :
1443 3204 : XMLTextPropertyHandlerFactory::~XMLTextPropertyHandlerFactory()
1444 : {
1445 1068 : delete pImpl;
1446 2136 : }
1447 :
1448 84279 : const XMLPropertyHandler *XMLTextPropertyHandlerFactory::GetPropertyHandler(
1449 : sal_Int32 nType ) const
1450 : {
1451 : const XMLPropertyHandler *pHdl =
1452 84279 : XMLPropertyHandlerFactory::GetPropertyHandler( nType );
1453 :
1454 84279 : if( !pHdl )
1455 : {
1456 11499 : const XMLPropertyHandler *pNewHdl = pImpl->GetPropertyHandler( nType );
1457 :
1458 11499 : if( pNewHdl )
1459 11499 : PutHdlCache( nType, pNewHdl );
1460 :
1461 11499 : pHdl = pNewHdl;
1462 : }
1463 :
1464 84279 : return pHdl;
1465 : }
1466 :
1467 :
1468 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
