libkommitwidgets/windows/mergewindow.cpp

0001 /*
0002 Copyright (C) 2020 Hamed Masafi <hamed.masafi@gmail.com>
0003 SPDX-License-Identifier: GPL-3.0-or-later
0004 */
0005
0006 #include "mergewindow.h"
0007
0008 #include "dialogs/mergecloseeventdialog.h"
0009 #include "dialogs/mergeopenfilesdialog.h"
0010 // #include "settings/settingsmanager.h"
0011 #include "core/editactionsmapper.h"
0012 #include "libkommitwidgets_appdebug.h"
0013 #include "widgets/codeeditor.h"
0014 #include "widgets/segmentsmapper.h"
0015
0016 #include <KActionCollection>
0017 #include <KLocalizedString>
0018 #include <KMessageBox>
0019
0020 #include "libkommitwidgets_appdebug.h"
0021
0022 #include <QFile>
0023 #include <QFileInfo>
0024 #include <QLabel>
0025 #include <QMenu>
0026 #include <QSettings>
0027 #include <QStatusBar>
0028 #include <QTextBlock>
0029 #include <QTextEdit>
0030
0031 bool isEmpty(const QStringList &list)
0032 {
0033     if (list.isEmpty())
0034         return true;
0035
0036     for (const auto &s : list)
0037         if (!s.trimmed().isEmpty())
0038             return false;
0039     return true;
0040 }
0041 void compare(QTextEdit *e1, QTextEdit *e2)
0042 {
0043     auto m = qMin(e1->document()->blockCount(), e2->document()->blockCount());
0044     for (int i = 0; i < m; ++i) {
0045         auto block1 = e1->document()->findBlock(i);
0046         auto block2 = e2->document()->findBlock(i);
0047         if (block1.text() != block2.text()) {
0048             //            block1.blockFormat()
0049         }
0050     }
0051 }
0052 QString readFile(const QString &filePath)
0053 {
0054     QFile f{filePath};
0055     if (!f.open(QIODevice::ReadOnly))
0056         return {};
0057
0058     const auto buf = QString(f.readAll());
0059     f.close();
0060     return buf;
0061 }
0062
0063 MergeWindow::MergeWindow(Git::Manager *git, Mode mode, QWidget *parent)
0064     : AppMainWindow(parent)
0065     , mGit(git)
0066 {
0067     Q_UNUSED(mode)
0068     auto w = new QWidget(this);
0069     m_ui.setupUi(w);
0070     setCentralWidget(w);
0071
0072     initActions();
0073     init();
0074
0075     QSettings s;
0076     s.beginGroup(QStringLiteral("MergeWindow"));
0077     if (s.value(QStringLiteral("actionType"), QStringLiteral("file")).toString() == QStringLiteral("file"))
0078         actionViewFiles_clicked();
0079     else
0080         actionViewBlocks_clicked();
0081 }
0082
0083 MergeWindow::~MergeWindow()
0084 {
0085     QSettings s;
0086     s.beginGroup(QStringLiteral("MergeWindow"));
0087     s.setValue(QStringLiteral("actionType"), mActionFilesView->isChecked() ? QStringLiteral("file") : QStringLiteral("block"));
0088     s.sync();
0089 }
0090
0091 void MergeWindow::init()
0092 {
0093     auto mapper = new EditActionsMapper;
0094     mapper->init(actionCollection());
0095
0096     mapper->addTextEdit(m_ui.plainTextEditMine);
0097     mapper->addTextEdit(m_ui.plainTextEditTheir);
0098     mapper->addTextEdit(m_ui.plainTextEditResult);
0099
0100     mMapper = new SegmentsMapper;
0101
0102     mMapper->addEditor(m_ui.plainTextEditBase);
0103     mMapper->addEditor(m_ui.plainTextEditMine);
0104     mMapper->addEditor(m_ui.plainTextEditTheir);
0105     mMapper->addEditor(m_ui.plainTextEditResult);
0106
0107     m_ui.plainTextEditMine->setContextMenuPolicy(Qt::CustomContextMenu);
0108     m_ui.plainTextEditTheir->setContextMenuPolicy(Qt::CustomContextMenu);
0109
0110     connect(m_ui.plainTextEditMine, &CodeEditor::customContextMenuRequested, this, &MergeWindow::codeEditors_customContextMenuRequested);
0111     connect(m_ui.plainTextEditTheir, &CodeEditor::customContextMenuRequested, this, &MergeWindow::codeEditors_customContextMenuRequested);
0112     // TODO: check these dulicated lines
0113     connect(m_ui.plainTextEditResult, &CodeEditor::blockSelected, this, &MergeWindow::slotPlainTextEditResultBlockSelected);
0114     connect(m_ui.plainTextEditResult, &CodeEditor::blockSelected, this, &MergeWindow::slotPlainTextEditResultBlockSelected);
0115     connect(m_ui.plainTextEditResult, &CodeEditor::blockSelected, this, &MergeWindow::slotPlainTextEditResultBlockSelected);
0116     connect(m_ui.plainTextEditResult, &CodeEditor::blockSelected, this, &MergeWindow::slotPlainTextEditResultBlockSelected);
0117     connect(m_ui.plainTextEditResult, &CodeEditor::textChanged, this, &MergeWindow::slotPlainTextEditResultTextChanged);
0118     connect(m_ui.plainTextEditResult, &CodeEditor::blockSelected, this, &MergeWindow::slotPlainTextEditResultBlockSelected);
0119
0120     mConflictsLabel = new QLabel(this);
0121     statusBar()->addPermanentWidget(mConflictsLabel);
0122
0123     actionViewBlocks_clicked();
0124
0125     setupGUI(Default, QStringLiteral("kommitmergeui.rc"));
0126 }
0127
0128 void MergeWindow::fillSegments()
0129 {
0130     m_ui.plainTextEditMine->clearAll();
0131     m_ui.plainTextEditBase->clearAll();
0132     m_ui.plainTextEditTheir->clearAll();
0133     for (const auto &d : std::as_const(mDiffs)) {
0134         auto blockSize = actionViewSameSizeBlocks->isChecked() ? qMax(d->base.size(), qMax(d->remote.size(), d->local.size())) : -1;
0135
0136         switch (d->type) {
0137         case Diff::SegmentType::SameOnBoth: {
0138             m_ui.plainTextEditMine->append(d->base, CodeEditor::Unchanged, d, blockSize);
0139             m_ui.plainTextEditTheir->append(d->base, CodeEditor::Unchanged, d, blockSize);
0140             m_ui.plainTextEditBase->append(d->base, CodeEditor::Unchanged, d, blockSize);
0141             d->mergeType = Diff::KeepLocal;
0142             break;
0143         }
0144
0145         case Diff::SegmentType::OnlyOnRight:
0146             m_ui.plainTextEditMine->append(d->local, CodeEditor::Removed, d, blockSize);
0147             m_ui.plainTextEditTheir->append(d->remote, CodeEditor::Added, d, blockSize);
0148             m_ui.plainTextEditBase->append(d->base, CodeEditor::Edited, d, blockSize);
0149             d->mergeType = Diff::KeepRemote;
0150             break;
0151         case Diff::SegmentType::OnlyOnLeft:
0152             m_ui.plainTextEditMine->append(d->local, CodeEditor::Added, d, blockSize);
0153             m_ui.plainTextEditTheir->append(d->remote, CodeEditor::Removed, d, blockSize);
0154             m_ui.plainTextEditBase->append(d->base, CodeEditor::Edited, d, blockSize);
0155             d->mergeType = Diff::KeepLocal;
0156             break;
0157
0158         case Diff::SegmentType::DifferentOnBoth:
0159             if (isEmpty(d->local)) {
0160                 m_ui.plainTextEditMine->append(d->local, CodeEditor::Edited, d, blockSize);
0161                 m_ui.plainTextEditTheir->append(d->remote, CodeEditor::Added, d, blockSize);
0162                 //                d->mergeType = Diff::KeepRemote;
0163             } else if (isEmpty(d->remote)) {
0164                 m_ui.plainTextEditMine->append(d->local, CodeEditor::Added, d, blockSize);
0165                 m_ui.plainTextEditTheir->append(d->remote, CodeEditor::Edited, d, blockSize);
0166                 //                d->mergeType = Diff::KeepLocal;
0167             } else {
0168                 m_ui.plainTextEditMine->append(d->local, CodeEditor::Edited, d, blockSize);
0169                 m_ui.plainTextEditTheir->append(d->remote, CodeEditor::Edited, d, blockSize);
0170             }
0171             m_ui.plainTextEditBase->append(d->base, CodeEditor::Edited, d, blockSize);
0172             d->mergeType = Diff::None;
0173             break;
0174         }
0175     }
0176 }
0177
0178 void MergeWindow::load()
0179 {
0180     m_ui.plainTextEditMine->clear();
0181     m_ui.plainTextEditTheir->clear();
0182     m_ui.plainTextEditResult->clear();
0183     m_ui.plainTextEditBase->clear();
0184
0185     auto baseList = readFile(mFilePathBase);
0186     auto localList = readFile(mFilePathLocal);
0187     auto remoteList = readFile(mFilePathRemote);
0188
0189     m_ui.plainTextEditBase->setHighlighting(mFilePathBase);
0190     m_ui.plainTextEditMine->setHighlighting(mFilePathLocal);
0191     m_ui.plainTextEditTheir->setHighlighting(mFilePathRemote);
0192     m_ui.plainTextEditResult->setHighlighting(mFilePathResult);
0193     m_ui.codeEditorMyBlock->setHighlighting(mFilePathLocal);
0194     m_ui.codeEditorTheirBlock->setHighlighting(mFilePathRemote);
0195
0196     auto result = Diff::diff3(baseList, localList, remoteList);
0197     mDiffs = result.segments;
0198     mMapper->setSegments(mDiffs);
0199
0200     fillSegments();
0201     updateResult();
0202
0203     QFileInfo fi;
0204     if (mFilePathResult.isEmpty())
0205         fi.setFile(mFilePathBase);
0206     else
0207         fi.setFile(mFilePathResult);
0208
0209     setWindowTitle(fi.fileName() + QStringLiteral("[*]"));
0210     setWindowModified(true);
0211
0212     actionKeepMine->setEnabled(true);
0213     actionKeepTheir->setEnabled(true);
0214     actionKeepMineBeforeTheir->setEnabled(true);
0215     actionKeepTheirBeforeMine->setEnabled(true);
0216     actionKeepMyFile->setEnabled(true);
0217     actionKeepTheirFile->setEnabled(true);
0218     actionGotoPrevDiff->setEnabled(true);
0219     actionGotoNextDiff->setEnabled(true);
0220 }
0221
0222 void MergeWindow::updateResult()
0223 {
0224     m_ui.plainTextEditResult->clearAll();
0225     for (const auto &d : std::as_const(mDiffs)) {
0226         auto blockSize = actionViewSameSizeBlocks->isChecked() ? qMax(d->base.size(), qMax(d->remote.size(), d->local.size())) : -1;
0227
0228         if (d->type == Diff::SegmentType::SameOnBoth) {
0229             m_ui.plainTextEditResult->append(d->base, CodeEditor::Unchanged, d, blockSize);
0230             continue;
0231         }
0232         switch (d->mergeType) {
0233         case Diff::None: {
0234             switch (d->type) {
0235             case Diff::SegmentType::SameOnBoth:
0236                 m_ui.plainTextEditResult->append(d->base, CodeEditor::Unchanged, d, blockSize);
0237                 break;
0238
0239             case Diff::SegmentType::OnlyOnRight:
0240                 m_ui.plainTextEditResult->append(d->remote, CodeEditor::Added, d, blockSize);
0241                 break;
0242
0243             case Diff::SegmentType::OnlyOnLeft:
0244                 m_ui.plainTextEditResult->append(d->local, CodeEditor::Added, d, blockSize);
0245                 break;
0246
0247             case Diff::SegmentType::DifferentOnBoth:
0248                 if (d->local == d->remote)
0249                     m_ui.plainTextEditResult->append(d->remote, CodeEditor::Added, d, blockSize); // Not changed
0250                 else if (isEmpty(d->local))
0251                     m_ui.plainTextEditResult->append(d->remote, CodeEditor::Added, d, blockSize);
0252                 else if (isEmpty(d->remote))
0253                     m_ui.plainTextEditResult->append(d->local, CodeEditor::Added, d, blockSize);
0254                 else
0255                     m_ui.plainTextEditResult->append(QStringLiteral(" "), CodeEditor::Removed, d);
0256                 break;
0257             }
0258             break;
0259         }
0260
0261         case Diff::KeepLocal:
0262             m_ui.plainTextEditResult->append(d->local, CodeEditor::Edited, d, blockSize);
0263             break;
0264
0265         case Diff::KeepRemote:
0266             m_ui.plainTextEditResult->append(d->remote, CodeEditor::Edited, d, blockSize);
0267             break;
0268
0269         case Diff::KeepLocalThenRemote:
0270             m_ui.plainTextEditResult->append(d->local, CodeEditor::Edited, d, blockSize);
0271             m_ui.plainTextEditResult->append(d->remote, CodeEditor::Edited, d, blockSize);
0272             break;
0273
0274         case Diff::KeepRemoteThenLocal:
0275             m_ui.plainTextEditResult->append(d->remote, CodeEditor::Edited, d, blockSize);
0276             m_ui.plainTextEditResult->append(d->local, CodeEditor::Edited, d, blockSize);
0277             break;
0278
0279         default:
0280             m_ui.plainTextEditResult->append(QStringLiteral("***"), CodeEditor::Edited, d);
0281             break;
0282         }
0283     }
0284     mConflictsLabel->setText(i18n("Conflicts: %1", mMapper->conflicts()));
0285 }
0286
0287 void MergeWindow::initActions()
0288 {
0289     KActionCollection *actionCollection = this->actionCollection();
0290
0291     actionKeepMine = actionCollection->addAction(QStringLiteral("keep_mine"), this, &MergeWindow::actionKeepMine_clicked);
0292     actionKeepMine->setText(i18n("Keep mine"));
0293     actionKeepMine->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-mine")));
0294     actionCollection->setDefaultShortcut(actionKeepMine, QKeySequence(Qt::CTRL | Qt::Key_L));
0295
0296     actionKeepTheir = actionCollection->addAction(QStringLiteral("keep_their"), this, &MergeWindow::actionKeepTheir_clicked);
0297     actionKeepTheir->setText(i18n("Keep their"));
0298     actionKeepTheir->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-their")));
0299     actionCollection->setDefaultShortcut(actionKeepTheir, QKeySequence(Qt::CTRL | Qt::Key_R));
0300
0301     actionKeepMineBeforeTheir = actionCollection->addAction(QStringLiteral("keep_mine_before_their"), this, &MergeWindow::actionKeepMineBeforeTheir_clicked);
0302
0303     actionKeepMineBeforeTheir->setText(i18n("Keep mine before their"));
0304     actionKeepMineBeforeTheir->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-mine-before-their")));
0305     actionCollection->setDefaultShortcut(actionKeepMineBeforeTheir, QKeySequence(Qt::CTRL | Qt::Key_L | Qt::SHIFT));
0306
0307     actionKeepTheirBeforeMine = actionCollection->addAction(QStringLiteral("keep_their_before_mine"), this, &MergeWindow::actionKeepTheirBeforeMine_clicked);
0308     actionKeepTheirBeforeMine->setText(i18n("Keep their before mine"));
0309     actionKeepTheirBeforeMine->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-their-before-mine")));
0310     actionCollection->setDefaultShortcut(actionKeepTheirBeforeMine, QKeySequence(Qt::CTRL | Qt::Key_R | Qt::SHIFT));
0311
0312     actionKeepMyFile = actionCollection->addAction(QStringLiteral("keep_my_file"), this, &MergeWindow::actionKeepMyFile_clicked);
0313     actionKeepMyFile->setText(i18n("Keep my file"));
0314     actionKeepMyFile->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-mine-file")));
0315     actionCollection->setDefaultShortcut(actionKeepMyFile, QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_L));
0316
0317     actionKeepTheirFile = actionCollection->addAction(QStringLiteral("keep_their_file"), this, &MergeWindow::actionKeepTheirFile_clicked);
0318     actionKeepTheirFile->setText(i18n("Keep their file"));
0319     actionKeepTheirFile->setIcon(QIcon::fromTheme(QStringLiteral("diff-keep-their-file")));
0320     actionCollection->setDefaultShortcut(actionKeepTheirFile, QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_R));
0321
0322     mActionBlocksView = actionCollection->addAction(QStringLiteral("view_blocks"), this, &MergeWindow::actionViewBlocks_clicked);
0323     mActionBlocksView->setText(i18n("Blocks"));
0324     mActionBlocksView->setCheckable(true);
0325
0326     mActionFilesView = actionCollection->addAction(QStringLiteral("view_files"), this, &MergeWindow::actionViewFiles_clicked);
0327     mActionFilesView->setText(i18n("Files"));
0328     mActionFilesView->setCheckable(true);
0329
0330     actionGotoPrevDiff = actionCollection->addAction(QStringLiteral("goto_prev_diff"), this, &MergeWindow::actionGotoPrevDiff_clicked);
0331     actionGotoPrevDiff->setText(i18n("Previous diff"));
0332     actionGotoPrevDiff->setIcon(QIcon::fromTheme(QStringLiteral("diff-goto-prev-diff")));
0333     actionGotoPrevDiff->setEnabled(false);
0334     actionCollection->setDefaultShortcut(actionGotoPrevDiff, QKeySequence(Qt::Key_PageUp));
0335
0336     actionGotoNextDiff = actionCollection->addAction(QStringLiteral("goto_next_diff"), this, &MergeWindow::actionGotoNextDiff_clicked);
0337     actionGotoNextDiff->setText(i18n("Next diff"));
0338     actionGotoNextDiff->setIcon(QIcon::fromTheme(QStringLiteral("diff-goto-next-diff")));
0339     actionCollection->setDefaultShortcut(actionGotoNextDiff, QKeySequence(Qt::Key_PageDown));
0340
0341     actionViewSameSizeBlocks = actionCollection->addAction(QStringLiteral("view_same_size_blocks"), this, &MergeWindow::fillSegments);
0342     actionViewSameSizeBlocks->setText(i18n("Same size blocks"));
0343     actionViewSameSizeBlocks->setCheckable(true);
0344     actionViewSameSizeBlocks->setChecked(true);
0345
0346     KStandardAction::open(this, &MergeWindow::fileOpen, actionCollection);
0347     KStandardAction::save(this, &MergeWindow::fileSave, actionCollection);
0348     KStandardAction::quit(this, &MergeWindow::close, actionCollection);
0349
0350 #ifdef UNDEF
0351     auto settingsManager = new SettingsManager(mGit, this);
0352     KStandardAction::preferences(settingsManager, &SettingsManager::show, actionCollection);
0353 #endif
0354
0355     mCodeEditorContextMenu = new QMenu(this);
0356     mCodeEditorContextMenu->addActions({actionKeepMine, actionKeepTheir});
0357     mCodeEditorContextMenu->addSeparator();
0358     mCodeEditorContextMenu->addActions({actionKeepMineBeforeTheir, actionKeepTheirBeforeMine});
0359     mCodeEditorContextMenu->addSeparator();
0360     mCodeEditorContextMenu->addActions({actionKeepMyFile, actionKeepTheirFile});
0361
0362     actionKeepMine->setEnabled(false);
0363     actionKeepTheir->setEnabled(false);
0364     actionKeepMineBeforeTheir->setEnabled(false);
0365     actionKeepTheirBeforeMine->setEnabled(false);
0366     actionKeepMyFile->setEnabled(false);
0367     actionKeepTheirFile->setEnabled(false);
0368     actionGotoPrevDiff->setEnabled(false);
0369     actionGotoNextDiff->setEnabled(false);
0370 }
0371
0372 void MergeWindow::doMergeAction(Diff::MergeType type)
0373 {
0374     auto s = mMapper->currentSegment();
0375
0376     if (!s)
0377         return;
0378
0379     if (s->type == Diff::SegmentType::SameOnBoth)
0380         return;
0381
0382     auto ss = static_cast<Diff::MergeSegment *>(s);
0383     ss->mergeType = type;
0384     updateResult();
0385     //    m_ui.plainTextEditResult->highlightSegment(s);
0386
0387     mMapper->setCurrentSegment(s);
0388
0389     setWindowModified(true);
0390 }
0391
0392 bool MergeWindow::isFullyResolved() const
0393 {
0394     for (const auto &d : std::as_const(mDiffs))
0395         if (d->mergeType == Diff::None && d->type == Diff::SegmentType::DifferentOnBoth)
0396             return false;
0397     return true;
0398 }
0399
0400 void MergeWindow::closeEvent(QCloseEvent *event)
0401 {
0402     if (isWindowModified()) {
0403         MergeCloseEventDialog d(this);
0404         auto r = d.exec();
0405
0406         switch (r) {
0407         case MergeCloseEventDialog::MarkAsResolved:
0408             fileSave();
0409             accept();
0410             break;
0411         case MergeCloseEventDialog::LeaveAsIs:
0412             reject();
0413             break;
0414         case MergeCloseEventDialog::DontExit:
0415             event->ignore();
0416             break;
0417         }
0418     }
0419     accept();
0420 }
0421
0422 const QString &MergeWindow::filePathResult() const
0423 {
0424     return mFilePathResult;
0425 }
0426
0427 void MergeWindow::setFilePathResult(const QString &newFilePathResult)
0428 {
0429     mFilePathResult = newFilePathResult;
0430 }
0431
0432 void MergeWindow::fileSave()
0433 {
0434     QFile f(mFilePathResult);
0435     if (!f.open(QIODevice::Text | QIODevice::WriteOnly)) {
0436         KMessageBox::information(this, i18n("Unable to open the file") + mFilePathResult);
0437         return;
0438     }
0439     f.write(m_ui.plainTextEditResult->toPlainText().toUtf8());
0440     f.close();
0441     setWindowModified(false);
0442 }
0443
0444 void MergeWindow::fileOpen()
0445 {
0446     MergeOpenFilesDialog d;
0447     if (d.exec() == QDialog::Accepted) {
0448         setFilePathBase(d.filePathBase());
0449         setFilePathLocal(d.filePathLocal());
0450         setFilePathRemote(d.filePathRemote());
0451         load();
0452     }
0453 }
0454
0455 void MergeWindow::actionKeepMine_clicked()
0456 {
0457     doMergeAction(Diff::MergeType::KeepLocal);
0458 }
0459
0460 void MergeWindow::actionKeepTheir_clicked()
0461 {
0462     doMergeAction(Diff::MergeType::KeepRemote);
0463 }
0464
0465 void MergeWindow::actionKeepMineBeforeTheir_clicked()
0466 {
0467     doMergeAction(Diff::MergeType::KeepLocalThenRemote);
0468 }
0469
0470 void MergeWindow::actionKeepTheirBeforeMine_clicked()
0471 {
0472     doMergeAction(Diff::MergeType::KeepRemoteThenLocal);
0473 }
0474
0475 void MergeWindow::actionKeepMyFile_clicked()
0476 {
0477     m_ui.plainTextEditResult->setPlainText(m_ui.plainTextEditMine->toPlainText());
0478 }
0479
0480 void MergeWindow::actionKeepTheirFile_clicked()
0481 {
0482     m_ui.plainTextEditResult->setPlainText(m_ui.plainTextEditTheir->toPlainText());
0483 }
0484
0485 void MergeWindow::actionGotoPrevDiff_clicked()
0486 {
0487     mMapper->findPrevious(Diff::SegmentType::DifferentOnBoth);
0488     slotPlainTextEditResultBlockSelected();
0489 }
0490
0491 void MergeWindow::actionGotoNextDiff_clicked()
0492 {
0493     mMapper->findNext(Diff::SegmentType::DifferentOnBoth);
0494     slotPlainTextEditResultBlockSelected();
0495 }
0496
0497 void MergeWindow::actionViewFiles_clicked()
0498 {
0499     mActionBlocksView->setChecked(false);
0500     mActionFilesView->setChecked(true);
0501     m_ui.widgetBlockView->hide();
0502     m_ui.widgetCodeView->show();
0503 }
0504
0505 void MergeWindow::actionViewBlocks_clicked()
0506 {
0507     mActionBlocksView->setChecked(true);
0508     mActionFilesView->setChecked(false);
0509     m_ui.widgetBlockView->show();
0510     m_ui.widgetCodeView->hide();
0511 }
0512
0513 void MergeWindow::codeEditors_customContextMenuRequested(QPoint pos)
0514 {
0515     Q_UNUSED(pos)
0516     mCodeEditorContextMenu->popup(QCursor::pos());
0517 }
0518
0519 const QString &MergeWindow::filePathBase() const
0520 {
0521     return mFilePathBase;
0522 }
0523
0524 void MergeWindow::setFilePathBase(const QString &newFilePathBase)
0525 {
0526     mFilePathBase = newFilePathBase;
0527 }
0528
0529 const QString &MergeWindow::filePathRemote() const
0530 {
0531     return mFilePathRemote;
0532 }
0533
0534 void MergeWindow::setFilePathRemote(const QString &newFilePathRemote)
0535 {
0536     mFilePathRemote = newFilePathRemote;
0537 }
0538
0539 const QString &MergeWindow::filePathLocal() const
0540 {
0541     return mFilePathLocal;
0542 }
0543
0544 void MergeWindow::setFilePathLocal(const QString &newFilePathLocal)
0545 {
0546     mFilePathLocal = newFilePathLocal;
0547 }
0548
0549 void MergeWindow::slotPlainTextEditResultTextChanged()
0550 {
0551     qCDebug(KOMMIT_WIDGETS_LOG()) << "**********************";
0552     //    auto segment = static_cast<Diff::MergeSegment *>(_mapper->currentSegment());
0553     //    if (segment) {
0554     //        segment->mergeType = Diff::MergeCustom;
0555     //    }
0556 }
0557
0558 void MergeWindow::slotPlainTextEditResultBlockSelected()
0559 {
0560     auto segment = static_cast<Diff::MergeSegment *>(m_ui.plainTextEditResult->currentSegment());
0561
0562     if (!segment)
0563         return;
0564     if (segment->type == Diff::SegmentType::DifferentOnBoth) {
0565         m_ui.codeEditorMyBlock->setPlainText(segment->local.join(QStringLiteral("\n")));
0566         m_ui.codeEditorTheirBlock->setPlainText(segment->remote.join(QStringLiteral("\n")));
0567     } else {
0568         m_ui.codeEditorMyBlock->clear();
0569         m_ui.codeEditorTheirBlock->clear();
0570     }
0571 }
0572
0573 #include "moc_mergewindow.cpp"