HistoryModel::HistoryModel(HistoryManager *history, QObject *parent)
: QAbstractTableModel(parent)
, m_history(history)
{
Q_ASSERT(m_history);
connect(m_history, SIGNAL(historyReset()),
this, SLOT(historyReset()));
connect(m_history, SIGNAL(entryRemoved(HistoryItem)),
this, SLOT(historyReset()));
connect(m_history, SIGNAL(entryAdded(HistoryItem)),
this, SLOT(entryAdded()));
connect(m_history, SIGNAL(entryUpdated(int)),
this, SLOT(entryUpdated(int)));
}
HistoryEntryItem* HistoryModel::addEntry(const QUrl &url, const QString &title, const QIcon &icon, const QDateTime &date, quint64 identifier)
{
blockSignals(true);
HistoryEntryItem *entry(new HistoryEntryItem());
entry->setIcon(icon);
insertRow(0, entry);
setData(entry->index(), url, UrlRole);
setData(entry->index(), title, TitleRole);
setData(entry->index(), date, TimeVisitedRole);
if (identifier == 0 || m_identifiers.contains(identifier))
{
identifier = (m_identifiers.isEmpty() ? 1 : (m_identifiers.keys().last() + 1));
}
setData(entry->index(), identifier, IdentifierRole);
m_identifiers[identifier] = entry;
blockSignals(false);
emit entryAdded(entry);
return entry;
}
HistoryManager::HistoryManager(QObject *parent)
:
#if defined(QWEBENGINEHISTORYINTERFACE)
QWebEngineHistoryInterface(parent),
#endif
m_saveTimer(new AutoSaver(this))
, m_historyLimit(30)
, m_historyModel(0)
, m_historyFilterModel(0)
, m_historyTreeModel(0)
{
m_expiredTimer.setSingleShot(true);
connect(&m_expiredTimer, SIGNAL(timeout()),
this, SLOT(checkForExpired()));
connect(this, SIGNAL(entryAdded(HistoryItem)),
m_saveTimer, SLOT(changeOccurred()));
connect(this, SIGNAL(entryRemoved(HistoryItem)),
m_saveTimer, SLOT(changeOccurred()));
load();
m_historyModel = new HistoryModel(this, this);
m_historyFilterModel = new HistoryFilterModel(m_historyModel, this);
m_historyTreeModel = new HistoryTreeModel(m_historyFilterModel, this);
#if defined(QWEBENGINEHISTORYINTERFACE)
// QWebEngineHistoryInterface will delete the history manager
QWebEngineHistoryInterface::setDefaultInterface(this);
#endif
}
void DvbEpgTableModel::setEpgModel(DvbEpgModel *epgModel_)
{
if (epgModel != NULL) {
Log("DvbEpgTableModel::setEpgModel: epg model already set");
return;
}
epgModel = epgModel_;
connect(epgModel, SIGNAL(entryAdded(DvbSharedEpgEntry)),
this, SLOT(entryAdded(DvbSharedEpgEntry)));
connect(epgModel, SIGNAL(entryAboutToBeUpdated(DvbSharedEpgEntry)),
this, SLOT(entryAboutToBeUpdated(DvbSharedEpgEntry)));
connect(epgModel, SIGNAL(entryUpdated(DvbSharedEpgEntry)),
this, SLOT(entryUpdated(DvbSharedEpgEntry)));
connect(epgModel, SIGNAL(entryRemoved(DvbSharedEpgEntry)),
this, SLOT(entryRemoved(DvbSharedEpgEntry)));
}
/*!
Displays the to-do viewer and populates the to-do entry attributes.
\param entry Agenda entry from which attributes have to be read.
*/
void AgendaEventView::execute(AgendaEntry entry,
AgendaEventViewer::Actions action)
{
OstTraceFunctionEntry0( AGENDAEVENTVIEW_EXECUTE_ENTRY );
mOriginalAgendaEntry = entry;
mAgendaEntry = entry;
// For later reference
mParentId = mOwner->mAgendaUtil->parentEntry(mAgendaEntry).id();
// Add the viewer data reading from the agenda entry.
addViewerData();
// Remove unnecessary widget from event viewer.
removeWidget();
// Add the menu items to event viewer.
addMenuItem();
// Add the toolbar items to event viewer
addToolBarItem(action);
// Connect for the entry updation and addtion signal to refresh the view
// when the same is edited in editor.
connect(mOwner->mAgendaUtil, SIGNAL(entryUpdated(ulong)),
this, SLOT(handleEntryUpdation(ulong)));
connect(mOwner->mAgendaUtil, SIGNAL(entryAdded(ulong)),
this, SLOT(handleEntryUpdation(ulong)));
// Connect for entry deletion signal to close the event viewer.
connect(mOwner->mAgendaUtil, SIGNAL(entryDeleted(ulong)), this,
SLOT(handleEntryDeletion(ulong)));
// Add the view to the main window.
HbMainWindow *window = hbInstance->allMainWindows().first();
if (!window) {
// Might be some non-ui based app called us
// so create mainwindow now
mMainWindow = new HbMainWindow();
mMainWindow->addView(mViewer);
mMainWindow->setCurrentView(mViewer);
connect(mMainWindow,SIGNAL(orientationChanged(Qt::Orientation)),this,SLOT(changedOrientation(Qt::Orientation)));
} else {
window->addView(mViewer);
window->setCurrentView(mViewer);
connect(window,SIGNAL(orientationChanged(Qt::Orientation)),this,SLOT(changedOrientation(Qt::Orientation)));
}
// Add softkey after adding view on window
mBackAction = new HbAction(Hb::BackNaviAction);
mViewer->setNavigationAction(mBackAction);
connect(mBackAction, SIGNAL(triggered()), this, SLOT(close()));
OstTraceFunctionExit0( AGENDAEVENTVIEW_EXECUTE_EXIT );
}
Core::Core()
: m_originalMangler(nullptr)
{
#if IDA_SDK_VERSION >= 670
action_desc_t action =
{
sizeof(action),
"retypedef_open_name_subst_editor",
"Edit name substitutions...",
&m_optionsMenuItemClickedAction,
&PLUGIN
};
register_action(action);
attach_action_to_menu("Options/", "retypedef_open_name_subst_editor", 0);
#else
add_menu_item("Options/", "Edit name substitutions...", nullptr, 0,
&Core::onOptionsMenuItemClicked, this);
#endif
// First start? Initialize with default rules.
Settings settings;
if (settings.value(Settings::kFirstStart, true).toBool())
{
QSettings defaultRules(":/Misc/default_rules.ini", QSettings::IniFormat);
SettingsImporterExporter importer(&m_substitutionManager, &defaultRules);
importer.importRules();
saveToSettings();
settings.setValue(Settings::kFirstStart, false);
}
// Load rules from settings and subscribe to changes in the manager
try
{
SettingsImporterExporter importer(&m_substitutionManager, &settings);
importer.importRules();
}
catch (const SettingsImporterExporter::Error& e)
{
msg("[" PLUGIN_NAME "] Cannot load settings: %s\n", e.what());
}
connect(&m_substitutionManager, SIGNAL(entryAdded()), SLOT(saveToSettings()));
connect(&m_substitutionManager, SIGNAL(entryDeleted()), SLOT(saveToSettings()));
// Place demangler detour
HMODULE hIdaWll = GetModuleHandleA("IDA.WLL");
if (!hIdaWll)
throw std::runtime_error("cannot find IDA.WLL");
auto demangle = reinterpret_cast<demangler_t*>(GetProcAddress(hIdaWll, "demangle"));
if (!demangle)
throw std::runtime_error("cannot find exported function \"demangle\" in IDA.WLL");
m_demanglerDetour.reset(new DemanglerDetour(demangle, &Core::demanglerHookCallback));
m_demanglerDetour->attach(m_originalMangler);
}
void HistoryManager::addHistoryItem(const HistoryItem &item)
{
if (BrowserApplication::instance()->privateBrowsing())
return;
m_history.prepend(item);
emit entryAdded(item);
if (m_history.count() == 1)
checkForExpired();
}
SMainForm::SMainForm(QWidget *parent) :
QWidget(parent),
ui(new Ui::SMainForm)
,m_watcher( new SWatcher())
{
ui->setupUi(this);
connect(SCmdLog::instance(),SIGNAL(entryAdded( QString )),this->ui->m_cmdWindow,SLOT(append(QString)),Qt::QueuedConnection);
connect(ui->addPathButton,SIGNAL(clicked()),this,SLOT(addPathsForWatch()));
connect(ui->m_createDbgEntryButton,SIGNAL(clicked()),this,SLOT(sendDbgEntry()));
}
void NetworkCache::insert(QIODevice *device)
{
QNetworkDiskCache::insert(device);
if (m_devices.contains(device))
{
emit entryAdded(m_devices[device]);
m_devices.remove(device);
}
}
void HistoryManager::addHistoryItem(const HistoryItem &item)
{
QWebSettings *globalSettings = QWebSettings::globalSettings();
if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
return;
m_history.prepend(item);
emit entryAdded(item);
if (m_history.count() == 1)
checkForExpired();
}
void Server::add(const QVariantMap& entry) {
CHECK_PARAM_RET(entry.contains(KEY));
const QString& sKey = entry.value(KEY).toString();
CHECK_PARAM_RET(!sKey.isEmpty());
m_database.insert(sKey, entry);
qDebug() << "database:";
qDebug() << m_database;
emit entryAdded(entry);
}
void HistoryManager::addHistoryItem(const HistoryItem &item)
{
#if defined(QWEBENGINESETTINGS)
QWebEngineSettings *globalSettings = QWebEngineSettings::globalSettings();
if (globalSettings->testAttribute(QWebEngineSettings::PrivateBrowsingEnabled))
return;
#endif
m_history.prepend(item);
emit entryAdded(item);
if (m_history.count() == 1)
checkForExpired();
}
void HistoryManager::addHistoryEntry(const QString &url)
{
QWebSettings *globalSettings = QWebSettings::globalSettings();
if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
return;
QUrl cleanUrl(url);
// don't store about: urls (home page related)
if (cleanUrl.scheme() == QString("about"))
return;
cleanUrl.setPassword(QString());
cleanUrl.setHost(cleanUrl.host().toLower());
QString checkUrlString = cleanUrl.toString();
HistoryItem item;
// NOTE
// check if the url has just been visited.
// if so, remove previous entry from history, update and prepend it
if(historyContains(checkUrlString))
{
int index = m_historyFilterModel->historyLocation(checkUrlString);
item = m_history.at(index);
m_history.removeOne(item);
emit entryRemoved(item);
item.dateTime = QDateTime::currentDateTime();
item.visitCount++;
}
else
{
item = HistoryItem(checkUrlString, QDateTime::currentDateTime());
}
m_history.prepend(item);
emit entryAdded(item);
if (m_history.count() == 1)
checkForExpired();
}
HistoryManager::HistoryManager(QObject *parent)
: QObject(parent)
, m_saveTimer(new AutoSaver(this))
, m_historyLimit(30)
, m_historyModel(0)
, m_historyFilterModel(0)
, m_historyTreeModel(0)
{
m_expiredTimer.setSingleShot(true);
connect(&m_expiredTimer, SIGNAL(timeout()),
this, SLOT(checkForExpired()));
connect(this, SIGNAL(entryAdded(HistoryItem)),
m_saveTimer, SLOT(changeOccurred()));
connect(this, SIGNAL(entryRemoved(HistoryItem)),
m_saveTimer, SLOT(changeOccurred()));
load();
m_historyModel = new HistoryModel(this, this);
m_historyFilterModel = new HistoryFilterModel(m_historyModel, this);
m_historyTreeModel = new HistoryTreeModel(m_historyFilterModel, this);
}
HistoryContentsWidget::HistoryContentsWidget(Window *window) : ContentsWidget(window),
m_model(new QStandardItemModel(this)),
m_isLoading(true),
m_ui(new Ui::HistoryContentsWidget)
{
m_ui->setupUi(this);
QStringList groups;
groups << tr("Today") << tr("Yesterday") << tr("Earlier This Week") << tr("Previous Week") << tr("Earlier This Month") << tr("Earlier This Year") << tr("Older");
for (int i = 0; i < groups.count(); ++i)
{
m_model->appendRow(new QStandardItem(Utils::getIcon(QLatin1String("inode-directory")), groups.at(i)));
}
QStringList labels;
labels << tr("Address") << tr("Title") << tr("Date");
m_model->setHorizontalHeaderLabels(labels);
m_model->setSortRole(Qt::DisplayRole);
m_ui->historyView->setModel(m_model);
m_ui->historyView->setItemDelegate(new ItemDelegate(this));
m_ui->historyView->header()->setTextElideMode(Qt::ElideRight);
m_ui->historyView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
m_ui->historyView->expand(m_model->index(0, 0));
QTimer::singleShot(100, this, SLOT(populateEntries()));
connect(HistoryManager::getInstance(), SIGNAL(cleared()), this, SLOT(populateEntries()));
connect(HistoryManager::getInstance(), SIGNAL(entryAdded(qint64)), this, SLOT(addEntry(qint64)));
connect(HistoryManager::getInstance(), SIGNAL(entryUpdated(qint64)), this, SLOT(updateEntry(qint64)));
connect(HistoryManager::getInstance(), SIGNAL(entryRemoved(qint64)), this, SLOT(removeEntry(qint64)));
connect(HistoryManager::getInstance(), SIGNAL(dayChanged()), this, SLOT(populateEntries()));
connect(m_ui->filterLineEdit, SIGNAL(textChanged(QString)), this, SLOT(filterHistory(QString)));
connect(m_ui->historyView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(openEntry(QModelIndex)));
connect(m_ui->historyView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showContextMenu(QPoint)));
}
//-----------------------------------------------------------------------------
int ctkErrorLogModelTest1(int argc, char * argv [])
{
QCoreApplication app(argc, argv);
Q_UNUSED(app);
ctkErrorLogModel model;
ctkModelTester modelTester;
modelTester.setVerbose(false);
QString errorMsg;
QStringList enabledMessageHandlers = model.msgHandlerEnabled();
int currentEnabledMessageHandlersCount = enabledMessageHandlers.count();
errorMsg = checkInteger(__LINE__, "EnabledMessageHandlersCount", currentEnabledMessageHandlersCount, 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
try
{
modelTester.setModel(&model);
// --------------------------------------------------------------------------
// Monitor Qt messages
{
model.registerMsgHandler(new ctkErrorLogQtMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, true);
QSignalSpy entryAddedSpy(&model, SIGNAL(entryAdded(ctkErrorLogLevel::LogLevel)));
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
QString qtMessage0("This is a qDebug message");
qDebug().nospace() << qPrintable(qtMessage0);
QString qtMessage1("This is a qWarning message");
qWarning().nospace() << qPrintable(qtMessage1);
QString qtMessage2("This is a qCritical message");
qCritical().nospace() << qPrintable(qtMessage2);
// Give enough time to the ErrorLogModel to consider the queued messages.
processEvents(1000);
QStringList expectedQtMessages;
expectedQtMessages << qtMessage0 << qtMessage1 << qtMessage2;
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ expectedQtMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ expectedQtMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedQtMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
// Check if msgHandlerEnabled() works as expected
enabledMessageHandlers = model.msgHandlerEnabled();
currentEnabledMessageHandlersCount = enabledMessageHandlers.count();
errorMsg = checkInteger(__LINE__, "EnabledMessageHandlersCount", currentEnabledMessageHandlersCount, 1);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
// Check if handler can be enabled / disabled multiple times in a row
for (int idx = 0; idx < 3; ++idx)
{
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, false);
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, true);
}
// Clear
model.clear();
entryAddedSpy.clear();
// Disable Qt messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, false);
qDebug() << "This qDebug message should appear in the console";
qWarning() << "This qWarning message should appear in the console";
qCritical() << "This qCritical message should appear in the console";
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
// --------------------------------------------------------------------------
// Monitor Stream messages
{
model.registerMsgHandler(new ctkErrorLogStreamMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, true);
QSignalSpy entryAddedSpy(&model, SIGNAL(entryAdded(ctkErrorLogLevel::LogLevel)));
// Make sure Qt message handler is still disabled
if (model.msgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName))
{
model.disableAllMsgHandler();
errorMsg = QLatin1String("Line %1 - Qt message handler should be disabled");
printErrorMessage(errorMsg.arg(__LINE__));
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
QString streamMessage0("This is a Cout message");
std::cout << qPrintable(streamMessage0) << std::endl;
QString streamMessage1("This is a Cerr message");
std::cerr << qPrintable(streamMessage1) << std::endl;
// Give enough time to the ErrorLogModel to consider the queued messages.
processEvents(1000);
QStringList expectedStreamMessages;
expectedStreamMessages << streamMessage0 << streamMessage1;
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ expectedStreamMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ expectedStreamMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedStreamMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
// Check if handler can be enabled / disabled multiple times in a row
for (int idx = 0; idx < 3; ++idx)
{
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, false);
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, true);
}
// Clear
model.clear();
entryAddedSpy.clear();
// Disable Stream messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, false);
std::cout << "This std::cout message should appear in the console" << std::endl;
std::cerr << "This std::cerr message should appear in the console" << std::endl;
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
// --------------------------------------------------------------------------
// Monitor FD messages
{
model.registerMsgHandler(new ctkErrorLogFDMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, true);
QSignalSpy entryAddedSpy(&model, SIGNAL(entryAdded(ctkErrorLogLevel::LogLevel)));
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
QString fdMessage0("This is a stdout");
fprintf(stdout, "%s", qPrintable(fdMessage0));
QString fdMessage0b(" message");
fprintf(stdout, "%s\n", qPrintable(fdMessage0b));
fdMessage0.append(fdMessage0b);
fflush(stdout);
QString fdMessage1("This is a 2nd stdout message");
fprintf(stdout, "%s\n", qPrintable(fdMessage1));
fflush(stdout);
QString fdMessage2("This is a stderr");
fprintf(stderr, "%s", qPrintable(fdMessage2));
QString fdMessage2b(" message");
fprintf(stderr, "%s\n", qPrintable(fdMessage2b));
fdMessage2.append(fdMessage2b);
fflush(stderr);
QString fdMessage3("This is a 2nd stderr message");
fprintf(stderr, "%s\n", qPrintable(fdMessage3));
fflush(stderr);
QStringList expectedFDMessages;
expectedFDMessages << fdMessage0 << fdMessage1 << fdMessage2 << fdMessage3;
// Give enough time to the ErrorLogModel to consider the queued messages.
// and also to the QFileSystemWatcher used internally by ctkErrorLogFDMessageHandler
// to consider the updated files.
processEvents(1500);
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ expectedFDMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ expectedFDMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedFDMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
// Check if handler can be enabled / disabled multiple times in a row
for (int idx = 0; idx < 3; ++idx)
{
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, false);
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, true);
}
// Clear
model.clear();
entryAddedSpy.clear();
// Disable FD messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, false);
fprintf(stdout, "%s", "This stdout message should appear in the console\n");
fprintf(stderr, "%s", "This stderr message should appear in the console\n");
fflush(stderr);
errorMsg = checkRowCount(__LINE__, model.logEntryCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkSpyCount(__LINE__, entryAddedSpy.count(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
}
catch (const char* error)
{
model.disableAllMsgHandler();
std::cerr << error << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void SubstitutionManager::addRule(const std::shared_ptr<Substitution> subst)
{
m_rules.push_back(std::move(subst));
emit entryAdded();
}
void FilteredLog::setLogModel(Log *model)
{
d->logmodel = model;
setSourceModel(model);
connect(model, SIGNAL(entryAdded(QSqlQuery)), this, SLOT(invalidate()));
}
