| /************************************************************** |
| * |
| * 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 "pvlaydlg.hxx" |
| |
| #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp> |
| #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp> |
| |
| #include <sfx2/dispatch.hxx> |
| #include <vcl/mnemonic.hxx> |
| #include <vcl/msgbox.hxx> |
| |
| #include "dbdocfun.hxx" |
| #include "uiitems.hxx" |
| #include "rangeutl.hxx" |
| #include "document.hxx" |
| #include "viewdata.hxx" |
| #include "tabvwsh.hxx" |
| #include "reffact.hxx" |
| #include "scresid.hxx" |
| #include "globstr.hrc" |
| #include "pivot.hrc" |
| #include "dpobject.hxx" |
| #include "dpsave.hxx" |
| #include "dpshttab.hxx" |
| #include "scmod.hxx" |
| |
| #include "sc.hrc" //CHINA001 |
| #include "scabstdlg.hxx" //CHINA001 |
| |
| // ============================================================================ |
| |
| using namespace ::com::sun::star; |
| using ::rtl::OUString; |
| |
| // ============================================================================ |
| |
| namespace { |
| |
| const sal_uInt16 STD_FORMAT = sal_uInt16( SCA_VALID | SCA_TAB_3D | SCA_COL_ABSOLUTE | SCA_ROW_ABSOLUTE | SCA_TAB_ABSOLUTE ); |
| |
| OUString lclGetNameWithoutMnemonic( const FixedText& rFixedText ) |
| { |
| return MnemonicGenerator::EraseAllMnemonicChars( rFixedText.GetText() ); |
| } |
| |
| } // namespace |
| |
| // ============================================================================ |
| |
| ScPivotLayoutDlg::ScPivotLayoutDlg( SfxBindings* pB, SfxChildWindow* pCW, Window* pParent, const ScDPObject& rDPObject ) : |
| |
| ScAnyRefDlg( pB, pCW, pParent, RID_SCDLG_PIVOT_LAYOUT ), |
| |
| maFlLayout( this, ScResId( FL_LAYOUT ) ), |
| maScrPage( this, ScResId( SCROLL_PAGE ) ), |
| maFtPage( this, ScResId( FT_PAGE ) ), |
| maWndPage( this, ScResId( WND_PAGE ), maScrPage, &maFtPage, lclGetNameWithoutMnemonic( maFtPage ), PIVOTFIELDTYPE_PAGE, HID_SC_DPLAY_PAGE, POINTER_PIVOT_FIELD, 5, 2, 1, 0 ), |
| maScrCol( this, ScResId( SCROLL_COL ) ), |
| maFtCol( this, ScResId( FT_COL ) ), |
| maWndCol( this, ScResId( WND_COL ), maScrCol, &maFtCol, lclGetNameWithoutMnemonic( maFtCol ), PIVOTFIELDTYPE_COL, HID_SC_DPLAY_COLUMN, POINTER_PIVOT_COL, 4, 2, 1, 0 ), |
| maScrRow( this, ScResId( SCROLL_ROW ) ), |
| maFtRow( this, ScResId( FT_ROW ) ), |
| maWndRow( this, ScResId( WND_ROW ), maScrRow, &maFtRow, lclGetNameWithoutMnemonic( maFtRow ), PIVOTFIELDTYPE_ROW, HID_SC_DPLAY_ROW, POINTER_PIVOT_ROW, 1, 8, 1, 0 ), |
| maScrData( this, ScResId( SCROLL_DATA ) ), |
| maFtData( this, ScResId( FT_DATA ) ), |
| maWndData( this, ScResId( WND_DATA ), maScrData, &maFtData, lclGetNameWithoutMnemonic( maFtData ), PIVOTFIELDTYPE_DATA, HID_SC_DPLAY_DATA, POINTER_PIVOT_FIELD, 1, 8, 4, 0 ), |
| maFlSelect( this, ScResId( FL_SELECT ) ), |
| maScrSelect( this, ScResId( WND_HSCROLL ) ), |
| maWndSelect( this, ScResId( WND_SELECT ), maScrSelect, 0, String( ScResId( STR_SELECT ) ), PIVOTFIELDTYPE_SELECT, HID_SC_DPLAY_SELECT, POINTER_PIVOT_FIELD, 2, 10, 1, 2 ), |
| maFtInfo( this, ScResId( FT_INFO ) ), |
| |
| maFlAreas( this, ScResId( FL_OUTPUT ) ), |
| maFtInArea( this, ScResId( FT_INAREA) ), |
| maEdInPos( this, this, ScResId( ED_INAREA) ), |
| maRbInPos( this, ScResId( RB_INAREA ), &maEdInPos, this ), |
| maLbOutPos( this, ScResId( LB_OUTAREA ) ), |
| maFtOutArea( this, ScResId( FT_OUTAREA ) ), |
| maEdOutPos( this, this, ScResId( ED_OUTAREA ) ), |
| maRbOutPos( this, ScResId( RB_OUTAREA ), &maEdOutPos, this ), |
| maBtnIgnEmptyRows( this, ScResId( BTN_IGNEMPTYROWS ) ), |
| maBtnDetectCat( this, ScResId( BTN_DETECTCAT ) ), |
| maBtnTotalCol( this, ScResId( BTN_TOTALCOL ) ), |
| maBtnTotalRow( this, ScResId( BTN_TOTALROW ) ), |
| maBtnFilter( this, ScResId( BTN_FILTER ) ), |
| maBtnDrillDown( this, ScResId( BTN_DRILLDOWN ) ), |
| |
| maBtnOk( this, ScResId( BTN_OK ) ), |
| maBtnCancel( this, ScResId( BTN_CANCEL ) ), |
| maBtnHelp( this, ScResId( BTN_HELP ) ), |
| maBtnRemove( this, ScResId( BTN_REMOVE ) ), |
| maBtnOptions( this, ScResId( BTN_OPTIONS ) ), |
| maBtnMore( this, ScResId( BTN_MORE ) ), |
| |
| mxDlgDPObject( new ScDPObject( rDPObject ) ), |
| mpViewData( ((ScTabViewShell*)SfxViewShell::Current())->GetViewData() ), |
| mpDoc( ((ScTabViewShell*)SfxViewShell::Current())->GetViewData()->GetDocument() ), |
| mpFocusWindow( 0 ), |
| mpTrackingWindow( 0 ), |
| mpDropWindow( 0 ), |
| mpActiveEdit( 0 ), |
| mbRefInputMode( false ) |
| { |
| DBG_ASSERT( mpViewData && mpDoc, "ScPivotLayoutDlg::ScPivotLayoutDlg - missing document or view data" ); |
| |
| mxDlgDPObject->SetAlive( true ); // needed to get structure information |
| mxDlgDPObject->FillOldParam( maPivotData ); |
| mxDlgDPObject->FillLabelData( maPivotData ); |
| |
| maBtnRemove.SetClickHdl( LINK( this, ScPivotLayoutDlg, ClickHdl ) ); |
| maBtnOptions.SetClickHdl( LINK( this, ScPivotLayoutDlg, ClickHdl ) ); |
| |
| // PIVOT_MAXFUNC defined in sc/inc/dpglobal.hxx |
| maFuncNames.reserve( PIVOT_MAXFUNC ); |
| for( sal_uInt16 i = 1; i <= PIVOT_MAXFUNC; ++i ) |
| maFuncNames.push_back( String( ScResId( i ) ) ); |
| |
| maBtnMore.AddWindow( &maFlAreas ); |
| maBtnMore.AddWindow( &maFtInArea ); |
| maBtnMore.AddWindow( &maEdInPos ); |
| maBtnMore.AddWindow( &maRbInPos ); |
| maBtnMore.AddWindow( &maFtOutArea ); |
| maBtnMore.AddWindow( &maLbOutPos ); |
| maBtnMore.AddWindow( &maEdOutPos ); |
| maBtnMore.AddWindow( &maRbOutPos ); |
| maBtnMore.AddWindow( &maBtnIgnEmptyRows ); |
| maBtnMore.AddWindow( &maBtnDetectCat ); |
| maBtnMore.AddWindow( &maBtnTotalCol ); |
| maBtnMore.AddWindow( &maBtnTotalRow ); |
| maBtnMore.AddWindow( &maBtnFilter ); |
| maBtnMore.AddWindow( &maBtnDrillDown ); |
| maBtnMore.SetClickHdl( LINK( this, ScPivotLayoutDlg, MoreClickHdl ) ); |
| |
| if( mxDlgDPObject->GetSheetDesc() ) |
| { |
| maEdInPos.Enable(); |
| maRbInPos.Enable(); |
| ScRange aRange = mxDlgDPObject->GetSheetDesc()->aSourceRange; |
| String aString; |
| aRange.Format( aString, SCR_ABS_3D, mpDoc, mpDoc->GetAddressConvention() ); |
| maEdInPos.SetText( aString ); |
| } |
| else |
| { |
| // data is not reachable, so could be a remote database |
| maEdInPos.Disable(); |
| maRbInPos.Disable(); |
| } |
| |
| // #i29203# align right border of page window with data window |
| long nPagePosX = maWndData.GetPosPixel().X() + maWndData.GetSizePixel().Width() - maWndPage.GetSizePixel().Width(); |
| maWndPage.SetPosPixel( Point( nPagePosX, maWndPage.GetPosPixel().Y() ) ); |
| maScrPage.SetPosPixel( Point( maScrData.GetPosPixel().X(), maScrPage.GetPosPixel().Y() ) ); |
| |
| InitFieldWindows(); |
| |
| maLbOutPos.SetSelectHdl( LINK( this, ScPivotLayoutDlg, SelAreaHdl ) ); |
| maEdOutPos.SetModifyHdl( LINK( this, ScPivotLayoutDlg, EdOutModifyHdl ) ); |
| maEdInPos.SetModifyHdl( LINK( this, ScPivotLayoutDlg, EdInModifyHdl ) ); |
| maBtnOk.SetClickHdl( LINK( this, ScPivotLayoutDlg, OkHdl ) ); |
| maBtnCancel.SetClickHdl( LINK( this, ScPivotLayoutDlg, CancelHdl ) ); |
| |
| if( mpViewData && mpDoc ) |
| { |
| /* |
| * Aus den RangeNames des Dokumentes werden nun die |
| * in einem Zeiger-Array gemerkt, bei denen es sich |
| * um sinnvolle Bereiche handelt |
| */ |
| |
| maLbOutPos.Clear(); |
| maLbOutPos.InsertEntry( String( ScResId( SCSTR_UNDEFINED ) ), 0 ); |
| maLbOutPos.InsertEntry( String( ScResId( SCSTR_NEWTABLE ) ), 1 ); |
| |
| ScAreaNameIterator aIter( mpDoc ); |
| String aName; |
| ScRange aRange; |
| String aRefStr; |
| while ( aIter.Next( aName, aRange ) ) |
| { |
| if ( !aIter.WasDBName() ) // hier keine DB-Bereiche ! |
| { |
| sal_uInt16 nInsert = maLbOutPos.InsertEntry( aName ); |
| |
| aRange.aStart.Format( aRefStr, SCA_ABS_3D, mpDoc, mpDoc->GetAddressConvention() ); |
| maLbOutPos.SetEntryData( nInsert, new String( aRefStr ) ); |
| } |
| } |
| } |
| |
| if ( maPivotData.nTab != MAXTAB+1 ) |
| { |
| String aStr; |
| ScAddress( maPivotData.nCol, |
| maPivotData.nRow, |
| maPivotData.nTab ).Format( aStr, STD_FORMAT, mpDoc, mpDoc->GetAddressConvention() ); |
| maEdOutPos.SetText( aStr ); |
| EdOutModifyHdl( 0 ); |
| } |
| else |
| { |
| maLbOutPos.SelectEntryPos( maLbOutPos.GetEntryCount()-1 ); |
| SelAreaHdl(NULL); |
| } |
| |
| maBtnIgnEmptyRows.Check( maPivotData.bIgnoreEmptyRows ); |
| maBtnDetectCat.Check( maPivotData.bDetectCategories ); |
| maBtnTotalCol.Check( maPivotData.bMakeTotalCol ); |
| maBtnTotalRow.Check( maPivotData.bMakeTotalRow ); |
| |
| const ScDPSaveData* pSaveData = mxDlgDPObject->GetSaveData(); |
| maBtnFilter.Check( !pSaveData || pSaveData->GetFilterButton() ); |
| maBtnDrillDown.Check( !pSaveData || pSaveData->GetDrillDown() ); |
| |
| // child event listener handles field movement when keyboard shortcut is pressed |
| AddChildEventListener( LINK( this, ScPivotLayoutDlg, ChildEventListener ) ); |
| GrabFieldFocus( maWndSelect ); |
| |
| FreeResource(); |
| } |
| |
| ScPivotLayoutDlg::~ScPivotLayoutDlg() |
| { |
| RemoveChildEventListener( LINK( this, ScPivotLayoutDlg, ChildEventListener ) ); |
| |
| for( sal_uInt16 i = 2, nEntries = maLbOutPos.GetEntryCount(); i < nEntries; ++i ) |
| delete (String*)maLbOutPos.GetEntryData( i ); |
| } |
| |
| ScDPLabelData* ScPivotLayoutDlg::GetLabelData( SCCOL nCol, size_t* pnIndex ) |
| { |
| ScDPLabelData* pLabelData = 0; |
| for( ScDPLabelDataVector::iterator aIt = maLabelData.begin(), aEnd = maLabelData.end(); !pLabelData && (aIt != aEnd); ++aIt ) |
| { |
| if( aIt->mnCol == nCol ) |
| { |
| pLabelData = &*aIt; |
| if( pnIndex ) |
| *pnIndex = aIt - maLabelData.begin(); |
| } |
| } |
| return pLabelData; |
| } |
| |
| String ScPivotLayoutDlg::GetFuncString( sal_uInt16& rnFuncMask, bool bIsValue ) |
| { |
| String aStr; |
| |
| if( (rnFuncMask == PIVOT_FUNC_NONE) || (rnFuncMask == PIVOT_FUNC_AUTO) ) |
| { |
| if( bIsValue ) |
| { |
| aStr = GetFuncName( PIVOTSTR_SUM ); |
| rnFuncMask = PIVOT_FUNC_SUM; |
| } |
| else |
| { |
| aStr = GetFuncName( PIVOTSTR_COUNT ); |
| rnFuncMask = PIVOT_FUNC_COUNT; |
| } |
| } |
| else if( rnFuncMask == PIVOT_FUNC_SUM ) aStr = GetFuncName( PIVOTSTR_SUM ); |
| else if( rnFuncMask == PIVOT_FUNC_COUNT ) aStr = GetFuncName( PIVOTSTR_COUNT ); |
| else if( rnFuncMask == PIVOT_FUNC_AVERAGE ) aStr = GetFuncName( PIVOTSTR_AVG ); |
| else if( rnFuncMask == PIVOT_FUNC_MAX ) aStr = GetFuncName( PIVOTSTR_MAX ); |
| else if( rnFuncMask == PIVOT_FUNC_MIN ) aStr = GetFuncName( PIVOTSTR_MIN ); |
| else if( rnFuncMask == PIVOT_FUNC_PRODUCT ) aStr = GetFuncName( PIVOTSTR_PROD ); |
| else if( rnFuncMask == PIVOT_FUNC_COUNT_NUM ) aStr = GetFuncName( PIVOTSTR_COUNT2 ); |
| else if( rnFuncMask == PIVOT_FUNC_STD_DEV ) aStr = GetFuncName( PIVOTSTR_DEV ); |
| else if( rnFuncMask == PIVOT_FUNC_STD_DEVP ) aStr = GetFuncName( PIVOTSTR_DEV2 ); |
| else if( rnFuncMask == PIVOT_FUNC_STD_VAR ) aStr = GetFuncName( PIVOTSTR_VAR ); |
| else if( rnFuncMask == PIVOT_FUNC_STD_VARP ) aStr = GetFuncName( PIVOTSTR_VAR2 ); |
| else |
| { |
| aStr = ScGlobal::GetRscString( STR_TABLE_ERGEBNIS ); |
| aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " - " ) ); |
| } |
| |
| return aStr; |
| } |
| |
| void ScPivotLayoutDlg::NotifyStartTracking( ScPivotFieldWindow& rSourceWindow ) |
| { |
| mpTrackingWindow = &rSourceWindow; |
| mpDropWindow = 0; |
| rSourceWindow.NotifyStartTracking(); |
| StartTracking( STARTTRACK_BUTTONREPEAT ); |
| SetPointer( Pointer( rSourceWindow.GetDropPointerStyle() ) ); |
| } |
| |
| void ScPivotLayoutDlg::NotifyDoubleClick( ScPivotFieldWindow& rSourceWindow ) |
| { |
| // nothing to do on double-click in selection window |
| if( rSourceWindow.GetType() == PIVOTFIELDTYPE_SELECT ) |
| return; |
| |
| const ScPivotFuncData* pFuncData = rSourceWindow.GetSelectedFuncData(); |
| DBG_ASSERT( pFuncData, "ScPivotLayoutDlg::NotifyDoubleClick - invalid selection" ); |
| if( !pFuncData ) |
| return; |
| |
| ScDPLabelData* pLabelData = GetLabelData( pFuncData->mnCol ); |
| DBG_ASSERT( pLabelData, "ScPivotLayoutDlg::NotifyDoubleClick - missing label data" ); |
| if( !pLabelData ) |
| return; |
| |
| ScAbstractDialogFactory* pFactory = ScAbstractDialogFactory::Create(); |
| DBG_ASSERT( pFactory, "ScPivotLayoutDlg::NotifyDoubleClick - ScAbstractDialogFactory creation failed" ); |
| if( !pFactory ) |
| return; |
| |
| if( rSourceWindow.GetType() == PIVOTFIELDTYPE_DATA ) |
| { |
| ::std::auto_ptr< AbstractScDPFunctionDlg > xDlg( pFactory->CreateScDPFunctionDlg( |
| this, RID_SCDLG_DPDATAFIELD, maLabelData, *pLabelData, *pFuncData ) ); |
| if( xDlg->Execute() == RET_OK ) |
| { |
| ScPivotFuncData aFuncData( *pFuncData ); |
| aFuncData.mnFuncMask = pLabelData->mnFuncMask = xDlg->GetFuncMask(); |
| aFuncData.maFieldRef = xDlg->GetFieldRef(); |
| rSourceWindow.ModifySelectedField( aFuncData ); |
| } |
| } |
| else |
| { |
| // list of plain names of all data fields |
| ScDPNameVec aDataFieldNames; |
| maWndData.WriteFieldNames( aDataFieldNames ); |
| // allow to modify layout options for row fields, if multiple data fields exist, or if it is not the last row field |
| bool bLayout = (rSourceWindow.GetType() == PIVOTFIELDTYPE_ROW) && ((aDataFieldNames.size() > 1) || (rSourceWindow.GetSelectedIndex() + 1 < rSourceWindow.GetFieldCount())); |
| |
| ::std::auto_ptr< AbstractScDPSubtotalDlg > xDlg( pFactory->CreateScDPSubtotalDlg( |
| this, RID_SCDLG_PIVOTSUBT, *mxDlgDPObject, *pLabelData, *pFuncData, aDataFieldNames, bLayout ) ); |
| if( xDlg->Execute() == RET_OK ) |
| { |
| xDlg->FillLabelData( *pLabelData ); |
| ScPivotFuncData aFuncData( *pFuncData ); |
| aFuncData.mnFuncMask = pLabelData->mnFuncMask; |
| rSourceWindow.ModifySelectedField( aFuncData ); |
| } |
| } |
| } |
| |
| void ScPivotLayoutDlg::NotifyFieldRemoved( ScPivotFieldWindow& rSourceWindow ) |
| { |
| // update focus: move to selection window, if source window is empty now |
| GrabFieldFocus( rSourceWindow ); |
| } |
| |
| // protected ------------------------------------------------------------------ |
| |
| void ScPivotLayoutDlg::Tracking( const TrackingEvent& rTEvt ) |
| { |
| DBG_ASSERT( mpTrackingWindow, "ScPivotLayoutDlg::Tracking - missing tracking source window" ); |
| if( !mpTrackingWindow ) |
| return; |
| |
| // find target window |
| const Point& rDialogPos = rTEvt.GetMouseEvent().GetPosPixel(); |
| ScPivotFieldWindow* pTargetWindow = dynamic_cast< ScPivotFieldWindow* >( FindWindow( rDialogPos ) ); |
| |
| // check if the target orientation is allowed for this field |
| if( pTargetWindow && (mpTrackingWindow != pTargetWindow) && !IsInsertAllowed( *mpTrackingWindow, *pTargetWindow ) ) |
| pTargetWindow = 0; |
| |
| // tracking from selection window: do not show "delete" mouse pointer |
| PointerStyle eTargetPointer = pTargetWindow ? pTargetWindow->GetDropPointerStyle() : |
| ((mpTrackingWindow->GetType() == PIVOTFIELDTYPE_SELECT) ? POINTER_NOTALLOWED : POINTER_PIVOT_DELETE); |
| |
| // after calculating pointer style, check if target is selection window |
| if( pTargetWindow && (pTargetWindow->GetType() == PIVOTFIELDTYPE_SELECT) ) |
| pTargetWindow = 0; |
| |
| // notify windows about tracking |
| if( mpDropWindow != pTargetWindow ) |
| { |
| // tracking window changed |
| if( mpDropWindow ) |
| mpDropWindow->NotifyEndTracking( ENDTRACKING_SUSPEND ); |
| if( pTargetWindow ) |
| pTargetWindow->NotifyStartTracking(); |
| mpDropWindow = pTargetWindow; |
| } |
| if( mpDropWindow ) |
| mpDropWindow->NotifyTracking( rDialogPos - pTargetWindow->GetPosPixel() ); |
| |
| // end tracking: move or remove field |
| if( rTEvt.IsTrackingEnded() ) |
| { |
| bool bCancelled = rTEvt.IsTrackingCanceled(); |
| if( mpDropWindow ) |
| { |
| mpDropWindow->NotifyEndTracking( bCancelled ? ENDTRACKING_CANCEL : ENDTRACKING_DROP ); |
| if( !bCancelled ) |
| { |
| size_t nInsertIndex = mpDropWindow->GetDropIndex( rDialogPos - mpDropWindow->GetPosPixel() ); |
| bool bMoved = MoveField( *mpTrackingWindow, *mpDropWindow, nInsertIndex, true ); |
| // focus drop window, if move was successful, otherwise back to source window |
| GrabFieldFocus( bMoved ? *mpDropWindow : *mpTrackingWindow ); |
| } |
| } |
| else |
| { |
| // drop target invalid (outside field windows): remove tracked field |
| if( !bCancelled ) |
| mpTrackingWindow->RemoveSelectedField(); |
| // focus source window (or another window, if it is empty now) |
| GrabFieldFocus( *mpTrackingWindow ); |
| } |
| eTargetPointer = POINTER_ARROW; |
| if( mpTrackingWindow != mpDropWindow ) |
| mpTrackingWindow->NotifyEndTracking( ENDTRACKING_CANCEL ); |
| mpTrackingWindow = mpDropWindow = 0; |
| } |
| SetPointer( eTargetPointer ); |
| } |
| |
| void ScPivotLayoutDlg::SetReference( const ScRange& rRef, ScDocument* pDocP ) |
| { |
| if( !mbRefInputMode || !mpActiveEdit ) |
| return; |
| |
| if( rRef.aStart != rRef.aEnd ) |
| RefInputStart( mpActiveEdit ); |
| |
| if( mpActiveEdit == &maEdInPos ) |
| { |
| String aRefStr; |
| rRef.Format( aRefStr, SCR_ABS_3D, pDocP, pDocP->GetAddressConvention() ); |
| mpActiveEdit->SetRefString( aRefStr ); |
| } |
| else if( mpActiveEdit == &maEdOutPos ) |
| { |
| String aRefStr; |
| rRef.aStart.Format( aRefStr, STD_FORMAT, pDocP, pDocP->GetAddressConvention() ); |
| mpActiveEdit->SetRefString( aRefStr ); |
| } |
| } |
| |
| sal_Bool ScPivotLayoutDlg::IsRefInputMode() const |
| { |
| return mbRefInputMode; |
| } |
| |
| void ScPivotLayoutDlg::SetActive() |
| { |
| if( mbRefInputMode ) |
| { |
| if( mpActiveEdit ) |
| mpActiveEdit->GrabFocus(); |
| |
| if( mpActiveEdit == &maEdInPos ) |
| EdInModifyHdl( 0 ); |
| else if( mpActiveEdit == &maEdOutPos ) |
| EdOutModifyHdl( 0 ); |
| } |
| else |
| { |
| GrabFocus(); |
| } |
| |
| RefInputDone(); |
| } |
| |
| sal_Bool ScPivotLayoutDlg::Close() |
| { |
| return DoClose( ScPivotLayoutWrapper::GetChildWindowId() ); |
| } |
| |
| // private -------------------------------------------------------------------- |
| |
| ScPivotFieldWindow& ScPivotLayoutDlg::GetFieldWindow( ScPivotFieldType eFieldType ) |
| { |
| switch( eFieldType ) |
| { |
| case PIVOTFIELDTYPE_PAGE: return maWndPage; |
| case PIVOTFIELDTYPE_ROW: return maWndRow; |
| case PIVOTFIELDTYPE_COL: return maWndCol; |
| case PIVOTFIELDTYPE_DATA: return maWndData; |
| default:; |
| } |
| return maWndSelect; |
| } |
| |
| bool ScPivotLayoutDlg::IsInsertAllowed( const ScPivotFieldWindow& rSourceWindow, const ScPivotFieldWindow& rTargetWindow ) |
| { |
| if( rTargetWindow.GetType() != PIVOTFIELDTYPE_SELECT ) |
| { |
| const ScPivotFuncData* pSourceData = rSourceWindow.GetSelectedFuncData(); |
| ScDPLabelData* pLabelData = pSourceData ? GetLabelData( pSourceData->mnCol ) : 0; |
| DBG_ASSERT( pLabelData, "ScPivotLayoutDlg::IsInsertAllowed - label data not found" ); |
| if( pLabelData ) |
| { |
| sheet::DataPilotFieldOrientation eOrient = sheet::DataPilotFieldOrientation_HIDDEN; |
| switch( rTargetWindow.GetType() ) |
| { |
| case PIVOTFIELDTYPE_PAGE: eOrient = sheet::DataPilotFieldOrientation_PAGE; break; |
| case PIVOTFIELDTYPE_COL: eOrient = sheet::DataPilotFieldOrientation_COLUMN; break; |
| case PIVOTFIELDTYPE_ROW: eOrient = sheet::DataPilotFieldOrientation_ROW; break; |
| case PIVOTFIELDTYPE_DATA: eOrient = sheet::DataPilotFieldOrientation_DATA; break; |
| default: return false; |
| } |
| return ScDPObject::IsOrientationAllowed( static_cast< sal_uInt16 >( eOrient ), pLabelData->mnFlags ); |
| } |
| } |
| return false; |
| } |
| |
| void ScPivotLayoutDlg::InitFieldWindows() |
| { |
| maLabelData = maPivotData.maLabelArray; |
| maWndSelect.ReadDataLabels( maLabelData ); |
| maWndPage.ReadPivotFields( maPivotData.maPageArr ); |
| maWndCol.ReadPivotFields( maPivotData.maColArr ); |
| maWndRow.ReadPivotFields( maPivotData.maRowArr ); |
| maWndData.ReadPivotFields( maPivotData.maDataArr ); |
| } |
| |
| void ScPivotLayoutDlg::GrabFieldFocus( ScPivotFieldWindow& rFieldWindow ) |
| { |
| if( rFieldWindow.IsEmpty() ) |
| { |
| if( maWndSelect.IsEmpty() ) |
| maBtnOk.GrabFocus(); |
| else |
| maWndSelect.GrabFocus(); |
| } |
| else |
| rFieldWindow.GrabFocus(); |
| } |
| |
| namespace { |
| |
| void lclFindFieldWindow( ScPivotFieldWindow*& rpFieldWindow, const ScPivotFuncData*& rpFuncData, size_t& rnFieldIndex, ScPivotFieldWindow& rFieldWindow ) |
| { |
| ScPivotFuncDataEntry aEntry = rFieldWindow.FindFuncDataByCol( rpFuncData->mnCol ); |
| if( aEntry.first ) |
| { |
| rpFieldWindow = &rFieldWindow; |
| rpFuncData = aEntry.first; |
| rnFieldIndex = aEntry.second; |
| } |
| } |
| |
| } // namespace |
| |
| bool ScPivotLayoutDlg::MoveField( ScPivotFieldWindow& rSourceWindow, ScPivotFieldWindow& rTargetWindow, size_t nInsertIndex, bool bMoveExisting ) |
| { |
| // move inside the same window |
| if( &rSourceWindow == &rTargetWindow ) |
| return bMoveExisting && rTargetWindow.MoveSelectedField( nInsertIndex ); |
| |
| // do not insert if not supported by target window |
| if( !IsInsertAllowed( rSourceWindow, rTargetWindow ) ) |
| { |
| rSourceWindow.RemoveSelectedField(); |
| return false; |
| } |
| |
| // move from one window to another window |
| if( const ScPivotFuncData* pSourceData = rSourceWindow.GetSelectedFuncData() ) |
| { |
| // move to page/col/row window: try to find existing field in another window |
| ScPivotFieldWindow* pSourceWindow = &rSourceWindow; |
| size_t nSourceIndex = rSourceWindow.GetSelectedIndex(); |
| if( rTargetWindow.GetType() != PIVOTFIELDTYPE_DATA ) |
| { |
| lclFindFieldWindow( pSourceWindow, pSourceData, nSourceIndex, maWndPage ); |
| lclFindFieldWindow( pSourceWindow, pSourceData, nSourceIndex, maWndCol ); |
| lclFindFieldWindow( pSourceWindow, pSourceData, nSourceIndex, maWndRow ); |
| } |
| |
| // found in target window: move to new position |
| if( pSourceWindow == &rTargetWindow ) |
| return bMoveExisting && pSourceWindow->MoveField( nSourceIndex, nInsertIndex ); |
| |
| // insert field into target window |
| rTargetWindow.InsertField( nInsertIndex, *pSourceData ); |
| // remove field from source window |
| pSourceWindow->RemoveField( nSourceIndex ); |
| // remove field from data window, if it is the original source |
| if( (rSourceWindow.GetType() == PIVOTFIELDTYPE_DATA) && (pSourceWindow->GetType() != PIVOTFIELDTYPE_DATA) ) |
| rSourceWindow.RemoveSelectedField(); |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| // handlers ------------------------------------------------------------------- |
| |
| IMPL_LINK( ScPivotLayoutDlg, ClickHdl, PushButton *, pBtn ) |
| { |
| if( mpFocusWindow ) |
| { |
| /* Raising sub dialogs (from the NotifyDoubleClick function) triggers |
| VCL child window focus events from this sub dialog which may |
| invalidate the member mpFocusWindow pointing to the target field |
| window. This would cause a crash with the following call to the |
| GrabFieldFocus function, if mpFocusWindow is used directly. */ |
| ScPivotFieldWindow& rTargetWindow = *mpFocusWindow; |
| |
| if( pBtn == &maBtnRemove ) |
| { |
| rTargetWindow.RemoveSelectedField(); |
| // focus back to field window |
| GrabFieldFocus( rTargetWindow ); |
| } |
| else if( pBtn == &maBtnOptions ) |
| { |
| NotifyDoubleClick( rTargetWindow ); |
| // focus back to field window |
| GrabFieldFocus( rTargetWindow ); |
| } |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, OkHdl, OKButton *, EMPTYARG ) |
| { |
| String aOutPosStr = maEdOutPos.GetText(); |
| ScAddress aAdrDest; |
| bool bToNewTable = maLbOutPos.GetSelectEntryPos() == 1; |
| sal_uInt16 nResult = !bToNewTable ? aAdrDest.Parse( aOutPosStr, mpDoc, mpDoc->GetAddressConvention() ) : 0; |
| |
| if( bToNewTable || ((aOutPosStr.Len() > 0) && ((nResult & SCA_VALID) == SCA_VALID)) ) |
| { |
| ScPivotFieldVector aPageFields, aColFields, aRowFields, aDataFields; |
| maWndPage.WritePivotFields( aPageFields ); |
| maWndCol.WritePivotFields( aColFields ); |
| maWndRow.WritePivotFields( aRowFields ); |
| maWndData.WritePivotFields( aDataFields ); |
| |
| // TODO: handle data field in dialog field windows? |
| aRowFields.resize( aRowFields.size() + 1 ); |
| aRowFields.back().nCol = PIVOT_DATA_FIELD; |
| |
| ScDPSaveData* pOldSaveData = mxDlgDPObject->GetSaveData(); |
| |
| ScRange aOutRange( aAdrDest ); // bToNewTable is passed separately |
| |
| ScDPSaveData aSaveData; |
| aSaveData.SetIgnoreEmptyRows( maBtnIgnEmptyRows.IsChecked() ); |
| aSaveData.SetRepeatIfEmpty( maBtnDetectCat.IsChecked() ); |
| aSaveData.SetColumnGrand( maBtnTotalCol.IsChecked() ); |
| aSaveData.SetRowGrand( maBtnTotalRow.IsChecked() ); |
| aSaveData.SetFilterButton( maBtnFilter.IsChecked() ); |
| aSaveData.SetDrillDown( maBtnDrillDown.IsChecked() ); |
| |
| uno::Reference< sheet::XDimensionsSupplier > xSource = mxDlgDPObject->GetSource(); |
| |
| ScDPObject::ConvertOrientation( aSaveData, aPageFields, sheet::DataPilotFieldOrientation_PAGE, 0, 0, 0, xSource, false ); |
| ScDPObject::ConvertOrientation( aSaveData, aColFields, sheet::DataPilotFieldOrientation_COLUMN, 0, 0, 0, xSource, false ); |
| ScDPObject::ConvertOrientation( aSaveData, aRowFields, sheet::DataPilotFieldOrientation_ROW, 0, 0, 0, xSource, false ); |
| ScDPObject::ConvertOrientation( aSaveData, aDataFields, sheet::DataPilotFieldOrientation_DATA, 0, 0, 0, xSource, false, &aColFields, &aRowFields, &aPageFields ); |
| |
| for( ScDPLabelDataVector::const_iterator aIt = maLabelData.begin(), aEnd = maLabelData.end(); aIt != aEnd; ++aIt ) |
| { |
| if( ScDPSaveDimension* pDim = aSaveData.GetExistingDimensionByName( aIt->maName ) ) |
| { |
| pDim->SetUsedHierarchy( aIt->mnUsedHier ); |
| pDim->SetShowEmpty( aIt->mbShowAll ); |
| pDim->SetSortInfo( &aIt->maSortInfo ); |
| pDim->SetLayoutInfo( &aIt->maLayoutInfo ); |
| pDim->SetAutoShowInfo( &aIt->maShowInfo ); |
| ScDPSaveDimension* pOldDim = NULL; |
| if (pOldSaveData) |
| { |
| // Transfer the existing layout names to new dimension instance. |
| pOldDim = pOldSaveData->GetExistingDimensionByName(aIt->maName); |
| if (pOldDim) |
| { |
| const OUString* pLayoutName = pOldDim->GetLayoutName(); |
| if (pLayoutName) |
| pDim->SetLayoutName(*pLayoutName); |
| |
| const OUString* pSubtotalName = pOldDim->GetSubtotalName(); |
| if (pSubtotalName) |
| pDim->SetSubtotalName(*pSubtotalName); |
| } |
| } |
| |
| bool bManualSort = ( aIt->maSortInfo.Mode == sheet::DataPilotFieldSortMode::MANUAL ); |
| |
| // visibility of members |
| for (::std::vector<ScDPLabelData::Member>::const_iterator itr = aIt->maMembers.begin(), itrEnd = aIt->maMembers.end(); |
| itr != itrEnd; ++itr) |
| { |
| ScDPSaveMember* pMember = pDim->GetMemberByName(itr->maName); |
| |
| // #i40054# create/access members only if flags are not default |
| // (or in manual sorting mode - to keep the order) |
| if (bManualSort || !itr->mbVisible || !itr->mbShowDetails) |
| { |
| pMember->SetIsVisible(itr->mbVisible); |
| pMember->SetShowDetails(itr->mbShowDetails); |
| } |
| if (pOldDim) |
| { |
| // Transfer the existing layout name. |
| ScDPSaveMember* pOldMember = pOldDim->GetMemberByName(itr->maName); |
| if (pOldMember) |
| { |
| const OUString* pLayoutName = pOldMember->GetLayoutName(); |
| if (pLayoutName) |
| pMember->SetLayoutName(*pLayoutName); |
| } |
| } |
| } |
| } |
| } |
| ScDPSaveDimension* pDim = aSaveData.GetDataLayoutDimension(); |
| if (pDim && pOldSaveData) |
| { |
| ScDPSaveDimension* pOldDim = pOldSaveData->GetDataLayoutDimension(); |
| if (pOldDim) |
| { |
| const OUString* pLayoutName = pOldDim->GetLayoutName(); |
| if (pLayoutName) |
| pDim->SetLayoutName(*pLayoutName); |
| } |
| } |
| |
| // also transfer grand total name |
| if (pOldSaveData) |
| { |
| const OUString* pGrandTotalName = pOldSaveData->GetGrandTotalName(); |
| if (pGrandTotalName) |
| aSaveData.SetGrandTotalName(*pGrandTotalName); |
| } |
| |
| sal_uInt16 nWhichPivot = SC_MOD()->GetPool().GetWhich( SID_PIVOT_TABLE ); |
| ScPivotItem aOutItem( nWhichPivot, &aSaveData, &aOutRange, bToNewTable ); |
| |
| mbRefInputMode = false; // to allow deselecting when switching sheets |
| |
| SetDispatcherLock( false ); |
| SwitchToDocument(); |
| |
| // #95513# don't hide the dialog before executing the slot, instead it is used as |
| // parent for message boxes in ScTabViewShell::GetDialogParent |
| |
| const SfxPoolItem* pRet = GetBindings().GetDispatcher()->Execute( |
| SID_PIVOT_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aOutItem, 0L, 0L ); |
| |
| bool bSuccess = true; |
| if (pRet) |
| { |
| const SfxBoolItem* pItem = dynamic_cast<const SfxBoolItem*>(pRet); |
| if (pItem) |
| bSuccess = pItem->GetValue(); |
| } |
| if (bSuccess) |
| // Table successfully inserted. |
| Close(); |
| else |
| { |
| // Table insertion failed. Keep the dialog open. |
| mbRefInputMode = true; |
| SetDispatcherLock(true); |
| } |
| } |
| else |
| { |
| if( !maBtnMore.GetState() ) |
| maBtnMore.SetState( true ); |
| |
| ErrorBox( this, WinBits( WB_OK | WB_DEF_OK ), ScGlobal::GetRscString( STR_INVALID_TABREF ) ).Execute(); |
| maEdOutPos.GrabFocus(); |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, CancelHdl, CancelButton *, EMPTYARG ) |
| { |
| Close(); |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, MoreClickHdl, MoreButton *, EMPTYARG ) |
| { |
| if ( maBtnMore.GetState() ) |
| { |
| mbRefInputMode = true; |
| if ( maEdInPos.IsEnabled() ) |
| { |
| maEdInPos.Enable(); |
| maEdInPos.GrabFocus(); |
| maEdInPos.Enable(); |
| } |
| else |
| { |
| maEdOutPos.Enable(); |
| maEdOutPos.GrabFocus(); |
| maEdOutPos.Enable(); |
| } |
| } |
| else |
| { |
| mbRefInputMode = false; |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, EdOutModifyHdl, Edit *, EMPTYARG ) |
| { |
| String theCurPosStr = maEdOutPos.GetText(); |
| sal_uInt16 nResult = ScAddress().Parse( theCurPosStr, mpDoc, mpDoc->GetAddressConvention() ); |
| |
| if ( SCA_VALID == (nResult & SCA_VALID) ) |
| { |
| String* pStr = 0; |
| bool bFound = false; |
| sal_uInt16 i = 0; |
| sal_uInt16 nCount = maLbOutPos.GetEntryCount(); |
| |
| for ( i=2; i<nCount && !bFound; i++ ) |
| { |
| pStr = (String*)maLbOutPos.GetEntryData( i ); |
| bFound = (theCurPosStr == *pStr); |
| } |
| |
| if ( bFound ) |
| maLbOutPos.SelectEntryPos( --i ); |
| else |
| maLbOutPos.SelectEntryPos( 0 ); |
| } |
| return 0; |
| } |
| |
| |
| IMPL_LINK( ScPivotLayoutDlg, EdInModifyHdl, Edit *, EMPTYARG ) |
| { |
| String theCurPosStr = maEdInPos.GetText(); |
| sal_uInt16 nResult = ScRange().Parse( theCurPosStr, mpDoc, mpDoc->GetAddressConvention() ); |
| |
| // invalid source range |
| if( SCA_VALID != (nResult & SCA_VALID) ) |
| return 0; |
| |
| ScRefAddress start, end; |
| ConvertDoubleRef( mpDoc, theCurPosStr, 1, start, end, mpDoc->GetAddressConvention() ); |
| ScRange aNewRange( start.GetAddress(), end.GetAddress() ); |
| ScSheetSourceDesc inSheet = *mxDlgDPObject->GetSheetDesc(); |
| |
| // new range is identical to the current range |
| if( inSheet.aSourceRange == aNewRange ) |
| return 0; |
| |
| ScTabViewShell* pTabViewShell = mpViewData->GetViewShell(); |
| inSheet.aSourceRange = aNewRange; |
| mxDlgDPObject->SetSheetDesc( inSheet ); |
| mxDlgDPObject->FillOldParam( maPivotData ); |
| mxDlgDPObject->FillLabelData( maPivotData ); |
| |
| // SetDialogDPObject does not take ownership but makes a copy internally |
| pTabViewShell->SetDialogDPObject( mxDlgDPObject.get() ); |
| |
| // re-initialize the field windows from the new data |
| InitFieldWindows(); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, SelAreaHdl, ListBox *, EMPTYARG ) |
| { |
| String aString; |
| sal_uInt16 nSelPos = maLbOutPos.GetSelectEntryPos(); |
| if( nSelPos > 1 ) |
| { |
| aString = *(String*)maLbOutPos.GetEntryData( nSelPos ); |
| } |
| else |
| { |
| // do not allow to specify output position, if target is "new sheet" |
| bool bNewSheet = nSelPos == 1; |
| maEdOutPos.Enable( !bNewSheet ); |
| maRbOutPos.Enable( !bNewSheet ); |
| } |
| |
| maEdOutPos.SetText( aString ); |
| return 0; |
| } |
| |
| IMPL_LINK( ScPivotLayoutDlg, ChildEventListener, VclWindowEvent*, pEvent ) |
| { |
| Window* pWindow = pEvent->GetWindow(); |
| // check that this dialog is the parent of the window, to ignore focus events from sub dialogs |
| if( (pEvent->GetId() == VCLEVENT_WINDOW_GETFOCUS) && pWindow && (pWindow->GetParent() == this) ) |
| { |
| // check if old window and/or new window are field windows |
| ScPivotFieldWindow* pSourceWindow = mpFocusWindow; |
| ScPivotFieldWindow* pTargetWindow = dynamic_cast< ScPivotFieldWindow* >( pWindow ); |
| |
| /* Enable or disable the Remove/Options buttons. Do nothing if the |
| buttons themselves get the focus. |
| #128113# The TestTool may set the focus into an empty window. Then |
| the Remove/Options buttons must be disabled. */ |
| if( (pWindow != &maBtnRemove) && (pWindow != &maBtnOptions) ) |
| { |
| bool bEnableButtons = pTargetWindow && (pTargetWindow->GetType() != PIVOTFIELDTYPE_SELECT) && !pTargetWindow->IsEmpty(); |
| maBtnRemove.Enable( bEnableButtons ); |
| maBtnOptions.Enable( bEnableButtons ); |
| /* Remember the new focus window (will not be changed, if |
| Remove/Option buttons are getting focus, because they need to |
| know the field window they are working on). */ |
| mpFocusWindow = pTargetWindow; |
| } |
| |
| /* Move the last selected field to target window, if focus changes via |
| keyboard shortcut. */ |
| if( pSourceWindow && pTargetWindow && (pSourceWindow != pTargetWindow) && ((pTargetWindow->GetGetFocusFlags() & GETFOCUS_MNEMONIC) != 0) ) |
| { |
| // append field in target window |
| MoveField( *pSourceWindow, *pTargetWindow, pTargetWindow->GetFieldCount(), false ); |
| // move cursor in selection window to next field |
| if( pSourceWindow->GetType() == PIVOTFIELDTYPE_SELECT ) |
| pSourceWindow->SelectNextField(); |
| // return focus to source window (if it is not empty) |
| GrabFieldFocus( pSourceWindow->IsEmpty() ? *pTargetWindow : *pSourceWindow ); |
| } |
| |
| mpActiveEdit = dynamic_cast< ::formula::RefEdit* >( pEvent->GetWindow() ); |
| } |
| return 0; |
| } |
| |
| // ============================================================================ |
