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