QTreeView(parent),

mSettings(nullptr),

mApplications(nullptr),

mContextItem(nullptr),

mShowFullPath(false),

mSaveFullPath(false),

mSaveAllErrors(true),

mShowErrorId(false),

mVisibleErrors(false),

mSelectionModel(nullptr),

mThread(nullptr),

mShowCppcheck(true),

mShowClang(true)

{

setModel(&mModel);

translate(); // Adds columns to grid

setExpandsOnDoubleClick(false);

setSortingEnabled(true);

connect(this, &ResultsTree::doubleClicked, this, &ResultsTree::quickStartApplication);

{

if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {

quickStartApplication(this->currentIndex());

}

QTreeView::keyPressEvent(event);

{

mSettings = settings;

mApplications = list;

mThread = checkThreadHandler;

loadSettings();

{

if (item.errorPath.isEmpty()) {

return false;

}

const QErrorPathItem &loc = item.errorId.startsWith("clang") ? item.errorPath.front() : item.errorPath.back();

QString realfile = stripPath(loc.file, false);

if (realfile.isEmpty()) {

realfile = tr("Undefined file");

}

bool hide = false;

// Ids that are temporarily hidden..

if (mHiddenMessageId.contains(item.errorId))

hide = true;

//If specified, filter on summary, message, filename, and id

if (!hide && !mFilter.isEmpty()) {

if (!item.summary.contains(mFilter, Qt::CaseInsensitive) &&

!item.message.contains(mFilter, Qt::CaseInsensitive) &&

!item.errorPath.back().file.contains(mFilter, Qt::CaseInsensitive) &&

!item.errorId.contains(mFilter, Qt::CaseInsensitive)) {

hide = true;

}

}

//if there is at least one error that is not hidden, we have a visible error

if (!hide) {

mVisibleErrors = true;

}

ErrorLine line;

line.file = realfile;

line.line = loc.line;

line.errorId = item.errorId;

line.incomplete = item.incomplete;

line.cwe = item.cwe;

line.hash = item.hash;

line.inconclusive = item.inconclusive;

line.summary = item.summary;

line.message = item.message;

line.severity = item.severity;

line.sinceDate = item.sinceDate;

if (const ProjectFile *activeProject = ProjectFile::getActiveProject()) {

line.tags = activeProject->getWarningTags(item.hash);

}

//Create the base item for the error and ensure it has a proper

//file item as a parent

QStandardItem* fileItem = ensureFileItem(loc.file, item.file0, hide);

QStandardItem* stditem = addBacktraceFiles(fileItem,

line,

hide,

severityToIcon(line.severity),

false);

if (!stditem)

return false;

//Add user data to that item

QMap<QString, QVariant> data;

data[SEVERITY] = ShowTypes::SeverityToShowType(item.severity);

data[SUMMARY] = item.summary;

data[MESSAGE] = item.message;

data[FILENAME] = loc.file;

data[LINE] = loc.line;

data[COLUMN] = loc.column;

data[ERRORID] = item.errorId;

data[INCOMPLETE] = item.incomplete;

data[CWE] = item.cwe;

data[HASH] = item.hash;

data[INCONCLUSIVE] = item.inconclusive;

data[FILE0] = stripPath(item.file0, true);

data[FUNCTION] = item.function;

data[SINCEDATE] = item.sinceDate;

data[SYMBOLNAMES] = item.symbolNames;

data[TAGS] = line.tags;

data[HIDE] = hide;

stditem->setData(QVariant(data));

//Add backtrace files as children

if (item.errorPath.size() > 1) {

for (int i = 0; i < item.errorPath.size(); i++) {

const QErrorPathItem &e = item.errorPath[i];

line.file = e.file;

line.line = e.line;

line.message = line.summary = e.info;

QStandardItem *child_item;

child_item = addBacktraceFiles(stditem,

line,

hide,

":images/go-down.png",

true);

if (!child_item)

continue;

// Add user data to that item

QMap<QString, QVariant> child_data;

child_data[SEVERITY] = ShowTypes::SeverityToShowType(line.severity);

child_data[SUMMARY] = line.summary;

child_data[MESSAGE] = line.message;

child_data[FILENAME] = e.file;

child_data[LINE] = e.line;

child_data[COLUMN] = e.column;

child_data[ERRORID] = line.errorId;

child_data[INCOMPLETE] = line.incomplete;

child_data[CWE] = line.cwe;

child_data[HASH] = line.hash;

child_data[INCONCLUSIVE] = line.inconclusive;

child_data[SYMBOLNAMES] = item.symbolNames;

child_item->setData(QVariant(child_data));

}

}

// Partially refresh the tree: Unhide file item if necessary

if (!hide) {

setRowHidden(fileItem->row(), QModelIndex(), !mShowSeverities.isShown(item.severity));

}

return true;

{

switch (severity) {

case Severity::style:

return tr("style");

case Severity::error:

return tr("error");

case Severity::warning:

return tr("warning");

case Severity::performance:

return tr("performance");

case Severity::portability:

return tr("portability");

case Severity::information:

return tr("information");

case Severity::debug:

return tr("debug");

case Severity::none:

default:

return QString();

}

{

const QString stripped = stripPath(filename, false);

for (int i = 0; i < mModel.rowCount(); ++i) {

const QStandardItem *fileItem = mModel.item(i, 0);

if (!fileItem)

continue;

QVariantMap data = fileItem->data().toMap();

if (stripped == data[FILENAME].toString() ||

filename == data[FILE0].toString()) {

mModel.removeRow(i);

break;

}

}

{

for (int i = 0; i < mModel.rowCount(); ++i) {

const QStandardItem *fileItem = mModel.item(i, 0);

if (!fileItem)

continue;

QString actualfile((!mCheckPath.isEmpty() && filename.startsWith(mCheckPath)) ? filename.mid(mCheckPath.length() + 1) : filename);

QVariantMap data = fileItem->data().toMap();

QString storedfile = data[FILENAME].toString();

storedfile = ((!mCheckPath.isEmpty() && storedfile.startsWith(mCheckPath)) ? storedfile.mid(mCheckPath.length() + 1) : storedfile);

if (actualfile == storedfile) {

mModel.removeRow(i);

break;

}

}

{

for (int i = 0; i < mModel.columnCount(); i++) {

QString temp = QString(SETTINGS_RESULT_COLUMN_WIDTH).arg(i);

setColumnWidth(i, qMax(20, mSettings->value(temp, 800 / mModel.columnCount()).toInt()));

}

mSaveFullPath = mSettings->value(SETTINGS_SAVE_FULL_PATH, false).toBool();

mSaveAllErrors = mSettings->value(SETTINGS_SAVE_ALL_ERRORS, false).toBool();

mShowFullPath = mSettings->value(SETTINGS_SHOW_FULL_PATH, false).toBool();

showIdColumn(mSettings->value(SETTINGS_SHOW_ERROR_ID, false).toBool());

showInconclusiveColumn(mSettings->value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool());

{

for (int i = 0; i < mModel.columnCount(); i++) {

QString temp = QString(SETTINGS_RESULT_COLUMN_WIDTH).arg(i);

mSettings->setValue(temp, columnWidth(i));

}

{

if (type != ShowTypes::ShowNone && mShowSeverities.isShown(type) != show) {

mShowSeverities.show(type, show);

refreshTree();

}

{

mShowCppcheck = show;

refreshTree();

{

mShowClang = show;

refreshTree();

{

mFilter = filter;

refreshTree();

{

//Clear the "hide" flag for each item

mHiddenMessageId.clear();

int filecount = mModel.rowCount();

for (int i = 0; i < filecount; i++) {

QStandardItem *fileItem = mModel.item(i, 0);

if (!fileItem)

continue;

QVariantMap data = fileItem->data().toMap();

data[HIDE] = false;

fileItem->setData(QVariant(data));

int errorcount = fileItem->rowCount();

for (int j = 0; j < errorcount; j++) {

QStandardItem *child = fileItem->child(j, 0);

if (child) {

data = child->data().toMap();

data[HIDE] = false;

child->setData(QVariant(data));

}

}

}

refreshTree();

emit resultsHidden(false);

{

mVisibleErrors = false;

//Get the amount of files in the tree

int filecount = mModel.rowCount();

for (int i = 0; i < filecount; i++) {

//Get file i

QStandardItem *fileItem = mModel.item(i, 0);

if (!fileItem) {

continue;

}

//Get the amount of errors this file contains

int errorcount = fileItem->rowCount();

//By default it shouldn't be visible

bool show = false;

for (int j = 0; j < errorcount; j++) {

//Get the error itself

QStandardItem *child = fileItem->child(j, 0);

if (!child) {

continue;

}

//Get error's user data

QVariant userdata = child->data();

//Convert it to QVariantMap

QVariantMap data = userdata.toMap();

//Check if this error should be hidden

bool hide = (data[HIDE].toBool() || !mShowSeverities.isShown(ShowTypes::VariantToShowType(data[SEVERITY])));

//If specified, filter on summary, message, filename, and id

if (!hide && !mFilter.isEmpty()) {

if (!data[SUMMARY].toString().contains(mFilter, Qt::CaseInsensitive) &&

!data[MESSAGE].toString().contains(mFilter, Qt::CaseInsensitive) &&

!data[FILENAME].toString().contains(mFilter, Qt::CaseInsensitive) &&

!data[ERRORID].toString().contains(mFilter, Qt::CaseInsensitive)) {

hide = true;

}

}

// Tool filter

if (!hide) {

if (data[ERRORID].toString().startsWith("clang"))

hide = !mShowClang;

else

hide = !mShowCppcheck;

}

if (!hide) {

mVisibleErrors = true;

}

//Hide/show accordingly

setRowHidden(j, fileItem->index(), hide);

//If it was shown then the file itself has to be shown as well

if (!hide) {

show = true;

}

}

//Hide the file if its "hide" attribute is set

if (fileItem->data().toMap()["hide"].toBool()) {

show = false;

}

//Show the file if any of it's errors are visible

setRowHidden(i, QModelIndex(), !show);

}

{

QModelIndex index = indexAt(e->pos());

if (index.isValid()) {

bool multipleSelection = false;

mSelectionModel = selectionModel();

if (mSelectionModel->selectedRows().count() > 1)

multipleSelection = true;

mContextItem = mModel.itemFromIndex(index);

//Create a new context menu

QMenu menu(this);

//Store all applications in a list

QList<QAction*> actions;

//Create a signal mapper so we don't have to store data to class

//member variables

QSignalMapper *signalMapper = new QSignalMapper(this);

if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {

//Create an action for the application

int defaultApplicationIndex = mApplications->getDefaultApplication();

if (defaultApplicationIndex < 0)

defaultApplicationIndex = 0;

const Application& app = mApplications->getApplication(defaultApplicationIndex);

QAction *start = new QAction(app.getName(), &menu);

if (multipleSelection)

start->setDisabled(true);

//Add it to our list so we can disconnect later on

actions << start;

//Add it to context menu

menu.addAction(start);

//Connect the signal to signal mapper

connect(start, SIGNAL(triggered()), signalMapper, SLOT(map()));

//Add a new mapping

signalMapper->setMapping(start, defaultApplicationIndex);

connect(signalMapper, SIGNAL(mapped(int)),

this, SLOT(context(int)));

}

// Add popup menuitems

if (mContextItem) {

if (mApplications->getApplicationCount() > 0) {

menu.addSeparator();

}

const bool bughunting = !multipleSelection && mContextItem->data().toMap().value("id").toString().startsWith("bughunting");

if (bughunting && !getFunction(mContextItem).isEmpty()) {

QAction *editContract = new QAction(tr("Edit contract.."), &menu);

connect(editContract, &QAction::triggered, this, &ResultsTree::editContract);

menu.addAction(editContract);

menu.addSeparator();

}

//Create an action for the application

QAction *recheckSelectedFiles = new QAction(tr("Recheck"), &menu);

QAction *copy = new QAction(tr("Copy"), &menu);

QAction *hide = new QAction(tr("Hide"), &menu);

QAction *hideallid = new QAction(tr("Hide all with id"), &menu);

QAction *opencontainingfolder = new QAction(tr("Open containing folder"), &menu);

if (multipleSelection) {

hideallid->setDisabled(true);

opencontainingfolder->setDisabled(true);

}

if (mThread->isChecking())

recheckSelectedFiles->setDisabled(true);

else

recheckSelectedFiles->setDisabled(false);

menu.addAction(recheckSelectedFiles);

menu.addSeparator();

menu.addAction(copy);

menu.addSeparator();

menu.addAction(hide);

menu.addAction(hideallid);

if (!bughunting) {

QAction *suppress = new QAction(tr("Suppress selected id(s)"), &menu);

menu.addAction(suppress);

connect(suppress, &QAction::triggered, this, &ResultsTree::suppressSelectedIds);

} else {

QAction *suppress = new QAction(tr("Suppress"), &menu);

menu.addAction(suppress);

connect(suppress, &QAction::triggered, this, &ResultsTree::suppressHash);

}

menu.addSeparator();

menu.addAction(opencontainingfolder);

connect(recheckSelectedFiles, SIGNAL(triggered()), this, SLOT(recheckSelectedFiles()));

connect(copy, SIGNAL(triggered()), this, SLOT(copy()));

connect(hide, SIGNAL(triggered()), this, SLOT(hideResult()));

connect(hideallid, SIGNAL(triggered()), this, SLOT(hideAllIdResult()));

connect(opencontainingfolder, SIGNAL(triggered()), this, SLOT(openContainingFolder()));

const ProjectFile *currentProject = ProjectFile::getActiveProject();

if (currentProject && !currentProject->getTags().isEmpty()) {

menu.addSeparator();

QMenu *tagMenu = menu.addMenu(tr("Tag"));

{

QAction *action = new QAction(tr("No tag"), tagMenu);

tagMenu->addAction(action);

connect(action, &QAction::triggered, [=]() {

tagSelectedItems(QString());

});

}

foreach (const QString tagstr, currentProject->getTags()) {

QAction *action = new QAction(tagstr, tagMenu);

tagMenu->addAction(action);

connect(action, &QAction::triggered, [=]() {

tagSelectedItems(tagstr);

});

}

}

}

//Start the menu

menu.exec(e->globalPos());

index = indexAt(e->pos());

if (index.isValid()) {

mContextItem = mModel.itemFromIndex(index);

if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {

//Disconnect all signals

for (QAction* action : actions) {

disconnect(action, SIGNAL(triggered()), signalMapper, SLOT(map()));

}

disconnect(signalMapper, SIGNAL(mapped(int)),

this, SLOT(context(int)));

//And remove the signal mapper

delete signalMapper;

}

}

}

{

//If there are no applications specified, tell the user about it

if (mApplications->getApplicationCount() == 0) {

QMessageBox msg(QMessageBox::Critical,

tr("Cppcheck"),

tr("No editor application configured.\n\n"

"Configure the editor application for Cppcheck in preferences/Applications."),

QMessageBox::Ok,

this);

msg.exec();

return;

}

if (application == -1)

application = mApplications->getDefaultApplication();

if (application == -1) {

QMessageBox msg(QMessageBox::Critical,

tr("Cppcheck"),

tr("No default editor application selected.\n\n"

"Please select the default editor application in preferences/Applications."),

QMessageBox::Ok,

this);

msg.exec();

return;

}

if (target && application >= 0 && application < mApplications->getApplicationCount() && target->parent()) {

// Make sure we are working with the first column

if (target->column() != 0)

target = target->parent()->child(target->row(), 0);

QVariantMap data = target->data().toMap();

//Replace (file) with filename

QString file = data[FILENAME].toString();

file = QDir::toNativeSeparators(file);

qDebug() << "Opening file: " << file;

QFileInfo info(file);

if (!info.exists()) {

if (info.isAbsolute()) {

QMessageBox msgbox(this);

msgbox.setWindowTitle("Cppcheck");

msgbox.setText(tr("Could not find the file!"));

msgbox.setIcon(QMessageBox::Critical);

msgbox.exec();

} else {

QDir checkdir(mCheckPath);

if (checkdir.isAbsolute() && checkdir.exists()) {

file = mCheckPath + "/" + file;

} else {

QString dir = askFileDir(file);

dir += '/';

file = dir + file;

}

}

}

if (file.indexOf(" ") > -1) {

file.insert(0, "\"");

file.append("\"");

}

const Application& app = mApplications->getApplication(application);

QString params = app.getParameters();

params.replace("(file)", file, Qt::CaseInsensitive);

QVariant line = data[LINE];

params.replace("(line)", QString("%1").arg(line.toInt()), Qt::CaseInsensitive);

params.replace("(message)", data[MESSAGE].toString(), Qt::CaseInsensitive);

params.replace("(severity)", data[SEVERITY].toString(), Qt::CaseInsensitive);

QString program = app.getPath();

// In Windows we must surround paths including spaces with quotation marks.

#ifdef Q_OS_WIN

if (program.indexOf(" ") > -1) {

if (!program.startsWith('"') && !program.endsWith('"')) {

program.insert(0, "\"");

program.append("\"");

}

}

#endif // Q_OS_WIN

const QString cmdLine = QString("%1 %2").arg(program).arg(params);

bool success = QProcess::startDetached(cmdLine);

if (!success) {

QString text = tr("Could not start %1\n\nPlease check the application path and parameters are correct.").arg(program);

QMessageBox msgbox(this);

msgbox.setWindowTitle("Cppcheck");

msgbox.setText(text);

msgbox.setIcon(QMessageBox::Critical);

msgbox.exec();

}

}

{

QString text = tr("Could not find file:") + '\n' + file + '\n';

QString title;

if (file.indexOf('/')) {

QString folderName = file.mid(0, file.indexOf('/'));

text += tr("Please select the folder '%1'").arg(folderName);

title = tr("Select Directory '%1'").arg(folderName);

} else {

text += tr("Please select the directory where file is located.");

title = tr("Select Directory");

}

QMessageBox msgbox(this);

msgbox.setWindowTitle("Cppcheck");

msgbox.setText(text);

msgbox.setIcon(QMessageBox::Warning);

msgbox.exec();

QString dir = QFileDialog::getExistingDirectory(this, title,

getPath(SETTINGS_LAST_SOURCE_PATH),

QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);

if (dir.isEmpty())

return QString();

// User selected root path

if (QFileInfo(dir + '/' + file).exists())

mCheckPath = dir;

// user selected checked folder

else if (file.indexOf('/') > 0) {

dir += '/';

QString folderName = file.mid(0, file.indexOf('/'));

if (dir.indexOf('/' + folderName + '/'))

dir = dir.mid(0, dir.lastIndexOf('/' + folderName + '/'));

if (QFileInfo(dir + '/' + file).exists())

mCheckPath = dir;

}

// Otherwise; return

else

return QString();

setPath(SETTINGS_LAST_SOURCE_PATH, mCheckPath);

return mCheckPath;

{

if (!mSelectionModel)

return;

QModelIndexList selectedRows = mSelectionModel->selectedRows();

QString text;

foreach (QModelIndex index, selectedRows) {

QStandardItem *item = mModel.itemFromIndex(index);

if (!item->parent()) {

text += item->text() + '\n';

continue;

}

if (item->parent()->parent())

item = item->parent();

QVariantMap data = item->data().toMap();

if (!data.contains("id"))

continue;

QString inconclusive = data[INCONCLUSIVE].toBool() ? ",inconclusive" : "";

text += '[' + data[FILENAME].toString() + ':' + QString::number(data[LINE].toInt())

+ "] ("

+ QString::fromStdString(Severity::toString(ShowTypes::ShowTypeToSeverity((ShowTypes::ShowType)data[SEVERITY].toInt()))) + inconclusive

+ ") "

+ data[MESSAGE].toString()

+ " ["

+ data[ERRORID].toString()

+ "]\n";

}

QClipboard *clipboard = QApplication::clipboard();

clipboard->setText(text);

{

if (!mSelectionModel)

return;

QModelIndexList selectedRows = mSelectionModel->selectedRows();

foreach (QModelIndex index, selectedRows) {

QStandardItem *item = mModel.itemFromIndex(index);

//Set the "hide" flag for this item

QVariantMap data = item->data().toMap();

data[HIDE] = true;

item->setData(QVariant(data));

refreshTree();

emit resultsHidden(true);

}

{

if (!mSelectionModel)

return;

QModelIndexList selectedRows = mSelectionModel->selectedRows();

QStringList selectedItems;

foreach (QModelIndex index, selectedRows) {

QStandardItem *item = mModel.itemFromIndex(index);

while (item->parent())

item = item->parent();

QVariantMap data = item->data().toMap();

QString currentFile = data[FILENAME].toString();

if (!currentFile.isEmpty()) {

QString fileNameWithCheckPath;

QFileInfo curfileInfo(currentFile);

if (!curfileInfo.exists() && !mCheckPath.isEmpty() && currentFile.indexOf(mCheckPath) != 0)

fileNameWithCheckPath = mCheckPath + "/" + currentFile;

else

fileNameWithCheckPath = currentFile;

const QFileInfo fileInfo(fileNameWithCheckPath);

if (!fileInfo.exists()) {

askFileDir(currentFile);

return;

}

if (Path::isHeader(currentFile.toStdString())) {

if (!data[FILE0].toString().isEmpty() && !selectedItems.contains(data[FILE0].toString())) {

selectedItems<<((!mCheckPath.isEmpty() && (data[FILE0].toString().indexOf(mCheckPath) != 0)) ? (mCheckPath + "/" + data[FILE0].toString()) : data[FILE0].toString());

if (!selectedItems.contains(fileNameWithCheckPath))

selectedItems<<fileNameWithCheckPath;

}

} else if (!selectedItems.contains(fileNameWithCheckPath))

selectedItems<<fileNameWithCheckPath;

}

}

emit checkSelected(selectedItems);

{

if (!mContextItem || !mContextItem->parent())

return;

// Make sure we are working with the first column

if (mContextItem->column() != 0)

mContextItem = mContextItem->parent()->child(mContextItem->row(), 0);

QVariantMap data = mContextItem->data().toMap();

QString messageId = data[ERRORID].toString();

mHiddenMessageId.append(messageId);

// hide all errors with that message Id

int filecount = mModel.rowCount();

for (int i = 0; i < filecount; i++) {

//Get file i

QStandardItem *file = mModel.item(i, 0);

if (!file) {

continue;