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::pCaseCollator->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