const QString& errorId, Severity severity) {

return QString::fromStdString(getGuideline(errorId.toStdString(),

reportType, guidelineMapping,

severity));

if (c == checkers::Man)

return Severity::error;

if (c == checkers::Req)

return Severity::warning;

if (c == checkers::Adv)

return Severity::style;

if (c == checkers::Doc)

return Severity::information;

if (c == "L1")

return Severity::error;

if (c == "L2")

return Severity::warning;

if (c == "L3")

return Severity::style;

return Severity::none;

return QStringList{

QObject::tr("File"),

QObject::tr("Line"),

QObject::tr("Severity"),

QObject::tr("Classification"),

QObject::tr("Level"),

QObject::tr("Inconclusive"),

QObject::tr("Summary"),

QObject::tr("Id"),

QObject::tr("Guideline"),

QObject::tr("Rule"),

QObject::tr("Since date"),

QObject::tr("Tags"),

"CWE"};

QTreeView(parent),

mModel(new QStandardItemModel)

{

setModel(mModel);

translate(); // Adds columns to grid

clear();

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);

mReportType = reportType;

mGuideline = createGuidelineMapping(reportType);

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

auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));

if (!fileItem)

continue;

for (int j = 0; j < fileItem->rowCount(); ++j) {

QSharedPointer<ErrorItem>& errorItem = dynamic_cast<ResultItem*>(fileItem->child(j,0))->errorItem;

errorItem->guideline = getGuideline(mReportType, mGuideline, errorItem->errorId, errorItem->severity);

errorItem->classification = getClassification(mReportType, errorItem->guideline);

dynamic_cast<ResultItem*>(fileItem->child(j, COLUMN_FILE))->setIconFileName(severityToIcon(getSeverity(reportType, *errorItem)));

fileItem->child(j, COLUMN_CERT_LEVEL)->setText(errorItem->classification);

fileItem->child(j, COLUMN_CERT_RULE)->setText(errorItem->guideline);

fileItem->child(j, COLUMN_MISRA_CLASSIFICATION)->setText(errorItem->classification);

fileItem->child(j, COLUMN_MISRA_GUIDELINE)->setText(errorItem->guideline);

}

}

if (isAutosarMisraReport()) {

showColumn(COLUMN_MISRA_CLASSIFICATION);

showColumn(COLUMN_MISRA_GUIDELINE);

} else {

hideColumn(COLUMN_MISRA_CLASSIFICATION);

hideColumn(COLUMN_MISRA_GUIDELINE);

}

if (isCertReport()) {

showColumn(COLUMN_CERT_LEVEL);

showColumn(COLUMN_CERT_RULE);

} else {

hideColumn(COLUMN_CERT_LEVEL);

hideColumn(COLUMN_CERT_RULE);

}

if (mReportType == ReportType::normal) {

showColumn(COLUMN_SEVERITY);

} else {

hideColumn(COLUMN_SEVERITY);

}

refreshTree();

{

mSettings = settings;

mApplications = list;

mThread = checkThreadHandler;

loadSettings();

{

if (errorItem.errorPath.isEmpty())

return false;

const QString s = errorItem.toString();

if (mErrorList.contains(s))

return false;

mErrorList.append(s);

QSharedPointer<ErrorItem> errorItemPtr{new ErrorItem(errorItem)};

if (mReportType != ReportType::normal) {

errorItemPtr->guideline = getGuideline(mReportType, mGuideline, errorItemPtr->errorId, errorItemPtr->severity);

errorItemPtr->classification = getClassification(mReportType, errorItemPtr->guideline);

}

const bool showItem = !isErrorItemHidden(errorItemPtr);

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

mVisibleErrors |= showItem;

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

errorItemPtr->tags = activeProject->getWarningTags(errorItemPtr->hash);

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

//file item as a parent

ResultItem* fileItem = ensureFileItem(errorItemPtr, !showItem);

ResultItem* stditem = addBacktraceFiles(fileItem,

errorItemPtr,

!showItem,

severityToIcon(getSeverity(mReportType, *errorItemPtr)),

ResultItem::Type::message,

errorItemPtr->getMainLocIndex());

if (!stditem)

return false;

//Add backtrace files as children

if (errorItemPtr->errorPath.size() > 1) {

for (int i = 0; i < errorItemPtr->errorPath.size(); i++) {

addBacktraceFiles(stditem,

errorItemPtr,

false,

":images/go-down.png",

ResultItem::Type::note,

i);

}

}

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::internal:

return tr("internal");

case Severity::none:

return QString();

}

cppcheck::unreachable();

{

mErrorList.clear();

mModel->removeRows(0, mModel->rowCount());

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

hideColumn(COLUMN_SINCE_DATE);

if (activeProject->getTags().isEmpty())

hideColumn(COLUMN_TAGS);

else

showColumn(COLUMN_TAGS);

} else {

hideColumn(COLUMN_SINCE_DATE);

hideColumn(COLUMN_TAGS);

}

{

const QString stripped = QDir::toNativeSeparators(stripPath(filename, false));

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

const auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));

