1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_xmloff.hxx"
26 #include <tools/debug.hxx>
27 #include <com/sun/star/awt/FontFamily.hpp>
28 #include <com/sun/star/awt/FontPitch.hpp>
29 #include <com/sun/star/table/BorderLine.hpp>
30 #include <com/sun/star/text/VertOrientation.hpp>
31 #include <com/sun/star/text/SizeType.hpp>
32 #include <tools/string.hxx>
33 #include <xmloff/XMLFontStylesContext.hxx>
34 #include <xmloff/txtprmap.hxx>
35 #include <xmloff/xmlimp.hxx>
36 #include "xmloff/txtimppr.hxx"
37
38 #define XML_LINE_LEFT 0
39 #define XML_LINE_RIGHT 1
40 #define XML_LINE_TOP 2
41 #define XML_LINE_BOTTOM 3
42 #define MIN_BORDER_DIST 49
43
44 using ::rtl::OUString;
45
46 using namespace ::com::sun::star;
47 using namespace ::com::sun::star::uno;
48 using namespace ::com::sun::star::table;
49 using namespace ::com::sun::star::text;
50
handleSpecialItem(XMLPropertyState & rProperty,::std::vector<XMLPropertyState> & rProperties,const::rtl::OUString & rValue,const SvXMLUnitConverter & rUnitConverter,const SvXMLNamespaceMap & rNamespaceMap) const51 sal_Bool XMLTextImportPropertyMapper::handleSpecialItem(
52 XMLPropertyState& rProperty,
53 ::std::vector< XMLPropertyState >& rProperties,
54 const ::rtl::OUString& rValue,
55 const SvXMLUnitConverter& rUnitConverter,
56 const SvXMLNamespaceMap& rNamespaceMap ) const
57 {
58 sal_Bool bRet = sal_False;
59 sal_Int32 nIndex = rProperty.mnIndex;
60 switch( getPropertySetMapper()->GetEntryContextId( nIndex ) )
61 {
62 case CTF_FONTNAME:
63 case CTF_FONTNAME_CJK:
64 case CTF_FONTNAME_CTL:
65 if( xFontDecls.Is() )
66 {
67 DBG_ASSERT(
68 ( CTF_FONTFAMILYNAME ==
69 getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
70 CTF_FONTSTYLENAME ==
71 getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
72 CTF_FONTFAMILY ==
73 getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
74 CTF_FONTPITCH ==
75 getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
76 CTF_FONTCHARSET ==
77 getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
78 ( CTF_FONTFAMILYNAME_CJK ==
79 getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
80 CTF_FONTSTYLENAME_CJK ==
81 getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
82 CTF_FONTFAMILY_CJK ==
83 getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
84 CTF_FONTPITCH_CJK ==
85 getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
86 CTF_FONTCHARSET_CJK ==
87 getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
88 ( CTF_FONTFAMILYNAME_CTL ==
89 getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
90 CTF_FONTSTYLENAME_CTL ==
91 getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
92 CTF_FONTFAMILY_CTL ==
93 getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
94 CTF_FONTPITCH_CTL ==
95 getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
96 CTF_FONTCHARSET_CTL ==
97 getPropertySetMapper()->GetEntryContextId(nIndex+5) ),
98 "illegal property map" );
99
100 ((XMLFontStylesContext *)&xFontDecls)->FillProperties(
101 rValue, rProperties,
102 rProperty.mnIndex+1, rProperty.mnIndex+2,
103 rProperty.mnIndex+3, rProperty.mnIndex+4,
104 rProperty.mnIndex+5 );
105 bRet = sal_False; // the property hasn't been filled
106 }
107 break;
108
109 // If we want to do StarMath/StarSymbol font conversion, then we'll
110 // want these special items to be treated just like regular ones...
111 // For the Writer, we'll catch and convert them in _FillPropertySet;
112 // the other apps probably don't care. For the other apps, we just
113 // imitate the default non-special-item mechanism.
114 case CTF_FONTFAMILYNAME:
115 case CTF_FONTFAMILYNAME_CJK:
116 case CTF_FONTFAMILYNAME_CTL:
117 bRet = getPropertySetMapper()->importXML( rValue, rProperty,
118 rUnitConverter );
119 break;
120
121 case CTF_TEXT_DISPLAY:
122 bRet = getPropertySetMapper()->importXML( rValue, rProperty,
123 rUnitConverter );
124 if( SvXMLImport::OOo_2x == GetImport().getGeneratorVersion() )
125 {
126 sal_Bool bHidden;
127 rProperty.maValue >>= bHidden;
128 bHidden = !bHidden;
129 rProperty.maValue <<= bHidden;
130 }
131 break;
132 default:
133 bRet = SvXMLImportPropertyMapper::handleSpecialItem( rProperty,
134 rProperties, rValue, rUnitConverter, rNamespaceMap );
135 break;
136 }
137
138 return bRet;
139 }
140
XMLTextImportPropertyMapper(const UniReference<XMLPropertySetMapper> & rMapper,SvXMLImport & rImp,XMLFontStylesContext * pFontDecls)141 XMLTextImportPropertyMapper::XMLTextImportPropertyMapper(
142 const UniReference< XMLPropertySetMapper >& rMapper,
143 SvXMLImport& rImp,
144 XMLFontStylesContext *pFontDecls ) :
145 SvXMLImportPropertyMapper( rMapper, rImp ),
146 nSizeTypeIndex( -2 ),
147 nWidthTypeIndex( -2 ),
148 xFontDecls( pFontDecls )
149 {
150 }
151
~XMLTextImportPropertyMapper()152 XMLTextImportPropertyMapper::~XMLTextImportPropertyMapper()
153 {
154 }
155
SetFontDecls(XMLFontStylesContext * pFontDecls)156 void XMLTextImportPropertyMapper::SetFontDecls(
157 XMLFontStylesContext *pFontDecls )
158 {
159 xFontDecls = pFontDecls;
160 }
161
FontFinished(XMLPropertyState * pFontFamilyNameState,XMLPropertyState * pFontStyleNameState,XMLPropertyState * pFontFamilyState,XMLPropertyState * pFontPitchState,XMLPropertyState * pFontCharsetState) const162 void XMLTextImportPropertyMapper::FontFinished(
163 XMLPropertyState *pFontFamilyNameState,
164 XMLPropertyState *pFontStyleNameState,
165 XMLPropertyState *pFontFamilyState,
166 XMLPropertyState *pFontPitchState,
167 XMLPropertyState *pFontCharsetState ) const
168 {
169 if( pFontFamilyNameState && pFontFamilyNameState->mnIndex != -1 )
170 {
171 OUString sName;
172 pFontFamilyNameState->maValue >>= sName;
173 if( !sName.getLength() )
174 pFontFamilyNameState->mnIndex = -1;
175 }
176 if( !pFontFamilyNameState || pFontFamilyNameState->mnIndex == -1 )
177 {
178 if( pFontStyleNameState )
179 pFontStyleNameState->mnIndex = -1;
180 if( pFontFamilyState )
181 pFontFamilyState->mnIndex = -1;
182 if( pFontPitchState )
183 pFontPitchState->mnIndex = -1;
184 if( pFontCharsetState )
185 pFontCharsetState->mnIndex = -1;
186 }
187 }
188
189 /** since the properties "CharFontFamilyName", "CharFontStyleName", "CharFontFamily",
190 "CharFontPitch" and "CharFontSet" and theire CJK and CTL counterparts are only
191 usable as a union, we add defaults to all values that are not set as long as we
192 have an "CharFontFamilyName"
193
194 #99928# CL */
FontDefaultsCheck(XMLPropertyState * pFontFamilyName,XMLPropertyState * pFontStyleName,XMLPropertyState * pFontFamily,XMLPropertyState * pFontPitch,XMLPropertyState * pFontCharSet,XMLPropertyState ** ppNewFontStyleName,XMLPropertyState ** ppNewFontFamily,XMLPropertyState ** ppNewFontPitch,XMLPropertyState ** ppNewFontCharSet) const195 void XMLTextImportPropertyMapper::FontDefaultsCheck(
196 XMLPropertyState* pFontFamilyName,
197 XMLPropertyState* pFontStyleName,
198 XMLPropertyState* pFontFamily,
199 XMLPropertyState* pFontPitch,
200 XMLPropertyState* pFontCharSet,
201 XMLPropertyState** ppNewFontStyleName,
202 XMLPropertyState** ppNewFontFamily,
203 XMLPropertyState** ppNewFontPitch,
204 XMLPropertyState** ppNewFontCharSet ) const
205 {
206 if( pFontFamilyName )
207 {
208 OUString sEmpty;
209 Any aAny;
210
211 if( !pFontStyleName )
212 {
213 aAny <<= sEmpty;
214 #ifdef DBG_UTIL
215 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
216 pFontFamilyName->mnIndex + 1 );
217 DBG_ASSERT( nTmp == CTF_FONTSTYLENAME || nTmp == CTF_FONTSTYLENAME_CJK || nTmp == CTF_FONTSTYLENAME_CTL,
218 "wrong property context id" );
219 #endif
220 *ppNewFontStyleName = new XMLPropertyState( pFontFamilyName->mnIndex + 1,
221 aAny );
222 }
223
224 if( !pFontFamily )
225 {
226 aAny <<= (sal_Int16)com::sun::star::awt::FontFamily::DONTKNOW;
227
228 #ifdef DBG_UTIL
229 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
230 pFontFamilyName->mnIndex + 2 );
231 DBG_ASSERT( nTmp == CTF_FONTFAMILY || nTmp == CTF_FONTFAMILY_CJK || nTmp == CTF_FONTFAMILY_CTL,
232 "wrong property context id" );
233 #endif
234 *ppNewFontFamily = new XMLPropertyState( pFontFamilyName->mnIndex + 2,
235 aAny );
236 }
237
238 if( !pFontPitch )
239 {
240 aAny <<= (sal_Int16)com::sun::star::awt::FontPitch::DONTKNOW;
241 #ifdef DBG_UTIL
242 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
243 pFontFamilyName->mnIndex + 3 );
244 DBG_ASSERT( nTmp == CTF_FONTPITCH || nTmp == CTF_FONTPITCH_CJK || nTmp == CTF_FONTPITCH_CTL,
245 "wrong property context id" );
246 #endif
247 *ppNewFontPitch = new XMLPropertyState( pFontFamilyName->mnIndex + 3,
248 aAny );
249 }
250
251 if( !pFontCharSet )
252 {
253 aAny <<= (sal_Int16)gsl_getSystemTextEncoding();
254 #ifdef DBG_UTIL
255 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
256 pFontFamilyName->mnIndex + 4 );
257 DBG_ASSERT( nTmp == CTF_FONTCHARSET || nTmp == CTF_FONTCHARSET_CJK || nTmp == CTF_FONTCHARSET_CTL,
258 "wrong property context id" );
259 #endif
260 *ppNewFontCharSet = new XMLPropertyState( pFontFamilyName->mnIndex + 4,
261 aAny );
262 }
263 }
264 }
265
finished(::std::vector<XMLPropertyState> & rProperties,sal_Int32,sal_Int32) const266 void XMLTextImportPropertyMapper::finished(
267 ::std::vector< XMLPropertyState >& rProperties,
268 sal_Int32 /*nStartIndex*/, sal_Int32 /*nEndIndex*/ ) const
269 {
270 sal_Bool bHasAnyHeight = sal_False;
271 sal_Bool bHasAnyMinHeight = sal_False;
272 sal_Bool bHasAnyWidth = sal_False;
273 sal_Bool bHasAnyMinWidth = sal_False;
274
275 XMLPropertyState* pFontFamilyName = 0;
276 XMLPropertyState* pFontStyleName = 0;
277 XMLPropertyState* pFontFamily = 0;
278 XMLPropertyState* pFontPitch = 0;
279 XMLPropertyState* pFontCharSet = 0;
280 XMLPropertyState* pNewFontStyleName = 0;
281 XMLPropertyState* pNewFontFamily = 0;
282 XMLPropertyState* pNewFontPitch = 0;
283 XMLPropertyState* pNewFontCharSet = 0;
284 XMLPropertyState* pFontFamilyNameCJK = 0;
285 XMLPropertyState* pFontStyleNameCJK = 0;
286 XMLPropertyState* pFontFamilyCJK = 0;
287 XMLPropertyState* pFontPitchCJK = 0;
288 XMLPropertyState* pFontCharSetCJK = 0;
289 XMLPropertyState* pNewFontStyleNameCJK = 0;
290 XMLPropertyState* pNewFontFamilyCJK = 0;
291 XMLPropertyState* pNewFontPitchCJK = 0;
292 XMLPropertyState* pNewFontCharSetCJK = 0;
293 XMLPropertyState* pFontFamilyNameCTL = 0;
294 XMLPropertyState* pFontStyleNameCTL = 0;
295 XMLPropertyState* pFontFamilyCTL = 0;
296 XMLPropertyState* pFontPitchCTL = 0;
297 XMLPropertyState* pFontCharSetCTL = 0;
298 XMLPropertyState* pNewFontStyleNameCTL = 0;
299 XMLPropertyState* pNewFontFamilyCTL = 0;
300 XMLPropertyState* pNewFontPitchCTL = 0;
301 XMLPropertyState* pNewFontCharSetCTL = 0;
302 XMLPropertyState* pAllBorderDistance = 0;
303 XMLPropertyState* pBorderDistances[4] = { 0, 0, 0, 0 };
304 XMLPropertyState* pNewBorderDistances[4] = { 0, 0, 0, 0 };
305 XMLPropertyState* pAllBorder = 0;
306 XMLPropertyState* pBorders[4] = { 0, 0, 0, 0 };
307 XMLPropertyState* pNewBorders[4] = { 0, 0, 0, 0 };
308 XMLPropertyState* pAllBorderWidth = 0;
309 XMLPropertyState* pBorderWidths[4] = { 0, 0, 0, 0 };
310 XMLPropertyState* pAnchorType = 0;
311 XMLPropertyState* pVertOrient = 0;
312 XMLPropertyState* pVertOrientRelAsChar = 0;
313 XMLPropertyState* pBackTransparency = NULL; // transparency in %
314 XMLPropertyState* pBackTransparent = NULL; // transparency as boolean
315
316 XMLPropertyState* pAllParaMargin = 0;
317 XMLPropertyState* pParaMargins[4] = { 0, 0, 0, 0 };
318 ::std::auto_ptr<XMLPropertyState> pNewParaMargins[4];
319
320 XMLPropertyState* pAllMargin = 0;
321 XMLPropertyState* pMargins[4] = { 0, 0, 0, 0 };
322 ::std::auto_ptr<XMLPropertyState> pNewMargins[4];
323
324 for( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin();
325 aIter != rProperties.end();
326 ++aIter )
327 {
328 XMLPropertyState* property = &(*aIter);
329 if( -1 == property->mnIndex )
330 continue;
331
332 switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ) )
333 {
334 case CTF_FONTFAMILYNAME: pFontFamilyName = property; break;
335 case CTF_FONTSTYLENAME: pFontStyleName = property; break;
336 case CTF_FONTFAMILY: pFontFamily = property; break;
337 case CTF_FONTPITCH: pFontPitch = property; break;
338 case CTF_FONTCHARSET: pFontCharSet = property; break;
339
340 case CTF_FONTFAMILYNAME_CJK: pFontFamilyNameCJK = property; break;
341 case CTF_FONTSTYLENAME_CJK: pFontStyleNameCJK = property; break;
342 case CTF_FONTFAMILY_CJK: pFontFamilyCJK = property; break;
343 case CTF_FONTPITCH_CJK: pFontPitchCJK = property; break;
344 case CTF_FONTCHARSET_CJK: pFontCharSetCJK = property; break;
345
346 case CTF_FONTFAMILYNAME_CTL: pFontFamilyNameCTL = property; break;
347 case CTF_FONTSTYLENAME_CTL: pFontStyleNameCTL = property; break;
348 case CTF_FONTFAMILY_CTL: pFontFamilyCTL = property; break;
349 case CTF_FONTPITCH_CTL: pFontPitchCTL = property; break;
350 case CTF_FONTCHARSET_CTL: pFontCharSetCTL = property; break;
351
352 case CTF_ALLBORDERDISTANCE: pAllBorderDistance = property; break;
353 case CTF_LEFTBORDERDISTANCE: pBorderDistances[XML_LINE_LEFT] = property; break;
354 case CTF_RIGHTBORDERDISTANCE: pBorderDistances[XML_LINE_RIGHT] = property; break;
355 case CTF_TOPBORDERDISTANCE: pBorderDistances[XML_LINE_TOP] = property; break;
356 case CTF_BOTTOMBORDERDISTANCE: pBorderDistances[XML_LINE_BOTTOM] = property; break;
357 case CTF_ALLBORDER: pAllBorder = property; break;
358 case CTF_LEFTBORDER: pBorders[XML_LINE_LEFT] = property; break;
359 case CTF_RIGHTBORDER: pBorders[XML_LINE_RIGHT] = property; break;
360 case CTF_TOPBORDER: pBorders[XML_LINE_TOP] = property; break;
361 case CTF_BOTTOMBORDER: pBorders[XML_LINE_BOTTOM] = property; break;
362
363 case CTF_ALLBORDERWIDTH: pAllBorderWidth = property; break;
364 case CTF_LEFTBORDERWIDTH: pBorderWidths[XML_LINE_LEFT] = property; break;
365 case CTF_RIGHTBORDERWIDTH: pBorderWidths[XML_LINE_RIGHT] = property; break;
366 case CTF_TOPBORDERWIDTH: pBorderWidths[XML_LINE_TOP] = property; break;
367 case CTF_BOTTOMBORDERWIDTH: pBorderWidths[XML_LINE_BOTTOM] = property; break;
368 case CTF_ANCHORTYPE: pAnchorType = property; break;
369 case CTF_VERTICALPOS: pVertOrient = property; break;
370 case CTF_VERTICALREL_ASCHAR: pVertOrientRelAsChar = property; break;
371
372 case CTF_FRAMEHEIGHT_MIN_ABS:
373 case CTF_FRAMEHEIGHT_MIN_REL:
374 // case CTF_SYNCHEIGHT_MIN:
375 bHasAnyMinHeight = sal_True;
376 // no break here!
377 case CTF_FRAMEHEIGHT_ABS:
378 case CTF_FRAMEHEIGHT_REL:
379 // case CTF_SYNCHEIGHT:
380 bHasAnyHeight = sal_True; break;
381 case CTF_FRAMEWIDTH_MIN_ABS:
382 case CTF_FRAMEWIDTH_MIN_REL:
383 bHasAnyMinWidth = sal_True;
384 // no break here!
385 case CTF_FRAMEWIDTH_ABS:
386 case CTF_FRAMEWIDTH_REL:
387 bHasAnyWidth = sal_True; break;
388 case CTF_BACKGROUND_TRANSPARENCY: pBackTransparency = property; break;
389 case CTF_BACKGROUND_TRANSPARENT: pBackTransparent = property; break;
390
391 case CTF_PARAMARGINALL:
392 pAllParaMargin = property;
393 break;
394 case CTF_PARAMARGINALL_REL:
395 {
396 sal_uInt32 nValue;
397 property->maValue >>= nValue;
398 // treat fo:margin="100%" as it is not exisiting as the
399 // corresponding core attribute classes - <SvxULSpaceItem> and
400 // <SvxLRSpaceItem> - are not able to treat such a value correctly.
401 // The result will be the same as the values will be inherited
402 // from parent, when the no margin attribute is given.
403 if ( nValue != 100 )
404 {
405 pAllParaMargin = property;
406 }
407 }
408 break;
409
410 case CTF_PARALEFTMARGIN:
411 case CTF_PARALEFTMARGIN_REL:
412 pParaMargins[XML_LINE_LEFT] = property; break;
413
414 case CTF_PARARIGHTMARGIN:
415 case CTF_PARARIGHTMARGIN_REL:
416 pParaMargins[XML_LINE_RIGHT] = property; break;
417
418 case CTF_PARATOPMARGIN:
419 case CTF_PARATOPMARGIN_REL:
420 pParaMargins[XML_LINE_TOP] = property; break;
421
422 case CTF_PARABOTTOMMARGIN:
423 case CTF_PARABOTTOMMARGIN_REL:
424 pParaMargins[XML_LINE_BOTTOM] = property; break;
425
426 case CTF_MARGINALL:
427 pAllMargin = property; break;
428 case CTF_MARGINLEFT:
429 pMargins[XML_LINE_LEFT] = property; break;
430 case CTF_MARGINRIGHT:
431 pMargins[XML_LINE_RIGHT] = property; break;
432 case CTF_MARGINTOP:
433 pMargins[XML_LINE_TOP] = property; break;
434 case CTF_MARGINBOTTOM:
435 pMargins[XML_LINE_BOTTOM] = property; break;
436 }
437 }
438
439 if( pFontFamilyName || pFontStyleName || pFontFamily ||
440 pFontPitch || pFontCharSet )
441 FontFinished( pFontFamilyName, pFontStyleName, pFontFamily,
442 pFontPitch, pFontCharSet );
443 if( pFontFamilyNameCJK || pFontStyleNameCJK || pFontFamilyCJK ||
444 pFontPitchCJK || pFontCharSetCJK )
445 FontFinished( pFontFamilyNameCJK, pFontStyleNameCJK, pFontFamilyCJK,
446 pFontPitchCJK, pFontCharSetCJK );
447 if( pFontFamilyNameCTL || pFontStyleNameCTL || pFontFamilyCTL ||
448 pFontPitchCTL || pFontCharSetCTL )
449 FontFinished( pFontFamilyNameCTL, pFontStyleNameCTL, pFontFamilyCTL,
450 pFontPitchCTL, pFontCharSetCTL );
451
452 for (sal_uInt16 i = 0; i < 4; i++)
453 {
454 if ( pAllParaMargin != NULL
455 && pParaMargins[i] == NULL )
456 {
457 #ifdef DBG_UTIL
458 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
459 pAllParaMargin->mnIndex + (2*i) + 2 );
460 OSL_ENSURE( nTmp >= CTF_PARALEFTMARGIN &&
461 nTmp <= CTF_PARABOTTOMMARGIN_REL,
462 "wrong property context id" );
463 #endif
464 // IMPORTANT NOTE: the index calculation depends on the right order in the property map
465 pNewParaMargins[i].reset(
466 new XMLPropertyState( pAllParaMargin->mnIndex + (2*i) + 2,
467 pAllParaMargin->maValue ) );
468 }
469
470 if (pAllMargin && !pMargins[i])
471 {
472 #ifdef DBG_UTIL
473 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
474 pAllMargin->mnIndex + i + 1 );
475 OSL_ENSURE( nTmp >= CTF_MARGINLEFT && nTmp <= CTF_MARGINBOTTOM,
476 "wrong property context id" );
477 #endif
478 // IMPORTANT NOTE: the index calculation depends on the right order in the property map
479 pNewMargins[i].reset(
480 new XMLPropertyState( pAllMargin->mnIndex + i + 1,
481 pAllMargin->maValue ) );
482 }
483 if( pAllBorderDistance && !pBorderDistances[i] )
484 {
485 #ifdef DBG_UTIL
486 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
487 pAllBorderDistance->mnIndex + i + 1 );
488 DBG_ASSERT( nTmp >= CTF_LEFTBORDERDISTANCE &&
489 nTmp <= CTF_BOTTOMBORDERDISTANCE,
490 "wrong property context id" );
491 #endif
492 pNewBorderDistances[i] =
493 new XMLPropertyState( pAllBorderDistance->mnIndex + i + 1,
494 pAllBorderDistance->maValue );
495 pBorderDistances[i] = pNewBorderDistances[i];
496 }
497 if( pAllBorder && !pBorders[i] )
498 {
499 #ifdef DBG_UTIL
500 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
501 pAllBorder->mnIndex + i + 1 );
502 DBG_ASSERT( nTmp >= CTF_LEFTBORDER && nTmp <= CTF_BOTTOMBORDER,
503 "wrong property context id" );
504 #endif
505 pNewBorders[i] = new XMLPropertyState( pAllBorder->mnIndex + i + 1,
506 pAllBorder->maValue );
507 pBorders[i] = pNewBorders[i];
508 }
509 if( !pBorderWidths[i] )
510 pBorderWidths[i] = pAllBorderWidth;
511 else
512 pBorderWidths[i]->mnIndex = -1;
513
514 #ifdef XML_CHECK_UI_CONSTRAINS
515 sal_Bool bHasBorder = sal_False;
516 if( pBorders[i] )
517 {
518 table::BorderLine aBorderLine;
519 pBorders[i]->maValue >>= aBorderLine;
520
521 if( pBorderWidths[i] )
522 {
523 table::BorderLine aBorderLineWidth;
524 pBorderWidths[i]->maValue >>= aBorderLineWidth;
525 aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
526 aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
527 aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
528
529 pBorders[i]->maValue <<= aBorderLine;
530 }
531 bHasBorder = (aBorderLine.OuterLineWidth +
532 aBorderLine.InnerLineWidth) > 0;
533 }
534 if( bHasBorder )
535 {
536 if( !pBorderDistances[i] )
537 {
538 #ifdef DBG_UTIL
539 sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
540 pBorders[i]->mnIndex + 5 );
541 DBG_ASSERT( nTmp >= CTF_LEFTBORDERDISTANCE &&
542 nTmp <= CTF_BOTTOMBORDERDISTANCE,
543 "wrong property context id" );
544 #endif
545
546 pNewBorderDistances[i] =
547 new XMLPropertyState( pBorders[i]->mnIndex + 5 );
548 pNewBorderDistances[i]->maValue <<= (sal_Int32)MIN_BORDER_DIST;
549 pBorderDistances[i] = pNewBorderDistances[i];
550 }
551 else
552 {
553 sal_Int32 nDist;
554 pBorderDistances[i]->maValue >>= nDist;
555 if( nDist < MIN_BORDER_DIST )
556 pBorderDistances[i]->maValue <<= (sal_Int32)MIN_BORDER_DIST;
557 }
558 }
559 else
560 {
561 if( pBorderDistances[i] )
562 {
563 sal_Int32 nDist;
564 pBorderDistances[i]->maValue >>= nDist;
565 if( nDist > 0 )
566 pBorderDistances[i]->maValue <<= (sal_Int32)0;
567 }
568 }
569 #else
570 if( pBorders[i] && pBorderWidths[i] )
571 {
572 table::BorderLine aBorderLine;
573 pBorders[i]->maValue >>= aBorderLine;
574
575 table::BorderLine aBorderLineWidth;
576 pBorderWidths[i]->maValue >>= aBorderLineWidth;
577
578 aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
579 aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
580 aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
581
582 pBorders[i]->maValue <<= aBorderLine;
583 }
584 #endif
585 }
586
587 if (pAllParaMargin)
588 {
589 pAllParaMargin->mnIndex = -1;
590 }
591 if (pAllMargin)
592 {
593 pAllMargin->mnIndex = -1;
594 }
595
596 if( pAllBorderDistance )
597 pAllBorderDistance->mnIndex = -1;
598
599 if( pAllBorder )
600 pAllBorder->mnIndex = -1;
601
602 if( pAllBorderWidth )
603 pAllBorderWidth->mnIndex = -1;
604
605 if( pVertOrient && pVertOrientRelAsChar )
606 {
607 sal_Int16 nVertOrient;
608 pVertOrient->maValue >>= nVertOrient;
609 sal_Int16 nVertOrientRel = 0;
610 pVertOrientRelAsChar->maValue >>= nVertOrientRel;
611 switch( nVertOrient )
612 {
613 case VertOrientation::TOP:
614 nVertOrient = nVertOrientRel;
615 break;
616 case VertOrientation::CENTER:
617 switch( nVertOrientRel )
618 {
619 case VertOrientation::CHAR_TOP:
620 nVertOrient = VertOrientation::CHAR_CENTER;
621 break;
622 case VertOrientation::LINE_TOP:
623 nVertOrient = VertOrientation::LINE_CENTER;
624 break;
625 }
626 break;
627 case VertOrientation::BOTTOM:
628 switch( nVertOrientRel )
629 {
630 case VertOrientation::CHAR_TOP:
631 nVertOrient = VertOrientation::CHAR_BOTTOM;
632 break;
633 case VertOrientation::LINE_TOP:
634 nVertOrient = VertOrientation::LINE_BOTTOM;
635 break;
636 }
637 break;
638 }
639 pVertOrient->maValue <<= nVertOrient;
640 pVertOrientRelAsChar->mnIndex = -1;
641 }
642
643 FontDefaultsCheck( pFontFamilyName,
644 pFontStyleName, pFontFamily, pFontPitch, pFontCharSet,
645 &pNewFontStyleName, &pNewFontFamily, &pNewFontPitch, &pNewFontCharSet );
646
647 FontDefaultsCheck( pFontFamilyNameCJK,
648 pFontStyleNameCJK, pFontFamilyCJK, pFontPitchCJK, pFontCharSetCJK,
649 &pNewFontStyleNameCJK, &pNewFontFamilyCJK, &pNewFontPitchCJK, &pNewFontCharSetCJK );
650
651 FontDefaultsCheck( pFontFamilyNameCTL,
652 pFontStyleNameCTL, pFontFamilyCTL, pFontPitchCTL, pFontCharSetCTL,
653 &pNewFontStyleNameCTL, &pNewFontFamilyCTL, &pNewFontPitchCTL, &pNewFontCharSetCTL );
654
655 // #i5775# don't overwrite %transparency with binary transparency
656 if( ( pBackTransparency != NULL ) && ( pBackTransparent != NULL ) )
657 {
658 if( ! *(sal_Bool*)(pBackTransparent->maValue.getValue()) )
659 pBackTransparent->mnIndex = -1;
660 }
661
662
663 // insert newly created properties. This inavlidates all iterators!
664 // Most of the pXXX variables in this method are iterators and will be
665 // invalidated!!!
666
667 if( pNewFontStyleName )
668 {
669 rProperties.push_back( *pNewFontStyleName );
670 delete pNewFontStyleName;
671 }
672
673 if( pNewFontFamily )
674 {
675 rProperties.push_back( *pNewFontFamily );
676 delete pNewFontFamily;
677 }
678
679 if( pNewFontPitch )
680 {
681 rProperties.push_back( *pNewFontPitch );
682 delete pNewFontPitch;
683 }
684
685 if( pNewFontCharSet )
686 {
687 rProperties.push_back( *pNewFontCharSet );
688 delete pNewFontCharSet;
689 }
690
691 if( pNewFontStyleNameCJK )
692 {
693 rProperties.push_back( *pNewFontStyleNameCJK );
694 delete pNewFontStyleNameCJK;
695 }
696
697 if( pNewFontFamilyCJK )
698 {
699 rProperties.push_back( *pNewFontFamilyCJK );
700 delete pNewFontFamilyCJK;
701 }
702
703 if( pNewFontPitchCJK )
704 {
705 rProperties.push_back( *pNewFontPitchCJK );
706 delete pNewFontPitchCJK;
707 }
708
709 if( pNewFontCharSetCJK )
710 {
711 rProperties.push_back( *pNewFontCharSetCJK );
712 delete pNewFontCharSetCJK;
713 }
714
715 if( pNewFontStyleNameCTL)
716 {
717 rProperties.push_back( *pNewFontStyleNameCTL );
718 delete pNewFontStyleNameCTL;
719 }
720
721 if( pNewFontFamilyCTL )
722 {
723 rProperties.push_back( *pNewFontFamilyCTL );
724 delete pNewFontFamilyCTL;
725 }
726
727 if( pNewFontPitchCTL )
728 {
729 rProperties.push_back( *pNewFontPitchCTL );
730 delete pNewFontPitchCTL;
731 }
732
733 if( pNewFontCharSetCTL )
734 {
735 rProperties.push_back( *pNewFontCharSetCTL );
736 delete pNewFontCharSetCTL;
737 }
738
739 for (sal_uInt16 i=0; i<4; i++)
740 {
741 if (pNewParaMargins[i].get())
742 {
743 rProperties.push_back(*pNewParaMargins[i]);
744 }
745 if (pNewMargins[i].get())
746 {
747 rProperties.push_back(*pNewMargins[i]);
748 }
749 if( pNewBorderDistances[i] )
750 {
751 rProperties.push_back( *pNewBorderDistances[i] );
752 delete pNewBorderDistances[i];
753 }
754 if( pNewBorders[i] )
755 {
756 rProperties.push_back( *pNewBorders[i] );
757 delete pNewBorders[i];
758 }
759 }
760
761 if( bHasAnyHeight )
762 {
763 if( nSizeTypeIndex == -2 )
764 {
765 const_cast < XMLTextImportPropertyMapper * > ( this )
766 ->nSizeTypeIndex = -1;
767 sal_Int32 nPropCount = getPropertySetMapper()->GetEntryCount();
768 for( sal_Int32 j=0; j < nPropCount; j++ )
769 {
770 if( CTF_SIZETYPE == getPropertySetMapper()
771 ->GetEntryContextId( j ) )
772 {
773 const_cast < XMLTextImportPropertyMapper * > ( this )
774 ->nSizeTypeIndex = j;
775 break;
776 }
777 }
778 }
779 if( nSizeTypeIndex != -1 )
780 {
781 XMLPropertyState aSizeTypeState( nSizeTypeIndex );
782 aSizeTypeState.maValue <<= (sal_Int16)( bHasAnyMinHeight
783 ? SizeType::MIN
784 : SizeType::FIX);
785 rProperties.push_back( aSizeTypeState );
786 }
787 }
788
789 if( bHasAnyWidth )
790 {
791 if( nWidthTypeIndex == -2 )
792 {
793 const_cast < XMLTextImportPropertyMapper * > ( this )
794 ->nWidthTypeIndex = -1;
795 sal_Int32 nCount = getPropertySetMapper()->GetEntryCount();
796 for( sal_Int32 j=0; j < nCount; j++ )
797 {
798 if( CTF_FRAMEWIDTH_TYPE == getPropertySetMapper()
799 ->GetEntryContextId( j ) )
800 {
801 const_cast < XMLTextImportPropertyMapper * > ( this )
802 ->nWidthTypeIndex = j;
803 break;
804 }
805 }
806 }
807 if( nWidthTypeIndex != -1 )
808 {
809 XMLPropertyState aSizeTypeState( nWidthTypeIndex );
810 aSizeTypeState.maValue <<= (sal_Int16)( bHasAnyMinWidth
811 ? SizeType::MIN
812 : SizeType::FIX);
813 rProperties.push_back( aSizeTypeState );
814 }
815 }
816
817 // DO NOT USE ITERATORS/POINTERS INTO THE rProperties-VECTOR AFTER
818 // THIS LINE. All iterators into the rProperties-vector, especially all
819 // pXXX-type variables set in the first switch statement of this method,
820 // may have been invalidated by the above push_back() calls!
821 }
822
823
824