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/eeitem.hxx>
26 :
27 : #include <sfx2/app.hxx>
28 : #include <sfx2/viewfrm.hxx>
29 : #include <sfx2/bindings.hxx>
30 : #include <sfx2/objface.hxx>
31 : #include <sfx2/request.hxx>
32 : #include <svl/whiter.hxx>
33 : #include <vcl/msgbox.hxx>
34 :
35 : #include <svl/stritem.hxx>
36 : #include <svl/zformat.hxx>
37 : #include <svl/languageoptions.hxx>
38 : #include <editeng/boxitem.hxx>
39 : #include <editeng/langitem.hxx>
40 : #include <svx/numinf.hxx>
41 : #include <sfx2/dispatch.hxx>
42 : #include <sfx2/templdlg.hxx>
43 : #include <sfx2/tplpitem.hxx>
44 : #include <editeng/svxenum.hxx>
45 : #include <svx/algitem.hxx>
46 : #include <editeng/wghtitem.hxx>
47 : #include <editeng/postitem.hxx>
48 : #include <editeng/udlnitem.hxx>
49 : #include <editeng/bolnitem.hxx>
50 : #include <editeng/colritem.hxx>
51 : #include <editeng/brshitem.hxx>
52 : #include <editeng/frmdiritem.hxx>
53 : #include <editeng/scripttypeitem.hxx>
54 : #include <svtools/colorcfg.hxx>
55 : #include <editeng/shaditem.hxx>
56 : #include <editeng/justifyitem.hxx>
57 :
58 : #include "formatsh.hxx"
59 : #include "sc.hrc"
60 : #include "globstr.hrc"
61 : #include "docsh.hxx"
62 : #include "patattr.hxx"
63 : #include "scmod.hxx"
64 : #include "attrdlg.hrc"
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 :
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 0 : TYPEINIT1( ScFormatShell, SfxShell );
120 :
121 25 : SFX_IMPL_INTERFACE(ScFormatShell, SfxShell, ScResId(SCSTR_FORMATSHELL) )
122 : {
123 10 : SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD |
124 : SFX_VISIBILITY_SERVER,
125 5 : ScResId(RID_OBJECTBAR_FORMAT));
126 :
127 5 : }
128 :
129 :
130 0 : ScFormatShell::ScFormatShell(ScViewData* pData) :
131 0 : SfxShell(pData->GetViewShell()),
132 0 : pViewData(pData)
133 : {
134 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
135 :
136 0 : SetPool( &pTabViewShell->GetPool() );
137 0 : ::svl::IUndoManager* pMgr = pViewData->GetSfxDocShell()->GetUndoManager();
138 0 : SetUndoManager( pMgr );
139 0 : if ( !pViewData->GetDocument()->IsUndoEnabled() )
140 : {
141 0 : pMgr->SetMaxUndoActionCount( 0 );
142 : }
143 0 : SetHelpId(HID_SCSHELL_FORMATSH);
144 0 : SetName(rtl::OUString("Format"));
145 0 : }
146 :
147 0 : ScFormatShell::~ScFormatShell()
148 : {
149 0 : }
150 :
151 : //------------------------------------------------------------------
152 :
153 0 : void ScFormatShell::GetStyleState( SfxItemSet& rSet )
154 : {
155 0 : ScDocument* pDoc = GetViewData()->GetDocument();
156 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
157 0 : SfxStyleSheetBasePool* pStylePool = pDoc->GetStyleSheetPool();
158 :
159 0 : bool bProtected = false;
160 0 : SCTAB nTabCount = pDoc->GetTableCount();
161 0 : for (SCTAB i=0; i<nTabCount; i++)
162 0 : if (pDoc->IsTabProtected(i)) // ueberhaupt eine Tabelle geschuetzt?
163 0 : bProtected = true;
164 :
165 0 : SfxWhichIter aIter(rSet);
166 0 : sal_uInt16 nWhich = aIter.FirstWhich();
167 0 : sal_uInt16 nSlotId = 0;
168 :
169 0 : while ( nWhich )
170 : {
171 0 : nSlotId = SfxItemPool::IsWhich( nWhich )
172 0 : ? GetPool().GetSlotId( nWhich )
173 0 : : nWhich;
174 :
175 0 : switch ( nSlotId )
176 : {
177 : case SID_STYLE_APPLY:
178 0 : if ( !pStylePool )
179 0 : rSet.DisableItem( nSlotId );
180 0 : break;
181 :
182 : case SID_STYLE_FAMILY2: // Zellvorlagen
183 : {
184 : SfxStyleSheet* pStyleSheet = (SfxStyleSheet*)
185 0 : pTabViewShell->GetStyleSheetFromMarked();
186 :
187 0 : if ( pStyleSheet )
188 0 : rSet.Put( SfxTemplateItem( nSlotId, pStyleSheet->GetName() ) );
189 : else
190 0 : rSet.Put( SfxTemplateItem( nSlotId, String() ) );
191 : }
192 0 : break;
193 :
194 : case SID_STYLE_FAMILY4: // Seitenvorlagen
195 : {
196 0 : SCTAB nCurTab = GetViewData()->GetTabNo();
197 0 : String aPageStyle = pDoc->GetPageStyle( nCurTab );
198 : SfxStyleSheet* pStyleSheet = (SfxStyleSheet*)pStylePool->
199 0 : Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
200 :
201 0 : if ( pStyleSheet )
202 0 : rSet.Put( SfxTemplateItem( nSlotId, aPageStyle ) );
203 : else
204 0 : rSet.Put( SfxTemplateItem( nSlotId, String() ) );
205 : }
206 0 : break;
207 :
208 : case SID_STYLE_WATERCAN:
209 : {
210 0 : rSet.Put( SfxBoolItem( nSlotId, SC_MOD()->GetIsWaterCan() ) );
211 : }
212 0 : break;
213 :
214 : case SID_STYLE_UPDATE_BY_EXAMPLE:
215 : {
216 : ISfxTemplateCommon* pDesigner = SFX_APP()->
217 0 : GetCurrentTemplateCommon(pTabViewShell->GetViewFrame()->GetBindings());
218 0 : bool bPage = pDesigner && SFX_STYLE_FAMILY_PAGE == pDesigner->GetActualFamily();
219 :
220 0 : if ( bProtected || bPage )
221 0 : rSet.DisableItem( nSlotId );
222 : }
223 0 : break;
224 :
225 : case SID_STYLE_EDIT:
226 : case SID_STYLE_DELETE:
227 : case SID_STYLE_HIDE:
228 : case SID_STYLE_SHOW:
229 : {
230 : ISfxTemplateCommon* pDesigner = SFX_APP()->
231 0 : GetCurrentTemplateCommon(pTabViewShell->GetViewFrame()->GetBindings());
232 0 : bool bPage = pDesigner && SFX_STYLE_FAMILY_PAGE == pDesigner->GetActualFamily();
233 :
234 0 : if ( bProtected && !bPage )
235 0 : rSet.DisableItem( nSlotId );
236 : }
237 0 : break;
238 :
239 : default:
240 0 : break;
241 : }
242 :
243 0 : nWhich = aIter.NextWhich();
244 0 : }
245 0 : }
246 :
247 : //------------------------------------------------------------------
248 :
249 0 : void ScFormatShell::ExecuteStyle( SfxRequest& rReq )
250 : {
251 : // Wenn ToolBar vertikal :
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 : || (nSlotId == SID_STYLE_EDIT)
273 : || (nSlotId == SID_STYLE_DELETE)
274 : || (nSlotId == SID_STYLE_HIDE)
275 : || (nSlotId == SID_STYLE_SHOW)
276 : || (nSlotId == SID_STYLE_APPLY)
277 : || (nSlotId == SID_STYLE_WATERCAN)
278 : || (nSlotId == SID_STYLE_FAMILY)
279 : || (nSlotId == SID_STYLE_NEW_BY_EXAMPLE)
280 : || (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 : else
296 0 : if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState( SID_STYLE_FAMILYNAME, sal_True, &pFamItem ) )
297 : {
298 0 : String sFamily = ((const SfxStringItem*)pFamItem)->GetValue();
299 0 : if (sFamily.CompareToAscii("CellStyles") == COMPARE_EQUAL)
300 0 : eFamily = SFX_STYLE_FAMILY_PARA;
301 : else
302 0 : if (sFamily.CompareToAscii("PageStyles") == COMPARE_EQUAL)
303 0 : eFamily = SFX_STYLE_FAMILY_PAGE;
304 : }
305 :
306 0 : String aStyleName;
307 0 : sal_uInt16 nRetMask = 0xffff;
308 :
309 0 : pStylePool->SetSearchMask( eFamily, SFXSTYLEBIT_ALL );
310 :
311 0 : switch ( nSlotId )
312 : {
313 : case SID_STYLE_NEW:
314 : {
315 : const SfxPoolItem* pNameItem;
316 0 : if (pArgs && SFX_ITEM_SET == pArgs->GetItemState( nSlotId, sal_True, &pNameItem ))
317 0 : aStyleName = ((const SfxStringItem*)pNameItem)->GetValue();
318 :
319 0 : const SfxPoolItem* pRefItem=NULL;
320 0 : if (pArgs && SFX_ITEM_SET == pArgs->GetItemState( SID_STYLE_REFERENCE, sal_True, &pRefItem ))
321 : {
322 0 : if(pRefItem!=NULL)
323 0 : aRefName = ((const SfxStringItem*)pRefItem)->GetValue();
324 : }
325 :
326 : pStyleSheet = &(pStylePool->Make( aStyleName, eFamily,
327 0 : SFXSTYLEBIT_USERDEF ) );
328 :
329 0 : if ( pStyleSheet && pStyleSheet->HasParentSupport() )
330 0 : pStyleSheet->SetParent(aRefName);
331 : }
332 0 : break;
333 :
334 : case SID_STYLE_APPLY:
335 : {
336 0 : SFX_REQUEST_ARG( rReq, pNameItem, SfxStringItem, SID_APPLY_STYLE, false );
337 0 : SFX_REQUEST_ARG( rReq, pFamilyItem, SfxStringItem, SID_STYLE_FAMILYNAME, false );
338 0 : if ( pFamilyItem && pNameItem )
339 : {
340 0 : com::sun::star::uno::Reference< com::sun::star::style::XStyleFamiliesSupplier > xModel(pDocSh->GetModel(), com::sun::star::uno::UNO_QUERY);
341 : try
342 : {
343 0 : com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xStyles;
344 0 : com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xCont = xModel->getStyleFamilies();
345 0 : xCont->getByName(pFamilyItem->GetValue()) >>= xStyles;
346 0 : com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xInfo;
347 0 : xStyles->getByName( pNameItem->GetValue() ) >>= xInfo;
348 0 : ::rtl::OUString aUIName;
349 0 : xInfo->getPropertyValue( ::rtl::OUString("DisplayName") ) >>= aUIName;
350 0 : if ( !aUIName.isEmpty() )
351 0 : rReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aUIName ) );
352 : }
353 0 : catch( com::sun::star::uno::Exception& )
354 : {
355 0 : }
356 : }
357 : }
358 : case SID_STYLE_EDIT:
359 : case SID_STYLE_DELETE:
360 : case SID_STYLE_HIDE:
361 : case SID_STYLE_SHOW:
362 : case SID_STYLE_NEW_BY_EXAMPLE:
363 : {
364 : const SfxPoolItem* pNameItem;
365 0 : if (pArgs && SFX_ITEM_SET == pArgs->GetItemState( nSlotId, sal_True, &pNameItem ))
366 0 : aStyleName = ((const SfxStringItem*)pNameItem)->GetValue();
367 0 : pStyleSheet = pStylePool->Find( aStyleName, eFamily );
368 :
369 0 : aOldData.InitFromStyle( pStyleSheet );
370 : }
371 0 : break;
372 :
373 : case SID_STYLE_WATERCAN:
374 : {
375 0 : bool bWaterCan = pScMod->GetIsWaterCan();
376 :
377 0 : if( !bWaterCan )
378 : {
379 : const SfxPoolItem* pItem;
380 :
381 0 : if ( SFX_ITEM_SET ==
382 0 : pArgs->GetItemState( nSlotId, sal_True, &pItem ) )
383 : {
384 0 : const SfxStringItem* pStrItem = PTR_CAST(SfxStringItem,pItem);
385 0 : if ( pStrItem )
386 : {
387 0 : aStyleName = pStrItem->GetValue();
388 0 : pStyleSheet = pStylePool->Find( aStyleName, eFamily );
389 :
390 0 : if ( pStyleSheet )
391 : {
392 : ((ScStyleSheetPool*)pStylePool)->
393 0 : SetActualStyleSheet( pStyleSheet );
394 0 : rReq.Done();
395 : }
396 : }
397 : }
398 : }
399 :
400 0 : if ( !bWaterCan && pStyleSheet )
401 : {
402 0 : pScMod->SetWaterCan( true );
403 0 : pTabViewShell->SetActivePointer( Pointer(POINTER_FILL) );
404 0 : rReq.Done();
405 : }
406 : else
407 : {
408 0 : pScMod->SetWaterCan( false );
409 0 : pTabViewShell->SetActivePointer( Pointer(POINTER_ARROW) );
410 0 : rReq.Done();
411 : }
412 : }
413 0 : break;
414 :
415 : default:
416 0 : break;
417 : }
418 :
419 : // Neuen Style fuer WaterCan-Mode setzen
420 0 : if ( nSlotId == SID_STYLE_APPLY && pScMod->GetIsWaterCan() && pStyleSheet )
421 0 : ((ScStyleSheetPool*)pStylePool)->SetActualStyleSheet( pStyleSheet );
422 :
423 0 : switch ( eFamily )
424 : {
425 : case SFX_STYLE_FAMILY_PARA:
426 : {
427 0 : switch ( nSlotId )
428 : {
429 : case SID_STYLE_DELETE:
430 : {
431 0 : if ( pStyleSheet )
432 : {
433 0 : pTabViewShell->RemoveStyleSheetInUse( pStyleSheet );
434 0 : pStylePool->Remove( pStyleSheet );
435 0 : pTabViewShell->InvalidateAttribs();
436 0 : nRetMask = true;
437 0 : bAddUndo = true;
438 0 : rReq.Done();
439 : }
440 : else
441 0 : nRetMask = false;
442 : }
443 0 : break;
444 :
445 : case SID_STYLE_HIDE:
446 : case SID_STYLE_SHOW:
447 : {
448 0 : if ( pStyleSheet )
449 : {
450 0 : pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
451 0 : pTabViewShell->InvalidateAttribs();
452 0 : rReq.Done();
453 : }
454 : else
455 0 : nRetMask = false;
456 : }
457 0 : break;
458 :
459 : case SID_STYLE_APPLY:
460 : {
461 0 : if ( pStyleSheet && !pScMod->GetIsWaterCan() )
462 : {
463 : // Anwenden der Vorlage auf das Dokument
464 0 : pTabViewShell->SetStyleSheetToMarked( (SfxStyleSheet*)pStyleSheet );
465 0 : pTabViewShell->InvalidateAttribs();
466 0 : rReq.Done();
467 : }
468 : }
469 0 : break;
470 :
471 : case SID_STYLE_NEW_BY_EXAMPLE:
472 : case SID_STYLE_UPDATE_BY_EXAMPLE:
473 : {
474 : // Vorlage erzeugen/ersetzen durch Attribute
475 : // an der Cursor-Position:
476 :
477 0 : const ScPatternAttr* pAttrItem = NULL;
478 :
479 : // Die Abfrage, ob markiert ist, war hier immer falsch,
480 : // darum jetzt gar nicht mehr, und einfach vom Cursor.
481 : // Wenn Attribute aus der Selektion genommen werden sollen,
482 : // muss noch darauf geachtet werden, Items aus Vorlagen nicht
483 : // zu uebernehmen (GetSelectionPattern sammelt auch Items aus
484 : // Vorlagen zusammen) (#44748#)
485 : // pAttrItem = GetSelectionPattern();
486 :
487 : // ScViewData* pViewData = GetViewData();
488 0 : SCCOL nCol = pViewData->GetCurX();
489 0 : SCROW nRow = pViewData->GetCurY();
490 0 : pAttrItem = pDoc->GetPattern( nCol, nRow, nCurTab );
491 :
492 0 : SfxItemSet aAttrSet = pAttrItem->GetItemSet();
493 0 : aAttrSet.ClearItem( ATTR_MERGE );
494 0 : aAttrSet.ClearItem( ATTR_MERGE_FLAG );
495 : // bedingte Formatierung und Gueltigkeit nicht uebernehmen,
496 : // weil sie in der Vorlage nicht editiert werden koennen
497 0 : aAttrSet.ClearItem( ATTR_VALIDDATA );
498 0 : aAttrSet.ClearItem( ATTR_CONDITIONAL );
499 :
500 0 : if ( SID_STYLE_NEW_BY_EXAMPLE == nSlotId )
501 : {
502 0 : if ( bUndo )
503 : {
504 0 : String aUndo = ScGlobal::GetRscString( STR_UNDO_EDITCELLSTYLE );
505 0 : pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
506 0 : bListAction = true;
507 : }
508 :
509 0 : bool bConvertBack = false;
510 : SfxStyleSheet* pSheetInUse = (SfxStyleSheet*)
511 0 : pTabViewShell->GetStyleSheetFromMarked();
512 :
513 : // wenn neuer Style vorhanden und in der Selektion
514 : // verwendet wird, so darf der Parent nicht uebernommen
515 : // werden:
516 :
517 0 : if ( pStyleSheet && pSheetInUse && pStyleSheet == pSheetInUse )
518 0 : pSheetInUse = NULL;
519 :
520 : // wenn bereits vorhanden, erstmal entfernen...
521 0 : if ( pStyleSheet )
522 : {
523 : // Style-Pointer zu Namen vor Erase,
524 : // weil Zellen sonst ungueltige Pointer
525 : // enthalten.
526 : //!!! bei Gelenheit mal eine Methode, die
527 : // das fuer einen bestimmten Style macht
528 0 : pDoc->StylesToNames();
529 0 : bConvertBack = true;
530 0 : pStylePool->Remove(pStyleSheet);
531 : }
532 :
533 : // ...und neu anlegen
534 : pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
535 0 : SFXSTYLEBIT_USERDEF );
536 :
537 : // wenn ein Style vorhanden ist, so wird dieser
538 : // Parent der neuen Vorlage:
539 0 : if ( pSheetInUse && pStyleSheet->HasParentSupport() )
540 0 : pStyleSheet->SetParent( pSheetInUse->GetName() );
541 :
542 0 : if ( bConvertBack )
543 : // Namen zu Style-Pointer
544 0 : pDoc->UpdStlShtPtrsFrmNms();
545 : else
546 0 : pDoc->GetPool()->CellStyleCreated( aStyleName );
547 :
548 : // Attribute uebernehmen und Style anwenden
549 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
550 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
551 :
552 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
553 : // (pStyleSheet pointer is used!)
554 0 : bStyleToMarked = true;
555 : }
556 : else // ( nSlotId == SID_STYLE_UPDATE_BY_EXAMPLE )
557 : {
558 0 : pStyleSheet = (SfxStyleSheet*)pTabViewShell->GetStyleSheetFromMarked();
559 :
560 0 : if ( pStyleSheet )
561 : {
562 0 : aOldData.InitFromStyle( pStyleSheet );
563 :
564 0 : if ( bUndo )
565 : {
566 0 : String aUndo = ScGlobal::GetRscString( STR_UNDO_EDITCELLSTYLE );
567 0 : pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
568 0 : bListAction = true;
569 : }
570 :
571 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
572 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
573 :
574 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle
575 : // (pStyleSheet pointer is used!)
576 0 : bStyleToMarked = true;
577 : }
578 : }
579 :
580 0 : aNewData.InitFromStyle( pStyleSheet );
581 0 : bAddUndo = true;
582 0 : rReq.Done();
583 : }
584 0 : break;
585 :
586 : default:
587 0 : break;
588 : }
589 : } // case SFX_STYLE_FAMILY_PARA:
590 0 : break;
591 :
592 : case SFX_STYLE_FAMILY_PAGE:
593 : {
594 0 : switch ( nSlotId )
595 : {
596 : case SID_STYLE_DELETE:
597 : {
598 0 : nRetMask = ( NULL != pStyleSheet );
599 0 : if ( pStyleSheet )
600 : {
601 0 : if ( pDoc->RemovePageStyleInUse( pStyleSheet->GetName() ) )
602 : {
603 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nCurTab ).UpdatePages();
604 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
605 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
606 : }
607 0 : pStylePool->Remove( pStyleSheet );
608 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
609 0 : pDocSh->SetDocumentModified();
610 0 : bAddUndo = true;
611 0 : rReq.Done();
612 : }
613 : }
614 0 : break;
615 :
616 : case SID_STYLE_HIDE:
617 : case SID_STYLE_SHOW:
618 : {
619 0 : nRetMask = ( NULL != pStyleSheet );
620 0 : if ( pStyleSheet )
621 : {
622 0 : pStyleSheet->SetHidden( nSlotId == SID_STYLE_HIDE );
623 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
624 0 : pDocSh->SetDocumentModified();
625 0 : rReq.Done();
626 : }
627 : }
628 0 : break;
629 :
630 : case SID_STYLE_APPLY:
631 : {
632 0 : nRetMask = ( NULL != pStyleSheet );
633 0 : if ( pStyleSheet && !pScMod->GetIsWaterCan() )
634 : {
635 0 : ScUndoApplyPageStyle* pUndoAction = 0;
636 0 : SCTAB nTabCount = pDoc->GetTableCount();
637 0 : ScMarkData::iterator itr = rMark.begin(), itrEnd = rMark.end();
638 0 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
639 : {
640 0 : String aOldName = pDoc->GetPageStyle( *itr );
641 0 : if ( aOldName != aStyleName )
642 : {
643 0 : pDoc->SetPageStyle( *itr, aStyleName );
644 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), *itr ).UpdatePages();
645 0 : if( !pUndoAction )
646 0 : pUndoAction = new ScUndoApplyPageStyle( pDocSh, aStyleName );
647 0 : pUndoAction->AddSheetAction( *itr, aOldName );
648 : }
649 0 : }
650 0 : if( pUndoAction )
651 : {
652 0 : pDocSh->GetUndoManager()->AddUndoAction( pUndoAction );
653 0 : pDocSh->SetDocumentModified();
654 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 );
655 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
656 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
657 : }
658 0 : rReq.Done();
659 : }
660 : }
661 0 : break;
662 :
663 : case SID_STYLE_NEW_BY_EXAMPLE:
664 : {
665 0 : const String& rStrCurStyle = pDoc->GetPageStyle( nCurTab );
666 :
667 0 : if ( rStrCurStyle != aStyleName )
668 : {
669 0 : SfxStyleSheetBase* pCurStyle = pStylePool->Find( rStrCurStyle, eFamily );
670 0 : SfxItemSet aAttrSet = pCurStyle->GetItemSet();
671 : SCTAB nInTab;
672 0 : bool bUsed = pDoc->IsPageStyleInUse( aStyleName, &nInTab );
673 :
674 : // wenn bereits vorhanden, erstmal entfernen...
675 0 : if ( pStyleSheet )
676 0 : pStylePool->Remove( pStyleSheet );
677 :
678 : // ...und neu anlegen
679 : pStyleSheet = &pStylePool->Make( aStyleName, eFamily,
680 0 : SFXSTYLEBIT_USERDEF );
681 :
682 : // Attribute uebernehmen
683 0 : pStyleSheet->GetItemSet().Put( aAttrSet );
684 0 : pDocSh->SetDocumentModified();
685 :
686 : // wenn in Verwendung -> Update
687 0 : if ( bUsed )
688 0 : ScPrintFunc( pDocSh, pTabViewShell->GetPrinter(true), nInTab ).UpdatePages();
689 :
690 0 : aNewData.InitFromStyle( pStyleSheet );
691 0 : bAddUndo = true;
692 0 : rReq.Done();
693 0 : nRetMask = true;
694 0 : }
695 : }
696 0 : break;
697 :
698 : default:
699 0 : break;
700 : } // switch ( nSlotId )
701 : } // case SFX_STYLE_FAMILY_PAGE:
702 0 : break;
703 :
704 : default:
705 0 : break;
706 : } // switch ( eFamily )
707 :
708 : // Neu anlegen oder bearbeiten ueber Dialog:
709 0 : if ( nSlotId == SID_STYLE_NEW || nSlotId == SID_STYLE_EDIT )
710 : {
711 0 : if ( pStyleSheet )
712 : {
713 0 : SvxNumberInfoItem* pNumberInfoItem = NULL;
714 :
715 0 : SfxStyleFamily eFam = pStyleSheet->GetFamily();
716 0 : SfxAbstractTabDialog* pDlg = NULL;
717 0 : sal_uInt16 nRsc = 0;
718 :
719 : // alte Items aus der Vorlage merken
720 0 : SfxItemSet aOldSet = pStyleSheet->GetItemSet();
721 0 : String aOldName = pStyleSheet->GetName();
722 :
723 0 : switch ( eFam )
724 : {
725 : case SFX_STYLE_FAMILY_PAGE:
726 0 : nRsc = RID_SCDLG_STYLES_PAGE;
727 0 : break;
728 :
729 : case SFX_STYLE_FAMILY_PARA:
730 : default:
731 : {
732 0 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
733 :
734 : const SfxPoolItem* pItem;
735 0 : if ( rSet.GetItemState( ATTR_VALUE_FORMAT,
736 0 : false, &pItem ) == SFX_ITEM_SET )
737 : {
738 : // NumberFormat Value aus Value und Language
739 : // erzeugen und eintueten
740 : sal_uLong nFormat =
741 0 : ((SfxUInt32Item*)pItem)->GetValue();
742 : LanguageType eLang =
743 : ((SvxLanguageItem*)&rSet.Get(
744 0 : ATTR_LANGUAGE_FORMAT ))->GetLanguage();
745 : sal_uLong nLangFormat = pDoc->GetFormatTable()->
746 0 : GetFormatForLanguageIfBuiltIn( nFormat, eLang );
747 0 : if ( nLangFormat != nFormat )
748 : {
749 0 : SfxUInt32Item aNewItem( ATTR_VALUE_FORMAT, nLangFormat );
750 0 : rSet.Put( aNewItem );
751 0 : aOldSet.Put( aNewItem );
752 : // auch in aOldSet fuer Vergleich nach dem Dialog,
753 : // sonst geht evtl. eine Aenderung der Sprache verloren
754 : }
755 : }
756 :
757 0 : pTabViewShell->MakeNumberInfoItem( pDoc, GetViewData(), &pNumberInfoItem );
758 0 : pDocSh->PutItem( *pNumberInfoItem );
759 0 : nRsc = RID_SCDLG_STYLES_PAR;
760 :
761 : // auf jeden Fall ein SvxBoxInfoItem mit Table = sal_False im Set:
762 : // (wenn gar kein Item da ist, loescht der Dialog auch das
763 : // BORDER_OUTER SvxBoxItem aus dem Vorlagen-Set)
764 :
765 0 : if ( rSet.GetItemState( ATTR_BORDER_INNER, false ) != SFX_ITEM_SET )
766 : {
767 0 : SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
768 0 : aBoxInfoItem.SetTable(false); // keine inneren Linien
769 0 : aBoxInfoItem.SetDist(true);
770 0 : aBoxInfoItem.SetMinDist(false);
771 0 : rSet.Put( aBoxInfoItem );
772 : }
773 : }
774 0 : break;
775 : }
776 :
777 : // If GetDefDialogParent is a dialog, it must be used
778 : // (style catalog)
779 :
780 0 : Window* pParent = Application::GetDefDialogParent();
781 0 : if ( !pParent || !pParent->IsDialog() )
782 : {
783 : // GetDefDialogParent currently doesn't return the window
784 : // that was set with SetDefDialogParent (but dynamically finds the
785 : // topmost parent of the focus window), so IsDialog above is FALSE
786 : // even if called from the style catalog.
787 : // -> Use NULL if a modal dialog is open, to enable the Dialog's
788 : // default parent handling.
789 0 : if ( Application::IsInModalMode() )
790 0 : pParent = NULL;
791 : else
792 0 : pParent = pTabViewShell->GetDialogParent();
793 : }
794 :
795 0 : pTabViewShell->SetInFormatDialog(true);
796 :
797 0 : ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
798 : OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
799 :
800 0 : pDlg = pFact->CreateScStyleDlg( pParent, *pStyleSheet, nRsc, nRsc );
801 : OSL_ENSURE(pDlg, "Dialog create fail!");
802 0 : short nResult = pDlg->Execute();
803 0 : pTabViewShell->SetInFormatDialog(false);
804 :
805 0 : if ( nResult == RET_OK )
806 : {
807 0 : const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
808 :
809 0 : if ( pOutSet )
810 : {
811 0 : nRetMask = pStyleSheet->GetMask();
812 :
813 : // Attribut-Vergleiche (frueher in ModifyStyleSheet)
814 : // jetzt hier mit den alten Werten (Style ist schon veraendert)
815 :
816 0 : if ( SFX_STYLE_FAMILY_PARA == eFam )
817 : {
818 0 : SfxItemSet& rNewSet = pStyleSheet->GetItemSet();
819 : bool bNumFormatChanged;
820 0 : if ( ScGlobal::CheckWidthInvalidate(
821 0 : bNumFormatChanged, aOldSet, rNewSet ) )
822 0 : pDoc->InvalidateTextWidth( NULL, NULL, bNumFormatChanged );
823 :
824 0 : SCTAB nTabCount = pDoc->GetTableCount();
825 0 : for (SCTAB nTab=0; nTab<nTabCount; nTab++)
826 0 : if (pDoc->IsStreamValid(nTab))
827 0 : pDoc->SetStreamValid(nTab, false);
828 :
829 : sal_uLong nOldFormat = ((const SfxUInt32Item&)aOldSet.
830 0 : Get( ATTR_VALUE_FORMAT )).GetValue();
831 : sal_uLong nNewFormat = ((const SfxUInt32Item&)rNewSet.
832 0 : Get( ATTR_VALUE_FORMAT )).GetValue();
833 0 : if ( nNewFormat != nOldFormat )
834 : {
835 0 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
836 0 : const SvNumberformat* pOld = pFormatter->GetEntry( nOldFormat );
837 0 : const SvNumberformat* pNew = pFormatter->GetEntry( nNewFormat );
838 0 : if ( pOld && pNew && pOld->GetLanguage() != pNew->GetLanguage() )
839 : rNewSet.Put( SvxLanguageItem(
840 0 : pNew->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
841 : }
842 :
843 0 : pDoc->GetPool()->CellStyleCreated( pStyleSheet->GetName() );
844 : }
845 : else
846 : {
847 : //! auch fuer Seitenvorlagen die Abfragen hier
848 :
849 0 : String aNewName = pStyleSheet->GetName();
850 0 : if ( aNewName != aOldName &&
851 0 : pDoc->RenamePageStyleInUse( aOldName, aNewName ) )
852 : {
853 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE );
854 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
855 : }
856 :
857 0 : pDoc->ModifyStyleSheet( *pStyleSheet, *pOutSet );
858 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
859 : }
860 :
861 0 : pDocSh->SetDocumentModified();
862 :
863 0 : if ( SFX_STYLE_FAMILY_PARA == eFam )
864 : {
865 : pTabViewShell->UpdateNumberFormatter(
866 : (const SvxNumberInfoItem&)
867 0 : *(pDocSh->GetItem(SID_ATTR_NUMBERFORMAT_INFO)) );
868 :
869 0 : pTabViewShell->UpdateStyleSheetInUse( pStyleSheet );
870 0 : pTabViewShell->InvalidateAttribs();
871 : }
872 :
873 0 : aNewData.InitFromStyle( pStyleSheet );
874 0 : bAddUndo = true;
875 : }
876 : }
877 : else
878 : {
879 0 : if ( nSlotId == SID_STYLE_NEW )
880 0 : pStylePool->Remove( pStyleSheet );
881 : else
882 : {
883 : // falls zwischendurch etwas mit dem temporaer geaenderten
884 : // ItemSet gepainted wurde:
885 0 : pDocSh->PostPaintGridAll();
886 : }
887 : }
888 0 : delete pDlg;
889 : }
890 : }
891 :
892 0 : rReq.SetReturnValue( SfxUInt16Item( nSlotId, nRetMask ) );
893 :
894 0 : if ( bAddUndo && bUndo)
895 0 : pDocSh->GetUndoManager()->AddUndoAction(
896 0 : new ScUndoModifyStyle( pDocSh, eFamily, aOldData, aNewData ) );
897 :
898 0 : if ( bStyleToMarked )
899 : {
900 : // call SetStyleSheetToMarked after adding the ScUndoModifyStyle,
901 : // so redo will find the modified style
902 0 : pTabViewShell->SetStyleSheetToMarked( (SfxStyleSheet*)pStyleSheet );
903 0 : pTabViewShell->InvalidateAttribs();
904 : }
905 :
906 0 : if ( bListAction )
907 0 : pDocSh->GetUndoManager()->LeaveListAction();
908 : }
909 : else
910 : {
911 : OSL_FAIL( "Unknown slot (ScViewShell::ExecuteStyle)" );
912 0 : }
913 : }
914 :
915 0 : void ScFormatShell::ExecuteNumFormat( SfxRequest& rReq )
916 : {
917 0 : ScModule* pScMod = SC_MOD();
918 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
919 0 : const SfxItemSet* pReqArgs = rReq.GetArgs();
920 0 : sal_uInt16 nSlot = rReq.GetSlot();
921 0 : SfxBindings& rBindings = pTabViewShell->GetViewFrame()->GetBindings();
922 :
923 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
924 :
925 : // Eingabe beenden
926 0 : if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
927 : {
928 0 : switch ( nSlot )
929 : {
930 : case SID_NUMBER_TWODEC:
931 : case SID_NUMBER_SCIENTIFIC:
932 : case SID_NUMBER_DATE:
933 : case SID_NUMBER_CURRENCY:
934 : case SID_NUMBER_PERCENT:
935 : case SID_NUMBER_STANDARD:
936 : case SID_NUMBER_FORMAT:
937 : case SID_NUMBER_INCDEC:
938 : case SID_NUMBER_DECDEC:
939 : case FID_DEFINE_NAME:
940 : case FID_ADD_NAME:
941 : case FID_USE_NAME:
942 : case FID_INSERT_NAME:
943 : case SID_SPELL_DIALOG:
944 : case SID_HANGUL_HANJA_CONVERSION:
945 :
946 0 : pScMod->InputEnterHandler();
947 0 : pTabViewShell->UpdateInputHandler();
948 0 : break;
949 :
950 : default:
951 0 : break;
952 : }
953 : }
954 :
955 0 : short nType = GetCurrentNumberFormatType();
956 0 : SfxItemSet aSet( GetPool(), nSlot, nSlot );
957 0 : switch ( nSlot )
958 : {
959 : case SID_NUMBER_TWODEC:
960 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER, 4 ); // Standard+4 = #.##0,00
961 0 : rReq.Done();
962 0 : break;
963 : case SID_NUMBER_SCIENTIFIC:
964 0 : if ((nType & NUMBERFORMAT_SCIENTIFIC))
965 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
966 : else
967 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_SCIENTIFIC );
968 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_SCIENTIFIC)) );
969 0 : rBindings.Invalidate( nSlot );
970 0 : rReq.Done();
971 0 : break;
972 : case SID_NUMBER_DATE:
973 0 : if ((nType & NUMBERFORMAT_DATE))
974 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
975 : else
976 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_DATE );
977 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_DATE)) );
978 0 : rBindings.Invalidate( nSlot );
979 0 : rReq.Done();
980 0 : break;
981 : case SID_NUMBER_TIME:
982 0 : if ((nType & NUMBERFORMAT_TIME))
983 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
984 : else
985 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_TIME );
986 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_TIME)) );
987 0 : rBindings.Invalidate( nSlot );
988 0 : rReq.Done();
989 0 : break;
990 : case SID_NUMBER_CURRENCY:
991 0 : if ((nType & NUMBERFORMAT_CURRENCY))
992 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
993 : else
994 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_CURRENCY );
995 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_CURRENCY)) );
996 0 : rBindings.Invalidate( nSlot );
997 0 : rReq.Done();
998 0 : break;
999 : case SID_NUMBER_PERCENT:
1000 0 : if ((nType & NUMBERFORMAT_PERCENT))
1001 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1002 : else
1003 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_PERCENT );
1004 0 : aSet.Put( SfxBoolItem(nSlot, !(nType & NUMBERFORMAT_PERCENT)) );
1005 0 : rBindings.Invalidate( nSlot );
1006 0 : rReq.Done();
1007 0 : break;
1008 : case SID_NUMBER_STANDARD:
1009 0 : pTabViewShell->SetNumberFormat( NUMBERFORMAT_NUMBER );
1010 0 : rReq.Done();
1011 0 : break;
1012 : case SID_NUMBER_INCDEC:
1013 0 : pTabViewShell->ChangeNumFmtDecimals( true );
1014 0 : rReq.Done();
1015 0 : break;
1016 : case SID_NUMBER_DECDEC:
1017 0 : pTabViewShell->ChangeNumFmtDecimals( false );
1018 0 : rReq.Done();
1019 0 : break;
1020 :
1021 : case SID_NUMBER_FORMAT:
1022 0 : if ( pReqArgs )
1023 : {
1024 : const SfxPoolItem* pItem;
1025 0 : if(pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET)
1026 : {
1027 0 : String aCode = ((const SfxStringItem*)pItem)->GetValue();
1028 0 : pTabViewShell->SetNumFmtByStr( aCode );
1029 : }
1030 : }
1031 0 : break;
1032 :
1033 : case SID_ATTR_NUMBERFORMAT_VALUE:
1034 0 : if ( pReqArgs )
1035 : {
1036 : const SfxPoolItem* pItem;
1037 0 : if ( pReqArgs->GetItemState( ATTR_VALUE_FORMAT, sal_True, &pItem ) == SFX_ITEM_SET )
1038 : {
1039 : // We have to accomplish this using ApplyAttributes()
1040 : // because we also need the language information to be
1041 : // considered.
1042 : const SfxItemSet& rOldSet =
1043 0 : pTabViewShell->GetSelectionPattern()->GetItemSet();
1044 0 : SfxItemPool* pDocPool = GetViewData()->GetDocument()->GetPool();
1045 0 : SfxItemSet aNewSet( *pDocPool, ATTR_PATTERN_START, ATTR_PATTERN_END );
1046 0 : aNewSet.Put( *pItem );
1047 0 : pTabViewShell->ApplyAttributes( &aNewSet, &rOldSet, sal_True );
1048 : }
1049 : }
1050 0 : break;
1051 :
1052 : default:
1053 : OSL_FAIL("falscher Slot bei ExecuteEdit");
1054 0 : break;
1055 0 : }
1056 0 : }
1057 :
1058 :
1059 : //------------------------------------------------------------------
1060 :
1061 0 : void ScFormatShell::ExecuteAlignment( SfxRequest& rReq )
1062 : {
1063 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1064 0 : SfxBindings& rBindings = pViewData->GetBindings();
1065 0 : const SfxItemSet* pSet = rReq.GetArgs();
1066 0 : sal_uInt16 nSlot = rReq.GetSlot();
1067 :
1068 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1069 :
1070 0 : switch( nSlot )
1071 : {
1072 : // pseudo slots for Format menu
1073 : case SID_ALIGN_ANY_HDEFAULT:
1074 : case SID_ALIGN_ANY_LEFT:
1075 : case SID_ALIGN_ANY_HCENTER:
1076 : case SID_ALIGN_ANY_RIGHT:
1077 : case SID_ALIGN_ANY_JUSTIFIED:
1078 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( lclConvertSlotToHAlign( nSlot ), ATTR_HOR_JUSTIFY ) );
1079 0 : break;
1080 : case SID_ALIGN_ANY_VDEFAULT:
1081 : case SID_ALIGN_ANY_TOP:
1082 : case SID_ALIGN_ANY_VCENTER:
1083 : case SID_ALIGN_ANY_BOTTOM:
1084 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( lclConvertSlotToVAlign( nSlot ), ATTR_VER_JUSTIFY ) );
1085 0 : break;
1086 :
1087 : default:
1088 0 : if( pSet )
1089 : {
1090 0 : const SfxPoolItem* pItem = NULL;
1091 0 : if( pSet->GetItemState(GetPool().GetWhich(nSlot), sal_True, &pItem ) == SFX_ITEM_SET )
1092 : {
1093 :
1094 0 : switch ( nSlot )
1095 : {
1096 : case SID_ATTR_ALIGN_HOR_JUSTIFY:
1097 : case SID_ATTR_ALIGN_VER_JUSTIFY:
1098 : case SID_ATTR_ALIGN_INDENT:
1099 : case SID_ATTR_ALIGN_HYPHENATION:
1100 : case SID_ATTR_ALIGN_DEGREES:
1101 : case SID_ATTR_ALIGN_LOCKPOS:
1102 : case SID_ATTR_ALIGN_MARGIN:
1103 : case SID_ATTR_ALIGN_STACKED:
1104 0 : pTabViewShell->ApplyAttr( *pItem );
1105 0 : break;
1106 :
1107 : case SID_H_ALIGNCELL:
1108 : {
1109 0 : SvxCellHorJustify eJust = (SvxCellHorJustify)((const SvxHorJustifyItem*)pItem)->GetValue();
1110 : // #i78476# update alignment of text in cell edit mode
1111 0 : pTabViewShell->UpdateInputHandlerCellAdjust( eJust );
1112 0 : pTabViewShell->ApplyAttr( SvxHorJustifyItem( eJust, ATTR_HOR_JUSTIFY ) );
1113 : }
1114 0 : break;
1115 : case SID_V_ALIGNCELL:
1116 0 : pTabViewShell->ApplyAttr( SvxVerJustifyItem( (SvxCellVerJustify)((const SvxVerJustifyItem*)pItem)->GetValue(), ATTR_VER_JUSTIFY ) );
1117 0 : break;
1118 : default:
1119 : OSL_FAIL( "ExecuteAlignment: invalid slot" );
1120 0 : return;
1121 : }
1122 : }
1123 : }
1124 : }
1125 :
1126 0 : rBindings.Invalidate( SID_ALIGNLEFT );
1127 0 : rBindings.Invalidate( SID_ALIGNRIGHT );
1128 0 : rBindings.Invalidate( SID_ALIGNCENTERHOR );
1129 0 : rBindings.Invalidate( SID_ALIGNBLOCK );
1130 0 : rBindings.Invalidate( SID_ALIGNTOP );
1131 0 : rBindings.Invalidate( SID_ALIGNBOTTOM );
1132 0 : rBindings.Invalidate( SID_ALIGNCENTERVER );
1133 0 : rBindings.Invalidate( SID_V_ALIGNCELL );
1134 0 : rBindings.Invalidate( SID_H_ALIGNCELL );
1135 : // pseudo slots for Format menu
1136 0 : rBindings.Invalidate( SID_ALIGN_ANY_HDEFAULT );
1137 0 : rBindings.Invalidate( SID_ALIGN_ANY_LEFT );
1138 0 : rBindings.Invalidate( SID_ALIGN_ANY_HCENTER );
1139 0 : rBindings.Invalidate( SID_ALIGN_ANY_RIGHT );
1140 0 : rBindings.Invalidate( SID_ALIGN_ANY_JUSTIFIED );
1141 0 : rBindings.Invalidate( SID_ALIGN_ANY_VDEFAULT );
1142 0 : rBindings.Invalidate( SID_ALIGN_ANY_TOP );
1143 0 : rBindings.Invalidate( SID_ALIGN_ANY_VCENTER );
1144 0 : rBindings.Invalidate( SID_ALIGN_ANY_BOTTOM );
1145 0 : rBindings.Update();
1146 :
1147 0 : if( ! rReq.IsAPI() )
1148 0 : rReq.Done();
1149 : }
1150 :
1151 0 : void ScFormatShell::ExecuteTextAttr( SfxRequest& rReq )
1152 : {
1153 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1154 0 : SfxBindings& rBindings = pViewData->GetBindings();
1155 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1156 0 : const SfxItemSet* pSet = rReq.GetArgs();
1157 0 : sal_uInt16 nSlot = rReq.GetSlot();
1158 0 : SfxAllItemSet* pNewSet = 0;
1159 :
1160 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1161 :
1162 0 : if ( (nSlot == SID_ATTR_CHAR_WEIGHT)
1163 : ||(nSlot == SID_ATTR_CHAR_POSTURE)
1164 : ||(nSlot == SID_ATTR_CHAR_UNDERLINE)
1165 : ||(nSlot == SID_ULINE_VAL_NONE)
1166 : ||(nSlot == SID_ULINE_VAL_SINGLE)
1167 : ||(nSlot == SID_ULINE_VAL_DOUBLE)
1168 : ||(nSlot == SID_ULINE_VAL_DOTTED) )
1169 : {
1170 0 : pNewSet = new SfxAllItemSet( GetPool() );
1171 :
1172 0 : switch ( nSlot )
1173 : {
1174 : case SID_ATTR_CHAR_WEIGHT:
1175 : {
1176 : // #i78017 establish the same behaviour as in Writer
1177 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1178 :
1179 0 : SfxItemPool& rPool = GetPool();
1180 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1181 0 : if ( pSet )
1182 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_WEIGHT ) );
1183 : else
1184 : {
1185 : // toggle manually
1186 :
1187 0 : FontWeight eWeight = WEIGHT_BOLD;
1188 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1189 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1190 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1191 0 : if ( pCore && ((const SvxWeightItem*)pCore)->GetWeight() == WEIGHT_BOLD )
1192 0 : eWeight = WEIGHT_NORMAL;
1193 :
1194 0 : aSetItem.PutItemForScriptType( nScript, SvxWeightItem( eWeight, ATTR_FONT_WEIGHT ) );
1195 : }
1196 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1197 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1198 : }
1199 0 : break;
1200 :
1201 : case SID_ATTR_CHAR_POSTURE:
1202 : {
1203 : // #i78017 establish the same behaviour as in Writer
1204 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1205 :
1206 0 : SfxItemPool& rPool = GetPool();
1207 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1208 0 : if ( pSet )
1209 0 : aSetItem.PutItemForScriptType( nScript, pSet->Get( ATTR_FONT_POSTURE ) );
1210 : else
1211 : {
1212 : // toggle manually
1213 :
1214 0 : FontItalic eItalic = ITALIC_NORMAL;
1215 0 : SvxScriptSetItem aOldSetItem( nSlot, rPool );
1216 0 : aOldSetItem.GetItemSet().Put( pAttrs->GetItemSet(), false );
1217 0 : const SfxPoolItem* pCore = aOldSetItem.GetItemOfScript( nScript );
1218 0 : if ( pCore && ((const SvxPostureItem*)pCore)->GetPosture() == ITALIC_NORMAL )
1219 0 : eItalic = ITALIC_NONE;
1220 :
1221 0 : aSetItem.PutItemForScriptType( nScript, SvxPostureItem( eItalic, ATTR_FONT_POSTURE ) );
1222 : }
1223 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1224 0 : pNewSet->Put( aSetItem.GetItemSet(), false );
1225 : }
1226 0 : break;
1227 :
1228 : case SID_ATTR_CHAR_UNDERLINE:
1229 : {
1230 : FontUnderline eUnderline;
1231 :
1232 0 : if( pSet )
1233 : {
1234 0 : const SfxPoolItem& rUnderline = pSet->Get( ATTR_FONT_UNDERLINE );
1235 :
1236 0 : if( rUnderline.ISA(SvxUnderlineItem) )
1237 : {
1238 0 : pTabViewShell->ApplyAttr( rUnderline );
1239 0 : pNewSet->Put( rUnderline,rUnderline.Which() );
1240 : }
1241 0 : else if ( rUnderline.ISA(SvxTextLineItem) )
1242 : {
1243 : // #i106580# also allow SvxTextLineItem (base class of SvxUnderlineItem)
1244 0 : const SvxTextLineItem& rTextLineItem = static_cast<const SvxTextLineItem&>(rUnderline);
1245 0 : SvxUnderlineItem aNewItem( rTextLineItem.GetLineStyle(), rTextLineItem.Which() );
1246 0 : aNewItem.SetColor( rTextLineItem.GetColor() );
1247 0 : pTabViewShell->ApplyAttr( aNewItem );
1248 0 : pNewSet->Put( aNewItem, aNewItem.Which() );
1249 : }
1250 : }
1251 : else
1252 : {
1253 : SvxUnderlineItem aUnderline( (const SvxUnderlineItem&)
1254 : pAttrs->GetItem(
1255 0 : ATTR_FONT_UNDERLINE ) );
1256 0 : eUnderline = (UNDERLINE_NONE != aUnderline.GetLineStyle())
1257 : ? UNDERLINE_NONE
1258 0 : : UNDERLINE_SINGLE;
1259 0 : aUnderline.SetLineStyle( eUnderline );
1260 0 : pTabViewShell->ApplyAttr( aUnderline );
1261 0 : pNewSet->Put( aUnderline,aUnderline.Which() );
1262 : }
1263 : }
1264 0 : break;
1265 :
1266 : case SID_ULINE_VAL_NONE:
1267 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( UNDERLINE_NONE, ATTR_FONT_UNDERLINE ) );
1268 0 : break;
1269 : case SID_ULINE_VAL_SINGLE: // Toggles
1270 : case SID_ULINE_VAL_DOUBLE:
1271 : case SID_ULINE_VAL_DOTTED:
1272 : {
1273 : FontUnderline eOld = ((const SvxUnderlineItem&)
1274 0 : pAttrs->GetItem(ATTR_FONT_UNDERLINE)).GetLineStyle();
1275 0 : FontUnderline eNew = eOld;
1276 0 : switch (nSlot)
1277 : {
1278 : case SID_ULINE_VAL_SINGLE:
1279 0 : eNew = ( eOld == UNDERLINE_SINGLE ) ? UNDERLINE_NONE : UNDERLINE_SINGLE;
1280 0 : break;
1281 : case SID_ULINE_VAL_DOUBLE:
1282 0 : eNew = ( eOld == UNDERLINE_DOUBLE ) ? UNDERLINE_NONE : UNDERLINE_DOUBLE;
1283 0 : break;
1284 : case SID_ULINE_VAL_DOTTED:
1285 0 : eNew = ( eOld == UNDERLINE_DOTTED ) ? UNDERLINE_NONE : UNDERLINE_DOTTED;
1286 0 : break;
1287 : }
1288 0 : pTabViewShell->ApplyAttr( SvxUnderlineItem( eNew, ATTR_FONT_UNDERLINE ) );
1289 : }
1290 0 : break;
1291 :
1292 : default:
1293 0 : break;
1294 : }
1295 0 : rBindings.Invalidate( nSlot );
1296 : }
1297 : else
1298 : {
1299 : /*
1300 : * "Selbstgemachte" RadioButton-Funktionalitaet
1301 : * Beim Toggle gibt es den Standard-State, d.h. kein
1302 : * Button ist gedrueckt
1303 : */
1304 :
1305 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1306 0 : const SfxPoolItem* pItem = NULL;
1307 0 : const SvxHorJustifyItem* pHorJustify = NULL;
1308 0 : const SvxVerJustifyItem* pVerJustify = NULL;
1309 0 : SvxCellHorJustify eHorJustify = SVX_HOR_JUSTIFY_STANDARD;
1310 0 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
1311 :
1312 0 : if (rAttrSet.GetItemState(ATTR_HOR_JUSTIFY, sal_True,&pItem ) == SFX_ITEM_SET)
1313 : {
1314 0 : pHorJustify = (const SvxHorJustifyItem*)pItem;
1315 0 : eHorJustify = SvxCellHorJustify( pHorJustify->GetValue() );
1316 : }
1317 0 : if (rAttrSet.GetItemState(ATTR_VER_JUSTIFY, sal_True,&pItem ) == SFX_ITEM_SET)
1318 : {
1319 0 : pVerJustify = (const SvxVerJustifyItem*)pItem;
1320 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
1321 : }
1322 :
1323 0 : switch ( nSlot )
1324 : {
1325 : case SID_ALIGNLEFT:
1326 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1327 : rReq.AppendItem( SvxHorJustifyItem(
1328 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_LEFT) ?
1329 0 : SVX_HOR_JUSTIFY_LEFT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1330 0 : ExecuteSlot( rReq, GetInterface() );
1331 : return;
1332 : //break;
1333 :
1334 : case SID_ALIGNRIGHT:
1335 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1336 : rReq.AppendItem( SvxHorJustifyItem(
1337 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_RIGHT) ?
1338 0 : SVX_HOR_JUSTIFY_RIGHT : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1339 0 : ExecuteSlot( rReq, GetInterface() );
1340 : return;
1341 : //break;
1342 :
1343 : case SID_ALIGNCENTERHOR:
1344 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1345 : rReq.AppendItem( SvxHorJustifyItem(
1346 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_CENTER) ?
1347 0 : SVX_HOR_JUSTIFY_CENTER : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1348 0 : ExecuteSlot( rReq, GetInterface() );
1349 : return;
1350 : //break;
1351 :
1352 : case SID_ALIGNBLOCK:
1353 0 : rReq.SetSlot( SID_H_ALIGNCELL );
1354 : rReq.AppendItem( SvxHorJustifyItem(
1355 : !pHorJustify || (eHorJustify != SVX_HOR_JUSTIFY_BLOCK) ?
1356 0 : SVX_HOR_JUSTIFY_BLOCK : SVX_HOR_JUSTIFY_STANDARD, SID_H_ALIGNCELL ) );
1357 0 : ExecuteSlot( rReq, GetInterface() );
1358 : return;
1359 : //break;
1360 :
1361 : case SID_ALIGNTOP:
1362 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1363 : rReq.AppendItem( SvxVerJustifyItem(
1364 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_TOP) ?
1365 0 : SVX_VER_JUSTIFY_TOP : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1366 0 : ExecuteSlot( rReq, GetInterface() );
1367 : return;
1368 : //break;
1369 :
1370 : case SID_ALIGNBOTTOM:
1371 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1372 : rReq.AppendItem( SvxVerJustifyItem(
1373 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_BOTTOM) ?
1374 0 : SVX_VER_JUSTIFY_BOTTOM : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1375 0 : ExecuteSlot( rReq, GetInterface() );
1376 : return;
1377 : //break;
1378 :
1379 : case SID_ALIGNCENTERVER:
1380 0 : rReq.SetSlot( SID_V_ALIGNCELL );
1381 : rReq.AppendItem( SvxVerJustifyItem(
1382 : !pVerJustify || (eVerJustify != SVX_VER_JUSTIFY_CENTER) ?
1383 0 : SVX_VER_JUSTIFY_CENTER : SVX_VER_JUSTIFY_STANDARD, SID_V_ALIGNCELL ) );
1384 0 : ExecuteSlot( rReq, GetInterface() );
1385 : return;
1386 : //break;
1387 :
1388 : default:
1389 0 : break;
1390 : }
1391 :
1392 : }
1393 :
1394 0 : rBindings.Update();
1395 :
1396 0 : if( pNewSet )
1397 : {
1398 0 : rReq.Done( *pNewSet );
1399 0 : delete pNewSet;
1400 : }
1401 : else
1402 : {
1403 0 : rReq.Done();
1404 : }
1405 :
1406 : }
1407 :
1408 : //------------------------------------------------------------------
1409 :
1410 0 : void ScFormatShell::ExecuteAttr( SfxRequest& rReq )
1411 : {
1412 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1413 0 : SfxBindings& rBindings = pViewData->GetBindings();
1414 0 : const SfxItemSet* pNewAttrs = rReq.GetArgs();
1415 0 : sal_uInt16 nSlot = rReq.GetSlot();
1416 :
1417 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
1418 0 : if ( !pNewAttrs )
1419 : {
1420 0 : switch ( nSlot )
1421 : {
1422 : case SID_ATTR_CHAR_COLOR:
1423 : case SID_ATTR_CHAR_FONT:
1424 : case SID_ATTR_CHAR_FONTHEIGHT:
1425 0 : pTabViewShell->ExecuteCellFormatDlg( rReq, TP_FONT ); // wenn ToolBar vertikal
1426 0 : break;
1427 :
1428 : case SID_BACKGROUND_COLOR:
1429 : {
1430 : SvxBrushItem aBrushItem( (const SvxBrushItem&)
1431 0 : pTabViewShell->GetSelectionPattern()->GetItem( ATTR_BACKGROUND ) );
1432 0 : aBrushItem.SetColor( COL_TRANSPARENT );
1433 0 : pTabViewShell->ApplyAttr( aBrushItem );
1434 : }
1435 0 : break;
1436 :
1437 : case SID_ATTR_ALIGN_LINEBREAK: // ohne Parameter als Toggle
1438 : {
1439 0 : const ScPatternAttr* pAttrs = pTabViewShell->GetSelectionPattern();
1440 0 : bool bOld = ((const SfxBoolItem&)pAttrs->GetItem(ATTR_LINEBREAK)).GetValue();
1441 0 : SfxBoolItem aBreakItem( ATTR_LINEBREAK, !bOld );
1442 0 : pTabViewShell->ApplyAttr( aBreakItem );
1443 :
1444 0 : SfxAllItemSet aNewSet( GetPool() );
1445 0 : aNewSet.Put( aBreakItem,aBreakItem.Which() );
1446 0 : rReq.Done( aNewSet );
1447 :
1448 0 : rBindings.Invalidate( nSlot );
1449 : }
1450 0 : break;
1451 : }
1452 : }
1453 : else
1454 : {
1455 0 : switch ( nSlot )
1456 : {
1457 : case SID_ATTR_CHAR_OVERLINE:
1458 : case SID_ATTR_CHAR_STRIKEOUT:
1459 : case SID_ATTR_ALIGN_LINEBREAK:
1460 : case SID_ATTR_CHAR_COLOR:
1461 : case SID_ATTR_CHAR_CONTOUR:
1462 : case SID_ATTR_CHAR_SHADOWED:
1463 : case SID_ATTR_CHAR_RELIEF:
1464 : case SID_SCATTR_PROTECTION :
1465 0 : pTabViewShell->ApplyAttr( pNewAttrs->Get( pNewAttrs->GetPool()->GetWhich( nSlot ) ) );
1466 0 : rBindings.Invalidate( nSlot );
1467 0 : rBindings.Update( nSlot );
1468 0 : break;
1469 :
1470 : case SID_ATTR_CHAR_FONT:
1471 : case SID_ATTR_CHAR_FONTHEIGHT:
1472 : {
1473 : // #i78017 establish the same behaviour as in Writer
1474 0 : sal_uInt8 nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
1475 0 : if (nSlot == SID_ATTR_CHAR_FONT)
1476 0 : nScript = pTabViewShell->GetSelectionScriptType();
1477 :
1478 0 : SfxItemPool& rPool = GetPool();
1479 0 : SvxScriptSetItem aSetItem( nSlot, rPool );
1480 0 : sal_uInt16 nWhich = rPool.GetWhich( nSlot );
1481 0 : aSetItem.PutItemForScriptType( nScript, pNewAttrs->Get( nWhich ) );
1482 :
1483 0 : pTabViewShell->ApplyUserItemSet( aSetItem.GetItemSet() );
1484 :
1485 0 : rBindings.Invalidate( nSlot );
1486 0 : rBindings.Update( nSlot );
1487 : }
1488 0 : break;
1489 :
1490 : case SID_FRAME_LINESTYLE:
1491 : {
1492 : // Default-Linie aktualisieren
1493 : const ::editeng::SvxBorderLine* pLine =
1494 : ((const SvxLineItem&)
1495 0 : pNewAttrs->Get( SID_FRAME_LINESTYLE )).
1496 0 : GetLine();
1497 :
1498 0 : if ( pLine )
1499 : {
1500 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1501 :
1502 0 : if ( pDefLine )
1503 : {
1504 : pDefLine->SetBorderLineStyle(
1505 0 : pLine->GetBorderLineStyle());
1506 0 : pDefLine->SetWidth( pLine->GetWidth( ) );
1507 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, false );
1508 : }
1509 : else
1510 : {
1511 0 : pTabViewShell->SetDefaultFrameLine( pLine );
1512 0 : pTabViewShell->GetDefaultFrameLine()->SetColor( COL_BLACK );
1513 0 : pTabViewShell->SetSelectionFrameLines( pLine, false );
1514 : }
1515 : }
1516 : else
1517 : {
1518 0 : Color aColorBlack( COL_BLACK );
1519 : ::editeng::SvxBorderLine aDefLine( &aColorBlack, 20,
1520 0 : table::BorderLineStyle::SOLID );
1521 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1522 0 : pTabViewShell->SetSelectionFrameLines( NULL, false );
1523 : }
1524 : }
1525 0 : break;
1526 :
1527 : case SID_FRAME_LINECOLOR:
1528 : {
1529 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1530 : const Color& rColor = ((const SvxColorItem&)
1531 0 : pNewAttrs->Get( SID_FRAME_LINECOLOR )).
1532 0 : GetValue();
1533 :
1534 : // Default-Linie aktualisieren
1535 0 : if ( pDefLine )
1536 : {
1537 0 : pDefLine->SetColor( rColor );
1538 0 : pTabViewShell->SetSelectionFrameLines( pDefLine, sal_True );
1539 : }
1540 : else
1541 : {
1542 : ::editeng::SvxBorderLine aDefLine( &rColor, 20,
1543 0 : table::BorderLineStyle::SOLID );
1544 0 : pTabViewShell->SetDefaultFrameLine( &aDefLine );
1545 0 : pTabViewShell->SetSelectionFrameLines( &aDefLine, false );
1546 : }
1547 : }
1548 0 : break;
1549 :
1550 : case SID_ATTR_BORDER_OUTER:
1551 : case SID_ATTR_BORDER:
1552 : {
1553 0 : ::editeng::SvxBorderLine* pDefLine = pTabViewShell->GetDefaultFrameLine();
1554 0 : const ScPatternAttr* pOldAttrs = pTabViewShell->GetSelectionPattern();
1555 0 : ScDocument* pDoc = GetViewData()->GetDocument();
1556 : SfxItemSet* pOldSet =
1557 : new SfxItemSet(
1558 0 : *(pDoc->GetPool()),
1559 : ATTR_PATTERN_START,
1560 0 : ATTR_PATTERN_END );
1561 : SfxItemSet* pNewSet =
1562 : new SfxItemSet(
1563 0 : *(pDoc->GetPool()),
1564 : ATTR_PATTERN_START,
1565 0 : ATTR_PATTERN_END );
1566 : const SfxPoolItem& rBorderAttr =
1567 0 : pOldAttrs->GetItemSet().
1568 0 : Get( ATTR_BORDER );
1569 :
1570 : // Border-Items vom Controller auswerten:
1571 0 : const SfxPoolItem* pItem = 0;
1572 :
1573 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER, sal_True, &pItem )
1574 : == SFX_ITEM_SET )
1575 : {
1576 : // The SvxFrameToolBoxControl toolbox controller uses a default
1577 : // SvxBorderLine (all widths 0) to mark the lines that should be set.
1578 : // Macro recording uses a SvxBoxItem with the real values (OutWidth > 0)
1579 : // or NULL pointers for no lines.
1580 : // -> Substitute existing lines with pDefLine only if widths are 0.
1581 0 : SvxBoxItem aBoxItem ( *(const SvxBoxItem*)pItem );
1582 0 : if ( aBoxItem.GetTop() && aBoxItem.GetTop()->GetOutWidth() == 0 )
1583 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_TOP );
1584 0 : if ( aBoxItem.GetBottom() && aBoxItem.GetBottom()->GetOutWidth() == 0 )
1585 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_BOTTOM );
1586 0 : if ( aBoxItem.GetLeft() && aBoxItem.GetLeft()->GetOutWidth() == 0 )
1587 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_LEFT );
1588 0 : if ( aBoxItem.GetRight() && aBoxItem.GetRight()->GetOutWidth() == 0 )
1589 0 : aBoxItem.SetLine( pDefLine, BOX_LINE_RIGHT );
1590 0 : pNewSet->Put( aBoxItem );
1591 0 : rReq.AppendItem( aBoxItem );
1592 : }
1593 :
1594 0 : if ( pNewAttrs->GetItemState( ATTR_BORDER_INNER, sal_True, &pItem )
1595 : == SFX_ITEM_SET )
1596 : {
1597 0 : SvxBoxInfoItem aBoxInfoItem( *(const SvxBoxInfoItem*)pItem );
1598 0 : if ( aBoxInfoItem.GetHori() && aBoxInfoItem.GetHori()->GetOutWidth() == 0 )
1599 0 : aBoxInfoItem.SetLine( pDefLine, BOXINFO_LINE_HORI );
1600 0 : if ( aBoxInfoItem.GetVert() && aBoxInfoItem.GetVert()->GetOutWidth() == 0 )
1601 0 : aBoxInfoItem.SetLine( pDefLine, BOXINFO_LINE_VERT );
1602 0 : pNewSet->Put( aBoxInfoItem );
1603 0 : rReq.AppendItem( aBoxInfoItem );
1604 : }
1605 : else
1606 : {
1607 0 : SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
1608 0 : aBoxInfoItem.SetLine( NULL, BOXINFO_LINE_HORI );
1609 0 : aBoxInfoItem.SetLine( NULL, BOXINFO_LINE_VERT );
1610 0 : pNewSet->Put( aBoxInfoItem );
1611 : }
1612 :
1613 0 : pOldSet->Put( rBorderAttr );
1614 0 : pTabViewShell->ApplyAttributes( pNewSet, pOldSet );
1615 :
1616 0 : delete pOldSet;
1617 0 : delete pNewSet;
1618 : }
1619 0 : break;
1620 :
1621 : // ATTR_BACKGROUND (=SID_ATTR_BRUSH) muss ueber zwei IDs
1622 : // gesetzt werden:
1623 : case SID_BACKGROUND_COLOR:
1624 : {
1625 : const SvxColorItem rNewColorItem = (const SvxColorItem&)
1626 0 : pNewAttrs->Get( SID_BACKGROUND_COLOR );
1627 :
1628 : SvxBrushItem aBrushItem( (const SvxBrushItem&)
1629 : pTabViewShell->GetSelectionPattern()->
1630 0 : GetItem( ATTR_BACKGROUND ) );
1631 :
1632 0 : aBrushItem.SetColor( rNewColorItem.GetValue() );
1633 :
1634 0 : pTabViewShell->ApplyAttr( aBrushItem );
1635 : }
1636 0 : break;
1637 :
1638 : case SID_ATTR_BRUSH:
1639 : {
1640 : SvxBrushItem aBrushItem( (const SvxBrushItem&)
1641 : pTabViewShell->GetSelectionPattern()->
1642 0 : GetItem( ATTR_BACKGROUND ) );
1643 : const SvxBrushItem& rNewBrushItem = (const SvxBrushItem&)
1644 0 : pNewAttrs->Get( GetPool().GetWhich(nSlot) );
1645 0 : aBrushItem.SetColor(rNewBrushItem.GetColor());
1646 0 : pTabViewShell->ApplyAttr( aBrushItem );
1647 : }
1648 0 : break;
1649 :
1650 : case SID_ATTR_BORDER_SHADOW:
1651 : {
1652 : const SvxShadowItem& rNewShadowItem = (const SvxShadowItem&)
1653 0 : pNewAttrs->Get( ATTR_SHADOW );
1654 0 : pTabViewShell->ApplyAttr( rNewShadowItem );
1655 : }
1656 0 : break;
1657 :
1658 : default:
1659 0 : break;
1660 : }
1661 :
1662 0 : if( ! rReq.IsAPI() )
1663 0 : if( ! rReq.IsDone() )
1664 0 : rReq.Done();
1665 : }
1666 0 : }
1667 :
1668 0 : void ScFormatShell::GetAttrState( SfxItemSet& rSet )
1669 : {
1670 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1671 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1672 0 : const ::editeng::SvxBorderLine* pLine = pTabViewShell->GetDefaultFrameLine();
1673 0 : const SvxBrushItem& rBrushItem = (const SvxBrushItem&)rAttrSet.Get( ATTR_BACKGROUND );
1674 0 : SfxWhichIter aIter( rSet );
1675 0 : sal_uInt16 nWhich = aIter.FirstWhich();
1676 :
1677 0 : rSet.Put( rAttrSet, false );
1678 :
1679 : // choose font info according to selection script type
1680 0 : sal_uInt8 nScript = 0; // GetSelectionScriptType never returns 0
1681 0 : if ( rSet.GetItemState( ATTR_FONT ) != SFX_ITEM_UNKNOWN )
1682 : {
1683 0 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1684 0 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT, nScript );
1685 : }
1686 0 : if ( rSet.GetItemState( ATTR_FONT_HEIGHT ) != SFX_ITEM_UNKNOWN )
1687 : {
1688 0 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1689 0 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_HEIGHT, nScript );
1690 : }
1691 :
1692 0 : while ( nWhich )
1693 : {
1694 0 : switch(nWhich)
1695 : {
1696 : case SID_BACKGROUND_COLOR:
1697 : {
1698 0 : rSet.Put( SvxColorItem( rBrushItem.GetColor(), SID_BACKGROUND_COLOR ) );
1699 : }
1700 0 : break;
1701 : case SID_FRAME_LINECOLOR:
1702 : {
1703 0 : rSet.Put( SvxColorItem( pLine ? pLine->GetColor() : Color(), SID_FRAME_LINECOLOR ) );
1704 : }
1705 0 : break;
1706 : case SID_ATTR_BRUSH:
1707 : {
1708 0 : rSet.Put( rBrushItem, GetPool().GetWhich(nWhich) );
1709 : }
1710 0 : break;
1711 : }
1712 0 : nWhich = aIter.NextWhich();
1713 0 : }
1714 0 : }
1715 :
1716 : //------------------------------------------------------------------
1717 :
1718 0 : void ScFormatShell::GetTextAttrState( SfxItemSet& rSet )
1719 : {
1720 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1721 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1722 0 : rSet.Put( rAttrSet, false ); // ItemStates mitkopieren
1723 :
1724 : // choose font info according to selection script type
1725 0 : sal_uInt8 nScript = 0; // GetSelectionScriptType never returns 0
1726 0 : if ( rSet.GetItemState( ATTR_FONT_WEIGHT ) != SFX_ITEM_UNKNOWN )
1727 : {
1728 0 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1729 0 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_WEIGHT, nScript );
1730 : }
1731 0 : if ( rSet.GetItemState( ATTR_FONT_POSTURE ) != SFX_ITEM_UNKNOWN )
1732 : {
1733 0 : if (!nScript) nScript = pTabViewShell->GetSelectionScriptType();
1734 0 : ScViewUtil::PutItemScript( rSet, rAttrSet, ATTR_FONT_POSTURE, nScript );
1735 : }
1736 :
1737 : SfxItemState eState;
1738 : // const SfxPoolItem* pItem;
1739 :
1740 : //--------------------------------------------------------------------
1741 : // eigene Kontrolle ueber RadioButton-Funktionalitaet:
1742 : //--------------------------------------------------------------------
1743 : // Unterstreichung
1744 : //------------------------
1745 :
1746 0 : eState = rAttrSet.GetItemState( ATTR_FONT_UNDERLINE, sal_True );
1747 0 : if ( eState == SFX_ITEM_DONTCARE )
1748 : {
1749 0 : rSet.InvalidateItem( SID_ULINE_VAL_NONE );
1750 0 : rSet.InvalidateItem( SID_ULINE_VAL_SINGLE );
1751 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOUBLE );
1752 0 : rSet.InvalidateItem( SID_ULINE_VAL_DOTTED );
1753 : }
1754 : else
1755 : {
1756 : FontUnderline eUnderline = ((const SvxUnderlineItem&)
1757 0 : rAttrSet.Get(ATTR_FONT_UNDERLINE)).GetLineStyle();
1758 0 : sal_uInt16 nId = SID_ULINE_VAL_NONE;
1759 0 : switch (eUnderline)
1760 : {
1761 0 : case UNDERLINE_SINGLE: nId = SID_ULINE_VAL_SINGLE; break;
1762 0 : case UNDERLINE_DOUBLE: nId = SID_ULINE_VAL_DOUBLE; break;
1763 0 : case UNDERLINE_DOTTED: nId = SID_ULINE_VAL_DOTTED; break;
1764 : default:
1765 0 : break;
1766 : }
1767 0 : rSet.Put( SfxBoolItem( nId, sal_True ) );
1768 : }
1769 :
1770 : //------------------------
1771 : // horizontale Ausrichtung
1772 : //------------------------
1773 :
1774 0 : const SvxHorJustifyItem* pHorJustify = NULL;
1775 0 : const SvxVerJustifyItem* pVerJustify = NULL;
1776 0 : SvxCellVerJustify eVerJustify = SVX_VER_JUSTIFY_STANDARD;
1777 0 : sal_uInt16 nWhich = 0;
1778 0 : bool bJustifyStd = false;
1779 0 : SfxBoolItem aBoolItem ( 0, sal_True );
1780 :
1781 : eState = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY, sal_True,
1782 0 : (const SfxPoolItem**)&pHorJustify );
1783 0 : switch ( eState )
1784 : {
1785 : case SFX_ITEM_SET:
1786 : {
1787 0 : switch ( SvxCellHorJustify( pHorJustify->GetValue() ) )
1788 : {
1789 : case SVX_HOR_JUSTIFY_STANDARD:
1790 0 : break;
1791 :
1792 : case SVX_HOR_JUSTIFY_LEFT:
1793 0 : nWhich = SID_ALIGNLEFT;
1794 0 : break;
1795 :
1796 : case SVX_HOR_JUSTIFY_RIGHT:
1797 0 : nWhich = SID_ALIGNRIGHT;
1798 0 : break;
1799 :
1800 : case SVX_HOR_JUSTIFY_CENTER:
1801 0 : nWhich = SID_ALIGNCENTERHOR;
1802 0 : break;
1803 :
1804 : case SVX_HOR_JUSTIFY_BLOCK:
1805 0 : nWhich = SID_ALIGNBLOCK;
1806 0 : break;
1807 :
1808 : case SVX_HOR_JUSTIFY_REPEAT:
1809 : default:
1810 0 : bJustifyStd = sal_True;
1811 0 : break;
1812 : }
1813 : }
1814 0 : break;
1815 :
1816 : case SFX_ITEM_DONTCARE:
1817 0 : rSet.InvalidateItem( SID_ALIGNLEFT );
1818 0 : rSet.InvalidateItem( SID_ALIGNRIGHT );
1819 0 : rSet.InvalidateItem( SID_ALIGNCENTERHOR );
1820 0 : rSet.InvalidateItem( SID_ALIGNBLOCK );
1821 0 : break;
1822 :
1823 : default:
1824 0 : bJustifyStd = sal_True;
1825 0 : break;
1826 : }
1827 :
1828 0 : if ( nWhich )
1829 : {
1830 0 : aBoolItem.SetWhich( nWhich );
1831 0 : rSet.Put( aBoolItem );
1832 : }
1833 0 : else if ( bJustifyStd )
1834 : {
1835 0 : aBoolItem.SetValue( false );
1836 0 : aBoolItem.SetWhich( SID_ALIGNLEFT ); rSet.Put( aBoolItem );
1837 0 : aBoolItem.SetWhich( SID_ALIGNRIGHT ); rSet.Put( aBoolItem );
1838 0 : aBoolItem.SetWhich( SID_ALIGNCENTERHOR ); rSet.Put( aBoolItem );
1839 0 : aBoolItem.SetWhich( SID_ALIGNBLOCK ); rSet.Put( aBoolItem );
1840 0 : bJustifyStd = false;
1841 : }
1842 :
1843 : //------------------------
1844 : // vertikale Ausrichtung
1845 : //------------------------
1846 :
1847 0 : nWhich = 0;
1848 0 : aBoolItem.SetValue( sal_True );
1849 :
1850 : eState = rAttrSet.GetItemState( ATTR_VER_JUSTIFY, sal_True,
1851 0 : (const SfxPoolItem**)&pVerJustify );
1852 :
1853 0 : switch ( eState )
1854 : {
1855 : case SFX_ITEM_SET:
1856 : {
1857 0 : eVerJustify = SvxCellVerJustify( pVerJustify->GetValue() );
1858 :
1859 0 : switch ( eVerJustify )
1860 : {
1861 : case SVX_VER_JUSTIFY_TOP:
1862 0 : nWhich = SID_ALIGNTOP;
1863 0 : break;
1864 :
1865 : case SVX_VER_JUSTIFY_BOTTOM:
1866 0 : nWhich = SID_ALIGNBOTTOM;
1867 0 : break;
1868 :
1869 : case SVX_VER_JUSTIFY_CENTER:
1870 0 : nWhich = SID_ALIGNCENTERVER;
1871 0 : break;
1872 :
1873 : case SVX_VER_JUSTIFY_STANDARD:
1874 : default:
1875 0 : bJustifyStd = sal_True;
1876 0 : break;
1877 : }
1878 : }
1879 0 : break;
1880 :
1881 : case SFX_ITEM_DONTCARE:
1882 0 : rSet.InvalidateItem( SID_ALIGNTOP );
1883 0 : rSet.InvalidateItem( SID_ALIGNBOTTOM );
1884 0 : rSet.InvalidateItem( SID_ALIGNCENTERVER );
1885 0 : break;
1886 :
1887 : default:
1888 0 : bJustifyStd = sal_True;
1889 0 : break;
1890 : }
1891 :
1892 0 : if ( nWhich )
1893 : {
1894 0 : aBoolItem.SetWhich( nWhich );
1895 0 : rSet.Put( aBoolItem );
1896 : }
1897 0 : else if ( bJustifyStd )
1898 : {
1899 0 : aBoolItem.SetValue( false );
1900 0 : aBoolItem.SetWhich( SID_ALIGNTOP ); rSet.Put( aBoolItem );
1901 0 : aBoolItem.SetWhich( SID_ALIGNBOTTOM ); rSet.Put( aBoolItem );
1902 0 : aBoolItem.SetWhich( SID_ALIGNCENTERVER ); rSet.Put( aBoolItem );
1903 0 : }
1904 0 : }
1905 :
1906 :
1907 : //------------------------------------------------------------------
1908 :
1909 0 : void ScFormatShell::GetBorderState( SfxItemSet& rSet )
1910 : {
1911 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1912 0 : SvxBoxItem aBoxItem( ATTR_BORDER );
1913 0 : SvxBoxInfoItem aInfoItem( ATTR_BORDER_INNER );
1914 :
1915 0 : pTabViewShell->GetSelectionFrame( aBoxItem, aInfoItem );
1916 :
1917 0 : if ( rSet.GetItemState( ATTR_BORDER ) != SFX_ITEM_UNKNOWN )
1918 0 : rSet.Put( aBoxItem );
1919 0 : if ( rSet.GetItemState( ATTR_BORDER_INNER ) != SFX_ITEM_UNKNOWN )
1920 0 : rSet.Put( aInfoItem );
1921 0 : }
1922 :
1923 : //------------------------------------------------------------------
1924 :
1925 0 : void ScFormatShell::GetAlignState( SfxItemSet& rSet )
1926 : {
1927 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1928 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1929 0 : SfxWhichIter aIter(rSet);
1930 0 : sal_uInt16 nWhich = aIter.FirstWhich();
1931 :
1932 0 : SvxCellHorJustify eHAlign = SVX_HOR_JUSTIFY_STANDARD;
1933 0 : bool bHasHAlign = rAttrSet.GetItemState( ATTR_HOR_JUSTIFY ) != SFX_ITEM_DONTCARE;
1934 0 : if( bHasHAlign )
1935 0 : eHAlign = (SvxCellHorJustify)((const SvxHorJustifyItem&) rAttrSet.Get( ATTR_HOR_JUSTIFY )).GetValue();
1936 :
1937 0 : SvxCellVerJustify eVAlign = SVX_VER_JUSTIFY_STANDARD;
1938 0 : bool bHasVAlign = rAttrSet.GetItemState( ATTR_VER_JUSTIFY ) != SFX_ITEM_DONTCARE;
1939 0 : if( bHasVAlign )
1940 0 : eVAlign = (SvxCellVerJustify)((const SvxVerJustifyItem&) rAttrSet.Get( ATTR_VER_JUSTIFY )).GetValue();
1941 :
1942 0 : while ( nWhich )
1943 : {
1944 0 : switch ( nWhich )
1945 : {
1946 : case SID_H_ALIGNCELL:
1947 0 : if ( bHasHAlign )
1948 0 : rSet.Put( SvxHorJustifyItem( eHAlign, nWhich ));
1949 0 : break;
1950 : case SID_V_ALIGNCELL:
1951 0 : if ( bHasVAlign )
1952 0 : rSet.Put( SvxVerJustifyItem( eVAlign, nWhich ));
1953 0 : break;
1954 :
1955 : // pseudo slots for Format menu
1956 : case SID_ALIGN_ANY_HDEFAULT:
1957 : case SID_ALIGN_ANY_LEFT:
1958 : case SID_ALIGN_ANY_HCENTER:
1959 : case SID_ALIGN_ANY_RIGHT:
1960 : case SID_ALIGN_ANY_JUSTIFIED:
1961 0 : rSet.Put( SfxBoolItem( nWhich, bHasHAlign && (eHAlign == lclConvertSlotToHAlign( nWhich )) ) );
1962 0 : break;
1963 : case SID_ALIGN_ANY_VDEFAULT:
1964 : case SID_ALIGN_ANY_TOP:
1965 : case SID_ALIGN_ANY_VCENTER:
1966 : case SID_ALIGN_ANY_BOTTOM:
1967 0 : rSet.Put( SfxBoolItem( nWhich, bHasVAlign && (eVAlign == lclConvertSlotToVAlign( nWhich )) ) );
1968 0 : break;
1969 : }
1970 0 : nWhich = aIter.NextWhich();
1971 0 : }
1972 0 : }
1973 :
1974 0 : void ScFormatShell::GetNumFormatState( SfxItemSet& rSet )
1975 : {
1976 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
1977 0 : ScDocument* pDoc = pViewData->GetDocument();
1978 0 : short nType = GetCurrentNumberFormatType();
1979 :
1980 0 : SfxWhichIter aIter(rSet);
1981 0 : sal_uInt16 nWhich = aIter.FirstWhich();
1982 0 : while ( nWhich )
1983 : {
1984 0 : switch ( nWhich )
1985 : {
1986 : case SID_NUMBER_FORMAT:
1987 : {
1988 0 : String aFormatCode; // bleibt leer, wenn dont-care
1989 :
1990 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
1991 0 : if ( rAttrSet.GetItemState( ATTR_VALUE_FORMAT ) != SFX_ITEM_DONTCARE )
1992 : {
1993 : sal_uLong nNumberFormat = ((const SfxUInt32Item&)rAttrSet.Get(
1994 0 : ATTR_VALUE_FORMAT )).GetValue();
1995 :
1996 0 : SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
1997 0 : const SvNumberformat* pFormatEntry = pFormatter->GetEntry( nNumberFormat );
1998 0 : if ( pFormatEntry )
1999 0 : aFormatCode = pFormatEntry->GetFormatstring();
2000 : }
2001 :
2002 0 : rSet.Put( SfxStringItem( nWhich, aFormatCode ) );
2003 : }
2004 0 : break;
2005 : case SID_NUMBER_SCIENTIFIC:
2006 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_SCIENTIFIC)) );
2007 0 : break;
2008 : case SID_NUMBER_DATE:
2009 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_DATE)) );
2010 0 : break;
2011 : case SID_NUMBER_CURRENCY:
2012 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_CURRENCY)) );
2013 0 : break;
2014 : case SID_NUMBER_PERCENT:
2015 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_PERCENT)) );
2016 0 : break;
2017 : case SID_NUMBER_TIME:
2018 0 : rSet.Put( SfxBoolItem(nWhich, (nType & NUMBERFORMAT_TIME)) );
2019 0 : break;
2020 : }
2021 0 : nWhich = aIter.NextWhich();
2022 0 : }
2023 0 : }
2024 :
2025 :
2026 0 : void ScFormatShell::ExecuteTextDirection( SfxRequest& rReq )
2027 : {
2028 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2029 0 : pTabViewShell->HideListBox(); // Autofilter-DropDown-Listbox
2030 0 : if ( GetViewData()->HasEditView( GetViewData()->GetActivePart() ) )
2031 : {
2032 0 : SC_MOD()->InputEnterHandler();
2033 0 : pTabViewShell->UpdateInputHandler();
2034 : }
2035 :
2036 0 : sal_uInt16 nSlot = rReq.GetSlot();
2037 0 : switch( nSlot )
2038 : {
2039 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2040 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2041 : {
2042 0 : sal_Bool bVert = (nSlot == SID_TEXTDIRECTION_TOP_TO_BOTTOM);
2043 0 : ScPatternAttr aAttr( GetViewData()->GetDocument()->GetPool() );
2044 0 : SfxItemSet& rItemSet = aAttr.GetItemSet();
2045 0 : rItemSet.Put( SfxBoolItem( ATTR_STACKED, bVert ) );
2046 0 : rItemSet.Put( SfxBoolItem( ATTR_VERTICAL_ASIAN, bVert ) );
2047 0 : pTabViewShell->ApplySelectionPattern( aAttr );
2048 0 : pTabViewShell->AdjustBlockHeight();
2049 : }
2050 0 : break;
2051 :
2052 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2053 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2054 : {
2055 : SvxFrameDirection eDirection = ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT ) ?
2056 0 : FRMDIR_HORI_LEFT_TOP : FRMDIR_HORI_RIGHT_TOP;
2057 0 : pTabViewShell->ApplyAttr( SvxFrameDirectionItem( eDirection, ATTR_WRITINGDIR ) );
2058 : }
2059 0 : break;
2060 : }
2061 0 : }
2062 :
2063 0 : void ScFormatShell::GetTextDirectionState( SfxItemSet& rSet )
2064 : {
2065 0 : ScTabViewShell* pTabViewShell = GetViewData()->GetViewShell();
2066 0 : const SfxItemSet& rAttrSet = pTabViewShell->GetSelectionPattern()->GetItemSet();
2067 :
2068 : sal_Bool bVertDontCare =
2069 0 : (rAttrSet.GetItemState( ATTR_VERTICAL_ASIAN ) == SFX_ITEM_DONTCARE) ||
2070 0 : (rAttrSet.GetItemState( ATTR_STACKED ) == SFX_ITEM_DONTCARE);
2071 : sal_Bool bLeftRight = !bVertDontCare &&
2072 0 : !((const SfxBoolItem&) rAttrSet.Get( ATTR_STACKED )).GetValue();
2073 : sal_Bool bTopBottom = !bVertDontCare && !bLeftRight &&
2074 0 : ((const SfxBoolItem&) rAttrSet.Get( ATTR_VERTICAL_ASIAN )).GetValue();
2075 :
2076 0 : sal_Bool bBidiDontCare = (rAttrSet.GetItemState( ATTR_WRITINGDIR ) == SFX_ITEM_DONTCARE);
2077 0 : EEHorizontalTextDirection eBidiDir = EE_HTEXTDIR_DEFAULT;
2078 0 : if ( !bBidiDontCare )
2079 : {
2080 : SvxFrameDirection eCellDir = (SvxFrameDirection)((const SvxFrameDirectionItem&)
2081 0 : rAttrSet.Get( ATTR_WRITINGDIR )).GetValue();
2082 0 : if ( eCellDir == FRMDIR_ENVIRONMENT )
2083 : eBidiDir = (EEHorizontalTextDirection)GetViewData()->GetDocument()->
2084 0 : GetEditTextDirection( GetViewData()->GetTabNo() );
2085 0 : else if ( eCellDir == FRMDIR_HORI_RIGHT_TOP )
2086 0 : eBidiDir = EE_HTEXTDIR_R2L;
2087 : else
2088 0 : eBidiDir = EE_HTEXTDIR_L2R;
2089 : }
2090 :
2091 0 : SvtLanguageOptions aLangOpt;
2092 0 : sal_Bool bDisableCTLFont = !aLangOpt.IsCTLFontEnabled();
2093 0 : sal_Bool bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled();
2094 :
2095 0 : SfxWhichIter aIter( rSet );
2096 0 : sal_uInt16 nWhich = aIter.FirstWhich();
2097 0 : while( nWhich )
2098 : {
2099 0 : switch( nWhich )
2100 : {
2101 : case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
2102 : case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
2103 0 : if ( bDisableVerticalText )
2104 0 : rSet.DisableItem( nWhich );
2105 : else
2106 : {
2107 0 : if( bVertDontCare )
2108 0 : rSet.InvalidateItem( nWhich );
2109 0 : else if ( nWhich == SID_TEXTDIRECTION_LEFT_TO_RIGHT )
2110 0 : rSet.Put( SfxBoolItem( nWhich, bLeftRight ) );
2111 : else
2112 0 : rSet.Put( SfxBoolItem( nWhich, bTopBottom ) );
2113 : }
2114 0 : break;
2115 :
2116 : case SID_ATTR_PARA_LEFT_TO_RIGHT:
2117 : case SID_ATTR_PARA_RIGHT_TO_LEFT:
2118 0 : if ( bDisableCTLFont )
2119 0 : rSet.DisableItem( nWhich );
2120 : else
2121 : {
2122 0 : if ( bTopBottom )
2123 0 : rSet.DisableItem( nWhich );
2124 0 : else if ( bBidiDontCare )
2125 0 : rSet.InvalidateItem( nWhich );
2126 0 : else if ( nWhich == SID_ATTR_PARA_LEFT_TO_RIGHT )
2127 0 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_L2R ) );
2128 : else
2129 0 : rSet.Put( SfxBoolItem( nWhich, eBidiDir == EE_HTEXTDIR_R2L ) );
2130 : }
2131 : }
2132 0 : nWhich = aIter.NextWhich();
2133 0 : }
2134 0 : }
2135 :
2136 0 : void ScFormatShell::ExecFormatPaintbrush( SfxRequest& rReq )
2137 : {
2138 0 : ScViewFunc* pView = pViewData->GetView();
2139 0 : if ( pView->HasPaintBrush() )
2140 : {
2141 : // cancel paintbrush mode
2142 0 : pView->ResetBrushDocument();
2143 : }
2144 : else
2145 : {
2146 0 : sal_Bool bLock = false;
2147 0 : const SfxItemSet *pArgs = rReq.GetArgs();
2148 0 : if( pArgs && pArgs->Count() >= 1 )
2149 0 : bLock = static_cast<const SfxBoolItem&>(pArgs->Get(SID_FORMATPAINTBRUSH)).GetValue();
2150 :
2151 : // in case of multi selection, deselect all and use the cursor position
2152 0 : ScRange aDummy;
2153 0 : if ( pViewData->GetSimpleArea(aDummy) != SC_MARK_SIMPLE )
2154 0 : pView->Unmark();
2155 :
2156 0 : ScDocument* pBrushDoc = new ScDocument( SCDOCMODE_CLIP );
2157 0 : pView->CopyToClip( pBrushDoc, false, true );
2158 0 : pView->SetBrushDocument( pBrushDoc, bLock );
2159 : }
2160 0 : }
2161 :
2162 0 : void ScFormatShell::StateFormatPaintbrush( SfxItemSet& rSet )
2163 : {
2164 0 : if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
2165 0 : rSet.DisableItem( SID_FORMATPAINTBRUSH );
2166 : else
2167 0 : rSet.Put( SfxBoolItem( SID_FORMATPAINTBRUSH, pViewData->GetView()->HasPaintBrush() ) );
2168 0 : }
2169 :
2170 0 : short ScFormatShell::GetCurrentNumberFormatType()
2171 : {
2172 0 : short nType = NUMBERFORMAT_ALL;
2173 0 : ScDocument* pDoc = GetViewData()->GetDocument();
2174 0 : ScMarkData aMark(GetViewData()->GetMarkData());
2175 0 : const SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2176 0 : if (!pFormatter)
2177 0 : return nType;
2178 :
2179 : // TODO: Find out how to get a selected table range in case multiple tables
2180 : // are selected. Currently we only check for the current active table.
2181 :
2182 0 : if ( aMark.IsMarked() || aMark.IsMultiMarked() )
2183 : {
2184 0 : aMark.MarkToMulti();
2185 0 : ScRange aRange;
2186 0 : aMark.GetMultiMarkArea(aRange);
2187 :
2188 0 : const ScMarkArray* pArray = aMark.GetArray();
2189 0 : if (!pArray)
2190 0 : return nType;
2191 :
2192 0 : short nComboType = NUMBERFORMAT_ALL;
2193 0 : bool bFirstItem = true;
2194 0 : for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
2195 : {
2196 0 : const ScMarkArray& rColArray = pArray[nCol];
2197 0 : if (!rColArray.HasMarks())
2198 0 : continue;
2199 :
2200 : SCROW nRow1, nRow2;
2201 0 : ScMarkArrayIter aMarkIter(&rColArray);
2202 0 : while (aMarkIter.Next(nRow1, nRow2))
2203 : {
2204 0 : ScRange aColRange(nCol, nRow1, aRange.aStart.Tab());
2205 0 : aColRange.aEnd.SetRow(nRow2);
2206 0 : sal_uInt32 nNumFmt = pDoc->GetNumberFormat(aColRange);
2207 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nNumFmt);
2208 0 : if (!pEntry)
2209 0 : return 0;
2210 :
2211 0 : short nThisType = pEntry->GetType();
2212 0 : if (bFirstItem)
2213 : {
2214 0 : bFirstItem = false;
2215 0 : nComboType = nThisType;
2216 : }
2217 0 : else if (nComboType != nThisType)
2218 : // mixed number format type.
2219 0 : return NUMBERFORMAT_ALL;
2220 : }
2221 0 : }
2222 0 : nType = nComboType;
2223 : }
2224 : else
2225 : {
2226 : sal_uInt32 nNumFmt;
2227 0 : pDoc->GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
2228 0 : pViewData->GetTabNo(), nNumFmt );
2229 0 : const SvNumberformat* pEntry = pFormatter->GetEntry( nNumFmt );
2230 0 : nType = pEntry ? pEntry->GetType() : 0;
2231 : }
2232 0 : return nType;
2233 15 : }
2234 :
2235 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