if (!fileItem)

continue;

if (stripped == fileItem->text() ||

filename == fileItem->errorItem->file0) {

mErrorList.removeAll(fileItem->errorItem->toString());

mModel->removeRow(i);

break;

}

}

{

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

const auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));

if (!fileItem)

continue;

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

QString storedfile = fileItem->getErrorPathItem().file;

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

if (actualfile == storedfile) {

mErrorList.removeAll(fileItem->errorItem->toString());

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, true).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();

refreshTree();

emit resultsHidden(false);

{

mVisibleErrors = false;

//Get the amount of files in the tree

const int filecount = mModel->rowCount();

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

//Get file i

auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, 0));

if (!fileItem) {

continue;

}

//Get the amount of errors this file contains

const int errorcount = fileItem->rowCount();

//By default it shouldn't be visible

bool showFile = false;

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

//Get the error itself

const auto *child = dynamic_cast<ResultItem*>(fileItem->child(j, 0));

if (!child) {

continue;

}

//Check if this error should be hidden

const bool hide = child->hidden || isErrorItemHidden(child->errorItem);

if (!hide) {

showFile = true;

mVisibleErrors = true;

}

//Hide/show accordingly

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

}

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

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

}

sortByColumn(header()->sortIndicatorSection(), header()->sortIndicatorOrder());

//Check if this error should be hidden

if (mHiddenMessageId.contains(errorItem->errorId))

return true;

bool hide;

if (mReportType == ReportType::normal)

hide = !mShowSeverities.isShown(errorItem->severity);

else

hide = errorItem->classification.isEmpty() || !mShowSeverities.isShown(getSeverityFromClassification(errorItem->classification));

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

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

hide = !errorItem->filterMatch(mFilter);

// Tool filter

if (!hide) {

if (errorItem->isClangResult())

hide = !mShowClang;

else

hide = !mShowCppcheck;

}

return hide;

{

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

if (index.isValid()) {

bool multipleSelection = false;

mSelectionModel = selectionModel();

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

multipleSelection = true;

mContextItem = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

//Create a new context menu

QMenu menu(this);

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

//member variables

QSignalMapper signalMapper;

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

//Create an action for the application

int defaultApplicationIndex = mApplications->getDefaultApplication();

defaultApplicationIndex = std::max(defaultApplicationIndex, 0);

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

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

if (multipleSelection)

start->setDisabled(true);

//Add it to context menu

menu.addAction(start);

//Connect the signal to signal mapper

connect(start, &QAction::triggered, &signalMapper, QOverload<>::of(&QSignalMapper::map));

//Add a new mapping

signalMapper.setMapping(start, defaultApplicationIndex);

connect(&signalMapper, SIGNAL(mappedInt(int)),

this, SLOT(context(int)));

}

// Add popup menuitems

if (mContextItem) {

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

menu.addSeparator();

}

int selectedFiles = 0;

int selectedResults = 0;

for (auto row : mSelectionModel->selectedRows()) {

auto *item = mModel->itemFromIndex(row);

if (!item->parent())

selectedFiles++;

else if (!item->parent()->parent())

selectedResults++;

}

//Create an action for the application

auto *recheckAction = new QAction(tr("Recheck %1 file(s)").arg(selectedFiles), &menu);

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

auto *hide = new QAction(tr("Hide %1 result(s)").arg(selectedResults), &menu);

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

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

if (selectedFiles == 0 || mThread->isChecking() || mResultsSource == ResultsSource::Log)

recheckAction->setDisabled(true);

if (selectedResults == 0)

hide->setDisabled(true);

if (selectedResults == 0 || multipleSelection)

hideallid->setDisabled(true);

if (multipleSelection || mResultsSource == ResultsSource::Log)

opencontainingfolder->setDisabled(true);

menu.addAction(recheckAction);

menu.addSeparator();

menu.addAction(copyAction);

menu.addSeparator();

menu.addAction(hide);

menu.addAction(hideallid);

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

{

if (selectedResults == 0 || ErrorLogger::isCriticalErrorId(mContextItem->errorItem->errorId.toStdString()))

suppress->setDisabled(true);

}

menu.addAction(suppress);

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

menu.addSeparator();

menu.addAction(opencontainingfolder);

connect(recheckAction, &QAction::triggered, this, &ResultsTree::recheckSelectedFiles);

connect(copyAction, &QAction::triggered, this, &ResultsTree::copy);

connect(hide, &QAction::triggered, this, &ResultsTree::hideResult);

connect(hideallid, &QAction::triggered, this, &ResultsTree::hideAllIdResult);

connect(opencontainingfolder, &QAction::triggered, this, &ResultsTree::openContainingFolder);

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

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

menu.addSeparator();

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

{

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

tagMenu->addAction(action);

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

tagSelectedItems(QString());

});

}

