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