sc/source/ui/miscdlgs/acredlin.cxx

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