KompareDiff2::ModelList Class

Member Function Documentation

ModelList::ModelList(KompareDiff2::DiffSettings *diffSettings, QObject *parent, bool supportReadWrite = true)

[override virtual noexcept] ModelList::~ModelList()

KActionCollection *ModelList::actionCollection() const

int ModelList::appliedCount() const

[signal] void ModelList::applyAllDifferences(bool apply)

[signal] void ModelList::applyDifference(bool apply)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::applyDifference),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::applyDifference),
        this, [](bool apply) { /* handle applyDifference */ });

[signal] void ModelList::applyDifference(const KompareDiff2::Difference *diff, bool apply)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::applyDifference),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::applyDifference),
        this, [](const KompareDiff2::Difference *diff, bool apply) { /* handle applyDifference */ });

bool ModelList::blendOriginalIntoModelList(const QString &localURL)

This will blend the original URL (dir or file) into the diffmodel, this is like patching but with a twist.

void ModelList::clear()

bool ModelList::compare()

Compares the source and destination to determine whether the comparison should be between directories, between files, or whether one file should be merged into another.

bool ModelList::compare(KompareDiff2::Mode)

int ModelList::currentDifference() const

int ModelList::currentModel() const

[signal] void ModelList::diffString(const QString &)

int ModelList::differenceCount() const

[signal] void ModelList::error(const QString &error)

int ModelList::findModel(KompareDiff2::DiffModel *model) const

bool ModelList::hasUnsavedChanges() const

bool ModelList::isReadWrite() const

KompareDiff2::DiffModel *ModelList::modelAt(int i)

const KompareDiff2::DiffModel *ModelList::modelAt(int i) const

int ModelList::modelCount() const

const KompareDiff2::DiffModelList *ModelList::models() const

[signal] void ModelList::modelsChanged(const KompareDiff2::DiffModelList *models)

bool ModelList::openDiff(const QString &diff)

bool ModelList::openDirAndDiff()

bool ModelList::openFileAndDiff()

bool ModelList::parseAndOpenDiff(const QString &diff)

Opens the given diff after parsing it.

int ModelList::parseDiffOutput(const QString &diff)

Parses the given diff and creates new models.

QString ModelList::recreateDiff() const

void ModelList::refresh()

bool ModelList::saveAll()

bool ModelList::saveDestination(KompareDiff2::DiffModel *model)

bool ModelList::saveDiff(const QString &url, const QString &directory, KompareDiff2::DiffSettings *diffSettings)

const KompareDiff2::Difference *ModelList::selectedDifference() const

const KompareDiff2::DiffModel *ModelList::selectedModel() const

void ModelList::setEncoding(const QString &encoding)

void ModelList::setReadWrite(bool isReadWrite)

See also isReadWrite().

[signal] void ModelList::setSelection(const KompareDiff2::Difference *diff)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::setSelection),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::setSelection),
        this, [](const KompareDiff2::Difference *diff) { /* handle setSelection */ });

[signal] void ModelList::setSelection(const KompareDiff2::DiffModel *model, const KompareDiff2::Difference *diff)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::setSelection),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::setSelection),
        this, [](const KompareDiff2::DiffModel *model, const KompareDiff2::Difference *diff) { /* handle setSelection */ });

[signal] void ModelList::setStatusBarModelInfo(int modelIndex, int differenceIndex, int modelCount, int differenceCount, int appliedCount)

void ModelList::show()

Call this to emit the signals to the rest of the "world" to show the diff.

[protected slot] void ModelList::slotActionApplyAllDifferences()

[protected slot] void ModelList::slotActionApplyDifference()

[protected slot] void ModelList::slotActionUnApplyDifference()

[protected slot] void ModelList::slotActionUnapplyAllDifferences()

[slot] void ModelList::slotApplyAllDifferences(bool apply)

[slot] void ModelList::slotApplyDifference(bool apply)

[protected slot] void ModelList::slotDiffProcessFinished(bool success)

[slot] void ModelList::slotKompareInfo(KompareDiff2::Info *)

[slot] void ModelList::slotNextDifference()

[slot] void ModelList::slotNextModel()

[slot] void ModelList::slotPreviousDifference()

[slot] void ModelList::slotPreviousModel()

[protected slot] void ModelList::slotSaveDestination()

Saves the currently selected destination in a multi-file diff, or the single destination if a single file diff.

[slot] void ModelList::slotSelectionChanged(const KompareDiff2::Difference *diff)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::slotSelectionChanged),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::slotSelectionChanged),
        this, [](const KompareDiff2::Difference *diff) { /* handle slotSelectionChanged */ });

[slot] void ModelList::slotSelectionChanged(const KompareDiff2::DiffModel *model, const KompareDiff2::Difference *diff)

// Connect using qOverload:
connect(modelList, qOverload(&ModelList::slotSelectionChanged),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(modelList, qOverload(&ModelList::slotSelectionChanged),
        this, [](const KompareDiff2::DiffModel *model, const KompareDiff2::Difference *diff) { /* handle slotSelectionChanged */ });

[protected slot] void ModelList::slotWriteDiffOutput(bool success)

[signal] void ModelList::status(KompareDiff2::Status status)

void ModelList::swap()

Swaps source with destination and show differences.

[signal] void ModelList::updateActions()