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