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 "scitems.hxx"
21 : #include <editeng/adjustitem.hxx>
22 : #include <svx/algitem.hxx>
23 : #include <editeng/boxitem.hxx>
24 : #include <editeng/lineitem.hxx>
25 : #include <editeng/brushitem.hxx>
26 : #include <editeng/charreliefitem.hxx>
27 : #include <editeng/contouritem.hxx>
28 : #include <svtools/colorcfg.hxx>
29 : #include <editeng/colritem.hxx>
30 : #include <editeng/crossedoutitem.hxx>
31 : #include <editeng/emphasismarkitem.hxx>
32 : #include <editeng/fhgtitem.hxx>
33 : #include <editeng/fontitem.hxx>
34 : #include <editeng/forbiddenruleitem.hxx>
35 : #include <editeng/frmdiritem.hxx>
36 : #include <editeng/langitem.hxx>
37 : #include <editeng/postitem.hxx>
38 : #include <svx/rotmodit.hxx>
39 : #include <editeng/scriptspaceitem.hxx>
40 : #include <editeng/scripttypeitem.hxx>
41 : #include <editeng/shaditem.hxx>
42 : #include <editeng/shdditem.hxx>
43 : #include <editeng/udlnitem.hxx>
44 : #include <editeng/wghtitem.hxx>
45 : #include <editeng/wrlmitem.hxx>
46 : #include <editeng/justifyitem.hxx>
47 : #include <svl/intitem.hxx>
48 : #include <svl/zforlist.hxx>
49 : #include <vcl/outdev.hxx>
50 : #include <vcl/svapp.hxx>
51 :
52 : #include "patattr.hxx"
53 : #include "docpool.hxx"
54 : #include "stlsheet.hxx"
55 : #include "stlpool.hxx"
56 : #include "document.hxx"
57 : #include "global.hxx"
58 : #include "globstr.hrc"
59 : #include "conditio.hxx"
60 : #include "validat.hxx"
61 : #include "scmod.hxx"
62 : #include "fillinfo.hxx"
63 :
64 : // STATIC DATA -----------------------------------------------------------
65 :
66 : using sc::HMMToTwips;
67 : using sc::TwipsToHMM;
68 :
69 2336 : ScPatternAttr::ScPatternAttr( SfxItemSet* pItemSet, const OUString& rStyleName )
70 : : SfxSetItem ( ATTR_PATTERN, pItemSet ),
71 2336 : pName ( new OUString( rStyleName ) ),
72 4672 : pStyle ( NULL )
73 : {
74 2336 : }
75 :
76 178226 : ScPatternAttr::ScPatternAttr( SfxItemSet* pItemSet, ScStyleSheet* pStyleSheet )
77 : : SfxSetItem ( ATTR_PATTERN, pItemSet ),
78 : pName ( NULL ),
79 178226 : pStyle ( pStyleSheet )
80 : {
81 178226 : if ( pStyleSheet )
82 0 : GetItemSet().SetParent( &pStyleSheet->GetItemSet() );
83 178226 : }
84 :
85 8036 : ScPatternAttr::ScPatternAttr( SfxItemPool* pItemPool )
86 8036 : : SfxSetItem ( ATTR_PATTERN, new SfxItemSet( *pItemPool, ATTR_PATTERN_START, ATTR_PATTERN_END ) ),
87 : pName ( NULL ),
88 16072 : pStyle ( NULL )
89 : {
90 8036 : }
91 :
92 478945 : ScPatternAttr::ScPatternAttr( const ScPatternAttr& rPatternAttr )
93 : : SfxSetItem ( rPatternAttr ),
94 478945 : pStyle ( rPatternAttr.pStyle )
95 : {
96 478945 : if (rPatternAttr.pName)
97 1504 : pName = new OUString(*rPatternAttr.pName);
98 : else
99 477441 : pName = NULL;
100 478945 : }
101 :
102 1981687 : ScPatternAttr::~ScPatternAttr()
103 : {
104 667437 : delete pName;
105 1314250 : }
106 :
107 155598 : SfxPoolItem* ScPatternAttr::Clone( SfxItemPool *pPool ) const
108 : {
109 155598 : ScPatternAttr* pPattern = new ScPatternAttr( GetItemSet().Clone(true, pPool) );
110 :
111 155598 : pPattern->pStyle = pStyle;
112 155598 : pPattern->pName = pName ? new OUString(*pName) : NULL;
113 :
114 155598 : return pPattern;
115 : }
116 :
117 843004 : inline bool StrCmp( const OUString* pStr1, const OUString* pStr2 )
118 : {
119 843004 : return ( pStr1 ? ( pStr2 && ( *pStr1 == *pStr2 ) ) : ( pStr2 ? false : true ) );
120 : }
121 :
122 16438168 : inline bool EqualPatternSets( const SfxItemSet& rSet1, const SfxItemSet& rSet2 )
123 : {
124 : // #i62090# The SfxItemSet in the SfxSetItem base class always has the same ranges
125 : // (single range from ATTR_PATTERN_START to ATTR_PATTERN_END), and the items are pooled,
126 : // so it's enough to compare just the pointers (Count just because it's even faster).
127 :
128 16438168 : if ( rSet1.Count() != rSet2.Count() )
129 13598237 : return false;
130 :
131 2839931 : SfxItemArray pItems1 = rSet1.GetItems_Impl(); // inline method of SfxItemSet
132 2839931 : SfxItemArray pItems2 = rSet2.GetItems_Impl();
133 :
134 2839931 : return ( 0 == memcmp( pItems1, pItems2, (ATTR_PATTERN_END - ATTR_PATTERN_START + 1) * sizeof(pItems1[0]) ) );
135 : }
136 :
137 16438168 : bool ScPatternAttr::operator==( const SfxPoolItem& rCmp ) const
138 : {
139 : // #i62090# Use quick comparison between ScPatternAttr's ItemSets
140 :
141 17281172 : return ( EqualPatternSets( GetItemSet(), static_cast<const ScPatternAttr&>(rCmp).GetItemSet() ) &&
142 17281172 : StrCmp( GetStyleName(), static_cast<const ScPatternAttr&>(rCmp).GetStyleName() ) );
143 : }
144 :
145 0 : SfxPoolItem* ScPatternAttr::Create( SvStream& rStream, sal_uInt16 /* nVersion */ ) const
146 : {
147 : OUString* pStr;
148 : bool bHasStyle;
149 :
150 0 : rStream.ReadCharAsBool( bHasStyle );
151 :
152 0 : if ( bHasStyle )
153 : {
154 : short eFamDummy;
155 0 : pStr = new OUString;
156 0 : *pStr = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
157 0 : rStream.ReadInt16( eFamDummy ); // wg. altem Dateiformat
158 : }
159 : else
160 0 : pStr = new OUString( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) );
161 :
162 0 : SfxItemSet *pNewSet = new SfxItemSet( *GetItemSet().GetPool(),
163 0 : ATTR_PATTERN_START, ATTR_PATTERN_END );
164 0 : pNewSet->Load( rStream );
165 :
166 0 : ScPatternAttr* pPattern = new ScPatternAttr( pNewSet );
167 :
168 0 : pPattern->pName = pStr;
169 :
170 0 : return pPattern;
171 : }
172 :
173 0 : SvStream& ScPatternAttr::Store(SvStream& rStream, sal_uInt16 /* nItemVersion */) const
174 : {
175 0 : rStream.WriteUChar( true );
176 :
177 0 : if ( pStyle )
178 0 : rStream.WriteUniOrByteString( pStyle->GetName(), rStream.GetStreamCharSet() );
179 0 : else if ( pName ) // wenn Style geloescht ist/war
180 0 : rStream.WriteUniOrByteString( *pName, rStream.GetStreamCharSet() );
181 : else
182 0 : rStream.WriteUniOrByteString( ScGlobal::GetRscString(STR_STYLENAME_STANDARD),
183 0 : rStream.GetStreamCharSet() );
184 :
185 0 : rStream.WriteInt16( SFX_STYLE_FAMILY_PARA ); // wg. altem Dateiformat
186 :
187 0 : GetItemSet().Store( rStream );
188 :
189 0 : return rStream;
190 : }
191 :
192 3410252 : SvxCellOrientation ScPatternAttr::GetCellOrientation( const SfxItemSet& rItemSet, const SfxItemSet* pCondSet )
193 : {
194 3410252 : SvxCellOrientation eOrient = SVX_ORIENTATION_STANDARD;
195 :
196 3410252 : if( static_cast<const SfxBoolItem&>(GetItem( ATTR_STACKED, rItemSet, pCondSet )).GetValue() )
197 : {
198 192410 : eOrient = SVX_ORIENTATION_STACKED;
199 : }
200 : else
201 : {
202 3217842 : sal_Int32 nAngle = static_cast<const SfxInt32Item&>(GetItem( ATTR_ROTATE_VALUE, rItemSet, pCondSet )).GetValue();
203 3217842 : if( nAngle == 9000 )
204 4 : eOrient = SVX_ORIENTATION_BOTTOMTOP;
205 3217838 : else if( nAngle == 27000 )
206 4466 : eOrient = SVX_ORIENTATION_TOPBOTTOM;
207 : }
208 :
209 3410252 : return eOrient;
210 : }
211 :
212 3410252 : SvxCellOrientation ScPatternAttr::GetCellOrientation( const SfxItemSet* pCondSet ) const
213 : {
214 3410252 : return GetCellOrientation( GetItemSet(), pCondSet );
215 : }
216 :
217 11435 : void ScPatternAttr::GetFont(
218 : vcl::Font& rFont, const SfxItemSet& rItemSet, ScAutoFontColorMode eAutoMode,
219 : OutputDevice* pOutDev, const Fraction* pScale,
220 : const SfxItemSet* pCondSet, sal_uInt8 nScript,
221 : const Color* pBackConfigColor, const Color* pTextConfigColor )
222 : {
223 : // Items auslesen
224 :
225 : const SvxFontItem* pFontAttr;
226 : sal_uInt32 nFontHeight;
227 : FontWeight eWeight;
228 : FontItalic eItalic;
229 : FontUnderline eUnder;
230 : FontUnderline eOver;
231 : bool bWordLine;
232 : FontStrikeout eStrike;
233 : bool bOutline;
234 : bool bShadow;
235 : FontEmphasisMark eEmphasis;
236 : FontRelief eRelief;
237 11435 : Color aColor;
238 : LanguageType eLang;
239 :
240 : sal_uInt16 nFontId, nHeightId, nWeightId, nPostureId, nLangId;
241 11435 : if ( nScript == SCRIPTTYPE_ASIAN )
242 : {
243 2 : nFontId = ATTR_CJK_FONT;
244 2 : nHeightId = ATTR_CJK_FONT_HEIGHT;
245 2 : nWeightId = ATTR_CJK_FONT_WEIGHT;
246 2 : nPostureId = ATTR_CJK_FONT_POSTURE;
247 2 : nLangId = ATTR_CJK_FONT_LANGUAGE;
248 : }
249 11433 : else if ( nScript == SCRIPTTYPE_COMPLEX )
250 : {
251 0 : nFontId = ATTR_CTL_FONT;
252 0 : nHeightId = ATTR_CTL_FONT_HEIGHT;
253 0 : nWeightId = ATTR_CTL_FONT_WEIGHT;
254 0 : nPostureId = ATTR_CTL_FONT_POSTURE;
255 0 : nLangId = ATTR_CTL_FONT_LANGUAGE;
256 : }
257 : else
258 : {
259 11433 : nFontId = ATTR_FONT;
260 11433 : nHeightId = ATTR_FONT_HEIGHT;
261 11433 : nWeightId = ATTR_FONT_WEIGHT;
262 11433 : nPostureId = ATTR_FONT_POSTURE;
263 11433 : nLangId = ATTR_FONT_LANGUAGE;
264 : }
265 :
266 11435 : if ( pCondSet )
267 : {
268 : const SfxPoolItem* pItem;
269 :
270 4 : if ( pCondSet->GetItemState( nFontId, true, &pItem ) != SfxItemState::SET )
271 4 : pItem = &rItemSet.Get( nFontId );
272 4 : pFontAttr = static_cast<const SvxFontItem*>(pItem);
273 :
274 4 : if ( pCondSet->GetItemState( nHeightId, true, &pItem ) != SfxItemState::SET )
275 4 : pItem = &rItemSet.Get( nHeightId );
276 4 : nFontHeight = static_cast<const SvxFontHeightItem*>(pItem)->GetHeight();
277 :
278 4 : if ( pCondSet->GetItemState( nWeightId, true, &pItem ) != SfxItemState::SET )
279 0 : pItem = &rItemSet.Get( nWeightId );
280 4 : eWeight = (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue();
281 :
282 4 : if ( pCondSet->GetItemState( nPostureId, true, &pItem ) != SfxItemState::SET )
283 0 : pItem = &rItemSet.Get( nPostureId );
284 4 : eItalic = (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue();
285 :
286 4 : if ( pCondSet->GetItemState( ATTR_FONT_UNDERLINE, true, &pItem ) != SfxItemState::SET )
287 0 : pItem = &rItemSet.Get( ATTR_FONT_UNDERLINE );
288 4 : eUnder = (FontUnderline)static_cast<const SvxUnderlineItem*>(pItem)->GetValue();
289 :
290 4 : if ( pCondSet->GetItemState( ATTR_FONT_OVERLINE, true, &pItem ) != SfxItemState::SET )
291 4 : pItem = &rItemSet.Get( ATTR_FONT_OVERLINE );
292 4 : eOver = (FontUnderline)static_cast<const SvxOverlineItem*>(pItem)->GetValue();
293 :
294 4 : if ( pCondSet->GetItemState( ATTR_FONT_WORDLINE, true, &pItem ) != SfxItemState::SET )
295 4 : pItem = &rItemSet.Get( ATTR_FONT_WORDLINE );
296 4 : bWordLine = static_cast<const SvxWordLineModeItem*>(pItem)->GetValue();
297 :
298 4 : if ( pCondSet->GetItemState( ATTR_FONT_CROSSEDOUT, true, &pItem ) != SfxItemState::SET )
299 4 : pItem = &rItemSet.Get( ATTR_FONT_CROSSEDOUT );
300 4 : eStrike = (FontStrikeout)static_cast<const SvxCrossedOutItem*>(pItem)->GetValue();
301 :
302 4 : if ( pCondSet->GetItemState( ATTR_FONT_CONTOUR, true, &pItem ) != SfxItemState::SET )
303 4 : pItem = &rItemSet.Get( ATTR_FONT_CONTOUR );
304 4 : bOutline = static_cast<const SvxContourItem*>(pItem)->GetValue();
305 :
306 4 : if ( pCondSet->GetItemState( ATTR_FONT_SHADOWED, true, &pItem ) != SfxItemState::SET )
307 4 : pItem = &rItemSet.Get( ATTR_FONT_SHADOWED );
308 4 : bShadow = static_cast<const SvxShadowedItem*>(pItem)->GetValue();
309 :
310 4 : if ( pCondSet->GetItemState( ATTR_FONT_EMPHASISMARK, true, &pItem ) != SfxItemState::SET )
311 4 : pItem = &rItemSet.Get( ATTR_FONT_EMPHASISMARK );
312 4 : eEmphasis = static_cast<const SvxEmphasisMarkItem*>(pItem)->GetEmphasisMark();
313 :
314 4 : if ( pCondSet->GetItemState( ATTR_FONT_RELIEF, true, &pItem ) != SfxItemState::SET )
315 4 : pItem = &rItemSet.Get( ATTR_FONT_RELIEF );
316 4 : eRelief = (FontRelief)static_cast<const SvxCharReliefItem*>(pItem)->GetValue();
317 :
318 4 : if ( pCondSet->GetItemState( ATTR_FONT_COLOR, true, &pItem ) != SfxItemState::SET )
319 4 : pItem = &rItemSet.Get( ATTR_FONT_COLOR );
320 4 : aColor = static_cast<const SvxColorItem*>(pItem)->GetValue();
321 :
322 4 : if ( pCondSet->GetItemState( nLangId, true, &pItem ) != SfxItemState::SET )
323 4 : pItem = &rItemSet.Get( nLangId );
324 4 : eLang = static_cast<const SvxLanguageItem*>(pItem)->GetLanguage();
325 : }
326 : else // alles aus rItemSet
327 : {
328 11431 : pFontAttr = &static_cast<const SvxFontItem&>(rItemSet.Get( nFontId ));
329 : nFontHeight = static_cast<const SvxFontHeightItem&>(
330 11431 : rItemSet.Get( nHeightId )).GetHeight();
331 : eWeight = (FontWeight)static_cast<const SvxWeightItem&>(
332 11431 : rItemSet.Get( nWeightId )).GetValue();
333 : eItalic = (FontItalic)static_cast<const SvxPostureItem&>(
334 11431 : rItemSet.Get( nPostureId )).GetValue();
335 : eUnder = (FontUnderline)static_cast<const SvxUnderlineItem&>(
336 11431 : rItemSet.Get( ATTR_FONT_UNDERLINE )).GetValue();
337 : eOver = (FontUnderline)static_cast<const SvxOverlineItem&>(
338 11431 : rItemSet.Get( ATTR_FONT_OVERLINE )).GetValue();
339 : bWordLine = static_cast<const SvxWordLineModeItem&>(
340 11431 : rItemSet.Get( ATTR_FONT_WORDLINE )).GetValue();
341 : eStrike = (FontStrikeout)static_cast<const SvxCrossedOutItem&>(
342 11431 : rItemSet.Get( ATTR_FONT_CROSSEDOUT )).GetValue();
343 : bOutline = static_cast<const SvxContourItem&>(
344 11431 : rItemSet.Get( ATTR_FONT_CONTOUR )).GetValue();
345 : bShadow = static_cast<const SvxShadowedItem&>(
346 11431 : rItemSet.Get( ATTR_FONT_SHADOWED )).GetValue();
347 : eEmphasis = static_cast<const SvxEmphasisMarkItem&>(
348 11431 : rItemSet.Get( ATTR_FONT_EMPHASISMARK )).GetEmphasisMark();
349 : eRelief = (FontRelief)static_cast<const SvxCharReliefItem&>(
350 11431 : rItemSet.Get( ATTR_FONT_RELIEF )).GetValue();
351 : aColor = static_cast<const SvxColorItem&>(
352 11431 : rItemSet.Get( ATTR_FONT_COLOR )).GetValue();
353 : // for graphite language features
354 11431 : eLang = static_cast<const SvxLanguageItem&>(rItemSet.Get( nLangId )).GetLanguage();
355 : }
356 : OSL_ENSURE(pFontAttr,"Oops?");
357 :
358 : // auswerten
359 :
360 : // FontItem:
361 :
362 11435 : if (rFont.GetName() != pFontAttr->GetFamilyName())
363 7868 : rFont.SetName( pFontAttr->GetFamilyName() );
364 11435 : if (rFont.GetStyleName() != pFontAttr->GetStyleName())
365 2505 : rFont.SetStyleName( pFontAttr->GetStyleName() );
366 :
367 11435 : rFont.SetFamily( pFontAttr->GetFamily() );
368 11435 : rFont.SetCharSet( pFontAttr->GetCharSet() );
369 11435 : rFont.SetPitch( pFontAttr->GetPitch() );
370 :
371 11435 : rFont.SetLanguage(eLang);
372 :
373 : // Groesse
374 :
375 11435 : if ( pOutDev != NULL )
376 : {
377 10065 : Size aEffSize;
378 10065 : Fraction aFraction( 1,1 );
379 10065 : if (pScale)
380 6615 : aFraction = *pScale;
381 10065 : Size aSize( 0, (long) nFontHeight );
382 10065 : MapMode aDestMode = pOutDev->GetMapMode();
383 20130 : MapMode aSrcMode( MAP_TWIP, Point(), aFraction, aFraction );
384 10065 : if (aDestMode.GetMapUnit() == MAP_PIXEL)
385 9909 : aEffSize = pOutDev->LogicToPixel( aSize, aSrcMode );
386 : else
387 : {
388 156 : Fraction aFractOne(1,1);
389 156 : aDestMode.SetScaleX( aFractOne );
390 156 : aDestMode.SetScaleY( aFractOne );
391 156 : aEffSize = OutputDevice::LogicToLogic( aSize, aSrcMode, aDestMode );
392 : }
393 20130 : rFont.SetSize( aEffSize );
394 : }
395 : else /* if pOutDev != NULL */
396 : {
397 1370 : rFont.SetSize( Size( 0, (long) nFontHeight ) );
398 : }
399 :
400 : // determine effective font color
401 :
402 29906 : if ( ( aColor.GetColor() == COL_AUTO && eAutoMode != SC_AUTOCOL_RAW ) ||
403 16332 : eAutoMode == SC_AUTOCOL_IGNOREFONT || eAutoMode == SC_AUTOCOL_IGNOREALL )
404 : {
405 6538 : if ( eAutoMode == SC_AUTOCOL_BLACK )
406 4312 : aColor.SetColor( COL_BLACK );
407 : else
408 : {
409 : // get background color from conditional or own set
410 2226 : Color aBackColor;
411 2226 : if ( pCondSet )
412 : {
413 : const SfxPoolItem* pItem;
414 4 : if ( pCondSet->GetItemState( ATTR_BACKGROUND, true, &pItem ) != SfxItemState::SET )
415 4 : pItem = &rItemSet.Get( ATTR_BACKGROUND );
416 4 : aBackColor = static_cast<const SvxBrushItem*>(pItem)->GetColor();
417 : }
418 : else
419 2222 : aBackColor = static_cast<const SvxBrushItem&>(rItemSet.Get( ATTR_BACKGROUND )).GetColor();
420 :
421 : // if background color attribute is transparent, use window color for brightness comparisons
422 6678 : if ( aBackColor == COL_TRANSPARENT ||
423 6678 : eAutoMode == SC_AUTOCOL_IGNOREBACK || eAutoMode == SC_AUTOCOL_IGNOREALL )
424 : {
425 2226 : if ( eAutoMode == SC_AUTOCOL_PRINT )
426 12 : aBackColor.SetColor( COL_WHITE );
427 2214 : else if ( pBackConfigColor )
428 : {
429 : // pBackConfigColor can be used to avoid repeated lookup of the configured color
430 2198 : aBackColor = *pBackConfigColor;
431 : }
432 : else
433 16 : aBackColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor );
434 : }
435 :
436 : // get system text color for comparison
437 2226 : Color aSysTextColor;
438 2226 : if ( eAutoMode == SC_AUTOCOL_PRINT )
439 12 : aSysTextColor.SetColor( COL_BLACK );
440 2214 : else if ( pTextConfigColor )
441 : {
442 : // pTextConfigColor can be used to avoid repeated lookup of the configured color
443 2198 : aSysTextColor = *pTextConfigColor;
444 : }
445 : else
446 16 : aSysTextColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor );
447 :
448 : // select the resulting color
449 2226 : if ( aBackColor.IsDark() && aSysTextColor.IsDark() )
450 : {
451 : // use white instead of dark on dark
452 0 : aColor.SetColor( COL_WHITE );
453 : }
454 2226 : else if ( aBackColor.IsBright() && aSysTextColor.IsBright() )
455 : {
456 : // use black instead of bright on bright
457 0 : aColor.SetColor( COL_BLACK );
458 : }
459 : else
460 : {
461 : // use aSysTextColor (black for SC_AUTOCOL_PRINT, from style settings otherwise)
462 2226 : aColor = aSysTextColor;
463 : }
464 : }
465 : }
466 :
467 : // set font effects
468 11435 : rFont.SetWeight( eWeight );
469 11435 : rFont.SetItalic( eItalic );
470 11435 : rFont.SetUnderline( eUnder );
471 11435 : rFont.SetOverline( eOver );
472 11435 : rFont.SetWordLineMode( bWordLine );
473 11435 : rFont.SetStrikeout( eStrike );
474 11435 : rFont.SetOutline( bOutline );
475 11435 : rFont.SetShadow( bShadow );
476 11435 : rFont.SetEmphasisMark( eEmphasis );
477 11435 : rFont.SetRelief( eRelief );
478 11435 : rFont.SetColor( aColor );
479 11435 : rFont.SetTransparent( true );
480 11435 : }
481 :
482 10097 : void ScPatternAttr::GetFont(
483 : vcl::Font& rFont, ScAutoFontColorMode eAutoMode,
484 : OutputDevice* pOutDev, const Fraction* pScale,
485 : const SfxItemSet* pCondSet, sal_uInt8 nScript,
486 : const Color* pBackConfigColor, const Color* pTextConfigColor ) const
487 : {
488 10097 : GetFont( rFont, GetItemSet(), eAutoMode, pOutDev, pScale, pCondSet, nScript, pBackConfigColor, pTextConfigColor );
489 10097 : }
490 :
491 7611 : void ScPatternAttr::FillToEditItemSet( SfxItemSet& rEditSet, const SfxItemSet& rSrcSet, const SfxItemSet* pCondSet )
492 : {
493 : // Items auslesen
494 :
495 7611 : SvxColorItem aColorItem(EE_CHAR_COLOR); // use item as-is
496 15222 : SvxFontItem aFontItem(EE_CHAR_FONTINFO); // use item as-is
497 15222 : SvxFontItem aCjkFontItem(EE_CHAR_FONTINFO_CJK);
498 15222 : SvxFontItem aCtlFontItem(EE_CHAR_FONTINFO_CTL);
499 : long nTHeight, nCjkTHeight, nCtlTHeight; // Twips
500 : FontWeight eWeight, eCjkWeight, eCtlWeight;
501 15222 : SvxUnderlineItem aUnderlineItem(UNDERLINE_NONE, EE_CHAR_UNDERLINE);
502 15222 : SvxOverlineItem aOverlineItem(UNDERLINE_NONE, EE_CHAR_OVERLINE);
503 : bool bWordLine;
504 : FontStrikeout eStrike;
505 : FontItalic eItalic, eCjkItalic, eCtlItalic;
506 : bool bOutline;
507 : bool bShadow;
508 : bool bForbidden;
509 : FontEmphasisMark eEmphasis;
510 : FontRelief eRelief;
511 : LanguageType eLang, eCjkLang, eCtlLang;
512 : bool bHyphenate;
513 : SvxFrameDirection eDirection;
514 :
515 : //! additional parameter to control if language is needed?
516 :
517 7611 : if ( pCondSet )
518 : {
519 : const SfxPoolItem* pItem;
520 :
521 280 : if ( pCondSet->GetItemState( ATTR_FONT_COLOR, true, &pItem ) != SfxItemState::SET )
522 280 : pItem = &rSrcSet.Get( ATTR_FONT_COLOR );
523 280 : aColorItem = *static_cast<const SvxColorItem*>(pItem);
524 :
525 280 : if ( pCondSet->GetItemState( ATTR_FONT, true, &pItem ) != SfxItemState::SET )
526 0 : pItem = &rSrcSet.Get( ATTR_FONT );
527 280 : aFontItem = *static_cast<const SvxFontItem*>(pItem);
528 280 : if ( pCondSet->GetItemState( ATTR_CJK_FONT, true, &pItem ) != SfxItemState::SET )
529 280 : pItem = &rSrcSet.Get( ATTR_CJK_FONT );
530 280 : aCjkFontItem = *static_cast<const SvxFontItem*>(pItem);
531 280 : if ( pCondSet->GetItemState( ATTR_CTL_FONT, true, &pItem ) != SfxItemState::SET )
532 280 : pItem = &rSrcSet.Get( ATTR_CTL_FONT );
533 280 : aCtlFontItem = *static_cast<const SvxFontItem*>(pItem);
534 :
535 280 : if ( pCondSet->GetItemState( ATTR_FONT_HEIGHT, true, &pItem ) != SfxItemState::SET )
536 280 : pItem = &rSrcSet.Get( ATTR_FONT_HEIGHT );
537 280 : nTHeight = static_cast<const SvxFontHeightItem*>(pItem)->GetHeight();
538 280 : if ( pCondSet->GetItemState( ATTR_CJK_FONT_HEIGHT, true, &pItem ) != SfxItemState::SET )
539 280 : pItem = &rSrcSet.Get( ATTR_CJK_FONT_HEIGHT );
540 280 : nCjkTHeight = static_cast<const SvxFontHeightItem*>(pItem)->GetHeight();
541 280 : if ( pCondSet->GetItemState( ATTR_CTL_FONT_HEIGHT, true, &pItem ) != SfxItemState::SET )
542 280 : pItem = &rSrcSet.Get( ATTR_CTL_FONT_HEIGHT );
543 280 : nCtlTHeight = static_cast<const SvxFontHeightItem*>(pItem)->GetHeight();
544 :
545 280 : if ( pCondSet->GetItemState( ATTR_FONT_WEIGHT, true, &pItem ) != SfxItemState::SET )
546 280 : pItem = &rSrcSet.Get( ATTR_FONT_WEIGHT );
547 280 : eWeight = (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue();
548 280 : if ( pCondSet->GetItemState( ATTR_CJK_FONT_WEIGHT, true, &pItem ) != SfxItemState::SET )
549 280 : pItem = &rSrcSet.Get( ATTR_CJK_FONT_WEIGHT );
550 280 : eCjkWeight = (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue();
551 280 : if ( pCondSet->GetItemState( ATTR_CTL_FONT_WEIGHT, true, &pItem ) != SfxItemState::SET )
552 280 : pItem = &rSrcSet.Get( ATTR_CTL_FONT_WEIGHT );
553 280 : eCtlWeight = (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue();
554 :
555 280 : if ( pCondSet->GetItemState( ATTR_FONT_POSTURE, true, &pItem ) != SfxItemState::SET )
556 280 : pItem = &rSrcSet.Get( ATTR_FONT_POSTURE );
557 280 : eItalic = (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue();
558 280 : if ( pCondSet->GetItemState( ATTR_CJK_FONT_POSTURE, true, &pItem ) != SfxItemState::SET )
559 280 : pItem = &rSrcSet.Get( ATTR_CJK_FONT_POSTURE );
560 280 : eCjkItalic = (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue();
561 280 : if ( pCondSet->GetItemState( ATTR_CTL_FONT_POSTURE, true, &pItem ) != SfxItemState::SET )
562 280 : pItem = &rSrcSet.Get( ATTR_CTL_FONT_POSTURE );
563 280 : eCtlItalic = (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue();
564 :
565 280 : if ( pCondSet->GetItemState( ATTR_FONT_UNDERLINE, true, &pItem ) != SfxItemState::SET )
566 280 : pItem = &rSrcSet.Get( ATTR_FONT_UNDERLINE );
567 280 : aUnderlineItem = *static_cast<const SvxUnderlineItem*>(pItem);
568 :
569 280 : if ( pCondSet->GetItemState( ATTR_FONT_OVERLINE, true, &pItem ) != SfxItemState::SET )
570 280 : pItem = &rSrcSet.Get( ATTR_FONT_OVERLINE );
571 280 : aOverlineItem = *static_cast<const SvxOverlineItem*>(pItem);
572 :
573 280 : if ( pCondSet->GetItemState( ATTR_FONT_WORDLINE, true, &pItem ) != SfxItemState::SET )
574 280 : pItem = &rSrcSet.Get( ATTR_FONT_WORDLINE );
575 280 : bWordLine = static_cast<const SvxWordLineModeItem*>(pItem)->GetValue();
576 :
577 280 : if ( pCondSet->GetItemState( ATTR_FONT_CROSSEDOUT, true, &pItem ) != SfxItemState::SET )
578 280 : pItem = &rSrcSet.Get( ATTR_FONT_CROSSEDOUT );
579 280 : eStrike = (FontStrikeout)static_cast<const SvxCrossedOutItem*>(pItem)->GetValue();
580 :
581 280 : if ( pCondSet->GetItemState( ATTR_FONT_CONTOUR, true, &pItem ) != SfxItemState::SET )
582 280 : pItem = &rSrcSet.Get( ATTR_FONT_CONTOUR );
583 280 : bOutline = static_cast<const SvxContourItem*>(pItem)->GetValue();
584 :
585 280 : if ( pCondSet->GetItemState( ATTR_FONT_SHADOWED, true, &pItem ) != SfxItemState::SET )
586 280 : pItem = &rSrcSet.Get( ATTR_FONT_SHADOWED );
587 280 : bShadow = static_cast<const SvxShadowedItem*>(pItem)->GetValue();
588 :
589 280 : if ( pCondSet->GetItemState( ATTR_FORBIDDEN_RULES, true, &pItem ) != SfxItemState::SET )
590 280 : pItem = &rSrcSet.Get( ATTR_FORBIDDEN_RULES );
591 280 : bForbidden = static_cast<const SvxForbiddenRuleItem*>(pItem)->GetValue();
592 :
593 280 : if ( pCondSet->GetItemState( ATTR_FONT_EMPHASISMARK, true, &pItem ) != SfxItemState::SET )
594 280 : pItem = &rSrcSet.Get( ATTR_FONT_EMPHASISMARK );
595 280 : eEmphasis = static_cast<const SvxEmphasisMarkItem*>(pItem)->GetEmphasisMark();
596 280 : if ( pCondSet->GetItemState( ATTR_FONT_RELIEF, true, &pItem ) != SfxItemState::SET )
597 280 : pItem = &rSrcSet.Get( ATTR_FONT_RELIEF );
598 280 : eRelief = (FontRelief)static_cast<const SvxCharReliefItem*>(pItem)->GetValue();
599 :
600 280 : if ( pCondSet->GetItemState( ATTR_FONT_LANGUAGE, true, &pItem ) != SfxItemState::SET )
601 280 : pItem = &rSrcSet.Get( ATTR_FONT_LANGUAGE );
602 280 : eLang = static_cast<const SvxLanguageItem*>(pItem)->GetLanguage();
603 280 : if ( pCondSet->GetItemState( ATTR_CJK_FONT_LANGUAGE, true, &pItem ) != SfxItemState::SET )
604 280 : pItem = &rSrcSet.Get( ATTR_CJK_FONT_LANGUAGE );
605 280 : eCjkLang = static_cast<const SvxLanguageItem*>(pItem)->GetLanguage();
606 280 : if ( pCondSet->GetItemState( ATTR_CTL_FONT_LANGUAGE, true, &pItem ) != SfxItemState::SET )
607 280 : pItem = &rSrcSet.Get( ATTR_CTL_FONT_LANGUAGE );
608 280 : eCtlLang = static_cast<const SvxLanguageItem*>(pItem)->GetLanguage();
609 :
610 280 : if ( pCondSet->GetItemState( ATTR_HYPHENATE, true, &pItem ) != SfxItemState::SET )
611 280 : pItem = &rSrcSet.Get( ATTR_HYPHENATE );
612 280 : bHyphenate = static_cast<const SfxBoolItem*>(pItem)->GetValue();
613 :
614 280 : if ( pCondSet->GetItemState( ATTR_WRITINGDIR, true, &pItem ) != SfxItemState::SET )
615 280 : pItem = &rSrcSet.Get( ATTR_WRITINGDIR );
616 280 : eDirection = (SvxFrameDirection)static_cast<const SvxFrameDirectionItem*>(pItem)->GetValue();
617 : }
618 : else // alles direkt aus Pattern
619 : {
620 7331 : aColorItem = static_cast<const SvxColorItem&>( rSrcSet.Get( ATTR_FONT_COLOR ) );
621 7331 : aFontItem = static_cast<const SvxFontItem&>( rSrcSet.Get( ATTR_FONT ) );
622 7331 : aCjkFontItem = static_cast<const SvxFontItem&>( rSrcSet.Get( ATTR_CJK_FONT ) );
623 7331 : aCtlFontItem = static_cast<const SvxFontItem&>( rSrcSet.Get( ATTR_CTL_FONT ) );
624 : nTHeight = static_cast<const SvxFontHeightItem&>(
625 7331 : rSrcSet.Get( ATTR_FONT_HEIGHT )).GetHeight();
626 : nCjkTHeight = static_cast<const SvxFontHeightItem&>(
627 7331 : rSrcSet.Get( ATTR_CJK_FONT_HEIGHT )).GetHeight();
628 : nCtlTHeight = static_cast<const SvxFontHeightItem&>(
629 7331 : rSrcSet.Get( ATTR_CTL_FONT_HEIGHT )).GetHeight();
630 : eWeight = (FontWeight)static_cast<const SvxWeightItem&>(
631 7331 : rSrcSet.Get( ATTR_FONT_WEIGHT )).GetValue();
632 : eCjkWeight = (FontWeight)static_cast<const SvxWeightItem&>(
633 7331 : rSrcSet.Get( ATTR_CJK_FONT_WEIGHT )).GetValue();
634 : eCtlWeight = (FontWeight)static_cast<const SvxWeightItem&>(
635 7331 : rSrcSet.Get( ATTR_CTL_FONT_WEIGHT )).GetValue();
636 : eItalic = (FontItalic)static_cast<const SvxPostureItem&>(
637 7331 : rSrcSet.Get( ATTR_FONT_POSTURE )).GetValue();
638 : eCjkItalic = (FontItalic)static_cast<const SvxPostureItem&>(
639 7331 : rSrcSet.Get( ATTR_CJK_FONT_POSTURE )).GetValue();
640 : eCtlItalic = (FontItalic)static_cast<const SvxPostureItem&>(
641 7331 : rSrcSet.Get( ATTR_CTL_FONT_POSTURE )).GetValue();
642 7331 : aUnderlineItem = static_cast<const SvxUnderlineItem&>( rSrcSet.Get( ATTR_FONT_UNDERLINE ) );
643 7331 : aOverlineItem = static_cast<const SvxOverlineItem&>( rSrcSet.Get( ATTR_FONT_OVERLINE ) );
644 : bWordLine = static_cast<const SvxWordLineModeItem&>(
645 7331 : rSrcSet.Get( ATTR_FONT_WORDLINE )).GetValue();
646 : eStrike = (FontStrikeout)static_cast<const SvxCrossedOutItem&>(
647 7331 : rSrcSet.Get( ATTR_FONT_CROSSEDOUT )).GetValue();
648 : bOutline = static_cast<const SvxContourItem&>(
649 7331 : rSrcSet.Get( ATTR_FONT_CONTOUR )).GetValue();
650 : bShadow = static_cast<const SvxShadowedItem&>(
651 7331 : rSrcSet.Get( ATTR_FONT_SHADOWED )).GetValue();
652 : bForbidden = static_cast<const SvxForbiddenRuleItem&>(
653 7331 : rSrcSet.Get( ATTR_FORBIDDEN_RULES )).GetValue();
654 : eEmphasis = static_cast<const SvxEmphasisMarkItem&>(
655 7331 : rSrcSet.Get( ATTR_FONT_EMPHASISMARK )).GetEmphasisMark();
656 : eRelief = (FontRelief)static_cast<const SvxCharReliefItem&>(
657 7331 : rSrcSet.Get( ATTR_FONT_RELIEF )).GetValue();
658 : eLang = static_cast<const SvxLanguageItem&>(
659 7331 : rSrcSet.Get( ATTR_FONT_LANGUAGE )).GetLanguage();
660 : eCjkLang = static_cast<const SvxLanguageItem&>(
661 7331 : rSrcSet.Get( ATTR_CJK_FONT_LANGUAGE )).GetLanguage();
662 : eCtlLang = static_cast<const SvxLanguageItem&>(
663 7331 : rSrcSet.Get( ATTR_CTL_FONT_LANGUAGE )).GetLanguage();
664 : bHyphenate = static_cast<const SfxBoolItem&>(
665 7331 : rSrcSet.Get( ATTR_HYPHENATE )).GetValue();
666 : eDirection = (SvxFrameDirection)static_cast<const SvxFrameDirectionItem&>(
667 7331 : rSrcSet.Get( ATTR_WRITINGDIR )).GetValue();
668 : }
669 :
670 : // kompatibel zu LogicToLogic rechnen, also 2540/1440 = 127/72, und runden
671 :
672 7611 : long nHeight = TwipsToHMM(nTHeight);
673 7611 : long nCjkHeight = TwipsToHMM(nCjkTHeight);
674 7611 : long nCtlHeight = TwipsToHMM(nCtlTHeight);
675 :
676 : // put items into EditEngine ItemSet
677 :
678 7611 : if ( aColorItem.GetValue().GetColor() == COL_AUTO )
679 : {
680 : // When cell attributes are converted to EditEngine paragraph attributes,
681 : // don't create a hard item for automatic color, because that would be converted
682 : // to black when the item's Store method is used in CreateTransferable/WriteBin.
683 : // COL_AUTO is the EditEngine's pool default, so ClearItem will result in automatic
684 : // color, too, without having to store the item.
685 5338 : rEditSet.ClearItem( EE_CHAR_COLOR );
686 : }
687 : else
688 2273 : rEditSet.Put( aColorItem );
689 7611 : rEditSet.Put( aFontItem );
690 7611 : rEditSet.Put( aCjkFontItem );
691 7611 : rEditSet.Put( aCtlFontItem );
692 7611 : rEditSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
693 7611 : rEditSet.Put( SvxFontHeightItem( nCjkHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
694 7611 : rEditSet.Put( SvxFontHeightItem( nCtlHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
695 7611 : rEditSet.Put( SvxWeightItem ( eWeight, EE_CHAR_WEIGHT ) );
696 7611 : rEditSet.Put( SvxWeightItem ( eCjkWeight, EE_CHAR_WEIGHT_CJK ) );
697 7611 : rEditSet.Put( SvxWeightItem ( eCtlWeight, EE_CHAR_WEIGHT_CTL ) );
698 7611 : rEditSet.Put( aUnderlineItem );
699 7611 : rEditSet.Put( aOverlineItem );
700 7611 : rEditSet.Put( SvxWordLineModeItem( bWordLine, EE_CHAR_WLM ) );
701 7611 : rEditSet.Put( SvxCrossedOutItem( eStrike, EE_CHAR_STRIKEOUT ) );
702 7611 : rEditSet.Put( SvxPostureItem ( eItalic, EE_CHAR_ITALIC ) );
703 7611 : rEditSet.Put( SvxPostureItem ( eCjkItalic, EE_CHAR_ITALIC_CJK ) );
704 7611 : rEditSet.Put( SvxPostureItem ( eCtlItalic, EE_CHAR_ITALIC_CTL ) );
705 7611 : rEditSet.Put( SvxContourItem ( bOutline, EE_CHAR_OUTLINE ) );
706 7611 : rEditSet.Put( SvxShadowedItem ( bShadow, EE_CHAR_SHADOW ) );
707 7611 : rEditSet.Put( SfxBoolItem ( EE_PARA_FORBIDDENRULES, bForbidden ) );
708 7611 : rEditSet.Put( SvxEmphasisMarkItem( eEmphasis, EE_CHAR_EMPHASISMARK ) );
709 7611 : rEditSet.Put( SvxCharReliefItem( eRelief, EE_CHAR_RELIEF ) );
710 7611 : rEditSet.Put( SvxLanguageItem ( eLang, EE_CHAR_LANGUAGE ) );
711 7611 : rEditSet.Put( SvxLanguageItem ( eCjkLang, EE_CHAR_LANGUAGE_CJK ) );
712 7611 : rEditSet.Put( SvxLanguageItem ( eCtlLang, EE_CHAR_LANGUAGE_CTL ) );
713 7611 : rEditSet.Put( SfxBoolItem ( EE_PARA_HYPHENATE, bHyphenate ) );
714 7611 : rEditSet.Put( SvxFrameDirectionItem( eDirection, EE_PARA_WRITINGDIR ) );
715 :
716 : // Script spacing is always off.
717 : // The cell attribute isn't used here as long as there is no UI to set it
718 : // (don't evaluate attributes that can't be changed).
719 : // If a locale-dependent default is needed, it has to go into the cell
720 : // style, like the fonts.
721 15222 : rEditSet.Put( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
722 7611 : }
723 :
724 7401 : void ScPatternAttr::FillEditItemSet( SfxItemSet* pEditSet, const SfxItemSet* pCondSet ) const
725 : {
726 7401 : if( pEditSet )
727 7401 : FillToEditItemSet( *pEditSet, GetItemSet(), pCondSet );
728 7401 : }
729 :
730 470 : void ScPatternAttr::GetFromEditItemSet( SfxItemSet& rDestSet, const SfxItemSet& rEditSet )
731 : {
732 : const SfxPoolItem* pItem;
733 :
734 470 : if (rEditSet.GetItemState(EE_CHAR_COLOR,true,&pItem) == SfxItemState::SET)
735 418 : rDestSet.Put( SvxColorItem(ATTR_FONT_COLOR) = *static_cast<const SvxColorItem*>(pItem) );
736 :
737 470 : if (rEditSet.GetItemState(EE_CHAR_FONTINFO,true,&pItem) == SfxItemState::SET)
738 428 : rDestSet.Put( SvxFontItem(ATTR_FONT) = *static_cast<const SvxFontItem*>(pItem) );
739 470 : if (rEditSet.GetItemState(EE_CHAR_FONTINFO_CJK,true,&pItem) == SfxItemState::SET)
740 368 : rDestSet.Put( SvxFontItem(ATTR_CJK_FONT) = *static_cast<const SvxFontItem*>(pItem) );
741 470 : if (rEditSet.GetItemState(EE_CHAR_FONTINFO_CTL,true,&pItem) == SfxItemState::SET)
742 370 : rDestSet.Put( SvxFontItem(ATTR_CTL_FONT) = *static_cast<const SvxFontItem*>(pItem) );
743 :
744 470 : if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT,true,&pItem) == SfxItemState::SET)
745 414 : rDestSet.Put( SvxFontHeightItem( HMMToTwips( static_cast<const SvxFontHeightItem*>(pItem)->GetHeight() ),
746 414 : 100, ATTR_FONT_HEIGHT ) );
747 470 : if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT_CJK,true,&pItem) == SfxItemState::SET)
748 342 : rDestSet.Put( SvxFontHeightItem( HMMToTwips( static_cast<const SvxFontHeightItem*>(pItem)->GetHeight() ),
749 342 : 100, ATTR_CJK_FONT_HEIGHT ) );
750 470 : if (rEditSet.GetItemState(EE_CHAR_FONTHEIGHT_CTL,true,&pItem) == SfxItemState::SET)
751 342 : rDestSet.Put( SvxFontHeightItem( HMMToTwips( static_cast<const SvxFontHeightItem*>(pItem)->GetHeight() ),
752 342 : 100, ATTR_CTL_FONT_HEIGHT ) );
753 :
754 470 : if (rEditSet.GetItemState(EE_CHAR_WEIGHT,true,&pItem) == SfxItemState::SET)
755 410 : rDestSet.Put( SvxWeightItem( (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue(),
756 410 : ATTR_FONT_WEIGHT) );
757 470 : if (rEditSet.GetItemState(EE_CHAR_WEIGHT_CJK,true,&pItem) == SfxItemState::SET)
758 376 : rDestSet.Put( SvxWeightItem( (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue(),
759 376 : ATTR_CJK_FONT_WEIGHT) );
760 470 : if (rEditSet.GetItemState(EE_CHAR_WEIGHT_CTL,true,&pItem) == SfxItemState::SET)
761 374 : rDestSet.Put( SvxWeightItem( (FontWeight)static_cast<const SvxWeightItem*>(pItem)->GetValue(),
762 374 : ATTR_CTL_FONT_WEIGHT) );
763 :
764 : // SvxTextLineItem contains enum and color
765 470 : if (rEditSet.GetItemState(EE_CHAR_UNDERLINE,true,&pItem) == SfxItemState::SET)
766 412 : rDestSet.Put( SvxUnderlineItem(UNDERLINE_NONE,ATTR_FONT_UNDERLINE) = *static_cast<const SvxUnderlineItem*>(pItem) );
767 470 : if (rEditSet.GetItemState(EE_CHAR_OVERLINE,true,&pItem) == SfxItemState::SET)
768 312 : rDestSet.Put( SvxOverlineItem(UNDERLINE_NONE,ATTR_FONT_OVERLINE) = *static_cast<const SvxOverlineItem*>(pItem) );
769 470 : if (rEditSet.GetItemState(EE_CHAR_WLM,true,&pItem) == SfxItemState::SET)
770 396 : rDestSet.Put( SvxWordLineModeItem( static_cast<const SvxWordLineModeItem*>(pItem)->GetValue(),
771 396 : ATTR_FONT_WORDLINE) );
772 :
773 470 : if (rEditSet.GetItemState(EE_CHAR_STRIKEOUT,true,&pItem) == SfxItemState::SET)
774 400 : rDestSet.Put( SvxCrossedOutItem( (FontStrikeout)static_cast<const SvxCrossedOutItem*>(pItem)->GetValue(),
775 400 : ATTR_FONT_CROSSEDOUT) );
776 :
777 470 : if (rEditSet.GetItemState(EE_CHAR_ITALIC,true,&pItem) == SfxItemState::SET)
778 408 : rDestSet.Put( SvxPostureItem( (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue(),
779 408 : ATTR_FONT_POSTURE) );
780 470 : if (rEditSet.GetItemState(EE_CHAR_ITALIC_CJK,true,&pItem) == SfxItemState::SET)
781 362 : rDestSet.Put( SvxPostureItem( (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue(),
782 362 : ATTR_CJK_FONT_POSTURE) );
783 470 : if (rEditSet.GetItemState(EE_CHAR_ITALIC_CTL,true,&pItem) == SfxItemState::SET)
784 322 : rDestSet.Put( SvxPostureItem( (FontItalic)static_cast<const SvxPostureItem*>(pItem)->GetValue(),
785 322 : ATTR_CTL_FONT_POSTURE) );
786 :
787 470 : if (rEditSet.GetItemState(EE_CHAR_OUTLINE,true,&pItem) == SfxItemState::SET)
788 388 : rDestSet.Put( SvxContourItem( static_cast<const SvxContourItem*>(pItem)->GetValue(),
789 388 : ATTR_FONT_CONTOUR) );
790 470 : if (rEditSet.GetItemState(EE_CHAR_SHADOW,true,&pItem) == SfxItemState::SET)
791 390 : rDestSet.Put( SvxShadowedItem( static_cast<const SvxShadowedItem*>(pItem)->GetValue(),
792 390 : ATTR_FONT_SHADOWED) );
793 470 : if (rEditSet.GetItemState(EE_CHAR_EMPHASISMARK,true,&pItem) == SfxItemState::SET)
794 386 : rDestSet.Put( SvxEmphasisMarkItem( static_cast<const SvxEmphasisMarkItem*>(pItem)->GetEmphasisMark(),
795 386 : ATTR_FONT_EMPHASISMARK) );
796 470 : if (rEditSet.GetItemState(EE_CHAR_RELIEF,true,&pItem) == SfxItemState::SET)
797 384 : rDestSet.Put( SvxCharReliefItem( (FontRelief)static_cast<const SvxCharReliefItem*>(pItem)->GetValue(),
798 384 : ATTR_FONT_RELIEF) );
799 :
800 470 : if (rEditSet.GetItemState(EE_CHAR_LANGUAGE,true,&pItem) == SfxItemState::SET)
801 392 : rDestSet.Put( SvxLanguageItem(static_cast<const SvxLanguageItem*>(pItem)->GetValue(), ATTR_FONT_LANGUAGE) );
802 470 : if (rEditSet.GetItemState(EE_CHAR_LANGUAGE_CJK,true,&pItem) == SfxItemState::SET)
803 366 : rDestSet.Put( SvxLanguageItem(static_cast<const SvxLanguageItem*>(pItem)->GetValue(), ATTR_CJK_FONT_LANGUAGE) );
804 470 : if (rEditSet.GetItemState(EE_CHAR_LANGUAGE_CTL,true,&pItem) == SfxItemState::SET)
805 362 : rDestSet.Put( SvxLanguageItem(static_cast<const SvxLanguageItem*>(pItem)->GetValue(), ATTR_CTL_FONT_LANGUAGE) );
806 :
807 470 : if (rEditSet.GetItemState(EE_PARA_JUST,true,&pItem) == SfxItemState::SET)
808 : {
809 : SvxCellHorJustify eVal;
810 112 : switch ( static_cast<const SvxAdjustItem*>(pItem)->GetAdjust() )
811 : {
812 : case SVX_ADJUST_LEFT:
813 : // EditEngine Default ist bei dem GetAttribs() ItemSet
814 : // immer gesetzt!
815 : // ob links oder rechts entscheiden wir selbst bei Text/Zahl
816 112 : eVal = SVX_HOR_JUSTIFY_STANDARD;
817 112 : break;
818 : case SVX_ADJUST_RIGHT:
819 0 : eVal = SVX_HOR_JUSTIFY_RIGHT;
820 0 : break;
821 : case SVX_ADJUST_BLOCK:
822 0 : eVal = SVX_HOR_JUSTIFY_BLOCK;
823 0 : break;
824 : case SVX_ADJUST_CENTER:
825 0 : eVal = SVX_HOR_JUSTIFY_CENTER;
826 0 : break;
827 : case SVX_ADJUST_BLOCKLINE:
828 0 : eVal = SVX_HOR_JUSTIFY_BLOCK;
829 0 : break;
830 : case SVX_ADJUST_END:
831 0 : eVal = SVX_HOR_JUSTIFY_RIGHT;
832 0 : break;
833 : default:
834 0 : eVal = SVX_HOR_JUSTIFY_STANDARD;
835 : }
836 112 : if ( eVal != SVX_HOR_JUSTIFY_STANDARD )
837 0 : rDestSet.Put( SvxHorJustifyItem( eVal, ATTR_HOR_JUSTIFY) );
838 : }
839 470 : }
840 :
841 358 : void ScPatternAttr::GetFromEditItemSet( const SfxItemSet* pEditSet )
842 : {
843 358 : if( pEditSet )
844 358 : GetFromEditItemSet( GetItemSet(), *pEditSet );
845 358 : }
846 :
847 122 : void ScPatternAttr::FillEditParaItems( SfxItemSet* pEditSet ) const
848 : {
849 : // in GetFromEditItemSet schon dabei, in FillEditItemSet aber nicht
850 : // Hor. Ausrichtung Standard wird immer als "links" umgesetzt
851 :
852 122 : const SfxItemSet& rMySet = GetItemSet();
853 :
854 : SvxCellHorJustify eHorJust = (SvxCellHorJustify)
855 122 : static_cast<const SvxHorJustifyItem&>(rMySet.Get(ATTR_HOR_JUSTIFY)).GetValue();
856 :
857 : SvxAdjust eSvxAdjust;
858 122 : switch (eHorJust)
859 : {
860 4 : case SVX_HOR_JUSTIFY_RIGHT: eSvxAdjust = SVX_ADJUST_RIGHT; break;
861 0 : case SVX_HOR_JUSTIFY_CENTER: eSvxAdjust = SVX_ADJUST_CENTER; break;
862 0 : case SVX_HOR_JUSTIFY_BLOCK: eSvxAdjust = SVX_ADJUST_BLOCK; break;
863 118 : default: eSvxAdjust = SVX_ADJUST_LEFT; break;
864 : }
865 122 : pEditSet->Put( SvxAdjustItem( eSvxAdjust, EE_PARA_JUST ) );
866 122 : }
867 :
868 346 : void ScPatternAttr::DeleteUnchanged( const ScPatternAttr* pOldAttrs )
869 : {
870 346 : SfxItemSet& rThisSet = GetItemSet();
871 346 : const SfxItemSet& rOldSet = pOldAttrs->GetItemSet();
872 :
873 : const SfxPoolItem* pThisItem;
874 : const SfxPoolItem* pOldItem;
875 :
876 19722 : for ( sal_uInt16 nSubWhich=ATTR_PATTERN_START; nSubWhich<=ATTR_PATTERN_END; nSubWhich++ )
877 : {
878 : // only items that are set are interesting
879 19376 : if ( rThisSet.GetItemState( nSubWhich, false, &pThisItem ) == SfxItemState::SET )
880 : {
881 6146 : SfxItemState eOldState = rOldSet.GetItemState( nSubWhich, true, &pOldItem );
882 6146 : if ( eOldState == SfxItemState::SET )
883 : {
884 : // item is set in OldAttrs (or its parent) -> compare pointers
885 5812 : if ( pThisItem == pOldItem )
886 5652 : rThisSet.ClearItem( nSubWhich );
887 : }
888 334 : else if ( eOldState != SfxItemState::DONTCARE )
889 : {
890 : // not set in OldAttrs -> compare item value to default item
891 334 : if ( *pThisItem == rThisSet.GetPool()->GetDefaultItem( nSubWhich ) )
892 268 : rThisSet.ClearItem( nSubWhich );
893 : }
894 : }
895 : }
896 346 : }
897 :
898 506 : bool ScPatternAttr::HasItemsSet( const sal_uInt16* pWhich ) const
899 : {
900 506 : const SfxItemSet& rSet = GetItemSet();
901 1012 : for (sal_uInt16 i=0; pWhich[i]; i++)
902 506 : if ( rSet.GetItemState( pWhich[i], false ) == SfxItemState::SET )
903 0 : return true;
904 506 : return false;
905 : }
906 :
907 0 : void ScPatternAttr::ClearItems( const sal_uInt16* pWhich )
908 : {
909 0 : SfxItemSet& rSet = GetItemSet();
910 0 : for (sal_uInt16 i=0; pWhich[i]; i++)
911 0 : rSet.ClearItem(pWhich[i]);
912 0 : }
913 :
914 140 : static SfxStyleSheetBase* lcl_CopyStyleToPool
915 : (
916 : SfxStyleSheetBase* pSrcStyle,
917 : SfxStyleSheetBasePool* pSrcPool,
918 : SfxStyleSheetBasePool* pDestPool,
919 : const SvNumberFormatterIndexTable* pFormatExchangeList
920 : )
921 : {
922 140 : if ( !pSrcStyle || !pDestPool || !pSrcPool )
923 : {
924 : OSL_FAIL( "CopyStyleToPool: Invalid Arguments :-/" );
925 0 : return NULL;
926 : }
927 :
928 140 : const OUString aStrSrcStyle = pSrcStyle->GetName();
929 140 : const SfxStyleFamily eFamily = pSrcStyle->GetFamily();
930 140 : SfxStyleSheetBase* pDestStyle = pDestPool->Find( aStrSrcStyle, eFamily );
931 :
932 140 : if ( !pDestStyle )
933 : {
934 2 : const OUString aStrParent = pSrcStyle->GetParent();
935 2 : const SfxItemSet& rSrcSet = pSrcStyle->GetItemSet();
936 :
937 2 : pDestStyle = &pDestPool->Make( aStrSrcStyle, eFamily, SFXSTYLEBIT_USERDEF );
938 2 : SfxItemSet& rDestSet = pDestStyle->GetItemSet();
939 2 : rDestSet.Put( rSrcSet );
940 :
941 : // number format exchange list has to be handled here, too
942 : // (only called for cell styles)
943 :
944 : const SfxPoolItem* pSrcItem;
945 2 : if ( pFormatExchangeList &&
946 0 : rSrcSet.GetItemState( ATTR_VALUE_FORMAT, false, &pSrcItem ) == SfxItemState::SET )
947 : {
948 0 : sal_uLong nOldFormat = static_cast<const SfxUInt32Item*>(pSrcItem)->GetValue();
949 0 : SvNumberFormatterIndexTable::const_iterator it = pFormatExchangeList->find(nOldFormat);
950 0 : if (it != pFormatExchangeList->end())
951 : {
952 0 : sal_uInt32 nNewFormat = it->second;
953 0 : rDestSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
954 : }
955 : }
956 :
957 : // ggF. abgeleitete Styles erzeugen, wenn nicht vorhanden:
958 :
959 4 : if ( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) != aStrParent &&
960 2 : aStrSrcStyle != aStrParent &&
961 0 : !pDestPool->Find( aStrParent, eFamily ) )
962 : {
963 0 : lcl_CopyStyleToPool( pSrcPool->Find( aStrParent, eFamily ),
964 0 : pSrcPool, pDestPool, pFormatExchangeList );
965 : }
966 :
967 2 : pDestStyle->SetParent( aStrParent );
968 : }
969 :
970 140 : return pDestStyle;
971 : }
972 :
973 140 : ScPatternAttr* ScPatternAttr::PutInPool( ScDocument* pDestDoc, ScDocument* pSrcDoc ) const
974 : {
975 140 : const SfxItemSet* pSrcSet = &GetItemSet();
976 :
977 140 : ScPatternAttr* pDestPattern = new ScPatternAttr(pDestDoc->GetPool());
978 140 : SfxItemSet* pDestSet = &pDestPattern->GetItemSet();
979 :
980 : // Zellformatvorlage in anderes Dokument kopieren:
981 :
982 140 : if ( pDestDoc != pSrcDoc )
983 : {
984 : OSL_ENSURE( pStyle, "Missing Pattern-Style! :-/" );
985 :
986 : // wenn Vorlage im DestDoc vorhanden, dieses benutzen, sonst Style
987 : // mit Parent-Vorlagen kopieren/ggF. erzeugen und dem DestDoc hinzufuegen
988 :
989 : SfxStyleSheetBase* pStyleCpy = lcl_CopyStyleToPool( pStyle,
990 140 : pSrcDoc->GetStyleSheetPool(),
991 140 : pDestDoc->GetStyleSheetPool(),
992 280 : pDestDoc->GetFormatExchangeList() );
993 :
994 140 : pDestPattern->SetStyleSheet( static_cast<ScStyleSheet*>(pStyleCpy) );
995 : }
996 :
997 7980 : for ( sal_uInt16 nAttrId = ATTR_PATTERN_START; nAttrId <= ATTR_PATTERN_END; nAttrId++ )
998 : {
999 : const SfxPoolItem* pSrcItem;
1000 7840 : SfxItemState eItemState = pSrcSet->GetItemState( nAttrId, false, &pSrcItem );
1001 7840 : if (eItemState==SfxItemState::SET)
1002 : {
1003 0 : SfxPoolItem* pNewItem = NULL;
1004 :
1005 0 : if ( nAttrId == ATTR_VALIDDATA )
1006 : {
1007 : // Gueltigkeit ins neue Dokument kopieren
1008 :
1009 0 : sal_uLong nNewIndex = 0;
1010 0 : ScValidationDataList* pSrcList = pSrcDoc->GetValidationList();
1011 0 : if ( pSrcList )
1012 : {
1013 0 : sal_uLong nOldIndex = static_cast<const SfxUInt32Item*>(pSrcItem)->GetValue();
1014 0 : const ScValidationData* pOldData = pSrcList->GetData( nOldIndex );
1015 0 : if ( pOldData )
1016 0 : nNewIndex = pDestDoc->AddValidationEntry( *pOldData );
1017 : }
1018 0 : pNewItem = new SfxUInt32Item( ATTR_VALIDDATA, nNewIndex );
1019 : }
1020 0 : else if ( nAttrId == ATTR_VALUE_FORMAT && pDestDoc->GetFormatExchangeList() )
1021 : {
1022 : // Zahlformate nach Exchange-Liste
1023 :
1024 0 : sal_uLong nOldFormat = static_cast<const SfxUInt32Item*>(pSrcItem)->GetValue();
1025 0 : SvNumberFormatterIndexTable::const_iterator it = pDestDoc->GetFormatExchangeList()->find(nOldFormat);
1026 0 : if (it != pDestDoc->GetFormatExchangeList()->end())
1027 : {
1028 0 : sal_uInt32 nNewFormat = it->second;
1029 0 : pNewItem = new SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat );
1030 : }
1031 : }
1032 :
1033 0 : if ( pNewItem )
1034 : {
1035 0 : pDestSet->Put(*pNewItem);
1036 0 : delete pNewItem;
1037 : }
1038 : else
1039 0 : pDestSet->Put(*pSrcItem);
1040 : }
1041 : }
1042 :
1043 : ScPatternAttr* pPatternAttr =
1044 140 : const_cast<ScPatternAttr*>( static_cast<const ScPatternAttr*>( &pDestDoc->GetPool()->Put(*pDestPattern) ) );
1045 140 : delete pDestPattern;
1046 140 : return pPatternAttr;
1047 : }
1048 :
1049 7802 : bool ScPatternAttr::IsVisible() const
1050 : {
1051 7802 : const SfxItemSet& rSet = GetItemSet();
1052 :
1053 : const SfxPoolItem* pItem;
1054 : SfxItemState eState;
1055 :
1056 7802 : eState = rSet.GetItemState( ATTR_BACKGROUND, true, &pItem );
1057 7802 : if ( eState == SfxItemState::SET )
1058 6886 : if ( static_cast<const SvxBrushItem*>(pItem)->GetColor().GetColor() != COL_TRANSPARENT )
1059 6808 : return true;
1060 :
1061 994 : eState = rSet.GetItemState( ATTR_BORDER, true, &pItem );
1062 994 : if ( eState == SfxItemState::SET )
1063 : {
1064 714 : const SvxBoxItem* pBoxItem = static_cast<const SvxBoxItem*>(pItem);
1065 1532 : if ( pBoxItem->GetTop() || pBoxItem->GetBottom() ||
1066 818 : pBoxItem->GetLeft() || pBoxItem->GetRight() )
1067 662 : return true;
1068 : }
1069 :
1070 332 : eState = rSet.GetItemState( ATTR_BORDER_TLBR, true, &pItem );
1071 332 : if ( eState == SfxItemState::SET )
1072 52 : if( static_cast< const SvxLineItem* >( pItem )->GetLine() )
1073 0 : return true;
1074 :
1075 332 : eState = rSet.GetItemState( ATTR_BORDER_BLTR, true, &pItem );
1076 332 : if ( eState == SfxItemState::SET )
1077 52 : if( static_cast< const SvxLineItem* >( pItem )->GetLine() )
1078 0 : return true;
1079 :
1080 332 : eState = rSet.GetItemState( ATTR_SHADOW, true, &pItem );
1081 332 : if ( eState == SfxItemState::SET )
1082 0 : if ( static_cast<const SvxShadowItem*>(pItem)->GetLocation() != SVX_SHADOW_NONE )
1083 0 : return true;
1084 :
1085 332 : return false;
1086 : }
1087 :
1088 2089172 : inline bool OneEqual( const SfxItemSet& rSet1, const SfxItemSet& rSet2, sal_uInt16 nId )
1089 : {
1090 2089172 : const SfxPoolItem* pItem1 = &rSet1.Get(nId);
1091 2089172 : const SfxPoolItem* pItem2 = &rSet2.Get(nId);
1092 2089172 : return ( pItem1 == pItem2 || *pItem1 == *pItem2 );
1093 : }
1094 :
1095 422990 : bool ScPatternAttr::IsVisibleEqual( const ScPatternAttr& rOther ) const
1096 : {
1097 422990 : const SfxItemSet& rThisSet = GetItemSet();
1098 422990 : const SfxItemSet& rOtherSet = rOther.GetItemSet();
1099 :
1100 845324 : return OneEqual( rThisSet, rOtherSet, ATTR_BACKGROUND ) &&
1101 836950 : OneEqual( rThisSet, rOtherSet, ATTR_BORDER ) &&
1102 829232 : OneEqual( rThisSet, rOtherSet, ATTR_BORDER_TLBR ) &&
1103 1252222 : OneEqual( rThisSet, rOtherSet, ATTR_BORDER_BLTR ) &&
1104 837606 : OneEqual( rThisSet, rOtherSet, ATTR_SHADOW );
1105 :
1106 : //! auch hier nur wirklich sichtbare Werte testen !!!
1107 : }
1108 :
1109 1924524 : const OUString* ScPatternAttr::GetStyleName() const
1110 : {
1111 1924524 : return pName ? pName : ( pStyle ? &pStyle->GetName() : NULL );
1112 : }
1113 :
1114 665650 : void ScPatternAttr::SetStyleSheet( ScStyleSheet* pNewStyle, bool bClearDirectFormat )
1115 : {
1116 665650 : if (pNewStyle)
1117 : {
1118 665650 : SfxItemSet& rPatternSet = GetItemSet();
1119 665650 : const SfxItemSet& rStyleSet = pNewStyle->GetItemSet();
1120 :
1121 665650 : if (bClearDirectFormat)
1122 : {
1123 24377418 : for (sal_uInt16 i=ATTR_PATTERN_START; i<=ATTR_PATTERN_END; i++)
1124 : {
1125 23949744 : if (rStyleSet.GetItemState(i, true) == SfxItemState::SET)
1126 2314836 : rPatternSet.ClearItem(i);
1127 : }
1128 : }
1129 665650 : rPatternSet.SetParent(&pNewStyle->GetItemSet());
1130 665650 : pStyle = pNewStyle;
1131 665650 : DELETEZ( pName );
1132 : }
1133 : else
1134 : {
1135 : OSL_FAIL( "ScPatternAttr::SetStyleSheet( NULL ) :-|" );
1136 0 : GetItemSet().SetParent(NULL);
1137 0 : pStyle = NULL;
1138 : }
1139 665650 : }
1140 :
1141 952 : void ScPatternAttr::UpdateStyleSheet(ScDocument* pDoc)
1142 : {
1143 952 : if (pName)
1144 : {
1145 952 : pStyle = static_cast<ScStyleSheet*>(pDoc->GetStyleSheetPool()->Find(*pName, SFX_STYLE_FAMILY_PARA));
1146 :
1147 : // wenn Style nicht gefunden, Standard nehmen,
1148 : // damit keine leere Anzeige im Toolbox-Controller
1149 : //! es wird vorausgesetzt, dass "Standard" immer der erste Eintrag ist!
1150 952 : if (!pStyle)
1151 : {
1152 0 : SfxStyleSheetIteratorPtr pIter = pDoc->GetStyleSheetPool()->CreateIterator( SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_ALL );
1153 0 : pStyle = dynamic_cast< ScStyleSheet* >(pIter->First());
1154 : }
1155 :
1156 952 : if (pStyle)
1157 : {
1158 952 : GetItemSet().SetParent(&pStyle->GetItemSet());
1159 952 : DELETEZ( pName );
1160 : }
1161 : }
1162 : else
1163 0 : pStyle = NULL;
1164 952 : }
1165 :
1166 0 : void ScPatternAttr::StyleToName()
1167 : {
1168 : // Style wurde geloescht, Namen merken:
1169 :
1170 0 : if ( pStyle )
1171 : {
1172 0 : if ( pName )
1173 0 : *pName = pStyle->GetName();
1174 : else
1175 0 : pName = new OUString( pStyle->GetName() );
1176 :
1177 0 : pStyle = NULL;
1178 0 : GetItemSet().SetParent( NULL );
1179 : }
1180 0 : }
1181 :
1182 0 : bool ScPatternAttr::IsSymbolFont() const
1183 : {
1184 : const SfxPoolItem* pItem;
1185 0 : if( GetItemSet().GetItemState( ATTR_FONT, true, &pItem ) == SfxItemState::SET )
1186 0 : return static_cast<const SvxFontItem*>(pItem)->GetCharSet() == RTL_TEXTENCODING_SYMBOL;
1187 : else
1188 0 : return false;
1189 : }
1190 :
1191 105815 : sal_uLong ScPatternAttr::GetNumberFormat( SvNumberFormatter* pFormatter ) const
1192 : {
1193 : sal_uLong nFormat =
1194 105815 : static_cast<const SfxUInt32Item*>(&GetItemSet().Get( ATTR_VALUE_FORMAT ))->GetValue();
1195 : LanguageType eLang =
1196 105815 : static_cast<const SvxLanguageItem*>(&GetItemSet().Get( ATTR_LANGUAGE_FORMAT ))->GetLanguage();
1197 105815 : if ( nFormat < SV_COUNTRY_LANGUAGE_OFFSET && eLang == LANGUAGE_SYSTEM )
1198 : ; // es bleibt wie es ist
1199 936 : else if ( pFormatter )
1200 936 : nFormat = pFormatter->GetFormatForLanguageIfBuiltIn( nFormat, eLang );
1201 105815 : return nFormat;
1202 : }
1203 :
1204 : // dasselbe, wenn bedingte Formatierung im Spiel ist:
1205 :
1206 82136 : sal_uLong ScPatternAttr::GetNumberFormat( SvNumberFormatter* pFormatter,
1207 : const SfxItemSet* pCondSet ) const
1208 : {
1209 : OSL_ENSURE(pFormatter,"GetNumberFormat without Formatter");
1210 :
1211 : const SfxPoolItem* pFormItem;
1212 82136 : if ( !pCondSet || pCondSet->GetItemState(ATTR_VALUE_FORMAT,true,&pFormItem) != SfxItemState::SET )
1213 81610 : pFormItem = &GetItemSet().Get(ATTR_VALUE_FORMAT);
1214 :
1215 : const SfxPoolItem* pLangItem;
1216 82136 : if ( !pCondSet || pCondSet->GetItemState(ATTR_LANGUAGE_FORMAT,true,&pLangItem) != SfxItemState::SET )
1217 81896 : pLangItem = &GetItemSet().Get(ATTR_LANGUAGE_FORMAT);
1218 :
1219 : return pFormatter->GetFormatForLanguageIfBuiltIn(
1220 : static_cast<const SfxUInt32Item*>(pFormItem)->GetValue(),
1221 82136 : static_cast<const SvxLanguageItem*>(pLangItem)->GetLanguage() );
1222 : }
1223 :
1224 7929547 : const SfxPoolItem& ScPatternAttr::GetItem( sal_uInt16 nWhich, const SfxItemSet& rItemSet, const SfxItemSet* pCondSet )
1225 : {
1226 : const SfxPoolItem* pCondItem;
1227 7929547 : if ( pCondSet && pCondSet->GetItemState( nWhich, true, &pCondItem ) == SfxItemState::SET )
1228 4 : return *pCondItem;
1229 7929543 : return rItemSet.Get(nWhich);
1230 : }
1231 :
1232 1301453 : const SfxPoolItem& ScPatternAttr::GetItem( sal_uInt16 nSubWhich, const SfxItemSet* pCondSet ) const
1233 : {
1234 1301453 : return GetItem( nSubWhich, GetItemSet(), pCondSet );
1235 : }
1236 :
1237 : // GetRotateVal testet vorher ATTR_ORIENTATION
1238 :
1239 609400 : long ScPatternAttr::GetRotateVal( const SfxItemSet* pCondSet ) const
1240 : {
1241 609400 : long nAttrRotate = 0;
1242 609400 : if ( GetCellOrientation() == SVX_ORIENTATION_STANDARD )
1243 : {
1244 608144 : bool bRepeat = ( static_cast<const SvxHorJustifyItem&>(GetItem(ATTR_HOR_JUSTIFY, pCondSet)).
1245 608144 : GetValue() == SVX_HOR_JUSTIFY_REPEAT );
1246 : // ignore orientation/rotation if "repeat" is active
1247 608144 : if ( !bRepeat )
1248 608144 : nAttrRotate = static_cast<const SfxInt32Item&>(GetItem( ATTR_ROTATE_VALUE, pCondSet )).GetValue();
1249 : }
1250 609400 : return nAttrRotate;
1251 : }
1252 :
1253 609400 : sal_uInt8 ScPatternAttr::GetRotateDir( const SfxItemSet* pCondSet ) const
1254 : {
1255 609400 : sal_uInt8 nRet = SC_ROTDIR_NONE;
1256 :
1257 609400 : long nAttrRotate = GetRotateVal( pCondSet );
1258 609400 : if ( nAttrRotate )
1259 : {
1260 : SvxRotateMode eRotMode = (SvxRotateMode)static_cast<const SvxRotateModeItem&>(
1261 1064 : GetItem(ATTR_ROTATE_MODE, pCondSet)).GetValue();
1262 :
1263 1064 : if ( eRotMode == SVX_ROTATE_MODE_STANDARD || nAttrRotate == 18000 )
1264 1064 : nRet = SC_ROTDIR_STANDARD;
1265 0 : else if ( eRotMode == SVX_ROTATE_MODE_CENTER )
1266 0 : nRet = SC_ROTDIR_CENTER;
1267 0 : else if ( eRotMode == SVX_ROTATE_MODE_TOP || eRotMode == SVX_ROTATE_MODE_BOTTOM )
1268 : {
1269 0 : long nRot180 = nAttrRotate % 18000; // 1/100 Grad
1270 0 : if ( nRot180 == 9000 )
1271 0 : nRet = SC_ROTDIR_CENTER;
1272 0 : else if ( ( eRotMode == SVX_ROTATE_MODE_TOP && nRot180 < 9000 ) ||
1273 0 : ( eRotMode == SVX_ROTATE_MODE_BOTTOM && nRot180 > 9000 ) )
1274 0 : nRet = SC_ROTDIR_LEFT;
1275 : else
1276 0 : nRet = SC_ROTDIR_RIGHT;
1277 : }
1278 : }
1279 :
1280 609400 : return nRet;
1281 228 : }
1282 :
1283 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
