?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m57
[ooovba.git] / sc / source / ui / dbgui / tpsort.cxx
blobd06627a8dca760bd646a174f1396a92b66920b77
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: tpsort.cxx,v $
10 * $Revision: 1.14 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34 #undef SC_DLLIMPLEMENTATION
35
36
37
38 #include <vcl/msgbox.hxx>
39 #include <i18npool/mslangid.hxx>
40 #include <svtools/collatorres.hxx>
41 #include <unotools/collatorwrapper.hxx>
42 #include <unotools/localedatawrapper.hxx>
43 #include <comphelper/processfactory.hxx>
44
45 #include "scitems.hxx"
46 #include "uiitems.hxx"
47 #include "viewdata.hxx"
48 #include "document.hxx"
49 #include "global.hxx"
50 #include "dbcolect.hxx"
51 #include "userlist.hxx"
52 #include "rangeutl.hxx"
53 #include "scresid.hxx"
54 #include "sc.hrc" // -> Slot IDs
55 #include "globstr.hrc"
56
57 #include "sortdlg.hxx"
58 #include "sortdlg.hrc"
59
60 #define _TPSORT_CXX
61 #include "tpsort.hxx"
62 #undef _TPSORT_CXX
63
64 using namespace com::sun::star;
65
66 // STATIC DATA -----------------------------------------------------------
67
68 static USHORT pSortRanges[] =
69 {
70 SID_SORT,
71 SID_SORT,
72 0
73 };
74
75 // -----------------------------------------------------------------------
76
77 /*
78 * Da sich Einstellungen auf der zweiten TabPage (Optionen) auf
79 * die erste TabPage auswirken, muss es die Moeglichkeit geben,
80 * dies der jeweils anderen Seite mitzuteilen.
81 *
82 * Im Moment wird dieses Problem ueber zwei Datenmember des TabDialoges
83 * geloest. Wird eine Seite Aktiviert/Deaktiviert, so gleicht sie diese
84 * Datenmember mit dem eigenen Zustand ab (->Activate()/Deactivate()).
85 *
86 * 31.01.95:
87 * Die Klasse SfxTabPage bietet mittlerweile ein Verfahren an:
88 *
89 * virtual BOOL HasExchangeSupport() const; -> return TRUE;
90 * virtual void ActivatePage(const SfxItemSet &);
91 * virtual int DeactivatePage(SfxItemSet * = 0);
92 *
93 * muss noch geaendert werden!
94 */
95
96 //========================================================================
97 //========================================================================
98 // Sortierkriterien-Tabpage:
99
100 ScTabPageSortFields::ScTabPageSortFields( Window* pParent,
101 const SfxItemSet& rArgSet )
102
103 : SfxTabPage ( pParent,
104 ScResId( RID_SCPAGE_SORT_FIELDS ),
105 rArgSet ),
106 //
107 aFlSort1 ( this, ScResId( FL_SORT1 ) ),
108 aLbSort1 ( this, ScResId( LB_SORT1 ) ),
109 aBtnUp1 ( this, ScResId( BTN_UP1 ) ),
110 aBtnDown1 ( this, ScResId( BTN_DOWN1 ) ),
111 //
112 aFlSort2 ( this, ScResId( FL_SORT2 ) ),
113 aLbSort2 ( this, ScResId( LB_SORT2 ) ),
114 aBtnUp2 ( this, ScResId( BTN_UP2 ) ),
115 aBtnDown2 ( this, ScResId( BTN_DOWN2 ) ),
116 //
117 aFlSort3 ( this, ScResId( FL_SORT3 ) ),
118 aLbSort3 ( this, ScResId( LB_SORT3 ) ),
119 aBtnUp3 ( this, ScResId( BTN_UP3 ) ),
120 aBtnDown3 ( this, ScResId( BTN_DOWN3 ) ),
121
122 aStrUndefined ( ScResId( SCSTR_UNDEFINED ) ),
123 aStrColumn ( ScResId( SCSTR_COLUMN ) ),
124 aStrRow ( ScResId( SCSTR_ROW ) ),
125 //
126 nWhichSort ( rArgSet.GetPool()->GetWhich( SID_SORT ) ),
127 pDlg ( (ScSortDlg*)(GetParent()->GetParent()) ),
128 pViewData ( NULL ),
129 rSortData ( ((const ScSortItem&)
130 rArgSet.Get( nWhichSort )).
131 GetSortData() ),
132 nFieldCount ( 0 ),
133 bHasHeader ( FALSE ),
134 bSortByRows ( FALSE )
135 {
136 Init();
137 FreeResource();
138 SetExchangeSupport();
139 }
140
141 // -----------------------------------------------------------------------
142
143 __EXPORT ScTabPageSortFields::~ScTabPageSortFields()
144 {
145 }
146
147 // -----------------------------------------------------------------------
148
149 void ScTabPageSortFields::Init()
150 {
151 const ScSortItem& rSortItem = (const ScSortItem&)
152 GetItemSet().Get( nWhichSort );
153
154 pViewData = rSortItem.GetViewData();
155
156 DBG_ASSERT( pViewData, "ViewData not found!" );
157
158 nFieldArr[0] = 0;
159 nFirstCol = 0;
160 nFirstRow = 0;
161
162 aLbSort1.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) );
163 aLbSort2.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) );
164 aLbSort3.SetSelectHdl( LINK( this, ScTabPageSortFields, SelectHdl ) );
165 aLbSort1.Clear();
166 aLbSort2.Clear();
167 aLbSort3.Clear();
168
169 aSortLbArr[0] = &aLbSort1;
170 aSortLbArr[1] = &aLbSort2;
171 aSortLbArr[2] = &aLbSort3;
172 aDirBtnArr[0][0] = &aBtnUp1;
173 aDirBtnArr[0][1] = &aBtnDown1;
174 aDirBtnArr[1][0] = &aBtnUp2;
175 aDirBtnArr[1][1] = &aBtnDown2;
176 aDirBtnArr[2][0] = &aBtnUp3;
177 aDirBtnArr[2][1] = &aBtnDown3;
178 aFlArr[0] = &aFlSort1;
179 aFlArr[1] = &aFlSort2;
180 aFlArr[2] = &aFlSort3;
181 }
182
183 //------------------------------------------------------------------------
184
185 USHORT* __EXPORT ScTabPageSortFields::GetRanges()
186 {
187 return pSortRanges;
188 }
189
190 // -----------------------------------------------------------------------
191
192 SfxTabPage* __EXPORT ScTabPageSortFields::Create( Window* pParent,
193 const SfxItemSet& rArgSet )
194 {
195 return ( new ScTabPageSortFields( pParent, rArgSet ) );
196 }
197
198 // -----------------------------------------------------------------------
199
200 void __EXPORT ScTabPageSortFields::Reset( const SfxItemSet& /* rArgSet */ )
201 {
202 bSortByRows = rSortData.bByRow;
203 bHasHeader = rSortData.bHasHeader;
204
205 if ( aLbSort1.GetEntryCount() == 0 )
206 FillFieldLists();
207
208 // Selektieren der ListBoxen:
209
210 if ( rSortData.bDoSort[0] )
211 {
212 for ( USHORT i=0; i<3; i++ )
213 {
214 if ( rSortData.bDoSort[i] )
215 {
216 aSortLbArr[i]->SelectEntryPos(
217 GetFieldSelPos( rSortData.nField[i] ) );
218
219 (rSortData.bAscending[i])
220 ? aDirBtnArr[i][0]->Check() // Up
221 : aDirBtnArr[i][1]->Check(); // Down
222 }
223 else
224 {
225 aSortLbArr[i]->SelectEntryPos( 0 ); // "keiner" selektieren
226 aDirBtnArr[i][0]->Check(); // Up
227 }
228 }
229
230 EnableField( 1 );
231 EnableField( 2 );
232 EnableField( 3 );
233 if ( aLbSort1.GetSelectEntryPos() == 0 )
234 DisableField( 2 );
235 if ( aLbSort2.GetSelectEntryPos() == 0 )
236 DisableField( 3 );
237 }
238 else
239 {
240 SCCOL nCol = pViewData->GetCurX();
241
242 if( nCol < rSortData.nCol1 )
243 nCol = rSortData.nCol1;
244 else if( nCol > rSortData.nCol2 )
245 nCol = rSortData.nCol2;
246
247 USHORT nSort1Pos = nCol - rSortData.nCol1+1;
248 aLbSort1.SelectEntryPos( nSort1Pos );
249 aLbSort2.SelectEntryPos( 0 );
250 aLbSort3.SelectEntryPos( 0 );
251 aBtnUp1.Check();
252 aBtnUp2.Check();
253 aBtnUp3.Check();
254 EnableField ( 1 );
255 EnableField ( 2 );
256 DisableField( 3 );
257 }
258
259 if ( pDlg )
260 {
261 pDlg->SetByRows ( bSortByRows );
262 pDlg->SetHeaders( bHasHeader );
263 }
264 }
265
266 // -----------------------------------------------------------------------
267
268 BOOL __EXPORT ScTabPageSortFields::FillItemSet( SfxItemSet& rArgSet )
269 {
270 ScSortParam theSortData = rSortData;
271 if (pDlg)
272 {
273 const SfxItemSet* pExample = pDlg->GetExampleSet();
274 const SfxPoolItem* pItem;
275 if ( pExample && pExample->GetItemState( nWhichSort, TRUE, &pItem ) == SFX_ITEM_SET )
276 theSortData = ((const ScSortItem*)pItem)->GetSortData();
277 }
278
279 USHORT nSort1Pos = aLbSort1.GetSelectEntryPos();
280 USHORT nSort2Pos = aLbSort2.GetSelectEntryPos();
281 USHORT nSort3Pos = aLbSort3.GetSelectEntryPos();
282
283 DBG_ASSERT( (nSort1Pos <= SC_MAXFIELDS)
284 && (nSort2Pos <= SC_MAXFIELDS)
285 && (nSort3Pos <= SC_MAXFIELDS),
286 "Array-Range Fehler!" );
287
288 if ( nSort1Pos == LISTBOX_ENTRY_NOTFOUND ) nSort1Pos = 0;
289 if ( nSort2Pos == LISTBOX_ENTRY_NOTFOUND ) nSort2Pos = 0;
290 if ( nSort3Pos == LISTBOX_ENTRY_NOTFOUND ) nSort3Pos = 0;
291
292 if ( nSort1Pos > 0 )
293 {
294 theSortData.bDoSort[0] = (nSort1Pos > 0);
295 theSortData.bDoSort[1] = (nSort2Pos > 0);
296 theSortData.bDoSort[2] = (nSort3Pos > 0);
297
298 // wenn auf Optionen-Seite "OK" gewaehlt wurde und
299 // dabei die Sortierrichtung umgestellt wurde, so
300 // wird das erste Feld der jeweiligen Richtung als
301 // Sortierkriterium gewaehlt (steht in nFieldArr[0]):
302 if ( bSortByRows != pDlg->GetByRows() )
303 {
304 theSortData.nField[0] =
305 theSortData.nField[1] =
306 theSortData.nField[2] = ( bSortByRows ?
307 static_cast<SCCOLROW>(nFirstRow) :
308 static_cast<SCCOLROW>(nFirstCol) );
309 }
310 else
311 {
312 theSortData.nField[0] = nFieldArr[nSort1Pos];
313 theSortData.nField[1] = nFieldArr[nSort2Pos];
314 theSortData.nField[2] = nFieldArr[nSort3Pos];
315 }
316
317 theSortData.bAscending[0] = aBtnUp1.IsChecked();
318 theSortData.bAscending[1] = aBtnUp2.IsChecked();
319 theSortData.bAscending[2] = aBtnUp3.IsChecked();
320 // bHasHeader ist in ScTabPageSortOptions::FillItemSet, wo es hingehoert
321 }
322 else
323 {
324 theSortData.bDoSort[0] =
325 theSortData.bDoSort[1] =
326 theSortData.bDoSort[2] = FALSE;
327 }
328
329 rArgSet.Put( ScSortItem( SCITEM_SORTDATA, NULL, &theSortData ) );
330
331 return TRUE;
332 }
333
334 // -----------------------------------------------------------------------
335
336 // fuer Datenaustausch ohne Dialog-Umweg: (! noch zu tun !)
337 // void ScTabPageSortFields::ActivatePage( const SfxItemSet& rSet )
338
339 void __EXPORT ScTabPageSortFields::ActivatePage()
340 {
341 if ( pDlg )
342 {
343 if ( bHasHeader != pDlg->GetHeaders()
344 || bSortByRows != pDlg->GetByRows() )
345 {
346 USHORT nCurSel1 = aLbSort1.GetSelectEntryPos();
347 USHORT nCurSel2 = aLbSort2.GetSelectEntryPos();
348 USHORT nCurSel3 = aLbSort3.GetSelectEntryPos();
349
350 bHasHeader = pDlg->GetHeaders();
351 bSortByRows = pDlg->GetByRows();
352 FillFieldLists();
353 aLbSort1.SelectEntryPos( nCurSel1 );
354 aLbSort2.SelectEntryPos( nCurSel2 );
355 aLbSort3.SelectEntryPos( nCurSel3 );
356 }
357 }
358 }
359
360 // -----------------------------------------------------------------------
361
362 int __EXPORT ScTabPageSortFields::DeactivatePage( SfxItemSet* pSetP )
363 {
364 if ( pDlg )
365 {
366 if ( bHasHeader != pDlg->GetHeaders() )
367 pDlg->SetHeaders( bHasHeader );
368
369 if ( bSortByRows != pDlg->GetByRows() )
370 pDlg->SetByRows( bSortByRows );
371 }
372
373 if ( pSetP )
374 FillItemSet( *pSetP );
375
376 return SfxTabPage::LEAVE_PAGE;
377 }
378
379 // -----------------------------------------------------------------------
380
381 void ScTabPageSortFields::DisableField( USHORT nField )
382 {
383 nField--;
384
385 if ( nField<=2 )
386 {
387 aSortLbArr[nField] ->Disable();
388 aDirBtnArr[nField][0]->Disable();
389 aDirBtnArr[nField][1]->Disable();
390 aFlArr[nField] ->Disable();
391 }
392 }
393
394 // -----------------------------------------------------------------------
395
396 void ScTabPageSortFields::EnableField( USHORT nField )
397 {
398 nField--;
399
400 if ( nField<=2 )
401 {
402 aSortLbArr[nField] ->Enable();
403 aDirBtnArr[nField][0]->Enable();
404 aDirBtnArr[nField][1]->Enable();
405 aFlArr[nField] ->Enable();
406 }
407 }
408
409 // -----------------------------------------------------------------------
410
411 void ScTabPageSortFields::FillFieldLists()
412 {
413 if ( pViewData )
414 {
415 ScDocument* pDoc = pViewData->GetDocument();
416
417 if ( pDoc )
418 {
419 aLbSort1.Clear();
420 aLbSort2.Clear();
421 aLbSort3.Clear();
422 aLbSort1.InsertEntry( aStrUndefined, 0 );
423 aLbSort2.InsertEntry( aStrUndefined, 0 );
424 aLbSort3.InsertEntry( aStrUndefined, 0 );
425
426 SCCOL nFirstSortCol = rSortData.nCol1;
427 SCROW nFirstSortRow = rSortData.nRow1;
428 SCTAB nTab = pViewData->GetTabNo();
429 USHORT i = 1;
430
431 if ( bSortByRows )
432 {
433 String aFieldName;
434 SCCOL nMaxCol = rSortData.nCol2;
435 SCCOL col;
436
437 for ( col=nFirstSortCol; col<=nMaxCol && i<SC_MAXFIELDS; col++ )
438 {
439 pDoc->GetString( col, nFirstSortRow, nTab, aFieldName );
440 if ( !bHasHeader || (aFieldName.Len() == 0) )
441 {
442 aFieldName = aStrColumn;
443 aFieldName += ' ';
444 aFieldName += ScColToAlpha( col );
445 }
446 nFieldArr[i] = col;
447 aLbSort1.InsertEntry( aFieldName, i );
448 aLbSort2.InsertEntry( aFieldName, i );
449 aLbSort3.InsertEntry( aFieldName, i );
450 i++;
451 }
452 }
453 else
454 {
455 String aFieldName;
456 SCROW nMaxRow = rSortData.nRow2;
457 SCROW row;
458
459 for ( row=nFirstSortRow; row<=nMaxRow && i<SC_MAXFIELDS; row++ )
460 {
461 pDoc->GetString( nFirstSortCol, row, nTab, aFieldName );
462 if ( !bHasHeader || (aFieldName.Len() == 0) )
463 {
464 aFieldName = aStrRow;
465 aFieldName += ' ';
466 aFieldName += String::CreateFromInt32( row+1 );
467 }
468 nFieldArr[i] = row;
469 aLbSort1.InsertEntry( aFieldName, i );
470 aLbSort2.InsertEntry( aFieldName, i );
471 aLbSort3.InsertEntry( aFieldName, i );
472 i++;
473 }
474 }
475 nFieldCount = i;
476 }
477 }
478 }
479
480 //------------------------------------------------------------------------
481
482 USHORT ScTabPageSortFields::GetFieldSelPos( SCCOLROW nField )
483 {
484 USHORT nFieldPos = 0;
485 BOOL bFound = FALSE;
486
487 for ( USHORT n=1; n<nFieldCount && !bFound; n++ )
488 {
489 if ( nFieldArr[n] == nField )
490 {
491 nFieldPos = n;
492 bFound = TRUE;
493 }
494 }
495
496 return nFieldPos;
497 }
498
499 // -----------------------------------------------------------------------
500 // Handler:
501 //---------
502
503 IMPL_LINK( ScTabPageSortFields, SelectHdl, ListBox *, pLb )
504 {
505 String aSelEntry = pLb->GetSelectEntry();
506
507 if ( pLb == &aLbSort1 )
508 {
509 if ( aSelEntry == aStrUndefined )
510 {
511 aLbSort2.SelectEntryPos( 0 );
512 aLbSort3.SelectEntryPos( 0 );
513
514 if ( aFlSort2.IsEnabled() )
515 DisableField( 2 );
516
517 if ( aFlSort3.IsEnabled() )
518 DisableField( 3 );
519 }
520 else
521 {
522 if ( !aFlSort2.IsEnabled() )
523 EnableField( 2 );
524 }
525 }
526 else if ( pLb == &aLbSort2 )
527 {
528 if ( aSelEntry == aStrUndefined )
529 {
530 aLbSort3.SelectEntryPos( 0 );
531 if ( aFlSort3.IsEnabled() )
532 DisableField( 3 );
533 }
534 else
535 {
536 if ( !aFlSort3.IsEnabled() )
537 EnableField( 3 );
538 }
539 }
540 return 0;
541 }
542
543 //========================================================================
544 // Sortieroptionen-Tabpage:
545 //========================================================================
546
547 #if ENABLE_LAYOUT_EXPERIMENTAL
548 #include <layout/layout-pre.hxx>
549
550 #if ENABLE_LAYOUT
551 #undef ScResId
552 #define ScResId(x) #x
553 #undef SfxTabPage
554 #define SfxTabPage( parent, id, args ) SfxTabPage( parent, "sort-options.xml", id, &args )
555 #endif /* ENABLE_LAYOUT */
556
557 #endif /* ENABLE_LAYOUT_EXPERIMENTAL */
558
559 ScTabPageSortOptions::ScTabPageSortOptions( Window* pParent,
560 const SfxItemSet& rArgSet )
561
562 : SfxTabPage ( pParent,
563 ScResId( RID_SCPAGE_SORT_OPTIONS ),
564 rArgSet ),
565 //
566 aBtnCase ( this, ScResId( BTN_CASESENSITIVE ) ),
567 aBtnHeader ( this, ScResId( BTN_LABEL ) ),
568 aBtnFormats ( this, ScResId( BTN_FORMATS ) ),
569 aBtnCopyResult ( this, ScResId( BTN_COPYRESULT ) ),
570 aBtnNaturalSort ( this, ScResId( BTN_NATURALSORT ) ),
571 aLbOutPos ( this, ScResId( LB_OUTAREA ) ),
572 aEdOutPos ( this, ScResId( ED_OUTAREA ) ),
573 aBtnSortUser ( this, ScResId( BTN_SORT_USER ) ),
574 aLbSortUser ( this, ScResId( LB_SORT_USER ) ),
575 aFtLanguage ( this, ScResId( FT_LANGUAGE ) ),
576 aLbLanguage ( this, ScResId( LB_LANGUAGE ) ),
577 aFtAlgorithm ( this, ScResId( FT_ALGORITHM ) ),
578 aLbAlgorithm ( this, ScResId( LB_ALGORITHM ) ),
579 aLineDirection ( this, ScResId( FL_DIRECTION ) ),
580 aBtnTopDown ( this, ScResId( BTN_TOP_DOWN ) ),
581 aBtnLeftRight ( this, ScResId( BTN_LEFT_RIGHT ) ),
582 // aFtAreaLabel ( this, ScResId( FT_AREA_LABEL ) ),
583 // aFtArea ( this, ScResId( FT_AREA ) ),
584 //
585 #if ENABLE_LAYOUT_EXPERIMENTAL
586 #undef this
587 #undef ScResId
588 #define ScResId(x) this, #x
589 #endif /* ENABLE_LAYOUT_EXPERIMENTAL */
590 aStrRowLabel ( ScResId( STR_ROW_LABEL ) ),
591 aStrColLabel ( ScResId( STR_COL_LABEL ) ),
592 aStrUndefined ( ScResId( SCSTR_UNDEFINED ) ),
593 aStrNoName ( ScGlobal::GetRscString(STR_DB_NONAME) ),
594 //
595 nWhichSort ( rArgSet.GetPool()->GetWhich( SID_SORT ) ),
596 rSortData ( ((const ScSortItem&)
597 rArgSet.Get( nWhichSort )).GetSortData() ),
598 pViewData ( NULL ),
599 pDoc ( NULL ),
600 pDlg ( (ScSortDlg*)(GetParent() ? GetParent()->GetParent() : 0 ) ),
601 pColRes ( NULL ),
602 pColWrap ( NULL )
603 {
604 Init();
605 FreeResource();
606 SetExchangeSupport();
607 }
608
609 // -----------------------------------------------------------------------
610
611 __EXPORT ScTabPageSortOptions::~ScTabPageSortOptions()
612 {
613 USHORT nEntries = aLbOutPos.GetEntryCount();
614
615 for ( USHORT i=1; i<nEntries; i++ )
616 delete (String*)aLbOutPos.GetEntryData( i );
617
618 delete pColRes;
619 delete pColWrap; //! not if from document
620 }
621
622 // -----------------------------------------------------------------------
623
624 void ScTabPageSortOptions::Init()
625 {
626 // aStrAreaLabel = aFtAreaLabel.GetText();
627 // aStrAreaLabel.Append( (sal_Unicode) ' ' );
628
629 // CollatorRessource has user-visible names for sort algorithms
630 pColRes = new CollatorRessource();
631
632 //! use CollatorWrapper from document?
633 pColWrap = new CollatorWrapper( comphelper::getProcessServiceFactory() );
634
635 const ScSortItem& rSortItem = (const ScSortItem&)
636 GetItemSet().Get( nWhichSort );
637
638 aLbOutPos.SetSelectHdl ( LINK( this, ScTabPageSortOptions, SelOutPosHdl ) );
639 aBtnCopyResult.SetClickHdl( LINK( this, ScTabPageSortOptions, EnableHdl ) );
640 aBtnSortUser.SetClickHdl ( LINK( this, ScTabPageSortOptions, EnableHdl ) );
641 aBtnTopDown.SetClickHdl ( LINK( this, ScTabPageSortOptions, SortDirHdl ) );
642 aBtnLeftRight.SetClickHdl ( LINK( this, ScTabPageSortOptions, SortDirHdl ) );
643 aLbLanguage.SetSelectHdl ( LINK( this, ScTabPageSortOptions, FillAlgorHdl ) );
644
645 pViewData = rSortItem.GetViewData();
646 pDoc = pViewData ? pViewData->GetDocument() : NULL;
647
648 DBG_ASSERT( pViewData, "ViewData not found! :-/" );
649
650 if ( pViewData && pDoc )
651 {
652 String theArea;
653 ScDBCollection* pDBColl = pDoc->GetDBCollection();
654 String theDbArea;
655 String theDbName = aStrNoName;
656 const SCTAB nCurTab = pViewData->GetTabNo();
657 const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
658
659 aLbOutPos.Clear();
660 aLbOutPos.InsertEntry( aStrUndefined, 0 );
661 aLbOutPos.Disable();
662
663 ScAreaNameIterator aIter( pDoc );
664 String aName;
665 ScRange aRange;
666 String aRefStr;
667 while ( aIter.Next( aName, aRange ) )
668 {
669 USHORT nInsert = aLbOutPos.InsertEntry( aName );
670
671 aRange.aStart.Format( aRefStr, SCA_ABS_3D, pDoc, eConv );
672 aLbOutPos.SetEntryData( nInsert, new String( aRefStr ) );
673 }
674
675 aLbOutPos.SelectEntryPos( 0 );
676 aEdOutPos.SetText( EMPTY_STRING );
677
678 /*
679 * Ueberpruefen, ob es sich bei dem uebergebenen
680 * Bereich um einen Datenbankbereich handelt:
681 */
682
683 ScAddress aScAddress( rSortData.nCol1, rSortData.nRow1, nCurTab );
684 ScRange( aScAddress,
685 ScAddress( rSortData.nCol2, rSortData.nRow2, nCurTab )
686 ).Format( theArea, SCR_ABS, pDoc, eConv );
687
688 if ( pDBColl )
689 {
690 ScDBData* pDBData
691 = pDBColl->GetDBAtArea( nCurTab,
692 rSortData.nCol1, rSortData.nRow1,
693 rSortData.nCol2, rSortData.nRow2 );
694 if ( pDBData )
695 {
696 pDBData->GetName( theDbName );
697 aBtnHeader.Check( pDBData->HasHeader() );
698 }
699 }
700
701 theArea.AppendAscii(RTL_CONSTASCII_STRINGPARAM(" ("));
702 theArea += theDbName;
703 theArea += ')';
704
705 //aFtArea.SetText( theArea );
706 //theArea.Insert( aStrAreaLabel, 0 );
707 //aFtAreaLabel.SetText( theArea );
708
709 aBtnHeader.SetText( aStrColLabel );
710 }
711
712 FillUserSortListBox();
713
714 // get available languages
715
716 aLbLanguage.SetLanguageList( LANG_LIST_ALL | LANG_LIST_ONLY_KNOWN, FALSE );
717 aLbLanguage.InsertLanguage( LANGUAGE_SYSTEM );
718 }
719
720 //------------------------------------------------------------------------
721
722 USHORT* __EXPORT ScTabPageSortOptions::GetRanges()
723 {
724 return pSortRanges;
725 }
726
727 // -----------------------------------------------------------------------
728
729 #if ENABLE_LAYOUT_EXPERIMENTAL
730 #undef SfxTabPage
731 #endif /* ENABLE_LAYOUT_EXPERIMENTAL */
732 SfxTabPage* __EXPORT ScTabPageSortOptions::Create(
733 Window* pParent,
734 const SfxItemSet& rArgSet )
735 {
736 return ( new ScTabPageSortOptions( pParent, rArgSet ) );
737 }
738
739 // -----------------------------------------------------------------------
740
741 void __EXPORT ScTabPageSortOptions::Reset( const SfxItemSet& /* rArgSet */ )
742 {
743 if ( rSortData.bUserDef )
744 {
745 aBtnSortUser.Check( TRUE );
746 aLbSortUser.Enable();
747 aLbSortUser.SelectEntryPos( rSortData.nUserIndex );
748 }
749 else
750 {
751 aBtnSortUser.Check( FALSE );
752 aLbSortUser.Disable();
753 aLbSortUser.SelectEntryPos( 0 );
754 }
755
756 aBtnCase.Check ( rSortData.bCaseSens );
757 aBtnFormats.Check ( rSortData.bIncludePattern );
758 aBtnHeader.Check ( rSortData.bHasHeader );
759 aBtnNaturalSort.Check ( rSortData.bNaturalSort );
760
761 if ( rSortData.bByRow )
762 {
763 aBtnTopDown.Check();
764 aBtnHeader.SetText( aStrColLabel );
765 }
766 else
767 {
768 aBtnLeftRight.Check();
769 aBtnHeader.SetText( aStrRowLabel );
770 }
771
772 LanguageType eLang = MsLangId::convertLocaleToLanguage( rSortData.aCollatorLocale );
773 if ( eLang == LANGUAGE_DONTKNOW )
774 eLang = LANGUAGE_SYSTEM;
775 aLbLanguage.SelectLanguage( eLang );
776 FillAlgorHdl( &aLbLanguage ); // get algorithms, select default
777 if ( rSortData.aCollatorAlgorithm.Len() )
778 aLbAlgorithm.SelectEntry( pColRes->GetTranslation( rSortData.aCollatorAlgorithm ) );
779
780 if ( pDoc && !rSortData.bInplace )
781 {
782 String aStr;
783 USHORT nFormat = (rSortData.nDestTab != pViewData->GetTabNo())
784 ? SCR_ABS_3D
785 : SCR_ABS;
786
787 theOutPos.Set( rSortData.nDestCol,
788 rSortData.nDestRow,
789 rSortData.nDestTab );
790
791 theOutPos.Format( aStr, nFormat, pDoc, pDoc->GetAddressConvention() );
792 aBtnCopyResult.Check();
793 aLbOutPos.Enable();
794 aEdOutPos.Enable();
795 aEdOutPos.SetText( aStr );
796 EdOutPosModHdl( &aEdOutPos );
797 aEdOutPos.GrabFocus();
798 aEdOutPos.SetSelection( Selection( 0, SELECTION_MAX ) );
799 }
800 else
801 {
802 aBtnCopyResult.Check( FALSE );
803 aLbOutPos.Disable();
804 aEdOutPos.Disable();
805 aEdOutPos.SetText( EMPTY_STRING );
806 }
807 }
808
809 // -----------------------------------------------------------------------
810
811 BOOL __EXPORT ScTabPageSortOptions::FillItemSet( SfxItemSet& rArgSet )
812 {
813 ScSortParam theSortData = rSortData;
814 if (pDlg)
815 {
816 const SfxItemSet* pExample = pDlg->GetExampleSet();
817 const SfxPoolItem* pItem;
818 if ( pExample && pExample->GetItemState( nWhichSort, TRUE, &pItem ) == SFX_ITEM_SET )
819 theSortData = ((const ScSortItem*)pItem)->GetSortData();
820 }
821
822 theSortData.bByRow = aBtnTopDown.IsChecked();
823 theSortData.bHasHeader = aBtnHeader.IsChecked();
824 theSortData.bCaseSens = aBtnCase.IsChecked();
825 theSortData.bNaturalSort = aBtnNaturalSort.IsChecked();
826 theSortData.bIncludePattern = aBtnFormats.IsChecked();
827 theSortData.bInplace = !aBtnCopyResult.IsChecked();
828 theSortData.nDestCol = theOutPos.Col();
829 theSortData.nDestRow = theOutPos.Row();
830 theSortData.nDestTab = theOutPos.Tab();
831 theSortData.bUserDef = aBtnSortUser.IsChecked();
832 theSortData.nUserIndex = (aBtnSortUser.IsChecked())
833 ? aLbSortUser.GetSelectEntryPos()
834 : 0;
835
836 // get locale
837 LanguageType eLang = aLbLanguage.GetSelectLanguage();
838 theSortData.aCollatorLocale = MsLangId::convertLanguageToLocale( eLang, false );
839
840 // get algorithm
841 String sAlg;
842 if ( eLang != LANGUAGE_SYSTEM )
843 {
844 uno::Sequence<rtl::OUString> aAlgos = pColWrap->listCollatorAlgorithms(
845 theSortData.aCollatorLocale );
846 USHORT nSel = aLbAlgorithm.GetSelectEntryPos();
847 if ( nSel < aAlgos.getLength() )
848 sAlg = aAlgos[nSel];
849 }
850 theSortData.aCollatorAlgorithm = sAlg;
851
852 rArgSet.Put( ScSortItem( SCITEM_SORTDATA, &theSortData ) );
853
854 return TRUE;
855 }
856
857 // -----------------------------------------------------------------------
858
859 // fuer Datenaustausch ohne Dialog-Umweg: (! noch zu tun !)
860 // void ScTabPageSortOptions::ActivatePage( const SfxItemSet& rSet )
861 void __EXPORT ScTabPageSortOptions::ActivatePage()
862 {
863 if ( pDlg )
864 {
865 if ( aBtnHeader.IsChecked() != pDlg->GetHeaders() )
866 {
867 aBtnHeader.Check( pDlg->GetHeaders() );
868 }
869
870 if ( aBtnTopDown.IsChecked() != pDlg->GetByRows() )
871 {
872 aBtnTopDown.Check( pDlg->GetByRows() );
873 aBtnLeftRight.Check( !pDlg->GetByRows() );
874 }
875
876 aBtnHeader.SetText( (pDlg->GetByRows())
877 ? aStrColLabel
878 : aStrRowLabel );
879 }
880 }
881
882 // -----------------------------------------------------------------------
883
884 int __EXPORT ScTabPageSortOptions::DeactivatePage( SfxItemSet* pSetP )
885 {
886 BOOL bPosInputOk = TRUE;
887
888 if ( aBtnCopyResult.IsChecked() )
889 {
890 String thePosStr = aEdOutPos.GetText();
891 ScAddress thePos;
892 xub_StrLen nColonPos = thePosStr.Search( ':' );
893
894 if ( STRING_NOTFOUND != nColonPos )
895 thePosStr.Erase( nColonPos );
896
897 if ( pViewData )
898 {
899 // visible table is default for input without table
900 // must be changed to GetRefTabNo when sorting has RefInput!
901 thePos.SetTab( pViewData->GetTabNo() );
902 }
903
904 USHORT nResult = thePos.Parse( thePosStr, pDoc, pDoc->GetAddressConvention() );
905
906 bPosInputOk = ( SCA_VALID == (nResult & SCA_VALID) );
907
908 if ( !bPosInputOk )
909 {
910 #if !ENABLE_LAYOUT_EXPERIMENTAL
911 ErrorBox( this, WinBits( WB_OK | WB_DEF_OK ),
912 ScGlobal::GetRscString( STR_INVALID_TABREF )
913 ).Execute();
914 #endif /* ENABLE_LAYOUT_EXPERIMENTAL */
915 aEdOutPos.GrabFocus();
916 aEdOutPos.SetSelection( Selection( 0, SELECTION_MAX ) );
917 theOutPos.Set(0,0,0);
918 }
919 else
920 {
921 aEdOutPos.SetText( thePosStr );
922 theOutPos = thePos;
923 }
924 }
925
926 if ( pDlg && bPosInputOk )
927 {
928 pDlg->SetHeaders( aBtnHeader.IsChecked() );
929 pDlg->SetByRows ( aBtnTopDown.IsChecked() );
930 }
931
932 if ( pSetP && bPosInputOk )
933 FillItemSet( *pSetP );
934
935 return bPosInputOk ? SfxTabPage::LEAVE_PAGE : SfxTabPage::KEEP_PAGE;
936 }
937
938 // -----------------------------------------------------------------------
939
940 void ScTabPageSortOptions::FillUserSortListBox()
941 {
942 ScUserList* pUserLists = ScGlobal::GetUserList();
943
944 aLbSortUser.Clear();
945 if ( pUserLists )
946 {
947 USHORT nCount = pUserLists->GetCount();
948 if ( nCount > 0 )
949 for ( USHORT i=0; i<nCount; i++ )
950 aLbSortUser.InsertEntry( (*pUserLists)[i]->GetString() );
951 }
952 }
953
954 // -----------------------------------------------------------------------
955 // Handler:
956
957 IMPL_LINK( ScTabPageSortOptions, EnableHdl, CheckBox *, pBox )
958 {
959 if ( pBox == &aBtnCopyResult )
960 {
961 if ( pBox->IsChecked() )
962 {
963 aLbOutPos.Enable();
964 aEdOutPos.Enable();
965 aEdOutPos.GrabFocus();
966 }
967 else
968 {
969 aLbOutPos.Disable();
970 aEdOutPos.Disable();
971 }
972 }
973 else if ( pBox == &aBtnSortUser )
974 {
975 if ( pBox->IsChecked() )
976 {
977 aLbSortUser.Enable();
978 aLbSortUser.GrabFocus();
979 }
980 else
981 aLbSortUser.Disable();
982 }
983 return 0;
984 }
985
986 // -----------------------------------------------------------------------
987
988 IMPL_LINK( ScTabPageSortOptions, SelOutPosHdl, ListBox *, pLb )
989 {
990 if ( pLb == &aLbOutPos )
991 {
992 String aString;
993 USHORT nSelPos = aLbOutPos.GetSelectEntryPos();
994
995 if ( nSelPos > 0 )
996 aString = *(String*)aLbOutPos.GetEntryData( nSelPos );
997
998 aEdOutPos.SetText( aString );
999 }
1000 return 0;
1001 }
1002
1003 // -----------------------------------------------------------------------
1004
1005 IMPL_LINK( ScTabPageSortOptions, SortDirHdl, RadioButton *, pBtn )
1006 {
1007 if ( pBtn == &aBtnTopDown )
1008 {
1009 aBtnHeader.SetText( aStrColLabel );
1010 }
1011 else if ( pBtn == &aBtnLeftRight )
1012 {
1013 aBtnHeader.SetText( aStrRowLabel );
1014 }
1015 return 0;
1016 }
1017
1018 // -----------------------------------------------------------------------
1019
1020 void __EXPORT ScTabPageSortOptions::EdOutPosModHdl( Edit* pEd )
1021 {
1022 if ( pEd == &aEdOutPos )
1023 {
1024 String theCurPosStr = aEdOutPos.GetText();
1025 USHORT nResult = ScAddress().Parse( theCurPosStr, pDoc, pDoc->GetAddressConvention() );
1026
1027 if ( SCA_VALID == (nResult & SCA_VALID) )
1028 {
1029 String* pStr = NULL;
1030 BOOL bFound = FALSE;
1031 USHORT i = 0;
1032 USHORT nCount = aLbOutPos.GetEntryCount();
1033
1034 for ( i=2; i<nCount && !bFound; i++ )
1035 {
1036 pStr = (String*)aLbOutPos.GetEntryData( i );
1037 bFound = (theCurPosStr == *pStr);
1038 }
1039
1040 if ( bFound )
1041 aLbOutPos.SelectEntryPos( --i );
1042 else
1043 aLbOutPos.SelectEntryPos( 0 );
1044 }
1045 }
1046 }
1047
1048 // -----------------------------------------------------------------------
1049
1050 IMPL_LINK( ScTabPageSortOptions, FillAlgorHdl, void *, EMPTYARG )
1051 {
1052 aLbAlgorithm.SetUpdateMode( FALSE );
1053 aLbAlgorithm.Clear();
1054
1055 LanguageType eLang = aLbLanguage.GetSelectLanguage();
1056 if ( eLang == LANGUAGE_SYSTEM )
1057 {
1058 // for LANGUAGE_SYSTEM no algorithm can be selected because
1059 // it wouldn't necessarily exist for other languages
1060 // -> leave list box empty if LANGUAGE_SYSTEM is selected
1061 aFtAlgorithm.Enable( FALSE ); // nothing to select
1062 aLbAlgorithm.Enable( FALSE ); // nothing to select
1063 }
1064 else
1065 {
1066 lang::Locale aLocale( MsLangId::convertLanguageToLocale( eLang ));
1067 uno::Sequence<rtl::OUString> aAlgos = pColWrap->listCollatorAlgorithms( aLocale );
1068
1069 long nCount = aAlgos.getLength();
1070 const rtl::OUString* pArray = aAlgos.getConstArray();
1071 for (long i=0; i<nCount; i++)
1072 {
1073 String sAlg = pArray[i];
1074 String sUser = pColRes->GetTranslation( sAlg );
1075 aLbAlgorithm.InsertEntry( sUser, LISTBOX_APPEND );
1076 }
1077 aLbAlgorithm.SelectEntryPos( 0 ); // first entry is default
1078 aFtAlgorithm.Enable( nCount > 1 ); // enable only if there is a choice
1079 aLbAlgorithm.Enable( nCount > 1 ); // enable only if there is a choice
1080 }
1081
1082 aLbAlgorithm.SetUpdateMode( TRUE );
1083 return 0;
1084 }
1085
1086
vba interoperability for OOo