#include <cstring>

#include <algorithm>

#include <QtGui/QClipboard>

#include <QtGui/QGuiApplication>

#include <QtCore/QStringList>

#include "entry.h"

#include "view.h"

#include "fontsettings.h"

const int AddressColumn = 0;

const int NameColumn = 1;

const int ColumnCount = 2;

GenericEntryModel::GenericEntryModel(QWidget* parent, BinaryViewRef data): QAbstractItemModel(parent)

{

m_data = data;

m_sortOrder = Qt::AscendingOrder;

m_allEntries = data->GetAllEntryFunctions();

m_entries = m_allEntries;

}

int GenericEntryModel::columnCount(const QModelIndex&) const

{

return ColumnCount;

}

int GenericEntryModel::rowCount(const QModelIndex& parent) const

{

if (parent.isValid())

return 0;

return (int)m_entries.size();

}

QVariant GenericEntryModel::data(const QModelIndex& index, int role) const

{

switch (role)

{

case Qt::DisplayRole:

if (!index.isValid() || index.row() >= (int)m_entries.size())

return QVariant();

if (index.column() == AddressColumn)

return QString("0x") + QString::number(m_entries[index.row()]->GetStart(), 16);

if (index.column() == NameColumn)

return QString::fromStdString(m_entries[index.row()]->GetSymbol()->GetFullName());

break;

case Qt::ForegroundRole:

if (index.column() == AddressColumn)

return getThemeColor(AddressColor);

if (index.column() == NameColumn)

return getThemeColor(ExportColor);

break;

default:

break;

}

return QVariant();

}

QVariant GenericEntryModel::headerData(int section, Qt::Orientation orientation, int role) const

{

if (orientation == Qt::Vertical)

return QVariant();

if (role != Qt::DisplayRole)

return QVariant();

if (section == AddressColumn)

return QString("Address");

if (section == NameColumn)

return QString("Name");

return QVariant();

}

QModelIndex GenericEntryModel::index(int row, int col, const QModelIndex& parent) const

{

if (parent.isValid())

return QModelIndex();

if (row >= (int)m_entries.size())

return QModelIndex();

if (col >= ColumnCount)

return QModelIndex();

return createIndex(row, col);

}

QModelIndex GenericEntryModel::parent(const QModelIndex&) const

{

return QModelIndex();

}

FunctionRef GenericEntryModel::getEntry(const QModelIndex& index)

{

if (!index.isValid() || index.row() >= (int)m_entries.size())

return nullptr;

return m_entries[index.row()];

}

void GenericEntryModel::performSort(int col, Qt::SortOrder order)

{

std::sort(m_entries.begin(), m_entries.end(), [&](FunctionRef a, FunctionRef b) {

if (col == AddressColumn)

{

if (a->GetStart() != b->GetStart())

{

if (order == Qt::AscendingOrder)

return a->GetStart() < b->GetStart();

else

return a->GetStart() > b->GetStart();

}

if (order == Qt::AscendingOrder)

return a->GetSymbol()->GetFullName() < b->GetSymbol()->GetFullName();

else

return a->GetSymbol()->GetFullName() > b->GetSymbol()->GetFullName();

}

else if (col == NameColumn)

{

if (order == Qt::AscendingOrder)

return a->GetSymbol()->GetFullName() < b->GetSymbol()->GetFullName();

else

return a->GetSymbol()->GetFullName() > b->GetSymbol()->GetFullName();

}

return false;

});

}

void GenericEntryModel::sort(int col, Qt::SortOrder order)

{

beginResetModel();

m_sortCol = col;

m_sortOrder = order;

performSort(col, order);

endResetModel();

}

void GenericEntryModel::setFilter(const std::string& filterText, FilterOptions options)

{

beginResetModel();

m_entries.clear();

bool caseSensitive = options.testFlag(FilterOption::CaseSensitiveOption);

for (auto& entry : m_allEntries)

{

if (FilteredView::match(entry->GetSymbol()->GetFullName(), filterText, caseSensitive))

m_entries.push_back(entry);

}

performSort(m_sortCol, m_sortOrder);

endResetModel();

}

EntryTreeView::EntryTreeView(EntryWidget* parent, TriageView* view, BinaryViewRef data) : QTreeView(parent)

