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 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sc.hxx" 26 27 // System - Includes --------------------------------------------------------- 28 29 30 31 #include <svl/undo.hxx> 32 #include <unotools/textsearch.hxx> 33 #include <unotools/localedatawrapper.hxx> 34 #include <unotools/collatorwrapper.hxx> 35 #include <vcl/msgbox.hxx> 36 #include <sfx2/app.hxx> 37 #include <sfx2/viewfrm.hxx> 38 39 // INCLUDE ------------------------------------------------------------------- 40 41 #include "acredlin.hxx" 42 #include "global.hxx" 43 #include "reffact.hxx" 44 #include "document.hxx" 45 #include "docsh.hxx" 46 #include "scresid.hxx" 47 #include "globstr.hrc" 48 #include "acredlin.hrc" 49 #include "simpref.hxx" 50 #include "scmod.hxx" 51 #include "popmenu.hxx" 52 #include "tabvwsh.hxx" 53 54 // defines ------------------------------------------------------------------- 55 56 #define ABS_SREF SCA_VALID \ 57 | SCA_COL_ABSOLUTE | SCA_ROW_ABSOLUTE | SCA_TAB_ABSOLUTE 58 #define ABS_DREF ABS_SREF \ 59 | SCA_COL2_ABSOLUTE | SCA_ROW2_ABSOLUTE | SCA_TAB2_ABSOLUTE 60 #define ABS_SREF3D ABS_SREF | SCA_TAB_3D 61 #define ABS_DREF3D ABS_DREF | SCA_TAB_3D 62 63 64 65 #define ERRORBOX(s) ErrorBox(this,WinBits(WB_OK|WB_DEF_OK),s).Execute(); 66 67 inline void EnableDisable( Window& rWin, sal_Bool bEnable ) 68 { 69 if (bEnable) 70 rWin.Enable(); 71 else 72 rWin.Disable(); 73 } 74 75 #define RD_SPECIAL_NONE 0 76 #define RD_SPECIAL_CONTENT 1 77 #define RD_SPECIAL_VISCONTENT 2 78 79 //============================================================================ 80 // class ScRedlinData 81 //---------------------------------------------------------------------------- 82 83 ScRedlinData::ScRedlinData() 84 :RedlinData() 85 { 86 nInfo=RD_SPECIAL_NONE; 87 nActionNo=0; 88 pData=NULL; 89 bDisabled=sal_False; 90 bIsRejectable=sal_False; 91 bIsAcceptable=sal_False; 92 nTable=SCTAB_MAX; 93 nCol=SCCOL_MAX; 94 nRow=SCROW_MAX; 95 } 96 97 ScRedlinData::~ScRedlinData() 98 { 99 nInfo=RD_SPECIAL_NONE; 100 nActionNo=0; 101 pData=NULL; 102 bDisabled=sal_False; 103 bIsRejectable=sal_False; 104 bIsAcceptable=sal_False; 105 } 106 107 108 //============================================================================ 109 // class ScAcceptChgDlg 110 //---------------------------------------------------------------------------- 111 ScAcceptChgDlg::ScAcceptChgDlg( SfxBindings* pB, SfxChildWindow* pCW, Window* pParent, 112 ScViewData* ptrViewData) 113 114 : SfxModelessDialog( pB, pCW, pParent, ScResId(RID_SCDLG_CHANGES) ), 115 // 116 aAcceptChgCtr ( this, ScResId( CTR_REDLINING ) ), 117 // 118 pViewData ( ptrViewData ), 119 pDoc ( ptrViewData->GetDocument() ), 120 aLocalRangeName ( *(pDoc->GetRangeName()) ), 121 // 122 aStrInsertCols ( ScResId( STR_INSERT_COLS)), 123 aStrInsertRows ( ScResId( STR_INSERT_ROWS)), 124 aStrInsertTabs ( ScResId( STR_INSERT_TABS)), 125 aStrDeleteCols ( ScResId( STR_DELETE_COLS)), 126 aStrDeleteRows ( ScResId( STR_DELETE_ROWS)), 127 aStrDeleteTabs ( ScResId( STR_DELETE_TABS)), 128 aStrMove ( ScResId( STR_MOVE )), 129 aStrContent ( ScResId( STR_CONTENT )), 130 aStrReject ( ScResId( STR_REJECT )), 131 aStrAllAccepted ( ScResId( STR_ACCEPTED )), 132 aStrAllRejected ( ScResId( STR_REJECTED )), 133 aStrNoEntry ( ScResId( STR_NO_ENTRY )), 134 aStrContentWithChild ( ScResId( STR_CONTENT_WITH_CHILD)), 135 aStrChildContent ( ScResId( STR_CHILD_CONTENT)), 136 aStrChildOrgContent ( ScResId( STR_CHILD_ORGCONTENT)), 137 aStrEmpty ( ScResId( STR_EMPTY )) 138 { 139 FreeResource(); 140 // bScAcceptChgDlgIsDead=sal_False; 141 bNoSelection=sal_False; 142 bNeedsUpdate=sal_False; 143 bIgnoreMsg=sal_False; 144 nAcceptCount=0; 145 nRejectCount=0; 146 bAcceptEnableFlag=sal_True; 147 bRejectEnableFlag=sal_True; 148 bHasFilterEntry=sal_False; 149 bUseColor=sal_False; 150 aReOpenTimer.SetTimeout(50); 151 aReOpenTimer.SetTimeoutHdl(LINK( this, ScAcceptChgDlg, ReOpenTimerHdl )); 152 153 // dialog is now only hidden, not deleted, on switching views, 154 // so there's no need to restore settings when reopening 155 156 MinSize=aAcceptChgCtr.GetMinSizePixel(); 157 MinSize.Height()+=2; 158 MinSize.Width()+=2; 159 SetMinOutputSizePixel(MinSize); 160 aUnknown.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Unknown")); 161 162 pTPFilter=aAcceptChgCtr.GetFilterPage(); 163 pTPView=aAcceptChgCtr.GetViewPage(); 164 pTheView=pTPView->GetTableControl(); 165 aSelectionTimer.SetTimeout(100); 166 aSelectionTimer.SetTimeoutHdl(LINK( this, ScAcceptChgDlg, UpdateSelectionHdl )); 167 168 pTPFilter->SetReadyHdl(LINK( this, ScAcceptChgDlg, FilterHandle )); 169 pTPFilter->SetRefHdl(LINK( this, ScAcceptChgDlg, RefHandle )); 170 pTPFilter->SetModifyHdl(LINK( this, ScAcceptChgDlg, FilterModified)); 171 pTPFilter->HideRange(sal_False); 172 pTPView->InsertCalcHeader(); 173 pTPView->SetRejectClickHdl( LINK( this, ScAcceptChgDlg,RejectHandle)); 174 pTPView->SetAcceptClickHdl( LINK(this, ScAcceptChgDlg, AcceptHandle)); 175 pTPView->SetRejectAllClickHdl( LINK( this, ScAcceptChgDlg,RejectAllHandle)); 176 pTPView->SetAcceptAllClickHdl( LINK(this, ScAcceptChgDlg, AcceptAllHandle)); 177 pTheView->SetCalcView(); 178 pTheView->SetStyle(pTheView->GetStyle()|WB_HASLINES|WB_CLIPCHILDREN|WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL); 179 pTheView->SetExpandingHdl( LINK(this, ScAcceptChgDlg, ExpandingHandle)); 180 pTheView->SetSelectHdl( LINK(this, ScAcceptChgDlg, SelectHandle)); 181 pTheView->SetDeselectHdl( LINK(this, ScAcceptChgDlg, SelectHandle)); 182 pTheView->SetCommandHdl( LINK(this, ScAcceptChgDlg, CommandHdl)); 183 pTheView->SetColCompareHdl( LINK(this, ScAcceptChgDlg,ColCompareHdl)); 184 pTheView->SetSelectionMode(MULTIPLE_SELECTION); 185 pTheView->SetHighlightRange(1); 186 187 Init(); 188 189 aAcceptChgCtr.SetMinSizeHdl( LINK( this, ScAcceptChgDlg, MinSizeHandle )); 190 191 UpdateView(); 192 SvLBoxEntry* pEntry=pTheView->First(); 193 if(pEntry!=NULL) 194 { 195 pTheView->Select(pEntry); 196 } 197 } 198 ScAcceptChgDlg::~ScAcceptChgDlg() 199 { 200 // bScAcceptChgDlgIsDead=sal_True; 201 ClearView(); 202 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 203 204 if(pChanges!=NULL) 205 { 206 Link aLink; 207 pChanges->SetModifiedLink(aLink); 208 } 209 } 210 211 void ScAcceptChgDlg::ReInit(ScViewData* ptrViewData) 212 { 213 pViewData=ptrViewData; 214 if(pViewData!=NULL) 215 { 216 pDoc=ptrViewData->GetDocument(); 217 } 218 else 219 { 220 pDoc=NULL; 221 } 222 223 bNoSelection=sal_False; 224 bNeedsUpdate=sal_False; 225 bIgnoreMsg=sal_False; 226 nAcceptCount=0; 227 nRejectCount=0; 228 bAcceptEnableFlag=sal_True; 229 bRejectEnableFlag=sal_True; 230 231 // #91781# don't call Init here (switching between views), just set link below 232 // (dialog is just hidden, not deleted anymore, when switching views) 233 ClearView(); 234 UpdateView(); 235 236 if ( pDoc ) 237 { 238 ScChangeTrack* pChanges = pDoc->GetChangeTrack(); 239 if ( pChanges ) 240 pChanges->SetModifiedLink( LINK( this, ScAcceptChgDlg, ChgTrackModHdl ) ); 241 } 242 } 243 244 void __EXPORT ScAcceptChgDlg::Init() 245 { 246 String aAreaStr; 247 ScRange aRange; 248 249 DBG_ASSERT( pViewData && pDoc, "ViewData oder Document nicht gefunden!" ); 250 251 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 252 253 if(pChanges!=NULL) 254 { 255 pChanges->SetModifiedLink( LINK( this, ScAcceptChgDlg,ChgTrackModHdl)); 256 aChangeViewSet.SetTheAuthorToShow(pChanges->GetUser()); 257 pTPFilter->ClearAuthors(); 258 ScStrCollection aUserColl=pChanges->GetUserCollection(); 259 for(sal_uInt16 i=0;i<aUserColl.GetCount();i++) 260 pTPFilter->InsertAuthor(aUserColl[i]->GetString()); 261 } 262 263 ScChangeViewSettings* pViewSettings=pDoc->GetChangeViewSettings(); 264 if ( pViewSettings!=NULL ) 265 aChangeViewSet = *pViewSettings; 266 // adjust TimeField for filter tabpage 267 aChangeViewSet.AdjustDateMode( *pDoc ); 268 269 pTPFilter->CheckDate(aChangeViewSet.HasDate()); 270 pTPFilter->SetFirstDate(aChangeViewSet.GetTheFirstDateTime()); 271 pTPFilter->SetFirstTime(aChangeViewSet.GetTheFirstDateTime()); 272 pTPFilter->SetLastDate(aChangeViewSet.GetTheLastDateTime()); 273 pTPFilter->SetLastTime(aChangeViewSet.GetTheLastDateTime()); 274 pTPFilter->SetDateMode((sal_uInt16)aChangeViewSet.GetTheDateMode()); 275 pTPFilter->CheckComment(aChangeViewSet.HasComment()); 276 pTPFilter->SetComment(aChangeViewSet.GetTheComment()); 277 278 pTPFilter->CheckAuthor(aChangeViewSet.HasAuthor()); 279 String aString=aChangeViewSet.GetTheAuthorToShow(); 280 if(aString.Len()!=0) 281 { 282 pTPFilter->SelectAuthor(aString); 283 if(pTPFilter->GetSelectedAuthor()!=aString) 284 { 285 pTPFilter->InsertAuthor(aString); 286 pTPFilter->SelectAuthor(aString); 287 } 288 } 289 else 290 { 291 pTPFilter->SelectedAuthorPos(0); 292 } 293 294 pTPFilter->CheckRange(aChangeViewSet.HasRange()); 295 296 ScRange* pRangeEntry=aChangeViewSet.GetTheRangeList().GetObject(0); 297 aRangeList=aChangeViewSet.GetTheRangeList(); 298 299 if(pRangeEntry!=NULL) 300 { 301 String aRefStr; 302 pRangeEntry->Format( aRefStr, ABS_DREF3D, pDoc ); 303 pTPFilter->SetRange(aRefStr); 304 } 305 306 Point aPoint(1,1); 307 aAcceptChgCtr.SetPosPixel(aPoint); 308 InitFilter(); 309 } 310 311 312 313 void ScAcceptChgDlg::ClearView() 314 { 315 nAcceptCount=0; 316 nRejectCount=0; 317 pTheView->SetUpdateMode(sal_False); 318 319 pTheView->Clear(); 320 pTheView->SetUpdateMode(sal_True); 321 } 322 323 String* ScAcceptChgDlg::MakeTypeString(ScChangeActionType eType) 324 { 325 String* pStr; 326 327 switch(eType) 328 { 329 330 case SC_CAT_INSERT_COLS: pStr=&aStrInsertCols;break; 331 332 case SC_CAT_INSERT_ROWS: pStr=&aStrInsertRows;break; 333 334 case SC_CAT_INSERT_TABS: pStr=&aStrInsertTabs;break; 335 336 case SC_CAT_DELETE_COLS: pStr=&aStrDeleteCols;break; 337 338 case SC_CAT_DELETE_ROWS: pStr=&aStrDeleteRows;break; 339 340 case SC_CAT_DELETE_TABS: pStr=&aStrDeleteTabs;break; 341 342 case SC_CAT_MOVE: pStr=&aStrMove;break; 343 344 case SC_CAT_CONTENT: pStr=&aStrContent;break; 345 346 case SC_CAT_REJECT: pStr=&aStrReject;break; 347 348 default: pStr=&aUnknown;break; 349 } 350 return pStr; 351 } 352 353 354 sal_Bool ScAcceptChgDlg::IsValidAction(const ScChangeAction* pScChangeAction) 355 { 356 if(pScChangeAction==NULL) return sal_False; 357 358 sal_Bool bFlag=sal_False; 359 360 ScRange aRef=pScChangeAction->GetBigRange().MakeRange(); 361 String aUser=pScChangeAction->GetUser(); 362 DateTime aDateTime=pScChangeAction->GetDateTime(); 363 364 ScChangeActionType eType=pScChangeAction->GetType(); 365 String aString; 366 String aDesc; 367 368 String aComment=pScChangeAction->GetComment(); 369 aComment.EraseAllChars('\n'); 370 371 if(eType==SC_CAT_CONTENT) 372 { 373 if(!pScChangeAction->IsDialogParent()) 374 { 375 pScChangeAction->GetDescription( aDesc, pDoc, sal_True); 376 } 377 } 378 else 379 { 380 pScChangeAction->GetDescription( aDesc, pDoc,!pScChangeAction->IsMasterDelete()); 381 } 382 383 if(aDesc.Len()>0) 384 { 385 aComment.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " (" )); 386 aComment+=aDesc; 387 aComment+=')'; 388 } 389 390 if(pTheView->IsValidEntry(&aUser,&aDateTime,&aComment)) 391 { 392 if(pTPFilter->IsRange()) 393 { 394 ScRange* pRangeEntry=aRangeList.First(); 395 396 while(pRangeEntry!=NULL) 397 { 398 if(pRangeEntry->Intersects(aRef)) break; 399 pRangeEntry=aRangeList.Next(); 400 } 401 402 if(pRangeEntry!=NULL) 403 { 404 bFlag=sal_True; 405 } 406 } 407 else 408 { 409 bFlag=sal_True; 410 } 411 } 412 413 return bFlag; 414 } 415 416 SvLBoxEntry* ScAcceptChgDlg::InsertChangeAction(const ScChangeAction* pScChangeAction, 417 ScChangeActionState /* eState */, SvLBoxEntry* pParent, 418 sal_Bool bDelMaster,sal_Bool bDisabled,sal_uLong nPos) 419 { 420 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 421 422 if(pScChangeAction==NULL || pChanges==NULL) return NULL; 423 424 SvLBoxEntry* pEntry=NULL; 425 426 sal_Bool bFlag=sal_False; 427 428 ScRange aRef=pScChangeAction->GetBigRange().MakeRange(); 429 String aUser=pScChangeAction->GetUser(); 430 DateTime aDateTime=pScChangeAction->GetDateTime(); 431 432 String aRefStr; 433 ScChangeActionType eType=pScChangeAction->GetType(); 434 String aString; 435 String aDesc; 436 437 ScRedlinData* pNewData=new ScRedlinData; 438 pNewData->pData=(void *)pScChangeAction; 439 pNewData->nActionNo=pScChangeAction->GetActionNumber(); 440 pNewData->bIsAcceptable=pScChangeAction->IsClickable(); 441 pNewData->bIsRejectable=pScChangeAction->IsRejectable(); 442 pNewData->bDisabled=!pNewData->bIsAcceptable | bDisabled; 443 pNewData->aDateTime=aDateTime; 444 pNewData->nRow = aRef.aStart.Row(); 445 pNewData->nCol = aRef.aStart.Col(); 446 pNewData->nTable= aRef.aStart.Tab(); 447 448 if(eType==SC_CAT_CONTENT) 449 { 450 if(pScChangeAction->IsDialogParent()) 451 { 452 aString=aStrContentWithChild; 453 pNewData->nInfo=RD_SPECIAL_VISCONTENT; 454 pNewData->bIsRejectable=sal_False; 455 pNewData->bIsAcceptable=sal_False; 456 } 457 else 458 { 459 aString=*MakeTypeString(eType); 460 pScChangeAction->GetDescription( aDesc, pDoc, sal_True); 461 } 462 } 463 else 464 { 465 aString=*MakeTypeString(eType); 466 467 if(bDelMaster) 468 { 469 pScChangeAction->GetDescription( aDesc, pDoc,sal_True); 470 pNewData->bDisabled=sal_True; 471 pNewData->bIsRejectable=sal_False; 472 } 473 else 474 pScChangeAction->GetDescription( aDesc, pDoc,!pScChangeAction->IsMasterDelete()); 475 476 } 477 478 aString+='\t'; 479 pScChangeAction->GetRefString(aRefStr, pDoc, sal_True); 480 aString+=aRefStr; 481 aString+='\t'; 482 483 sal_Bool bIsGenerated; 484 485 if(!pChanges->IsGenerated(pScChangeAction->GetActionNumber())) 486 { 487 aString+=aUser; 488 aString+='\t'; 489 490 aString+=ScGlobal::pLocaleData->getDate(aDateTime); 491 aString+=' '; 492 aString+=ScGlobal::pLocaleData->getTime(aDateTime); 493 aString+='\t'; 494 bIsGenerated=sal_False; 495 } 496 else 497 { 498 aString+='\t'; 499 aString+='\t'; 500 bIsGenerated=sal_True; 501 } 502 503 String aComment=pScChangeAction->GetComment(); 504 aComment.EraseAllChars('\n'); 505 if(aDesc.Len()>0) 506 { 507 aComment.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " (" )); 508 aComment+=aDesc; 509 aComment+=')'; 510 } 511 512 aString+=aComment; 513 514 if(pTheView->IsValidEntry(&aUser,&aDateTime)|| bIsGenerated) 515 { 516 if(pTheView->IsValidComment(&aComment)) 517 { 518 if(pTPFilter->IsRange()) 519 { 520 ScRange* pRangeEntry=aRangeList.First(); 521 522 while(pRangeEntry!=NULL) 523 { 524 if(pRangeEntry->Intersects(aRef)) break; 525 pRangeEntry=aRangeList.Next(); 526 } 527 //SC_CAS_VIRGIN,SC_CAS_ACCEPTED,SC_CAS_REJECTED 528 if(pRangeEntry!=NULL) 529 { 530 bHasFilterEntry=sal_True; 531 bFlag=sal_True; 532 } 533 } 534 else if(!bIsGenerated) 535 { 536 bHasFilterEntry=sal_True; 537 bFlag=sal_True; 538 } 539 } 540 } 541 542 if(!bFlag&& bUseColor&& pParent==NULL) 543 { 544 pEntry=pTheView->InsertEntry(aString,pNewData,Color(COL_LIGHTBLUE),pParent,nPos); 545 } 546 else if(bFlag&& bUseColor&& pParent!=NULL) 547 { 548 pEntry=pTheView->InsertEntry(aString,pNewData,Color(COL_GREEN),pParent,nPos); 549 SvLBoxEntry* pExpEntry=pParent; 550 551 while(pExpEntry!=NULL && !pTheView->IsExpanded(pExpEntry)) 552 { 553 SvLBoxEntry* pTmpEntry=pTheView->GetParent(pExpEntry); 554 555 if(pTmpEntry!=NULL) pTheView->Expand(pExpEntry); 556 557 pExpEntry=pTmpEntry; 558 } 559 } 560 else 561 { 562 pEntry=pTheView->InsertEntry(aString,pNewData,pParent,nPos); 563 } 564 return pEntry; 565 } 566 567 SvLBoxEntry* ScAcceptChgDlg::InsertFilteredAction(const ScChangeAction* pScChangeAction, 568 ScChangeActionState eState,SvLBoxEntry* pParent, 569 sal_Bool bDelMaster,sal_Bool bDisabled,sal_uLong nPos) 570 { 571 572 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 573 574 if(pScChangeAction==NULL || pChanges==NULL) return NULL; 575 576 sal_Bool bIsGenerated=pChanges->IsGenerated(pScChangeAction->GetActionNumber()); 577 578 SvLBoxEntry* pEntry=NULL; 579 580 int bFlag=sal_False; 581 582 ScRange aRef=pScChangeAction->GetBigRange().MakeRange(); 583 String aUser=pScChangeAction->GetUser(); 584 DateTime aDateTime=pScChangeAction->GetDateTime(); 585 586 if(pTheView->IsValidEntry(&aUser,&aDateTime)||bIsGenerated) 587 { 588 if(pTPFilter->IsRange()) 589 { 590 ScRange* pRangeEntry=aRangeList.First(); 591 592 while(pRangeEntry!=NULL) 593 { 594 if(pRangeEntry->Intersects(aRef)) break; 595 pRangeEntry=aRangeList.Next(); 596 } 597 //SC_CAS_VIRGIN,SC_CAS_ACCEPTED,SC_CAS_REJECTED 598 if(pRangeEntry!=NULL && 599 pScChangeAction->GetState()==eState) 600 { 601 bFlag=sal_True; 602 } 603 } 604 else if(pScChangeAction->GetState()==eState && !bIsGenerated) 605 { 606 bFlag=sal_True; 607 } 608 } 609 610 if(bFlag) 611 { 612 613 String aRefStr; 614 ScChangeActionType eType=pScChangeAction->GetType(); 615 String aString; 616 String aDesc; 617 618 619 ScRedlinData* pNewData=new ScRedlinData; 620 pNewData->pData=(void *)pScChangeAction; 621 pNewData->nActionNo=pScChangeAction->GetActionNumber(); 622 pNewData->bIsAcceptable=pScChangeAction->IsClickable(); 623 pNewData->bIsRejectable=pScChangeAction->IsRejectable(); 624 pNewData->bDisabled=!pNewData->bIsAcceptable | bDisabled; 625 pNewData->aDateTime=aDateTime; 626 pNewData->nRow = aRef.aStart.Row(); 627 pNewData->nCol = aRef.aStart.Col(); 628 pNewData->nTable= aRef.aStart.Tab(); 629 630 if(eType==SC_CAT_CONTENT) 631 { 632 if(pScChangeAction->IsDialogParent()) 633 { 634 aString=aStrContentWithChild; 635 pNewData->nInfo=RD_SPECIAL_VISCONTENT; 636 pNewData->bIsRejectable=sal_False; 637 pNewData->bIsAcceptable=sal_False; 638 } 639 else 640 { 641 aString=*MakeTypeString(eType); 642 pScChangeAction->GetDescription( aDesc, pDoc, sal_True); 643 } 644 } 645 else 646 { 647 aString=*MakeTypeString(eType); 648 649 if(bDelMaster) 650 { 651 pScChangeAction->GetDescription( aDesc, pDoc,sal_True); 652 pNewData->bDisabled=sal_True; 653 pNewData->bIsRejectable=sal_False; 654 } 655 else 656 pScChangeAction->GetDescription( aDesc, pDoc,!pScChangeAction->IsMasterDelete()); 657 658 } 659 660 aString+='\t'; 661 pScChangeAction->GetRefString(aRefStr, pDoc, sal_True); 662 aString+=aRefStr; 663 aString+='\t'; 664 665 if(!bIsGenerated) 666 { 667 aString+=aUser; 668 aString+='\t'; 669 aString+=ScGlobal::pLocaleData->getDate(aDateTime); 670 aString+=' '; 671 aString+=ScGlobal::pLocaleData->getTime(aDateTime); 672 aString+='\t'; 673 } 674 else 675 { 676 aString+='\t'; 677 aString+='\t'; 678 } 679 680 String aComment=pScChangeAction->GetComment(); 681 aComment.EraseAllChars('\n'); 682 if(aDesc.Len()>0) 683 { 684 aComment.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " (" )); 685 aComment+=aDesc; 686 aComment+=')'; 687 } 688 if(pTheView->IsValidComment(&aComment)) 689 { 690 aString+=aComment; 691 pEntry=pTheView->InsertEntry(aString,pNewData,pParent,nPos); 692 } 693 else 694 delete pNewData; 695 } 696 return pEntry; 697 } 698 699 SvLBoxEntry* ScAcceptChgDlg::InsertChangeActionContent(const ScChangeActionContent* pScChangeAction, 700 SvLBoxEntry* pParent, sal_uLong nSpecial) 701 { 702 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 703 SvLBoxEntry* pEntry=NULL; 704 705 if(pScChangeAction==NULL || pChanges==NULL) return NULL; 706 707 sal_Bool bIsGenerated=pChanges->IsGenerated(pScChangeAction->GetActionNumber()); 708 709 sal_Bool bFlag=sal_False; 710 711 ScRange aRef=pScChangeAction->GetBigRange().MakeRange(); 712 String aUser=pScChangeAction->GetUser(); 713 DateTime aDateTime=pScChangeAction->GetDateTime(); 714 715 if(pTheView->IsValidEntry(&aUser,&aDateTime)||bIsGenerated) 716 { 717 if(pTPFilter->IsRange()) 718 { 719 ScRange* pRangeEntry=aRangeList.First(); 720 721 while(pRangeEntry!=NULL) 722 { 723 if(pRangeEntry->Intersects(aRef)) break; 724 pRangeEntry=aRangeList.Next(); 725 } 726 //SC_CAS_VIRGIN,SC_CAS_ACCEPTED,SC_CAS_REJECTED 727 if(pRangeEntry!=NULL) 728 { 729 bFlag=sal_True; 730 } 731 } 732 else if(!bIsGenerated) 733 bFlag=sal_True; 734 } 735 736 String aRefStr; 737 String aString; 738 String a2String; 739 String aDesc; 740 741 if(nSpecial==RD_SPECIAL_CONTENT) 742 { 743 pScChangeAction->GetOldString(a2String); 744 if(a2String.Len()==0) a2String=aStrEmpty; 745 746 //aString+="\'"; 747 aString+=a2String; 748 //aString+="\'"; 749 750 aDesc=aStrChildOrgContent; 751 aDesc.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ": " )); 752 } 753 else 754 { 755 pScChangeAction->GetNewString(a2String); 756 if(a2String.Len()==0) 757 { 758 a2String=aStrEmpty; 759 aString+=a2String; 760 } 761 else 762 { 763 aString+='\''; 764 aString+=a2String; 765 aString+='\''; 766 a2String=aString; 767 } 768 aDesc=aStrChildContent; 769 770 } 771 772 aDesc+=a2String; 773 aString+='\t'; 774 pScChangeAction->GetRefString(aRefStr, pDoc, sal_True); 775 aString+=aRefStr; 776 aString+='\t'; 777 778 if(!bIsGenerated) 779 { 780 aString+=aUser; 781 aString+='\t'; 782 783 aString+=ScGlobal::pLocaleData->getDate(aDateTime); 784 aString+=' '; 785 aString+=ScGlobal::pLocaleData->getTime(aDateTime); 786 aString+='\t'; 787 } 788 else 789 { 790 aString+='\t'; 791 aString+='\t'; 792 } 793 String aComment=pScChangeAction->GetComment(); 794 aComment.EraseAllChars('\n'); 795 796 if(aDesc.Len()>0) 797 { 798 aComment.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " (" )); 799 aComment+=aDesc; 800 aComment+=')'; 801 } 802 803 aString+=aComment; 804 805 ScRedlinData* pNewData=new ScRedlinData; 806 pNewData->nInfo=nSpecial; 807 pNewData->pData=(void *)pScChangeAction; 808 pNewData->nActionNo=pScChangeAction->GetActionNumber(); 809 pNewData->bIsAcceptable=pScChangeAction->IsClickable(); 810 pNewData->bIsRejectable=sal_False; 811 pNewData->bDisabled=!pNewData->bIsAcceptable; 812 pNewData->aDateTime=aDateTime; 813 pNewData->nRow = aRef.aStart.Row(); 814 pNewData->nCol = aRef.aStart.Col(); 815 pNewData->nTable= aRef.aStart.Tab(); 816 817 if(pTheView->IsValidComment(&aComment) && bFlag) 818 { 819 bHasFilterEntry=sal_True; 820 pEntry=pTheView->InsertEntry(aString,pNewData,pParent); 821 } 822 else 823 pEntry=pTheView->InsertEntry(aString,pNewData,Color(COL_LIGHTBLUE),pParent); 824 return pEntry; 825 } 826 827 long ScAcceptChgDlg::PreNotify( NotifyEvent& rNEvt ) 828 { 829 if(rNEvt.GetType()==EVENT_GETFOCUS && bNeedsUpdate) 830 { 831 ClearView(); 832 UpdateView(); 833 bNoSelection=sal_False; 834 } 835 836 return SfxModelessDialog::PreNotify(rNEvt); 837 } 838 839 840 void ScAcceptChgDlg::UpdateView() 841 { 842 bNeedsUpdate=sal_False; 843 DateTime aDateTime; 844 SvLBoxEntry* pParent=NULL; 845 ScChangeTrack* pChanges=NULL; 846 const ScChangeAction* pScChangeAction=NULL; 847 bAcceptEnableFlag=sal_True; 848 bRejectEnableFlag=sal_True; 849 SetPointer(Pointer(POINTER_WAIT)); 850 pTheView->SetUpdateMode(sal_False); 851 sal_Bool bFilterFlag=pTPFilter->IsDate()||pTPFilter->IsRange()|| 852 pTPFilter->IsAuthor()||pTPFilter->IsComment(); 853 854 bUseColor=bFilterFlag; 855 856 if(pDoc!=NULL) 857 { 858 pChanges=pDoc->GetChangeTrack(); 859 if(pChanges!=NULL) 860 { 861 pScChangeAction=pChanges->GetFirst(); 862 } 863 } 864 ScChangeActionTable ActionTable; 865 sal_Bool bTheFlag=sal_False; 866 867 while(pScChangeAction!=NULL) 868 { 869 bHasFilterEntry=sal_False; 870 switch(pScChangeAction->GetState()) 871 { 872 case SC_CAS_VIRGIN: 873 874 if(pScChangeAction->IsDialogRoot()) 875 { 876 if(pScChangeAction->IsDialogParent()) 877 pParent=InsertChangeAction(pScChangeAction,SC_CAS_VIRGIN); 878 else 879 pParent=InsertFilteredAction(pScChangeAction,SC_CAS_VIRGIN); 880 } 881 else 882 pParent=NULL; 883 884 bTheFlag=sal_True; 885 break; 886 887 case SC_CAS_ACCEPTED: 888 pParent=NULL; 889 nAcceptCount++; 890 break; 891 892 case SC_CAS_REJECTED: 893 pParent=NULL; 894 nRejectCount++; 895 break; 896 } 897 898 if(pParent!=NULL && pScChangeAction->IsDialogParent()) 899 { 900 if(!bFilterFlag) 901 { 902 pParent->EnableChildsOnDemand(sal_True); 903 } 904 else 905 { 906 sal_Bool bTestFlag=bHasFilterEntry; 907 bHasFilterEntry=sal_False; 908 if(Expand(pChanges,pScChangeAction,pParent,!bTestFlag)&&!bTestFlag) 909 pTheView->RemoveEntry(pParent); 910 } 911 } 912 913 pScChangeAction=pScChangeAction->GetNext(); 914 } 915 916 if( bTheFlag && (!pDoc->IsDocEditable() || pChanges->IsProtected()) ) 917 bTheFlag=sal_False; 918 919 pTPView->EnableAccept(bTheFlag); 920 pTPView->EnableAcceptAll(bTheFlag); 921 pTPView->EnableReject(bTheFlag); 922 pTPView->EnableRejectAll(bTheFlag); 923 924 if(nAcceptCount>0) 925 { 926 pParent=pTheView->InsertEntry( 927 aStrAllAccepted, static_cast< RedlinData * >(NULL), 928 static_cast< SvLBoxEntry * >(NULL)); 929 pParent->EnableChildsOnDemand(sal_True); 930 } 931 if(nRejectCount>0) 932 { 933 pParent=pTheView->InsertEntry( 934 aStrAllRejected, static_cast< RedlinData * >(NULL), 935 static_cast< SvLBoxEntry * >(NULL)); 936 pParent->EnableChildsOnDemand(sal_True); 937 } 938 pTheView->SetUpdateMode(sal_True); 939 SetPointer(Pointer(POINTER_ARROW)); 940 SvLBoxEntry* pEntry=pTheView->First(); 941 if(pEntry!=NULL) 942 { 943 pTheView->Select(pEntry); 944 } 945 } 946 947 //---------------------------------------------------------------------------- 948 sal_Bool ScAcceptChgDlg::Close() 949 { 950 return SfxModelessDialog::Close(); 951 } 952 953 void ScAcceptChgDlg::Resize() 954 { 955 SfxModelessDialog::Resize(); 956 Size aOutSize=GetOutputSizePixel(); 957 aAcceptChgCtr.SetSizePixel(aOutSize); 958 } 959 960 IMPL_LINK( ScAcceptChgDlg, MinSizeHandle, SvxAcceptChgCtr*, pCtr ) 961 { 962 if(pCtr==&aAcceptChgCtr) 963 { 964 if(!IsRollUp()) 965 SetOutputSizePixel(MinSize); 966 } 967 return 0; 968 } 969 970 IMPL_LINK( ScAcceptChgDlg, RefHandle, SvxTPFilter*, EMPTYARG ) 971 { 972 sal_uInt16 nId =ScSimpleRefDlgWrapper::GetChildWindowId(); 973 974 ScSimpleRefDlgWrapper::SetDefaultPosSize(GetPosPixel(),GetSizePixel(),sal_True); 975 976 SC_MOD()->SetRefDialog( nId, sal_True ); 977 978 SfxViewFrame* pViewFrm = pViewData->GetViewShell()->GetViewFrame(); 979 ScSimpleRefDlgWrapper* pWnd =(ScSimpleRefDlgWrapper*)pViewFrm->GetChildWindow( nId ); 980 981 if(pWnd!=NULL) 982 { 983 // bSimpleRefDlgStarted=sal_True; 984 sal_uInt16 nAcceptId=ScAcceptChgDlgWrapper::GetChildWindowId(); 985 pViewFrm->ShowChildWindow(nAcceptId,sal_False); 986 pWnd->SetCloseHdl(LINK( this, ScAcceptChgDlg,RefInfoHandle)); 987 pWnd->SetRefString(pTPFilter->GetRange()); 988 pWnd->SetAutoReOpen(sal_False); 989 Window* pWin=pWnd->GetWindow(); 990 pWin->SetPosSizePixel(GetPosPixel(),GetSizePixel()); 991 Hide(); 992 pWin->SetText(GetText()); 993 pWnd->StartRefInput(); 994 } 995 return 0; 996 } 997 998 IMPL_LINK( ScAcceptChgDlg, RefInfoHandle, String*, pResult) 999 { 1000 sal_uInt16 nId; 1001 1002 // bSimpleRefDlgStarted=sal_False; 1003 ScSimpleRefDlgWrapper::SetAutoReOpen(sal_True); 1004 1005 SfxViewFrame* pViewFrm = pViewData->GetViewShell()->GetViewFrame(); 1006 if(pResult!=NULL) 1007 { 1008 pTPFilter->SetRange(*pResult); 1009 FilterHandle(pTPFilter); 1010 1011 nId = ScSimpleRefDlgWrapper::GetChildWindowId(); 1012 ScSimpleRefDlgWrapper* pWnd = (ScSimpleRefDlgWrapper*)pViewFrm->GetChildWindow( nId ); 1013 1014 if(pWnd!=NULL) 1015 { 1016 Window* pWin=pWnd->GetWindow(); 1017 Size aWinSize=pWin->GetSizePixel(); 1018 aWinSize.Width()=GetSizePixel().Width(); 1019 SetPosSizePixel(pWin->GetPosPixel(),aWinSize); 1020 Invalidate(); 1021 } 1022 nId = ScAcceptChgDlgWrapper::GetChildWindowId(); 1023 pViewFrm->ShowChildWindow( nId, sal_True ); 1024 } 1025 else 1026 { 1027 nId = ScAcceptChgDlgWrapper::GetChildWindowId(); 1028 pViewFrm->SetChildWindow( nId, sal_False ); 1029 } 1030 return 0; 1031 } 1032 1033 IMPL_LINK( ScAcceptChgDlg, FilterHandle, SvxTPFilter*, pRef ) 1034 { 1035 if(pRef!=NULL) 1036 { 1037 ClearView(); 1038 aRangeList.Clear(); 1039 aRangeList.Parse(pTPFilter->GetRange(),pDoc); 1040 UpdateView(); 1041 } 1042 return 0; 1043 } 1044 1045 IMPL_LINK( ScAcceptChgDlg, RejectHandle, SvxTPView*, pRef ) 1046 { 1047 SetPointer(Pointer(POINTER_WAIT)); 1048 1049 bIgnoreMsg=sal_True; 1050 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1051 1052 if(pRef!=NULL) 1053 { 1054 SvLBoxEntry* pEntry=pTheView->FirstSelected(); 1055 while(pEntry!=NULL) 1056 { 1057 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1058 if(pEntryData!=NULL) 1059 { 1060 ScChangeAction* pScChangeAction= 1061 (ScChangeAction*) pEntryData->pData; 1062 1063 if(pScChangeAction->GetType()==SC_CAT_INSERT_TABS) 1064 { 1065 pViewData->SetTabNo(0); 1066 } 1067 pChanges->Reject(pScChangeAction); 1068 } 1069 pEntry = pTheView->NextSelected(pEntry); 1070 } 1071 ScDocShell* pDocSh=pViewData->GetDocShell(); 1072 pDocSh->PostPaintExtras(); 1073 pDocSh->PostPaintGridAll(); 1074 pDocSh->GetUndoManager()->Clear(); 1075 pDocSh->SetDocumentModified(); 1076 ClearView(); 1077 UpdateView(); 1078 } 1079 SetPointer(Pointer(POINTER_ARROW)); 1080 1081 bIgnoreMsg=sal_False; 1082 return 0; 1083 } 1084 IMPL_LINK( ScAcceptChgDlg, AcceptHandle, SvxTPView*, pRef ) 1085 { 1086 SetPointer(Pointer(POINTER_WAIT)); 1087 1088 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1089 bIgnoreMsg=sal_True; 1090 if(pRef!=NULL) 1091 { 1092 SvLBoxEntry* pEntry=pTheView->FirstSelected(); 1093 while(pEntry!=NULL) 1094 { 1095 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1096 if(pEntryData!=NULL) 1097 { 1098 ScChangeAction* pScChangeAction= 1099 (ScChangeAction*) pEntryData->pData; 1100 if(pScChangeAction->GetType()==SC_CAT_CONTENT) 1101 { 1102 if(pEntryData->nInfo==RD_SPECIAL_CONTENT) 1103 { 1104 pChanges->SelectContent(pScChangeAction,sal_True); 1105 } 1106 else 1107 { 1108 pChanges->SelectContent(pScChangeAction); 1109 } 1110 } 1111 else 1112 pChanges->Accept(pScChangeAction); 1113 } 1114 pEntry = pTheView->NextSelected(pEntry); 1115 } 1116 ScDocShell* pDocSh=pViewData->GetDocShell(); 1117 pDocSh->PostPaintExtras(); 1118 pDocSh->PostPaintGridAll(); 1119 pDocSh->SetDocumentModified(); 1120 ClearView(); 1121 UpdateView(); 1122 } 1123 bIgnoreMsg=sal_False; 1124 1125 return 0; 1126 } 1127 1128 void ScAcceptChgDlg::RejectFiltered() 1129 { 1130 if(pDoc==NULL) return; 1131 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1132 const ScChangeAction* pScChangeAction=NULL; 1133 1134 if(pChanges!=NULL) 1135 { 1136 pScChangeAction=pChanges->GetLast(); 1137 } 1138 1139 while(pScChangeAction!=NULL) 1140 { 1141 if(pScChangeAction->IsDialogRoot()) 1142 { 1143 if(IsValidAction(pScChangeAction)) 1144 { 1145 pChanges->Reject((ScChangeAction*)pScChangeAction); 1146 } 1147 } 1148 pScChangeAction=pScChangeAction->GetPrev(); 1149 } 1150 } 1151 void ScAcceptChgDlg::AcceptFiltered() 1152 { 1153 if(pDoc==NULL) return; 1154 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1155 const ScChangeAction* pScChangeAction=NULL; 1156 1157 if(pChanges!=NULL) 1158 { 1159 pScChangeAction=pChanges->GetLast(); 1160 } 1161 1162 while(pScChangeAction!=NULL) 1163 { 1164 if(pScChangeAction->IsDialogRoot()) 1165 { 1166 if(IsValidAction(pScChangeAction)) 1167 { 1168 pChanges->Accept((ScChangeAction*)pScChangeAction); 1169 } 1170 } 1171 pScChangeAction=pScChangeAction->GetPrev(); 1172 } 1173 } 1174 1175 IMPL_LINK( ScAcceptChgDlg, RejectAllHandle, SvxTPView*, EMPTYARG ) 1176 { 1177 SetPointer(Pointer(POINTER_WAIT)); 1178 bIgnoreMsg=sal_True; 1179 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1180 if(pChanges!=NULL) 1181 { 1182 if(pTPFilter->IsDate()||pTPFilter->IsAuthor()||pTPFilter->IsRange()||pTPFilter->IsComment()) 1183 { 1184 RejectFiltered(); 1185 } 1186 else 1187 { 1188 pChanges->RejectAll(); 1189 } 1190 pViewData->SetTabNo(0); 1191 1192 ScDocShell* pDocSh=pViewData->GetDocShell(); 1193 pDocSh->PostPaintExtras(); 1194 pDocSh->PostPaintGridAll(); 1195 pDocSh->GetUndoManager()->Clear(); 1196 pDocSh->SetDocumentModified(); 1197 ClearView(); 1198 UpdateView(); 1199 } 1200 SetPointer(Pointer(POINTER_ARROW)); 1201 1202 bIgnoreMsg=sal_False; 1203 1204 return 0; 1205 } 1206 1207 IMPL_LINK( ScAcceptChgDlg, AcceptAllHandle, SvxTPView*, EMPTYARG ) 1208 { 1209 SetPointer(Pointer(POINTER_WAIT)); 1210 1211 bIgnoreMsg=sal_True; 1212 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1213 if(pChanges!=NULL) 1214 { 1215 if(pTPFilter->IsDate()||pTPFilter->IsAuthor()||pTPFilter->IsRange()||pTPFilter->IsComment()) 1216 { 1217 AcceptFiltered(); 1218 } 1219 else 1220 { 1221 pChanges->AcceptAll(); 1222 } 1223 ScDocShell* pDocSh=pViewData->GetDocShell(); 1224 pDocSh->PostPaintExtras(); 1225 pDocSh->PostPaintGridAll(); 1226 pDocSh->SetDocumentModified(); 1227 ClearView(); 1228 UpdateView(); 1229 } 1230 bIgnoreMsg=sal_False; 1231 SetPointer(Pointer(POINTER_ARROW)); 1232 1233 return 0; 1234 } 1235 1236 IMPL_LINK( ScAcceptChgDlg, SelectHandle, SvxRedlinTable*, EMPTYARG ) 1237 { 1238 if(!bNoSelection) 1239 { 1240 aSelectionTimer.Start(); 1241 } 1242 bNoSelection=sal_False; 1243 return 0; 1244 } 1245 1246 void ScAcceptChgDlg::GetDependents( const ScChangeAction* pScChangeAction, 1247 ScChangeActionTable& aActionTable, 1248 SvLBoxEntry* pEntry) 1249 { 1250 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1251 1252 SvLBoxEntry* pParent=pTheView->GetParent(pEntry); 1253 if(pParent!=NULL) 1254 { 1255 ScRedlinData *pParentData=(ScRedlinData *)(pParent->GetUserData()); 1256 ScChangeAction* pParentAction=(ScChangeAction*) pParentData->pData; 1257 if(pParentAction!=pScChangeAction) 1258 { 1259 pChanges->GetDependents((ScChangeAction*) pScChangeAction, 1260 aActionTable,pScChangeAction->IsMasterDelete()); 1261 } 1262 else 1263 { 1264 pChanges->GetDependents((ScChangeAction*) pScChangeAction, 1265 aActionTable); 1266 } 1267 } 1268 else 1269 { 1270 pChanges->GetDependents((ScChangeAction*) pScChangeAction, 1271 aActionTable,pScChangeAction->IsMasterDelete()); 1272 } 1273 } 1274 1275 sal_Bool ScAcceptChgDlg::InsertContentChilds(ScChangeActionTable* pActionTable,SvLBoxEntry* pParent) 1276 { 1277 sal_Bool bTheTestFlag=sal_True; 1278 ScRedlinData *pEntryData=(ScRedlinData *)(pParent->GetUserData()); 1279 const ScChangeAction* pScChangeAction = (ScChangeAction*) pEntryData->pData; 1280 sal_Bool bParentInserted = sal_False; 1281 // If the parent is a MatrixOrigin then place it in the right order before 1282 // the MatrixReferences. Also if it is the first content change at this 1283 // position don't insert the first dependent MatrixReference as the special 1284 // content (original value) but insert the predecessor of the MatrixOrigin 1285 // itself instead. 1286 if ( pScChangeAction->GetType() == SC_CAT_CONTENT && 1287 ((const ScChangeActionContent*)pScChangeAction)->IsMatrixOrigin() ) 1288 { 1289 pActionTable->Insert( pScChangeAction->GetActionNumber(), 1290 (ScChangeAction*) pScChangeAction ); 1291 bParentInserted = sal_True; 1292 } 1293 SvLBoxEntry* pEntry=NULL; 1294 1295 const ScChangeActionContent* pCChild=(const ScChangeActionContent*)pActionTable->First(); 1296 while(pCChild!=NULL) 1297 { 1298 if( pCChild->GetState()==SC_CAS_VIRGIN ) 1299 break; 1300 pCChild=(const ScChangeActionContent*)pActionTable->Next(); 1301 } 1302 1303 if(pCChild==NULL) return sal_True; 1304 1305 SvLBoxEntry* pOriginal=InsertChangeActionContent(pCChild,pParent,RD_SPECIAL_CONTENT); 1306 if(pOriginal!=NULL) 1307 { 1308 bTheTestFlag=sal_False; 1309 ScRedlinData *pParentData=(ScRedlinData *)(pOriginal->GetUserData()); 1310 pParentData->pData=(void *)pScChangeAction; 1311 pParentData->nActionNo=pScChangeAction->GetActionNumber(); 1312 pParentData->bIsAcceptable=pScChangeAction->IsRejectable(); // select old value 1313 pParentData->bIsRejectable=sal_False; 1314 pParentData->bDisabled=sal_False; 1315 } 1316 while(pCChild!=NULL) 1317 { 1318 if(pCChild->GetState()==SC_CAS_VIRGIN) 1319 { 1320 pEntry=InsertChangeActionContent(pCChild,pParent,RD_SPECIAL_NONE); 1321 1322 if(pEntry!=NULL) 1323 bTheTestFlag=sal_False; 1324 } 1325 pCChild=(const ScChangeActionContent*)pActionTable->Next(); 1326 } 1327 1328 if ( !bParentInserted ) 1329 { 1330 pEntry=InsertChangeActionContent((const ScChangeActionContent*) 1331 pScChangeAction,pParent,RD_SPECIAL_NONE); 1332 1333 if(pEntry!=NULL) 1334 { 1335 bTheTestFlag=sal_False; 1336 ScRedlinData *pParentData=(ScRedlinData *)(pEntry->GetUserData()); 1337 pParentData->pData=(void *)pScChangeAction; 1338 pParentData->nActionNo=pScChangeAction->GetActionNumber(); 1339 pParentData->bIsAcceptable=pScChangeAction->IsClickable(); 1340 pParentData->bIsRejectable=sal_False; 1341 pParentData->bDisabled=sal_False; 1342 } 1343 } 1344 1345 return bTheTestFlag; 1346 1347 } 1348 1349 sal_Bool ScAcceptChgDlg::InsertAcceptedORejected(SvLBoxEntry* pParent) 1350 { 1351 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1352 sal_Bool bTheTestFlag=sal_True; 1353 1354 ScChangeActionState eState = SC_CAS_VIRGIN; 1355 String aString=pTheView->GetEntryText( pParent); 1356 String a2String=aString.Copy(0,aStrAllAccepted.Len()); 1357 if(a2String==aStrAllAccepted) 1358 { 1359 eState=SC_CAS_ACCEPTED; 1360 } 1361 else 1362 { 1363 a2String=aString.Copy(0,aStrAllRejected.Len()); 1364 if(a2String==aStrAllRejected) 1365 { 1366 eState=SC_CAS_REJECTED; 1367 } 1368 } 1369 1370 ScChangeAction* pScChangeAction=pChanges->GetFirst(); 1371 while(pScChangeAction!=NULL) 1372 { 1373 if(pScChangeAction->GetState()==eState && 1374 InsertFilteredAction(pScChangeAction,eState,pParent)!=NULL) 1375 bTheTestFlag=sal_False; 1376 pScChangeAction=pScChangeAction->GetNext(); 1377 } 1378 return bTheTestFlag; 1379 } 1380 1381 sal_Bool ScAcceptChgDlg::InsertChilds(ScChangeActionTable* pActionTable,SvLBoxEntry* pParent) 1382 { 1383 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1384 sal_Bool bTheTestFlag=sal_True; 1385 SvLBoxEntry* pEntry=NULL; 1386 const ScChangeAction* pChild=(const ScChangeAction*)pActionTable->First(); 1387 while(pChild!=NULL) 1388 { 1389 pEntry=InsertChangeAction(pChild,SC_CAS_VIRGIN,pParent,sal_False,sal_True); 1390 1391 if(pEntry!=NULL) 1392 { 1393 bTheTestFlag=sal_False; 1394 1395 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1396 pEntryData->bIsRejectable=sal_False; 1397 pEntryData->bIsAcceptable=sal_False; 1398 pEntryData->bDisabled=sal_True; 1399 1400 if(pChild->IsDialogParent()) 1401 { 1402 1403 //pEntry->EnableChildsOnDemand(sal_True); 1404 Expand(pChanges,pChild,pEntry); 1405 } 1406 } 1407 pChild=pActionTable->Next(); 1408 } 1409 return bTheTestFlag; 1410 } 1411 sal_Bool ScAcceptChgDlg::InsertDeletedChilds(const ScChangeAction* pScChangeAction, 1412 ScChangeActionTable* pActionTable,SvLBoxEntry* pParent) 1413 { 1414 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1415 sal_Bool bTheTestFlag=sal_True; 1416 SvLBoxEntry* pEntry=NULL; 1417 ScChangeActionTable aDelActionTable; 1418 const ScChangeAction* pChild=(const ScChangeAction*)pActionTable->First(); 1419 1420 while(pChild!=NULL) 1421 { 1422 1423 if(pScChangeAction!=pChild) 1424 pEntry=InsertChangeAction(pChild,SC_CAS_VIRGIN,pParent,sal_False,sal_True); 1425 else 1426 pEntry=InsertChangeAction(pChild,SC_CAS_VIRGIN,pParent,sal_True,sal_True); 1427 1428 if(pEntry!=NULL) 1429 { 1430 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1431 pEntryData->bIsRejectable=sal_False; 1432 pEntryData->bIsAcceptable=sal_False; 1433 pEntryData->bDisabled=sal_True; 1434 1435 bTheTestFlag=sal_False; 1436 if ( pChild->IsDialogParent() ) 1437 { 1438 Expand(pChanges,pChild,pEntry); 1439 /* 1440 pChanges->GetDependents((ScChangeAction*) pChild,aDelActionTable); 1441 if(aDelActionTable.First()!=NULL) 1442 { 1443 pEntry->EnableChildsOnDemand(sal_True); 1444 } 1445 aDelActionTable.Clear(); 1446 */ 1447 } 1448 } 1449 pChild=pActionTable->Next(); 1450 } 1451 return bTheTestFlag; 1452 } 1453 1454 sal_Bool ScAcceptChgDlg::Expand(ScChangeTrack* pChanges,const ScChangeAction* pScChangeAction, 1455 SvLBoxEntry* pEntry,sal_Bool bFilter) 1456 { 1457 sal_Bool bTheTestFlag=sal_True; 1458 1459 if(pChanges!=NULL &&pEntry!=NULL &&pScChangeAction!=NULL) 1460 { 1461 ScChangeActionTable aActionTable; 1462 1463 GetDependents( pScChangeAction,aActionTable,pEntry); 1464 1465 switch(pScChangeAction->GetType()) 1466 { 1467 case SC_CAT_CONTENT: 1468 { 1469 InsertContentChilds(&aActionTable,pEntry); 1470 bTheTestFlag=!bHasFilterEntry; 1471 break; 1472 } 1473 case SC_CAT_DELETE_COLS: 1474 case SC_CAT_DELETE_ROWS: 1475 case SC_CAT_DELETE_TABS: 1476 { 1477 InsertDeletedChilds(pScChangeAction,&aActionTable,pEntry); 1478 bTheTestFlag=!bHasFilterEntry; 1479 break; 1480 } 1481 default: 1482 { 1483 if(!bFilter) 1484 bTheTestFlag=InsertChilds(&aActionTable,pEntry); 1485 break; 1486 } 1487 } 1488 aActionTable.Clear(); 1489 } 1490 return bTheTestFlag; 1491 } 1492 1493 IMPL_LINK( ScAcceptChgDlg, ExpandingHandle, SvxRedlinTable*, pTable ) 1494 { 1495 ScChangeTrack* pChanges=pDoc->GetChangeTrack(); 1496 ScChangeAction* pScChangeAction=NULL; 1497 SetPointer(Pointer(POINTER_WAIT)); 1498 if(pTable!=NULL && pChanges!=NULL) 1499 { 1500 ScChangeActionTable aActionTable; 1501 SvLBoxEntry* pEntry=pTheView->GetHdlEntry(); 1502 if(pEntry!=NULL) 1503 { 1504 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1505 if(pEntryData!=NULL) 1506 { 1507 pScChangeAction=(ScChangeAction*) pEntryData->pData; 1508 } 1509 1510 if(pEntry->HasChildsOnDemand()) 1511 { 1512 sal_Bool bTheTestFlag=sal_True; 1513 pEntry->EnableChildsOnDemand(sal_False); 1514 pTheView->RemoveEntry(pTheView->FirstChild(pEntry)); 1515 1516 if(pEntryData!=NULL) 1517 { 1518 pScChangeAction=(ScChangeAction*) pEntryData->pData; 1519 1520 GetDependents( pScChangeAction,aActionTable,pEntry); 1521 1522 switch(pScChangeAction->GetType()) 1523 { 1524 case SC_CAT_CONTENT: 1525 { 1526 bTheTestFlag=InsertContentChilds(&aActionTable,pEntry); 1527 break; 1528 } 1529 case SC_CAT_DELETE_COLS: 1530 case SC_CAT_DELETE_ROWS: 1531 case SC_CAT_DELETE_TABS: 1532 { 1533 bTheTestFlag=InsertDeletedChilds(pScChangeAction,&aActionTable,pEntry); 1534 break; 1535 } 1536 default: 1537 { 1538 bTheTestFlag=InsertChilds(&aActionTable,pEntry); 1539 break; 1540 } 1541 } 1542 aActionTable.Clear(); 1543 1544 } 1545 else 1546 { 1547 bTheTestFlag=InsertAcceptedORejected(pEntry); 1548 } 1549 if(bTheTestFlag) pTheView->InsertEntry(aStrNoEntry,NULL,Color(COL_GRAY),pEntry); 1550 } 1551 1552 } 1553 } 1554 SetPointer(Pointer(POINTER_ARROW)); 1555 return (sal_uLong) sal_True; 1556 } 1557 1558 1559 void ScAcceptChgDlg::AppendChanges(ScChangeTrack* pChanges,sal_uLong nStartAction, 1560 sal_uLong nEndAction, sal_uLong /* nPos */) 1561 { 1562 if(pChanges!=NULL) 1563 { 1564 DateTime aDateTime; 1565 SvLBoxEntry* pParent=NULL; 1566 const ScChangeAction* pScChangeAction=NULL; 1567 bAcceptEnableFlag=sal_True; 1568 bRejectEnableFlag=sal_True; 1569 SetPointer(Pointer(POINTER_WAIT)); 1570 pTheView->SetUpdateMode(sal_False); 1571 1572 ScChangeActionTable ActionTable; 1573 sal_Bool bTheFlag=sal_False; 1574 1575 sal_Bool bFilterFlag=pTPFilter->IsDate()||pTPFilter->IsRange()|| 1576 pTPFilter->IsAuthor()||pTPFilter->IsComment(); 1577 1578 bUseColor=bFilterFlag; 1579 1580 for(sal_uLong i=nStartAction;i<=nEndAction;i++) 1581 { 1582 pScChangeAction=pChanges->GetAction(i); 1583 if(pScChangeAction==NULL) continue; 1584 1585 1586 switch(pScChangeAction->GetState()) 1587 { 1588 case SC_CAS_VIRGIN: 1589 1590 if(pScChangeAction->IsDialogRoot()) 1591 { 1592 if(pScChangeAction->IsDialogParent()) 1593 pParent=InsertChangeAction(pScChangeAction,SC_CAS_VIRGIN); 1594 else 1595 pParent=InsertFilteredAction(pScChangeAction,SC_CAS_VIRGIN); 1596 } 1597 else 1598 pParent=NULL; 1599 1600 bTheFlag=sal_True; 1601 break; 1602 1603 case SC_CAS_ACCEPTED: 1604 pParent=NULL; 1605 nAcceptCount++; 1606 break; 1607 1608 case SC_CAS_REJECTED: 1609 pParent=NULL; 1610 nRejectCount++; 1611 break; 1612 } 1613 1614 if(pParent!=NULL && pScChangeAction->IsDialogParent()) 1615 { 1616 if(!bFilterFlag) 1617 { 1618 pParent->EnableChildsOnDemand(sal_True); 1619 } 1620 else 1621 { 1622 sal_Bool bTestFlag=bHasFilterEntry; 1623 bHasFilterEntry=sal_False; 1624 if(Expand(pChanges,pScChangeAction,pParent,!bTestFlag)&&!bTestFlag) 1625 pTheView->RemoveEntry(pParent); 1626 } 1627 } 1628 1629 pScChangeAction=pScChangeAction->GetNext(); 1630 } 1631 1632 if( bTheFlag && (!pDoc->IsDocEditable() || pChanges->IsProtected()) ) 1633 bTheFlag=sal_False; 1634 1635 pTPView->EnableAccept(bTheFlag); 1636 pTPView->EnableAcceptAll(bTheFlag); 1637 pTPView->EnableReject(bTheFlag); 1638 pTPView->EnableRejectAll(bTheFlag); 1639 1640 pTheView->SetUpdateMode(sal_True); 1641 SetPointer(Pointer(POINTER_ARROW)); 1642 } 1643 } 1644 1645 void ScAcceptChgDlg::RemoveEntrys(sal_uLong nStartAction,sal_uLong nEndAction) 1646 { 1647 1648 pTheView->SetUpdateMode(sal_False); 1649 1650 SvLBoxEntry* pEntry=pTheView->GetCurEntry(); 1651 1652 ScRedlinData *pEntryData=NULL; 1653 1654 if(pEntry!=NULL) 1655 pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1656 1657 sal_uLong nAction=0; 1658 if(pEntryData!=NULL) 1659 { 1660 nAction=pEntryData->nActionNo; 1661 } 1662 1663 if(nAction>=nStartAction && nAction<=nEndAction) 1664 { 1665 pTheView->SetCurEntry(pTheView->GetModel()->GetEntry(0)); 1666 } 1667 1668 sal_Bool bRemove=sal_False; 1669 1670 // MUST do it backwards, don't delete parents before children and GPF 1671 pEntry=pTheView->Last(); 1672 while(pEntry!=NULL) 1673 { 1674 bRemove=sal_False; 1675 pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1676 if(pEntryData!=NULL) 1677 { 1678 nAction=pEntryData->nActionNo; 1679 1680 if(nStartAction<=nAction && nAction<=nEndAction) bRemove=sal_True; 1681 1682 1683 } 1684 SvLBoxEntry* pPrevEntry = pTheView->Prev(pEntry); 1685 1686 if(bRemove) 1687 { 1688 //delete pEntryData; 1689 pTheView->RemoveEntry(pEntry); 1690 } 1691 pEntry=pPrevEntry; 1692 } 1693 pTheView->SetUpdateMode(sal_True); 1694 1695 } 1696 1697 void ScAcceptChgDlg::UpdateEntrys(ScChangeTrack* pChgTrack, sal_uLong nStartAction,sal_uLong nEndAction) 1698 { 1699 pTheView->SetUpdateMode(sal_False); 1700 1701 sal_uLong nPos=LIST_APPEND; 1702 1703 sal_Bool bRemove=sal_False; 1704 1705 SvLBoxEntry* pEntry=pTheView->First(); 1706 SvLBoxEntry* pNextEntry = (pEntry ? pTheView->NextSibling(pEntry) : NULL); 1707 SvLBoxEntry* pLastEntry=NULL; 1708 while(pEntry!=NULL) 1709 { 1710 bRemove=sal_False; 1711 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1712 if(pEntryData!=NULL) 1713 { 1714 ScChangeAction* pScChangeAction= 1715 (ScChangeAction*) pEntryData->pData; 1716 1717 sal_uLong nAction=pScChangeAction->GetActionNumber(); 1718 1719 if(nStartAction<=nAction && nAction<=nEndAction) bRemove=sal_True; 1720 } 1721 1722 if(bRemove) 1723 { 1724 nPos=pEntry->GetChildListPos(); 1725 pTheView->RemoveEntry(pEntry); 1726 1727 if(pLastEntry==NULL) pLastEntry=pTheView->First(); 1728 if(pLastEntry!=NULL) 1729 { 1730 pNextEntry=pTheView->Next(pLastEntry); 1731 1732 if(pNextEntry==NULL) 1733 { 1734 pNextEntry=pLastEntry; 1735 pLastEntry=NULL; 1736 } 1737 } 1738 else 1739 pNextEntry=NULL; 1740 1741 } 1742 else 1743 { 1744 pLastEntry = pEntry; 1745 pNextEntry = pTheView->Next(pEntry); 1746 } 1747 pEntry=pNextEntry; 1748 } 1749 1750 if(nStartAction==nEndAction) 1751 AppendChanges(pChgTrack,nStartAction,nEndAction,nPos); 1752 else 1753 AppendChanges(pChgTrack,nStartAction,nEndAction); 1754 1755 pTheView->SetUpdateMode(sal_True); 1756 1757 } 1758 1759 IMPL_LINK( ScAcceptChgDlg, ChgTrackModHdl, ScChangeTrack*, pChgTrack) 1760 { 1761 // if(bScAcceptChgDlgIsDead) return 0; 1762 1763 ScChangeTrackMsgQueue& aMsgQueue= pChgTrack->GetMsgQueue(); 1764 1765 ScChangeTrackMsgInfo* pTrackInfo=aMsgQueue.Get(); 1766 sal_uLong nStartAction; 1767 sal_uLong nEndAction; 1768 1769 while(pTrackInfo!=NULL) 1770 { 1771 nStartAction=pTrackInfo->nStartAction; 1772 nEndAction=pTrackInfo->nEndAction; 1773 1774 if(!bIgnoreMsg) 1775 { 1776 bNoSelection=sal_True; 1777 1778 switch(pTrackInfo->eMsgType) 1779 { 1780 case SC_CTM_APPEND: AppendChanges(pChgTrack,nStartAction,nEndAction); 1781 break; 1782 case SC_CTM_REMOVE: RemoveEntrys(nStartAction,nEndAction); 1783 break; 1784 case SC_CTM_PARENT: 1785 case SC_CTM_CHANGE: //bNeedsUpdate=sal_True; 1786 UpdateEntrys(pChgTrack,nStartAction,nEndAction); 1787 break; 1788 default: 1789 { 1790 // added to avoid warnings 1791 } 1792 } 1793 } 1794 delete pTrackInfo; 1795 pTrackInfo=aMsgQueue.Get(); 1796 } 1797 1798 return 0; 1799 } 1800 IMPL_LINK( ScAcceptChgDlg, ReOpenTimerHdl, Timer*, EMPTYARG ) 1801 { 1802 ScSimpleRefDlgWrapper::SetAutoReOpen(sal_True); 1803 aAcceptChgCtr.ShowFilterPage(); 1804 RefHandle(NULL); 1805 1806 return 0; 1807 } 1808 1809 IMPL_LINK( ScAcceptChgDlg, UpdateSelectionHdl, Timer*, EMPTYARG ) 1810 { 1811 ScTabView* pTabView = pViewData->GetView(); 1812 1813 sal_Bool bAcceptFlag = sal_True; 1814 sal_Bool bRejectFlag = sal_True; 1815 sal_Bool bContMark = sal_False; 1816 1817 pTabView->DoneBlockMode(); // clears old marking 1818 SvLBoxEntry* pEntry = pTheView->FirstSelected(); 1819 while( pEntry ) 1820 { 1821 ScRedlinData* pEntryData = (ScRedlinData*) pEntry->GetUserData(); 1822 if( pEntryData ) 1823 { 1824 bRejectFlag &= pEntryData->bIsRejectable; 1825 bAcceptFlag &= pEntryData->bIsAcceptable; 1826 1827 const ScChangeAction* pScChangeAction = (ScChangeAction*) pEntryData->pData; 1828 if( pScChangeAction && (pScChangeAction->GetType() != SC_CAT_DELETE_TABS) && 1829 (!pEntryData->bDisabled || pScChangeAction->IsVisible()) ) 1830 { 1831 const ScBigRange& rBigRange = pScChangeAction->GetBigRange(); 1832 if( rBigRange.IsValid( pDoc ) && IsActive() ) 1833 { 1834 sal_Bool bSetCursor = !pTheView->NextSelected( pEntry ); 1835 pTabView->MarkRange( rBigRange.MakeRange(), bSetCursor, bContMark ); 1836 bContMark = sal_True; 1837 } 1838 } 1839 } 1840 else 1841 { 1842 bAcceptFlag = sal_False; 1843 bRejectFlag = sal_False; 1844 } 1845 bAcceptEnableFlag = bAcceptFlag; 1846 bRejectEnableFlag = bRejectFlag; 1847 1848 pEntry = pTheView->NextSelected( pEntry ); 1849 } 1850 1851 ScChangeTrack* pChanges = pDoc->GetChangeTrack(); 1852 sal_Bool bEnable = pDoc->IsDocEditable() && pChanges && !pChanges->IsProtected(); 1853 pTPView->EnableAccept( bAcceptFlag && bEnable ); 1854 pTPView->EnableReject( bRejectFlag && bEnable ); 1855 1856 return 0; 1857 } 1858 1859 IMPL_LINK( ScAcceptChgDlg, CommandHdl, Control*, EMPTYARG ) 1860 { 1861 1862 const CommandEvent aCEvt(pTheView->GetCommandEvent()); 1863 1864 if(aCEvt.GetCommand()==COMMAND_CONTEXTMENU) 1865 { 1866 ScPopupMenu aPopup(ScResId(RID_POPUP_CHANGES)); 1867 1868 aPopup.SetMenuFlags(MENU_FLAG_HIDEDISABLEDENTRIES); 1869 1870 SvLBoxEntry* pEntry=pTheView->GetCurEntry(); 1871 if(pEntry!=NULL) 1872 { 1873 pTheView->Select(pEntry); 1874 } 1875 else 1876 { 1877 aPopup.Deactivate(); 1878 } 1879 1880 sal_uInt16 nSortedCol= pTheView->GetSortedCol(); 1881 1882 if(nSortedCol!=0xFFFF) 1883 { 1884 sal_uInt16 nItemId=nSortedCol+SC_SUB_SORT+1; 1885 1886 aPopup.CheckItem(nItemId); 1887 1888 PopupMenu *pSubMenu = aPopup.GetPopupMenu(SC_SUB_SORT); 1889 if (pSubMenu) 1890 { 1891 pSubMenu->CheckItem(nItemId); 1892 } 1893 } 1894 1895 aPopup.EnableItem(SC_CHANGES_COMMENT,sal_False); 1896 1897 if(pDoc->IsDocEditable() && pEntry!=NULL) 1898 { 1899 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1900 if(pEntryData!=NULL) 1901 { 1902 ScChangeAction* pScChangeAction= 1903 (ScChangeAction*) pEntryData->pData; 1904 if(pScChangeAction!=NULL && !pTheView->GetParent(pEntry)) 1905 aPopup.EnableItem(SC_CHANGES_COMMENT); 1906 } 1907 } 1908 1909 sal_uInt16 nCommand=aPopup.Execute( this, GetPointerPosPixel() ); 1910 1911 1912 if(nCommand) 1913 { 1914 if(nCommand==SC_CHANGES_COMMENT) 1915 { 1916 if(pEntry!=NULL) 1917 { 1918 ScRedlinData *pEntryData=(ScRedlinData *)(pEntry->GetUserData()); 1919 if(pEntryData!=NULL) 1920 { 1921 ScChangeAction* pScChangeAction= 1922 (ScChangeAction*) pEntryData->pData; 1923 1924 pViewData->GetDocShell()->ExecuteChangeCommentDialog( pScChangeAction, this,sal_False); 1925 } 1926 } 1927 } 1928 else 1929 { 1930 sal_Bool bSortDir=pTheView->GetSortDirection(); 1931 sal_uInt16 nDialogCol=nCommand-SC_SUB_SORT-1; 1932 if(nSortedCol==nDialogCol) bSortDir=!bSortDir; 1933 pTheView->SortByCol(nDialogCol,bSortDir); 1934 /* 1935 SC_SUB_SORT 1936 SC_SORT_ACTION 1937 SC_SORT_POSITION 1938 SC_SORT_AUTHOR 1939 SC_SORT_DATE 1940 SC_SORT_COMMENT 1941 */ 1942 } 1943 } 1944 } 1945 return 0; 1946 } 1947 1948 void ScAcceptChgDlg::Initialize(SfxChildWinInfo *pInfo) 1949 { 1950 String aStr; 1951 if(pInfo!=NULL) 1952 { 1953 if ( pInfo->aExtraString.Len() ) 1954 { 1955 xub_StrLen nPos = pInfo->aExtraString.Search( 1956 String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("AcceptChgDat:"))); 1957 1958 // Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn 1959 // er nicht vorhanden ist, liegt eine "altere Version vor 1960 if ( nPos != STRING_NOTFOUND ) 1961 { 1962 xub_StrLen n1 = pInfo->aExtraString.Search('(', nPos); 1963 if ( n1 != STRING_NOTFOUND ) 1964 { 1965 xub_StrLen n2 = pInfo->aExtraString.Search(')', n1); 1966 if ( n2 != STRING_NOTFOUND ) 1967 { 1968 // Alignment-String herausschneiden 1969 aStr = pInfo->aExtraString.Copy(nPos, n2 - nPos + 1); 1970 pInfo->aExtraString.Erase(nPos, n2 - nPos + 1); 1971 aStr.Erase(0, n1-nPos+1); 1972 } 1973 } 1974 } 1975 } 1976 } 1977 SfxModelessDialog::Initialize(pInfo); 1978 1979 if ( aStr.Len()) 1980 { 1981 sal_uInt16 nCount=(sal_uInt16)aStr.ToInt32(); 1982 1983 for(sal_uInt16 i=0;i<nCount;i++) 1984 { 1985 xub_StrLen n1 = aStr.Search(';'); 1986 aStr.Erase(0, n1+1); 1987 pTheView->SetTab(i,(sal_uInt16)aStr.ToInt32(),MAP_PIXEL); 1988 } 1989 } 1990 } 1991 1992 //------------------------------------------------------------------------- 1993 1994 void ScAcceptChgDlg::FillInfo(SfxChildWinInfo& rInfo) const 1995 { 1996 SfxModelessDialog::FillInfo(rInfo); 1997 rInfo.aExtraString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "AcceptChgDat:(" )); 1998 1999 sal_uInt16 nCount=pTheView->TabCount(); 2000 2001 rInfo.aExtraString += String::CreateFromInt32(nCount); 2002 rInfo.aExtraString += ';'; 2003 for(sal_uInt16 i=0;i<nCount;i++) 2004 { 2005 rInfo.aExtraString += String::CreateFromInt32(pTheView->GetTab(i)); 2006 rInfo.aExtraString += ';'; 2007 } 2008 rInfo.aExtraString += ')'; 2009 } 2010 2011 void ScAcceptChgDlg::InitFilter() 2012 { 2013 if(pTPFilter->IsDate()||pTPFilter->IsRange()|| 2014 pTPFilter->IsAuthor()||pTPFilter->IsComment()) 2015 { 2016 pTheView->SetFilterDate(pTPFilter->IsDate()); 2017 pTheView->SetDateTimeMode(pTPFilter->GetDateMode()); 2018 pTheView->SetFirstDate(pTPFilter->GetFirstDate()); 2019 pTheView->SetLastDate(pTPFilter->GetLastDate()); 2020 pTheView->SetFirstTime(pTPFilter->GetFirstTime()); 2021 pTheView->SetLastTime(pTPFilter->GetLastTime()); 2022 pTheView->SetFilterAuthor(pTPFilter->IsAuthor()); 2023 pTheView->SetAuthor(pTPFilter->GetSelectedAuthor()); 2024 2025 pTheView->SetFilterComment(pTPFilter->IsComment()); 2026 2027 utl::SearchParam aSearchParam( pTPFilter->GetComment(), 2028 utl::SearchParam::SRCH_REGEXP,sal_False,sal_False,sal_False ); 2029 2030 pTheView->SetCommentParams(&aSearchParam); 2031 2032 pTheView->UpdateFilterTest(); 2033 } 2034 } 2035 2036 //UNUSED2008-05 void ScAcceptChgDlg::SetMyStaticData() 2037 //UNUSED2008-05 { 2038 //UNUSED2008-05 } 2039 2040 IMPL_LINK( ScAcceptChgDlg, FilterModified, SvxTPFilter*, EMPTYARG ) 2041 { 2042 return 0; 2043 } 2044 2045 #define CALC_DATE 3 2046 #define CALC_POS 1 2047 2048 IMPL_LINK( ScAcceptChgDlg, ColCompareHdl, SvSortData*, pSortData ) 2049 { 2050 StringCompare eCompare=COMPARE_EQUAL; 2051 SCCOL nSortCol= static_cast<SCCOL>(pTheView->GetSortedCol()); 2052 2053 if(pSortData) 2054 { 2055 SvLBoxEntry* pLeft = (SvLBoxEntry*)(pSortData->pLeft ); 2056 SvLBoxEntry* pRight = (SvLBoxEntry*)(pSortData->pRight ); 2057 2058 if(CALC_DATE==nSortCol) 2059 { 2060 RedlinData *pLeftData=(RedlinData *)(pLeft->GetUserData()); 2061 RedlinData *pRightData=(RedlinData *)(pRight->GetUserData()); 2062 2063 if(pLeftData!=NULL && pRightData!=NULL) 2064 { 2065 if(pLeftData->aDateTime < pRightData->aDateTime) 2066 { 2067 eCompare=COMPARE_LESS; 2068 } 2069 else if(pLeftData->aDateTime > pRightData->aDateTime) 2070 { 2071 eCompare=COMPARE_GREATER; 2072 } 2073 return eCompare; 2074 } 2075 } 2076 else if(CALC_POS==nSortCol) 2077 { 2078 ScRedlinData *pLeftData=(ScRedlinData *)(pLeft->GetUserData()); 2079 ScRedlinData *pRightData=(ScRedlinData *)(pRight->GetUserData()); 2080 2081 if(pLeftData!=NULL && pRightData!=NULL) 2082 { 2083 eCompare=COMPARE_GREATER; 2084 2085 if(pLeftData->nTable < pRightData->nTable) 2086 { 2087 eCompare=COMPARE_LESS; 2088 } 2089 else if(pLeftData->nTable == pRightData->nTable) 2090 { 2091 if(pLeftData->nRow < pRightData->nRow) 2092 { 2093 eCompare=COMPARE_LESS; 2094 } 2095 else if(pLeftData->nRow == pRightData->nRow) 2096 { 2097 if(pLeftData->nCol < pRightData->nCol) 2098 { 2099 eCompare=COMPARE_LESS; 2100 } 2101 else if(pLeftData->nCol == pRightData->nCol) 2102 { 2103 eCompare=COMPARE_EQUAL; 2104 } 2105 } 2106 } 2107 2108 return eCompare; 2109 } 2110 } 2111 2112 SvLBoxItem* pLeftItem = pTheView->GetEntryAtPos( pLeft, static_cast<sal_uInt16>(nSortCol)); 2113 SvLBoxItem* pRightItem = pTheView->GetEntryAtPos( pRight, static_cast<sal_uInt16>(nSortCol)); 2114 2115 if(pLeftItem != NULL && pRightItem != NULL) 2116 { 2117 sal_uInt16 nLeftKind=pLeftItem->IsA(); 2118 sal_uInt16 nRightKind=pRightItem->IsA(); 2119 2120 if(nRightKind == SV_ITEM_ID_LBOXSTRING && 2121 nLeftKind == SV_ITEM_ID_LBOXSTRING ) 2122 { 2123 eCompare= (StringCompare) ScGlobal::GetCaseCollator()->compareString( 2124 ((SvLBoxString*)pLeftItem)->GetText(), 2125 ((SvLBoxString*)pRightItem)->GetText()); 2126 2127 if(eCompare==COMPARE_EQUAL) eCompare=COMPARE_LESS; 2128 } 2129 } 2130 2131 2132 } 2133 return eCompare; 2134 } 2135 2136