for (const QString& tagstr : currentProject->getTags()) {

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

tagMenu->addAction(action);

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

tagSelectedItems(tagstr);

});

}

}

}

//Start the menu

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

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

if (index.isValid())

mContextItem = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

}

{

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

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

QMessageBox msg(QMessageBox::Critical,

"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,

"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()) {

const auto& errorPathItem = target->getErrorPathItem();

//Replace (file) with filename

QString file = QDir::toNativeSeparators(errorPathItem.file);

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

const 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);

params.replace("(line)", QString::number(errorPathItem.line), Qt::CaseInsensitive);

params.replace("(message)", target->errorItem->message, Qt::CaseInsensitive);

params.replace("(severity)", severityToTranslatedString(target->errorItem->severity), 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 bool success = QProcess::startDetached(program, QProcess::splitCommand(params));

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::exists(dir + '/' + file))

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::exists(dir + '/' + file))

mCheckPath = dir;

}

// Otherwise; return

else

return QString();

setPath(SETTINGS_LAST_SOURCE_PATH, mCheckPath);

return mCheckPath;

{

if (!mSelectionModel)

return;

QString text;

for (const QModelIndex& index : mSelectionModel->selectedRows()) {

const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

if (!item)

continue;

if (item->getType() == ResultItem::Type::file)

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

else if (item->getType() == ResultItem::Type::message)

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

else if (item->getType() == ResultItem::Type::note) {

const auto e = item->getErrorPathItem();

text += e.file + ":" + QString::number(e.line) + ":" + QString::number(e.column) + ":note: " + e.info + '\n';

}

}

QClipboard *clipboard = QApplication::clipboard();

clipboard->setText(text);

{

if (!mSelectionModel)

return;

bool hide = false;

for (const QModelIndex& index : mSelectionModel->selectedRows()) {

auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

if (item && item->getType() == ResultItem::Type::message)

hide = item->hidden = true;

}

if (hide) {

refreshTree();

emit resultsHidden(true);

}

{

if (!mSelectionModel)

return;

QStringList selectedItems;

for (const QModelIndex& index : mSelectionModel->selectedRows()) {

const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

while (item->parent())

item = dynamic_cast<const ResultItem*>(item->parent());

const auto e = item->getErrorPathItem();

const QString currentFile = e.file;

if (!currentFile.isEmpty()) {

QString fileNameWithCheckPath;

const 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 (!item->errorItem->file0.isEmpty() && !selectedItems.contains(item->errorItem->file0)) {

selectedItems << ((!mCheckPath.isEmpty() && (item->errorItem->file0.indexOf(mCheckPath) != 0)) ? (mCheckPath + "/" + item->errorItem->file0) : item->errorItem->file0);

if (!selectedItems.contains(fileNameWithCheckPath))

selectedItems << fileNameWithCheckPath;

}

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

selectedItems << fileNameWithCheckPath;

}

}

emit checkSelected(std::move(selectedItems));

{

if (!mContextItem || mContextItem->getType() == ResultItem::Type::file)

return;

mHiddenMessageId.append(mContextItem->errorItem->errorId);

refreshTree();

emit resultsHidden(true);

{

if (!mSelectionModel)

return;

QSet<QString> selectedIds;

for (const QModelIndex& index : mSelectionModel->selectedRows()) {

const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));

if (!item || item->getType() == ResultItem::Type::file || !item->errorItem)

continue;

selectedIds << item->errorItem->errorId;

}

// delete all errors with selected message Ids

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

QStandardItem * const file = mModel->item(i, 0);

for (int j = 0; j < file->rowCount();) {

const auto *errorItem = dynamic_cast<ResultItem*>(file->child(j, 0));

if (errorItem && errorItem->errorItem && selectedIds.contains(errorItem->errorItem->errorId)) {

file->removeRow(j);

} else {

j++;

}

}

if (file->rowCount() == 0)

mModel->removeRow(file->row());

}

if (!selectedIds.isEmpty()) {

refreshTree(); // If all visible warnings was suppressed then the file item should be hidden

emit suppressIds(selectedIds.values());