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