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