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 4080 : TYPEINIT1( ScFormatShell, SfxShell );
121 :
122 208 : SFX_IMPL_INTERFACE(ScFormatShell, SfxShell)
123 :
124 52 : void ScFormatShell::InitInterface_Impl()
125 : {
126 : GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_SERVER,
127 52 : RID_OBJECTBAR_FORMAT);
128 52 : }
129 :
130 3572 : ScFormatShell::ScFormatShell(ScViewData* pData) :
131 3572 : SfxShell(pData->GetViewShell()),
132 3572 : pViewData(pData)
133 : {
134 3572 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
135 :
136 3572 : SetPool( &pTabViewShell->GetPool() );
137 3572 : ::svl::IUndoManager* pMgr = pViewData->GetSfxDocShell()->GetUndoManager();
138 3572 : SetUndoManager( pMgr );
139 3572 : if ( !pViewData->GetDocument()->IsUndoEnabled() )
140 : {
141 0 : pMgr->SetMaxUndoActionCount( 0 );
142 : }
143 3572 : SetHelpId(HID_SCSHELL_FORMATSH);
144 3572 : SetName(OUString("Format"));
145 3572 : }
146 :
147 3569 : ScFormatShell::~ScFormatShell()
148 : {
149 3569 : }
150 :
151 108 : void ScFormatShell::GetStyleState( SfxItemSet& rSet )
152 : {
153 108 : ScDocument* pDoc = GetViewData()->GetDocument();
154 108 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
155 108 : SfxStyleSheetBasePool* pStylePool = pDoc->GetStyleSheetPool();
156 :
157 108 : bool bProtected = false;
158 108 : SCTAB nTabCount = pDoc->GetTableCount();
159 253 : for (SCTAB i=0; i<nTabCount; i++)
160 145 : if (pDoc->IsTabProtected(i)) // look after protected table
161 0 : bProtected = true;
162 :
163 108 : SfxWhichIter aIter(rSet);
164 108 : sal_uInt16 nWhich = aIter.FirstWhich();
165 108 : sal_uInt16 nSlotId = 0;
166 :
167 432 : while ( nWhich )
168 : {
169 216 : nSlotId = SfxItemPool::IsWhich( nWhich )
170 0 : ? GetPool().GetSlotId( nWhich )
171 216 : : nWhich;
172 :
173 216 : 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 = const_cast<SfxStyleSheet*>(
183 108 : pTabViewShell->GetStyleSheetFromMarked());
184 :
185 108 : if ( pStyleSheet )
186 108 : rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
187 : else
188 0 : rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
189 : }
190 108 : break;
191 :
192 : case SID_STYLE_FAMILY4: // page style sheets
193 : {
194 108 : SCTAB nCurTab = GetViewData()->GetTabNo();
195 108 : OUString aPageStyle = pDoc->GetPageStyle( nCurTab );
196 : SfxStyleSheet* pStyleSheet = pStylePool ? static_cast<SfxStyleSheet*>(pStylePool->
197 108 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE )) : NULL;
198 :
199 108 : if ( pStyleSheet )
200 108 : rSet.Put( SfxTemplateItem( nSlotId, aPageStyle ) );
201 : else
202 0 : rSet.Put( SfxTemplateItem( nSlotId, OUString() ) );
203 : }
204 108 : 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 216 : nWhich = aIter.NextWhich();
247 108 : }
248 108 : }
249 :
250 3224 : void ScFormatShell::ExecuteStyle( SfxRequest& rReq )
251 : {
252 : // in case of vertical toolbar
253 3224 : if ( !rReq.GetArgs() )
254 : {
255 0 : pViewData->GetDispatcher().Execute( SID_STYLE_DESIGNER, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
256 3224 : return;
257 : }
258 :
259 3224 : SfxBindings& rBindings = pViewData->GetBindings();
260 3224 : const SfxItemSet* pArgs = rReq.GetArgs();
261 3224 : const sal_uInt16 nSlotId = rReq.GetSlot();
262 3224 : const SCTAB nCurTab = GetViewData()->GetTabNo();
263 3224 : ScDocShell* pDocSh = GetViewData()->GetDocShell();
264 3224 : ScTabViewShell* pTabViewShell= GetViewData()->GetViewShell();
265 3224 : ScDocument& rDoc = pDocSh->GetDocument();
266 3224 : ScMarkData& rMark = GetViewData()->GetMarkData();
267 3224 : ScModule* pScMod = SC_MOD();
268 3224 : OUString aRefName;
269 3224 : bool bUndo = rDoc.IsUndoEnabled();
270 3224 : SfxStyleSheetBasePool* pStylePool = rDoc.GetStyleSheetPool();
271 :
272 3224 : if ( (nSlotId == SID_STYLE_PREVIEW)
273 3224 : || (nSlotId == SID_STYLE_END_PREVIEW) )
274 : {
275 3224 : 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 3224 : ScMarkData aPreviewMark( rDoc.GetPreviewSelection());
321 3224 : if (aPreviewMark.IsMarked() || aPreviewMark.IsMultiMarked())
322 : {
323 0 : ScPatternAttr aAttr( *rDoc.GetSelectionPattern( aPreviewMark ) );
324 0 : if ( ScStyleSheet* pPreviewStyle = rDoc.GetPreviewCellStyle() )
325 0 : aAttr.SetStyleSheet( pPreviewStyle );
326 0 : rDoc.SetPreviewCellStyle(NULL);
327 :
328 0 : SfxItemSet aItemSet( GetPool() );
329 :
330 0 : ScPatternAttr aNewAttrs( GetViewData()->GetDocument()->GetPool() );
331 0 : SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
332 0 : rNewSet.Put( aItemSet, false );
333 0 : rDoc.ApplySelectionPattern( aNewAttrs, aPreviewMark );
334 0 : pTabViewShell->UpdateSelectionArea( aPreviewMark, &aAttr );
335 3224 : }
336 3224 : }
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 == "CellStyles")
365 0 : eFamily = SFX_STYLE_FAMILY_PARA;
366 0 : else if (sFamily == "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(PointerStyle::Fill) );
469 0 : rReq.Done();
470 : }
471 : else
472 : {
473 0 : pScMod->SetWaterCan( false );
474 0 : pTabViewShell->SetActivePointer( Pointer(PointerStyle::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 = const_cast<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 = const_cast<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 : ScTabViewShell::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 : ScTabViewShell::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 3224 : }
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( css::util::NumberFormat::NUMBER, 4 ); // Standard+4 = #.##0,00
1025 0 : rReq.Done();
1026 0 : break;
1027 : case SID_NUMBER_SCIENTIFIC:
1028 0 : if ((nType & css::util::NumberFormat::SCIENTIFIC))
1029 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER );
1030 : else
1031 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::SCIENTIFIC );
1032 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & css::util::NumberFormat::SCIENTIFIC)) );
1033 0 : rBindings.Invalidate( nSlot );
1034 0 : rReq.Done();
1035 0 : break;
1036 : case SID_NUMBER_DATE:
1037 0 : if ((nType & css::util::NumberFormat::DATE))
1038 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER );
1039 : else
1040 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::DATE );
1041 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & css::util::NumberFormat::DATE)) );
1042 0 : rBindings.Invalidate( nSlot );
1043 0 : rReq.Done();
1044 0 : break;
1045 : case SID_NUMBER_TIME:
1046 0 : if ((nType & css::util::NumberFormat::TIME))
1047 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER );
1048 : else
1049 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::TIME );
1050 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & css::util::NumberFormat::TIME)) );
1051 0 : rBindings.Invalidate( nSlot );
1052 0 : rReq.Done();
1053 0 : break;
1054 : case SID_NUMBER_CURRENCY:
1055 0 : if ((nType & css::util::NumberFormat::CURRENCY))
1056 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER );
1057 : else
1058 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::CURRENCY );
1059 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & css::util::NumberFormat::CURRENCY)) );
1060 0 : rBindings.Invalidate( nSlot );
1061 0 : rReq.Done();
1062 0 : break;
1063 : case SID_NUMBER_PERCENT:
1064 0 : if ((nType & css::util::NumberFormat::PERCENT))
1065 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER );
1066 : else
1067 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::PERCENT );
1068 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & css::util::NumberFormat::PERCENT)) );
1069 0 : rBindings.Invalidate( nSlot );
1070 0 : rReq.Done();
1071 0 : break;
1072 : case SID_NUMBER_STANDARD:
1073 0 : pTabViewShell->SetNumberFormat( css::util::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/SCIENTIFIC
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 css::util::NumberFormat::ALL:
1120 : case css::util::NumberFormat::NUMBER:
1121 : case css::util::NumberFormat::NUMBER| css::util::NumberFormat::DEFINED:
1122 : case css::util::NumberFormat::PERCENT:
1123 : case css::util::NumberFormat::PERCENT| css::util::NumberFormat::DEFINED:
1124 : case css::util::NumberFormat::CURRENCY:
1125 : case css::util::NumberFormat::CURRENCY|css::util::NumberFormat::DEFINED:
1126 : case css::util::NumberFormat::SCIENTIFIC:
1127 : case css::util::NumberFormat::SCIENTIFIC|css::util::NumberFormat::DEFINED:
1128 0 : eType = 0;
1129 0 : break;
1130 : default:
1131 0 : eType =-1;
1132 : }
1133 :
1134 0 : if(SfxItemState::SET == pReqArgs->GetItemState(nSlot, true, &pItem) && eType != -1)
1135 : {
1136 0 : OUString aCode = static_cast<const SfxStringItem*>(pItem)->GetValue();
1137 0 : sal_uInt16 aLen = aCode.getLength();
1138 0 : OUString* sFormat = new OUString[4];
1139 0 : OUString sTmpStr = "";
1140 0 : sal_uInt16 nCount(0);
1141 0 : sal_uInt16 nStrCount(0);
1142 :
1143 0 : while(nCount < aLen)
1144 : {
1145 0 : sal_Unicode cChar = aCode[nCount];
1146 :
1147 0 : if(cChar == ',')
1148 : {
1149 0 : sFormat[nStrCount] = sTmpStr;
1150 0 : sTmpStr.clear();
1151 0 : nStrCount++;
1152 : }
1153 : else
1154 : {
1155 0 : sTmpStr += OUString(cChar);
1156 : }
1157 :
1158 0 : nCount++;
1159 :
1160 0 : if(nStrCount > 3)
1161 0 : break;
1162 : }
1163 :
1164 0 : const bool bThousand = (bool)sFormat[0].toInt32();
1165 0 : const bool bNegRed = (bool)sFormat[1].toInt32();
1166 0 : const sal_uInt16 nPrecision = (sal_uInt16)sFormat[2].toInt32();
1167 0 : const sal_uInt16 nLeadZeroes = (sal_uInt16)sFormat[3].toInt32();
1168 :
1169 0 : aCode = pFormatter->GenerateFormat(
1170 : nCurrentNumberFormat,//modify
1171 : eLanguage,
1172 : bThousand,
1173 : bNegRed,
1174 : nPrecision,
1175 0 : nLeadZeroes);
1176 0 : pTabViewShell->SetNumFmtByStr(aCode);
1177 0 : delete[] sFormat;
1178 : }
1179 : }
1180 0 : break;
1181 :
1182 : case SID_ATTR_NUMBERFORMAT_VALUE:
1183 0 : if ( pReqArgs )
1184 : {
1185 : const SfxPoolItem* pItem;
1186 0 : if ( pReqArgs->GetItemState( ATTR_VALUE_FORMAT, true, &pItem ) == SfxItemState::SET )
1187 : {
1188 : // We have to accomplish this using ApplyAttributes()
1189 : // because we also need the language information to be
1190 : // considered.
1191 : const SfxItemSet& rOldSet =
1192 0 : pTabViewShell->GetSelectionPattern()->GetItemSet();
1193 0 : SfxItemPool* pDocPool = GetViewData()->GetDocument()->GetPool();
1194 0 : SfxItemSet aNewSet( *pDocPool, ATTR_PATTERN_START, ATTR_PATTERN_END );
1195 0 : aNewSet.Put( *pItem );
1196 0 : pTabViewShell->ApplyAttributes( &aNewSet, &rOldSet, true );
1197 : }
1198 : }
1199 0 : break;
1200 :
1201 : case SID_NUMBER_TYPE_FORMAT:
1202 0 : if ( pReqArgs )
1203 : {
1204 : const SfxPoolItem* pItem;
1205 0 : if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )
1206 : {
1207 0 : sal_uInt16 nFormat = static_cast<const SfxInt16Item *>(pItem)->GetValue();
1208 0 : switch(nFormat)
1209 : {
1210 : case 0:
1211 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER); //Modify
1212 0 : break;
1213 : case 1:
1214 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::NUMBER, 2 ); //Modify
1215 0 : break;
1216 : case 2:
1217 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::PERCENT );
1218 0 : break;
1219 : case 3:
1220 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::CURRENCY );
1221 0 : break;
1222 : case 4:
1223 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::DATE );
1224 0 : break;
1225 : case 5:
1226 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::TIME );
1227 0 : break;
1228 : case 6:
1229 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::SCIENTIFIC );
1230 0 : break;
1231 : case 7:
1232 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::FRACTION );
1233 0 : break;
1234 : case 8:
1235 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::LOGICAL );
1236 0 : break;
1237 : case 9:
1238 0 : pTabViewShell->SetNumberFormat( css::util::NumberFormat::TEXT );
1239 0 : break;
1240 : default:
1241 : ;
1242 : }
1243 0 : rReq.Done();
1244 : }
1245 : }
1246 0 : break;
1247 :
1248 : default:
1249 : OSL_FAIL("falscher Slot bei ExecuteEdit");
1250 0 : break;
1251 0 : }
1252 0 : }
1253 :
1254 0 : void ScFormatShell::ExecuteAlignment( SfxRequest& rReq )
1255 : {
1256 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1257 0 : SfxBindings& rBindings = pViewData->GetBindings();
1258 0 : const SfxItemSet* pSet = rReq.GetArgs();
1259 0 : sal_uInt16 nSlot = rReq.GetSlot();
1260 :
1261 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1262 :
1263 0 : switch( nSlot )
1264 : {
1265 : // pseudo slots for Format menu
1266 : case SID_ALIGN_ANY_HDEFAULT:
1267 : case SID_ALIGN_ANY_LEFT:
1268 : case SID_ALIGN_ANY_HCENTER:
1269 : case SID_ALIGN_ANY_RIGHT:
1270 : case SID_ALIGN_ANY_JUSTIFIED:
1271 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( lclConvertSlotToHAlign( nSlot ), ATTR_HOR_JUSTIFY ) );
1272 0 : break;
1273 : case SID_ALIGN_ANY_VDEFAULT:
1274 : case SID_ALIGN_ANY_TOP:
1275 : case SID_ALIGN_ANY_VCENTER:
1276 : case SID_ALIGN_ANY_BOTTOM:
1277 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( lclConvertSlotToVAlign( nSlot ), ATTR_VER_JUSTIFY ) );
1278 0 : break;
1279 :
1280 : default:
1281 0 : if( pSet )
1282 : {
1283 0 : const SfxPoolItem* pItem = NULL;
1284 0 : if( pSet->GetItemState(GetPool().GetWhich(nSlot), true, &pItem ) == SfxItemState::SET )
1285 : {
1286 :
1287 0 : switch ( nSlot )
1288 : {
1289 : case SID_ATTR_ALIGN_HOR_JUSTIFY:
1290 : case SID_ATTR_ALIGN_VER_JUSTIFY:
1291 : case SID_ATTR_ALIGN_INDENT:
1292 : case SID_ATTR_ALIGN_HYPHENATION:
1293 : case SID_ATTR_ALIGN_DEGREES:
1294 : case SID_ATTR_ALIGN_LOCKPOS:
1295 : case SID_ATTR_ALIGN_MARGIN:
1296 : case SID_ATTR_ALIGN_STACKED:
1297 0 : pTabViewShell->ApplyAttr( *pItem );
1298 0 : break;
1299 :
1300 : case SID_H_ALIGNCELL:
1301 : {
1302 0 : SvxCellHorJustify eJust = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem*>(pItem)->GetValue();
1303 : // #i78476# update alignment of text in cell edit mode
1304 0 : pTabViewShell->UpdateInputHandlerCellAdjust( eJust );
1305 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( eJust, ATTR_HOR_JUSTIFY ) );
1306 : }
1307 0 : break;
1308 : case SID_V_ALIGNCELL:
1309 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( (SvxCellVerJustify)static_cast<const SvxVerJustifyItem*>(pItem)->GetValue(), ATTR_VER_JUSTIFY ) );
1310 0 : break;
1311 : default:
1312 : OSL_FAIL( "ExecuteAlignment: invalid slot" );
1313 0 : return;
1314 : }
1315 : }
1316 : }
1317 : }
1318 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
1319 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
1320 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
1321 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
1322 0 : rBindings.Invalidate( SID_ALIGNLEFT );
1323 0 : rBindings.Invalidate( SID_ALIGNRIGHT );
1324 0 : rBindings.Invalidate( SID_ALIGNCENTERHOR );
1325 0 : rBindings.Invalidate( SID_ALIGNBLOCK );
1326 0 : rBindings.Invalidate( SID_ALIGNTOP );
1327 0 : rBindings.Invalidate( SID_ALIGNBOTTOM );
1328 0 : rBindings.Invalidate( SID_ALIGNCENTERVER );
1329 0 : rBindings.Invalidate( SID_V_ALIGNCELL );
1330 0 : rBindings.Invalidate( SID_H_ALIGNCELL );
1331 : // pseudo slots for Format menu
1332 0 : rBindings.Invalidate( SID_ALIGN_ANY_HDEFAULT );
1333 0 : rBindings.Invalidate( SID_ALIGN_ANY_LEFT );
1334 0 : rBindings.Invalidate( SID_ALIGN_ANY_HCENTER );
1335 0 : rBindings.Invalidate( SID_ALIGN_ANY_RIGHT );
1336 0 : rBindings.Invalidate( SID_ALIGN_ANY_JUSTIFIED );
1337 0 : rBindings.Invalidate( SID_ALIGN_ANY_VDEFAULT );
1338 0 : rBindings.Invalidate( SID_ALIGN_ANY_TOP );
1339 0 : rBindings.Invalidate( SID_ALIGN_ANY_VCENTER );
1340 0 : rBindings.Invalidate( SID_ALIGN_ANY_BOTTOM );
1341 0 : rBindings.Update();
1342 :
1343 0 : if( ! rReq.IsAPI() )
1344 0 : rReq.Done();
1345 : }
1346 :
1347 0 : void ScFormatShell::ExecuteTextAttr( SfxRequest& rReq )
1348 : {
1349 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1350 0 : SfxBindings& rBindings = pViewData->GetBindings();
1351 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1352 0 : const SfxItemSet* pSet = rReq.GetArgs();
1353 0 : sal_uInt16 nSlot = rReq.GetSlot();
1354 0 : SfxAllItemSet* pNewSet = 0;
1355 :
1356 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1357 :
1358 0 : if ( (nSlot == SID_ATTR_CHAR_WEIGHT)
1359 0 : ||(nSlot == SID_ATTR_CHAR_POSTURE)
1360 0 : ||(nSlot == SID_ATTR_CHAR_UNDERLINE)
1361 0 : ||(nSlot == SID_ULINE_VAL_NONE)
1362 0 : ||(nSlot == SID_ULINE_VAL_SINGLE)
1363 0 : ||(nSlot == SID_ULINE_VAL_DOUBLE)
1364 0 : ||(nSlot == SID_ULINE_VAL_DOTTED) )
1365 : {
1366 0 : pNewSet = new SfxAllItemSet( GetPool() );
1367 :
1368 0 : switch ( nSlot )
1369 : {
1370 : case SID_ATTR_CHAR_WEIGHT:
1371 : {
1372 : // #i78017 establish the same behaviour as in Writer
1373 0 : SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1374 :
1375 0 : SfxItemPool& rPool = GetPool();
1376 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1377 0 : if ( pSet )
1378 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_WEIGHT ) );
1379 : else
1380 : {
1381 : // toggle manually
1382 :
1383 0 : FontWeight eWeight = WEIGHT_BOLD;
1384 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1385 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1386 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1387 0 : if ( pCore && static_cast<const SvxWeightItem*>(pCore)->GetWeight() == WEIGHT_BOLD )
1388 0 : eWeight = WEIGHT_NORMAL;
1389 :
1390 0 : aSetItem.PutItemForScriptType( nScript, SvxWeightItem( eWeight, ATTR_FONT_WEIGHT ) );
1391 : }
1392 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1393 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1394 : }
1395 0 : break;
1396 :
1397 : case SID_ATTR_CHAR_POSTURE:
1398 : {
1399 : // #i78017 establish the same behaviour as in Writer
1400 0 : SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1401 :
1402 0 : SfxItemPool& rPool = GetPool();
1403 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1404 0 : if ( pSet )
1405 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_POSTURE ) );
1406 : else
1407 : {
1408 : // toggle manually
1409 :
1410 0 : FontItalic eItalic = ITALIC_NORMAL;
1411 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1412 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1413 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1414 0 : if ( pCore && static_cast<const SvxPostureItem*>(pCore)->GetPosture() == ITALIC_NORMAL )
1415 0 : eItalic = ITALIC_NONE;
1416 :
1417 0 : aSetItem.PutItemForScriptType( nScript, SvxPostureItem( eItalic, ATTR_FONT_POSTURE ) );
1418 : }
1419 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1420 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1421 : }
1422 0 : break;
1423 :
1424 : case SID_ATTR_CHAR_UNDERLINE:
1425 : {
1426 : FontUnderline eUnderline;
1427 :
1428 0 : if( pSet )
1429 : {
1430 0 : const SfxPoolItem& rUnderline = pSet->Get( ATTR_FONT_UNDERLINE );
1431 :
1432 0 : if( rUnderline.ISA(SvxUnderlineItem) )
1433 : {
1434 0 : pTabViewShell->ApplyAttr( rUnderline );
1435 0 : pNewSet->Put( rUnderline,rUnderline.Which() );
1436 : }
1437 0 : else if ( rUnderline.ISA(SvxTextLineItem) )
1438 : {
1439 : // #i106580# also allow SvxTextLineItem (base class of SvxUnderlineItem)
1440 0 : const SvxTextLineItem& rTextLineItem = static_cast<const SvxTextLineItem&>(rUnderline);
1441 0 : SvxUnderlineItem aNewItem( rTextLineItem.GetLineStyle(), rTextLineItem.Which() );
1442 0 : aNewItem.SetColor( rTextLineItem.GetColor() );
1443 0 : pTabViewShell->ApplyAttr( aNewItem );
1444 0 : pNewSet->Put( aNewItem, aNewItem.Which() );
1445 : }
1446 : }
1447 : else
1448 : {
1449 : SvxUnderlineItem aUnderline( static_cast<const SvxUnderlineItem&>(
1450 : pAttrs->GetItem(
1451 0 : ATTR_FONT_UNDERLINE ) ) );
1452 0 : eUnderline = (UNDERLINE_NONE != aUnderline.GetLineStyle())
1453 : ? UNDERLINE_NONE
1454 0 : : UNDERLINE_SINGLE;
1455 0 : aUnderline.SetLineStyle( eUnderline );
1456 0 : pTabViewShell->ApplyAttr( aUnderline );
1457 0 : pNewSet->Put( aUnderline,aUnderline.Which() );
1458 : }
1459 : }
1460 0 : break;
1461 :
1462 : case SID_ULINE_VAL_NONE:
1463 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( UNDERLINE_NONE, ATTR_FONT_UNDERLINE ) );
1464 0 : break;
1465 : case SID_ULINE_VAL_SINGLE: // Toggles
1466 : case SID_ULINE_VAL_DOUBLE:
1467 : case SID_ULINE_VAL_DOTTED:
1468 : {
1469 : FontUnderline eOld = static_cast<const SvxUnderlineItem&>(
1470 0 : pAttrs->GetItem(ATTR_FONT_UNDERLINE)).GetLineStyle();
1471 0 : FontUnderline eNew = eOld;
1472 0 : switch (nSlot)
1473 : {
1474 : case SID_ULINE_VAL_SINGLE:
1475 0 : eNew = ( eOld == UNDERLINE_SINGLE ) ? UNDERLINE_NONE : UNDERLINE_SINGLE;
1476 0 : break;
1477 : case SID_ULINE_VAL_DOUBLE:
1478 0 : eNew = ( eOld == UNDERLINE_DOUBLE ) ? UNDERLINE_NONE : UNDERLINE_DOUBLE;
1479 0 : break;
1480 : case SID_ULINE_VAL_DOTTED:
1481 0 : eNew = ( eOld == UNDERLINE_DOTTED ) ? UNDERLINE_NONE : UNDERLINE_DOTTED;
1482 0 : break;
1483 : }
1484 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( eNew, ATTR_FONT_UNDERLINE ) );
1485 : }
1486 0 : break;
1487 :
1488 : default:
1489 0 : break;
1490 : }
1491 0 : rBindings.Invalidate( nSlot );
1492 : }
1493 : else
1494 : {
1495 : /*
1496 : * "Selbstgemachte" RadioButton-Funktionalitaet
1497 : * Beim Toggle gibt es den Standard-State, d.h. kein
1498 : * Button ist gedrueckt
1499 : */
1500 :
1501 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1502 0 : const SfxPoolItem* pItem = NULL;
1503 0 : const SvxHorJustifyItem* pHorJustify = NULL;
1504 0 : const SvxVerJustifyItem* pVerJustify = NULL;
1505 0 : SvxCellHorJustify eHorJustify = SVX_HOR_JUSTIFY_STANDARD;
1506 0 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
1507 :
1508 0 : if (rAttrSet.GetItemState(ATTR_HOR_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1509 : {
1510 0 : pHorJustify = static_cast<const SvxHorJustifyItem*>(pItem);
1511 0 : eHorJustify = SvxCellHorJustify( pHorJustify->GetValue() );
1512 : }
1513 0 : if (rAttrSet.GetItemState(ATTR_VER_JUSTIFY, true,&pItem ) == SfxItemState::SET)
1514 : {
1515 0 : pVerJustify = static_cast<const SvxVerJustifyItem*>(pItem);
1516 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
1517 : }
1518 :
1519 0 : switch ( nSlot )
1520 : {
1521 : case SID_ALIGNLEFT:
1522 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1523 : rReq.AppendItem( SvxHorJustifyItem(
1524 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_LEFT) ?
1525 0 : SVX_HOR_JUSTIFY_LEFT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1526 0 : ExecuteSlot( rReq, GetInterface() );
1527 0 : return;
1528 :
1529 : case SID_ALIGNRIGHT:
1530 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1531 : rReq.AppendItem( SvxHorJustifyItem(
1532 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_RIGHT) ?
1533 0 : SVX_HOR_JUSTIFY_RIGHT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1534 0 : ExecuteSlot( rReq, GetInterface() );
1535 0 : return;
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 :
1545 : case SID_ALIGNBLOCK:
1546 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1547 : rReq.AppendItem( SvxHorJustifyItem(
1548 0 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_BLOCK) ?
1549 0 : SVX_HOR_JUSTIFY_BLOCK : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1550 0 : ExecuteSlot( rReq, GetInterface() );
1551 0 : return;
1552 :
1553 : case SID_ALIGNTOP:
1554 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1555 : rReq.AppendItem( SvxVerJustifyItem(
1556 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_TOP) ?
1557 0 : SVX_VER_JUSTIFY_TOP : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1558 0 : ExecuteSlot( rReq, GetInterface() );
1559 0 : return;
1560 :
1561 : case SID_ALIGNBOTTOM:
1562 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1563 : rReq.AppendItem( SvxVerJustifyItem(
1564 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_BOTTOM) ?
1565 0 : SVX_VER_JUSTIFY_BOTTOM : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1566 0 : ExecuteSlot( rReq, GetInterface() );
1567 0 : return;
1568 :
1569 : case SID_ALIGNCENTERVER:
1570 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1571 : rReq.AppendItem( SvxVerJustifyItem(
1572 0 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_CENTER) ?
1573 0 : SVX_VER_JUSTIFY_CENTER : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1574 0 : ExecuteSlot( rReq, GetInterface() );
1575 0 : return;
1576 :
1577 : default:
1578 0 : break;
1579 : }
1580 :
1581 : }
1582 :
1583 0 : rBindings.Update();
1584 :
1585 0 : if( pNewSet )
1586 : {
1587 0 : rReq.Done( *pNewSet );
1588 0 : delete pNewSet;
1589 : }
1590 : else
1591 : {
1592 0 : rReq.Done();
1593 : }
1594 :
1595 : }
1596 :
1597 0 : void ScFormatShell::ExecuteAttr( SfxRequest& rReq )
1598 : {
1599 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1600 0 : SfxBindings& rBindings = pViewData->GetBindings();
1601 0 : const SfxItemSet* pNewAttrs = rReq.GetArgs();
1602 0 : sal_uInt16 nSlot = rReq.GetSlot();
1603 :
1604 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1605 0 : ScDocument* pDoc = GetViewData()->GetDocument();
1606 0 : if ( !pNewAttrs )
1607 : {
1608 0 : switch ( nSlot )
1609 : {
1610 : case SID_ATTR_CHAR_ENDPREVIEW_FONT:
1611 : {
1612 0 : pDoc->SetPreviewFont(NULL);
1613 0 : pTabViewShell->UpdateSelectionArea( pDoc->GetPreviewSelection() );
1614 0 : break;
1615 : }
1616 : case SID_ATTR_CHAR_COLOR:
1617 : case SID_ATTR_CHAR_FONT:
1618 : case SID_ATTR_CHAR_FONTHEIGHT:
1619 0 : pTabViewShell->ExecuteCellFormatDlg(rReq, "font"); // wenn ToolBar vertikal
1620 0 : break;
1621 :
1622 : case SID_BACKGROUND_COLOR:
1623 : {
1624 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1625 0 : pTabViewShell->GetSelectionPattern()->GetItem( ATTR_BACKGROUND ) ) );
1626 0 : aBrushItem.SetColor( COL_TRANSPARENT );
1627 0 : pTabViewShell->ApplyAttr( aBrushItem );
1628 : }
1629 0 : break;
1630 :
1631 : case SID_ATTR_ALIGN_LINEBREAK: // ohne Parameter als Toggle
1632 : {
1633 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1634 0 : bool bOld = static_cast<const SfxBoolItem&>(pAttrs->GetItem(ATTR_LINEBREAK)).GetValue();
1635 0 : SfxBoolItem aBreakItem( ATTR_LINEBREAK, !bOld );
1636 0 : pTabViewShell->ApplyAttr( aBreakItem );
1637 :
1638 0 : SfxAllItemSet aNewSet( GetPool() );
1639 0 : aNewSet.Put( aBreakItem,aBreakItem.Which() );
1640 0 : rReq.Done( aNewSet );
1641 :
1642 0 : rBindings.Invalidate( nSlot );
1643 : }
1644 0 : break;
1645 : }
1646 : }
1647 : else
1648 : {
1649 0 : switch ( nSlot )
1650 : {
1651 : case SID_ATTR_CHAR_PREVIEW_FONT:
1652 : {
1653 0 : SfxItemPool& rPool = GetPool();
1654 0 : sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1655 0 : const SvxFontItem& rFont = static_cast<const SvxFontItem&>(pNewAttrs->Get( nWhich ));
1656 0 : SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, rPool );
1657 0 : SvtScriptType nScript = pTabViewShell->GetSelectionScriptType();
1658 0 : aSetItem.PutItemForScriptType( nScript, rFont );
1659 :
1660 0 : ScMarkData aFuncMark( pViewData->GetMarkData() );
1661 0 : ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1662 0 : pDoc->SetPreviewFont( aSetItem.GetItemSet().Clone() );
1663 0 : aFuncMark.MarkToMulti();
1664 :
1665 0 : if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
1666 : {
1667 0 : SCCOL nCol = pViewData->GetCurX();
1668 0 : SCROW nRow = pViewData->GetCurY();
1669 0 : SCTAB nTab = pViewData->GetTabNo();
1670 0 : ScRange aRange( nCol, nRow, nTab );
1671 0 : aFuncMark.SetMarkArea( aRange );
1672 : }
1673 0 : pDoc->SetPreviewSelection( aFuncMark );
1674 0 : pTabViewShell->UpdateSelectionArea( aFuncMark );
1675 0 : break;
1676 : }
1677 : case SID_ATTR_CHAR_OVERLINE:
1678 : case SID_ATTR_CHAR_STRIKEOUT:
1679 : case SID_ATTR_ALIGN_LINEBREAK:
1680 : case SID_ATTR_CHAR_COLOR:
1681 : case SID_ATTR_CHAR_CONTOUR:
1682 : case SID_ATTR_CHAR_SHADOWED:
1683 : case SID_ATTR_CHAR_RELIEF:
1684 : case SID_SCATTR_PROTECTION :
1685 0 : pTabViewShell->ApplyAttr( pNewAttrs->Get( pNewAttrs->GetPool()->GetWhich( nSlot ) ) );
1686 0 : rBindings.Invalidate( nSlot );
1687 0 : rBindings.Update( nSlot );
1688 0 : break;
1689 :
1690 : case SID_ATTR_CHAR_FONT:
1691 : case SID_ATTR_CHAR_FONTHEIGHT:
1692 : {
1693 : // #i78017 establish the same behaviour as in Writer
1694 0 : SvtScriptType nScript = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
1695 0 : if (nSlot == SID_ATTR_CHAR_FONT)
1696 0 : nScript = pTabViewShell->GetSelectionScriptType();
1697 :
1698 0 : SfxItemPool& rPool = GetPool();
1699 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1700 0 : sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1701 0 : aSetItem.PutItemForScriptType( nScript, pNewAttrs->Get( nWhich ) );
1702 :
1703 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1704 :
1705 0 : rBindings.Invalidate( nSlot );
1706 0 : rBindings.Update( nSlot );
1707 : }
1708 0 : break;
1709 :
1710 : case SID_FRAME_LINESTYLE:
1711 : {
1712 : // Default-Linie aktualisieren
1713 : const ::editeng::SvxBorderLine* pLine =
1714 : static_cast<const SvxLineItem&>(
1715 0 : pNewAttrs->Get( SID_FRAME_LINESTYLE )).
1716 0 : GetLine();
1717 :
1718 0 : if ( pLine )
1719 : {
1720 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1721 :
1722 0 : if ( pDefLine )
1723 : {
1724 : pDefLine->SetBorderLineStyle(
1725 0 : pLine->GetBorderLineStyle());
1726 0 : pDefLine->SetWidth( pLine->GetWidth( ) );
1727 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, false );
1728 : }
1729 : else
1730 : {
1731 0 : pTabViewShell->SetDefaultFrameLine( pLine );
1732 0 : pTabViewShell->GetDefaultFrameLine()->SetColor( COL_BLACK );
1733 0 : pTabViewShell->SetSelectionFrameLines( pLine, false );
1734 : }
1735 : }
1736 : else
1737 : {
1738 0 : Color aColorBlack( COL_BLACK );
1739 : ::editeng::SvxBorderLine aDefLine( &aColorBlack, 20,
1740 0 : table::BorderLineStyle::SOLID );
1741 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1742 0 : pTabViewShell->SetSelectionFrameLines( NULL, false );
1743 : }
1744 : }
1745 0 : break;
1746 :
1747 : case SID_FRAME_LINECOLOR:
1748 : {
1749 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1750 : const Color& rColor = static_cast<const SvxColorItem&>(
1751 0 : pNewAttrs->Get( SID_FRAME_LINECOLOR )).
1752 0 : GetValue();
1753 :
1754 : // Default-Linie aktualisieren
1755 0 : if ( pDefLine )
1756 : {
1757 0 : pDefLine->SetColor( rColor );
1758 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, true );
1759 : }
1760 : else
1761 : {
1762 : ::editeng::SvxBorderLine aDefLine( &rColor, 20,
1763 0 : table::BorderLineStyle::SOLID );
1764 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1765 0 : pTabViewShell->SetSelectionFrameLines( &aDefLine, false );
1766 : }
1767 : }
1768 0 : break;
1769 :
1770 : case SID_ATTR_BORDER_OUTER:
1771 : case SID_ATTR_BORDER:
1772 : {
1773 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1774 0 : const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1775 : boost::scoped_ptr<SfxItemSet> pOldSet(
1776 : new SfxItemSet(
1777 0 : *(pDoc->GetPool()),
1778 : ATTR_PATTERN_START,
1779 0 : ATTR_PATTERN_END ));
1780 : boost::scoped_ptr<SfxItemSet> pNewSet(
1781 : new SfxItemSet(
1782 0 : *(pDoc->GetPool()),
1783 : ATTR_PATTERN_START,
1784 0 : ATTR_PATTERN_END ));
1785 : const SfxPoolItem& rBorderAttr =
1786 0 : pOldAttrs->GetItemSet().
1787 0 : Get( ATTR_BORDER );
1788 :
1789 : // Border-Items vom Controller auswerten:
1790 0 : const SfxPoolItem* pItem = 0;
1791 :
1792 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER, true, &pItem )
1793 : == SfxItemState::SET )
1794 : {
1795 : // The SvxFrameToolBoxControl toolbox controller uses a default
1796 : // SvxBorderLine (all widths 0) to mark the lines that should be set.
1797 : // Macro recording uses a SvxBoxItem with the real values (OutWidth > 0)
1798 : // or NULL pointers for no lines.
1799 : // -> Substitute existing lines with pDefLine only if widths are 0.
1800 0 : SvxBoxItem aBoxItem ( *static_cast<const SvxBoxItem*>(pItem ));
1801 0 : if ( aBoxItem.GetTop() && aBoxItem.GetTop()->GetOutWidth() == 0 )
1802 0 : aBoxItem.SetLine( pDefLine, SvxBoxItemLine::TOP );
1803 0 : if ( aBoxItem.GetBottom() && aBoxItem.GetBottom()->GetOutWidth() == 0 )
1804 0 : aBoxItem.SetLine( pDefLine, SvxBoxItemLine::BOTTOM );
1805 0 : if ( aBoxItem.GetLeft() && aBoxItem.GetLeft()->GetOutWidth() == 0 )
1806 0 : aBoxItem.SetLine( pDefLine, SvxBoxItemLine::LEFT );
1807 0 : if ( aBoxItem.GetRight() && aBoxItem.GetRight()->GetOutWidth() == 0 )
1808 0 : aBoxItem.SetLine( pDefLine, SvxBoxItemLine::RIGHT );
1809 0 : pNewSet->Put( aBoxItem );
1810 0 : rReq.AppendItem( aBoxItem );
1811 : }
1812 :
1813 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER_INNER, true, &pItem )
1814 : == SfxItemState::SET )
1815 : {
1816 0 : SvxBoxInfoItem aBoxInfoItem( *static_cast<const SvxBoxInfoItem*>(pItem) );
1817 0 : if ( aBoxInfoItem.GetHori() && aBoxInfoItem.GetHori()->GetOutWidth() == 0 )
1818 0 : aBoxInfoItem.SetLine( pDefLine, SvxBoxInfoItemLine::HORI );
1819 0 : if ( aBoxInfoItem.GetVert() && aBoxInfoItem.GetVert()->GetOutWidth() == 0 )
1820 0 : aBoxInfoItem.SetLine( pDefLine, SvxBoxInfoItemLine::VERT );
1821 0 : pNewSet->Put( aBoxInfoItem );
1822 0 : rReq.AppendItem( aBoxInfoItem );
1823 : }
1824 : else
1825 : {
1826 0 : SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
1827 0 : aBoxInfoItem.SetLine( NULL, SvxBoxInfoItemLine::HORI );
1828 0 : aBoxInfoItem.SetLine( NULL, SvxBoxInfoItemLine::VERT );
1829 0 : pNewSet->Put( aBoxInfoItem );
1830 : }
1831 :
1832 0 : pOldSet->Put( rBorderAttr );
1833 0 : pTabViewShell->ApplyAttributes( pNewSet.get(), pOldSet.get() );
1834 : }
1835 0 : break;
1836 :
1837 : case SID_ATTR_BORDER_DIAG_TLBR:
1838 : case SID_ATTR_BORDER_DIAG_BLTR:
1839 : {
1840 0 : const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1841 0 : boost::scoped_ptr<SfxItemSet> pOldSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1842 0 : boost::scoped_ptr<SfxItemSet> pNewSet(new SfxItemSet(pOldAttrs->GetItemSet()));
1843 0 : const SfxPoolItem* pItem = 0;
1844 :
1845 0 : if(SID_ATTR_BORDER_DIAG_TLBR == nSlot)
1846 : {
1847 0 : if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_TLBR, true, &pItem))
1848 : {
1849 0 : SvxLineItem aItem(ATTR_BORDER_TLBR);
1850 0 : aItem.SetLine(static_cast<const SvxLineItem&>(pNewAttrs->Get(ATTR_BORDER_TLBR)).GetLine());
1851 0 : pNewSet->Put(aItem);
1852 0 : rReq.AppendItem(aItem);
1853 0 : pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1854 : }
1855 : }
1856 : else // if( nSlot == SID_ATTR_BORDER_DIAG_BLTR )
1857 : {
1858 0 : if(SfxItemState::SET == pNewAttrs->GetItemState(ATTR_BORDER_BLTR, true, &pItem ))
1859 : {
1860 0 : SvxLineItem aItem(ATTR_BORDER_BLTR);
1861 0 : aItem.SetLine(static_cast<const SvxLineItem&>(pNewAttrs->Get(ATTR_BORDER_BLTR)).GetLine());
1862 0 : pNewSet->Put(aItem);
1863 0 : rReq.AppendItem(aItem);
1864 0 : pTabViewShell->ApplyAttributes(pNewSet.get(), pOldSet.get());
1865 : }
1866 : }
1867 :
1868 0 : rBindings.Invalidate(nSlot);
1869 : }
1870 0 : break;
1871 :
1872 : // ATTR_BACKGROUND (=SID_ATTR_BRUSH) muss ueber zwei IDs
1873 : // gesetzt werden:
1874 : case SID_BACKGROUND_COLOR:
1875 : {
1876 : const SvxColorItem rNewColorItem = static_cast<const SvxColorItem&>(
1877 0 : pNewAttrs->Get( SID_BACKGROUND_COLOR ) );
1878 :
1879 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1880 : pTabViewShell->GetSelectionPattern()->
1881 0 : GetItem( ATTR_BACKGROUND ) ) );
1882 :
1883 0 : aBrushItem.SetColor( rNewColorItem.GetValue() );
1884 :
1885 0 : pTabViewShell->ApplyAttr( aBrushItem );
1886 : }
1887 0 : break;
1888 :
1889 : case SID_ATTR_BRUSH:
1890 : {
1891 : SvxBrushItem aBrushItem( static_cast<const SvxBrushItem&>(
1892 : pTabViewShell->GetSelectionPattern()->
1893 0 : GetItem( ATTR_BACKGROUND ) ) );
1894 : const SvxBrushItem& rNewBrushItem = static_cast<const SvxBrushItem&>(
1895 0 : pNewAttrs->Get( GetPool().GetWhich(nSlot) ) );
1896 0 : aBrushItem.SetColor(rNewBrushItem.GetColor());
1897 0 : pTabViewShell->ApplyAttr( aBrushItem );
1898 : }
1899 0 : break;
1900 :
1901 : case SID_ATTR_BORDER_SHADOW:
1902 : {
1903 : const SvxShadowItem& rNewShadowItem = static_cast<const SvxShadowItem&>(
1904 0 : pNewAttrs->Get( ATTR_SHADOW ) );
1905 0 : pTabViewShell->ApplyAttr( rNewShadowItem );
1906 : }
1907 0 : break;
1908 :
1909 : default:
1910 0 : break;
1911 : }
1912 :
1913 0 : if( ! rReq.IsAPI() )
1914 0 : if( ! rReq.IsDone() )
1915 0 : rReq.Done();
1916 : }
1917 0 : }
1918 :
1919 3761 : void ScFormatShell::GetAttrState( SfxItemSet& rSet )
1920 : {
1921 3761 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1922 3761 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1923 : //const ::editeng::SvxBorderLine* pLine = pTabViewShell->GetDefaultFrameLine();
1924 3761 : const SvxBrushItem& rBrushItem = static_cast<const SvxBrushItem&>(rAttrSet.Get( ATTR_BACKGROUND ));
1925 3761 : SfxWhichIter aIter( rSet );
1926 3761 : sal_uInt16 nWhich = aIter.FirstWhich();
1927 :
1928 3761 : rSet.Put( rAttrSet, false );
1929 :
1930 : // choose font info according to selection script type
1931 3761 : SvtScriptType nScript = SvtScriptType::NONE; // GetSelectionScriptType never returns 0
1932 3761 : if ( rSet.GetItemState( ATTR_FONT ) != SfxItemState::UNKNOWN )
1933 : {
1934 705 : if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
1935 705 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT, nScript );
1936 : }
1937 3761 : if ( rSet.GetItemState( ATTR_FONT_HEIGHT ) != SfxItemState::UNKNOWN )
1938 : {
1939 400 : if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
1940 400 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_HEIGHT, nScript );
1941 : }
1942 :
1943 12708 : while ( nWhich )
1944 : {
1945 5186 : switch(nWhich)
1946 : {
1947 : case SID_BACKGROUND_COLOR:
1948 : {
1949 400 : rSet.Put( SvxColorItem( rBrushItem.GetColor(), SID_BACKGROUND_COLOR ) );
1950 :
1951 400 : if(SfxItemState::DONTCARE == rAttrSet.GetItemState(ATTR_BACKGROUND))
1952 : {
1953 0 : rSet.InvalidateItem(SID_BACKGROUND_COLOR);
1954 : }
1955 : }
1956 400 : break;
1957 : case SID_FRAME_LINESTYLE:
1958 : case SID_FRAME_LINECOLOR:
1959 : {
1960 : // handled together because both need the cell border information for decisions
1961 : // rSet.Put( SvxColorItem( pLine ? pLine->GetColor() : Color(), SID_FRAME_LINECOLOR ) );
1962 649 : Color aCol = 0;
1963 649 : editeng::SvxBorderLine aLine(0,0,0,false);
1964 649 : bool bCol = false;
1965 649 : bool bColDisable = false, bStyleDisable = false;
1966 649 : SvxBoxItem aBoxItem(ATTR_BORDER);
1967 1298 : SvxBoxInfoItem aInfoItem(ATTR_BORDER_INNER);
1968 :
1969 649 : pTabViewShell->GetSelectionFrame(aBoxItem, aInfoItem);
1970 :
1971 649 : if( aBoxItem.GetTop() )
1972 : {
1973 0 : bCol = true;
1974 0 : aCol = aBoxItem.GetTop()->GetColor() ;
1975 0 : aLine.SetColor(aCol);
1976 0 : aLine.SetWidth( aBoxItem.GetTop()->GetWidth());
1977 0 : aLine.SetBorderLineStyle( aBoxItem.GetTop()->GetBorderLineStyle());
1978 : }
1979 :
1980 649 : if( aBoxItem.GetBottom() )
1981 : {
1982 0 : if(!bCol)
1983 : {
1984 0 : bCol = true;
1985 0 : aCol = aBoxItem.GetBottom()->GetColor() ;
1986 0 : aLine.SetColor(aCol);
1987 0 : aLine.SetWidth( aBoxItem.GetBottom()->GetWidth());
1988 0 : aLine.SetBorderLineStyle( aBoxItem.GetBottom()->GetBorderLineStyle());
1989 : }
1990 : else
1991 : {
1992 0 : if(aCol != aBoxItem.GetBottom()->GetColor() )
1993 0 : bColDisable = true;
1994 0 : if(!( aLine == *(aBoxItem.GetBottom())) )
1995 0 : bStyleDisable = true;
1996 : }
1997 : }
1998 :
1999 649 : if( aBoxItem.GetLeft() )
2000 : {
2001 0 : if(!bCol)
2002 : {
2003 0 : bCol = true;
2004 0 : aCol = aBoxItem.GetLeft()->GetColor() ;
2005 0 : aLine.SetColor(aCol);
2006 0 : aLine.SetWidth( aBoxItem.GetLeft()->GetWidth());
2007 0 : aLine.SetBorderLineStyle( aBoxItem.GetLeft()->GetBorderLineStyle());
2008 : }
2009 : else
2010 : {
2011 0 : if(aCol != aBoxItem.GetLeft()->GetColor() )
2012 0 : bColDisable = true;
2013 0 : if(!( aLine == *(aBoxItem.GetLeft())) )
2014 0 : bStyleDisable = true;
2015 : }
2016 : }
2017 :
2018 649 : if( aBoxItem.GetRight() )
2019 : {
2020 0 : if(!bCol)
2021 : {
2022 0 : bCol = true;
2023 0 : aCol = aBoxItem.GetRight()->GetColor() ;
2024 0 : aLine.SetColor(aCol);
2025 0 : aLine.SetWidth( aBoxItem.GetRight()->GetWidth());
2026 0 : aLine.SetBorderLineStyle( aBoxItem.GetRight()->GetBorderLineStyle());
2027 : }
2028 : else
2029 : {
2030 0 : if(aCol != aBoxItem.GetRight()->GetColor() )
2031 0 : bColDisable = true;
2032 0 : if(!( aLine == *(aBoxItem.GetRight())) )
2033 0 : bStyleDisable = true;
2034 : }
2035 : }
2036 :
2037 649 : if( aInfoItem.GetVert())
2038 : {
2039 0 : if(!bCol)
2040 : {
2041 0 : bCol = true;
2042 0 : aCol = aInfoItem.GetVert()->GetColor() ;
2043 0 : aLine.SetColor(aCol);
2044 0 : aLine.SetWidth( aInfoItem.GetVert()->GetWidth());
2045 0 : aLine.SetBorderLineStyle( aInfoItem.GetVert()->GetBorderLineStyle());
2046 : }
2047 : else
2048 : {
2049 0 : if(aCol != aInfoItem.GetVert()->GetColor() )
2050 0 : bColDisable = true;
2051 0 : if(!( aLine == *(aInfoItem.GetVert())) )
2052 0 : bStyleDisable = true;
2053 : }
2054 : }
2055 :
2056 649 : if( aInfoItem.GetHori())
2057 : {
2058 0 : if(!bCol)
2059 : {
2060 0 : bCol = true;
2061 0 : aCol = aInfoItem.GetHori()->GetColor() ;
2062 0 : aLine.SetColor(aCol);
2063 0 : aLine.SetWidth( aInfoItem.GetHori()->GetWidth());
2064 0 : aLine.SetBorderLineStyle( aInfoItem.GetHori()->GetBorderLineStyle());
2065 : }
2066 : else
2067 : {
2068 0 : if(aCol != aInfoItem.GetHori()->GetColor() )
2069 0 : bColDisable = true;
2070 0 : if(!( aLine == *(aInfoItem.GetHori())) )
2071 0 : bStyleDisable = true;
2072 : }
2073 : }
2074 :
2075 1298 : if( !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::VERT )
2076 649 : || !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::HORI )
2077 649 : || !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::LEFT )
2078 649 : || !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::RIGHT )
2079 649 : || !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::TOP )
2080 1298 : || !aInfoItem.IsValid( SvxBoxInfoItemValidFlags::BOTTOM ) )
2081 : {
2082 0 : bColDisable = true;
2083 0 : bStyleDisable = true;
2084 : }
2085 :
2086 649 : if(SID_FRAME_LINECOLOR == nWhich)
2087 : {
2088 400 : if(bColDisable) // if different lines have differernt colors
2089 : {
2090 0 : aCol = COL_TRANSPARENT;
2091 0 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2092 0 : rSet.InvalidateItem(SID_FRAME_LINECOLOR);
2093 : }
2094 400 : else if( !bCol && !bColDisable) // if no line available
2095 : {
2096 400 : aCol = COL_AUTO;
2097 400 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2098 : }
2099 : else
2100 0 : rSet.Put( SvxColorItem(aCol, SID_FRAME_LINECOLOR ) );
2101 : }
2102 : else // if( nWhich == SID_FRAME_LINESTYLE)
2103 : {
2104 249 : if(bStyleDisable) // if have several lines but don't have same style
2105 : {
2106 0 : aLine.SetWidth( 1 );
2107 0 : SvxLineItem aItem(SID_FRAME_LINESTYLE);
2108 0 : aItem.SetLine(&aLine);
2109 0 : rSet.Put( aItem );
2110 0 : rSet.InvalidateItem(SID_FRAME_LINESTYLE);
2111 : }
2112 : else // all the lines have same style or no line availavle, use initial value (0,0,0,0)
2113 : {
2114 249 : SvxLineItem aItem(SID_FRAME_LINESTYLE);
2115 249 : aItem.SetLine(&aLine);
2116 249 : rSet.Put( aItem );
2117 : }
2118 649 : }
2119 : }
2120 649 : break;
2121 : case SID_ATTR_BRUSH:
2122 : {
2123 0 : rSet.Put( rBrushItem, GetPool().GetWhich(nWhich) );
2124 : }
2125 0 : break;
2126 : }
2127 5186 : nWhich = aIter.NextWhich();
2128 : }
2129 :
2130 : // stuff for sidebar panels
2131 3761 : Invalidate(SID_ATTR_ALIGN_DEGREES);
2132 3761 : Invalidate(SID_ATTR_ALIGN_STACKED);
2133 3761 : }
2134 :
2135 3300 : void ScFormatShell::GetTextAttrState( SfxItemSet& rSet )
2136 : {
2137 3300 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2138 3300 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2139 3300 : rSet.Put( rAttrSet, false ); // ItemStates mitkopieren
2140 :
2141 : // choose font info according to selection script type
2142 3300 : SvtScriptType nScript = SvtScriptType::NONE; // GetSelectionScriptType never returns 0
2143 3300 : if ( rSet.GetItemState( ATTR_FONT_WEIGHT ) != SfxItemState::UNKNOWN )
2144 : {
2145 400 : if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
2146 400 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_WEIGHT, nScript );
2147 : }
2148 3300 : if ( rSet.GetItemState( ATTR_FONT_POSTURE ) != SfxItemState::UNKNOWN )
2149 : {
2150 400 : if (nScript == SvtScriptType::NONE) nScript = pTabViewShell->GetSelectionScriptType();
2151 400 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_POSTURE, nScript );
2152 : }
2153 :
2154 : SfxItemState eState;
2155 : // const SfxPoolItem* pItem;
2156 :
2157 : // eigene Kontrolle ueber RadioButton-Funktionalitaet:
2158 :
2159 : // Unterstreichung
2160 :
2161 3300 : eState = rAttrSet.GetItemState( ATTR_FONT_UNDERLINE, true );
2162 3300 : if ( eState == SfxItemState::DONTCARE )
2163 : {
2164 0 : rSet.InvalidateItem( SID_ULINE_VAL_NONE );
2165 0 : rSet.InvalidateItem( SID_ULINE_VAL_SINGLE );
2166 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOUBLE );
2167 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOTTED );
2168 : }
2169 : else
2170 : {
2171 : FontUnderline eUnderline = static_cast<const SvxUnderlineItem&>(
2172 3300 : rAttrSet.Get(ATTR_FONT_UNDERLINE)).GetLineStyle();
2173 3300 : sal_uInt16 nId = SID_ULINE_VAL_NONE;
2174 3300 : switch (eUnderline)
2175 : {
2176 0 : case UNDERLINE_SINGLE: nId = SID_ULINE_VAL_SINGLE; break;
2177 0 : case UNDERLINE_DOUBLE: nId = SID_ULINE_VAL_DOUBLE; break;
2178 0 : case UNDERLINE_DOTTED: nId = SID_ULINE_VAL_DOTTED; break;
2179 : default:
2180 3300 : break;
2181 : }
2182 3300 : rSet.Put( SfxBoolItem( nId, true ) );
2183 : }
2184 :
2185 : // horizontale Ausrichtung
2186 :
2187 3300 : const SvxHorJustifyItem* pHorJustify = NULL;
2188 3300 : const SvxVerJustifyItem* pVerJustify = NULL;
2189 3300 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
2190 3300 : sal_uInt16 nWhich = 0;
2191 3300 : bool bJustifyStd = false;
2192 3300 : SfxBoolItem aBoolItem ( 0, true );
2193 :
2194 : eState = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY, true,
2195 3300 : reinterpret_cast<const SfxPoolItem**>(&pHorJustify) );
2196 3300 : switch ( eState )
2197 : {
2198 : case SfxItemState::SET:
2199 : {
2200 0 : switch ( SvxCellHorJustify( pHorJustify->GetValue() ) )
2201 : {
2202 : case SVX_HOR_JUSTIFY_STANDARD:
2203 0 : break;
2204 :
2205 : case SVX_HOR_JUSTIFY_LEFT:
2206 0 : nWhich = SID_ALIGNLEFT;
2207 0 : break;
2208 :
2209 : case SVX_HOR_JUSTIFY_RIGHT:
2210 0 : nWhich = SID_ALIGNRIGHT;
2211 0 : break;
2212 :
2213 : case SVX_HOR_JUSTIFY_CENTER:
2214 0 : nWhich = SID_ALIGNCENTERHOR;
2215 0 : break;
2216 :
2217 : case SVX_HOR_JUSTIFY_BLOCK:
2218 0 : nWhich = SID_ALIGNBLOCK;
2219 0 : break;
2220 :
2221 : case SVX_HOR_JUSTIFY_REPEAT:
2222 : default:
2223 0 : bJustifyStd = true;
2224 0 : break;
2225 : }
2226 : }
2227 0 : break;
2228 :
2229 : case SfxItemState::DONTCARE:
2230 0 : rSet.InvalidateItem( SID_ALIGNLEFT );
2231 0 : rSet.InvalidateItem( SID_ALIGNRIGHT );
2232 0 : rSet.InvalidateItem( SID_ALIGNCENTERHOR );
2233 0 : rSet.InvalidateItem( SID_ALIGNBLOCK );
2234 0 : break;
2235 :
2236 : default:
2237 3300 : bJustifyStd = true;
2238 3300 : break;
2239 : }
2240 :
2241 3300 : if ( nWhich )
2242 : {
2243 0 : aBoolItem.SetWhich( nWhich );
2244 0 : rSet.Put( aBoolItem );
2245 : }
2246 3300 : else if ( bJustifyStd )
2247 : {
2248 3300 : aBoolItem.SetValue( false );
2249 3300 : aBoolItem.SetWhich( SID_ALIGNLEFT ); rSet.Put( aBoolItem );
2250 3300 : aBoolItem.SetWhich( SID_ALIGNRIGHT ); rSet.Put( aBoolItem );
2251 3300 : aBoolItem.SetWhich( SID_ALIGNCENTERHOR ); rSet.Put( aBoolItem );
2252 3300 : aBoolItem.SetWhich( SID_ALIGNBLOCK ); rSet.Put( aBoolItem );
2253 3300 : bJustifyStd = false;
2254 : }
2255 :
2256 : // vertikale Ausrichtung
2257 :
2258 3300 : nWhich = 0;
2259 3300 : aBoolItem.SetValue( true );
2260 :
2261 : eState = rAttrSet.GetItemState( ATTR_VER_JUSTIFY, true,
2262 3300 : reinterpret_cast<const SfxPoolItem**>(&pVerJustify) );
2263 :
2264 3300 : switch ( eState )
2265 : {
2266 : case SfxItemState::SET:
2267 : {
2268 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
2269 :
2270 0 : switch ( eVerJustify )
2271 : {
2272 : case SVX_VER_JUSTIFY_TOP:
2273 0 : nWhich = SID_ALIGNTOP;
2274 0 : break;
2275 :
2276 : case SVX_VER_JUSTIFY_BOTTOM:
2277 0 : nWhich = SID_ALIGNBOTTOM;
2278 0 : break;
2279 :
2280 : case SVX_VER_JUSTIFY_CENTER:
2281 0 : nWhich = SID_ALIGNCENTERVER;
2282 0 : break;
2283 :
2284 : case SVX_VER_JUSTIFY_STANDARD:
2285 : default:
2286 0 : bJustifyStd = true;
2287 0 : break;
2288 : }
2289 : }
2290 0 : break;
2291 :
2292 : case SfxItemState::DONTCARE:
2293 0 : rSet.InvalidateItem( SID_ALIGNTOP );
2294 0 : rSet.InvalidateItem( SID_ALIGNBOTTOM );
2295 0 : rSet.InvalidateItem( SID_ALIGNCENTERVER );
2296 0 : break;
2297 :
2298 : default:
2299 3300 : bJustifyStd = true;
2300 3300 : break;
2301 : }
2302 :
2303 3300 : if ( nWhich )
2304 : {
2305 0 : aBoolItem.SetWhich( nWhich );
2306 0 : rSet.Put( aBoolItem );
2307 : }
2308 3300 : else if ( bJustifyStd )
2309 : {
2310 3300 : aBoolItem.SetValue( false );
2311 3300 : aBoolItem.SetWhich( SID_ALIGNTOP ); rSet.Put( aBoolItem );
2312 3300 : aBoolItem.SetWhich( SID_ALIGNBOTTOM ); rSet.Put( aBoolItem );
2313 3300 : aBoolItem.SetWhich( SID_ALIGNCENTERVER ); rSet.Put( aBoolItem );
2314 3300 : }
2315 3300 : }
2316 :
2317 31 : void ScFormatShell::GetBorderState( SfxItemSet& rSet )
2318 : {
2319 31 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2320 31 : SvxBoxItem aBoxItem( ATTR_BORDER );
2321 62 : SvxBoxInfoItem aInfoItem( ATTR_BORDER_INNER );
2322 :
2323 31 : pTabViewShell->GetSelectionFrame( aBoxItem, aInfoItem );
2324 :
2325 31 : if ( rSet.GetItemState( ATTR_BORDER ) != SfxItemState::UNKNOWN )
2326 31 : rSet.Put( aBoxItem );
2327 31 : if ( rSet.GetItemState( ATTR_BORDER_INNER ) != SfxItemState::UNKNOWN )
2328 62 : rSet.Put( aInfoItem );
2329 31 : }
2330 :
2331 31 : void ScFormatShell::GetAlignState( SfxItemSet& rSet )
2332 : {
2333 31 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2334 31 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2335 31 : SfxWhichIter aIter(rSet);
2336 31 : sal_uInt16 nWhich = aIter.FirstWhich();
2337 :
2338 31 : SvxCellHorJustify eHAlign = SVX_HOR_JUSTIFY_STANDARD;
2339 31 : bool bHasHAlign = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY ) != SfxItemState::DONTCARE;
2340 31 : if( bHasHAlign )
2341 31 : eHAlign = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem&>(rAttrSet.Get( ATTR_HOR_JUSTIFY )).GetValue();
2342 :
2343 31 : SvxCellVerJustify eVAlign = SVX_VER_JUSTIFY_STANDARD;
2344 31 : bool bHasVAlign = rAttrSet.GetItemState( ATTR_VER_JUSTIFY ) != SfxItemState::DONTCARE;
2345 31 : if( bHasVAlign )
2346 31 : eVAlign = (SvxCellVerJustify)static_cast<const SvxVerJustifyItem&>(rAttrSet.Get( ATTR_VER_JUSTIFY )).GetValue();
2347 :
2348 93 : while ( nWhich )
2349 : {
2350 31 : switch ( nWhich )
2351 : {
2352 : case SID_H_ALIGNCELL:
2353 31 : if ( bHasHAlign )
2354 31 : rSet.Put( SvxHorJustifyItem( eHAlign, nWhich ));
2355 31 : break;
2356 : case SID_V_ALIGNCELL:
2357 0 : if ( bHasVAlign )
2358 0 : rSet.Put( SvxVerJustifyItem( eVAlign, nWhich ));
2359 0 : break;
2360 :
2361 : // pseudo slots for Format menu
2362 : case SID_ALIGN_ANY_HDEFAULT:
2363 : case SID_ALIGN_ANY_LEFT:
2364 : case SID_ALIGN_ANY_HCENTER:
2365 : case SID_ALIGN_ANY_RIGHT:
2366 : case SID_ALIGN_ANY_JUSTIFIED:
2367 0 : rSet.Put( SfxBoolItem( nWhich, bHasHAlign && (eHAlign == lclConvertSlotToHAlign( nWhich )) ) );
2368 0 : break;
2369 : case SID_ALIGN_ANY_VDEFAULT:
2370 : case SID_ALIGN_ANY_TOP:
2371 : case SID_ALIGN_ANY_VCENTER:
2372 : case SID_ALIGN_ANY_BOTTOM:
2373 0 : rSet.Put( SfxBoolItem( nWhich, bHasVAlign && (eVAlign == lclConvertSlotToVAlign( nWhich )) ) );
2374 0 : break;
2375 : }
2376 31 : nWhich = aIter.NextWhich();
2377 31 : }
2378 31 : }
2379 :
2380 647 : void ScFormatShell::GetNumFormatState( SfxItemSet& rSet )
2381 : {
2382 647 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2383 647 : ScDocument* pDoc = pViewData->GetDocument();
2384 647 : short nType = GetCurrentNumberFormatType();
2385 :
2386 647 : SfxWhichIter aIter(rSet);
2387 647 : sal_uInt16 nWhich = aIter.FirstWhich();
2388 2096 : while ( nWhich )
2389 : {
2390 802 : switch ( nWhich )
2391 : {
2392 : case SID_NUMBER_FORMAT:
2393 : //{
2394 : // String aFormatCode; // bleibt leer, wenn dont-care
2395 : //
2396 : // const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2397 : // if ( rAttrSet.GetItemState( ATTR_VALUE_FORMAT ) != SfxItemState::DONTCARE )
2398 : // {
2399 : // sal_uLong nNumberFormat = ((const SfxUInt32Item&)rAttrSet.Get(
2400 : // ATTR_VALUE_FORMAT )).GetValue();
2401 : //
2402 : // SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
2403 : // const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2404 : // if ( pFormatEntry )
2405 : // aFormatCode = pFormatEntry->GetFormatstring();
2406 : // }
2407 : //
2408 : // rSet.Put( SfxStringItem( nWhich, aFormatCode ) );
2409 : //}
2410 :
2411 : // symphony version with format interpretation
2412 : {
2413 31 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2414 :
2415 31 : if(SfxItemState::DONTCARE != rAttrSet.GetItemState(ATTR_VALUE_FORMAT))
2416 : {
2417 31 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2418 31 : sal_uInt32 nNumberFormat = static_cast<const SfxUInt32Item&>(rAttrSet.Get(ATTR_VALUE_FORMAT)).GetValue();
2419 31 : bool bThousand(false);
2420 31 : bool bNegRed(false);
2421 31 : sal_uInt16 nPrecision(0);
2422 31 : sal_uInt16 nLeadZeroes(0);
2423 :
2424 31 : pFormatter->GetFormatSpecialInfo(nNumberFormat,bThousand, bNegRed, nPrecision, nLeadZeroes);
2425 :
2426 31 : const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2427 31 : if (pFormatEntry && (pFormatEntry->GetType() & css::util::NumberFormat::SCIENTIFIC))
2428 : {
2429 : // if scientific, bThousand is used for engineering notation
2430 0 : const sal_uInt16 nIntegerDigits = pFormatEntry->GetFormatIntegerDigits();
2431 0 : if (nIntegerDigits > 0 && ((nIntegerDigits % 3) == 0))
2432 0 : bThousand = true;
2433 : else
2434 0 : bThousand = false;
2435 : }
2436 31 : OUString aFormat;
2437 31 : static OUString sBreak = ",";
2438 62 : const OUString sThousand = OUString::number(static_cast<sal_Int32>(bThousand));
2439 62 : const OUString sNegRed = OUString::number(static_cast<sal_Int32>(bNegRed));
2440 62 : const OUString sPrecision = OUString::number(nPrecision);
2441 62 : const OUString sLeadZeroes = OUString::number(nLeadZeroes);
2442 :
2443 31 : aFormat += sThousand;
2444 31 : aFormat += sBreak;
2445 31 : aFormat += sNegRed;
2446 31 : aFormat += sBreak;
2447 31 : aFormat += sPrecision;
2448 31 : aFormat += sBreak;
2449 31 : aFormat += sLeadZeroes;
2450 31 : aFormat += sBreak;
2451 :
2452 62 : rSet.Put(SfxStringItem(nWhich, aFormat));
2453 : }
2454 : else
2455 : {
2456 0 : rSet.InvalidateItem( nWhich );
2457 : }
2458 : }
2459 31 : break;
2460 :
2461 : case SID_NUMBER_TYPE_FORMAT:
2462 : {
2463 31 : sal_Int16 aFormatCode = -1;
2464 31 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2465 31 : if ( rAttrSet.GetItemState( ATTR_VALUE_FORMAT ) >= SfxItemState::DEFAULT ) //Modify for more robust
2466 : {
2467 31 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2468 31 : sal_uInt32 nNumberFormat = pTabViewShell->GetSelectionPattern()->GetNumberFormat( pFormatter );
2469 31 : const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
2470 31 : bool bStandard = false;
2471 :
2472 31 : if ( pFormatEntry )
2473 : {
2474 31 : aFormatCode = pFormatEntry->GetType();
2475 31 : bStandard = pFormatEntry->IsStandard();
2476 : }
2477 :
2478 31 : switch(aFormatCode)
2479 : {
2480 : case css::util::NumberFormat::NUMBER:
2481 : case css::util::NumberFormat::NUMBER| css::util::NumberFormat::DEFINED:
2482 : //use format code and standard format code to judge whether it is General,
2483 : //if (nNumberFormat == nStandardNumberFormat)
2484 31 : if (bStandard)
2485 31 : aFormatCode = 0;
2486 : else
2487 0 : aFormatCode = 1;
2488 31 : break;
2489 : case css::util::NumberFormat::PERCENT:
2490 : case css::util::NumberFormat::PERCENT| css::util::NumberFormat::DEFINED:
2491 0 : aFormatCode = 2;
2492 0 : break;
2493 : case css::util::NumberFormat::CURRENCY:
2494 : case css::util::NumberFormat::CURRENCY| css::util::NumberFormat::DEFINED:
2495 0 : aFormatCode = 3;
2496 0 : break;
2497 : case css::util::NumberFormat::DATE:
2498 : case css::util::NumberFormat::DATE| css::util::NumberFormat::DEFINED:
2499 : //Add
2500 : case css::util::NumberFormat::DATETIME:
2501 : case css::util::NumberFormat::DATETIME | css::util::NumberFormat::DEFINED:
2502 0 : aFormatCode = 4;
2503 0 : break;
2504 : case css::util::NumberFormat::TIME:
2505 : case css::util::NumberFormat::TIME| css::util::NumberFormat::DEFINED:
2506 0 : aFormatCode = 5;
2507 0 : break;
2508 : case css::util::NumberFormat::SCIENTIFIC:
2509 : case css::util::NumberFormat::SCIENTIFIC| css::util::NumberFormat::DEFINED:
2510 0 : aFormatCode = 6;
2511 0 : break;
2512 : case css::util::NumberFormat::FRACTION:
2513 : case css::util::NumberFormat::FRACTION| css::util::NumberFormat::DEFINED:
2514 0 : aFormatCode = 7;
2515 0 : break;
2516 : case css::util::NumberFormat::LOGICAL:
2517 : case css::util::NumberFormat::LOGICAL| css::util::NumberFormat::DEFINED:
2518 0 : aFormatCode = 8;
2519 0 : break;
2520 : case css::util::NumberFormat::TEXT:
2521 : case css::util::NumberFormat::TEXT| css::util::NumberFormat::DEFINED:
2522 0 : aFormatCode = 9;
2523 0 : break;
2524 : default:
2525 0 : aFormatCode = -1; //for more roburst
2526 : }
2527 31 : if( aFormatCode == -1 )
2528 0 : rSet.InvalidateItem( nWhich );
2529 : else
2530 31 : rSet.Put( SfxInt16Item( nWhich, aFormatCode ) );
2531 : }
2532 : else
2533 : {
2534 0 : rSet.InvalidateItem( nWhich );
2535 : }
2536 :
2537 : }
2538 31 : break;
2539 : case SID_NUMBER_SCIENTIFIC:
2540 185 : rSet.Put( SfxBoolItem(nWhich, (nType & css::util::NumberFormat::SCIENTIFIC)) );
2541 185 : break;
2542 : case SID_NUMBER_DATE:
2543 185 : rSet.Put( SfxBoolItem(nWhich, (nType & css::util::NumberFormat::DATE)) );
2544 185 : break;
2545 : case SID_NUMBER_CURRENCY:
2546 185 : rSet.Put( SfxBoolItem(nWhich, (nType & css::util::NumberFormat::CURRENCY)) );
2547 185 : break;
2548 : case SID_NUMBER_PERCENT:
2549 185 : rSet.Put( SfxBoolItem(nWhich, (nType & css::util::NumberFormat::PERCENT)) );
2550 185 : break;
2551 : case SID_NUMBER_TIME:
2552 0 : rSet.Put( SfxBoolItem(nWhich, (nType & css::util::NumberFormat::TIME)) );
2553 0 : break;
2554 : }
2555 802 : nWhich = aIter.NextWhich();
2556 647 : }
2557 647 : }
2558 :
2559 0 : void ScFormatShell::ExecuteTextDirection( SfxRequest& rReq )
2560 : {
2561 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2562 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
2563 0 : bool bEditMode = false;
2564 0 : if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
2565 : {
2566 0 : bEditMode=true;
2567 0 : SC_MOD()->InputEnterHandler();
2568 0 : pTabViewShell->UpdateInputHandler();
2569 : }
2570 0 : sal_uInt16 nSlot = rReq.GetSlot();
2571 0 : switch( nSlot )
2572 : {
2573 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2574 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2575 : {
2576 0 : bool bVert = (nSlot == SID_TEXTDIRECTION_TOP_TO_BOTTOM);
2577 0 : ScPatternAttr aAttr( GetViewData()->GetDocument()->GetPool() );
2578 0 : SfxItemSet& rItemSet = aAttr.GetItemSet();
2579 0 : rItemSet.Put( SfxBoolItem( ATTR_STACKED, bVert ) );
2580 0 : rItemSet.Put( SfxBoolItem( ATTR_VERTICAL_ASIAN, bVert ) );
2581 0 : pTabViewShell->ApplySelectionPattern( aAttr );
2582 0 : pTabViewShell->AdjustBlockHeight();
2583 : }
2584 0 : break;
2585 :
2586 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2587 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2588 : {
2589 : SvxFrameDirection eDirection = ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) ?
2590 0 : FRMDIR_HORI_LEFT_TOP : FRMDIR_HORI_RIGHT_TOP;
2591 0 : pTabViewShell->ApplyAttr( SvxFrameDirectionItem( eDirection, ATTR_WRITINGDIR ) );
2592 : }
2593 0 : break;
2594 : }
2595 0 : if (bEditMode)
2596 0 : SC_MOD()->SetInputMode( SC_INPUT_TABLE );
2597 0 : }
2598 :
2599 2483 : void ScFormatShell::GetTextDirectionState( SfxItemSet& rSet )
2600 : {
2601 2483 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2602 2483 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2603 :
2604 : bool bVertDontCare =
2605 4966 : (rAttrSet.GetItemState( ATTR_VERTICAL_ASIAN ) == SfxItemState::DONTCARE) ||
2606 4966 : (rAttrSet.GetItemState( ATTR_STACKED ) == SfxItemState::DONTCARE);
2607 4966 : bool bLeftRight = !bVertDontCare &&
2608 4966 : !static_cast<const SfxBoolItem&>(rAttrSet.Get( ATTR_STACKED )).GetValue();
2609 2483 : bool bTopBottom = !bVertDontCare && !bLeftRight &&
2610 2483 : static_cast<const SfxBoolItem&>(rAttrSet.Get( ATTR_VERTICAL_ASIAN )).GetValue();
2611 :
2612 2483 : bool bBidiDontCare = (rAttrSet.GetItemState( ATTR_WRITINGDIR ) == SfxItemState::DONTCARE);
2613 2483 : EEHorizontalTextDirection eBidiDir = EE_HTEXTDIR_DEFAULT;
2614 2483 : if ( !bBidiDontCare )
2615 : {
2616 : SvxFrameDirection eCellDir = (SvxFrameDirection)static_cast<const SvxFrameDirectionItem&>(
2617 2483 : rAttrSet.Get( ATTR_WRITINGDIR )).GetValue();
2618 2483 : if ( eCellDir == FRMDIR_ENVIRONMENT )
2619 : eBidiDir = (EEHorizontalTextDirection)GetViewData()->GetDocument()->
2620 2483 : GetEditTextDirection( GetViewData()->GetTabNo() );
2621 0 : else if ( eCellDir == FRMDIR_HORI_RIGHT_TOP )
2622 0 : eBidiDir = EE_HTEXTDIR_R2L;
2623 : else
2624 0 : eBidiDir = EE_HTEXTDIR_L2R;
2625 : }
2626 :
2627 2483 : SvtLanguageOptions aLangOpt;
2628 2483 : bool bDisableCTLFont = !aLangOpt.IsCTLFontEnabled();
2629 2483 : bool bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled();
2630 :
2631 4966 : SfxWhichIter aIter( rSet );
2632 2483 : sal_uInt16 nWhich = aIter.FirstWhich();
2633 7604 : while( nWhich )
2634 : {
2635 2638 : switch( nWhich )
2636 : {
2637 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2638 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2639 370 : if ( bDisableVerticalText )
2640 0 : rSet.DisableItem( nWhich );
2641 : else
2642 : {
2643 370 : if( bVertDontCare )
2644 0 : rSet.InvalidateItem( nWhich );
2645 370 : else if ( nWhich == SID_TEXTDIRECTION_LEFT_TO_RIGHT )
2646 185 : rSet.Put( SfxBoolItem( nWhich, bLeftRight ) );
2647 : else
2648 185 : rSet.Put( SfxBoolItem( nWhich, bTopBottom ) );
2649 : }
2650 370 : break;
2651 :
2652 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2653 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2654 980 : if ( bDisableCTLFont )
2655 0 : rSet.DisableItem( nWhich );
2656 : else
2657 : {
2658 980 : if ( bTopBottom )
2659 0 : rSet.DisableItem( nWhich );
2660 980 : else if ( bBidiDontCare )
2661 0 : rSet.InvalidateItem( nWhich );
2662 980 : else if ( nWhich == SID_ATTR_PARA_LEFT_TO_RIGHT )
2663 490 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_L2R ) );
2664 : else
2665 490 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_R2L ) );
2666 : }
2667 : }
2668 2638 : nWhich = aIter.NextWhich();
2669 2483 : }
2670 2483 : }
2671 :
2672 0 : void ScFormatShell::ExecFormatPaintbrush( SfxRequest& rReq )
2673 : {
2674 0 : ScViewFunc* pView = pViewData->GetView();
2675 0 : if ( pView->HasPaintBrush() )
2676 : {
2677 : // cancel paintbrush mode
2678 0 : pView->ResetBrushDocument();
2679 : }
2680 : else
2681 : {
2682 0 : bool bLock = false;
2683 0 : const SfxItemSet *pArgs = rReq.GetArgs();
2684 0 : if( pArgs && pArgs->Count() >= 1 )
2685 0 : bLock = static_cast<const SfxBoolItem&>(pArgs->Get(SID_FORMATPAINTBRUSH)).GetValue();
2686 :
2687 : // in case of multi selection, deselect all and use the cursor position
2688 0 : ScRange aDummy;
2689 0 : if ( pViewData->GetSimpleArea(aDummy) != SC_MARK_SIMPLE )
2690 0 : pView->Unmark();
2691 :
2692 0 : ScDocument* pBrushDoc = new ScDocument( SCDOCMODE_CLIP );
2693 0 : pView->CopyToClip( pBrushDoc, false, true );
2694 0 : pView->SetBrushDocument( pBrushDoc, bLock );
2695 : }
2696 0 : }
2697 :
2698 249 : void ScFormatShell::StateFormatPaintbrush( SfxItemSet& rSet )
2699 : {
2700 249 : if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
2701 0 : rSet.DisableItem( SID_FORMATPAINTBRUSH );
2702 : else
2703 249 : rSet.Put( SfxBoolItem( SID_FORMATPAINTBRUSH, pViewData->GetView()->HasPaintBrush() ) );
2704 249 : }
2705 :
2706 647 : short ScFormatShell::GetCurrentNumberFormatType()
2707 : {
2708 647 : short nType = css::util::NumberFormat::ALL;
2709 647 : ScDocument* pDoc = GetViewData()->GetDocument();
2710 647 : ScMarkData aMark(GetViewData()->GetMarkData());
2711 647 : const SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2712 647 : if (!pFormatter)
2713 0 : return nType;
2714 :
2715 : // TODO: Find out how to get a selected table range in case multiple tables
2716 : // are selected. Currently we only check for the current active table.
2717 :
2718 647 : if ( aMark.IsMarked() || aMark.IsMultiMarked() )
2719 : {
2720 0 : aMark.MarkToMulti();
2721 0 : ScRange aRange;
2722 0 : aMark.GetMultiMarkArea(aRange);
2723 :
2724 0 : const ScMarkArray* pArray = aMark.GetArray();
2725 0 : if (!pArray)
2726 0 : return nType;
2727 :
2728 0 : short nComboType = css::util::NumberFormat::ALL;
2729 0 : bool bFirstItem = true;
2730 0 : for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
2731 : {
2732 0 : const ScMarkArray& rColArray = pArray[nCol];
2733 0 : if (!rColArray.HasMarks())
2734 0 : continue;
2735 :
2736 : SCROW nRow1, nRow2;
2737 0 : ScMarkArrayIter aMarkIter(&rColArray);
2738 0 : while (aMarkIter.Next(nRow1, nRow2))
2739 : {
2740 0 : ScRange aColRange(nCol, nRow1, aRange.aStart.Tab());
2741 0 : aColRange.aEnd.SetRow(nRow2);
2742 0 : sal_uInt32 nNumFmt = pDoc->GetNumberFormat(aColRange);
2743 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nNumFmt);
2744 0 : if (!pEntry)
2745 0 : return 0;
2746 :
2747 0 : short nThisType = pEntry->GetType();
2748 0 : if (bFirstItem)
2749 : {
2750 0 : bFirstItem = false;
2751 0 : nComboType = nThisType;
2752 : }
2753 0 : else if (nComboType != nThisType)
2754 : // mixed number format type.
2755 0 : return css::util::NumberFormat::ALL;
2756 : }
2757 0 : }
2758 0 : nType = nComboType;
2759 : }
2760 : else
2761 : {
2762 : sal_uInt32 nNumFmt;
2763 647 : pDoc->GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
2764 1294 : pViewData->GetTabNo(), nNumFmt );
2765 647 : const SvNumberformat* pEntry = pFormatter->GetEntry( nNumFmt );
2766 647 : nType = pEntry ? pEntry->GetType() : 0;
2767 : }
2768 647 : return nType;
2769 156 : }
2770 :
2771 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
