| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #if !TEST_LAYOUT |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| #endif /* !TEST_LAYOUT */ |
| |
| #undef SC_DLLIMPLEMENTATION |
| |
| |
| |
| #include <vcl/msgbox.hxx> |
| #include <i18npool/mslangid.hxx> |
| #include <svtools/collatorres.hxx> |
| #include <unotools/collatorwrapper.hxx> |
| #include <unotools/localedatawrapper.hxx> |
| #include <comphelper/processfactory.hxx> |
| |
| #include "scitems.hxx" |
| #include "uiitems.hxx" |
| #include "viewdata.hxx" |
| #include "document.hxx" |
| #include "global.hxx" |
| #include "dbcolect.hxx" |
| #include "userlist.hxx" |
| #include "rangeutl.hxx" |
| #include "scresid.hxx" |
| #include "sc.hrc" // -> Slot IDs |
| #include "globstr.hrc" |
| |
| #include "sortdlg.hxx" |
| #include "sortdlg.hrc" |
| |
| #define _TPSORT_CXX |
| #include "tpsort.hxx" |
| #undef _TPSORT_CXX |
| |
| using namespace com::sun::star; |
| |
| // STATIC DATA ----------------------------------------------------------- |
| |
| static USHORT pSortRanges[] = |
| { |
| SID_SORT, |
| SID_SORT, |
| 0 |
| }; |
| |
| // ----------------------------------------------------------------------- |
| |
| /* |
| * Da sich Einstellungen auf der zweiten TabPage (Optionen) auf |
| * die erste TabPage auswirken, muss es die Moeglichkeit geben, |
| * dies der jeweils anderen Seite mitzuteilen. |
| * |
| * Im Moment wird dieses Problem ueber zwei Datenmember des TabDialoges |
| * geloest. Wird eine Seite Aktiviert/Deaktiviert, so gleicht sie diese |
| * Datenmember mit dem eigenen Zustand ab (->Activate()/Deactivate()). |
| * |
| * 31.01.95: |
| * Die Klasse SfxTabPage bietet mittlerweile ein Verfahren an: |
| * |
| * virtual BOOL HasExchangeSupport() const; -> return TRUE; |
| * virtual void ActivatePage(const SfxItemSet &); |
| * virtual int DeactivatePage(SfxItemSet * = 0); |
| * |
| * muss noch geaendert werden! |
| */ |
| |
| //======================================================================== |
| //======================================================================== |
| // Sortierkriterien-Tabpage: |
| |
| ScTabPageSortFields::ScTabPageSortFields( Window* pParent, |
| const SfxItemSet& rArgSet ) |
| |
| : SfxTabPage ( pParent, |
| ScResId( RID_SCPAGE_SORT_FIELDS ), |
| rArgSet ), |
| // |
| aFlSort1 ( this, ScResId( FL_SORT1 ) ), |
| aLbSort1 ( this, ScResId( LB_SORT1 ) ), |
| aBtnUp1 ( this, ScResId( BTN_UP1 ) ), |
| aBtnDown1 ( this, ScResId( BTN_DOWN1 ) ), |
| // |
| aFlSort2 ( this, ScResId( FL_SORT2 ) ), |
| aLbSort2 ( this, ScResId( LB_SORT2 ) ), |
| aBtnUp2 ( this, ScResId( BTN_UP2 ) ), |
| aBtnDown2 ( this, ScResId( BTN_DOWN2 ) ), |
| // |
| aFlSort3 ( this, ScResId( FL_SORT3 ) ), |
| aLbSort3 ( this, ScResId( LB_SORT3 ) ), |
| aBtnUp3 ( this, ScResId( BTN_UP3 ) ), |
| aBtnDown3 ( this, ScResId( BTN_DOWN3 ) ), |
| |
| aStrUndefined ( ScResId( SCSTR_UNDEFINED ) ), |
| aStrColumn ( ScResId( SCSTR_COLUMN ) ), |
| aStrRow ( ScResId( SCSTR_ROW ) ), |
| // |
| #if !TEST_LAYOUT |
| nWhichSort ( rArgSet.GetPool()->GetWhich( SID_SORT ) ), |
| #else /* TEST_LAYOUT */ |
| nWhichSort ( 0 ), |
| #endif /* TEST_LAYOUT */ |
| pDlg ( (ScSortDlg*)(GetParent()->GetParent()) ), |
| pViewData ( NULL ), |
| #if !TEST_LAYOUT |
| rSortData ( ((const ScSortItem&) |
| rArgSet.Get( nWhichSort )). |
| GetSortData() ), |
| #else /* TEST_LAYOUT */ |
| rSortData ( *new ScSortParam() ), |
| #endif /* TEST_LAYOUT */ |
| nFieldCount ( 0 ), |
| bHasHeader ( FALSE ), |
| bSortByRows ( FALSE ) |
| { |
| Init(); |
| FreeResource(); |
| SetExchangeSupport(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| __EXPORT ScTabPageSortFields::~ScTabPageSortFields() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortFields::Init() |
| { |
| #if !TEST_LAYOUT |
| const ScSortItem& rSortItem = (const ScSortItem&) |
| GetItemSet().Get( nWhichSort ); |
| |
| pViewData = rSortItem.GetViewData(); |
| |
| DBG_ASSERT( pViewData, "ViewData not found!" ); |
| #endif /* !TEST_LAYOUT */ |
| |
| nFieldArr[0] = 0; |
| nFirstCol = 0; |
| nFirstRow = 0; |
| |
| aLbSort1.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) ); |
| aLbSort2.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) ); |
| aLbSort3.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) ); |
| aLbSort1.Clear(); |
| aLbSort2.Clear(); |
| aLbSort3.Clear(); |
| |
| aSortLbArr[0] = &aLbSort1; |
| aSortLbArr[1] = &aLbSort2; |
| aSortLbArr[2] = &aLbSort3; |
| aDirBtnArr[0][0] = &aBtnUp1; |
| aDirBtnArr[0][1] = &aBtnDown1; |
| aDirBtnArr[1][0] = &aBtnUp2; |
| aDirBtnArr[1][1] = &aBtnDown2; |
| aDirBtnArr[2][0] = &aBtnUp3; |
| aDirBtnArr[2][1] = &aBtnDown3; |
| aFlArr[0] = &aFlSort1; |
| aFlArr[1] = &aFlSort2; |
| aFlArr[2] = &aFlSort3; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| USHORT* __EXPORT ScTabPageSortFields::GetRanges() |
| { |
| return pSortRanges; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SfxTabPage* __EXPORT ScTabPageSortFields::Create( Window* pParent, |
| const SfxItemSet& rArgSet ) |
| { |
| return ( new ScTabPageSortFields( pParent, rArgSet ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void __EXPORT ScTabPageSortFields::Reset( const SfxItemSet& /* rArgSet */ ) |
| { |
| bSortByRows = rSortData.bByRow; |
| bHasHeader = rSortData.bHasHeader; |
| |
| if ( aLbSort1.GetEntryCount() == 0 ) |
| FillFieldLists(); |
| |
| // Selektieren der ListBoxen: |
| |
| if ( rSortData.bDoSort[0] ) |
| { |
| for ( USHORT i=0; i<3; i++ ) |
| { |
| if ( rSortData.bDoSort[i] ) |
| { |
| aSortLbArr[i]->SelectEntryPos( |
| GetFieldSelPos( rSortData.nField[i] ) ); |
| |
| (rSortData.bAscending[i]) |
| ? aDirBtnArr[i][0]->Check() // Up |
| : aDirBtnArr[i][1]->Check(); // Down |
| } |
| else |
| { |
| aSortLbArr[i]->SelectEntryPos( 0 ); // "keiner" selektieren |
| aDirBtnArr[i][0]->Check(); // Up |
| } |
| } |
| |
| EnableField( 1 ); |
| EnableField( 2 ); |
| EnableField( 3 ); |
| if ( aLbSort1.GetSelectEntryPos() == 0 ) |
| DisableField( 2 ); |
| if ( aLbSort2.GetSelectEntryPos() == 0 ) |
| DisableField( 3 ); |
| } |
| else |
| { |
| aLbSort1.SelectEntryPos( 1 ); |
| aLbSort2.SelectEntryPos( 0 ); |
| aLbSort3.SelectEntryPos( 0 ); |
| aBtnUp1.Check(); |
| aBtnUp2.Check(); |
| aBtnUp3.Check(); |
| EnableField ( 1 ); |
| EnableField ( 2 ); |
| DisableField( 3 ); |
| } |
| |
| if ( pDlg ) |
| { |
| pDlg->SetByRows ( bSortByRows ); |
| pDlg->SetHeaders( bHasHeader ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| BOOL __EXPORT ScTabPageSortFields::FillItemSet( SfxItemSet& rArgSet ) |
| { |
| ScSortParam theSortData = rSortData; |
| if (pDlg) |
| { |
| const SfxItemSet* pExample = pDlg->GetExampleSet(); |
| const SfxPoolItem* pItem; |
| if ( pExample && pExample->GetItemState( nWhichSort, TRUE, &pItem ) == SFX_ITEM_SET ) |
| theSortData = ((const ScSortItem*)pItem)->GetSortData(); |
| } |
| |
| USHORT nSort1Pos = aLbSort1.GetSelectEntryPos(); |
| USHORT nSort2Pos = aLbSort2.GetSelectEntryPos(); |
| USHORT nSort3Pos = aLbSort3.GetSelectEntryPos(); |
| |
| DBG_ASSERT( (nSort1Pos <= SC_MAXFIELDS) |
| && (nSort2Pos <= SC_MAXFIELDS) |
| && (nSort3Pos <= SC_MAXFIELDS), |
| "Array-Range Fehler!" ); |
| |
| if ( nSort1Pos == LISTBOX_ENTRY_NOTFOUND ) nSort1Pos = 0; |
| if ( nSort2Pos == LISTBOX_ENTRY_NOTFOUND ) nSort2Pos = 0; |
| if ( nSort3Pos == LISTBOX_ENTRY_NOTFOUND ) nSort3Pos = 0; |
| |
| if ( nSort1Pos > 0 ) |
| { |
| theSortData.bDoSort[0] = (nSort1Pos > 0); |
| theSortData.bDoSort[1] = (nSort2Pos > 0); |
| theSortData.bDoSort[2] = (nSort3Pos > 0); |
| |
| // wenn auf Optionen-Seite "OK" gewaehlt wurde und |
| // dabei die Sortierrichtung umgestellt wurde, so |
| // wird das erste Feld der jeweiligen Richtung als |
| // Sortierkriterium gewaehlt (steht in nFieldArr[0]): |
| if ( bSortByRows != pDlg->GetByRows() ) |
| { |
| theSortData.nField[0] = |
| theSortData.nField[1] = |
| theSortData.nField[2] = ( bSortByRows ? |
| static_cast<SCCOLROW>(nFirstRow) : |
| static_cast<SCCOLROW>(nFirstCol) ); |
| } |
| else |
| { |
| theSortData.nField[0] = nFieldArr[nSort1Pos]; |
| theSortData.nField[1] = nFieldArr[nSort2Pos]; |
| theSortData.nField[2] = nFieldArr[nSort3Pos]; |
| } |
| |
| theSortData.bAscending[0] = aBtnUp1.IsChecked(); |
| theSortData.bAscending[1] = aBtnUp2.IsChecked(); |
| theSortData.bAscending[2] = aBtnUp3.IsChecked(); |
| // bHasHeader ist in ScTabPageSortOptions::FillItemSet, wo es hingehoert |
| } |
| else |
| { |
| theSortData.bDoSort[0] = |
| theSortData.bDoSort[1] = |
| theSortData.bDoSort[2] = FALSE; |
| } |
| |
| rArgSet.Put( ScSortItem( SCITEM_SORTDATA, NULL, &theSortData ) ); |
| |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| // fuer Datenaustausch ohne Dialog-Umweg: (! noch zu tun !) |
| // void ScTabPageSortFields::ActivatePage( const SfxItemSet& rSet ) |
| |
| void __EXPORT ScTabPageSortFields::ActivatePage() |
| { |
| if ( pDlg ) |
| { |
| if ( bHasHeader != pDlg->GetHeaders() |
| || bSortByRows != pDlg->GetByRows() ) |
| { |
| USHORT nCurSel1 = aLbSort1.GetSelectEntryPos(); |
| USHORT nCurSel2 = aLbSort2.GetSelectEntryPos(); |
| USHORT nCurSel3 = aLbSort3.GetSelectEntryPos(); |
| |
| bHasHeader = pDlg->GetHeaders(); |
| bSortByRows = pDlg->GetByRows(); |
| FillFieldLists(); |
| aLbSort1.SelectEntryPos( nCurSel1 ); |
| aLbSort2.SelectEntryPos( nCurSel2 ); |
| aLbSort3.SelectEntryPos( nCurSel3 ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int __EXPORT ScTabPageSortFields::DeactivatePage( SfxItemSet* pSetP ) |
| { |
| if ( pDlg ) |
| { |
| if ( bHasHeader != pDlg->GetHeaders() ) |
| pDlg->SetHeaders( bHasHeader ); |
| |
| if ( bSortByRows != pDlg->GetByRows() ) |
| pDlg->SetByRows( bSortByRows ); |
| } |
| |
| if ( pSetP ) |
| FillItemSet( *pSetP ); |
| |
| return SfxTabPage::LEAVE_PAGE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortFields::DisableField( USHORT nField ) |
| { |
| nField--; |
| |
| if ( nField<=2 ) |
| { |
| aSortLbArr[nField] ->Disable(); |
| aDirBtnArr[nField][0]->Disable(); |
| aDirBtnArr[nField][1]->Disable(); |
| aFlArr[nField] ->Disable(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortFields::EnableField( USHORT nField ) |
| { |
| nField--; |
| |
| if ( nField<=2 ) |
| { |
| aSortLbArr[nField] ->Enable(); |
| aDirBtnArr[nField][0]->Enable(); |
| aDirBtnArr[nField][1]->Enable(); |
| aFlArr[nField] ->Enable(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortFields::FillFieldLists() |
| { |
| if ( pViewData ) |
| { |
| ScDocument* pDoc = pViewData->GetDocument(); |
| |
| if ( pDoc ) |
| { |
| aLbSort1.Clear(); |
| aLbSort2.Clear(); |
| aLbSort3.Clear(); |
| aLbSort1.InsertEntry( aStrUndefined, 0 ); |
| aLbSort2.InsertEntry( aStrUndefined, 0 ); |
| aLbSort3.InsertEntry( aStrUndefined, 0 ); |
| |
| SCCOL nFirstSortCol = rSortData.nCol1; |
| SCROW nFirstSortRow = rSortData.nRow1; |
| SCTAB nTab = pViewData->GetTabNo(); |
| USHORT i = 1; |
| |
| if ( bSortByRows ) |
| { |
| String aFieldName; |
| SCCOL nMaxCol = rSortData.nCol2; |
| SCCOL col; |
| |
| for ( col=nFirstSortCol; col<=nMaxCol && i<SC_MAXFIELDS; col++ ) |
| { |
| pDoc->GetString( col, nFirstSortRow, nTab, aFieldName ); |
| if ( !bHasHeader || (aFieldName.Len() == 0) ) |
| { |
| aFieldName = aStrColumn; |
| aFieldName += ' '; |
| aFieldName += ColToAlpha( col ); |
| } |
| nFieldArr[i] = col; |
| aLbSort1.InsertEntry( aFieldName, i ); |
| aLbSort2.InsertEntry( aFieldName, i ); |
| aLbSort3.InsertEntry( aFieldName, i ); |
| i++; |
| } |
| } |
| else |
| { |
| String aFieldName; |
| SCROW nMaxRow = rSortData.nRow2; |
| SCROW row; |
| |
| for ( row=nFirstSortRow; row<=nMaxRow && i<SC_MAXFIELDS; row++ ) |
| { |
| pDoc->GetString( nFirstSortCol, row, nTab, aFieldName ); |
| if ( !bHasHeader || (aFieldName.Len() == 0) ) |
| { |
| aFieldName = aStrRow; |
| aFieldName += ' '; |
| aFieldName += String::CreateFromInt32( row+1 ); |
| } |
| nFieldArr[i] = row; |
| aLbSort1.InsertEntry( aFieldName, i ); |
| aLbSort2.InsertEntry( aFieldName, i ); |
| aLbSort3.InsertEntry( aFieldName, i ); |
| i++; |
| } |
| } |
| nFieldCount = i; |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| USHORT ScTabPageSortFields::GetFieldSelPos( SCCOLROW nField ) |
| { |
| USHORT nFieldPos = 0; |
| BOOL bFound = FALSE; |
| |
| for ( USHORT n=1; n<nFieldCount && !bFound; n++ ) |
| { |
| if ( nFieldArr[n] == nField ) |
| { |
| nFieldPos = n; |
| bFound = TRUE; |
| } |
| } |
| |
| return nFieldPos; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Handler: |
| //--------- |
| |
| IMPL_LINK( ScTabPageSortFields, SelectHdl, ListBox *, pLb ) |
| { |
| String aSelEntry = pLb->GetSelectEntry(); |
| |
| if ( pLb == &aLbSort1 ) |
| { |
| if ( aSelEntry == aStrUndefined ) |
| { |
| aLbSort2.SelectEntryPos( 0 ); |
| aLbSort3.SelectEntryPos( 0 ); |
| |
| if ( aFlSort2.IsEnabled() ) |
| DisableField( 2 ); |
| |
| if ( aFlSort3.IsEnabled() ) |
| DisableField( 3 ); |
| } |
| else |
| { |
| if ( !aFlSort2.IsEnabled() ) |
| EnableField( 2 ); |
| } |
| } |
| else if ( pLb == &aLbSort2 ) |
| { |
| if ( aSelEntry == aStrUndefined ) |
| { |
| aLbSort3.SelectEntryPos( 0 ); |
| if ( aFlSort3.IsEnabled() ) |
| DisableField( 3 ); |
| } |
| else |
| { |
| if ( !aFlSort3.IsEnabled() ) |
| EnableField( 3 ); |
| } |
| } |
| return 0; |
| } |
| |
| //======================================================================== |
| // Sortieroptionen-Tabpage: |
| //======================================================================== |
| |
| #include <layout/layout-pre.hxx> |
| |
| #if ENABLE_LAYOUT |
| #undef ScResId |
| #define ScResId(x) #x |
| #undef SfxTabPage |
| #define SfxTabPage( parent, id, args ) SfxTabPage( parent, "sort-options.xml", id, &args ) |
| #endif /* ENABLE_LAYOUT */ |
| |
| ScTabPageSortOptions::ScTabPageSortOptions( Window* pParent, |
| const SfxItemSet& rArgSet ) |
| |
| : SfxTabPage ( pParent, |
| ScResId( RID_SCPAGE_SORT_OPTIONS ), |
| rArgSet ), |
| // |
| aBtnCase ( this, ScResId( BTN_CASESENSITIVE ) ), |
| aBtnHeader ( this, ScResId( BTN_LABEL ) ), |
| aBtnFormats ( this, ScResId( BTN_FORMATS ) ), |
| aBtnCopyResult ( this, ScResId( BTN_COPYRESULT ) ), |
| aBtnNaturalSort ( this, ScResId( BTN_NATURALSORT ) ), |
| aLbOutPos ( this, ScResId( LB_OUTAREA ) ), |
| aEdOutPos ( this, ScResId( ED_OUTAREA ) ), |
| aBtnSortUser ( this, ScResId( BTN_SORT_USER ) ), |
| aLbSortUser ( this, ScResId( LB_SORT_USER ) ), |
| aFtLanguage ( this, ScResId( FT_LANGUAGE ) ), |
| aLbLanguage ( this, ScResId( LB_LANGUAGE ) ), |
| aFtAlgorithm ( this, ScResId( FT_ALGORITHM ) ), |
| aLbAlgorithm ( this, ScResId( LB_ALGORITHM ) ), |
| aLineDirection ( this, ScResId( FL_DIRECTION ) ), |
| aBtnTopDown ( this, ScResId( BTN_TOP_DOWN ) ), |
| aBtnLeftRight ( this, ScResId( BTN_LEFT_RIGHT ) ), |
| // aFtAreaLabel ( this, ScResId( FT_AREA_LABEL ) ), |
| // aFtArea ( this, ScResId( FT_AREA ) ), |
| // |
| #if ENABLE_LAYOUT |
| #undef this |
| #undef ScResId |
| #define ScResId(x) this, #x |
| #endif /* ENABLE_LAYOUT */ |
| aStrRowLabel ( ScResId( STR_ROW_LABEL ) ), |
| aStrColLabel ( ScResId( STR_COL_LABEL ) ), |
| aStrUndefined ( ScResId( SCSTR_UNDEFINED ) ), |
| aStrNoName ( ScGlobal::GetRscString(STR_DB_NONAME) ), |
| // |
| #if !TEST_LAYOUT |
| nWhichSort ( rArgSet.GetPool()->GetWhich( SID_SORT ) ), |
| rSortData ( ((const ScSortItem&) |
| rArgSet.Get( nWhichSort )).GetSortData() ), |
| #else /* TEST_LAYOUT */ |
| nWhichSort ( 0 ), |
| rSortData ( *new ScSortParam() ), |
| #endif /* TEST_LAYOUT */ |
| pViewData ( NULL ), |
| pDoc ( NULL ), |
| pDlg ( (ScSortDlg*)(GetParent() ? GetParent()->GetParent() : 0 ) ), |
| pColRes ( NULL ), |
| pColWrap ( NULL ) |
| { |
| #if TEST_LAYOUT |
| (void) rArgSet; |
| #endif /* TEST_LAYOUT */ |
| Init(); |
| FreeResource(); |
| SetExchangeSupport(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| __EXPORT ScTabPageSortOptions::~ScTabPageSortOptions() |
| { |
| #if !TEST_LAYOUT |
| USHORT nEntries = aLbOutPos.GetEntryCount(); |
| |
| for ( USHORT i=1; i<nEntries; i++ ) |
| delete (String*)aLbOutPos.GetEntryData( i ); |
| #endif /* !TEST_LAYOUT */ |
| |
| delete pColRes; |
| delete pColWrap; //! not if from document |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortOptions::Init() |
| { |
| // aStrAreaLabel = aFtAreaLabel.GetText(); |
| // aStrAreaLabel.Append( (sal_Unicode) ' ' ); |
| |
| // CollatorRessource has user-visible names for sort algorithms |
| pColRes = new CollatorRessource(); |
| |
| //! use CollatorWrapper from document? |
| pColWrap = new CollatorWrapper( comphelper::getProcessServiceFactory() ); |
| |
| #if !TEST_LAYOUT |
| const ScSortItem& rSortItem = (const ScSortItem&) |
| GetItemSet().Get( nWhichSort ); |
| #endif /* !TEST_LAYOUT */ |
| |
| aLbOutPos.SetSelectHdl ( LINK( this, ScTabPageSortOptions, SelOutPosHdl ) ); |
| aBtnCopyResult.SetClickHdl( LINK( this, ScTabPageSortOptions, EnableHdl ) ); |
| aBtnSortUser.SetClickHdl ( LINK( this, ScTabPageSortOptions, EnableHdl ) ); |
| aBtnTopDown.SetClickHdl ( LINK( this, ScTabPageSortOptions, SortDirHdl ) ); |
| aBtnLeftRight.SetClickHdl ( LINK( this, ScTabPageSortOptions, SortDirHdl ) ); |
| aLbLanguage.SetSelectHdl ( LINK( this, ScTabPageSortOptions, FillAlgorHdl ) ); |
| |
| #if !TEST_LAYOUT |
| pViewData = rSortItem.GetViewData(); |
| #endif /* TEST_LAYOUT */ |
| pDoc = pViewData ? pViewData->GetDocument() : NULL; |
| |
| DBG_ASSERT( pViewData, "ViewData not found! :-/" ); |
| |
| #if !TEST_LAYOUT |
| if ( pViewData && pDoc ) |
| { |
| String theArea; |
| ScDBCollection* pDBColl = pDoc->GetDBCollection(); |
| String theDbArea; |
| String theDbName = aStrNoName; |
| const SCTAB nCurTab = pViewData->GetTabNo(); |
| const ScAddress::Convention eConv = pDoc->GetAddressConvention(); |
| #endif /* !TEST_LAYOUT */ |
| |
| aLbOutPos.Clear(); |
| aLbOutPos.InsertEntry( aStrUndefined, 0 ); |
| aLbOutPos.Disable(); |
| |
| #if !TEST_LAYOUT |
| ScAreaNameIterator aIter( pDoc ); |
| String aName; |
| ScRange aRange; |
| String aRefStr; |
| while ( aIter.Next( aName, aRange ) ) |
| { |
| USHORT nInsert = aLbOutPos.InsertEntry( aName ); |
| |
| aRange.aStart.Format( aRefStr, SCA_ABS_3D, pDoc, eConv ); |
| aLbOutPos.SetEntryData( nInsert, new String( aRefStr ) ); |
| } |
| #endif /* !TEST_LAYOUT */ |
| |
| aLbOutPos.SelectEntryPos( 0 ); |
| aEdOutPos.SetText( EMPTY_STRING ); |
| |
| #if !TEST_LAYOUT |
| /* |
| * Ueberpruefen, ob es sich bei dem uebergebenen |
| * Bereich um einen Datenbankbereich handelt: |
| */ |
| |
| ScAddress aScAddress( rSortData.nCol1, rSortData.nRow1, nCurTab ); |
| ScRange( aScAddress, |
| ScAddress( rSortData.nCol2, rSortData.nRow2, nCurTab ) |
| ).Format( theArea, SCR_ABS, pDoc, eConv ); |
| |
| if ( pDBColl ) |
| { |
| ScDBData* pDBData |
| = pDBColl->GetDBAtArea( nCurTab, |
| rSortData.nCol1, rSortData.nRow1, |
| rSortData.nCol2, rSortData.nRow2 ); |
| if ( pDBData ) |
| { |
| pDBData->GetName( theDbName ); |
| aBtnHeader.Check( pDBData->HasHeader() ); |
| } |
| } |
| |
| theArea.AppendAscii(RTL_CONSTASCII_STRINGPARAM(" (")); |
| theArea += theDbName; |
| theArea += ')'; |
| |
| //aFtArea.SetText( theArea ); |
| //theArea.Insert( aStrAreaLabel, 0 ); |
| //aFtAreaLabel.SetText( theArea ); |
| |
| aBtnHeader.SetText( aStrColLabel ); |
| } |
| #endif /* TEST_LAYOUT */ |
| |
| FillUserSortListBox(); |
| |
| // get available languages |
| |
| aLbLanguage.SetLanguageList( LANG_LIST_ALL | LANG_LIST_ONLY_KNOWN, FALSE ); |
| aLbLanguage.InsertLanguage( LANGUAGE_SYSTEM ); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| USHORT* __EXPORT ScTabPageSortOptions::GetRanges() |
| { |
| return pSortRanges; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| #if ENABLE_LAYOUT |
| #undef SfxTabPage |
| #endif /* ENABLE_LAYOUT */ |
| SfxTabPage* __EXPORT ScTabPageSortOptions::Create( |
| Window* pParent, |
| const SfxItemSet& rArgSet ) |
| { |
| return ( new ScTabPageSortOptions( pParent, rArgSet ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void __EXPORT ScTabPageSortOptions::Reset( const SfxItemSet& /* rArgSet */ ) |
| { |
| if ( rSortData.bUserDef ) |
| { |
| aBtnSortUser.Check( TRUE ); |
| aLbSortUser.Enable(); |
| aLbSortUser.SelectEntryPos( rSortData.nUserIndex ); |
| } |
| else |
| { |
| aBtnSortUser.Check( FALSE ); |
| aLbSortUser.Disable(); |
| aLbSortUser.SelectEntryPos( 0 ); |
| } |
| |
| aBtnCase.Check ( rSortData.bCaseSens ); |
| aBtnFormats.Check ( rSortData.bIncludePattern ); |
| aBtnHeader.Check ( rSortData.bHasHeader ); |
| aBtnNaturalSort.Check ( rSortData.bNaturalSort ); |
| |
| if ( rSortData.bByRow ) |
| { |
| aBtnTopDown.Check(); |
| aBtnHeader.SetText( aStrColLabel ); |
| } |
| else |
| { |
| aBtnLeftRight.Check(); |
| aBtnHeader.SetText( aStrRowLabel ); |
| } |
| |
| LanguageType eLang = MsLangId::convertLocaleToLanguage( rSortData.aCollatorLocale ); |
| if ( eLang == LANGUAGE_DONTKNOW ) |
| eLang = LANGUAGE_SYSTEM; |
| aLbLanguage.SelectLanguage( eLang ); |
| FillAlgorHdl( &aLbLanguage ); // get algorithms, select default |
| if ( rSortData.aCollatorAlgorithm.Len() ) |
| aLbAlgorithm.SelectEntry( pColRes->GetTranslation( rSortData.aCollatorAlgorithm ) ); |
| |
| if ( pDoc && !rSortData.bInplace ) |
| { |
| String aStr; |
| USHORT nFormat = (rSortData.nDestTab != pViewData->GetTabNo()) |
| ? SCR_ABS_3D |
| : SCR_ABS; |
| |
| theOutPos.Set( rSortData.nDestCol, |
| rSortData.nDestRow, |
| rSortData.nDestTab ); |
| |
| theOutPos.Format( aStr, nFormat, pDoc, pDoc->GetAddressConvention() ); |
| aBtnCopyResult.Check(); |
| aLbOutPos.Enable(); |
| aEdOutPos.Enable(); |
| aEdOutPos.SetText( aStr ); |
| EdOutPosModHdl( &aEdOutPos ); |
| aEdOutPos.GrabFocus(); |
| aEdOutPos.SetSelection( Selection( 0, SELECTION_MAX ) ); |
| } |
| else |
| { |
| aBtnCopyResult.Check( FALSE ); |
| aLbOutPos.Disable(); |
| aEdOutPos.Disable(); |
| aEdOutPos.SetText( EMPTY_STRING ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| BOOL __EXPORT ScTabPageSortOptions::FillItemSet( SfxItemSet& rArgSet ) |
| { |
| ScSortParam theSortData = rSortData; |
| if (pDlg) |
| { |
| const SfxItemSet* pExample = pDlg->GetExampleSet(); |
| const SfxPoolItem* pItem; |
| if ( pExample && pExample->GetItemState( nWhichSort, TRUE, &pItem ) == SFX_ITEM_SET ) |
| theSortData = ((const ScSortItem*)pItem)->GetSortData(); |
| } |
| |
| theSortData.bByRow = aBtnTopDown.IsChecked(); |
| theSortData.bHasHeader = aBtnHeader.IsChecked(); |
| theSortData.bCaseSens = aBtnCase.IsChecked(); |
| theSortData.bNaturalSort = aBtnNaturalSort.IsChecked(); |
| theSortData.bIncludePattern = aBtnFormats.IsChecked(); |
| theSortData.bInplace = !aBtnCopyResult.IsChecked(); |
| theSortData.nDestCol = theOutPos.Col(); |
| theSortData.nDestRow = theOutPos.Row(); |
| theSortData.nDestTab = theOutPos.Tab(); |
| theSortData.bUserDef = aBtnSortUser.IsChecked(); |
| theSortData.nUserIndex = (aBtnSortUser.IsChecked()) |
| ? aLbSortUser.GetSelectEntryPos() |
| : 0; |
| |
| // get locale |
| LanguageType eLang = aLbLanguage.GetSelectLanguage(); |
| theSortData.aCollatorLocale = MsLangId::convertLanguageToLocale( eLang, false ); |
| |
| // get algorithm |
| String sAlg; |
| if ( eLang != LANGUAGE_SYSTEM ) |
| { |
| uno::Sequence<rtl::OUString> aAlgos = pColWrap->listCollatorAlgorithms( |
| theSortData.aCollatorLocale ); |
| USHORT nSel = aLbAlgorithm.GetSelectEntryPos(); |
| if ( nSel < aAlgos.getLength() ) |
| sAlg = aAlgos[nSel]; |
| } |
| theSortData.aCollatorAlgorithm = sAlg; |
| |
| #if !TEST_LAYOUT |
| rArgSet.Put( ScSortItem( SCITEM_SORTDATA, &theSortData ) ); |
| #endif /* TEST_LAYOUT */ |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| // fuer Datenaustausch ohne Dialog-Umweg: (! noch zu tun !) |
| // void ScTabPageSortOptions::ActivatePage( const SfxItemSet& rSet ) |
| void __EXPORT ScTabPageSortOptions::ActivatePage() |
| { |
| if ( pDlg ) |
| { |
| if ( aBtnHeader.IsChecked() != pDlg->GetHeaders() ) |
| { |
| aBtnHeader.Check( pDlg->GetHeaders() ); |
| } |
| |
| if ( aBtnTopDown.IsChecked() != pDlg->GetByRows() ) |
| { |
| aBtnTopDown.Check( pDlg->GetByRows() ); |
| aBtnLeftRight.Check( !pDlg->GetByRows() ); |
| } |
| |
| aBtnHeader.SetText( (pDlg->GetByRows()) |
| ? aStrColLabel |
| : aStrRowLabel ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int __EXPORT ScTabPageSortOptions::DeactivatePage( SfxItemSet* pSetP ) |
| { |
| BOOL bPosInputOk = TRUE; |
| |
| if ( aBtnCopyResult.IsChecked() ) |
| { |
| String thePosStr = aEdOutPos.GetText(); |
| ScAddress thePos; |
| xub_StrLen nColonPos = thePosStr.Search( ':' ); |
| |
| if ( STRING_NOTFOUND != nColonPos ) |
| thePosStr.Erase( nColonPos ); |
| |
| if ( pViewData ) |
| { |
| // visible table is default for input without table |
| // must be changed to GetRefTabNo when sorting has RefInput! |
| thePos.SetTab( pViewData->GetTabNo() ); |
| } |
| |
| USHORT nResult = thePos.Parse( thePosStr, pDoc, pDoc->GetAddressConvention() ); |
| |
| bPosInputOk = ( SCA_VALID == (nResult & SCA_VALID) ); |
| |
| if ( !bPosInputOk ) |
| { |
| #if !ENABLE_LAYOUT |
| ErrorBox( this, WinBits( WB_OK | WB_DEF_OK ), |
| ScGlobal::GetRscString( STR_INVALID_TABREF ) |
| ).Execute(); |
| #endif /* ENABLE_LAYOUT */ |
| aEdOutPos.GrabFocus(); |
| aEdOutPos.SetSelection( Selection( 0, SELECTION_MAX ) ); |
| theOutPos.Set(0,0,0); |
| } |
| else |
| { |
| aEdOutPos.SetText( thePosStr ); |
| theOutPos = thePos; |
| } |
| } |
| |
| if ( pDlg && bPosInputOk ) |
| { |
| pDlg->SetHeaders( aBtnHeader.IsChecked() ); |
| pDlg->SetByRows ( aBtnTopDown.IsChecked() ); |
| } |
| |
| if ( pSetP && bPosInputOk ) |
| FillItemSet( *pSetP ); |
| |
| return bPosInputOk ? SfxTabPage::LEAVE_PAGE : SfxTabPage::KEEP_PAGE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void ScTabPageSortOptions::FillUserSortListBox() |
| { |
| ScUserList* pUserLists = ScGlobal::GetUserList(); |
| |
| aLbSortUser.Clear(); |
| if ( pUserLists ) |
| { |
| USHORT nCount = pUserLists->GetCount(); |
| if ( nCount > 0 ) |
| for ( USHORT i=0; i<nCount; i++ ) |
| aLbSortUser.InsertEntry( (*pUserLists)[i]->GetString() ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Handler: |
| |
| IMPL_LINK( ScTabPageSortOptions, EnableHdl, CheckBox *, pBox ) |
| { |
| if ( pBox == &aBtnCopyResult ) |
| { |
| if ( pBox->IsChecked() ) |
| { |
| aLbOutPos.Enable(); |
| aEdOutPos.Enable(); |
| aEdOutPos.GrabFocus(); |
| } |
| else |
| { |
| aLbOutPos.Disable(); |
| aEdOutPos.Disable(); |
| } |
| } |
| else if ( pBox == &aBtnSortUser ) |
| { |
| if ( pBox->IsChecked() ) |
| { |
| aLbSortUser.Enable(); |
| aLbSortUser.GrabFocus(); |
| } |
| else |
| aLbSortUser.Disable(); |
| } |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( ScTabPageSortOptions, SelOutPosHdl, ListBox *, pLb ) |
| { |
| if ( pLb == &aLbOutPos ) |
| { |
| String aString; |
| USHORT nSelPos = aLbOutPos.GetSelectEntryPos(); |
| |
| if ( nSelPos > 0 ) |
| aString = *(String*)aLbOutPos.GetEntryData( nSelPos ); |
| |
| aEdOutPos.SetText( aString ); |
| } |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( ScTabPageSortOptions, SortDirHdl, RadioButton *, pBtn ) |
| { |
| if ( pBtn == &aBtnTopDown ) |
| { |
| aBtnHeader.SetText( aStrColLabel ); |
| } |
| else if ( pBtn == &aBtnLeftRight ) |
| { |
| aBtnHeader.SetText( aStrRowLabel ); |
| } |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void __EXPORT ScTabPageSortOptions::EdOutPosModHdl( Edit* pEd ) |
| { |
| if ( pEd == &aEdOutPos ) |
| { |
| String theCurPosStr = aEdOutPos.GetText(); |
| USHORT nResult = ScAddress().Parse( theCurPosStr, pDoc, pDoc->GetAddressConvention() ); |
| |
| if ( SCA_VALID == (nResult & SCA_VALID) ) |
| { |
| String* pStr = NULL; |
| BOOL bFound = FALSE; |
| USHORT i = 0; |
| USHORT nCount = aLbOutPos.GetEntryCount(); |
| |
| for ( i=2; i<nCount && !bFound; i++ ) |
| { |
| pStr = (String*)aLbOutPos.GetEntryData( i ); |
| bFound = (theCurPosStr == *pStr); |
| } |
| |
| if ( bFound ) |
| aLbOutPos.SelectEntryPos( --i ); |
| else |
| aLbOutPos.SelectEntryPos( 0 ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( ScTabPageSortOptions, FillAlgorHdl, void *, EMPTYARG ) |
| { |
| aLbAlgorithm.SetUpdateMode( FALSE ); |
| aLbAlgorithm.Clear(); |
| |
| LanguageType eLang = aLbLanguage.GetSelectLanguage(); |
| if ( eLang == LANGUAGE_SYSTEM ) |
| { |
| // for LANGUAGE_SYSTEM no algorithm can be selected because |
| // it wouldn't necessarily exist for other languages |
| // -> leave list box empty if LANGUAGE_SYSTEM is selected |
| aFtAlgorithm.Enable( FALSE ); // nothing to select |
| aLbAlgorithm.Enable( FALSE ); // nothing to select |
| } |
| else |
| { |
| lang::Locale aLocale( MsLangId::convertLanguageToLocale( eLang )); |
| uno::Sequence<rtl::OUString> aAlgos = pColWrap->listCollatorAlgorithms( aLocale ); |
| |
| long nCount = aAlgos.getLength(); |
| const rtl::OUString* pArray = aAlgos.getConstArray(); |
| for (long i=0; i<nCount; i++) |
| { |
| String sAlg = pArray[i]; |
| String sUser = pColRes->GetTranslation( sAlg ); |
| aLbAlgorithm.InsertEntry( sUser, LISTBOX_APPEND ); |
| } |
| aLbAlgorithm.SelectEntryPos( 0 ); // first entry is default |
| aFtAlgorithm.Enable( nCount > 1 ); // enable only if there is a choice |
| aLbAlgorithm.Enable( nCount > 1 ); // enable only if there is a choice |
| } |
| |
| aLbAlgorithm.SetUpdateMode( TRUE ); |
| return 0; |
| } |
| |
| |