| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| |
| // INCLUDE --------------------------------------------------------------- |
| |
| #include "scitems.hxx" |
| #include <editeng/eeitem.hxx> |
| |
| #include <sfx2/app.hxx> |
| //CHINA001 #include <svx/zoom.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/passwd.hxx> |
| #include <sfx2/request.hxx> |
| #include <svl/ptitem.hxx> |
| #include <svl/stritem.hxx> |
| #include <tools/urlobj.hxx> |
| #include <sfx2/objface.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <vcl/vclenum.hxx> |
| |
| #include "globstr.hrc" |
| #include "scmod.hxx" |
| #include "appoptio.hxx" |
| #include "tabvwsh.hxx" |
| #include "document.hxx" |
| #include "sc.hrc" |
| #include "inputwin.hxx" |
| #include "scresid.hxx" |
| #include "printfun.hxx" |
| #include "docsh.hxx" |
| #include "rangelst.hxx" |
| #include "prevwsh.hxx" |
| #include "rangeutl.hxx" |
| #include "reffact.hxx" |
| #include "uiitems.hxx" |
| #include "cell.hxx" |
| #include "inputhdl.hxx" |
| //CHINA001 #include "scendlg.hxx" |
| //CHINA001 #include "mtrindlg.hxx" |
| #include "autoform.hxx" |
| #include "autofmt.hxx" |
| #include "dwfunctr.hxx" |
| #include "shtabdlg.hxx" |
| #include "tabprotection.hxx" |
| #include "protectiondlg.hxx" |
| |
| #include <svl/ilstitem.hxx> |
| #define _SVSTDARR_ULONGS |
| #include <svl/svstdarr.hxx> |
| |
| #include <svx/zoomslideritem.hxx> |
| #include <svx/svxdlg.hxx> //CHINA001 |
| #include <svx/dialogs.hrc> //CHINA001 |
| #include "scabstdlg.hxx" //CHINA001 |
| |
| #include <memory> |
| |
| using ::std::auto_ptr; |
| |
| #define IS_EDITMODE() GetViewData()->HasEditView( GetViewData()->GetActivePart() ) |
| #define IS_AVAILABLE(WhichId,ppItem) \ |
| (pReqArgs->GetItemState((WhichId), sal_True, ppItem ) == SFX_ITEM_SET) |
| #define GET_STRING(nid) ((const SfxStringItem&)pReqArgs->Get(nid)).GetValue() |
| #define GET_UINT16(nid) ((const SfxUInt16Item&)pReqArgs->Get(nid)).GetValue() |
| #define GET_BOOL(nid) ((const SfxBoolItem&)pReqArgs->Get(nid)).GetValue() |
| #define RECALC_PAGE(pDocSh) ScPrintFunc( pDocSh, GetPrinter(), nCurTab ).UpdatePages() |
| |
| //------------------------------------------------------------------ |
| |
| /** Try to parse the given range using Calc-style syntax first, then |
| Excel-style if that fails. */ |
| sal_uInt16 lcl_ParseRange(ScRange& rScRange, const String& aAddress, ScDocument* pDoc, sal_uInt16 /* nSlot */) |
| { |
| sal_uInt16 nResult = rScRange.Parse(aAddress, pDoc); |
| if ( (nResult & SCA_VALID) ) |
| return nResult; |
| |
| return rScRange.Parse(aAddress, pDoc, ScAddress::Details(formula::FormulaGrammar::CONV_XL_A1, 0, 0)); |
| } |
| |
| /** Try to parse the given address using Calc-style syntax first, then |
| Excel-style if that fails. */ |
| sal_uInt16 lcl_ParseAddress(ScAddress& rScAddress, const String& aAddress, ScDocument* pDoc, sal_uInt16 /* nSlot */) |
| { |
| sal_uInt16 nResult = rScAddress.Parse(aAddress, pDoc); |
| if ( (nResult & SCA_VALID) ) |
| return nResult; |
| |
| return rScAddress.Parse(aAddress, pDoc, ScAddress::Details(formula::FormulaGrammar::CONV_XL_A1, 0, 0)); |
| } |
| |
| void ScTabViewShell::Execute( SfxRequest& rReq ) |
| { |
| SfxViewFrame* pThisFrame = GetViewFrame(); |
| SfxBindings& rBindings = pThisFrame->GetBindings(); |
| ScModule* pScMod = SC_MOD(); |
| const SfxItemSet* pReqArgs = rReq.GetArgs(); |
| sal_uInt16 nSlot = rReq.GetSlot(); |
| |
| if (nSlot != SID_CURRENTCELL) // der kommt beim MouseButtonUp |
| HideListBox(); // Autofilter-DropDown-Listbox |
| |
| switch ( nSlot ) |
| { |
| case FID_INSERT_FILE: |
| { |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && |
| pReqArgs->GetItemState(FID_INSERT_FILE,sal_True,&pItem) == SFX_ITEM_SET ) |
| { |
| String aFileName = ((const SfxStringItem*)pItem)->GetValue(); |
| |
| // Einfuege-Position |
| |
| Point aInsertPos; |
| if ( pReqArgs->GetItemState(FN_PARAM_1,sal_True,&pItem) == SFX_ITEM_SET ) |
| aInsertPos = ((const SfxPointItem*)pItem)->GetValue(); |
| else |
| aInsertPos = GetInsertPos(); |
| |
| // als Link? |
| |
| sal_Bool bAsLink = sal_False; |
| if ( pReqArgs->GetItemState(FN_PARAM_2,sal_True,&pItem) == SFX_ITEM_SET ) |
| bAsLink = ((const SfxBoolItem*)pItem)->GetValue(); |
| |
| // ausfuehren |
| |
| PasteFile( aInsertPos, aFileName, bAsLink ); |
| } |
| } |
| break; |
| |
| case SID_OPENDLG_EDIT_PRINTAREA: |
| { |
| sal_uInt16 nId = ScPrintAreasDlgWrapper::GetChildWindowId(); |
| SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId ); |
| |
| pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True ); |
| } |
| break; |
| |
| case SID_CHANGE_PRINTAREA: |
| { |
| if ( pReqArgs ) // OK aus Dialog |
| { |
| String aPrintStr; |
| String aRowStr; |
| String aColStr; |
| sal_Bool bEntire = sal_False; |
| const SfxPoolItem* pItem; |
| if ( pReqArgs->GetItemState( SID_CHANGE_PRINTAREA, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aPrintStr = static_cast<const SfxStringItem*>(pItem)->GetValue(); |
| if ( pReqArgs->GetItemState( FN_PARAM_2, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aRowStr = static_cast<const SfxStringItem*>(pItem)->GetValue(); |
| if ( pReqArgs->GetItemState( FN_PARAM_3, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aColStr = static_cast<const SfxStringItem*>(pItem)->GetValue(); |
| if ( pReqArgs->GetItemState( FN_PARAM_4, sal_True, &pItem ) == SFX_ITEM_SET ) |
| bEntire = static_cast<const SfxBoolItem*>(pItem)->GetValue(); |
| |
| SetPrintRanges( bEntire, &aPrintStr, &aColStr, &aRowStr, sal_False ); |
| |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| case SID_ADD_PRINTAREA: |
| case SID_DEFINE_PRINTAREA: // Menue oder Basic |
| { |
| sal_Bool bAdd = ( nSlot == SID_ADD_PRINTAREA ); |
| if ( pReqArgs ) |
| { |
| String aPrintStr; |
| const SfxPoolItem* pItem; |
| if ( pReqArgs->GetItemState( SID_DEFINE_PRINTAREA, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aPrintStr = static_cast<const SfxStringItem*>(pItem)->GetValue(); |
| SetPrintRanges( sal_False, &aPrintStr, NULL, NULL, bAdd ); |
| } |
| else |
| { |
| SetPrintRanges( sal_False, NULL, NULL, NULL, bAdd ); // aus Selektion |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| case SID_DELETE_PRINTAREA: |
| { |
| String aEmpty; |
| SetPrintRanges( sal_False, &aEmpty, NULL, NULL, sal_False ); // Druckbereich loeschen |
| rReq.Done(); |
| } |
| break; |
| |
| case FID_DEL_MANUALBREAKS: |
| RemoveManualBreaks(); |
| rReq.Done(); |
| break; |
| |
| case FID_ADJUST_PRINTZOOM: |
| AdjustPrintZoom(); |
| rReq.Done(); |
| break; |
| |
| case FID_RESET_PRINTZOOM: |
| SetPrintZoom( 100, 0 ); // 100%, nicht auf Seiten |
| rReq.Done(); |
| break; |
| |
| case SID_FORMATPAGE: |
| case SID_STATUS_PAGESTYLE: |
| case SID_HFEDIT: |
| GetViewData()->GetDocShell()-> |
| ExecutePageStyle( *this, rReq, GetViewData()->GetTabNo() ); |
| break; |
| |
| case SID_JUMPTOMARK: |
| case SID_CURRENTCELL: |
| if ( pReqArgs ) |
| { |
| String aAddress; |
| const SfxPoolItem* pItem; |
| if ( pReqArgs->GetItemState( nSlot, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aAddress = ((const SfxStringItem*)pItem)->GetValue(); |
| else if ( nSlot == SID_JUMPTOMARK && pReqArgs->GetItemState( |
| SID_JUMPTOMARK, sal_True, &pItem ) == SFX_ITEM_SET ) |
| aAddress = ((const SfxStringItem*)pItem)->GetValue(); |
| |
| // #i14927# SID_CURRENTCELL with a single cell must unmark if FN_PARAM_1 |
| // isn't set (for recorded macros, because IsAPI is no longer available). |
| // ScGridWindow::MouseButtonUp no longer executes the slot for a single |
| // cell if there is a multi selection. |
| sal_Bool bUnmark = ( nSlot == SID_CURRENTCELL ); |
| if ( pReqArgs->GetItemState( FN_PARAM_1, sal_True, &pItem ) == SFX_ITEM_SET ) |
| bUnmark = ((const SfxBoolItem*)pItem)->GetValue(); |
| |
| if ( nSlot == SID_JUMPTOMARK ) |
| { |
| // #106586# URL has to be decoded for escaped characters (%20) |
| aAddress = INetURLObject::decode( aAddress, INET_HEX_ESCAPE, |
| INetURLObject::DECODE_WITH_CHARSET, |
| RTL_TEXTENCODING_UTF8 ); |
| } |
| |
| sal_Bool bFound = sal_False; |
| ScViewData* pViewData = GetViewData(); |
| ScDocument* pDoc = pViewData->GetDocument(); |
| ScMarkData& rMark = pViewData->GetMarkData(); |
| ScRange aScRange; |
| ScAddress aScAddress; |
| sal_uInt16 nResult = lcl_ParseRange(aScRange, aAddress, pDoc, nSlot); |
| SCTAB nTab = pViewData->GetTabNo(); |
| sal_Bool bMark = sal_True; |
| |
| // Is this a range ? |
| if( nResult & SCA_VALID ) |
| { |
| if ( nResult & SCA_TAB_3D ) |
| { |
| if( aScRange.aStart.Tab() != nTab ) |
| SetTabNo( nTab = aScRange.aStart.Tab() ); |
| } |
| else |
| { |
| aScRange.aStart.SetTab( nTab ); |
| aScRange.aEnd.SetTab( nTab ); |
| } |
| } |
| // Is this a cell ? |
| else if ( (nResult = lcl_ParseAddress(aScAddress, aAddress, pDoc, nSlot)) & SCA_VALID ) |
| { |
| if ( nResult & SCA_TAB_3D ) |
| { |
| if( aScAddress.Tab() != nTab ) |
| SetTabNo( nTab = aScAddress.Tab() ); |
| } |
| else |
| aScAddress.SetTab( nTab ); |
| |
| aScRange = ScRange( aScAddress, aScAddress ); |
| // Zellen sollen nicht markiert werden |
| bMark = sal_False; |
| } |
| // Ist es benahmster Bereich (erst Namen dann DBBereiche) ? |
| else |
| { |
| ScRangeUtil aRangeUtil; |
| formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention(); |
| if( aRangeUtil.MakeRangeFromName( aAddress, pDoc, nTab, aScRange, RUTL_NAMES, eConv ) || |
| aRangeUtil.MakeRangeFromName( aAddress, pDoc, nTab, aScRange, RUTL_DBASE, eConv ) ) |
| { |
| nResult |= SCA_VALID; |
| if( aScRange.aStart.Tab() != nTab ) |
| SetTabNo( nTab = aScRange.aStart.Tab() ); |
| } |
| } |
| |
| if ( !(nResult & SCA_VALID) && |
| ByteString(aAddress, RTL_TEXTENCODING_ASCII_US).IsNumericAscii() ) |
| { |
| sal_Int32 nNumeric = aAddress.ToInt32(); |
| if ( nNumeric > 0 && nNumeric <= MAXROW+1 ) |
| { |
| // 1-basierte Zeilennummer |
| |
| aScAddress.SetRow( (SCROW)(nNumeric - 1) ); |
| aScAddress.SetCol( pViewData->GetCurX() ); |
| aScAddress.SetTab( nTab ); |
| aScRange = ScRange( aScAddress, aScAddress ); |
| bMark = sal_False; |
| nResult = SCA_VALID; |
| } |
| } |
| |
| if ( !ValidRow(aScRange.aStart.Row()) || !ValidRow(aScRange.aEnd.Row()) ) |
| nResult = 0; |
| |
| // wir haben was gefunden |
| if( nResult & SCA_VALID ) |
| { |
| bFound = sal_True; |
| SCCOL nCol = aScRange.aStart.Col(); |
| SCROW nRow = aScRange.aStart.Row(); |
| sal_Bool bNothing = ( pViewData->GetCurX()==nCol && pViewData->GetCurY()==nRow ); |
| |
| // markieren |
| if( bMark ) |
| { |
| if (rMark.IsMarked()) // ist derselbe Bereich schon markiert? |
| { |
| ScRange aOldMark; |
| rMark.GetMarkArea( aOldMark ); |
| aOldMark.Justify(); |
| ScRange aCurrent = aScRange; |
| aCurrent.Justify(); |
| bNothing = ( aCurrent == aOldMark ); |
| } |
| else |
| bNothing = sal_False; |
| |
| if (!bNothing) |
| MarkRange( aScRange, sal_False ); // Cursor kommt hinterher... |
| } |
| else |
| { |
| // remove old selection, unless bUnmark argument is sal_False (from navigator) |
| if( bUnmark ) |
| { |
| MoveCursorAbs( nCol, nRow, |
| SC_FOLLOW_NONE, sal_False, sal_False ); |
| } |
| } |
| |
| // und Cursor setzen |
| |
| // zusammengefasste Zellen beruecksichtigen: |
| while ( pDoc->IsHorOverlapped( nCol, nRow, nTab ) ) //! ViewData !!! |
| --nCol; |
| while ( pDoc->IsVerOverlapped( nCol, nRow, nTab ) ) |
| --nRow; |
| |
| // Navigator-Aufrufe sind nicht API!!! |
| |
| if( bNothing ) |
| { |
| if (rReq.IsAPI()) |
| rReq.Ignore(); // wenn Makro, dann gar nix |
| else |
| rReq.Done(); // sonst wenigstens aufzeichnen |
| } |
| else |
| { |
| pViewData->ResetOldCursor(); |
| SetCursor( nCol, nRow ); |
| AlignToCursor( nCol, nRow, SC_FOLLOW_JUMP ); |
| rBindings.Invalidate( SID_CURRENTCELL ); |
| rBindings.Update( nSlot ); |
| |
| if (!rReq.IsAPI()) |
| rReq.Done(); |
| } |
| |
| rReq.SetReturnValue( SfxStringItem( SID_CURRENTCELL, aAddress ) ); |
| } |
| |
| if (!bFound) // kein gueltiger Bereich |
| { |
| // wenn es ein Tabellenname ist, umschalten (fuer Navigator/URL's) |
| |
| SCTAB nNameTab; |
| if ( pDoc->GetTable( aAddress, nNameTab ) ) |
| { |
| bFound = sal_True; |
| if ( nNameTab != nTab ) |
| SetTabNo( nNameTab ); |
| } |
| } |
| |
| if ( !bFound && nSlot == SID_JUMPTOMARK ) |
| { |
| // Grafik-Objekte probieren (nur bei URL's) |
| |
| bFound = SelectObject( aAddress ); |
| } |
| |
| if (!bFound && !rReq.IsAPI()) |
| ErrorMessage( STR_ERR_INVALID_AREA ); |
| } |
| break; |
| |
| case SID_CURRENTOBJECT: |
| if ( pReqArgs ) |
| { |
| String aName = ((const SfxStringItem&)pReqArgs->Get(nSlot)).GetValue(); |
| SelectObject( aName ); |
| } |
| break; |
| |
| case SID_CURRENTTAB: |
| if ( pReqArgs ) |
| { |
| // Tabelle fuer Basic ist 1-basiert |
| SCTAB nTab = ((const SfxUInt16Item&)pReqArgs->Get(nSlot)).GetValue() - 1; |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| if ( nTab < pDoc->GetTableCount() ) |
| { |
| SetTabNo( nTab ); |
| rBindings.Update( nSlot ); |
| |
| if( ! rReq.IsAPI() ) |
| rReq.Done(); |
| } |
| //! sonst Fehler ? |
| } |
| break; |
| |
| case SID_CURRENTDOC: |
| if ( pReqArgs ) |
| { |
| String aStrDocName( ((const SfxStringItem&)pReqArgs-> |
| Get(nSlot)).GetValue() ); |
| |
| SfxViewFrame* pViewFrame = NULL; |
| ScDocShell* pDocSh = (ScDocShell*)SfxObjectShell::GetFirst(); |
| sal_Bool bFound = sal_False; |
| |
| // zu aktivierenden ViewFrame suchen |
| |
| while ( pDocSh && !bFound ) |
| { |
| if ( pDocSh->GetTitle() == aStrDocName ) |
| { |
| pViewFrame = SfxViewFrame::GetFirst( pDocSh ); |
| bFound = ( NULL != pViewFrame ); |
| } |
| |
| pDocSh = (ScDocShell*)SfxObjectShell::GetNext( *pDocSh ); |
| } |
| |
| if ( bFound ) |
| pViewFrame->GetFrame().Appear(); |
| |
| rReq.Ignore();//XXX wird von SFX erledigt |
| } |
| |
| case SID_ATTR_SIZE://XXX ??? |
| break; |
| |
| |
| case SID_PRINTPREVIEW: |
| { |
| if ( !pThisFrame->GetFrame().IsInPlace() ) // nicht bei OLE |
| { |
| // print preview is now always in the same frame as the tab view |
| // -> always switch this frame back to normal view |
| // (ScPreviewShell ctor reads view data) |
| |
| // #102785#; finish input |
| pScMod->InputEnterHandler(); |
| |
| pThisFrame->GetDispatcher()->Execute( SID_VIEWSHELL1, SFX_CALLMODE_ASYNCHRON ); |
| } |
| // else Fehler (z.B. Ole) |
| } |
| break; |
| |
| case SID_DETECTIVE_DEL_ALL: |
| DetectiveDelAll(); |
| rReq.Done(); |
| break; |
| |
| // SID_TABLE_ACTIVATE und SID_MARKAREA werden von Basic aus an der versteckten |
| // View aufgerufen, um auf der sichtbaren View zu markieren/umzuschalten: |
| |
| case SID_TABLE_ACTIVATE: |
| DBG_ERROR("old slot SID_TABLE_ACTIVATE"); |
| break; |
| |
| case SID_REPAINT: |
| PaintGrid(); |
| PaintTop(); |
| PaintLeft(); |
| PaintExtras(); |
| rReq.Done(); |
| break; |
| |
| case FID_NORMALVIEWMODE: |
| case FID_PAGEBREAKMODE: |
| { |
| sal_Bool bWantPageBreak = nSlot == FID_PAGEBREAKMODE; |
| |
| // check whether there is an explicit argument, use it |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET ) |
| { |
| sal_Bool bItemValue = ((const SfxBoolItem*)pItem)->GetValue(); |
| bWantPageBreak = (nSlot == FID_PAGEBREAKMODE) == bItemValue; |
| } |
| |
| if( GetViewData()->IsPagebreakMode() != bWantPageBreak ) |
| { |
| SetPagebreakMode( bWantPageBreak ); |
| UpdatePageBreakData(); |
| SetCurSubShell( GetCurObjectSelectionType(), sal_True ); |
| PaintGrid(); |
| PaintTop(); |
| PaintLeft(); |
| rBindings.Invalidate( nSlot ); |
| rReq.AppendItem( SfxBoolItem( nSlot, sal_True ) ); |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| case FID_FUNCTION_BOX: |
| { |
| sal_uInt16 nChildId = ScFunctionChildWindow::GetChildWindowId(); |
| if ( rReq.GetArgs() ) |
| pThisFrame->SetChildWindow( nChildId, ((const SfxBoolItem&) (rReq.GetArgs()->Get(FID_FUNCTION_BOX))).GetValue()); |
| else |
| { |
| pThisFrame->ToggleChildWindow( nChildId ); |
| rReq.AppendItem( SfxBoolItem( FID_FUNCTION_BOX , pThisFrame->HasChildWindow( nChildId ) ) ); |
| } |
| |
| GetViewFrame()->GetBindings().Invalidate(FID_FUNCTION_BOX); |
| rReq.Done (); |
| } |
| break; |
| |
| |
| case FID_TOGGLESYNTAX: |
| { |
| sal_Bool bSet = !GetViewData()->IsSyntaxMode(); |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET ) |
| bSet = ((const SfxBoolItem*)pItem)->GetValue(); |
| GetViewData()->SetSyntaxMode( bSet ); |
| PaintGrid(); |
| rBindings.Invalidate( FID_TOGGLESYNTAX ); |
| rReq.AppendItem( SfxBoolItem( nSlot, bSet ) ); |
| rReq.Done(); |
| } |
| break; |
| case FID_TOGGLEHEADERS: |
| { |
| sal_Bool bSet = !GetViewData()->IsHeaderMode(); |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET ) |
| bSet = ((const SfxBoolItem*)pItem)->GetValue(); |
| GetViewData()->SetHeaderMode( bSet ); |
| RepeatResize(); |
| rBindings.Invalidate( FID_TOGGLEHEADERS ); |
| rReq.AppendItem( SfxBoolItem( nSlot, bSet ) ); |
| rReq.Done(); |
| } |
| break; |
| |
| case FID_TOGGLEFORMULA: |
| { |
| ScViewData* pViewData = GetViewData(); |
| const ScViewOptions& rOpts = pViewData->GetOptions(); |
| sal_Bool bFormulaMode = !rOpts.GetOption( VOPT_FORMULAS ); |
| const SfxPoolItem *pItem; |
| if( pReqArgs && pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET ) |
| bFormulaMode = ((const SfxBoolItem *)pItem)->GetValue(); |
| |
| ScViewOptions rSetOpts = ScViewOptions( rOpts ); |
| rSetOpts.SetOption( VOPT_FORMULAS, bFormulaMode ); |
| pViewData->SetOptions( rSetOpts ); |
| |
| pViewData->GetDocShell()->PostPaintGridAll(); |
| |
| rBindings.Invalidate( FID_TOGGLEFORMULA ); |
| rReq.AppendItem( SfxBoolItem( nSlot, bFormulaMode ) ); |
| rReq.Done(); |
| } |
| break; |
| |
| case FID_TOGGLEINPUTLINE: |
| { |
| sal_uInt16 nId = ScInputWindowWrapper::GetChildWindowId(); |
| SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId ); |
| sal_Bool bSet = ( pWnd == NULL ); |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && pReqArgs->GetItemState(nSlot, sal_True, &pItem) == SFX_ITEM_SET ) |
| bSet = ((const SfxBoolItem*)pItem)->GetValue(); |
| |
| pThisFrame->SetChildWindow( nId, bSet ); |
| rBindings.Invalidate( FID_TOGGLEINPUTLINE ); |
| rReq.AppendItem( SfxBoolItem( nSlot, bSet ) ); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_ATTR_ZOOM: // Statuszeile |
| case FID_SCALE: |
| { |
| sal_Bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom(); |
| SvxZoomType eOldZoomType = GetZoomType(); |
| SvxZoomType eNewZoomType = eOldZoomType; |
| const Fraction& rOldY = GetViewData()->GetZoomY(); // Y wird angezeigt |
| sal_uInt16 nOldZoom = (sal_uInt16)(( rOldY.GetNumerator() * 100 ) |
| / rOldY.GetDenominator()); |
| sal_uInt16 nZoom = nOldZoom; |
| sal_Bool bCancel = sal_False; |
| |
| if ( pReqArgs ) |
| { |
| const SvxZoomItem& rZoomItem = (const SvxZoomItem&) |
| pReqArgs->Get(SID_ATTR_ZOOM); |
| |
| eNewZoomType = rZoomItem.GetType(); |
| nZoom = rZoomItem.GetValue(); |
| } |
| else |
| { |
| SfxItemSet aSet ( GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM ); |
| SvxZoomItem aZoomItem( eOldZoomType, nOldZoom, SID_ATTR_ZOOM ); |
| //CHINA001 SvxZoomDialog* pDlg = NULL; |
| AbstractSvxZoomDialog* pDlg = NULL; |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| sal_uInt16 nBtnFlags = SVX_ZOOM_ENABLE_50 |
| | SVX_ZOOM_ENABLE_75 |
| | SVX_ZOOM_ENABLE_100 |
| | SVX_ZOOM_ENABLE_150 |
| | SVX_ZOOM_ENABLE_200 |
| | SVX_ZOOM_ENABLE_WHOLEPAGE |
| | SVX_ZOOM_ENABLE_PAGEWIDTH; |
| |
| if ( rMark.IsMarked() || rMark.IsMultiMarked() ) |
| nBtnFlags = nBtnFlags | SVX_ZOOM_ENABLE_OPTIMAL; |
| |
| aZoomItem.SetValueSet( nBtnFlags ); |
| aSet.Put( aZoomItem ); |
| //CHINA001 pDlg = new SvxZoomDialog( GetDialogParent(), aSet ); |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); |
| if(pFact) |
| { |
| pDlg = pFact->CreateSvxZoomDialog(GetDialogParent(), aSet ); |
| DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001 |
| } |
| pDlg->SetLimits( MINZOOM, MAXZOOM ); |
| |
| bCancel = ( RET_CANCEL == pDlg->Execute() ); |
| |
| if ( !bCancel ) |
| { |
| const SvxZoomItem& rZoomItem = (const SvxZoomItem&) |
| pDlg->GetOutputItemSet()-> |
| Get( SID_ATTR_ZOOM ); |
| |
| eNewZoomType = rZoomItem.GetType(); |
| nZoom = rZoomItem.GetValue(); |
| } |
| |
| delete pDlg; |
| } |
| |
| if ( !bCancel ) |
| { |
| if ( eNewZoomType == SVX_ZOOM_PERCENT ) |
| { |
| if ( nZoom < MINZOOM ) nZoom = MINZOOM; |
| if ( nZoom > MAXZOOM ) nZoom = MAXZOOM; |
| } |
| else |
| { |
| nZoom = CalcZoom( eNewZoomType, nOldZoom ); |
| bCancel = nZoom == 0; |
| } |
| |
| switch ( eNewZoomType ) |
| { |
| case SVX_ZOOM_WHOLEPAGE: |
| case SVX_ZOOM_PAGEWIDTH: |
| SetZoomType( eNewZoomType, bSyncZoom ); |
| break; |
| |
| default: |
| SetZoomType( SVX_ZOOM_PERCENT, bSyncZoom ); |
| } |
| } |
| |
| if ( nZoom != nOldZoom && !bCancel ) |
| { |
| if (!GetViewData()->IsPagebreakMode()) |
| { |
| ScAppOptions aNewOpt = pScMod->GetAppOptions(); |
| aNewOpt.SetZoom( nZoom ); |
| aNewOpt.SetZoomType( GetZoomType() ); |
| pScMod->SetAppOptions( aNewOpt ); |
| } |
| Fraction aFract( nZoom, 100 ); |
| SetZoom( aFract, aFract, bSyncZoom ); |
| PaintGrid(); |
| PaintTop(); |
| PaintLeft(); |
| rBindings.Invalidate( SID_ATTR_ZOOM ); |
| rReq.AppendItem( SvxZoomItem( GetZoomType(), nZoom, nSlot ) ); |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| case SID_ATTR_ZOOMSLIDER: |
| { |
| const SfxPoolItem* pItem = NULL; |
| sal_Bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom(); |
| if ( pReqArgs && pReqArgs->GetItemState(SID_ATTR_ZOOMSLIDER, sal_True, &pItem) == SFX_ITEM_SET ) |
| { |
| const sal_uInt16 nCurrentZoom = ((const SvxZoomSliderItem *)pItem)->GetValue(); |
| if( nCurrentZoom ) |
| { |
| SetZoomType( SVX_ZOOM_PERCENT, bSyncZoom ); |
| if (!GetViewData()->IsPagebreakMode()) |
| { |
| ScAppOptions aNewOpt = pScMod->GetAppOptions(); |
| aNewOpt.SetZoom( nCurrentZoom ); |
| aNewOpt.SetZoomType( GetZoomType() ); |
| pScMod->SetAppOptions( aNewOpt ); |
| } |
| Fraction aFract( nCurrentZoom,100 ); |
| SetZoom( aFract, aFract, bSyncZoom ); |
| PaintGrid(); |
| PaintTop(); |
| PaintLeft(); |
| rBindings.Invalidate( SID_ATTR_ZOOMSLIDER ); |
| rReq.Done(); |
| } |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------- |
| |
| case FID_TAB_SELECTALL: |
| SelectAllTables(); |
| rReq.Done(); |
| break; |
| |
| case FID_TAB_DESELECTALL: |
| DeselectAllTables(); |
| rReq.Done(); |
| break; |
| |
| case SID_SELECT_TABLES: |
| { |
| ScViewData& rViewData = *GetViewData(); |
| ScDocument& rDoc = *rViewData.GetDocument(); |
| ScMarkData& rMark = rViewData.GetMarkData(); |
| SCTAB nTabCount = rDoc.GetTableCount(); |
| SCTAB nTab; |
| |
| SvULongs aIndexList( 4, 4 ); |
| SFX_REQUEST_ARG( rReq, pItem, SfxIntegerListItem, SID_SELECT_TABLES, sal_False ); |
| if ( pItem ) |
| pItem->GetList( aIndexList ); |
| else |
| { |
| //CHINA001 ScShowTabDlg* pDlg = new ScShowTabDlg( GetDialogParent() ); |
| ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001 |
| |
| AbstractScShowTabDlg* pDlg = pFact->CreateScShowTabDlg( GetDialogParent(), RID_SCDLG_SHOW_TAB); |
| DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001 |
| pDlg->SetDescription( |
| String( ScResId( STR_DLG_SELECTTABLES_TITLE ) ), |
| String( ScResId( STR_DLG_SELECTTABLES_LBNAME ) ), |
| GetStaticInterface()->GetSlot(SID_SELECT_TABLES)->GetCommand(), HID_SELECTTABLES ); |
| |
| // fill all table names with selection state |
| String aTabName; |
| for( nTab = 0; nTab < nTabCount; ++nTab ) |
| { |
| rDoc.GetName( nTab, aTabName ); |
| pDlg->Insert( aTabName, rMark.GetTableSelect( nTab ) ); |
| } |
| |
| if( pDlg->Execute() == RET_OK ) |
| { |
| sal_uInt16 nSelCount = pDlg->GetSelectEntryCount(); |
| sal_uInt16 nSelIx; |
| for( nSelIx = 0; nSelIx < nSelCount; ++nSelIx ) |
| aIndexList.Insert( pDlg->GetSelectEntryPos( nSelIx ), nSelIx ); |
| delete pDlg; |
| rReq.AppendItem( SfxIntegerListItem( SID_SELECT_TABLES, aIndexList ) ); |
| } |
| else |
| rReq.Ignore(); |
| } |
| |
| if ( aIndexList.Count() ) |
| { |
| sal_uInt16 nSelCount = aIndexList.Count(); |
| sal_uInt16 nSelIx; |
| SCTAB nFirstVisTab = 0; |
| |
| // special case: only hidden tables selected -> do nothing |
| sal_Bool bVisSelected = sal_False; |
| for( nSelIx = 0; !bVisSelected && (nSelIx < nSelCount); ++nSelIx ) |
| bVisSelected = rDoc.IsVisible( nFirstVisTab = static_cast<SCTAB>(aIndexList[nSelIx]) ); |
| if( !bVisSelected ) |
| nSelCount = 0; |
| |
| // select the tables |
| if( nSelCount ) |
| { |
| for( nTab = 0; nTab < nTabCount; ++nTab ) |
| rMark.SelectTable( nTab, sal_False ); |
| |
| for( nSelIx = 0; nSelIx < nSelCount; ++nSelIx ) |
| rMark.SelectTable( static_cast<SCTAB>(aIndexList[nSelIx]), sal_True ); |
| |
| // activate another table, if current is deselected |
| if( !rMark.GetTableSelect( rViewData.GetTabNo() ) ) |
| { |
| rMark.SelectTable( nFirstVisTab, sal_True ); |
| SetTabNo( nFirstVisTab ); |
| } |
| |
| rViewData.GetDocShell()->PostPaintExtras(); |
| SfxBindings& rBind = rViewData.GetBindings(); |
| rBind.Invalidate( FID_FILL_TAB ); |
| rBind.Invalidate( FID_TAB_DESELECTALL ); |
| } |
| |
| rReq.Done(); |
| } |
| } |
| break; |
| |
| |
| case SID_OUTLINE_DELETEALL: |
| RemoveAllOutlines(); |
| rReq.Done(); |
| break; |
| |
| case SID_AUTO_OUTLINE: |
| AutoOutline(); |
| rReq.Done(); |
| break; |
| |
| |
| case SID_WINDOW_SPLIT: |
| { |
| ScSplitMode eHSplit = GetViewData()->GetHSplitMode(); |
| ScSplitMode eVSplit = GetViewData()->GetVSplitMode(); |
| if ( eHSplit == SC_SPLIT_NORMAL || eVSplit == SC_SPLIT_NORMAL ) // aufheben |
| RemoveSplit(); |
| else if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX ) // normal |
| FreezeSplitters( sal_False ); |
| else // erzeugen |
| SplitAtCursor(); |
| rReq.Done(); |
| |
| InvalidateSplit(); |
| } |
| break; |
| |
| case SID_WINDOW_FIX: |
| { |
| ScSplitMode eHSplit = GetViewData()->GetHSplitMode(); |
| ScSplitMode eVSplit = GetViewData()->GetVSplitMode(); |
| if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX ) // aufheben |
| RemoveSplit(); |
| else |
| FreezeSplitters( sal_True ); // erzeugen oder fixieren |
| rReq.Done(); |
| |
| InvalidateSplit(); |
| } |
| break; |
| |
| // ---------------------------------------------------------------- |
| |
| case FID_CHG_SHOW: |
| { |
| sal_uInt16 nId = ScHighlightChgDlgWrapper::GetChildWindowId(); |
| SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId ); |
| |
| pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True ); |
| } |
| break; |
| |
| case FID_CHG_ACCEPT: |
| { |
| pThisFrame->ToggleChildWindow(ScAcceptChgDlgWrapper::GetChildWindowId()); |
| GetViewFrame()->GetBindings().Invalidate(FID_CHG_ACCEPT); |
| rReq.Done (); |
| |
| /* |
| sal_uInt16 nId = ScAcceptChgDlgWrapper::GetChildWindowId(); |
| SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId ); |
| |
| pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True ); |
| */ |
| } |
| break; |
| |
| case FID_CHG_COMMENT: |
| { |
| ScViewData* pData = GetViewData(); |
| ScAddress aCursorPos( pData->GetCurX(), pData->GetCurY(), pData->GetTabNo() ); |
| ScDocShell* pDocSh = pData->GetDocShell(); |
| |
| ScChangeAction* pAction = pDocSh->GetChangeAction( aCursorPos ); |
| if ( pAction ) |
| { |
| const SfxPoolItem* pItem; |
| if ( pReqArgs && |
| pReqArgs->GetItemState( nSlot, sal_True, &pItem ) == SFX_ITEM_SET && |
| pItem->ISA( SfxStringItem ) ) |
| { |
| String aComment = ((const SfxStringItem*)pItem)->GetValue(); |
| pDocSh->SetChangeComment( pAction, aComment ); |
| rReq.Done(); |
| } |
| else |
| { |
| pDocSh->ExecuteChangeCommentDialog( pAction, GetDialogParent() ); |
| rReq.Done(); |
| } |
| } |
| } |
| break; |
| |
| case SID_CREATE_SW_DRAWVIEW: |
| // wird von den Forms gerufen, wenn die DrawView mit allem Zubehoer |
| // angelegt werden muss |
| if (!GetScDrawView()) |
| { |
| GetViewData()->GetDocShell()->MakeDrawLayer(); |
| rBindings.InvalidateAll(sal_False); |
| } |
| break; |
| |
| case FID_PROTECT_DOC: |
| { |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| SfxPasswordDialog* pDlg; |
| |
| if( pReqArgs ) |
| { |
| const SfxPoolItem* pItem; |
| if( IS_AVAILABLE( FID_PROTECT_DOC, &pItem ) && |
| ((const SfxBoolItem*)pItem)->GetValue() == pDoc->IsDocProtected() ) |
| { |
| rReq.Ignore(); |
| break; |
| } |
| } |
| |
| ScDocProtection* pProtect = pDoc->GetDocProtection(); |
| if (pProtect && pProtect->isProtected()) |
| { |
| sal_Bool bCancel = sal_False; |
| String aPassword; |
| |
| if (pProtect->isProtectedWithPass()) |
| { |
| String aText( ScResId(SCSTR_PASSWORD) ); |
| |
| pDlg = new SfxPasswordDialog( GetDialogParent(), &aText ); |
| pDlg->SetText( ScResId(SCSTR_UNPROTECTDOC) ); |
| pDlg->SetMinLen( 0 ); |
| pDlg->SetHelpId( GetStaticInterface()->GetSlot(FID_PROTECT_DOC)->GetCommand() ); |
| pDlg->SetEditHelpId( HID_PASSWD_DOC ); |
| |
| if (pDlg->Execute() == RET_OK) |
| aPassword = pDlg->GetPassword(); |
| else |
| bCancel = sal_True; |
| delete pDlg; |
| } |
| if (!bCancel) |
| { |
| Unprotect( TABLEID_DOC, aPassword ); |
| rReq.AppendItem( SfxBoolItem( FID_PROTECT_DOC, sal_False ) ); |
| rReq.Done(); |
| } |
| } |
| else |
| { |
| String aText( ScResId(SCSTR_PASSWORDOPT) ); |
| |
| pDlg = new SfxPasswordDialog( GetDialogParent(), &aText ); |
| pDlg->SetText( ScResId(SCSTR_PROTECTDOC) ); |
| pDlg->SetMinLen( 0 ); |
| pDlg->SetHelpId( GetStaticInterface()->GetSlot(FID_PROTECT_DOC)->GetCommand() ); |
| pDlg->SetEditHelpId( HID_PASSWD_DOC ); |
| pDlg->ShowExtras( SHOWEXTRAS_CONFIRM ); |
| |
| if (pDlg->Execute() == RET_OK) |
| { |
| String aPassword = pDlg->GetPassword(); |
| Protect( TABLEID_DOC, aPassword ); |
| rReq.AppendItem( SfxBoolItem( FID_PROTECT_DOC, sal_True ) ); |
| rReq.Done(); |
| } |
| |
| delete pDlg; |
| } |
| rBindings.Invalidate( FID_PROTECT_DOC ); |
| } |
| break; |
| |
| |
| case FID_PROTECT_TABLE: |
| { |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| SCTAB nTab = GetViewData()->GetTabNo(); |
| bool bOldProtection = pDoc->IsTabProtected(nTab); |
| |
| #if ENABLE_SHEET_PROTECTION |
| |
| if( pReqArgs ) |
| { |
| const SfxPoolItem* pItem; |
| bool bNewProtection = !bOldProtection; |
| if( IS_AVAILABLE( FID_PROTECT_TABLE, &pItem ) ) |
| bNewProtection = ((const SfxBoolItem*)pItem)->GetValue(); |
| if( bNewProtection == bOldProtection ) |
| { |
| rReq.Ignore(); |
| break; |
| } |
| } |
| |
| if (bOldProtection) |
| { |
| // Unprotect a protected sheet. |
| |
| ScTableProtection* pProtect = pDoc->GetTabProtection(nTab); |
| if (pProtect && pProtect->isProtectedWithPass()) |
| { |
| String aText( ScResId(SCSTR_PASSWORDOPT) ); |
| auto_ptr<SfxPasswordDialog> pDlg(new SfxPasswordDialog(GetDialogParent(), &aText)); |
| pDlg->SetText( ScResId(SCSTR_UNPROTECTTAB) ); |
| pDlg->SetMinLen( 0 ); |
| pDlg->SetHelpId( GetStaticInterface()->GetSlot(FID_PROTECT_TABLE)->GetCommand() ); |
| pDlg->SetEditHelpId( HID_PASSWD_TABLE ); |
| |
| if (pDlg->Execute() == RET_OK) |
| { |
| String aPassword = pDlg->GetPassword(); |
| Unprotect(nTab, aPassword); |
| } |
| } |
| else |
| // this sheet is not password-protected. |
| Unprotect(nTab, String()); |
| |
| if (!pReqArgs) |
| { |
| rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, false) ); |
| rReq.Done(); |
| } |
| } |
| else |
| { |
| // Protect a current sheet. |
| |
| auto_ptr<ScTableProtectionDlg> pDlg(new ScTableProtectionDlg(GetDialogParent())); |
| |
| ScTableProtection* pProtect = pDoc->GetTabProtection(nTab); |
| if (pProtect) |
| pDlg->SetDialogData(*pProtect); |
| |
| if (pDlg->Execute() == RET_OK) |
| { |
| pScMod->InputEnterHandler(); |
| |
| ScTableProtection aNewProtect; |
| pDlg->WriteData(aNewProtect); |
| ProtectSheet(nTab, aNewProtect); |
| if (!pReqArgs) |
| { |
| rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, true) ); |
| rReq.Done(); |
| } |
| } |
| } |
| #else |
| auto_ptr<SfxPasswordDialog> pDlg; |
| String aPassword; |
| sal_Bool bCancel = sal_False; |
| bool bNewProtection = ! bOldProtection; |
| |
| if( pReqArgs ) |
| { |
| const SfxPoolItem* pItem; |
| if( IS_AVAILABLE( FID_PROTECT_TABLE, &pItem ) ) |
| bNewProtection = ((const SfxBoolItem*)pItem)->GetValue(); |
| if( bNewProtection == bOldProtection ) |
| { |
| rReq.Ignore(); |
| break; |
| } |
| } |
| |
| if ( bOldProtection) |
| { |
| // Unprotect a protected sheet. |
| |
| ScTableProtection* pProtect = pDoc->GetTabProtection(nTab); |
| if (pProtect && pProtect->isProtectedWithPass()) |
| { |
| String aText( ScResId(SCSTR_PASSWORDOPT) ); |
| pDlg.reset(new SfxPasswordDialog(GetDialogParent(), &aText)); |
| pDlg->SetText( ScResId(SCSTR_UNPROTECTTAB) ); |
| pDlg->SetMinLen( 0 ); |
| pDlg->SetHelpId( GetStaticInterface()->GetSlot(FID_PROTECT_TABLE)->GetCommand() ); |
| pDlg->SetEditHelpId( HID_PASSWD_TABLE ); |
| |
| if (pDlg->Execute() == RET_OK) |
| aPassword = pDlg->GetPassword(); |
| else |
| bCancel = sal_True; |
| } |
| |
| if (!pReqArgs) |
| { |
| rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, false) ); |
| rReq.Done(); |
| } |
| } |
| else |
| { |
| String aText( ScResId(SCSTR_PASSWORDOPT) ); |
| |
| pDlg.reset(new SfxPasswordDialog(GetDialogParent(), &aText)); |
| pDlg->SetText( ScResId(SCSTR_PROTECTTAB) ); |
| pDlg->SetMinLen( 0 ); |
| pDlg->SetHelpId( GetStaticInterface()->GetSlot(FID_PROTECT_TABLE)->GetCommand() ); |
| pDlg->SetEditHelpId( HID_PASSWD_TABLE ); |
| pDlg->ShowExtras( SHOWEXTRAS_CONFIRM ); |
| |
| if (pDlg->Execute() == RET_OK) |
| aPassword = pDlg->GetPassword(); |
| else |
| bCancel = sal_True; |
| } |
| |
| if( !bCancel ) |
| { |
| if ( bOldProtection ) |
| Unprotect( nTab, aPassword ); |
| else |
| { |
| pScMod->InputEnterHandler(); |
| |
| Protect( nTab, aPassword ); |
| } |
| |
| if( !pReqArgs ) |
| { |
| rReq.AppendItem( SfxBoolItem( FID_PROTECT_TABLE, bNewProtection ) ); |
| rReq.Done(); |
| } |
| } |
| #endif |
| TabChanged(); |
| UpdateInputHandler(true); // damit sofort wieder eingegeben werden kann |
| SelectionChanged(); |
| } |
| break; |
| |
| case SID_OPT_LOCALE_CHANGED : |
| { // locale changed, SYSTEM number formats changed => repaint cell contents |
| PaintGrid(); |
| rReq.Done(); |
| } |
| break; |
| |
| default: |
| DBG_ERROR("Unbekannter Slot bei ScTabViewShell::Execute"); |
| break; |
| } |
| } |
| |
| |
| |
