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