{

m_data = data;

m_parent = parent;

m_view = view;

// Allow view-specific shortcuts when imports are focused

m_actionHandler.setupActionHandler(this);

m_actionHandler.setActionContext([=, this]() { return m_view->actionContext(); });

m_model = new GenericEntryModel(this, m_data);

setModel(m_model);

setRootIsDecorated(false);

setUniformRowHeights(true);

setSortingEnabled(true);

setSelectionMode(QAbstractItemView::ExtendedSelection);

setSelectionBehavior(QAbstractItemView::SelectRows);

setAllColumnsShowFocus(true);

sortByColumn(AddressColumn, Qt::AscendingOrder);

setColumnWidth(AddressColumn, 90);

setFont(getMonospaceFont(this));

connect(selectionModel(), &QItemSelectionModel::currentChanged, this, &EntryTreeView::entrySelected);

connect(this, &QTreeView::doubleClicked, this, &EntryTreeView::entryDoubleClicked);

m_actionHandler.bindAction("Copy", UIAction([this]() { copySelection(); }, [this]() { return canCopySelection(); }));

}

void EntryTreeView::copySelection()

{

if (!model() || !selectionModel())

return;

QModelIndexList rows = selectionModel()->selectedRows();

if (rows.isEmpty())

return;

std::sort(rows.begin(), rows.end(), [](const QModelIndex& a, const QModelIndex& b) { return a.row() < b.row(); });

QStringList lines;

for (const QModelIndex& rowIndex : rows)

{

QStringList cells;

for (int column = 0; column < m_model->columnCount(QModelIndex()); column++)

{

if (isColumnHidden(column))

continue;

QModelIndex idx = m_model->index(rowIndex.row(), column, QModelIndex());

cells << m_model->data(idx, Qt::DisplayRole).toString();

}

lines << cells.join("\t");

}

if (QClipboard* clipboard = QGuiApplication::clipboard())

clipboard->setText(lines.join("\n"));

}

bool EntryTreeView::canCopySelection() const

{

return !selectionModel()->selectedRows().isEmpty();

}

void EntryTreeView::entrySelected(const QModelIndex& cur, const QModelIndex&)

{

}

void EntryTreeView::entryDoubleClicked(const QModelIndex& cur)

{

FunctionRef func = m_model->getEntry(cur);

if (func)

{

ViewFrame* viewFrame = ViewFrame::viewFrameForWidget(this);

if (viewFrame)

{

if (BinaryNinja::Settings::Instance()->Get<bool>("ui.view.graph.preferred") &&

viewFrame->getCurrentBinaryView() &&

func->GetStart() > 0)

{

viewFrame->navigate("Graph:" + viewFrame->getCurrentDataType(), func->GetStart());

}

else

{

viewFrame->navigate("Linear:" + viewFrame->getCurrentDataType(), func->GetStart());

}

}

}

}

void EntryTreeView::setFilter(const std::string& filterText, FilterOptions options)

{

m_model->setFilter(filterText, options);

}

void EntryTreeView::scrollToFirstItem()

{

scrollToTop();

}

void EntryTreeView::scrollToCurrentItem()

{

scrollTo(currentIndex());

}

void EntryTreeView::ensureSelection()

{

if (auto current = currentIndex(); !current.isValid())

setCurrentIndex(m_model->index(0, 0, QModelIndex()));

}

void EntryTreeView::activateSelection()

{

ensureSelection();

if (auto current = currentIndex(); current.isValid())

entryDoubleClicked(current);

}

void EntryTreeView::closeFilter()

{

setFocus(Qt::OtherFocusReason);

}

void EntryTreeView::keyPressEvent(QKeyEvent* event)

{

if ((event->text().size() == 1) && (event->text()[0] > ' ') && (event->text()[0] <= '~'))

{

m_parent->showFilter(event->text());

event->accept();

}

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

{

QList<QModelIndex> sel = selectionModel()->selectedIndexes();

if (sel.size() != 0)

entryDoubleClicked(sel[0]);

}

else if (event->matches(QKeySequence::Copy))

{

copySelection();

event->accept();

return;

}

QTreeView::keyPressEvent(event);

}

EntryWidget::EntryWidget(QWidget* parent, TriageView* view, BinaryViewRef data) : QWidget(parent)

{

QVBoxLayout* layout = new QVBoxLayout();

layout->setContentsMargins(0, 0, 0, 0);

EntryTreeView* entry = new EntryTreeView(this, view, data);

m_filter = new FilteredView(this, entry, entry);

m_filter->setFilterPlaceholderText("Search entry functions");

layout->addWidget(m_filter, 1);

setLayout(layout);

setMinimumSize(UIContext::getScaledWindowSize(100, 196));

}

void EntryWidget::showFilter(const QString& filter)

{

m_filter->showFilter(filter);

}