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