sc/source/ui/miscdlgs/conflictsdlg.cxx

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