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