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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>
21 : #include <com/sun/star/beans/XPropertySet.hpp>
22 : #include <com/sun/star/container/XNameAccess.hpp>
23 :
24 : #include "scitems.hxx"
25 : #include <editeng/borderline.hxx>
26 : #include <editeng/eeitem.hxx>
27 :
28 : #include <sfx2/app.hxx>
29 : #include <sfx2/viewfrm.hxx>
30 : #include <sfx2/bindings.hxx>
31 : #include <sfx2/objface.hxx>
32 : #include <sfx2/request.hxx>
33 : #include <svl/whiter.hxx>
34 : #include <vcl/msgbox.hxx>
35 :
36 : #include <svl/stritem.hxx>
37 : #include <svl/zformat.hxx>
38 : #include <svl/languageoptions.hxx>
39 : #include <editeng/boxitem.hxx>
40 : #include <editeng/langitem.hxx>
41 : #include <svx/numinf.hxx>
42 : #include <sfx2/dispatch.hxx>
43 : #include <sfx2/templdlg.hxx>
44 : #include <sfx2/tplpitem.hxx>
45 : #include <editeng/svxenum.hxx>
46 : #include <svx/algitem.hxx>
47 : #include <editeng/wghtitem.hxx>
48 : #include <editeng/postitem.hxx>
49 : #include <editeng/udlnitem.hxx>
50 : #include <editeng/lineitem.hxx>
51 : #include <editeng/colritem.hxx>
52 : #include <editeng/brushitem.hxx>
53 : #include <editeng/frmdiritem.hxx>
54 : #include <editeng/scripttypeitem.hxx>
55 : #include <svtools/colorcfg.hxx>
56 : #include <editeng/shaditem.hxx>
57 : #include <editeng/justifyitem.hxx>
58 :
59 : #include "formatsh.hxx"
60 : #include "sc.hrc"
61 : #include "globstr.hrc"
62 : #include "docsh.hxx"
63 : #include "patattr.hxx"
64 : #include "scmod.hxx"
65 : #include "stlpool.hxx"
66 : #include "stlsheet.hxx"
67 : #include "printfun.hxx"
68 : #include "docpool.hxx"
69 : #include "scresid.hxx"
70 : #include "tabvwsh.hxx"
71 : #include "undostyl.hxx"
72 : #include "markdata.hxx"
73 : #include "markarr.hxx"
74 :
75 : #define ScFormatShell
76 : #define TableFont
77 : #define FormatForSelection
78 : #include "scslots.hxx"
79 :
80 : #include "scabstdlg.hxx"
81 : #include <editeng/fontitem.hxx>
82 :
83 : #include <boost/scoped_ptr.hpp>
84 :
85 : using namespace ::com::sun::star;
86 :
87 : namespace {
88 :
89 0 : SvxCellHorJustify lclConvertSlotToHAlign( sal_uInt16 nSlot )
90 : {
91 0 : SvxCellHorJustify eHJustify = SVX_HOR_JUSTIFY_STANDARD;
92 0 : switch( nSlot )
93 : {
94 0 : case SID_ALIGN_ANY_HDEFAULT: eHJustify = SVX_HOR_JUSTIFY_STANDARD; break;
95 0 : case SID_ALIGN_ANY_LEFT: eHJustify = SVX_HOR_JUSTIFY_LEFT; break;
96 0 : case SID_ALIGN_ANY_HCENTER: eHJustify = SVX_HOR_JUSTIFY_CENTER; break;
97 0 : case SID_ALIGN_ANY_RIGHT: eHJustify = SVX_HOR_JUSTIFY_RIGHT; break;
98 0 : case SID_ALIGN_ANY_JUSTIFIED: eHJustify = SVX_HOR_JUSTIFY_BLOCK; break;
99 : default: OSL_FAIL( "lclConvertSlotToHAlign - invalid slot" );
100 : }
101 0 : return eHJustify;
102 : }
103 :
104 0 : SvxCellVerJustify lclConvertSlotToVAlign( sal_uInt16 nSlot )
105 : {
106 0 : SvxCellVerJustify eVJustify = SVX_VER_JUSTIFY_STANDARD;
107 0 : switch( nSlot )
108 : {
109 0 : case SID_ALIGN_ANY_VDEFAULT: eVJustify = SVX_VER_JUSTIFY_STANDARD; break;
110 0 : case SID_ALIGN_ANY_TOP: eVJustify = SVX_VER_JUSTIFY_TOP; break;
111 0 : case SID_ALIGN_ANY_VCENTER: eVJustify = SVX_VER_JUSTIFY_CENTER; break;
112 0 : case SID_ALIGN_ANY_BOTTOM: eVJustify = SVX_VER_JUSTIFY_BOTTOM; break;
113 : default: OSL_FAIL( "lclConvertSlotToVAlign - invalid slot" );
114 : }
115 0 : return eVJustify;
116 : }
117 :
118 : } // namespace
119 :
120 6540 : TYPEINIT1( ScFormatShell, SfxShell );
121 :
122 304 : SFX_IMPL_INTERFACE(ScFormatShell, SfxShell, ScResId(SCSTR_FORMATSHELL))
123 :
124 76 : void ScFormatShell::InitInterface_Impl()
125 : {
126 : GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_SERVER,
127 76 : ScResId(RID_OBJECTBAR_FORMAT));
128 76 : }
129 :
130 4400 : ScFormatShell::ScFormatShell(ScViewData* pData) :
131 4400 : SfxShell(pData->GetViewShell()),
132 4400 : pViewData(pData)
133 : {
134 4400 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
135 :
136 4400 : SetPool( &pTabViewShell->GetPool() );
137 4400 : ::svl::IUndoManager* pMgr = pViewData->GetSfxDocShell()->GetUndoManager();
138 4400 : SetUndoManager( pMgr );
139 4400 : if ( !pViewData->GetDocument()->IsUndoEnabled() )
140 : {
141 0 : pMgr->SetMaxUndoActionCount( 0 );
142 : }
143 4400 : SetHelpId(HID_SCSHELL_FORMATSH);
144 4400 : SetName(OUString("Format"));
145 4400 : }
146 :
147 4400 : ScFormatShell::~ScFormatShell()
148 : {
149 4400 : }
150 :
151 20 : void ScFormatShell::GetStyleState( SfxItemSet& rSet )
152 : {
153 20 : ScDocument* pDoc = GetViewData()->GetDocument();
154 20 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
155 20 : SfxStyleSheetBasePool* pStylePool = pDoc->GetStyleSheetPool();
156 :
157 20 : bool bProtected = false;
158 20 : SCTAB nTabCount = pDoc->GetTableCount();
159 44 : for (SCTAB i=0; i<nTabCount; i++)
160 24 : if (pDoc->IsTabProtected(i)) // look after protected table
161 0 : bProtected = true;
162 :
163 20 : SfxWhichIter aIter(rSet);
164 20 : sal_uInt16 nWhich = aIter.FirstWhich();
165 20 : sal_uInt16 nSlotId = 0;
166 :
167 80 : while ( nWhich )
168 : {
169 40 : nSlotId = SfxItemPool::IsWhich( nWhich )
170 0 : ? GetPool().GetSlotId( nWhich )
171 40 : : nWhich;
172 :
173 40 : switch ( nSlotId )
174 : {
175 : case SID_STYLE_APPLY:
176 0 : if ( !pStylePool )
177 0 : rSet.DisableItem( nSlotId );
178 0 : break;
179 :
180 : case SID_STYLE_FAMILY2: // cell style sheets
181 : {
182 : SfxStyleSheet* pStyleSheet = (SfxStyleSheet*)
183 20 : pTabViewShell->GetStyleSheetFromMarked();
184 :
185 20 : if ( pStyleSheet )
186 20 : rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
187 : else
188 0 : rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
189 : }
190 20 : break;
191 :
192 : case SID_STYLE_FAMILY4: // page style sheets
193 : {
194 20 : SCTAB nCurTab = GetViewData()->GetTabNo();
195 20 : OUString aPageStyle = pDoc->GetPageStyle( nCurTab );
196 : SfxStyleSheet* pStyleSheet = pStylePool ? static_cast<SfxStyleSheet*>(pStylePool->
197 20 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE )) : NULL;
198 :
199 20 : if ( pStyleSheet )
200 20 : rSet.Put( SfxTemplateItem( nSlotId, aPageStyle ) );
201 : else
202 0 : rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
203 : }
204 20 : break;
205 :
206 : case SID_STYLE_WATERCAN:
207 : {
208 0 : rSet.Put( SfxBoolItem( nSlotId, SC_MOD()->GetIsWaterCan() ) );
209 : }
210 0 : break;
211 :
212 : case SID_STYLE_UPDATE_BY_EXAMPLE:
213 : {
214 0 : SfxPoolItem* pItem = NULL;
215 0 : pTabViewShell->GetViewFrame()->GetBindings().QueryState(SID_STYLE_FAMILY, pItem);
216 0 : SfxUInt16Item* pFamilyItem = dynamic_cast<SfxUInt16Item*>(pItem);
217 :
218 0 : bool bPage = pFamilyItem && SFX_STYLE_FAMILY_PAGE == SfxTemplate::NIdToSfxFamilyId(pFamilyItem->GetValue());
219 0 : delete pItem;
220 :
221 0 : if ( bProtected || bPage )
222 0 : rSet.DisableItem( nSlotId );
223 : }
224 0 : break;
225 :
226 : case SID_STYLE_EDIT:
227 : case SID_STYLE_DELETE:
228 : case SID_STYLE_HIDE:
229 : case SID_STYLE_SHOW:
230 : {
231 0 : SfxPoolItem* pItem = NULL;
232 0 : pTabViewShell->GetViewFrame()->GetBindings().QueryState(SID_STYLE_FAMILY, pItem);
233 0 : SfxUInt16Item* pFamilyItem = dynamic_cast<SfxUInt16Item*>(pItem);
234 0 : bool bPage = pFamilyItem && SFX_STYLE_FAMILY_PAGE == SfxTemplate::NIdToSfxFamilyId(pFamilyItem->GetValue());
235 0 : delete pItem;
236 :
237 0 : if ( bProtected && !bPage )
238 0 : rSet.DisableItem( nSlotId );
239 : }
240 0 : break;
241 :
242 : default:
243 0 : break;
244 : }
245 :
246 40 : nWhich = aIter.NextWhich();
247 20 : }
248 20 : }
249 :
250 3854 : void ScFormatShell::ExecuteStyle( SfxRequest& rReq )
251 : {
252 : // in case of vertical toolbar
253 3854 : if ( !rReq.GetArgs() )
254 : {
255 0 : pViewData->GetDispatcher().Execute( SID_STYLE_DESIGNER, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
256 3854 : return;
257 : }
258 :
259 3854 : SfxBindings& rBindings = pViewData->GetBindings();
260 3854 : const SfxItemSet* pArgs = rReq.GetArgs();
261 3854 : const sal_uInt16 nSlotId = rReq.GetSlot();
262 3854 : const SCTAB nCurTab = GetViewData()->GetTabNo();
263 3854 : ScDocShell* pDocSh = GetViewData()->GetDocShell();
264 3854 : ScTabViewShell* pTabViewShell= GetViewData()->GetViewShell();
265 3854 : ScDocument& rDoc = pDocSh->GetDocument();
266 3854 : ScMarkData& rMark = GetViewData()->GetMarkData();
267 3854 : ScModule* pScMod = SC_MOD();
268 3854 : OUString aRefName;
269 3854 : bool bUndo = rDoc.IsUndoEnabled();
270 3854 : SfxStyleSheetBasePool* pStylePool = rDoc.GetStyleSheetPool();
271 :
272 3854 : if ( (nSlotId == SID_STYLE_PREVIEW)
273 3854 : || (nSlotId == SID_STYLE_END_PREVIEW) )
274 : {
275 3854 : if (nSlotId == SID_STYLE_PREVIEW)
276 : {
277 0 : SfxStyleFamily eFamily = SFX_STYLE_FAMILY_PARA;
278 : const SfxPoolItem* pFamItem;
279 0 : if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY, true, &pFamItem ) )
280 0 : eFamily = (SfxStyleFamily) static_cast<const SfxUInt16Item*>(pFamItem)->GetValue();
281 : const SfxPoolItem* pNameItem;
282 0 : OUString aStyleName;
283 0 : if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
284 0 : aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
285 0 : if ( eFamily == SFX_STYLE_FAMILY_PARA ) // CellStyles
286 : {
287 0 : ScMarkData aFuncMark( pViewData->GetMarkData() );
288 0 : ScViewUtil::UnmarkFiltered( aFuncMark, &rDoc );
289 0 : aFuncMark.MarkToMulti();
290 :
291 0 : if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
292 : {
293 0 : SCCOL nCol = pViewData->GetCurX();
294 0 : SCROW nRow = pViewData->GetCurY();
295 0 : SCTAB nTab = pViewData->GetTabNo();
296 0 : ScRange aRange( nCol, nRow, nTab );
297 0 : aFuncMark.SetMarkArea( aRange );
298 : }
299 0 : rDoc.SetPreviewSelection( aFuncMark );
300 0 : ScStyleSheet* pPreviewStyle = static_cast<ScStyleSheet*>( pStylePool->Find( aStyleName, eFamily ) );
301 0 : rDoc.SetPreviewCellStyle( pPreviewStyle );
302 0 : ScPatternAttr aAttr( *rDoc.GetSelectionPattern( aFuncMark ) );
303 0 : aAttr.SetStyleSheet( pPreviewStyle );
304 :
305 0 : SfxItemSet aItemSet( GetPool() );
306 :
307 0 : ScPatternAttr aNewAttrs( GetViewData()->GetDocument()->GetPool() );
308 0 : SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
309 0 : rNewSet.Put( aItemSet, false );
310 :
311 0 : rDoc.ApplySelectionPattern( aNewAttrs, rDoc.GetPreviewSelection() );
312 0 : pTabViewShell->UpdateSelectionArea( aFuncMark, &aAttr );
313 0 : }
314 : }
315 : else
316 : {
317 : // No mark at all happens when creating a new document, in which
318 : // case the selection pattern obtained would be empty (created of
319 : // GetPool()) anyway and nothing needs to be applied.
320 3854 : ScMarkData aPreviewMark( rDoc.GetPreviewSelection());
321 3854 : if (aPreviewMark.IsMarked() || aPreviewMark.IsMultiMarked())
322 : {
323 844 : ScPatternAttr aAttr( *rDoc.GetSelectionPattern( aPreviewMark ) );
324 844 : if ( ScStyleSheet* pPreviewStyle = rDoc.GetPreviewCellStyle() )
325 0 : aAttr.SetStyleSheet( pPreviewStyle );
326 844 : rDoc.SetPreviewCellStyle(NULL);
327 :
328 1688 : SfxItemSet aItemSet( GetPool() );
329 :
330 1688 : ScPatternAttr aNewAttrs( GetViewData()->GetDocument()->GetPool() );
331 844 : SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
332 844 : rNewSet.Put( aItemSet, false );
333 844 : rDoc.ApplySelectionPattern( aNewAttrs, aPreviewMark );
334 1688 : pTabViewShell->UpdateSelectionArea( aPreviewMark, &aAttr );
335 3854 : }
336 3854 : }
337 : }
338 0 : else if ( (nSlotId == SID_STYLE_NEW)
339 0 : || (nSlotId == SID_STYLE_EDIT)
340 0 : || (nSlotId == SID_STYLE_DELETE)
341 0 : || (nSlotId == SID_STYLE_HIDE)
342 0 : || (nSlotId == SID_STYLE_SHOW)
343 0 : || (nSlotId == SID_STYLE_APPLY)
344 0 : || (nSlotId == SID_STYLE_WATERCAN)
345 0 : || (nSlotId == SID_STYLE_FAMILY)
346 0 : || (nSlotId == SID_STYLE_NEW_BY_EXAMPLE)
347 0 : || (nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE) )
348 : {
349 0 : SfxStyleSheetBase* pStyleSheet = NULL;
350 :
351 0 : bool bStyleToMarked = false;
352 0 : bool bListAction = false;
353 0 : bool bAddUndo = false; // add ScUndoModifyStyle (style modified)
354 0 : ScStyleSaveData aOldData; // for undo/redo
355 0 : ScStyleSaveData aNewData;
356 :
357 0 : SfxStyleFamily eFamily = SFX_STYLE_FAMILY_PARA;
358 : const SfxPoolItem* pFamItem;
359 0 : if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY, true, &pFamItem ) )
360 0 : eFamily = (SfxStyleFamily) static_cast<const SfxUInt16Item*>(pFamItem)->GetValue();
361 0 : else if ( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILYNAME, true, &pFamItem ) )
362 : {
363 0 : OUString sFamily = static_cast<const SfxStringItem*>(pFamItem)->GetValue();
364 0 : if (sFamily.equalsAscii("CellStyles"))
365 0 : eFamily = SFX_STYLE_FAMILY_PARA;
366 0 : else if (sFamily.equalsAscii("PageStyles"))
367 0 : eFamily = SFX_STYLE_FAMILY_PAGE;
368 : }
369 :
370 0 : OUString aStyleName;
371 0 : sal_uInt16 nRetMask = 0xffff;
372 :
373 0 : pStylePool->SetSearchMask( eFamily, SFXSTYLEBIT_ALL );
374 :
375 0 : switch ( nSlotId )
376 : {
377 : case SID_STYLE_NEW:
378 : {
379 : const SfxPoolItem* pNameItem;
380 0 : if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
381 0 : aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
382 :
383 0 : const SfxPoolItem* pRefItem=NULL;
384 0 : if (pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_REFERENCE, true, &pRefItem ))
385 : {
386 0 : if(pRefItem!=NULL)
387 0 : aRefName = static_cast<const SfxStringItem*>(pRefItem)->GetValue();
388 : }
389 :
390 : pStyleSheet = &(pStylePool->Make( aStyleName, eFamily,
391 0 : SFXSTYLEBIT_USERDEF ) );
392 :
393 0 : if ( pStyleSheet && pStyleSheet->HasParentSupport() )
394 0 : pStyleSheet->SetParent(aRefName);
395 : }
396 0 : break;
397 :
398 : case SID_STYLE_APPLY:
399 : {
400 0 : SFX_REQUEST_ARG( rReq, pNameItem, SfxStringItem, SID_APPLY_STYLE, false );
401 0 : SFX_REQUEST_ARG( rReq, pFamilyItem, SfxStringItem, SID_STYLE_FAMILYNAME, false );
402 0 : if ( pFamilyItem && pNameItem )
403 : {
404 0 : com::sun::star::uno::Reference< com::sun::star::style::XStyleFamiliesSupplier > xModel(pDocSh->GetModel(), com::sun::star::uno::UNO_QUERY);
405 : try
406 : {
407 0 : com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xStyles;
408 0 : com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xCont = xModel->getStyleFamilies();
409 0 : xCont->getByName(pFamilyItem->GetValue()) >>= xStyles;
410 0 : com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xInfo;
411 0 : xStyles->getByName( pNameItem->GetValue() ) >>= xInfo;
412 0 : OUString aUIName;
413 0 : xInfo->getPropertyValue("DisplayName") >>= aUIName;
414 0 : if ( !aUIName.isEmpty() )
415 0 : rReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aUIName ) );
416 : }
417 0 : catch( com::sun::star::uno::Exception& )
418 : {
419 0 : }
420 : }
421 : }
422 : //fall-through
423 : case SID_STYLE_EDIT:
424 : case SID_STYLE_DELETE:
425 : case SID_STYLE_HIDE:
426 : case SID_STYLE_SHOW:
427 : case SID_STYLE_NEW_BY_EXAMPLE:
428 : {
429 : const SfxPoolItem* pNameItem;
430 0 : if (pArgs && SfxItemState::SET == pArgs->GetItemState( nSlotId, true, &pNameItem ))
431 0 : aStyleName = static_cast<const SfxStringItem*>(pNameItem)->GetValue();
432 0 : pStyleSheet = pStylePool->Find( aStyleName, eFamily );
433 :
434 0 : aOldData.InitFromStyle( pStyleSheet );
435 : }
436 0 : break;
437 :
438 : case SID_STYLE_WATERCAN:
439 : {
440 0 : bool bWaterCan = pScMod->GetIsWaterCan();
441 :
442 0 : if( !bWaterCan )
443 : {
444 : const SfxPoolItem* pItem;
445 :
446 0 : if ( SfxItemState::SET ==
447 0 : pArgs->GetItemState( nSlotId, true, &pItem ) )
448 : {
449 0 : const SfxStringItem* pStrItem = PTR_CAST(SfxStringItem,pItem);
450 0 : if ( pStrItem )
451 : {
452 0 : aStyleName = pStrItem->GetValue();
453 0 : pStyleSheet = pStylePool->Find( aStyleName, eFamily );
454 :
455 0 : if ( pStyleSheet )
456 : {
457 : static_cast<ScStyleSheetPool*>(pStylePool)->
458 0 : SetActualStyleSheet( pStyleSheet );
459 0 : rReq.Done();
460 : }
461 : }
462 : }
463 : }
464 :
465 0 : if ( !bWaterCan && pStyleSheet )
466 : {
467 0 : pScMod->SetWaterCan( true );
468 0 : pTabViewShell->SetActivePointer( Pointer(POINTER_FILL) );
469 0 : rReq.Done();
470 : }
471 : else
472 : {
473 0 : pScMod->SetWaterCan( false );
474 0 : pTabViewShell->SetActivePointer( Pointer(POINTER_ARROW) );
475 0 : rReq.Done();
476 : }
477 : }
478 0 : break;
479 :
480 : default:
481 0 : break;
482 : }
483 :
484 : // set new style for WaterCan-Mode
485 0 : if ( nSlotId == SID_STYLE_APPLY && pScMod->GetIsWaterCan() && pStyleSheet )
486 0 : static_cast<ScStyleSheetPool*>(pStylePool)->SetActualStyleSheet( pStyleSheet );
487 :
488 0 : switch ( eFamily )
489 : {
490 : case SFX_STYLE_FAMILY_PARA:
491 : {
492 0 : switch ( nSlotId )
493 : {
494 : case SID_STYLE_DELETE:
495 : {
496 0 : if ( pStyleSheet )
497 : {
498 0 : pTabViewShell->RemoveStyleSheetInUse( pStyleSheet );
499 0 : pStylePool->Remove( pStyleSheet );
500 0 : pTabViewShell->InvalidateAttribs();
501 0 : nRetMask = sal_uInt16(true);
502 0 : bAddUndo = true;
503 0 : rReq.Done();
504 : }
505 : else
506 0 : nRetMask = sal_uInt16(false);
507 : }
508 0 : break;
509 :
510 : case SID_STYLE_HIDE:
511 : case SID_STYLE_SHOW:
512 : {
513 0 : if ( pStyleSheet )
514 : {
515 0 : pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
516 0 : pTabViewShell->InvalidateAttribs();
517 0 : rReq.Done();
518 : }
519 : else
520 0 : nRetMask = sal_uInt16(false);
521 : }
522 0 : break;
523 :
524 : case SID_STYLE_APPLY:
525 : {
526 0 : if ( pStyleSheet && !pScMod->GetIsWaterCan() )
527 : {
528 : // apply style sheet to document
529 0 : pTabViewShell->SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
530 0 : pTabViewShell->InvalidateAttribs();
531 0 : rReq.Done();
532 : }
533 : }
534 0 : break;
535 :
536 : case SID_STYLE_NEW_BY_EXAMPLE:
537 : case SID_STYLE_UPDATE_BY_EXAMPLE:
538 : {
539 : // create/replace style sheet by attributes
540 : // at cursor position:
541 :
542 0 : const ScPatternAttr* pAttrItem = NULL;
543 :
544 : // Die Abfrage, ob markiert ist, war hier immer falsch,
545 : // darum jetzt gar nicht mehr, und einfach vom Cursor.
546 : // Wenn Attribute aus der Selektion genommen werden sollen,
547 : // muss noch darauf geachtet werden, Items aus Vorlagen nicht
548 : // zu uebernehmen (GetSelectionPattern sammelt auch Items aus
549 : // Vorlagen zusammen) (#44748#)
550 : // pAttrItem = GetSelectionPattern();
551 :
552 : // ScViewData* pViewData = GetViewData();
553 0 : SCCOL nCol = pViewData->GetCurX();
554 0 : SCROW nRow = pViewData->GetCurY();
555 0 : pAttrItem = rDoc.GetPattern( nCol, nRow, nCurTab );
556 :
557 0 : SfxItemSet aAttrSet = pAttrItem->GetItemSet();
558 0 : aAttrSet.ClearItem( ATTR_MERGE );
559 0 : aAttrSet.ClearItem( ATTR_MERGE_FLAG );
560 : // bedingte Formatierung und Gueltigkeit nicht uebernehmen,
561 : // weil sie in der Vorlage nicht editiert werden koennen
562 0 : aAttrSet.ClearItem( ATTR_VALIDDATA );
563 0 : aAttrSet.ClearItem( ATTR_CONDITIONAL );
564 :
565 0 : if ( SID_STYLE_NEW_BY_EXAMPLE == nSlotId )
566 : {
567 0 : if ( bUndo )
568 : {
569 0 : OUString aUndo = ScGlobal::GetRscString( STR_UNDO_EDITCELLSTYLE );
570 0 : pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
571 0 : bListAction = true;
572 : }
573 :
574 0 : bool bConvertBack = false;
575 : SfxStyleSheet* pSheetInUse = (SfxStyleSheet*)
576 0 : pTabViewShell->GetStyleSheetFromMarked();
577 :
578 : // wenn neuer Style vorhanden und in der Selektion
579 : // verwendet wird, so darf der Parent nicht uebernommen
580 : // werden:
581 :
582 0 : if ( pStyleSheet && pSheetInUse && pStyleSheet == pSheetInUse )
583 0 : pSheetInUse = NULL;
584 :
585 : // wenn bereits vorhanden, erstmal entfernen...
586 0 : if ( pStyleSheet )
587 : {
588 : // Style-Pointer zu Namen vor Erase,
589 : // weil Zellen sonst ungueltige Pointer
590 : // enthalten.
591 : //!!! bei Gelenheit mal eine Methode, die
592 : // das fuer einen bestimmten Style macht
593 0 : rDoc.StylesToNames();
594 0 : bConvertBack = true;
595 0 : pStylePool->Remove(pStyleSheet);
596 : }
597 :
598 : // ...und neu anlegen
599 : pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
600 0 : SFXSTYLEBIT_USERDEF );
601 :
602 : // wenn ein Style vorhanden ist, so wird dieser
603 : // Parent der neuen Vorlage:
604 0 : if ( pSheetInUse && pStyleSheet->HasParentSupport() )
605 0 : pStyleSheet->SetParent( pSheetInUse->GetName() );
606 :
607 0 : if ( bConvertBack )
608 : // Namen zu Style-Pointer
609 0 : rDoc.UpdStlShtPtrsFrmNms();
610 : else
611 0 : rDoc.GetPool()->CellStyleCreated( aStyleName, &rDoc );
612 :
613 : // Attribute uebernehmen und Style anwenden
614 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
615 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
616 :
617 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
618 : // (pStyleSheet pointer is used!)
619 0 : bStyleToMarked = true;
620 : }
621 : else // ( nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE )
622 : {
623 0 : pStyleSheet = (SfxStyleSheet*)pTabViewShell->GetStyleSheetFromMarked();
624 :
625 0 : if ( pStyleSheet )
626 : {
627 0 : aOldData.InitFromStyle( pStyleSheet );
628 :
629 0 : if ( bUndo )
630 : {
631 0 : OUString aUndo = ScGlobal::GetRscString( STR_UNDO_EDITCELLSTYLE );
632 0 : pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
633 0 : bListAction = true;
634 : }
635 :
636 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
637 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
638 :
639 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
640 : // (pStyleSheet pointer is used!)
641 0 : bStyleToMarked = true;
642 : }
643 : }
644 :
645 0 : aNewData.InitFromStyle( pStyleSheet );
646 0 : bAddUndo = true;
647 0 : rReq.Done();
648 : }
649 0 : break;
650 :
651 : default:
652 0 : break;
653 : }
654 : } // case SFX_STYLE_FAMILY_PARA:
655 0 : break;
656 :
657 : case SFX_STYLE_FAMILY_PAGE:
658 : {
659 0 : switch ( nSlotId )
660 : {
661 : case SID_STYLE_DELETE:
662 : {
663 0 : nRetMask = sal_uInt16( NULL != pStyleSheet );
664 0 : if ( pStyleSheet )
665 : {
666 0 : if ( rDoc.RemovePageStyleInUse( pStyleSheet->GetName() ) )
667 : {
668 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nCurTab ).UpdatePages();
669 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
670 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
671 : }
672 0 : pStylePool->Remove( pStyleSheet );
673 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
674 0 : pDocSh->SetDocumentModified();
675 0 : bAddUndo = true;
676 0 : rReq.Done();
677 : }
678 : }
679 0 : break;
680 :
681 : case SID_STYLE_HIDE:
682 : case SID_STYLE_SHOW:
683 : {
684 0 : nRetMask = sal_uInt16( NULL != pStyleSheet );
685 0 : if ( pStyleSheet )
686 : {
687 0 : pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
688 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
689 0 : pDocSh->SetDocumentModified();
690 0 : rReq.Done();
691 : }
692 : }
693 0 : break;
694 :
695 : case SID_STYLE_APPLY:
696 : {
697 0 : nRetMask = sal_uInt16( NULL != pStyleSheet );
698 0 : if ( pStyleSheet && !pScMod->GetIsWaterCan() )
699 : {
700 0 : ScUndoApplyPageStyle* pUndoAction = 0;
701 0 : SCTAB nTabCount = rDoc.GetTableCount();
702 0 : ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
703 0 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
704 : {
705 0 : OUString aOldName = rDoc.GetPageStyle( *itr );
706 0 : if ( aOldName != aStyleName )
707 : {
708 0 : rDoc.SetPageStyle( *itr, aStyleName );
709 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), *itr ).UpdatePages();
710 0 : if( !pUndoAction )
711 0 : pUndoAction = new ScUndoApplyPageStyle( pDocSh, aStyleName );
712 0 : pUndoAction->AddSheetAction( *itr, aOldName );
713 : }
714 0 : }
715 0 : if( pUndoAction )
716 : {
717 0 : pDocSh->GetUndoManager()->AddUndoAction( pUndoAction );
718 0 : pDocSh->SetDocumentModified();
719 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
720 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
721 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
722 : }
723 0 : rReq.Done();
724 : }
725 : }
726 0 : break;
727 :
728 : case SID_STYLE_NEW_BY_EXAMPLE:
729 : {
730 0 : const OUString& rStrCurStyle = rDoc.GetPageStyle( nCurTab );
731 :
732 0 : if ( rStrCurStyle != aStyleName )
733 : {
734 0 : SfxStyleSheetBase* pCurStyle = pStylePool->Find( rStrCurStyle, eFamily );
735 0 : SfxItemSet aAttrSet = pCurStyle->GetItemSet();
736 : SCTAB nInTab;
737 0 : bool bUsed = rDoc.IsPageStyleInUse( aStyleName, &nInTab );
738 :
739 : // wenn bereits vorhanden, erstmal entfernen...
740 0 : if ( pStyleSheet )
741 0 : pStylePool->Remove( pStyleSheet );
742 :
743 : // ...und neu anlegen
744 : pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
745 0 : SFXSTYLEBIT_USERDEF );
746 :
747 : // Attribute uebernehmen
748 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
749 0 : pDocSh->SetDocumentModified();
750 :
751 : // wenn in Verwendung -> Update
752 0 : if ( bUsed )
753 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nInTab ).UpdatePages();
754 :
755 0 : aNewData.InitFromStyle( pStyleSheet );
756 0 : bAddUndo = true;
757 0 : rReq.Done();
758 0 : nRetMask = sal_uInt16(true);
759 0 : }
760 : }
761 0 : break;
762 :
763 : default:
764 0 : break;
765 : } // switch ( nSlotId )
766 : } // case SFX_STYLE_FAMILY_PAGE:
767 0 : break;
768 :
769 : default:
770 0 : break;
771 : } // switch ( eFamily )
772 :
773 : // Neu anlegen oder bearbeiten ueber Dialog:
774 0 : if ( nSlotId == SID_STYLE_NEW || nSlotId == SID_STYLE_EDIT )
775 : {
776 0 : if ( pStyleSheet )
777 : {
778 0 : SfxStyleFamily eFam = pStyleSheet->GetFamily();
779 0 : boost::scoped_ptr<SfxAbstractTabDialog> pDlg;
780 0 : sal_uInt16 nRsc = 0;
781 :
782 : // alte Items aus der Vorlage merken
783 0 : SfxItemSet aOldSet = pStyleSheet->GetItemSet();
784 0 : OUString aOldName = pStyleSheet->GetName();
785 :
786 0 : switch ( eFam )
787 : {
788 : case SFX_STYLE_FAMILY_PAGE:
789 0 : nRsc = RID_SCDLG_STYLES_PAGE;
790 0 : break;
791 :
792 : case SFX_STYLE_FAMILY_PARA:
793 : default:
794 : {
795 0 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
796 :
797 : const SfxPoolItem* pItem;
798 0 : if ( rSet.GetItemState( ATTR_VALUE_FORMAT,
799 0 : false, &pItem ) == SfxItemState::SET )
800 : {
801 : // NumberFormat Value aus Value und Language
802 : // erzeugen und eintueten
803 : sal_uLong nFormat =
804 0 : static_cast<const SfxUInt32Item*>(pItem)->GetValue();
805 : LanguageType eLang =
806 : static_cast<const SvxLanguageItem*>(&rSet.Get(
807 0 : ATTR_LANGUAGE_FORMAT ))->GetLanguage();
808 : sal_uLong nLangFormat = rDoc.GetFormatTable()->
809 0 : GetFormatForLanguageIfBuiltIn( nFormat, eLang );
810 0 : if ( nLangFormat != nFormat )
811 : {
812 0 : SfxUInt32Item aNewItem( ATTR_VALUE_FORMAT, nLangFormat );
813 0 : rSet.Put( aNewItem );
814 0 : aOldSet.Put( aNewItem );
815 : // auch in aOldSet fuer Vergleich nach dem Dialog,
816 : // sonst geht evtl. eine Aenderung der Sprache verloren
817 : }
818 : }
819 :
820 : boost::scoped_ptr<SvxNumberInfoItem> pNumberInfoItem(
821 0 : pTabViewShell->MakeNumberInfoItem(&rDoc, GetViewData()));
822 :
823 0 : pDocSh->PutItem( *pNumberInfoItem );
824 0 : nRsc = RID_SCDLG_STYLES_PAR;
825 :
826 : // auf jeden Fall ein SvxBoxInfoItem mit Table = sal_False im Set:
827 : // (wenn gar kein Item da ist, loescht der Dialog auch das
828 : // BORDER_OUTER SvxBoxItem aus dem Vorlagen-Set)
829 :
830 0 : if ( rSet.GetItemState( ATTR_BORDER_INNER, false ) != SfxItemState::SET )
831 : {
832 0 : SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
833 0 : aBoxInfoItem.SetTable(false); // keine inneren Linien
834 0 : aBoxInfoItem.SetDist(true);
835 0 : aBoxInfoItem.SetMinDist(false);
836 0 : rSet.Put( aBoxInfoItem );
837 0 : }
838 : }
839 0 : break;
840 : }
841 :
842 : // If GetDefDialogParent is a dialog, it must be used
843 : // (style catalog)
844 :
845 0 : vcl::Window* pParent = Application::GetDefDialogParent();
846 0 : if ( !pParent || !pParent->IsDialog() )
847 : {
848 : // GetDefDialogParent currently doesn't return the window
849 : // that was set with SetDefDialogParent (but dynamically finds the
850 : // topmost parent of the focus window), so IsDialog above is FALSE
851 : // even if called from the style catalog.
852 : // -> Use NULL if a modal dialog is open, to enable the Dialog's
853 : // default parent handling.
854 0 : if ( Application::IsInModalMode() )
855 0 : pParent = NULL;
856 : else
857 0 : pParent = pTabViewShell->GetDialogParent();
858 : }
859 :
860 0 : pTabViewShell->SetInFormatDialog(true);
861 :
862 0 : ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
863 : OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
864 :
865 0 : pDlg.reset(pFact->CreateScStyleDlg( pParent, *pStyleSheet, nRsc, nRsc ));
866 : OSL_ENSURE(pDlg, "Dialog create fail!");
867 0 : short nResult = pDlg->Execute();
868 0 : pTabViewShell->SetInFormatDialog(false);
869 :
870 0 : if ( nResult == RET_OK )
871 : {
872 0 : const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
873 :
874 0 : if ( pOutSet )
875 : {
876 0 : nRetMask = pStyleSheet->GetMask();
877 :
878 : // Attribut-Vergleiche (frueher in ModifyStyleSheet)
879 : // jetzt hier mit den alten Werten (Style ist schon veraendert)
880 :
881 0 : if ( SFX_STYLE_FAMILY_PARA == eFam )
882 : {
883 0 : SfxItemSet& rNewSet = pStyleSheet->GetItemSet();
884 : bool bNumFormatChanged;
885 0 : if ( ScGlobal::CheckWidthInvalidate(
886 : bNumFormatChanged, rNewSet, aOldSet ) )
887 0 : rDoc.InvalidateTextWidth( NULL, NULL, bNumFormatChanged );
888 :
889 0 : SCTAB nTabCount = rDoc.GetTableCount();
890 0 : for (SCTAB nTab=0; nTab<nTabCount; nTab++)
891 0 : if (rDoc.IsStreamValid(nTab))
892 0 : rDoc.SetStreamValid(nTab, false);
893 :
894 : sal_uLong nOldFormat = static_cast<const SfxUInt32Item&>(aOldSet.
895 0 : Get( ATTR_VALUE_FORMAT )).GetValue();
896 : sal_uLong nNewFormat = static_cast<const SfxUInt32Item&>(rNewSet.
897 0 : Get( ATTR_VALUE_FORMAT )).GetValue();
898 0 : if ( nNewFormat != nOldFormat )
899 : {
900 0 : SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
901 0 : const SvNumberformat* pOld = pFormatter->GetEntry( nOldFormat );
902 0 : const SvNumberformat* pNew = pFormatter->GetEntry( nNewFormat );
903 0 : if ( pOld && pNew && pOld->GetLanguage() != pNew->GetLanguage() )
904 : rNewSet.Put( SvxLanguageItem(
905 0 : pNew->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
906 : }
907 :
908 0 : rDoc.GetPool()->CellStyleCreated( pStyleSheet->GetName(), &rDoc );
909 : }
910 : else
911 : {
912 : //! auch fuer Seitenvorlagen die Abfragen hier
913 :
914 0 : OUString aNewName = pStyleSheet->GetName();
915 0 : if ( aNewName != aOldName &&
916 0 : rDoc.RenamePageStyleInUse( aOldName, aNewName ) )
917 : {
918 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
919 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
920 : }
921 :
922 0 : rDoc.ModifyStyleSheet( *pStyleSheet, *pOutSet );
923 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
924 : }
925 :
926 0 : pDocSh->SetDocumentModified();
927 :
928 0 : if ( SFX_STYLE_FAMILY_PARA == eFam )
929 : {
930 : pTabViewShell->UpdateNumberFormatter(
931 : static_cast<const SvxNumberInfoItem&>(
932 0 : *(pDocSh->GetItem(SID_ATTR_NUMBERFORMAT_INFO)) ));
933 :
934 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
935 0 : pTabViewShell->InvalidateAttribs();
936 : }
937 :
938 0 : aNewData.InitFromStyle( pStyleSheet );
939 0 : bAddUndo = true;
940 : }
941 : }
942 : else
943 : {
944 0 : if ( nSlotId == SID_STYLE_NEW )
945 0 : pStylePool->Remove( pStyleSheet );
946 : else
947 : {
948 : // falls zwischendurch etwas mit dem temporaer geaenderten
949 : // ItemSet gepainted wurde:
950 0 : pDocSh->PostPaintGridAll();
951 : }
952 0 : }
953 : }
954 : }
955 :
956 0 : rReq.SetReturnValue( SfxUInt16Item( nSlotId, nRetMask ) );
957 :
958 0 : if ( bAddUndo && bUndo)
959 0 : pDocSh->GetUndoManager()->AddUndoAction(
960 0 : new ScUndoModifyStyle( pDocSh, eFamily, aOldData, aNewData ) );
961 :
962 0 : if ( bStyleToMarked )
963 : {
964 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle,
965 : // so redo will find the modified style
966 0 : pTabViewShell->SetStyleSheetToMarked( static_cast<SfxStyleSheet*>(pStyleSheet) );
967 0 : pTabViewShell->InvalidateAttribs();
968 : }
969 :
970 0 : if ( bListAction )
971 0 : pDocSh->GetUndoManager()->LeaveListAction();
972 : }
973 : else
974 : {
975 : OSL_FAIL( "Unknown slot (ScViewShell::ExecuteStyle)" );
976 3854 : }
977 : }
978 :
979 0 : void ScFormatShell::ExecuteNumFormat( SfxRequest& rReq )
980 : {
981 0 : ScModule* pScMod = SC_MOD();
982 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
983 0 : const SfxItemSet* pReqArgs = rReq.GetArgs();
984 0 : sal_uInt16 nSlot = rReq.GetSlot();
985 0 : SfxBindings& rBindings = pTabViewShell->GetViewFrame()->GetBindings();
986 :
987 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
988 :
989 : // Eingabe beenden
990 0 : if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
991 : {
992 0 : switch ( nSlot )
993 : {
994 : case SID_NUMBER_TWODEC:
995 : case SID_NUMBER_SCIENTIFIC:
996 : case SID_NUMBER_DATE:
997 : case SID_NUMBER_CURRENCY:
998 : case SID_NUMBER_PERCENT:
999 : case SID_NUMBER_STANDARD:
1000 : case SID_NUMBER_FORMAT:
1001 : case SID_NUMBER_INCDEC:
1002 : case SID_NUMBER_DECDEC:
1003 : case FID_DEFINE_NAME:
1004 : case FID_ADD_NAME:
1005 : case FID_USE_NAME:
1006 : case FID_INSERT_NAME:
1007 : case SID_SPELL_DIALOG:
1008 : case SID_HANGUL_HANJA_CONVERSION:
1009 :
1010 0 : pScMod->InputEnterHandler();
1011 0 : pTabViewShell->UpdateInputHandler();
1012 0 : break;
1013 :
1014 : default:
1015 0 : break;
1016 : }
1017 : }
1018 :
1019 0 : short nType = GetCurrentNumberFormatType();
1020 0 : SfxItemSet aSet( GetPool(), nSlot, nSlot );
1021 0 : switch ( nSlot )
1022 : {
1023 : case SID_NUMBER_TWODEC:
1024 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER, 4 ); // Standard+4 = #.##0,00
1025 0 : rReq.Done();
1026 0 : break;
1027 : case SID_NUMBER_SCIENTIFIC:
1028 0 : if ((nType & NUMBERFORMAT_SCIENTIFIC))
1029 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1030 : else
1031 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_SCIENTIFIC );
1032 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_SCIENTIFIC)) );
1033 0 : rBindings.Invalidate( nSlot );
1034 0 : rReq.Done();
1035 0 : break;
1036 : case SID_NUMBER_DATE:
1037 0 : if ((nType & NUMBERFORMAT_DATE))
1038 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1039 : else
1040 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_DATE );
1041 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_DATE)) );
1042 0 : rBindings.Invalidate( nSlot );
1043 0 : rReq.Done();
1044 0 : break;
1045 : case SID_NUMBER_TIME:
1046 0 : if ((nType & NUMBERFORMAT_TIME))
1047 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1048 : else
1049 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_TIME );
1050 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_TIME)) );
1051 0 : rBindings.Invalidate( nSlot );
1052 0 : rReq.Done();
1053 0 : break;
1054 : case SID_NUMBER_CURRENCY:
1055 0 : if ((nType & NUMBERFORMAT_CURRENCY))
1056 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1057 : else
1058 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_CURRENCY );
1059 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_CURRENCY)) );
1060 0 : rBindings.Invalidate( nSlot );
1061 0 : rReq.Done();
1062 0 : break;
1063 : case SID_NUMBER_PERCENT:
1064 0 : if ((nType & NUMBERFORMAT_PERCENT))
1065 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1066 : else
1067 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_PERCENT );
1068 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_PERCENT)) );
1069 0 : rBindings.Invalidate( nSlot );
1070 0 : rReq.Done();
1071 0 : break;
1072 : case SID_NUMBER_STANDARD:
1073 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1074 0 : rReq.Done();
1075 0 : break;
1076 : case SID_NUMBER_INCDEC:
1077 0 : pTabViewShell->ChangeNumFmtDecimals( true );
1078 0 : rReq.Done();
1079 0 : break;
1080 : case SID_NUMBER_DECDEC:
1081 0 : pTabViewShell->ChangeNumFmtDecimals( false );
1082 0 : rReq.Done();
1083 0 : break;
1084 :
1085 : case SID_NUMBER_FORMAT:
1086 : //if ( pReqArgs )
1087 : //{
1088 : // const SfxPoolItem* pItem;
1089 : // if(pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SfxItemState::SET)
1090 : // {
1091 : // String aCode = ((const SfxStringItem*)pItem)->GetValue();
1092 : // pTabViewShell->SetNumFmtByStr( aCode );
1093 : // }
1094 : //}
1095 :
1096 : // symphony version with format interpretation
1097 0 : if(pReqArgs)
1098 : {
1099 : const SfxPoolItem* pItem;
1100 0 : ScDocument* pDoc = pViewData->GetDocument();
1101 0 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
1102 0 : LanguageType eLanguage = ScGlobal::eLnge;
1103 0 : sal_Int16 eType = -1;
1104 : sal_uInt32 nCurrentNumberFormat;
1105 :
1106 0 : pDoc->GetNumberFormat(pViewData->GetCurX(), pViewData->GetCurY(), pViewData->GetTabNo(), nCurrentNumberFormat);
1107 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nCurrentNumberFormat);
1108 :
1109 0 : if(pEntry)
1110 : {
1111 0 : eLanguage = pEntry->GetLanguage();
1112 0 : eType = pEntry->GetType();
1113 : }
1114 :
1115 : //Just use eType to judge whether the command is fired for NUMBER/PERCENT/CURRENCY
1116 : //In sidebar, users can fire SID_NUMBER_FORMAT command by operating the related UI controls before they are disable
1117 0 : switch(eType)
1118 : {
1119 : case NUMBERFORMAT_ALL:
1120 : case NUMBERFORMAT_NUMBER:
1121 : case NUMBERFORMAT_NUMBER| NUMBERFORMAT_DEFINED:
1122 : case NUMBERFORMAT_PERCENT:
1123 : case NUMBERFORMAT_PERCENT| NUMBERFORMAT_DEFINED:
1124 : case NUMBERFORMAT_CURRENCY:
1125 : case NUMBERFORMAT_CURRENCY|NUMBERFORMAT_DEFINED:
1126 0 : eType = 0;
1127 0 : break;
1128 : default:
1129 0 : eType =-1;
1130 : }
1131 :
1132 0 : if(SfxItemState::SET == pReqArgs->GetItemState(nSlot, true, &pItem) && eType != -1)
1133 : {
1134 0 : OUString aCode = static_cast<const SfxStringItem*>(pItem)->GetValue();
1135 0 : sal_uInt16 aLen = aCode.getLength();
1136 0 : OUString* sFormat = new OUString[4];
1137 0 : OUString sTmpStr = "";
1138 0 : sal_uInt16 nCount(0);
1139 0 : sal_uInt16 nStrCount(0);
1140 :
1141 0 : while(nCount < aLen)
1142 : {
1143 0 : sal_Unicode cChar = aCode[nCount];
1144 :
1145 0 : if(cChar == ',')
1146 : {
1147 0 : sFormat[nStrCount] = sTmpStr;
1148 0 : sTmpStr = "";
1149 0 : nStrCount++;
1150 : }
1151 : else
1152 : {
1153 0 : sTmpStr += OUString(cChar);
1154 : }
1155 :
1156 0 : nCount++;
1157 :
1158 0 : if(nStrCount > 3)
1159 0 : break;
1160 : }
1161 :
1162 0 : const bool bThousand = (bool)sFormat[0].toInt32();
1163 0 : const bool bNegRed = (bool)sFormat[1].toInt32();
1164 0 : const sal_uInt16 nPrecision = (sal_uInt16)sFormat[2].toInt32();
1165 0 : const sal_uInt16 nLeadZeroes = (sal_uInt16)sFormat[3].toInt32();
1166 :
1167 0 : aCode = pFormatter->GenerateFormat(
1168 : nCurrentNumberFormat,//modify
1169 : eLanguage,
1170 : bThousand,
1171 : bNegRed,
1172 : nPrecision,
1173 0 : nLeadZeroes);
1174 0 : pTabViewShell->SetNumFmtByStr(aCode);
1175 0 : delete[] sFormat;
1176 : }
1177 : }
1178 0 : break;
1179 :
1180 : case SID_ATTR_NUMBERFORMAT_VALUE:
1181 0 : if ( pReqArgs )
1182 : {
1183 : const SfxPoolItem* pItem;
1184 0 : if ( pReqArgs->GetItemState( ATTR_VALUE_FORMAT, true, &pItem ) == SfxItemState::SET )
1185 : {
1186 : // We have to accomplish this using ApplyAttributes()
1187 : // because we also need the language information to be
1188 : // considered.
1189 : const SfxItemSet& rOldSet =
1190 0 : pTabViewShell->GetSelectionPattern()->GetItemSet();
1191 0 : SfxItemPool* pDocPool = GetViewData()->GetDocument()->GetPool();
1192 0 : SfxItemSet aNewSet( *pDocPool, ATTR_PATTERN_START, ATTR_PATTERN_END );
1193 0 : aNewSet.Put( *pItem );
1194 0 : pTabViewShell->ApplyAttributes( &aNewSet, &rOldSet, true );
1195 : }
1196 : }
1197 0 : break;
1198 :
1199 : case SID_NUMBER_TYPE_FORMAT:
1200 0 : if ( pReqArgs )
1201 : {
1202 : const SfxPoolItem* pItem;
1203 0 : if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
1204 : {
1205 0 : sal_uInt16 nFormat = static_cast<const SfxInt16Item *>(pItem)->GetValue();
1206 0 : switch(nFormat)
1207 : {
1208 : case 0:
1209 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER); //Modify
1210 0 : break;
1211 : case 1:
1212 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER, 2 ); //Modify
1213 0 : break;
1214 : case 2:
1215 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_PERCENT );
1216 0 : break;
1217 : case 3:
1218 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_CURRENCY );
1219 0 : break;
1220 : case 4:
1221 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_DATE );
1222 0 : break;
1223 : case 5:
1224 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_TIME );
1225 0 : break;
1226 : case 6:
1227 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_SCIENTIFIC );
1228 0 : break;
1229 : case 7:
1230 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_FRACTION );
1231 0 : break;
1232 : case 8:
1233 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_LOGICAL );
1234 0 : break;
1235 : case 9:
1236 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_TEXT );
1237 0 : break;
1238 : default:
1239 : ;
1240 : }
1241 0 : rReq.Done();
1242 : }
1243 : }
1244 0 : break;
1245 :
1246 : default:
1247 : OSL_FAIL("falscher Slot bei ExecuteEdit");
1248 0 : break;
1249 0 : }
1250 0 : }
1251 :
1252 0 : void ScFormatShell::ExecuteAlignment( SfxRequest& rReq )
1253 : {
1254 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1255 0 : SfxBindings& rBindings = pViewData->GetBindings();
1256 0 : const SfxItemSet* pSet = rReq.GetArgs();
1257 0 : sal_uInt16 nSlot = rReq.GetSlot();
1258 :
1259 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1260 :
1261 0 : switch( nSlot )
1262 : {
1263 : // pseudo slots for Format menu
1264 : case SID_ALIGN_ANY_HDEFAULT:
1265 : case SID_ALIGN_ANY_LEFT:
1266 : case SID_ALIGN_ANY_HCENTER:
1267 : case SID_ALIGN_ANY_RIGHT:
1268 : case SID_ALIGN_ANY_JUSTIFIED:
1269 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( lclConvertSlotToHAlign( nSlot ), ATTR_HOR_JUSTIFY ) );
1270 0 : break;
1271 : case SID_ALIGN_ANY_VDEFAULT:
1272 : case SID_ALIGN_ANY_TOP:
1273 : case SID_ALIGN_ANY_VCENTER:
1274 : case SID_ALIGN_ANY_BOTTOM:
1275 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( lclConvertSlotToVAlign( nSlot ), ATTR_VER_JUSTIFY ) );
1276 0 : break;
1277 :
1278 : default:
1279 0 : if( pSet )
1280 : {
1281 0 : const SfxPoolItem* pItem = NULL;
1282 0 : if( pSet->GetItemState(GetPool().GetWhich(nSlot), true, &pItem ) == SfxItemState::SET )
1283 : {
1284 :
1285 0 : switch ( nSlot )
1286 : {
1287 : case SID_ATTR_ALIGN_HOR_JUSTIFY:
1288 : case SID_ATTR_ALIGN_VER_JUSTIFY:
1289 : case SID_ATTR_ALIGN_INDENT:
1290 : case SID_ATTR_ALIGN_HYPHENATION:
1291 : case SID_ATTR_ALIGN_DEGREES:
1292 : case SID_ATTR_ALIGN_LOCKPOS:
1293 : case SID_ATTR_ALIGN_MARGIN:
1294 : case SID_ATTR_ALIGN_STACKED:
1295 0 : pTabViewShell->ApplyAttr( *pItem );
1296 0 : break;
1297 :
1298 : case SID_H_ALIGNCELL:
1299 : {
1300 0 : SvxCellHorJustify eJust = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem*>(pItem)->GetValue();
1301 : // #i78476# update alignment of text in cell edit mode
1302 0 : pTabViewShell->UpdateInputHandlerCellAdjust( eJust );
1303 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( eJust, ATTR_HOR_JUSTIFY ) );
1304 : }
1305 0 : break;
1306 : case SID_V_ALIGNCELL:
1307 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( (SvxCellVerJustify)static_cast<const SvxVerJustifyItem*>(pItem)->GetValue(), ATTR_VER_JUSTIFY ) );
1308 0 : break;
1309 : default:
1310 : OSL_FAIL( "ExecuteAlignment: invalid slot" );
1311 0 : return;
1312 : }
1313 : }
1314 : }
1315 : }
1316 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
1317 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
1318 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
1319 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
1320 0 : rBindings.Invalidate( SID_ALIGNLEFT );
1321 0 : rBindings.Invalidate( SID_ALIGNRIGHT );
1322 0 : rBindings.Invalidate( SID_ALIGNCENTERHOR );
1323 0 : rBindings.Invalidate( SID_ALIGNBLOCK );
1324 0 : rBindings.Invalidate( SID_ALIGNTOP );
1325 0 : rBindings.Invalidate( SID_ALIGNBOTTOM );
1326 0 : rBindings.Invalidate( SID_ALIGNCENTERVER );
1327 0 : rBindings.Invalidate( SID_V_ALIGNCELL );
1328 0 : rBindings.Invalidate( SID_H_ALIGNCELL );
1329 : // pseudo slots for Format menu
1330 0 : rBindings.Invalidate( SID_ALIGN_ANY_HDEFAULT );
1331 0 : rBindings.Invalidate( SID_ALIGN_ANY_LEFT );
1332 0 : rBindings.Invalidate( SID_ALIGN_ANY_HCENTER );
1333 0 : rBindings.Invalidate( SID_ALIGN_ANY_RIGHT );
1334 0 : rBindings.Invalidate( SID_ALIGN_ANY_JUSTIFIED );
1335 0 : rBindings.Invalidate( SID_ALIGN_ANY_VDEFAULT );
1336 0 : rBindings.Invalidate( SID_ALIGN_ANY_TOP );
1337 0 : rBindings.Invalidate( SID_ALIGN_ANY_VCENTER );
1338 0 : rBindings.Invalidate( SID_ALIGN_ANY_BOTTOM );
1339 0 : rBindings.Update();
1340 :
1341 0 : if( ! rReq.IsAPI() )
1342 0 : rReq.Done();
1343 : }
1344 :
1345 0 : void ScFormatShell::ExecuteTextAttr( SfxRequest& rReq )
1346 : {
1347 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1348 0 : SfxBindings& rBindings = pViewData->GetBindings();
1349 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1350 0 : const SfxItemSet* pSet = rReq.GetArgs();
1351 0 : sal_uInt16 nSlot = rReq.GetSlot();
1352 0 : SfxAllItemSet* pNewSet = 0;
1353 :
1354 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1355 :
1356 0 : if ( (nSlot == SID_ATTR_CHAR_WEIGHT)
1357 0 : ||(nSlot == SID_ATTR_CHAR_POSTURE)
1358 0 : ||(nSlot == SID_ATTR_CHAR_UNDERLINE)
1359 0 : ||(nSlot == SID_ULINE_VAL_NONE)
1360 0 : ||(nSlot == SID_ULINE_VAL_SINGLE)
1361 0 : ||(nSlot == SID_ULINE_VAL_DOUBLE)
1362 0 : ||(nSlot == SID_ULINE_VAL_DOTTED) )
1363 : {
1364 0 : pNewSet = new SfxAllItemSet( GetPool() );
1365 :
1366 0 : switch ( nSlot )
1367 : {
1368 : case SID_ATTR_CHAR_WEIGHT:
1369 : {
1370 : // #i78017 establish the same behaviour as in Writer
1371 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1372 :
1373 0 : SfxItemPool& rPool = GetPool();
1374 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1375 0 : if ( pSet )
1376 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_WEIGHT ) );
1377 : else
1378 : {
1379 : // toggle manually
1380 :
1381 0 : FontWeight eWeight = WEIGHT_BOLD;
1382 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1383 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1384 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1385 0 : if ( pCore && static_cast<const SvxWeightItem*>(pCore)->GetWeight() == WEIGHT_BOLD )
1386 0 : eWeight = WEIGHT_NORMAL;
1387 :
1388 0 : aSetItem.PutItemForScriptType( nScript, SvxWeightItem( eWeight, ATTR_FONT_WEIGHT ) );
1389 : }
1390 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1391 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1392 : }
1393 0 : break;
1394 :
1395 : case SID_ATTR_CHAR_POSTURE:
1396 : {
1397 : // #i78017 establish the same behaviour as in Writer
1398 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1399 :
1400 0 : SfxItemPool& rPool = GetPool();
1401 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1402 0 : if ( pSet )
1403 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_POSTURE ) );
1404 : else
1405 : {
1406 : // toggle manually
1407 :
1408 0 : FontItalic eItalic = ITALIC_NORMAL;
1409 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1410 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1411 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1412 0 : if ( pCore && static_cast<const SvxPostureItem*>(pCore)->GetPosture() == ITALIC_NORMAL )
1413 0 : eItalic = ITALIC_NONE;
1414 :
1415 0 : aSetItem.PutItemForScriptType( nScript, SvxPostureItem( eItalic, ATTR_FONT_POSTURE ) );
1416 : }
1417 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1418 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1419 : }
1420 0 : break;
1421 :
1422 : case SID_ATTR_CHAR_UNDERLINE:
1423 : {
1424 : FontUnderline eUnderline;
1425 :
1426 0 : if( pSet )
1427 : {
1428 0 : const SfxPoolItem& rUnderline = pSet->Get( ATTR_FONT_UNDERLINE );
1429 :
1430 0 : if( rUnderline.ISA(SvxUnderlineItem) )
1431 : {
1432 0 : pTabViewShell->ApplyAttr( rUnderline );
1433 0 : pNewSet->Put( rUnderline,rUnderline.Which() );
1434 : }
1435 0 : else if ( rUnderline.ISA(SvxTextLineItem) )
1436 : {
1437 : // #i106580# also allow SvxTextLineItem (base class of SvxUnderlineItem)
1438 0 : const SvxTextLineItem& rTextLineItem = static_cast<const SvxTextLineItem&>(rUnderline);
1439 0 : SvxUnderlineItem aNewItem( rTextLineItem.GetLineStyle(), rTextLineItem.Which() );
1440 0 : aNewItem.SetColor( rTextLineItem.GetColor() );
1441 0 : pTabViewShell->ApplyAttr( aNewItem );
1442 0 : pNewSet->Put( aNewItem, aNewItem.Which() );
1443 : }
1444 : }
1445 : else
1446 : {
1447 : SvxUnderlineItem aUnderline( static_cast<const SvxUnderlineItem&>(
1448 : pAttrs->GetItem(
1449 0 : ATTR_FONT_UNDERLINE ) ) );
1450 0 : eUnderline = (UNDERLINE_NONE != aUnderline.GetLineStyle())
1451 : ? UNDERLINE_NONE
1452 0 : : UNDERLINE_SINGLE;
1453 0 : aUnderline.SetLineStyle( eUnderline );
1454 0 : pTabViewShell->ApplyAttr( aUnderline );
1455 0 : pNewSet->Put( aUnderline,aUnderline.Which() );
1456 : }
1457 : }
1458 0 : break;
1459 :
1460 : case SID_ULINE_VAL_NONE:
1461 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( UNDERLINE_NONE, ATTR_FONT_UNDERLINE ) );
1462 0 : break;
1463 : case SID_ULINE_VAL_SINGLE: // Toggles
1464 : case SID_ULINE_VAL_DOUBLE:
1465 : case SID_ULINE_VAL_DOTTED:
1466 : {
1467 : FontUnderline eOld = static_cast<const SvxUnderlineItem&>(
1468 0 : pAttrs->GetItem(ATTR_FONT_UNDERLINE)).GetLineStyle();
1469 0 : FontUnderline eNew = eOld;
1470 0 : switch (nSlot)
1471 : {
1472 : case SID_ULINE_VAL_SINGLE:
1473 0 : eNew = ( eOld == UNDERLINE_SINGLE ) ? UNDERLINE_NONE : UNDERLINE_SINGLE;
1474 0 : break;
1475 : case SID_ULINE_VAL_DOUBLE:
1476 0 : eNew = ( eOld == UNDERLINE_DOUBLE ) ? UNDERLINE_NONE : UNDERLINE_DOUBLE;
1477 0 : break;
1478 : case SID_ULINE_VAL_DOTTED:
1479 0 : eNew = ( eOld == UNDERLINE_DOTTED ) ? UNDERLINE_NONE : UNDERLINE_DOTTED;
1480 0 : break;
1481 : }
1482 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( eNew, ATTR_FONT_UNDERLINE ) );
1483 : }
1484 0 : break;
1485 :
1486 : default:
1487 0 : break;
1488 : }
1489 0 : rBindings.Invalidate( nSlot );
1490 : }
1491 : else
1492 : {
1493 : /*
1494 : * "Selbstgemachte" RadioButton-Funktionalitaet
1495 : * Beim Toggle gibt es den Standard-State, d.h. kein
1496 : * Button ist gedrueckt
1497 : */
1498 :
1499 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1500 0 : const SfxPoolItem* pItem = NULL;
1501 0 : const SvxHorJustifyItem* pHorJustify = NULL;
1502 0 : const SvxVerJustifyItem* pVerJustify = NULL;
1503 0 : SvxCellHorJustify eHorJustify = SVX_HOR_JUSTIFY_STANDARD;
1504 0 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
1505 :
1506 0 : if (rAttrSet.GetItemState(ATTR_HOR_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1507 : {
1508 0 : pHorJustify = static_cast<const SvxHorJustifyItem*>(pItem);
1509 0 : eHorJustify = SvxCellHorJustify( pHorJustify->GetValue() );
1510 : }
1511 0 : if (rAttrSet.GetItemState(ATTR_VER_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1512 : {
1513 0 : pVerJustify = static_cast<const SvxVerJustifyItem*>(pItem);
1514 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
1515 : }
1516 :
1517 0 : switch ( nSlot )
1518 : {
1519 : case SID_ALIGNLEFT:
1520 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1521 : rReq.AppendItem( SvxHorJustifyItem(
1522 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_LEFT) ?
1523 0 : SVX_HOR_JUSTIFY_LEFT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1524 0 : ExecuteSlot( rReq, GetInterface() );
1525 0 : return;
1526 : //break;
1527 :
1528 : case SID_ALIGNRIGHT:
1529 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1530 : rReq.AppendItem( SvxHorJustifyItem(
1531 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_RIGHT) ?
1532 0 : SVX_HOR_JUSTIFY_RIGHT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1533 0 : ExecuteSlot( rReq, GetInterface() );
1534 0 : return;
1535 : //break;
1536 :
1537 : case SID_ALIGNCENTERHOR:
1538 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1539 : rReq.AppendItem( SvxHorJustifyItem(
1540 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_CENTER) ?
1541 0 : SVX_HOR_JUSTIFY_CENTER : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1542 0 : ExecuteSlot( rReq, GetInterface() );
1543 0 : return;
1544 : //break;
1545 :
1546 : case SID_ALIGNBLOCK:
1547 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1548 : rReq.AppendItem( SvxHorJustifyItem(
1549 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_BLOCK) ?
1550 0 : SVX_HOR_JUSTIFY_BLOCK : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1551 0 : ExecuteSlot( rReq, GetInterface() );
1552 0 : return;
1553 : //break;
1554 :
1555 : case SID_ALIGNTOP:
1556 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1557 : rReq.AppendItem( SvxVerJustifyItem(
1558 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_TOP) ?
1559 0 : SVX_VER_JUSTIFY_TOP : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1560 0 : ExecuteSlot( rReq, GetInterface() );
1561 0 : return;
1562 : //break;
1563 :
1564 : case SID_ALIGNBOTTOM:
1565 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1566 : rReq.AppendItem( SvxVerJustifyItem(
1567 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_BOTTOM) ?
1568 0 : SVX_VER_JUSTIFY_BOTTOM : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1569 0 : ExecuteSlot( rReq, GetInterface() );
1570 0 : return;
1571 : //break;
1572 :
1573 : case SID_ALIGNCENTERVER:
1574 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1575 : rReq.AppendItem( SvxVerJustifyItem(
1576 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_CENTER) ?
1577 0 : SVX_VER_JUSTIFY_CENTER : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1578 0 : ExecuteSlot( rReq, GetInterface() );
1579 0 : return;
1580 : //break;
1581 :
1582 : default:
1583 0 : break;
1584 : }
1585 :
1586 : }
1587 :
1588 0 : rBindings.Update();
1589 :
1590 0 : if( pNewSet )
1591 : {
1592 0 : rReq.Done( *pNewSet );
1593 0 : delete pNewSet;
1594 : }
1595 : else
1596 : {
1597 0 : rReq.Done();
1598 : }
1599 :
1600 : }
1601 :
1602 232 : void ScFormatShell::ExecuteAttr( SfxRequest& rReq )
1603 : {
1604 232 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1605 232 : SfxBindings& rBindings = pViewData->GetBindings();
1606 232 : const SfxItemSet* pNewAttrs = rReq.GetArgs();
1607 232 : sal_uInt16 nSlot = rReq.GetSlot();
1608 :
1609 232 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1610 232 : ScDocument* pDoc = GetViewData()->GetDocument();
1611 232 : if ( !pNewAttrs )
1612 : {
1613 0 : switch ( nSlot )
1614 : {
1615 : case SID_ATTR_CHAR_ENDPREVIEW_FONT:
1616 : {
1617 0 : pDoc->SetPreviewFont(NULL);
1618 0 : pTabViewShell->UpdateSelectionArea( pDoc->GetPreviewSelection() );
1619 0 : break;
1620 : }
1621 : case SID_ATTR_CHAR_COLOR:
1622 : case SID_ATTR_CHAR_FONT:
1623 : case SID_ATTR_CHAR_FONTHEIGHT:
1624 0 : pTabViewShell->ExecuteCellFormatDlg(rReq, "font"); // wenn ToolBar vertikal
1625 0 : break;
1626 :
1627 : case SID_BACKGROUND_COLOR:
1628 : {
1629 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1630 0 : pTabViewShell->GetSelectionPattern()->GetItem( ATTR_BACKGROUND ) ) );
1631 0 : aBrushItem.SetColor( COL_TRANSPARENT );
1632 0 : pTabViewShell->ApplyAttr( aBrushItem );
1633 : }
1634 0 : break;
1635 :
1636 : case SID_ATTR_ALIGN_LINEBREAK: // ohne Parameter als Toggle
1637 : {
1638 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1639 0 : bool bOld = static_cast<const SfxBoolItem&>(pAttrs->GetItem(ATTR_LINEBREAK)).GetValue();
1640 0 : SfxBoolItem aBreakItem( ATTR_LINEBREAK, !bOld );
1641 0 : pTabViewShell->ApplyAttr( aBreakItem );
1642 :
1643 0 : SfxAllItemSet aNewSet( GetPool() );
1644 0 : aNewSet.Put( aBreakItem,aBreakItem.Which() );
1645 0 : rReq.Done( aNewSet );
1646 :
1647 0 : rBindings.Invalidate( nSlot );
1648 : }
1649 0 : break;
1650 : }
1651 : }
1652 : else
1653 : {
1654 232 : switch ( nSlot )
1655 : {
1656 : case SID_ATTR_CHAR_PREVIEW_FONT:
1657 : {
1658 232 : SfxItemPool& rPool = GetPool();
1659 232 : sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1660 232 : const SvxFontItem& rFont = static_cast<const SvxFontItem&>(pNewAttrs->Get( nWhich ));
1661 232 : SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, rPool );
1662 232 : sal_uInt8 nScript = pTabViewShell->GetSelectionScriptType();
1663 232 : aSetItem.PutItemForScriptType( nScript, rFont );
1664 :
1665 464 : ScMarkData aFuncMark( pViewData->GetMarkData() );
1666 232 : ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1667 232 : pDoc->SetPreviewFont( aSetItem.GetItemSet().Clone() );
1668 232 : aFuncMark.MarkToMulti();
1669 :
1670 232 : if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
1671 : {
1672 230 : SCCOL nCol = pViewData->GetCurX();
1673 230 : SCROW nRow = pViewData->GetCurY();
1674 230 : SCTAB nTab = pViewData->GetTabNo();
1675 230 : ScRange aRange( nCol, nRow, nTab );
1676 230 : aFuncMark.SetMarkArea( aRange );
1677 : }
1678 232 : pDoc->SetPreviewSelection( aFuncMark );
1679 232 : pTabViewShell->UpdateSelectionArea( aFuncMark );
1680 464 : break;
1681 : }
1682 : case SID_ATTR_CHAR_OVERLINE:
1683 : case SID_ATTR_CHAR_STRIKEOUT:
1684 : case SID_ATTR_ALIGN_LINEBREAK:
1685 : case SID_ATTR_CHAR_COLOR:
1686 : case SID_ATTR_CHAR_CONTOUR:
1687 : case SID_ATTR_CHAR_SHADOWED:
1688 : case SID_ATTR_CHAR_RELIEF:
1689 : case SID_SCATTR_PROTECTION :
1690 0 : pTabViewShell->ApplyAttr( pNewAttrs->Get( pNewAttrs->GetPool()->GetWhich( nSlot ) ) );
1691 0 : rBindings.Invalidate( nSlot );
1692 0 : rBindings.Update( nSlot );
1693 0 : break;
1694 :
1695 : case SID_ATTR_CHAR_FONT:
1696 : case SID_ATTR_CHAR_FONTHEIGHT:
1697 : {
1698 : // #i78017 establish the same behaviour as in Writer
1699 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1700 0 : if (nSlot == SID_ATTR_CHAR_FONT)
1701 0 : nScript = pTabViewShell->GetSelectionScriptType();
1702 :
1703 0 : SfxItemPool& rPool = GetPool();
1704 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1705 0 : sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1706 0 : aSetItem.PutItemForScriptType( nScript, pNewAttrs->Get( nWhich ) );
1707 :
1708 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1709 :
1710 0 : rBindings.Invalidate( nSlot );
1711 0 : rBindings.Update( nSlot );
1712 : }
1713 0 : break;
1714 :
1715 : case SID_FRAME_LINESTYLE:
1716 : {
1717 : // Default-Linie aktualisieren
1718 : const ::editeng::SvxBorderLine* pLine =
1719 : static_cast<const SvxLineItem&>(
1720 0 : pNewAttrs->Get( SID_FRAME_LINESTYLE )).
1721 0 : GetLine();
1722 :
1723 0 : if ( pLine )
1724 : {
1725 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1726 :
1727 0 : if ( pDefLine )
1728 : {
1729 : pDefLine->SetBorderLineStyle(
1730 0 : pLine->GetBorderLineStyle());
1731 0 : pDefLine->SetWidth( pLine->GetWidth( ) );
1732 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, false );
1733 : }
1734 : else
1735 : {
1736 0 : pTabViewShell->SetDefaultFrameLine( pLine );
1737 0 : pTabViewShell->GetDefaultFrameLine()->SetColor( COL_BLACK );
1738 0 : pTabViewShell->SetSelectionFrameLines( pLine, false );
1739 : }
1740 : }
1741 : else
1742 : {
1743 0 : Color aColorBlack( COL_BLACK );
1744 : ::editeng::SvxBorderLine aDefLine( &aColorBlack, 20,
1745 0 : table::BorderLineStyle::SOLID );
1746 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1747 0 : pTabViewShell->SetSelectionFrameLines( NULL, false );
1748 : }
1749 : }
1750 0 : break;
1751 :
1752 : case SID_FRAME_LINECOLOR:
1753 : {
1754 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1755 : const Color& rColor = static_cast<const SvxColorItem&>(
1756 0 : pNewAttrs->Get( SID_FRAME_LINECOLOR )).
1757 0 : GetValue();
1758 :
1759 : // Default-Linie aktualisieren
1760 0 : if ( pDefLine )
1761 : {
1762 0 : pDefLine->SetColor( rColor );
1763 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, true );
1764 : }
1765 : else
1766 : {
1767 : ::editeng::SvxBorderLine aDefLine( &rColor, 20,
1768 0 : table::BorderLineStyle::SOLID );
1769 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1770 0 : pTabViewShell->SetSelectionFrameLines( &aDefLine, false );
1771 : }
1772 : }
1773 0 : break;
1774 :
1775 : case SID_ATTR_BORDER_OUTER:
1776 : case SID_ATTR_BORDER:
1777 : {
1778 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1779 0 : const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1780 : boost::scoped_ptr<SfxItemSet> pOldSet(
1781 : new SfxItemSet(
1782 0 : *(pDoc->GetPool()),
1783 : ATTR_PATTERN_START,
1784 0 : ATTR_PATTERN_END ));
1785 : boost::scoped_ptr<SfxItemSet> pNewSet(
1786 : new SfxItemSet(
1787 0 : *(pDoc->GetPool()),
1788 : ATTR_PATTERN_START,
1789 0 : ATTR_PATTERN_END ));
1790 : const SfxPoolItem& rBorderAttr =
1791 0 : pOldAttrs->GetItemSet().
1792 0 : Get( ATTR_BORDER );
1793 :
1794 : // Border-Items vom Controller auswerten:
1795 0 : const SfxPoolItem* pItem = 0;
1796 :
1797 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER, true, &pItem )
1798 : == SfxItemState::SET )
1799 : {
1800 : // The SvxFrameToolBoxControl toolbox controller uses a default
1801 : // SvxBorderLine (all widths 0) to mark the lines that should be set.
1802 : // Macro recording uses a SvxBoxItem with the real values (OutWidth > 0)
1803 : // or NULL pointers for no lines.
1804 : // -> Substitute existing lines with pDefLine only if widths are 0.
1805 0 : SvxBoxItem aBoxItem ( *static_cast<const SvxBoxItem*>(pItem ));
1806 0 : if ( aBoxItem.GetTop() && aBoxItem.GetTop()->GetOutWidth() == 0 )
1807 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_TOP );
1808 0 : if ( aBoxItem.GetBottom() && aBoxItem.GetBottom()->GetOutWidth() == 0 )
1809 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_BOTTOM );
1810 0 : if ( aBoxItem.GetLeft() && aBoxItem.GetLeft()->GetOutWidth() == 0 )
1811 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_LEFT );
1812 0 : if ( aBoxItem.GetRight() && aBoxItem.GetRight()->GetOutWidth() == 0 )
1813 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_RIGHT );
1814 0 : pNewSet->Put( aBoxItem );
1815 0 : rReq.AppendItem( aBoxItem );
1816 : }
1817 :
1818 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER_INNER, true, &pItem )
1819 : == SfxItemState::SET )
1820 : {
1821 0 : SvxBoxInfoItem aBoxInfoItem( *static_cast<const SvxBoxInfoItem*>(pItem) );
1822 0 : if ( aBoxInfoItem.GetHori() && aBoxInfoItem.GetHori()->GetOutWidth() == 0 )
1823 0 : aBoxInfoItem.SetLine( pDefLine, BOXINFO_LINE_HORI );
1824 0 : if ( aBoxInfoItem.GetVert() && aBoxInfoItem.GetVert()->GetOutWidth() == 0 )
1825 0 : aBoxInfoItem.SetLine( pDefLine, BOXINFO_LINE_VERT );
1826 0 : pNewSet->Put( aBoxInfoItem );
1827 0 : rReq.AppendItem( aBoxInfoItem );
1828 : }
1829 : else
1830 : {
1831 0 : SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
1832 0 : aBoxInfoItem.SetLine( NULL, BOXINFO_LINE_HORI );
1833 0 : aBoxInfoItem.SetLine( NULL, BOXINFO_LINE_VERT );
1834 0 : pNewSet->Put( aBoxInfoItem );
1835 : }
1836 :
1837 0 : pOldSet->Put( rBorderAttr );
1838 0 : pTabViewShell->ApplyAttributes( pNewSet.get(), pOldSet.get() );
1839 : }
1840 0 : break;
1841 :
1842 : case SID_ATTR_BORDER_DIAG_TLBR:
1843 : case SID_ATTR_BORDER_DIAG_BLTR:
1844 : {
1845 0 : const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1846 0 : boost::scoped_ptr<SfxItemSet> pOldSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1847 0 : boost::scoped_ptr<SfxItemSet> pNewSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1848 0 : const SfxPoolItem* pItem = 0;
1849 :
1850 0 : if(SID_ATTR_BORDER_DIAG_TLBR == nSlot)
1851 : {
1852 0 : if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_TLBR, true, &pItem))
1853 : {
1854 0 : SvxLineItem aItem(ATTR_BORDER_TLBR);
1855 0 : aItem.SetLine(static_cast<const SvxLineItem&>(pNewAttrs->Get(ATTR_BORDER_TLBR)).GetLine());
1856 0 : pNewSet->Put(aItem);
1857 0 : rReq.AppendItem(aItem);
1858 0 : pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1859 : }
1860 : }
1861 : else // if( nSlot == SID_ATTR_BORDER_DIAG_BLTR )
1862 : {
1863 0 : if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_BLTR, true, &pItem ))
1864 : {
1865 0 : SvxLineItem aItem(ATTR_BORDER_BLTR);
1866 0 : aItem.SetLine(static_cast<const SvxLineItem&>(pNewAttrs->Get(ATTR_BORDER_BLTR)).GetLine());
1867 0 : pNewSet->Put(aItem);
1868 0 : rReq.AppendItem(aItem);
1869 0 : pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1870 : }
1871 : }
1872 :
1873 0 : rBindings.Invalidate(nSlot);
1874 : }
1875 0 : break;
1876 :
1877 : // ATTR_BACKGROUND (=SID_ATTR_BRUSH) muss ueber zwei IDs
1878 : // gesetzt werden:
1879 : case SID_BACKGROUND_COLOR:
1880 : {
1881 : const SvxColorItem rNewColorItem = static_cast<const SvxColorItem&>(
1882 0 : pNewAttrs->Get( SID_BACKGROUND_COLOR ) );
1883 :
1884 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1885 : pTabViewShell->GetSelectionPattern()->
1886 0 : GetItem( ATTR_BACKGROUND ) ) );
1887 :
1888 0 : aBrushItem.SetColor( rNewColorItem.GetValue() );
1889 :
1890 0 : pTabViewShell->ApplyAttr( aBrushItem );
1891 : }
1892 0 : break;
1893 :
1894 : case SID_ATTR_BRUSH:
1895 : {
1896 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1897 : pTabViewShell->GetSelectionPattern()->
1898 0 : GetItem( ATTR_BACKGROUND ) ) );
1899 : const SvxBrushItem& rNewBrushItem = static_cast<const SvxBrushItem&>(
1900 0 : pNewAttrs->Get( GetPool().GetWhich(nSlot) ) );
1901 0 : aBrushItem.SetColor(rNewBrushItem.GetColor());
1902 0 : pTabViewShell->ApplyAttr( aBrushItem );
1903 : }
1904 0 : break;
1905 :
1906 : case SID_ATTR_BORDER_SHADOW:
1907 : {
1908 : const SvxShadowItem& rNewShadowItem = static_cast<const SvxShadowItem&>(
1909 0 : pNewAttrs->Get( ATTR_SHADOW ) );
1910 0 : pTabViewShell->ApplyAttr( rNewShadowItem );
1911 : }
1912 0 : break;
1913 :
1914 : default:
1915 0 : break;
1916 : }
1917 :
1918 232 : if( ! rReq.IsAPI() )
1919 232 : if( ! rReq.IsDone() )
1920 232 : rReq.Done();
1921 : }
1922 232 : }
1923 :
1924 2103 : void ScFormatShell::GetAttrState( SfxItemSet& rSet )
1925 : {
1926 2103 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1927 2103 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1928 : //const ::editeng::SvxBorderLine* pLine = pTabViewShell->GetDefaultFrameLine();
1929 2103 : const SvxBrushItem& rBrushItem = static_cast<const SvxBrushItem&>(rAttrSet.Get( ATTR_BACKGROUND ));
1930 2103 : SfxWhichIter aIter( rSet );
1931 2103 : sal_uInt16 nWhich = aIter.FirstWhich();
1932 :
1933 2103 : rSet.Put( rAttrSet, false );
1934 :
1935 : // choose font info according to selection script type
1936 2103 : sal_uInt8 nScript = 0; // GetSelectionScriptType never returns 0
1937 2103 : if ( rSet.GetItemState( ATTR_FONT ) != SfxItemState::UNKNOWN )
1938 : {
1939 479 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1940 479 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT, nScript );
1941 : }
1942 2103 : if ( rSet.GetItemState( ATTR_FONT_HEIGHT ) != SfxItemState::UNKNOWN )
1943 : {
1944 247 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1945 247 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_HEIGHT, nScript );
1946 : }
1947 :
1948 6414 : while ( nWhich )
1949 : {
1950 2208 : switch(nWhich)
1951 : {
1952 : case SID_BACKGROUND_COLOR:
1953 : {
1954 247 : rSet.Put( SvxColorItem( rBrushItem.GetColor(), SID_BACKGROUND_COLOR ) );
1955 :
1956 247 : if(SfxItemState::DONTCARE == rAttrSet.GetItemState(ATTR_BACKGROUND))
1957 : {
1958 0 : rSet.InvalidateItem(SID_BACKGROUND_COLOR);
1959 : }
1960 : }
1961 247 : break;
1962 : case SID_FRAME_LINESTYLE:
1963 : case SID_FRAME_LINECOLOR:
1964 : {
1965 : // handled together because both need the cell border information for decisions
1966 : // rSet.Put( SvxColorItem( pLine ? pLine->GetColor() : Color(), SID_FRAME_LINECOLOR ) );
1967 494 : Color aCol = 0;
1968 494 : editeng::SvxBorderLine aLine(0,0,0,false);
1969 494 : bool bCol = false;
1970 494 : bool bColDisable = false, bStyleDisable = false;
1971 494 : SvxBoxItem aBoxItem(ATTR_BORDER);
1972 988 : SvxBoxInfoItem aInfoItem(ATTR_BORDER_INNER);
1973 :
1974 494 : pTabViewShell->GetSelectionFrame(aBoxItem, aInfoItem);
1975 :
1976 494 : if( aBoxItem.GetTop() )
1977 : {
1978 0 : bCol = true;
1979 0 : aCol = aBoxItem.GetTop()->GetColor() ;
1980 0 : aLine.SetColor(aCol);
1981 0 : aLine.SetWidth( aBoxItem.GetTop()->GetWidth());
1982 0 : aLine.SetBorderLineStyle( aBoxItem.GetTop()->GetBorderLineStyle());
1983 : }
1984 :
1985 494 : if( aBoxItem.GetBottom() )
1986 : {
1987 0 : if(!bCol)
1988 : {
1989 0 : bCol = true;
1990 0 : aCol = aBoxItem.GetBottom()->GetColor() ;
1991 0 : aLine.SetColor(aCol);
1992 0 : aLine.SetWidth( aBoxItem.GetBottom()->GetWidth());
1993 0 : aLine.SetBorderLineStyle( aBoxItem.GetBottom()->GetBorderLineStyle());
1994 : }
1995 : else
1996 : {
1997 0 : if(aCol != aBoxItem.GetBottom()->GetColor() )
1998 0 : bColDisable = true;
1999 0 : if(!( aLine == *(aBoxItem.GetBottom())) )
2000 0 : bStyleDisable = true;
2001 : }
2002 : }
2003 :
2004 494 : if( aBoxItem.GetLeft() )
2005 : {
2006 0 : if(!bCol)
2007 : {
2008 0 : bCol = true;
2009 0 : aCol = aBoxItem.GetLeft()->GetColor() ;
2010 0 : aLine.SetColor(aCol);
2011 0 : aLine.SetWidth( aBoxItem.GetLeft()->GetWidth());
2012 0 : aLine.SetBorderLineStyle( aBoxItem.GetLeft()->GetBorderLineStyle());
2013 : }
2014 : else
2015 : {
2016 0 : if(aCol != aBoxItem.GetLeft()->GetColor() )
2017 0 : bColDisable = true;
2018 0 : if(!( aLine == *(aBoxItem.GetLeft())) )
2019 0 : bStyleDisable = true;
2020 : }
2021 : }
2022 :
2023 494 : if( aBoxItem.GetRight() )
2024 : {
2025 0 : if(!bCol)
2026 : {
2027 0 : bCol = true;
2028 0 : aCol = aBoxItem.GetRight()->GetColor() ;
2029 0 : aLine.SetColor(aCol);
2030 0 : aLine.SetWidth( aBoxItem.GetRight()->GetWidth());
2031 0 : aLine.SetBorderLineStyle( aBoxItem.GetRight()->GetBorderLineStyle());
2032 : }
2033 : else
2034 : {
2035 0 : if(aCol != aBoxItem.GetRight()->GetColor() )
2036 0 : bColDisable = true;
2037 0 : if(!( aLine == *(aBoxItem.GetRight())) )
2038 0 : bStyleDisable = true;
2039 : }
2040 : }
2041 :
2042 494 : if( aInfoItem.GetVert())
2043 : {
2044 0 : if(!bCol)
2045 : {
2046 0 : bCol = true;
2047 0 : aCol = aInfoItem.GetVert()->GetColor() ;
2048 0 : aLine.SetColor(aCol);
2049 0 : aLine.SetWidth( aInfoItem.GetVert()->GetWidth());
2050 0 : aLine.SetBorderLineStyle( aInfoItem.GetVert()->GetBorderLineStyle());
2051 : }
2052 : else
2053 : {
2054 0 : if(aCol != aInfoItem.GetVert()->GetColor() )
2055 0 : bColDisable = true;
2056 0 : if(!( aLine == *(aInfoItem.GetVert())) )
2057 0 : bStyleDisable = true;
2058 : }
2059 : }
2060 :
2061 494 : if( aInfoItem.GetHori())
2062 : {
2063 0 : if(!bCol)
2064 : {
2065 0 : bCol = true;
2066 0 : aCol = aInfoItem.GetHori()->GetColor() ;
2067 0 : aLine.SetColor(aCol);
2068 0 : aLine.SetWidth( aInfoItem.GetHori()->GetWidth());
2069 0 : aLine.SetBorderLineStyle( aInfoItem.GetHori()->GetBorderLineStyle());
2070 : }
2071 : else
2072 : {
2073 0 : if(aCol != aInfoItem.GetHori()->GetColor() )
2074 0 : bColDisable = true;
2075 0 : if(!( aLine == *(aInfoItem.GetHori())) )
2076 0 : bStyleDisable = true;
2077 : }
2078 : }
2079 :
2080 988 : if( !aInfoItem.IsValid( VALID_VERT )
2081 494 : || !aInfoItem.IsValid( VALID_HORI )
2082 494 : || !aInfoItem.IsValid( VALID_LEFT )
2083 494 : || !aInfoItem.IsValid( VALID_RIGHT )
2084 494 : || !aInfoItem.IsValid( VALID_TOP )
2085 988 : || !aInfoItem.IsValid( VALID_BOTTOM ) )
2086 : {
2087 0 : bColDisable = true;
2088 0 : bStyleDisable = true;
2089 : }
2090 :
2091 494 : if(SID_FRAME_LINECOLOR == nWhich)
2092 : {
2093 247 : if(bColDisable) // if different lines have differernt colors
2094 : {
2095 0 : aCol = COL_TRANSPARENT;
2096 0 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2097 0 : rSet.InvalidateItem(SID_FRAME_LINECOLOR);
2098 : }
2099 247 : else if( !bCol && !bColDisable) // if no line available
2100 : {
2101 247 : aCol = COL_AUTO;
2102 247 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2103 : }
2104 : else
2105 0 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2106 : }
2107 : else // if( nWhich == SID_FRAME_LINESTYLE)
2108 : {
2109 247 : if(bStyleDisable) // if have several lines but don't have same style
2110 : {
2111 0 : aLine.SetWidth( 1 );
2112 0 : SvxLineItem aItem(SID_FRAME_LINESTYLE);
2113 0 : aItem.SetLine(&aLine);
2114 0 : rSet.Put( aItem );
2115 0 : rSet.InvalidateItem(SID_FRAME_LINESTYLE);
2116 : }
2117 : else // all the lines have same style or no line availavle, use initial value (0,0,0,0)
2118 : {
2119 247 : SvxLineItem aItem(SID_FRAME_LINESTYLE);
2120 247 : aItem.SetLine(&aLine);
2121 247 : rSet.Put( aItem );
2122 : }
2123 494 : }
2124 : }
2125 494 : break;
2126 : case SID_ATTR_BRUSH:
2127 : {
2128 0 : rSet.Put( rBrushItem, GetPool().GetWhich(nWhich) );
2129 : }
2130 0 : break;
2131 : }
2132 2208 : nWhich = aIter.NextWhich();
2133 : }
2134 :
2135 : // stuff for sidebar panels
2136 2103 : Invalidate(SID_ATTR_ALIGN_DEGREES);
2137 2103 : Invalidate(SID_ATTR_ALIGN_STACKED);
2138 2103 : }
2139 :
2140 2567 : void ScFormatShell::GetTextAttrState( SfxItemSet& rSet )
2141 : {
2142 2567 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2143 2567 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2144 2567 : rSet.Put( rAttrSet, false ); // ItemStates mitkopieren
2145 :
2146 : // choose font info according to selection script type
2147 2567 : sal_uInt8 nScript = 0; // GetSelectionScriptType never returns 0
2148 2567 : if ( rSet.GetItemState( ATTR_FONT_WEIGHT ) != SfxItemState::UNKNOWN )
2149 : {
2150 247 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
2151 247 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_WEIGHT, nScript );
2152 : }
2153 2567 : if ( rSet.GetItemState( ATTR_FONT_POSTURE ) != SfxItemState::UNKNOWN )
2154 : {
2155 247 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
2156 247 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_POSTURE, nScript );
2157 : }
2158 :
2159 : SfxItemState eState;
2160 : // const SfxPoolItem* pItem;
2161 :
2162 : // eigene Kontrolle ueber RadioButton-Funktionalitaet:
2163 :
2164 : // Unterstreichung
2165 :
2166 2567 : eState = rAttrSet.GetItemState( ATTR_FONT_UNDERLINE, true );
2167 2567 : if ( eState == SfxItemState::DONTCARE )
2168 : {
2169 0 : rSet.InvalidateItem( SID_ULINE_VAL_NONE );
2170 0 : rSet.InvalidateItem( SID_ULINE_VAL_SINGLE );
2171 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOUBLE );
2172 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOTTED );
2173 : }
2174 : else
2175 : {
2176 : FontUnderline eUnderline = static_cast<const SvxUnderlineItem&>(
2177 2567 : rAttrSet.Get(ATTR_FONT_UNDERLINE)).GetLineStyle();
2178 2567 : sal_uInt16 nId = SID_ULINE_VAL_NONE;
2179 2567 : switch (eUnderline)
2180 : {
2181 0 : case UNDERLINE_SINGLE: nId = SID_ULINE_VAL_SINGLE; break;
2182 0 : case UNDERLINE_DOUBLE: nId = SID_ULINE_VAL_DOUBLE; break;
2183 0 : case UNDERLINE_DOTTED: nId = SID_ULINE_VAL_DOTTED; break;
2184 : default:
2185 2567 : break;
2186 : }
2187 2567 : rSet.Put( SfxBoolItem( nId, true ) );
2188 : }
2189 :
2190 : // horizontale Ausrichtung
2191 :
2192 2567 : const SvxHorJustifyItem* pHorJustify = NULL;
2193 2567 : const SvxVerJustifyItem* pVerJustify = NULL;
2194 2567 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
2195 2567 : sal_uInt16 nWhich = 0;
2196 2567 : bool bJustifyStd = false;
2197 2567 : SfxBoolItem aBoolItem ( 0, true );
2198 :
2199 : eState = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY, true,
2200 2567 : (const SfxPoolItem**)&pHorJustify );
2201 2567 : switch ( eState )
2202 : {
2203 : case SfxItemState::SET:
2204 : {
2205 22 : switch ( SvxCellHorJustify( pHorJustify->GetValue() ) )
2206 : {
2207 : case SVX_HOR_JUSTIFY_STANDARD:
2208 0 : break;
2209 :
2210 : case SVX_HOR_JUSTIFY_LEFT:
2211 22 : nWhich = SID_ALIGNLEFT;
2212 22 : break;
2213 :
2214 : case SVX_HOR_JUSTIFY_RIGHT:
2215 0 : nWhich = SID_ALIGNRIGHT;
2216 0 : break;
2217 :
2218 : case SVX_HOR_JUSTIFY_CENTER:
2219 0 : nWhich = SID_ALIGNCENTERHOR;
2220 0 : break;
2221 :
2222 : case SVX_HOR_JUSTIFY_BLOCK:
2223 0 : nWhich = SID_ALIGNBLOCK;
2224 0 : break;
2225 :
2226 : case SVX_HOR_JUSTIFY_REPEAT:
2227 : default:
2228 0 : bJustifyStd = true;
2229 0 : break;
2230 : }
2231 : }
2232 22 : break;
2233 :
2234 : case SfxItemState::DONTCARE:
2235 0 : rSet.InvalidateItem( SID_ALIGNLEFT );
2236 0 : rSet.InvalidateItem( SID_ALIGNRIGHT );
2237 0 : rSet.InvalidateItem( SID_ALIGNCENTERHOR );
2238 0 : rSet.InvalidateItem( SID_ALIGNBLOCK );
2239 0 : break;
2240 :
2241 : default:
2242 2545 : bJustifyStd = true;
2243 2545 : break;
2244 : }
2245 :
2246 2567 : if ( nWhich )
2247 : {
2248 22 : aBoolItem.SetWhich( nWhich );
2249 22 : rSet.Put( aBoolItem );
2250 : }
2251 2545 : else if ( bJustifyStd )
2252 : {
2253 2545 : aBoolItem.SetValue( false );
2254 2545 : aBoolItem.SetWhich( SID_ALIGNLEFT ); rSet.Put( aBoolItem );
2255 2545 : aBoolItem.SetWhich( SID_ALIGNRIGHT ); rSet.Put( aBoolItem );
2256 2545 : aBoolItem.SetWhich( SID_ALIGNCENTERHOR ); rSet.Put( aBoolItem );
2257 2545 : aBoolItem.SetWhich( SID_ALIGNBLOCK ); rSet.Put( aBoolItem );
2258 2545 : bJustifyStd = false;
2259 : }
2260 :
2261 : // vertikale Ausrichtung
2262 :
2263 2567 : nWhich = 0;
2264 2567 : aBoolItem.SetValue( true );
2265 :
2266 : eState = rAttrSet.GetItemState( ATTR_VER_JUSTIFY, true,
2267 2567 : (const SfxPoolItem**)&pVerJustify );
2268 :
2269 2567 : switch ( eState )
2270 : {
2271 : case SfxItemState::SET:
2272 : {
2273 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
2274 :
2275 0 : switch ( eVerJustify )
2276 : {
2277 : case SVX_VER_JUSTIFY_TOP:
2278 0 : nWhich = SID_ALIGNTOP;
2279 0 : break;
2280 :
2281 : case SVX_VER_JUSTIFY_BOTTOM:
2282 0 : nWhich = SID_ALIGNBOTTOM;
2283 0 : break;
2284 :
2285 : case SVX_VER_JUSTIFY_CENTER:
2286 0 : nWhich = SID_ALIGNCENTERVER;
2287 0 : break;
2288 :
2289 : case SVX_VER_JUSTIFY_STANDARD:
2290 : default:
2291 0 : bJustifyStd = true;
2292 0 : break;
2293 : }
2294 : }
2295 0 : break;
2296 :
2297 : case SfxItemState::DONTCARE:
2298 0 : rSet.InvalidateItem( SID_ALIGNTOP );
2299 0 : rSet.InvalidateItem( SID_ALIGNBOTTOM );
2300 0 : rSet.InvalidateItem( SID_ALIGNCENTERVER );
2301 0 : break;
2302 :
2303 : default:
2304 2567 : bJustifyStd = true;
2305 2567 : break;
2306 : }
2307 :
2308 2567 : if ( nWhich )
2309 : {
2310 0 : aBoolItem.SetWhich( nWhich );
2311 0 : rSet.Put( aBoolItem );
2312 : }
2313 2567 : else if ( bJustifyStd )
2314 : {
2315 2567 : aBoolItem.SetValue( false );
2316 2567 : aBoolItem.SetWhich( SID_ALIGNTOP ); rSet.Put( aBoolItem );
2317 2567 : aBoolItem.SetWhich( SID_ALIGNBOTTOM ); rSet.Put( aBoolItem );
2318 2567 : aBoolItem.SetWhich( SID_ALIGNCENTERVER ); rSet.Put( aBoolItem );
2319 2567 : }
2320 2567 : }
2321 :
2322 0 : void ScFormatShell::GetBorderState( SfxItemSet& rSet )
2323 : {
2324 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2325 0 : SvxBoxItem aBoxItem( ATTR_BORDER );
2326 0 : SvxBoxInfoItem aInfoItem( ATTR_BORDER_INNER );
2327 :
2328 0 : pTabViewShell->GetSelectionFrame( aBoxItem, aInfoItem );
2329 :
2330 0 : if ( rSet.GetItemState( ATTR_BORDER ) != SfxItemState::UNKNOWN )
2331 0 : rSet.Put( aBoxItem );
2332 0 : if ( rSet.GetItemState( ATTR_BORDER_INNER ) != SfxItemState::UNKNOWN )
2333 0 : rSet.Put( aInfoItem );
2334 0 : }
2335 :
2336 0 : void ScFormatShell::GetAlignState( SfxItemSet& rSet )
2337 : {
2338 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2339 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2340 0 : SfxWhichIter aIter(rSet);
2341 0 : sal_uInt16 nWhich = aIter.FirstWhich();
2342 :
2343 0 : SvxCellHorJustify eHAlign = SVX_HOR_JUSTIFY_STANDARD;
2344 0 : bool bHasHAlign = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY ) != SfxItemState::DONTCARE;
2345 0 : if( bHasHAlign )
2346 0 : eHAlign = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem&>(rAttrSet.Get( ATTR_HOR_JUSTIFY )).GetValue();
2347 :
2348 0 : SvxCellVerJustify eVAlign = SVX_VER_JUSTIFY_STANDARD;
2349 0 : bool bHasVAlign = rAttrSet.GetItemState( ATTR_VER_JUSTIFY ) != SfxItemState::DONTCARE;
2350 0 : if( bHasVAlign )
2351 0 : eVAlign = (SvxCellVerJustify)static_cast<const SvxVerJustifyItem&>(rAttrSet.Get( ATTR_VER_JUSTIFY )).GetValue();
2352 :
2353 0 : while ( nWhich )
2354 : {
2355 0 : switch ( nWhich )
2356 : {
2357 : case SID_H_ALIGNCELL:
2358 0 : if ( bHasHAlign )
2359 0 : rSet.Put( SvxHorJustifyItem( eHAlign, nWhich ));
2360 0 : break;
2361 : case SID_V_ALIGNCELL:
2362 0 : if ( bHasVAlign )
2363 0 : rSet.Put( SvxVerJustifyItem( eVAlign, nWhich ));
2364 0 : break;
2365 :
2366 : // pseudo slots for Format menu
2367 : case SID_ALIGN_ANY_HDEFAULT:
2368 : case SID_ALIGN_ANY_LEFT:
2369 : case SID_ALIGN_ANY_HCENTER:
2370 : case SID_ALIGN_ANY_RIGHT:
2371 : case SID_ALIGN_ANY_JUSTIFIED:
2372 0 : rSet.Put( SfxBoolItem( nWhich, bHasHAlign && (eHAlign == lclConvertSlotToHAlign( nWhich )) ) );
2373 0 : break;
2374 : case SID_ALIGN_ANY_VDEFAULT:
2375 : case SID_ALIGN_ANY_TOP:
2376 : case SID_ALIGN_ANY_VCENTER:
2377 : case SID_ALIGN_ANY_BOTTOM:
2378 0 : rSet.Put( SfxBoolItem( nWhich, bHasVAlign && (eVAlign == lclConvertSlotToVAlign( nWhich )) ) );
2379 0 : break;
2380 : }
2381 0 : nWhich = aIter.NextWhich();
2382 0 : }
2383 0 : }
2384 :
2385 938 : void ScFormatShell::GetNumFormatState( SfxItemSet& rSet )
2386 : {
2387 938 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2388 938 : ScDocument* pDoc = pViewData->GetDocument();
2389 938 : short nType = GetCurrentNumberFormatType();
2390 :
2391 938 : SfxWhichIter aIter(rSet);
2392 938 : sal_uInt16 nWhich = aIter.FirstWhich();
2393 2844 : while ( nWhich )
2394 : {
2395 968 : switch ( nWhich )
2396 : {
2397 : case SID_NUMBER_FORMAT:
2398 : //{
2399 : // String aFormatCode; // bleibt leer, wenn dont-care
2400 : //
2401 : // const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2402 : // if ( rAttrSet.GetItemState( ATTR_VALUE_FORMAT ) != SfxItemState::DONTCARE )
2403 : // {
2404 : // sal_uLong nNumberFormat = ((const SfxUInt32Item&)rAttrSet.Get(
2405 : // ATTR_VALUE_FORMAT )).GetValue();
2406 : //
2407 : // SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
2408 : // const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2409 : // if ( pFormatEntry )
2410 : // aFormatCode = pFormatEntry->GetFormatstring();
2411 : // }
2412 : //
2413 : // rSet.Put( SfxStringItem( nWhich, aFormatCode ) );
2414 : //}
2415 :
2416 : // symphony version with format interpretation
2417 : {
2418 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2419 :
2420 0 : if(SfxItemState::DONTCARE != rAttrSet.GetItemState(ATTR_VALUE_FORMAT))
2421 : {
2422 0 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2423 0 : sal_uInt32 nNumberFormat = static_cast<const SfxUInt32Item&>(rAttrSet.Get(ATTR_VALUE_FORMAT)).GetValue();
2424 0 : bool bThousand(false);
2425 0 : bool bNegRed(false);
2426 0 : sal_uInt16 nPrecision(0);
2427 0 : sal_uInt16 nLeadZeroes(0);
2428 :
2429 0 : pFormatter->GetFormatSpecialInfo(nNumberFormat,bThousand, bNegRed, nPrecision, nLeadZeroes);
2430 0 : OUString aFormat;
2431 0 : static OUString sBreak = ",";
2432 0 : const OUString sThousand = OUString::number(static_cast<sal_Int32>(bThousand));
2433 0 : const OUString sNegRed = OUString::number(static_cast<sal_Int32>(bNegRed));
2434 0 : const OUString sPrecision = OUString::number(nPrecision);
2435 0 : const OUString sLeadZeroes = OUString::number(nLeadZeroes);
2436 :
2437 0 : aFormat += sThousand;
2438 0 : aFormat += sBreak;
2439 0 : aFormat += sNegRed;
2440 0 : aFormat += sBreak;
2441 0 : aFormat += sPrecision;
2442 0 : aFormat += sBreak;
2443 0 : aFormat += sLeadZeroes;
2444 0 : aFormat += sBreak;
2445 :
2446 0 : rSet.Put(SfxStringItem(nWhich, aFormat));
2447 : }
2448 : else
2449 : {
2450 0 : rSet.InvalidateItem( nWhich );
2451 : }
2452 : }
2453 0 : break;
2454 :
2455 : case SID_NUMBER_TYPE_FORMAT:
2456 : {
2457 0 : sal_Int16 aFormatCode = -1;
2458 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2459 0 : if ( rAttrSet.GetItemState( ATTR_VALUE_FORMAT ) >= SfxItemState::DEFAULT ) //Modify for more robust
2460 : {
2461 0 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2462 0 : sal_uInt32 nNumberFormat = pTabViewShell->GetSelectionPattern()->GetNumberFormat( pFormatter );
2463 0 : const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2464 0 : bool bStandard = false;
2465 :
2466 0 : if ( pFormatEntry )
2467 : {
2468 0 : aFormatCode = pFormatEntry->GetType();
2469 0 : bStandard = pFormatEntry->IsStandard();
2470 : }
2471 :
2472 0 : switch(aFormatCode)
2473 : {
2474 : case NUMBERFORMAT_NUMBER:
2475 : case NUMBERFORMAT_NUMBER| NUMBERFORMAT_DEFINED:
2476 : //use format code and standard format code to judge whether it is General,
2477 : //if (nNumberFormat == nStandardNumberFormat)
2478 0 : if (bStandard)
2479 0 : aFormatCode = 0;
2480 : else
2481 0 : aFormatCode = 1;
2482 0 : break;
2483 : case NUMBERFORMAT_PERCENT:
2484 : case NUMBERFORMAT_PERCENT| NUMBERFORMAT_DEFINED:
2485 0 : aFormatCode = 2;
2486 0 : break;
2487 : case NUMBERFORMAT_CURRENCY:
2488 : case NUMBERFORMAT_CURRENCY| NUMBERFORMAT_DEFINED:
2489 0 : aFormatCode = 3;
2490 0 : break;
2491 : case NUMBERFORMAT_DATE:
2492 : case NUMBERFORMAT_DATE| NUMBERFORMAT_DEFINED:
2493 : //Add
2494 : case NUMBERFORMAT_DATETIME:
2495 : case NUMBERFORMAT_DATETIME | NUMBERFORMAT_DEFINED:
2496 0 : aFormatCode = 4;
2497 0 : break;
2498 : case NUMBERFORMAT_TIME:
2499 : case NUMBERFORMAT_TIME| NUMBERFORMAT_DEFINED:
2500 0 : aFormatCode = 5;
2501 0 : break;
2502 : case NUMBERFORMAT_SCIENTIFIC:
2503 : case NUMBERFORMAT_SCIENTIFIC| NUMBERFORMAT_DEFINED:
2504 0 : aFormatCode = 6;
2505 0 : break;
2506 : case NUMBERFORMAT_FRACTION:
2507 : case NUMBERFORMAT_FRACTION| NUMBERFORMAT_DEFINED:
2508 0 : aFormatCode = 7;
2509 0 : break;
2510 : case NUMBERFORMAT_LOGICAL:
2511 : case NUMBERFORMAT_LOGICAL| NUMBERFORMAT_DEFINED:
2512 0 : aFormatCode = 8;
2513 0 : break;
2514 : case NUMBERFORMAT_TEXT:
2515 : case NUMBERFORMAT_TEXT| NUMBERFORMAT_DEFINED:
2516 0 : aFormatCode = 9;
2517 0 : break;
2518 : default:
2519 0 : aFormatCode = -1; //for more roburst
2520 : }
2521 0 : if( aFormatCode == -1 )
2522 0 : rSet.InvalidateItem( nWhich );
2523 : else
2524 0 : rSet.Put( SfxInt16Item( nWhich, aFormatCode ) );
2525 : }
2526 : else
2527 : {
2528 0 : rSet.InvalidateItem( nWhich );
2529 : }
2530 :
2531 : }
2532 0 : break;
2533 : case SID_NUMBER_SCIENTIFIC:
2534 242 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_SCIENTIFIC)) );
2535 242 : break;
2536 : case SID_NUMBER_DATE:
2537 242 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_DATE)) );
2538 242 : break;
2539 : case SID_NUMBER_CURRENCY:
2540 242 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_CURRENCY)) );
2541 242 : break;
2542 : case SID_NUMBER_PERCENT:
2543 242 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_PERCENT)) );
2544 242 : break;
2545 : case SID_NUMBER_TIME:
2546 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_TIME)) );
2547 0 : break;
2548 : }
2549 968 : nWhich = aIter.NextWhich();
2550 938 : }
2551 938 : }
2552 :
2553 0 : void ScFormatShell::ExecuteTextDirection( SfxRequest& rReq )
2554 : {
2555 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2556 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
2557 0 : bool bEditMode = false;
2558 0 : if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
2559 : {
2560 0 : bEditMode=true;
2561 0 : SC_MOD()->InputEnterHandler();
2562 0 : pTabViewShell->UpdateInputHandler();
2563 : }
2564 0 : sal_uInt16 nSlot = rReq.GetSlot();
2565 0 : switch( nSlot )
2566 : {
2567 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2568 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2569 : {
2570 0 : bool bVert = (nSlot == SID_TEXTDIRECTION_TOP_TO_BOTTOM);
2571 0 : ScPatternAttr aAttr( GetViewData()->GetDocument()->GetPool() );
2572 0 : SfxItemSet& rItemSet = aAttr.GetItemSet();
2573 0 : rItemSet.Put( SfxBoolItem( ATTR_STACKED, bVert ) );
2574 0 : rItemSet.Put( SfxBoolItem( ATTR_VERTICAL_ASIAN, bVert ) );
2575 0 : pTabViewShell->ApplySelectionPattern( aAttr );
2576 0 : pTabViewShell->AdjustBlockHeight();
2577 : }
2578 0 : break;
2579 :
2580 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2581 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2582 : {
2583 : SvxFrameDirection eDirection = ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) ?
2584 0 : FRMDIR_HORI_LEFT_TOP : FRMDIR_HORI_RIGHT_TOP;
2585 0 : pTabViewShell->ApplyAttr( SvxFrameDirectionItem( eDirection, ATTR_WRITINGDIR ) );
2586 : }
2587 0 : break;
2588 : }
2589 0 : if (bEditMode)
2590 0 : SC_MOD()->SetInputMode( SC_INPUT_TABLE );
2591 0 : }
2592 :
2593 3322 : void ScFormatShell::GetTextDirectionState( SfxItemSet& rSet )
2594 : {
2595 3322 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2596 3322 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2597 :
2598 : bool bVertDontCare =
2599 6644 : (rAttrSet.GetItemState( ATTR_VERTICAL_ASIAN ) == SfxItemState::DONTCARE) ||
2600 6644 : (rAttrSet.GetItemState( ATTR_STACKED ) == SfxItemState::DONTCARE);
2601 6644 : bool bLeftRight = !bVertDontCare &&
2602 6644 : !static_cast<const SfxBoolItem&>(rAttrSet.Get( ATTR_STACKED )).GetValue();
2603 3322 : bool bTopBottom = !bVertDontCare && !bLeftRight &&
2604 3322 : static_cast<const SfxBoolItem&>(rAttrSet.Get( ATTR_VERTICAL_ASIAN )).GetValue();
2605 :
2606 3322 : bool bBidiDontCare = (rAttrSet.GetItemState( ATTR_WRITINGDIR ) == SfxItemState::DONTCARE);
2607 3322 : EEHorizontalTextDirection eBidiDir = EE_HTEXTDIR_DEFAULT;
2608 3322 : if ( !bBidiDontCare )
2609 : {
2610 : SvxFrameDirection eCellDir = (SvxFrameDirection)static_cast<const SvxFrameDirectionItem&>(
2611 3322 : rAttrSet.Get( ATTR_WRITINGDIR )).GetValue();
2612 3322 : if ( eCellDir == FRMDIR_ENVIRONMENT )
2613 : eBidiDir = (EEHorizontalTextDirection)GetViewData()->GetDocument()->
2614 3322 : GetEditTextDirection( GetViewData()->GetTabNo() );
2615 0 : else if ( eCellDir == FRMDIR_HORI_RIGHT_TOP )
2616 0 : eBidiDir = EE_HTEXTDIR_R2L;
2617 : else
2618 0 : eBidiDir = EE_HTEXTDIR_L2R;
2619 : }
2620 :
2621 3322 : SvtLanguageOptions aLangOpt;
2622 3322 : bool bDisableCTLFont = !aLangOpt.IsCTLFontEnabled();
2623 3322 : bool bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled();
2624 :
2625 6644 : SfxWhichIter aIter( rSet );
2626 3322 : sal_uInt16 nWhich = aIter.FirstWhich();
2627 10016 : while( nWhich )
2628 : {
2629 3372 : switch( nWhich )
2630 : {
2631 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2632 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2633 484 : if ( bDisableVerticalText )
2634 0 : rSet.DisableItem( nWhich );
2635 : else
2636 : {
2637 484 : if( bVertDontCare )
2638 0 : rSet.InvalidateItem( nWhich );
2639 484 : else if ( nWhich == SID_TEXTDIRECTION_LEFT_TO_RIGHT )
2640 242 : rSet.Put( SfxBoolItem( nWhich, bLeftRight ) );
2641 : else
2642 242 : rSet.Put( SfxBoolItem( nWhich, bTopBottom ) );
2643 : }
2644 484 : break;
2645 :
2646 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2647 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2648 1212 : if ( bDisableCTLFont )
2649 0 : rSet.DisableItem( nWhich );
2650 : else
2651 : {
2652 1212 : if ( bTopBottom )
2653 0 : rSet.DisableItem( nWhich );
2654 1212 : else if ( bBidiDontCare )
2655 0 : rSet.InvalidateItem( nWhich );
2656 1212 : else if ( nWhich == SID_ATTR_PARA_LEFT_TO_RIGHT )
2657 606 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_L2R ) );
2658 : else
2659 606 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_R2L ) );
2660 : }
2661 : }
2662 3372 : nWhich = aIter.NextWhich();
2663 3322 : }
2664 3322 : }
2665 :
2666 0 : void ScFormatShell::ExecFormatPaintbrush( SfxRequest& rReq )
2667 : {
2668 0 : ScViewFunc* pView = pViewData->GetView();
2669 0 : if ( pView->HasPaintBrush() )
2670 : {
2671 : // cancel paintbrush mode
2672 0 : pView->ResetBrushDocument();
2673 : }
2674 : else
2675 : {
2676 0 : bool bLock = false;
2677 0 : const SfxItemSet *pArgs = rReq.GetArgs();
2678 0 : if( pArgs && pArgs->Count() >= 1 )
2679 0 : bLock = static_cast<const SfxBoolItem&>(pArgs->Get(SID_FORMATPAINTBRUSH)).GetValue();
2680 :
2681 : // in case of multi selection, deselect all and use the cursor position
2682 0 : ScRange aDummy;
2683 0 : if ( pViewData->GetSimpleArea(aDummy) != SC_MARK_SIMPLE )
2684 0 : pView->Unmark();
2685 :
2686 0 : ScDocument* pBrushDoc = new ScDocument( SCDOCMODE_CLIP );
2687 0 : pView->CopyToClip( pBrushDoc, false, true );
2688 0 : pView->SetBrushDocument( pBrushDoc, bLock );
2689 : }
2690 0 : }
2691 :
2692 247 : void ScFormatShell::StateFormatPaintbrush( SfxItemSet& rSet )
2693 : {
2694 247 : if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
2695 0 : rSet.DisableItem( SID_FORMATPAINTBRUSH );
2696 : else
2697 247 : rSet.Put( SfxBoolItem( SID_FORMATPAINTBRUSH, pViewData->GetView()->HasPaintBrush() ) );
2698 247 : }
2699 :
2700 938 : short ScFormatShell::GetCurrentNumberFormatType()
2701 : {
2702 938 : short nType = NUMBERFORMAT_ALL;
2703 938 : ScDocument* pDoc = GetViewData()->GetDocument();
2704 938 : ScMarkData aMark(GetViewData()->GetMarkData());
2705 938 : const SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2706 938 : if (!pFormatter)
2707 0 : return nType;
2708 :
2709 : // TODO: Find out how to get a selected table range in case multiple tables
2710 : // are selected. Currently we only check for the current active table.
2711 :
2712 938 : if ( aMark.IsMarked() || aMark.IsMultiMarked() )
2713 : {
2714 8 : aMark.MarkToMulti();
2715 8 : ScRange aRange;
2716 8 : aMark.GetMultiMarkArea(aRange);
2717 :
2718 8 : const ScMarkArray* pArray = aMark.GetArray();
2719 8 : if (!pArray)
2720 0 : return nType;
2721 :
2722 8 : short nComboType = NUMBERFORMAT_ALL;
2723 8 : bool bFirstItem = true;
2724 56 : for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
2725 : {
2726 48 : const ScMarkArray& rColArray = pArray[nCol];
2727 48 : if (!rColArray.HasMarks())
2728 0 : continue;
2729 :
2730 : SCROW nRow1, nRow2;
2731 48 : ScMarkArrayIter aMarkIter(&rColArray);
2732 144 : while (aMarkIter.Next(nRow1, nRow2))
2733 : {
2734 48 : ScRange aColRange(nCol, nRow1, aRange.aStart.Tab());
2735 48 : aColRange.aEnd.SetRow(nRow2);
2736 48 : sal_uInt32 nNumFmt = pDoc->GetNumberFormat(aColRange);
2737 48 : const SvNumberformat* pEntry = pFormatter->GetEntry(nNumFmt);
2738 48 : if (!pEntry)
2739 0 : return 0;
2740 :
2741 48 : short nThisType = pEntry->GetType();
2742 48 : if (bFirstItem)
2743 : {
2744 8 : bFirstItem = false;
2745 8 : nComboType = nThisType;
2746 : }
2747 40 : else if (nComboType != nThisType)
2748 : // mixed number format type.
2749 0 : return NUMBERFORMAT_ALL;
2750 : }
2751 48 : }
2752 8 : nType = nComboType;
2753 : }
2754 : else
2755 : {
2756 : sal_uInt32 nNumFmt;
2757 930 : pDoc->GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
2758 1860 : pViewData->GetTabNo(), nNumFmt );
2759 930 : const SvNumberformat* pEntry = pFormatter->GetEntry( nNumFmt );
2760 930 : nType = pEntry ? pEntry->GetType() : 0;
2761 : }
2762 938 : return nType;
2763 228 : }
2764 :
2765 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
