sc/source/ui/miscdlgs/conflictsdlg.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: conflictsdlg.cxx,v $
  10  * $Revision: 1.5 $
  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 //-----------------------------------------------------------------------------
  35
  36 #include <vcl/msgbox.hxx>
  37
  38 #include "conflictsdlg.hxx"
  39 #include "conflictsdlg.hrc"
  40 #include "scresid.hxx"
  41 #include "viewdata.hxx"
  42 #include "tabview.hxx"
  43
  44
  45 //=============================================================================
  46 // struct ScConflictsListEntry
  47 //=============================================================================
  48
  49 bool ScConflictsListEntry::HasSharedAction( ULONG nSharedAction ) const
  50 {
  51     ScChangeActionList::const_iterator aEnd = maSharedActions.end();
  52     for ( ScChangeActionList::const_iterator aItr = maSharedActions.begin(); aItr != aEnd; ++aItr )
  53     {
  54         if ( *aItr == nSharedAction )
  55         {
  56             return true;
  57         }
  58     }
  59
  60     return false;
  61 }
  62
  63 bool ScConflictsListEntry::HasOwnAction( ULONG nOwnAction ) const
  64 {
  65     ScChangeActionList::const_iterator aEnd = maOwnActions.end();
  66     for ( ScChangeActionList::const_iterator aItr = maOwnActions.begin(); aItr != aEnd; ++aItr )
  67     {
  68         if ( *aItr == nOwnAction )
  69         {
  70             return true;
  71         }
  72     }
  73
  74     return false;
  75 }
  76
  77
  78 //=============================================================================
  79 // class ScConflictsListHelper
  80 //=============================================================================
  81
  82 //UNUSED2008-05  bool ScConflictsListHelper::HasSharedAction( ScConflictsList& rConflictsList, ULONG nSharedAction )
  83 //UNUSED2008-05  {
  84 //UNUSED2008-05      ScConflictsList::const_iterator aEnd = rConflictsList.end();
  85 //UNUSED2008-05      for ( ScConflictsList::const_iterator aItr = rConflictsList.begin(); aItr != aEnd; ++aItr )
  86 //UNUSED2008-05      {
  87 //UNUSED2008-05          if ( aItr->HasSharedAction( nSharedAction ) )
  88 //UNUSED2008-05          {
  89 //UNUSED2008-05              return true;
  90 //UNUSED2008-05          }
  91 //UNUSED2008-05      }
  92 //UNUSED2008-05
  93 //UNUSED2008-05      return false;
  94 //UNUSED2008-05  }
  95
  96 bool ScConflictsListHelper::HasOwnAction( ScConflictsList& rConflictsList, ULONG nOwnAction )
  97 {
  98     ScConflictsList::const_iterator aEnd = rConflictsList.end();
  99     for ( ScConflictsList::const_iterator aItr = rConflictsList.begin(); aItr != aEnd; ++aItr )
 100     {
 101         if ( aItr->HasOwnAction( nOwnAction ) )
 102         {
 103             return true;
 104         }
 105     }
 106
 107     return false;
 108 }
 109
 110 ScConflictsListEntry* ScConflictsListHelper::GetSharedActionEntry( ScConflictsList& rConflictsList, ULONG nSharedAction )
 111 {
 112     ScConflictsList::iterator aEnd = rConflictsList.end();
 113     for ( ScConflictsList::iterator aItr = rConflictsList.begin(); aItr != aEnd; ++aItr )
 114     {
 115         if ( aItr->HasSharedAction( nSharedAction ) )
 116         {
 117             return &(*aItr);
 118         }
 119     }
 120
 121     return NULL;
 122 }
 123
 124 ScConflictsListEntry* ScConflictsListHelper::GetOwnActionEntry( ScConflictsList& rConflictsList, ULONG nOwnAction )
 125 {
 126     ScConflictsList::iterator aEnd = rConflictsList.end();
 127     for ( ScConflictsList::iterator aItr = rConflictsList.begin(); aItr != aEnd; ++aItr )
 128     {
 129         if ( aItr->HasOwnAction( nOwnAction ) )
 130         {
 131             return &(*aItr);
 132         }
 133     }
 134
 135     return NULL;
 136 }
 137
 138 void ScConflictsListHelper::Transform_Impl( ScChangeActionList& rActionList, ScChangeActionMergeMap* pMergeMap )
 139 {
 140     if ( !pMergeMap )
 141     {
 142         return;
 143     }
 144
 145     for ( ScChangeActionList::iterator aItr = rActionList.begin(); aItr != rActionList.end(); )
 146     {
 147         ScChangeActionMergeMap::iterator aItrMap = pMergeMap->find( *aItr );
 148         if ( aItrMap != pMergeMap->end() )
 149         {
 150             *aItr = aItrMap->second;
 151             aItr++;
 152         }
 153         else
 154         {
 155             aItr = rActionList.erase( aItr );
 156             DBG_ERROR( "ScConflictsListHelper::Transform_Impl: erased action from conflicts list!" );
 157         }
 158     }
 159 }
 160
 161 void ScConflictsListHelper::TransformConflictsList( ScConflictsList& rConflictsList,
 162     ScChangeActionMergeMap* pSharedMap, ScChangeActionMergeMap* pOwnMap )
 163 {
 164     ScConflictsList::iterator aEnd = rConflictsList.end();
 165     for ( ScConflictsList::iterator aItr = rConflictsList.begin(); aItr != aEnd; ++aItr )
 166     {
 167         if ( pSharedMap )
 168         {
 169             ScConflictsListHelper::Transform_Impl( aItr->maSharedActions, pSharedMap );
 170         }
 171
 172         if ( pOwnMap )
 173         {
 174             ScConflictsListHelper::Transform_Impl( aItr->maOwnActions, pOwnMap );
 175         }
 176     }
 177 }
 178
 179
 180 //=============================================================================
 181 // class ScConflictsFinder
 182 //=============================================================================
 183
 184 ScConflictsFinder::ScConflictsFinder( ScChangeTrack* pTrack, ULONG nStartShared, ULONG nEndShared,
 185         ULONG nStartOwn, ULONG nEndOwn, ScConflictsList& rConflictsList )
 186     :mpTrack( pTrack )
 187     ,mnStartShared( nStartShared )
 188     ,mnEndShared( nEndShared )
 189     ,mnStartOwn( nStartOwn )
 190     ,mnEndOwn( nEndOwn )
 191     ,mrConflictsList( rConflictsList )
 192 {
 193 }
 194
 195 ScConflictsFinder::~ScConflictsFinder()
 196 {
 197 }
 198
 199 bool ScConflictsFinder::DoActionsIntersect( const ScChangeAction* pAction1, const ScChangeAction* pAction2 )
 200 {
 201     if ( pAction1 && pAction2 && pAction1->GetBigRange().Intersects( pAction2->GetBigRange() ) )
 202     {
 203         return true;
 204     }
 205     return false;
 206 }
 207
 208 ScConflictsListEntry* ScConflictsFinder::GetIntersectingEntry( const ScChangeAction* pAction ) const
 209 {
 210     ScConflictsList::iterator aEnd = mrConflictsList.end();
 211     for ( ScConflictsList::iterator aItr = mrConflictsList.begin(); aItr != aEnd; ++aItr )
 212     {
 213         ScChangeActionList::const_iterator aEndShared = aItr->maSharedActions.end();
 214         for ( ScChangeActionList::const_iterator aItrShared = aItr->maSharedActions.begin(); aItrShared != aEndShared; ++aItrShared )
 215         {
 216             if ( DoActionsIntersect( mpTrack->GetAction( *aItrShared ), pAction ) )
 217             {
 218                 return &(*aItr);
 219             }
 220         }
 221
 222         ScChangeActionList::const_iterator aEndOwn = aItr->maOwnActions.end();
 223         for ( ScChangeActionList::const_iterator aItrOwn = aItr->maOwnActions.begin(); aItrOwn != aEndOwn; ++aItrOwn )
 224         {
 225             if ( DoActionsIntersect( mpTrack->GetAction( *aItrOwn ), pAction ) )
 226             {
 227                 return &(*aItr);
 228             }
 229         }
 230     }
 231
 232     return NULL;
 233 }
 234
 235 ScConflictsListEntry* ScConflictsFinder::GetEntry( ULONG nSharedAction, const ScChangeActionList& rOwnActions )
 236 {
 237     // try to get a list entry which already contains the shared action
 238     ScConflictsListEntry* pEntry = ScConflictsListHelper::GetSharedActionEntry( mrConflictsList, nSharedAction );
 239     if ( pEntry )
 240     {
 241         return pEntry;
 242     }
 243
 244     // try to get a list entry for which the shared action intersects with any
 245     // other action of this entry
 246     pEntry = GetIntersectingEntry( mpTrack->GetAction( nSharedAction ) );
 247     if ( pEntry )
 248     {
 249         pEntry->maSharedActions.push_back( nSharedAction );
 250         return pEntry;
 251     }
 252
 253     // try to get a list entry for which any of the own actions intersects with
 254     // any other action of this entry
 255     ScChangeActionList::const_iterator aEnd = rOwnActions.end();
 256     for ( ScChangeActionList::const_iterator aItr = rOwnActions.begin(); aItr != aEnd; ++aItr )
 257     {
 258         pEntry = GetIntersectingEntry( mpTrack->GetAction( *aItr ) );
 259         if ( pEntry )
 260         {
 261             pEntry->maSharedActions.push_back( nSharedAction );
 262             return pEntry;
 263         }
 264     }
 265
 266     // if no entry was found, create a new one
 267     ScConflictsListEntry aEntry;
 268     aEntry.meConflictAction = SC_CONFLICT_ACTION_NONE;
 269     aEntry.maSharedActions.push_back( nSharedAction );
 270     mrConflictsList.push_back( aEntry );
 271     return &(mrConflictsList.back());
 272 }
 273
 274 bool ScConflictsFinder::Find()
 275 {
 276     if ( !mpTrack )
 277     {
 278         return false;
 279     }
 280
 281     bool bReturn = false;
 282     ScChangeAction* pSharedAction = mpTrack->GetAction( mnStartShared );
 283     while ( pSharedAction && pSharedAction->GetActionNumber() <= mnEndShared )
 284     {
 285         ScChangeActionList aOwnActions;
 286         ScChangeAction* pOwnAction = mpTrack->GetAction( mnStartOwn );
 287         while ( pOwnAction && pOwnAction->GetActionNumber() <= mnEndOwn )
 288         {
 289             if ( DoActionsIntersect( pSharedAction, pOwnAction ) )
 290             {
 291                 aOwnActions.push_back( pOwnAction->GetActionNumber() );
 292             }
 293             pOwnAction = pOwnAction->GetNext();
 294         }
 295
 296         if ( aOwnActions.size() )
 297         {
 298             ScConflictsListEntry* pEntry = GetEntry( pSharedAction->GetActionNumber(), aOwnActions );;
 299             ScChangeActionList::iterator aEnd = aOwnActions.end();
 300             for ( ScChangeActionList::iterator aItr = aOwnActions.begin(); aItr != aEnd; ++aItr )
 301             {
 302                 if ( pEntry && !ScConflictsListHelper::HasOwnAction( mrConflictsList, *aItr ) )
 303                 {
 304                     pEntry->maOwnActions.push_back( *aItr );
 305                 }
 306             }
 307             bReturn = true;
 308         }
 309
 310         pSharedAction = pSharedAction->GetNext();
 311     }
 312
 313     return bReturn;
 314 }
 315
 316 //=============================================================================
 317 // class ScConflictsResolver
 318 //=============================================================================
 319
 320 ScConflictsResolver::ScConflictsResolver( ScChangeTrack* pTrack, ScConflictsList& rConflictsList )
 321     :mpTrack ( pTrack )
 322     ,mrConflictsList ( rConflictsList )
 323 {
 324     DBG_ASSERT( mpTrack, "ScConflictsResolver CTOR: mpTrack is null!" );
 325 }
 326
 327 ScConflictsResolver::~ScConflictsResolver()
 328 {
 329 }
 330
 331 void ScConflictsResolver::HandleAction( ScChangeAction* pAction, bool bIsSharedAction,
 332     bool bHandleContentAction, bool bHandleNonContentAction )
 333 {
 334     if ( !mpTrack || !pAction )
 335     {
 336         return;
 337     }
 338
 339     if ( bIsSharedAction )
 340     {
 341         ScConflictsListEntry* pConflictEntry = ScConflictsListHelper::GetSharedActionEntry(
 342             mrConflictsList, pAction->GetActionNumber() );
 343         if ( pConflictEntry )
 344         {
 345             ScConflictAction eConflictAction = pConflictEntry->meConflictAction;
 346             if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_MINE )
 347             {
 348                 if ( pAction->GetType() == SC_CAT_CONTENT )
 349                 {
 350                     if ( bHandleContentAction )
 351                     {
 352                         mpTrack->Reject( pAction );
 353                     }
 354                 }
 355                 else
 356                 {
 357                     if ( bHandleNonContentAction )
 358                     {
 359                         mpTrack->Reject( pAction );
 360                     }
 361                 }
 362             }
 363             else if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_OTHER )
 364             {
 365                 if ( pAction->GetType() == SC_CAT_CONTENT )
 366                 {
 367                     if ( bHandleContentAction )
 368                     {
 369                         // do nothing
 370                         //mpTrack->SelectContent( pAction );
 371                     }
 372                 }
 373                 else
 374                 {
 375                     if ( bHandleNonContentAction )
 376                     {
 377                         // do nothing
 378                         //mpTrack->Accept( pAction );
 379                     }
 380                 }
 381             }
 382         }
 383     }
 384     else
 385     {
 386         ScConflictsListEntry* pConflictEntry = ScConflictsListHelper::GetOwnActionEntry(
 387             mrConflictsList, pAction->GetActionNumber() );
 388         if ( pConflictEntry )
 389         {
 390             ScConflictAction eConflictAction = pConflictEntry->meConflictAction;
 391             if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_MINE )
 392             {
 393                 if ( pAction->GetType() == SC_CAT_CONTENT )
 394                 {
 395                     if ( bHandleContentAction )
 396                     {
 397                         // do nothing
 398                         //mpTrack->SelectContent( pAction );
 399                     }
 400                 }
 401                 else
 402                 {
 403                     if ( bHandleNonContentAction )
 404                     {
 405                         // do nothing
 406                         //mpTrack->Accept( pAction );
 407                     }
 408                 }
 409             }
 410             else if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_OTHER )
 411             {
 412                 if ( pAction->GetType() == SC_CAT_CONTENT )
 413                 {
 414                     if ( bHandleContentAction )
 415                     {
 416                         mpTrack->Reject( pAction );
 417                     }
 418                 }
 419                 else
 420                 {
 421                     if ( bHandleNonContentAction )
 422                     {
 423                         mpTrack->Reject( pAction );
 424                     }
 425                 }
 426             }
 427         }
 428     }
 429 }
 430
 431
 432 //=============================================================================
 433 // class ScConflictsListBox
 434 //=============================================================================
 435
 436 //UNUSED2008-05  ScConflictsListBox::ScConflictsListBox( Window* pParent, WinBits nBits )
 437 //UNUSED2008-05      :SvxRedlinTable( pParent, nBits )
 438 //UNUSED2008-05  {
 439 //UNUSED2008-05  }
 440
 441 ScConflictsListBox::ScConflictsListBox( Window* pParent, const ResId& rResId )
 442     :SvxRedlinTable( pParent, rResId )
 443 {
 444 }
 445
 446 ScConflictsListBox::~ScConflictsListBox()
 447 {
 448 }
 449
 450 //UNUSED2008-05  ULONG ScConflictsListBox::GetRootEntryPos( const SvLBoxEntry* pRootEntry ) const
 451 //UNUSED2008-05  {
 452 //UNUSED2008-05      ULONG nPos = 0;
 453 //UNUSED2008-05      SvLBoxEntry* pEntry = GetRootLevelParent( First() );
 454 //UNUSED2008-05      while ( pEntry )
 455 //UNUSED2008-05      {
 456 //UNUSED2008-05          if ( pEntry == pRootEntry )
 457 //UNUSED2008-05          {
 458 //UNUSED2008-05              return nPos;
 459 //UNUSED2008-05          }
 460 //UNUSED2008-05          pEntry = NextSibling( pEntry );
 461 //UNUSED2008-05          ++nPos;
 462 //UNUSED2008-05      }
 463 //UNUSED2008-05      return 0xffffffff;
 464 //UNUSED2008-05  }
 465
 466
 467 //=============================================================================
 468 // class ScConflictsDlg
 469 //=============================================================================
 470
 471 ScConflictsDlg::ScConflictsDlg( Window* pParent, ScViewData* pViewData, ScDocument* pSharedDoc, ScConflictsList& rConflictsList )
 472     :ModalDialog( pParent, ScResId( RID_SCDLG_CONFLICTS ) )
 473     ,maFtConflicts      ( this, ScResId( FT_CONFLICTS ) )
 474     ,maLbConflicts      ( this, ScResId( LB_CONFLICTS ) )
 475     ,maBtnKeepMine      ( this, ScResId( BTN_KEEPMINE ) )
 476     ,maBtnKeepOther     ( this, ScResId( BTN_KEEPOTHER ) )
 477     ,maFlConflicts      ( this, ScResId( FL_CONFLICTS ) )
 478     ,maBtnKeepAllMine   ( this, ScResId( BTN_KEEPALLMINE ) )
 479     ,maBtnKeepAllOthers ( this, ScResId( BTN_KEEPALLOTHERS ) )
 480     ,maBtnCancel        ( this, ScResId( BTN_CANCEL ) )
 481     ,maBtnHelp          ( this, ScResId( BTN_HELP ) )
 482     ,maStrTitleConflict ( ScResId( STR_TITLE_CONFLICT ) )
 483     ,maStrTitleAuthor   ( ScResId( STR_TITLE_AUTHOR ) )
 484     ,maStrTitleDate     ( ScResId( STR_TITLE_DATE ) )
 485     ,maStrUnknownUser   ( ScResId( STR_UNKNOWN_USER ) )
 486     ,mpViewData         ( pViewData )
 487     ,mpOwnDoc           ( NULL )
 488     ,mpOwnTrack         ( NULL )
 489     ,mpSharedDoc        ( pSharedDoc )
 490     ,mpSharedTrack      ( NULL )
 491     ,mrConflictsList    ( rConflictsList )
 492     ,maDialogSize       ( GetSizePixel() )
 493     ,mbInSelectHdl      ( false )
 494     ,mbInDeselectHdl    ( false )
 495 {
 496     DBG_ASSERT( mpViewData, "ScConflictsDlg CTOR: mpViewData is null!" );
 497     mpOwnDoc = ( mpViewData ? mpViewData->GetDocument() : NULL );
 498     DBG_ASSERT( mpOwnDoc, "ScConflictsDlg CTOR: mpOwnDoc is null!" );
 499     mpOwnTrack = ( mpOwnDoc ? mpOwnDoc->GetChangeTrack() : NULL );
 500     DBG_ASSERT( mpOwnTrack, "ScConflictsDlg CTOR: mpOwnTrack is null!" );
 501     DBG_ASSERT( mpSharedDoc, "ScConflictsDlg CTOR: mpSharedDoc is null!" );
 502     mpSharedTrack = ( mpSharedDoc ? mpSharedDoc->GetChangeTrack() : NULL );
 503     DBG_ASSERT( mpSharedTrack, "ScConflictsDlg CTOR: mpSharedTrack is null!" );
 504
 505     FreeResource();
 506
 507     SetMinOutputSizePixel( maDialogSize );
 508
 509     long nTabs[] = { 3, 10, 216, 266 };
 510     maLbConflicts.SetTabs( nTabs );
 511
 512     String aTab( sal_Unicode( '\t' ) );
 513     String aHeader( maStrTitleConflict );
 514     aHeader += aTab;
 515     aHeader += maStrTitleAuthor;
 516     aHeader += aTab;
 517     aHeader += maStrTitleDate;
 518     maLbConflicts.InsertHeaderEntry( aHeader, HEADERBAR_APPEND, HIB_LEFT | HIB_LEFTIMAGE | HIB_VCENTER );
 519
 520     maLbConflicts.SetWindowBits( WB_HASLINES | WB_CLIPCHILDREN | WB_HASBUTTONS | WB_HASBUTTONSATROOT | WB_HSCROLL );
 521     maLbConflicts.SetSelectionMode( MULTIPLE_SELECTION );
 522     maLbConflicts.SetHighlightRange();
 523
 524     maSelectionTimer.SetTimeout( 100 );
 525     maSelectionTimer.SetTimeoutHdl( LINK( this, ScConflictsDlg, UpdateSelectionHdl ) );
 526
 527     maLbConflicts.SetSelectHdl( LINK( this, ScConflictsDlg, SelectHandle ) );
 528     maLbConflicts.SetDeselectHdl( LINK( this, ScConflictsDlg, DeselectHandle ) );
 529
 530     maBtnKeepMine.SetClickHdl( LINK( this, ScConflictsDlg, KeepMineHandle ) );
 531     maBtnKeepOther.SetClickHdl( LINK( this, ScConflictsDlg, KeepOtherHandle ) );
 532     maBtnKeepAllMine.SetClickHdl( LINK( this, ScConflictsDlg, KeepAllMineHandle ) );
 533     maBtnKeepAllOthers.SetClickHdl( LINK( this, ScConflictsDlg, KeepAllOthersHandle ) );
 534
 535     UpdateView();
 536
 537     SvLBoxEntry* pEntry = maLbConflicts.First();
 538     if ( pEntry != NULL )
 539     {
 540         maLbConflicts.Select( pEntry );
 541     }
 542 }
 543
 544 ScConflictsDlg::~ScConflictsDlg()
 545 {
 546 }
 547
 548 String ScConflictsDlg::GetConflictString( const ScConflictsListEntry& rConflictEntry )
 549 {
 550     String aString;
 551     if ( mpOwnTrack )
 552     {
 553         const ScChangeAction* pAction = mpOwnTrack->GetAction( rConflictEntry.maOwnActions[ 0 ] );
 554         if ( pAction && mpOwnDoc )
 555         {
 556             SCTAB nTab = pAction->GetBigRange().MakeRange().aStart.Tab();
 557             mpOwnDoc->GetName( nTab, aString );
 558         }
 559     }
 560     return aString;
 561 }
 562
 563 String ScConflictsDlg::GetActionString( const ScChangeAction* pAction, ScDocument* pDoc )
 564 {
 565     String aString;
 566
 567     DBG_ASSERT( pAction, "ScConflictsDlg::GetActionString(): pAction is null!" );
 568     DBG_ASSERT( pDoc, "ScConflictsDlg::GetActionString(): pDoc is null!" );
 569     if ( pAction && pDoc )
 570     {
 571         String aDesc;
 572         pAction->GetDescription( aDesc, pDoc, TRUE, false );
 573         aString += aDesc;
 574         aString += '\t';
 575
 576         String aUser = pAction->GetUser();
 577         aUser.EraseLeadingAndTrailingChars();
 578         if ( aUser.Len() == 0 )
 579         {
 580             aUser = maStrUnknownUser;
 581         }
 582         aString += aUser;
 583         aString += '\t';
 584
 585         DateTime aDateTime = pAction->GetDateTime();
 586         aString += ScGlobal::pLocaleData->getDate( aDateTime );
 587         aString += ' ';
 588         aString += ScGlobal::pLocaleData->getTime( aDateTime, FALSE );
 589         aString += '\t';
 590     }
 591
 592     return aString;
 593 }
 594
 595 void ScConflictsDlg::HandleListBoxSelection( bool bSelectHandle )
 596 {
 597     SvLBoxEntry* pSelEntry = maLbConflicts.GetCurEntry();
 598     if ( !pSelEntry )
 599     {
 600         pSelEntry = maLbConflicts.FirstSelected();
 601     }
 602     if ( !pSelEntry )
 603     {
 604         return;
 605     }
 606
 607     SvLBoxEntry* pRootEntry = maLbConflicts.GetRootLevelParent( pSelEntry );
 608     if ( pRootEntry )
 609     {
 610         if ( bSelectHandle )
 611         {
 612             maLbConflicts.SelectAll( FALSE );
 613         }
 614         if ( !maLbConflicts.IsSelected( pRootEntry ) )
 615         {
 616             maLbConflicts.Select( pRootEntry );
 617         }
 618         SvLBoxEntry* pEntry = maLbConflicts.FirstChild( pRootEntry );
 619         while ( pEntry )
 620         {
 621             if ( !maLbConflicts.IsSelected( pEntry ) )
 622             {
 623                 maLbConflicts.Select( pEntry );
 624             }
 625             pEntry = maLbConflicts.NextSibling( pEntry );
 626         }
 627     }
 628 }
 629
 630 IMPL_LINK( ScConflictsDlg, SelectHandle, SvxRedlinTable*, EMPTYARG )
 631 {
 632     if ( mbInSelectHdl || mbInDeselectHdl )
 633     {
 634         return 0;
 635     }
 636
 637     mbInSelectHdl = true;
 638     HandleListBoxSelection( true );
 639     maSelectionTimer.Start();
 640     mbInSelectHdl = false;
 641
 642     return 0;
 643 }
 644
 645 IMPL_LINK( ScConflictsDlg, DeselectHandle, SvxRedlinTable*, EMPTYARG )
 646 {
 647     if ( mbInDeselectHdl || mbInSelectHdl )
 648     {
 649         return 0;
 650     }
 651
 652     mbInDeselectHdl = true;
 653     HandleListBoxSelection( false );
 654     mbInDeselectHdl = false;
 655
 656     return 0;
 657 }
 658
 659 IMPL_LINK( ScConflictsDlg, UpdateSelectionHdl, Timer*, EMPTYARG )
 660 {
 661     if ( !mpViewData || !mpOwnDoc )
 662     {
 663         return 0;
 664     }
 665
 666     ScTabView* pTabView = reinterpret_cast< ScTabView* >( mpViewData->GetView() );
 667     pTabView->DoneBlockMode();
 668     BOOL bContMark = FALSE;
 669     SvLBoxEntry* pEntry = maLbConflicts.FirstSelected();
 670     while ( pEntry )
 671     {
 672         if ( pEntry != maLbConflicts.GetRootLevelParent( pEntry ) )
 673         {
 674             RedlinData* pUserData = static_cast< RedlinData* >( pEntry->GetUserData() );
 675             if  ( pUserData )
 676             {
 677                 ScChangeAction* pAction = static_cast< ScChangeAction* >( pUserData->pData );
 678                 if ( pAction && ( pAction->GetType() != SC_CAT_DELETE_TABS ) &&
 679                      ( pAction->IsClickable() || pAction->IsVisible() ) )
 680                 {
 681                     const ScBigRange& rBigRange = ( static_cast< const ScChangeAction* >( pAction ) )->GetBigRange();
 682                     if ( rBigRange.IsValid( mpOwnDoc ) )
 683                     {
 684                         BOOL bSetCursor = !maLbConflicts.NextSelected( pEntry );
 685                         pTabView->MarkRange( rBigRange.MakeRange(), bSetCursor, bContMark );
 686                         bContMark = TRUE;
 687                     }
 688                 }
 689             }
 690         }
 691         pEntry = maLbConflicts.NextSelected( pEntry );
 692     }
 693
 694     return 0;
 695 }
 696
 697 void ScConflictsDlg::SetConflictAction( SvLBoxEntry* pRootEntry, ScConflictAction eConflictAction )
 698 {
 699     RedlinData* pUserData = static_cast< RedlinData* >( pRootEntry ? pRootEntry->GetUserData() : NULL );
 700     ScConflictsListEntry* pConflictEntry = static_cast< ScConflictsListEntry* >( pUserData ? pUserData->pData : NULL );
 701     if ( pConflictEntry )
 702     {
 703         pConflictEntry->meConflictAction = eConflictAction;
 704     }
 705 }
 706
 707 void ScConflictsDlg::KeepHandler( bool bMine )
 708 {
 709     SvLBoxEntry* pEntry = maLbConflicts.FirstSelected();
 710     SvLBoxEntry* pRootEntry = ( pEntry ? maLbConflicts.GetRootLevelParent( pEntry ) : NULL );
 711     if ( !pRootEntry )
 712     {
 713         return;
 714     }
 715     SetPointer( Pointer( POINTER_WAIT ) );
 716     ScConflictAction eConflictAction = ( bMine ? SC_CONFLICT_ACTION_KEEP_MINE : SC_CONFLICT_ACTION_KEEP_OTHER );
 717     SetConflictAction( pRootEntry, eConflictAction );
 718     maLbConflicts.RemoveEntry( pRootEntry );
 719     SetPointer( Pointer( POINTER_ARROW ) );
 720     if ( maLbConflicts.GetEntryCount() == 0 )
 721     {
 722         EndDialog( RET_OK );
 723     }
 724 }
 725
 726 void ScConflictsDlg::KeepAllHandler( bool bMine )
 727 {
 728     SvLBoxEntry* pEntry = maLbConflicts.First();
 729     SvLBoxEntry* pRootEntry = ( pEntry ? maLbConflicts.GetRootLevelParent( pEntry ) : NULL );
 730     if ( !pRootEntry )
 731     {
 732         return;
 733     }
 734     SetPointer( Pointer( POINTER_WAIT ) );
 735     ScConflictAction eConflictAction = ( bMine ? SC_CONFLICT_ACTION_KEEP_MINE : SC_CONFLICT_ACTION_KEEP_OTHER );
 736     while ( pRootEntry )
 737     {
 738         SetConflictAction( pRootEntry, eConflictAction );
 739         pRootEntry = maLbConflicts.NextSibling( pRootEntry );
 740     }
 741     maLbConflicts.SetUpdateMode( FALSE );
 742     maLbConflicts.Clear();
 743     maLbConflicts.SetUpdateMode( TRUE );
 744     SetPointer( Pointer( POINTER_ARROW ) );
 745     EndDialog( RET_OK );
 746 }
 747
 748 IMPL_LINK( ScConflictsDlg, KeepMineHandle, void*, EMPTYARG )
 749 {
 750     KeepHandler( true );
 751
 752     return 0;
 753 }
 754
 755 IMPL_LINK( ScConflictsDlg, KeepOtherHandle, void*, EMPTYARG )
 756 {
 757     KeepHandler( false );
 758
 759     return 0;
 760 }
 761
 762 IMPL_LINK( ScConflictsDlg, KeepAllMineHandle, void*, EMPTYARG )
 763 {
 764     KeepAllHandler( true );
 765
 766     return 0;
 767 }
 768
 769 IMPL_LINK( ScConflictsDlg, KeepAllOthersHandle, void*, EMPTYARG )
 770 {
 771     KeepAllHandler( false );
 772
 773     return 0;
 774 }
 775
 776 void lcl_MoveControlX( Window& rWindow, long nDelta )
 777 {
 778     Point aPos( rWindow.GetPosPixel() );
 779     aPos.X() += nDelta;
 780     rWindow.SetPosPixel( aPos );
 781 }
 782
 783 void lcl_MoveControlY( Window& rWindow, long nDelta )
 784 {
 785     Point aPos( rWindow.GetPosPixel() );
 786     aPos.Y() += nDelta;
 787     rWindow.SetPosPixel( aPos );
 788 }
 789
 790 void lcl_ChangeControlWidth( Window& rWindow, long nDelta )
 791 {
 792     Size aSize( rWindow.GetSizePixel() );
 793     aSize.Width() += nDelta;
 794     rWindow.SetSizePixel( aSize );
 795 }
 796
 797 void lcl_ChangeControlHeight( Window& rWindow, long nDelta )
 798 {
 799     Size aSize( rWindow.GetSizePixel() );
 800     aSize.Height() += nDelta;
 801     rWindow.SetSizePixel( aSize );
 802 }
 803
 804 void ScConflictsDlg::Resize()
 805 {
 806     Size aSize( GetSizePixel() );
 807     long nDeltaWidth = aSize.Width() - maDialogSize.Width();
 808     long nDeltaHeight = aSize.Height() - maDialogSize.Height();
 809     maDialogSize = aSize;
 810
 811     lcl_ChangeControlWidth( maFtConflicts, nDeltaWidth );
 812
 813     lcl_ChangeControlWidth( maLbConflicts, nDeltaWidth );
 814     lcl_ChangeControlHeight( maLbConflicts, nDeltaHeight );
 815
 816     lcl_MoveControlX( maBtnKeepMine, nDeltaWidth / 2 );
 817     lcl_MoveControlY( maBtnKeepMine, nDeltaHeight );
 818
 819     lcl_MoveControlX( maBtnKeepOther, nDeltaWidth / 2 );
 820     lcl_MoveControlY( maBtnKeepOther, nDeltaHeight );
 821
 822     lcl_MoveControlY( maFlConflicts, nDeltaHeight );
 823     lcl_ChangeControlWidth( maFlConflicts, nDeltaWidth );
 824
 825     lcl_MoveControlX( maBtnKeepAllMine, nDeltaWidth );
 826     lcl_MoveControlY( maBtnKeepAllMine, nDeltaHeight );
 827
 828     lcl_MoveControlX( maBtnKeepAllOthers, nDeltaWidth );
 829     lcl_MoveControlY( maBtnKeepAllOthers, nDeltaHeight );
 830
 831     lcl_MoveControlX( maBtnCancel, nDeltaWidth );
 832     lcl_MoveControlY( maBtnCancel, nDeltaHeight );
 833
 834     lcl_MoveControlX( maBtnHelp, nDeltaWidth );
 835     lcl_MoveControlY( maBtnHelp, nDeltaHeight );
 836 }
 837
 838 void ScConflictsDlg::UpdateView()
 839 {
 840     ScConflictsList::iterator aEndItr = mrConflictsList.end();
 841     for ( ScConflictsList::iterator aItr = mrConflictsList.begin(); aItr != aEndItr; ++aItr )
 842     {
 843         ScConflictsListEntry* pConflictEntry = &(*aItr);
 844         if ( pConflictEntry && pConflictEntry->meConflictAction == SC_CONFLICT_ACTION_NONE )
 845         {
 846             RedlinData* pRootUserData = new RedlinData();
 847             pRootUserData->pData = static_cast< void* >( pConflictEntry );
 848             SvLBoxEntry* pRootEntry = maLbConflicts.InsertEntry( GetConflictString( *aItr ), pRootUserData );
 849
 850             ScChangeActionList::const_iterator aEndShared = aItr->maSharedActions.end();
 851             for ( ScChangeActionList::const_iterator aItrShared = aItr->maSharedActions.begin(); aItrShared != aEndShared; ++aItrShared )
 852             {
 853                 ScChangeAction* pAction = mpSharedTrack->GetAction( *aItrShared );
 854                 if ( pAction )
 855                 {
 856                     // only display shared top content entries
 857                     if ( pAction->GetType() == SC_CAT_CONTENT )
 858                     {
 859                         ScChangeActionContent* pNextContent = ( dynamic_cast< ScChangeActionContent* >( pAction ) )->GetNextContent();
 860                         if ( pNextContent && aItr->HasSharedAction( pNextContent->GetActionNumber() ) )
 861                         {
 862                             continue;
 863                         }
 864                     }
 865
 866                     String aString( GetActionString( pAction, mpSharedDoc ) );
 867                     maLbConflicts.InsertEntry( aString, static_cast< RedlinData* >( NULL ), pRootEntry );
 868                 }
 869             }
 870
 871             ScChangeActionList::const_iterator aEndOwn = aItr->maOwnActions.end();
 872             for ( ScChangeActionList::const_iterator aItrOwn = aItr->maOwnActions.begin(); aItrOwn != aEndOwn; ++aItrOwn )
 873             {
 874                 ScChangeAction* pAction = mpOwnTrack->GetAction( *aItrOwn );
 875                 if ( pAction )
 876                 {
 877                     // only display own top content entries
 878                     if ( pAction->GetType() == SC_CAT_CONTENT )
 879                     {
 880                         ScChangeActionContent* pNextContent = ( dynamic_cast< ScChangeActionContent* >( pAction ) )->GetNextContent();
 881                         if ( pNextContent && aItr->HasOwnAction( pNextContent->GetActionNumber() ) )
 882                         {
 883                             continue;
 884                         }
 885                     }
 886
 887                     String aString( GetActionString( pAction, mpOwnDoc ) );
 888                     RedlinData* pUserData = new RedlinData();
 889                     pUserData->pData = static_cast< void* >( pAction );
 890                     maLbConflicts.InsertEntry( aString, pUserData, pRootEntry );
 891                 }
 892             }
 893
 894             maLbConflicts.Expand( pRootEntry );
 895         }
 896     }
 897 }