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