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 <osl/diagnose.h>
  22
  23 #include <conflictsdlg.hxx>
  24 #include <o3tl/safeint.hxx>
  25 #include <strings.hrc>
  26 #include <scresid.hxx>
  27 #include <viewdata.hxx>
  28 #include <dbfunc.hxx>
  29 #include <chgtrack.hxx>
  30
  31 // struct ScConflictsListEntry
  32
  33 bool ScConflictsListEntry::HasSharedAction( sal_uLong nSharedAction ) const
  34 {
  35     auto aEnd = maSharedActions.cend();
  36     auto aItr = std::find(maSharedActions.cbegin(), aEnd, nSharedAction);
  37
  38     return aItr != aEnd;
  39 }
  40
  41 bool ScConflictsListEntry::HasOwnAction( sal_uLong nOwnAction ) const
  42 {
  43     auto aEnd = maOwnActions.cend();
  44     auto aItr = std::find(maOwnActions.cbegin(), aEnd, nOwnAction);
  45
  46     return aItr != aEnd;
  47 }
  48
  49
  50 bool ScConflictsListHelper::HasOwnAction( ScConflictsList& rConflictsList, sal_uLong nOwnAction )
  51 {
  52     return std::any_of(rConflictsList.begin(), rConflictsList.end(),
  53                        [nOwnAction](ScConflictsListEntry& rConflict) { return rConflict.HasOwnAction( nOwnAction ); });
  54 }
  55
  56 ScConflictsListEntry* ScConflictsListHelper::GetSharedActionEntry( ScConflictsList& rConflictsList, sal_uLong nSharedAction )
  57 {
  58     auto aEnd = rConflictsList.end();
  59     auto aItr = std::find_if(rConflictsList.begin(), aEnd,
  60         [nSharedAction](ScConflictsListEntry& rConflict) { return rConflict.HasSharedAction( nSharedAction ); });
  61
  62     if (aItr != aEnd)
  63         return &(*aItr);
  64
  65     return nullptr;
  66 }
  67
  68 ScConflictsListEntry* ScConflictsListHelper::GetOwnActionEntry( ScConflictsList& rConflictsList, sal_uLong nOwnAction )
  69 {
  70     auto aEnd = rConflictsList.end();
  71     auto aItr = std::find_if(rConflictsList.begin(), aEnd,
  72         [nOwnAction](ScConflictsListEntry& rConflict) { return rConflict.HasOwnAction( nOwnAction ); });
  73
  74     if (aItr != aEnd)
  75         return &(*aItr);
  76
  77     return nullptr;
  78 }
  79
  80 void ScConflictsListHelper::Transform_Impl( std::vector<sal_uLong>& rActionList, ScChangeActionMergeMap* pMergeMap )
  81 {
  82     if ( !pMergeMap )
  83     {
  84         return;
  85     }
  86
  87     for ( auto aItr = rActionList.begin(); aItr != rActionList.end(); )
  88     {
  89         ScChangeActionMergeMap::iterator aItrMap = pMergeMap->find( *aItr );
  90         if ( aItrMap != pMergeMap->end() )
  91         {
  92             *aItr = aItrMap->second;
  93             ++aItr;
  94         }
  95         else
  96         {
  97             aItr = rActionList.erase( aItr );
  98             OSL_FAIL( "ScConflictsListHelper::Transform_Impl: erased action from conflicts list!" );
  99         }
 100     }
 101 }
 102
 103 void ScConflictsListHelper::TransformConflictsList( ScConflictsList& rConflictsList,
 104     ScChangeActionMergeMap* pSharedMap, ScChangeActionMergeMap* pOwnMap )
 105 {
 106     for ( auto& rConflictEntry : rConflictsList )
 107     {
 108         if ( pSharedMap )
 109         {
 110             ScConflictsListHelper::Transform_Impl( rConflictEntry.maSharedActions, pSharedMap );
 111         }
 112
 113         if ( pOwnMap )
 114         {
 115             ScConflictsListHelper::Transform_Impl( rConflictEntry.maOwnActions, pOwnMap );
 116         }
 117     }
 118 }
 119
 120
 121 ScConflictsFinder::ScConflictsFinder( ScChangeTrack* pTrack, sal_uLong nStartShared, sal_uLong nEndShared,
 122         sal_uLong nStartOwn, sal_uLong nEndOwn, ScConflictsList& rConflictsList )
 123     :mpTrack( pTrack )
 124     ,mnStartShared( nStartShared )
 125     ,mnEndShared( nEndShared )
 126     ,mnStartOwn( nStartOwn )
 127     ,mnEndOwn( nEndOwn )
 128     ,mrConflictsList( rConflictsList )
 129 {
 130 }
 131
 132 bool ScConflictsFinder::DoActionsIntersect( const ScChangeAction* pAction1, const ScChangeAction* pAction2 )
 133 {
 134     return pAction1 && pAction2 && pAction1->GetBigRange().Intersects( pAction2->GetBigRange() );
 135 }
 136
 137 ScConflictsListEntry* ScConflictsFinder::GetIntersectingEntry( const ScChangeAction* pAction ) const
 138 {
 139     auto doActionsIntersect = [this, pAction](const sal_uLong& aAction) { return DoActionsIntersect( mpTrack->GetAction( aAction ), pAction ); };
 140
 141     for ( auto& rConflict : mrConflictsList )
 142     {
 143         if (std::any_of( rConflict.maSharedActions.cbegin(), rConflict.maSharedActions.cend(), doActionsIntersect ))
 144             return &rConflict;
 145
 146         if (std::any_of( rConflict.maOwnActions.cbegin(), rConflict.maOwnActions.cend(), doActionsIntersect ))
 147             return &rConflict;
 148     }
 149
 150     return nullptr;
 151 }
 152
 153 ScConflictsListEntry& ScConflictsFinder::GetEntry( sal_uLong nSharedAction, const std::vector<sal_uLong>& rOwnActions )
 154 {
 155     // try to get a list entry which already contains the shared action
 156     ScConflictsListEntry* pEntry = ScConflictsListHelper::GetSharedActionEntry( mrConflictsList, nSharedAction );
 157     if ( pEntry )
 158     {
 159         return *pEntry;
 160     }
 161
 162     // try to get a list entry for which the shared action intersects with any
 163     // other action of this entry
 164     pEntry = GetIntersectingEntry( mpTrack->GetAction( nSharedAction ) );
 165     if ( pEntry )
 166     {
 167         pEntry->maSharedActions.push_back( nSharedAction );
 168         return *pEntry;
 169     }
 170
 171     // try to get a list entry for which any of the own actions intersects with
 172     // any other action of this entry
 173     for ( auto& rOwnAction : rOwnActions )
 174     {
 175         pEntry = GetIntersectingEntry( mpTrack->GetAction( rOwnAction ) );
 176         if ( pEntry )
 177         {
 178             pEntry->maSharedActions.push_back( nSharedAction );
 179             return *pEntry;
 180         }
 181     }
 182
 183     // if no entry was found, create a new one
 184     ScConflictsListEntry aEntry;
 185     aEntry.meConflictAction = SC_CONFLICT_ACTION_NONE;
 186     aEntry.maSharedActions.push_back( nSharedAction );
 187     mrConflictsList.push_back( aEntry );
 188     return mrConflictsList.back();
 189 }
 190
 191 bool ScConflictsFinder::Find()
 192 {
 193     if ( !mpTrack )
 194     {
 195         return false;
 196     }
 197
 198     bool bReturn = false;
 199     ScChangeAction* pSharedAction = mpTrack->GetAction( mnStartShared );
 200     while ( pSharedAction && pSharedAction->GetActionNumber() <= mnEndShared )
 201     {
 202         std::vector<sal_uLong> aOwnActions;
 203         ScChangeAction* pOwnAction = mpTrack->GetAction( mnStartOwn );
 204         while ( pOwnAction && pOwnAction->GetActionNumber() <= mnEndOwn )
 205         {
 206             if ( DoActionsIntersect( pSharedAction, pOwnAction ) )
 207             {
 208                 aOwnActions.push_back( pOwnAction->GetActionNumber() );
 209             }
 210             pOwnAction = pOwnAction->GetNext();
 211         }
 212
 213         if ( !aOwnActions.empty() )
 214         {
 215             ScConflictsListEntry& rEntry = GetEntry(pSharedAction->GetActionNumber(), aOwnActions);
 216             for ( const auto& aOwnAction : aOwnActions )
 217             {
 218                 if (!ScConflictsListHelper::HasOwnAction(mrConflictsList, aOwnAction))
 219                 {
 220                     rEntry.maOwnActions.push_back(aOwnAction);
 221                 }
 222             }
 223             bReturn = true;
 224         }
 225
 226         pSharedAction = pSharedAction->GetNext();
 227     }
 228
 229     return bReturn;
 230 }
 231
 232
 233 ScConflictsResolver::ScConflictsResolver( ScChangeTrack* pTrack, ScConflictsList& rConflictsList )
 234     :mpTrack ( pTrack )
 235     ,mrConflictsList ( rConflictsList )
 236 {
 237     OSL_ENSURE( mpTrack, "ScConflictsResolver CTOR: mpTrack is null!" );
 238 }
 239
 240 void ScConflictsResolver::HandleAction( ScChangeAction* pAction, bool bIsSharedAction,
 241     bool bHandleContentAction, bool bHandleNonContentAction )
 242 {
 243     if ( !mpTrack || !pAction )
 244     {
 245         return;
 246     }
 247
 248     if ( bIsSharedAction )
 249     {
 250         ScConflictsListEntry* pConflictEntry = ScConflictsListHelper::GetSharedActionEntry(
 251             mrConflictsList, pAction->GetActionNumber() );
 252         if ( pConflictEntry )
 253         {
 254             ScConflictAction eConflictAction = pConflictEntry->meConflictAction;
 255             if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_MINE )
 256             {
 257                 if ( pAction->GetType() == SC_CAT_CONTENT )
 258                 {
 259                     if ( bHandleContentAction )
 260                     {
 261                         mpTrack->Reject( pAction );
 262                     }
 263                 }
 264                 else
 265                 {
 266                     if ( bHandleNonContentAction )
 267                     {
 268                         mpTrack->Reject( pAction );
 269                     }
 270                 }
 271             }
 272         }
 273     }
 274     else
 275     {
 276         ScConflictsListEntry* pConflictEntry = ScConflictsListHelper::GetOwnActionEntry(
 277             mrConflictsList, pAction->GetActionNumber() );
 278         if ( pConflictEntry )
 279         {
 280             ScConflictAction eConflictAction = pConflictEntry->meConflictAction;
 281             if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_MINE )
 282             {
 283                 if ( pAction->GetType() == SC_CAT_CONTENT )
 284                 {
 285                     if ( bHandleContentAction )
 286                     {
 287                         // do nothing
 288                         //mpTrack->SelectContent( pAction );
 289                     }
 290                 }
 291                 else
 292                 {
 293                     if ( bHandleNonContentAction )
 294                     {
 295                         // do nothing
 296                         //mpTrack->Accept( pAction );
 297                     }
 298                 }
 299             }
 300             else if ( eConflictAction == SC_CONFLICT_ACTION_KEEP_OTHER )
 301             {
 302                 if ( pAction->GetType() == SC_CAT_CONTENT )
 303                 {
 304                     if ( bHandleContentAction )
 305                     {
 306                         mpTrack->Reject( pAction );
 307                     }
 308                 }
 309                 else
 310                 {
 311                     if ( bHandleNonContentAction )
 312                     {
 313                         mpTrack->Reject( pAction );
 314                     }
 315                 }
 316             }
 317         }
 318     }
 319 }
 320
 321
 322 ScConflictsDlg::ScConflictsDlg(weld::Window* pParent, ScViewData* pViewData, ScDocument* pSharedDoc, ScConflictsList& rConflictsList)
 323     : GenericDialogController(pParent, u"modules/scalc/ui/conflictsdialog.ui"_ustr, u"ConflictsDialog"_ustr)
 324     , maStrUnknownUser   ( ScResId( STR_UNKNOWN_USER_CONFLICT ) )
 325     , mpViewData         ( pViewData )
 326     , mpOwnDoc           ( nullptr )
 327     , mpOwnTrack         ( nullptr )
 328     , mpSharedDoc        ( pSharedDoc )
 329     , mpSharedTrack      ( nullptr )
 330     , mrConflictsList    ( rConflictsList )
 331     , maSelectionIdle    ( "ScConflictsDlg maSelectionIdle" )
 332     , mbInSelectHdl      ( false )
 333     , m_xBtnKeepMine(m_xBuilder->weld_button(u"keepmine"_ustr))
 334     , m_xBtnKeepOther(m_xBuilder->weld_button(u"keepother"_ustr))
 335     , m_xBtnKeepAllMine(m_xBuilder->weld_button(u"keepallmine"_ustr))
 336     , m_xBtnKeepAllOthers(m_xBuilder->weld_button(u"keepallothers"_ustr))
 337     , m_xLbConflicts(new SvxRedlinTable(m_xBuilder->weld_tree_view(u"container"_ustr), nullptr,
 338                                         nullptr))
 339 {
 340     OSL_ENSURE( mpViewData, "ScConflictsDlg CTOR: mpViewData is null!" );
 341     mpOwnDoc = ( mpViewData ? &mpViewData->GetDocument() : nullptr );
 342     OSL_ENSURE( mpOwnDoc, "ScConflictsDlg CTOR: mpOwnDoc is null!" );
 343     mpOwnTrack = ( mpOwnDoc ? mpOwnDoc->GetChangeTrack() : nullptr );
 344     OSL_ENSURE( mpOwnTrack, "ScConflictsDlg CTOR: mpOwnTrack is null!" );
 345     OSL_ENSURE( mpSharedDoc, "ScConflictsDlg CTOR: mpSharedDoc is null!" );
 346     mpSharedTrack = ( mpSharedDoc ? mpSharedDoc->GetChangeTrack() : nullptr );
 347     OSL_ENSURE( mpSharedTrack, "ScConflictsDlg CTOR: mpSharedTrack is null!" );
 348
 349     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 350
 351     auto nDigitWidth = rTreeView.get_approximate_digit_width();
 352     std::vector<int> aWidths
 353     {
 354         o3tl::narrowing<int>(nDigitWidth * 60),
 355         o3tl::narrowing<int>(nDigitWidth * 20)
 356     };
 357     rTreeView.set_column_fixed_widths(aWidths);
 358
 359     rTreeView.set_selection_mode(SelectionMode::Multiple);
 360     rTreeView.set_size_request(-1, rTreeView.get_height_rows(16));
 361
 362     maSelectionIdle.SetInvokeHandler( LINK( this, ScConflictsDlg, UpdateSelectionHdl ) );
 363
 364     rTreeView.connect_selection_changed(LINK(this, ScConflictsDlg, SelectHandle));
 365
 366     m_xBtnKeepMine->connect_clicked( LINK( this, ScConflictsDlg, KeepMineHandle ) );
 367     m_xBtnKeepOther->connect_clicked( LINK( this, ScConflictsDlg, KeepOtherHandle ) );
 368     m_xBtnKeepAllMine->connect_clicked( LINK( this, ScConflictsDlg, KeepAllMineHandle ) );
 369     m_xBtnKeepAllOthers->connect_clicked( LINK( this, ScConflictsDlg, KeepAllOthersHandle ) );
 370
 371     UpdateView();
 372
 373     std::unique_ptr<weld::TreeIter> xEntry(rTreeView.make_iterator());
 374     if (rTreeView.get_iter_first(*xEntry))
 375         rTreeView.select(*xEntry);
 376 }
 377
 378 ScConflictsDlg::~ScConflictsDlg()
 379 {
 380 }
 381
 382 OUString ScConflictsDlg::GetConflictString( const ScConflictsListEntry& rConflictEntry )
 383 {
 384     OUString aString;
 385     if ( mpOwnTrack )
 386     {
 387         const ScChangeAction* pAction = mpOwnTrack->GetAction( rConflictEntry.maOwnActions[ 0 ] );
 388         if ( pAction && mpOwnDoc )
 389         {
 390             SCTAB nTab = pAction->GetBigRange().MakeRange( *mpOwnDoc ).aStart.Tab();
 391             mpOwnDoc->GetName( nTab, aString );
 392         }
 393     }
 394     return aString;
 395 }
 396
 397 void ScConflictsDlg::SetActionString(const ScChangeAction* pAction, ScDocument* pDoc, const weld::TreeIter& rEntry)
 398 {
 399     OSL_ENSURE( pAction, "ScConflictsDlg::GetActionString(): pAction is null!" );
 400     OSL_ENSURE( pDoc, "ScConflictsDlg::GetActionString(): pDoc is null!" );
 401     if (!pAction || !pDoc)
 402         return;
 403
 404     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 405     OUString aDesc = pAction->GetDescription(*pDoc, true, false);
 406     rTreeView.set_text(rEntry, aDesc, 0);
 407
 408     OUString aUser = comphelper::string::strip(pAction->GetUser(), ' ');
 409     if ( aUser.isEmpty() )
 410     {
 411         aUser = maStrUnknownUser;
 412     }
 413     rTreeView.set_text(rEntry, aUser, 1);
 414
 415     DateTime aDateTime = pAction->GetDateTime();
 416     OUString aString = ScGlobal::getLocaleData().getDate( aDateTime ) + " " +
 417         ScGlobal::getLocaleData().getTime( aDateTime, false );
 418     rTreeView.set_text(rEntry, aString, 2);
 419 }
 420
 421 void ScConflictsDlg::HandleListBoxSelection()
 422 {
 423     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 424     std::unique_ptr<weld::TreeIter> xEntry(rTreeView.make_iterator());
 425     bool bSelEntry = rTreeView.get_cursor(xEntry.get());
 426     if (!bSelEntry)
 427         bSelEntry = rTreeView.get_selected(xEntry.get());
 428     if (!bSelEntry)
 429         return;
 430
 431     bool bSelectHandle = rTreeView.is_selected(*xEntry);
 432
 433     while (rTreeView.get_iter_depth(*xEntry))
 434         rTreeView.iter_parent(*xEntry);
 435
 436     if (bSelectHandle)
 437         rTreeView.unselect_all();
 438     if (!rTreeView.is_selected(*xEntry))
 439         rTreeView.select(*xEntry);
 440     if (rTreeView.iter_children(*xEntry))
 441     {
 442         do
 443         {
 444             if (!rTreeView.is_selected(*xEntry))
 445                 rTreeView.select(*xEntry);
 446         } while (rTreeView.iter_next_sibling(*xEntry));
 447     }
 448 }
 449
 450 IMPL_LINK_NOARG(ScConflictsDlg, SelectHandle, weld::TreeView&, void)
 451 {
 452     if (mbInSelectHdl)
 453         return;
 454
 455     mbInSelectHdl = true;
 456     HandleListBoxSelection();
 457     maSelectionIdle.Start();
 458     mbInSelectHdl = false;
 459 }
 460
 461 IMPL_LINK_NOARG(ScConflictsDlg, UpdateSelectionHdl, Timer *, void)
 462 {
 463     if ( !mpViewData || !mpOwnDoc )
 464     {
 465         return;
 466     }
 467
 468     ScTabView* pTabView = mpViewData->GetView();
 469     pTabView->DoneBlockMode();
 470
 471     std::vector<const ScChangeAction*> aActions;
 472
 473     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 474     rTreeView.selected_foreach([&rTreeView, &aActions](weld::TreeIter& rEntry){
 475         if (rTreeView.get_iter_depth(rEntry))
 476         {
 477             RedlinData* pUserData = weld::fromId<RedlinData*>(rTreeView.get_id(rEntry));
 478             if  (pUserData)
 479             {
 480                 ScChangeAction* pAction = static_cast< ScChangeAction* >( pUserData->pData );
 481                 if ( pAction && ( pAction->GetType() != SC_CAT_DELETE_TABS ) &&
 482                      ( pAction->IsClickable() || pAction->IsVisible() ) )
 483                 {
 484                     aActions.push_back(pAction);
 485                 }
 486             }
 487         }
 488         return false;
 489     });
 490
 491     bool bContMark = false;
 492     for (size_t i = 0, nCount = aActions.size(); i < nCount; ++i)
 493     {
 494         const ScBigRange& rBigRange = aActions[i]->GetBigRange();
 495         if (rBigRange.IsValid(*mpOwnDoc))
 496         {
 497             bool bSetCursor = i == nCount - 1;
 498             pTabView->MarkRange(rBigRange.MakeRange( *mpOwnDoc ), bSetCursor, bContMark);
 499             bContMark = true;
 500         }
 501     }
 502 }
 503
 504 void ScConflictsDlg::SetConflictAction(const weld::TreeIter& rRootEntry, ScConflictAction eConflictAction)
 505 {
 506     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 507     RedlinData* pUserData = weld::fromId<RedlinData*>(rTreeView.get_id(rRootEntry));
 508     ScConflictsListEntry* pConflictEntry = static_cast< ScConflictsListEntry* >( pUserData ? pUserData->pData : nullptr );
 509     if ( pConflictEntry )
 510     {
 511         pConflictEntry->meConflictAction = eConflictAction;
 512     }
 513 }
 514
 515 void ScConflictsDlg::KeepHandler(bool bMine)
 516 {
 517     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 518     std::unique_ptr<weld::TreeIter> xEntry(rTreeView.make_iterator());
 519     if (!rTreeView.get_selected(xEntry.get()))
 520         return;
 521
 522     while (rTreeView.get_iter_depth(*xEntry))
 523         rTreeView.iter_parent(*xEntry);
 524
 525     m_xDialog->set_busy_cursor(true);
 526     ScConflictAction eConflictAction = ( bMine ? SC_CONFLICT_ACTION_KEEP_MINE : SC_CONFLICT_ACTION_KEEP_OTHER );
 527     SetConflictAction(*xEntry, eConflictAction);
 528     rTreeView.remove(*xEntry);
 529     m_xDialog->set_busy_cursor(false);
 530     if (rTreeView.n_children() == 0)
 531         m_xDialog->response(RET_OK);
 532 }
 533
 534 void ScConflictsDlg::KeepAllHandler( bool bMine )
 535 {
 536     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 537     std::unique_ptr<weld::TreeIter> xEntry(rTreeView.make_iterator());
 538     if (!rTreeView.get_iter_first(*xEntry))
 539         return;
 540
 541     while (rTreeView.get_iter_depth(*xEntry))
 542         rTreeView.iter_parent(*xEntry);
 543
 544     m_xDialog->set_busy_cursor(true);
 545
 546     ScConflictAction eConflictAction = ( bMine ? SC_CONFLICT_ACTION_KEEP_MINE : SC_CONFLICT_ACTION_KEEP_OTHER );
 547     do
 548     {
 549         SetConflictAction(*xEntry, eConflictAction);
 550     } while (rTreeView.iter_next_sibling(*xEntry));
 551
 552     rTreeView.freeze();
 553     rTreeView.clear();
 554     rTreeView.thaw();
 555
 556     m_xDialog->set_busy_cursor(false);
 557
 558     m_xDialog->response(RET_OK);
 559 }
 560
 561 IMPL_LINK_NOARG(ScConflictsDlg, KeepMineHandle, weld::Button&, void)
 562 {
 563     KeepHandler( true );
 564 }
 565
 566 IMPL_LINK_NOARG(ScConflictsDlg, KeepOtherHandle, weld::Button&, void)
 567 {
 568     KeepHandler( false );
 569 }
 570
 571 IMPL_LINK_NOARG(ScConflictsDlg, KeepAllMineHandle, weld::Button&, void)
 572 {
 573     KeepAllHandler( true );
 574 }
 575
 576 IMPL_LINK_NOARG(ScConflictsDlg, KeepAllOthersHandle, weld::Button&, void)
 577 {
 578     KeepAllHandler( false );
 579 }
 580
 581 void ScConflictsDlg::UpdateView()
 582 {
 583     weld::TreeView& rTreeView = m_xLbConflicts->GetWidget();
 584     for ( ScConflictsListEntry& rConflictEntry : mrConflictsList )
 585     {
 586         if (rConflictEntry.meConflictAction == SC_CONFLICT_ACTION_NONE)
 587         {
 588             std::unique_ptr<RedlinData> pRootUserData(new RedlinData());
 589             pRootUserData->pData = static_cast<void*>(&rConflictEntry);
 590             OUString sString(GetConflictString(rConflictEntry));
 591             OUString sId(weld::toId(pRootUserData.release()));
 592             std::unique_ptr<weld::TreeIter> xRootEntry(rTreeView.make_iterator());
 593             std::unique_ptr<weld::TreeIter> xEntry(rTreeView.make_iterator());
 594             rTreeView.insert(nullptr, -1, &sString, &sId, nullptr, nullptr, false, xRootEntry.get());
 595
 596             for ( const auto& aSharedAction : rConflictEntry.maSharedActions )
 597             {
 598                 ScChangeAction* pAction = mpSharedTrack ? mpSharedTrack->GetAction(aSharedAction) : nullptr;
 599                 if ( pAction )
 600                 {
 601                     // only display shared top content entries
 602                     if ( pAction->GetType() == SC_CAT_CONTENT )
 603                     {
 604                         ScChangeActionContent* pNextContent = dynamic_cast<ScChangeActionContent&>(*pAction).GetNextContent();
 605                         if ( pNextContent && rConflictEntry.HasSharedAction( pNextContent->GetActionNumber() ) )
 606                         {
 607                             continue;
 608                         }
 609                     }
 610
 611                     rTreeView.insert(xRootEntry.get(), -1, nullptr, nullptr, nullptr, nullptr, false, xEntry.get());
 612                     SetActionString(pAction, mpSharedDoc, *xEntry);
 613                 }
 614             }
 615
 616             for ( const auto& aOwnAction : rConflictEntry.maOwnActions )
 617             {
 618                 ScChangeAction* pAction = mpOwnTrack ? mpOwnTrack->GetAction(aOwnAction) : nullptr;
 619                 if ( pAction )
 620                 {
 621                     // only display own top content entries
 622                     if ( pAction->GetType() == SC_CAT_CONTENT )
 623                     {
 624                         ScChangeActionContent* pNextContent = dynamic_cast<ScChangeActionContent&>(*pAction).GetNextContent();
 625                         if ( pNextContent && rConflictEntry.HasOwnAction( pNextContent->GetActionNumber() ) )
 626                         {
 627                             continue;
 628                         }
 629                     }
 630
 631                     std::unique_ptr<RedlinData> pUserData(new RedlinData());
 632                     pUserData->pData = static_cast< void* >( pAction );
 633                     OUString aId(weld::toId(pUserData.release()));
 634                     rTreeView.insert(xRootEntry.get(), -1, nullptr, &aId, nullptr, nullptr, false, xEntry.get());
 635                     SetActionString(pAction, mpOwnDoc, *xEntry);
 636                 }
 637             }
 638
 639             rTreeView.expand_row(*xRootEntry);
 640         }
 641     }
 642 }
 643
 644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */