int main(int argc, char *argv[])
{
qInstallMessageHandler(logMessageOutput);
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
#ifdef Q_OS_WIN
signal(SIGBREAK, signalHandler);
#else
signal(SIGHUP, signalHandler);
#endif
signal(SIGINT, signalHandler);
qInstallMessageHandler(messageOutput);
QCoreApplication a(argc, argv);
if (!QDir("../data/").exists())
{
if (!QDir().mkdir("../data/"))
{
DEBUG_FUNCTION("Cant open data folder! Exiting...");
return 0;
}
}
QFile file("../data/log.txt");
log_file = &file;
if (!log_file->open(QFile::WriteOnly | QFile::Text | QFile::Append))
{
qInstallMessageHandler(nullptr);
qDebug() << "Couldn't log to file!";
}
QSettings settings("../data/settings.ini", QSettings::IniFormat);
global_settings = &settings;
DEBUG_FUNCTION("Session started!");
SslServer server;
Q_UNUSED(server)
return a.exec();
}
Logger::~Logger() {
if (defaultLogger==this) {
#if QT_VERSION >= 0x050000
qInstallMessageHandler(0);
#else
qInstallMsgHandler(0);
#endif
defaultLogger=0;
}
}
int main(int argc, char *argv[])
{
qInstallMessageHandler(customMessageHandler);
QCoreApplication a(argc, argv);
MyTcpServer ser;
ser.listen(QHostAddress::Any,6666);
return a.exec();
}
QErrorMessage * QErrorMessage::qtHandler()
{
if (!qtMessageHandler) {
qtMessageHandler = new QErrorMessage(0);
qAddPostRoutine(deleteStaticcQErrorMessage); // clean up
qtMessageHandler->setWindowTitle(QApplication::applicationName());
qInstallMessageHandler(jump);
}
return qtMessageHandler;
}
void LogManager::doSetHandleQtMessages(bool handleQtMessages)
{
QMutexLocker locker(&mObjectGuard);
if (instance()->mHandleQtMessages == handleQtMessages)
return;
instance()->mHandleQtMessages = handleQtMessages;
if (instance()->mHandleQtMessages)
{
static_logger()->trace("Activate Qt message handling");
instance()->mOldQtMsgHandler = qInstallMessageHandler(qtMessageHandler);
}
else
{
static_logger()->trace("Deactivate Qt message handling");
qInstallMessageHandler(instance()->mOldQtMsgHandler);
}
}
// Before all tests
void HandleSignalRouterUnitTests::initTestCase()
{
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
qInstallMsgHandler(myMessageOutput);
#else
qInstallMessageHandler(myMessageOutput);
#endif
// Help the QSignalSpy handle QVariant
qRegisterMetaType<QVariant>("QVariant");
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(player);
qRegisterMetaType<GenericDAO>();
qRegisterMetaType<TrackDAO>();
qRegisterMetaTypeStreamOperators<TrackDAO>("TrackDAO");
qRegisterMetaType<QFileInfo>();
qRegisterMetaType<PluginInfo>();
qRegisterMetaTypeStreamOperators<PluginInfo>("PluginInfo");
#if defined(Q_OS_WIN)
qInstallMessageHandler(debugOutput);
#endif
QtSingleApplication app(SOFT, argc, argv);
app.setOrganizationName(COMPANY);
app.setApplicationName(SOFT);
app.setApplicationVersion(VERSION);
app.setAttribute(Qt::AA_UseHighDpiPixmaps);
if (app.isRunning()) {
app.forwardArgsToServer();
return 0;
}
SettingsPrivate *settings = SettingsPrivate::instance();
app.installTranslator(&settings->playerTranslator);
app.installTranslator(&settings->defaultQtTranslator);
app.setStyle(new MiamStyle);
MainWindow *window = new MainWindow;
app.setActivationWindow(window);
logBrowser = new LogBrowser;
QObject::connect(window->actionShowDebug, &QAction::triggered, [=]() { logBrowser->show(); });
QObject::connect(&app, &QtSingleApplication::sendArgs, window, &MainWindow::processArgs);
if (settings->isCustomColors()) {
app.setPalette(settings->value("customPalette").value<QPalette>());
}
window->init();
window->show();
window->loadPlugins();
window->activateLastView();
QStringList args;
for (int i = 0; i < argc; i++) {
args << argv[i];
}
window->processArgs(args);
int result = app.exec();
delete logBrowser;
return result;
}
QDebugMessageService::QDebugMessageService(QObject *parent) :
QQmlDebugService(s_key, 2, parent), oldMsgHandler(0),
prevState(QQmlDebugService::NotConnected)
{
// don't execute stateChanged() in parallel
QMutexLocker lock(&initMutex);
if (state() == Enabled) {
oldMsgHandler = qInstallMessageHandler(DebugMessageHandler);
prevState = Enabled;
}
}
int main(int argc, char *argv[])
{
debugMessages.clear();
qInstallMessageHandler(stdConsoleOutput);
QApplication a(argc, argv);
CMainWindow w;
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
qInstallMessageHandler(myMessageOutput);
w.show();
ct.start();
return a.exec();
}
MainServerWindow::MainServerWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainServerWindow)
{
if(INSTANCE)
throw new std::runtime_error("One instance is already running!");
ui->setupUi(this);
INSTANCE = this;
qInstallMessageHandler(MainServerWindow::msgHandler);
qDebug() << "Installed Message Handler";
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(mp);
qRegisterMetaType<GenericDAO>();
qRegisterMetaType<TrackDAO>();
qRegisterMetaTypeStreamOperators<TrackDAO>("TrackDAO");
qRegisterMetaType<QFileInfo>();
qRegisterMetaType<PluginInfo>();
qRegisterMetaTypeStreamOperators<PluginInfo>("PluginInfo");
qInstallMessageHandler(debugOutput);
QtSingleApplication app(SOFT, argc, argv);
if (app.isRunning()) {
QString arg = QApplication::arguments().join(";");
app.sendMessage(arg);
return 0;
}
app.setStyle(new MiamStyle);
MainWindow *window = new MainWindow;
logBrowser = new LogBrowser;
QObject::connect(window->actionShowDebug, &QAction::triggered, [=]() {
logBrowser->show();
});
QObject::connect(&app, &QtSingleApplication::sendArgs, window, &MainWindow::processArgs);
app.setActivationWindow(window);
SettingsPrivate *settings = SettingsPrivate::instance();
if (settings->isCustomColors()) {
app.setPalette(settings->value("customPalette").value<QPalette>());
}
app.setOrganizationName(COMPANY);
app.setApplicationName(SOFT);
app.setApplicationVersion(VERSION);
window->init();
window->show();
window->loadPlugins();
window->activateLastView();
// It this application was started from a file (for example)
if (argc > 1) {
QStringList args;
for (int i = 0; i < argc; i++) {
args << argv[i];
}
window->processArgs(args);
}
int result = app.exec();
delete logBrowser;
return result;
}
int main(int argc, char *argv[])
{
// Install the local debug message handler
qInstallMessageHandler(debugOutputHandler);
QApplication a(argc, argv);
// Set application name and version
QCoreApplication::setApplicationName("ld-analyse");
QCoreApplication::setApplicationVersion("1.1");
QCoreApplication::setOrganizationDomain("domesday86.com");
// Set up the command line parser
QCommandLineParser parser;
parser.setApplicationDescription(
"ld-analyse - TBC output analysis\n"
"\n"
"(c)2018 Simon Inns\n"
"GPLv3 Open-Source - github: https://github.com/happycube/ld-decode");
parser.addHelpOption();
parser.addVersionOption();
// Option to show debug (-d)
QCommandLineOption showDebugOption(QStringList() << "d" << "debug",
QCoreApplication::translate("main", "Show debug"));
parser.addOption(showDebugOption);
// Positional argument to specify input video file
parser.addPositionalArgument("input", QCoreApplication::translate("main", "Specify input TBC file"));
// Process the command line arguments given by the user
parser.process(a);
// Get the configured settings from the parser
bool isDebugOn = parser.isSet(showDebugOption);
// Process the command line options
if (isDebugOn) showDebug = true;
// Get the arguments from the parser
QString inputFileName;
QStringList positionalArguments = parser.positionalArguments();
if (positionalArguments.count() == 1) {
inputFileName = positionalArguments.at(0);
} else {
inputFileName.clear();
}
// Start the GUI application
MainWindow w(inputFileName);
w.show();
return a.exec();
}
int main(int argc, char* argv[])
{
qSetMessagePattern("%{type} %{threadid} %{message}");
NetworkViewerApp app(argc,argv);
app.init();
qInstallMessageHandler(myMessageOutput);
//See also void qSetMessagePattern(const QString & pattern)
return app.exec();
}
void tst_qdeclarativeengine::outputWarningsToStandardError()
{
QDeclarativeEngine engine;
QCOMPARE(engine.outputWarningsToStandardError(), true);
QDeclarativeComponent c(&engine);
c.setData("import QtQuick 1.0; QtObject { property int a: undefined }", QUrl());
QVERIFY(c.isReady() == true);
warnings.clear();
QtMessageHandler old = qInstallMessageHandler(msgHandler);
QObject *o = c.create();
qInstallMessageHandler(old);
QVERIFY(o != 0);
delete o;
QCOMPARE(warnings.count(), 1);
QCOMPARE(warnings.at(0), QLatin1String("<Unknown File>:1: Unable to assign [undefined] to int a"));
warnings.clear();
engine.setOutputWarningsToStandardError(false);
QCOMPARE(engine.outputWarningsToStandardError(), false);
old = qInstallMessageHandler(msgHandler);
o = c.create();
qInstallMessageHandler(old);
QVERIFY(o != 0);
delete o;
QCOMPARE(warnings.count(), 0);
}
void g_messageOutput(QtMsgType type, const QMessageLogContext& context, const QString& msg)
{
if (msg.contains("requested for null window or window without handle"))
return;
if (msg.contains("QBackingStore::flush() called with non-exposed window, behavior is undefined"))
return;
if (msg.contains("Cannot create accessible interface for object"))
return;
qInstallMessageHandler(NULL);
QString message = QString("%1\n\nfile: %2: %3\nat function: %4")
.arg(msg)
.arg(context.file)
.arg(context.line)
.arg(context.function);
switch (type)
{
case QtDebugMsg:
TRACE1("Debug: %s\n", msg.toLocal8Bit().constData());
break;
case QtWarningMsg:
TRACE1("Warning: %s\n", message.toLocal8Bit().constData());
QMessageBox::warning(g_pApp->getMainWnd(), "QtWarning", message);
break;
case QtCriticalMsg:
QMessageBox::critical(g_pApp->getMainWnd(), "QtCritical", message);
break;
case QtFatalMsg:
QMessageBox::critical(g_pApp->getMainWnd(), "QtFatal", message);
break;
}
qInstallMessageHandler(g_messageOutput);
}
bool CoreApplication::init()
{
if (Quassel::init() && _internal->init()) {
#if QT_VERSION < 0x050000
qInstallMsgHandler(Logger::logMessage);
#else
qInstallMessageHandler(Logger::logMessage);
#endif
return true;
}
return false;
}
int main(int argc, char *argv[])
{
qInstallMessageHandler(myMessageOutput);
QApplication a(argc, argv);
Log::display();
Server myServer;
return a.exec();
}
int main(int argc, char **argv) {
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) && !TEST
// install message handler
qInstallMessageHandler(SDDM::MessageHandler);
#endif
// create application
SDDM::DaemonApp app(argc, argv);
// run application
return app.exec();
}
LogWindow::~LogWindow()
{
{
QMutexLocker lock(&sMutex);
qInstallMessageHandler(mPreviousHandler);
sInstance = 0;
mTimer.stop();
}
onTimeout();
delete ui;
}
Logger::Logger( QObject* parent) : QObject(parent),
_showTime(true), _doLogging(false), _doFileFlush(false), _logExpire(0)
{
#ifndef NO_MSG_HANDLER
#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
qSetMessagePattern("%{time MM-dd hh:mm:ss:zzz} %{threadid} %{function}: %{message}");
#endif
qInstallMessageHandler(mirallLogCatcher);
#else
Q_UNUSED(mirallLogCatcher)
#endif
}
int main(int argc, char *argv[]){
qInstallMessageHandler(myMessageOutput);
QCoreApplication a(argc, argv);
glb::mainThread = a.thread();
std::cout << std::endl << "Oi, mate!";
qRegisterMetaType<QAbstractSocket::SocketError>();
qRegisterMetaType<QAbstractSocket::SocketState>();
//set current working directory to executable path
//needed if started from within IDE
boost::filesystem::path curDir(QCoreApplication::applicationDirPath().toStdString());
boost::filesystem::current_path(curDir);
srand(time(NULL));
int alg = 0;
if (argc < 2){
std::cout << std::endl << "No algorithm specified -> using Central Mutual Exclusion algorithm";
}
else{
QString inputAlg = argv[1];
if (inputAlg == "RA"){
std::cout << std::endl << "Ricart Agrawala algorithm selected";
alg = 1;
}
else if (inputAlg == "CME"){
std::cout << std::endl << "Central Mutual Exclusion algorithm selected";
}
else{
std::cout << std::endl << "unknown algorithm specified -> using Central Mutual Exclusion algorithm";
}
}
if (alg == 1){
}
else{
//init the Server
Server* server = new Server();
server->init();
Reader* reader = new Reader(server->getClient());
reader->start();
}
return a.exec();
}
int main(int argc, char *argv[])
{
QtSingleApplication app(argc, argv);
#ifdef HAVE_QT5
qInstallMessageHandler(LogFile::msgHandler);
#else
qInstallMsgHandler(LogFile::msgHandler);
#endif
qWarning() << "Start application!";
qDebug() << "isRunning: " << app.isRunning();
QString message = app.arguments().value(1);
qDebug() << "message: " << message;
if (app.isRunning()) {
if (1 == argc) {
app.sendMessage("--show");
}
else {
for (int i = 2; i < argc; ++i)
message += '\n' + app.arguments().value(i);
app.sendMessage(message);
}
return 0;
} else {
QString appDirPath = QCoreApplication::applicationDirPath();
qDebug() << "Application dir path: " << appDirPath;
if (!appDirPath.contains("QuiteRSSUpdater")) {
qDebug() << "Temp dir path: " << QDir::tempPath();
QStringList fileDll;
fileDll << "libgcc_s_dw2-1.dll" << "mingwm10.dll"<< "QtCore4.dll"
<< "QtGui4.dll" << "QtNetwork4.dll" << "Updater.exe"
<< "7za.exe";
QDir(QDir::tempPath()).mkdir("QuiteRSSUpdater");
foreach (QString file, fileDll) {
QFile::remove(QDir::tempPath() + "/QuiteRSSUpdater/" + file);
bool okCopy = QFile::copy(appDirPath + "/" + file,
QDir::tempPath() + "/QuiteRSSUpdater/" + file);
if (!okCopy)
qCritical() << "Error copying file: " << file;
}
QString quiterssFile = QDir::tempPath() + "/QuiteRSSUpdater/Updater.exe";
appDirPath = "\"" + appDirPath + "\"";
(quintptr)ShellExecute(
0, 0,
(wchar_t *)quiterssFile.utf16(),
(wchar_t *)appDirPath.utf16(),
0, SW_SHOWNORMAL);
return 0;
}
int main(int argc, char **argv) {
int result;
qInstallMessageHandler(noMessageOutput);
#ifdef NDEBUG
Logs::disable();
#endif
testing::InitGoogleTest(&argc, argv);
result = RUN_ALL_TESTS();
return result;
}
int main(int argc, char** argv)
{
qInstallMessageHandler(myMessageOutput);
qDebug() << "Starting application";
QCoreApplication::setOrganizationName("CodeCharm");
QCoreApplication::setOrganizationDomain("codecharm.co.uk");
QCoreApplication::setApplicationName("UTLauncher");
// QApplication::setDesktopSettingsAware(false);
UTLauncher app(argc, argv);
return app.exec();
}
Debug::Debug() :
mDebugLevelStderr(DebugLevel_t::All), mDebugLevelLogFile(DebugLevel_t::Nothing),
mStderrStream(new QTextStream(stderr)), mLogFilepath(), mLogFile(0)
{
// determine the filename of the log file which will be used if logging is enabled
QString datetime = QDateTime::currentDateTime().toString("yyyy-MM-dd_hh-mm-ss");
QString dataDir = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
if (!dataDir.isEmpty())
mLogFilepath.setPath(dataDir % "/logs/" % datetime % ".log");
// install the message handler for Qt's debug functions (qDebug(), ...)
qInstallMessageHandler(messageHandler);
}
void TestJson::initTestCase(void)
{
qInstallMessageHandler(noMessageOutput);
#ifndef DISABLE_QMJSON_GUI
QMJsonValue::registerFromComplexJson("QColor", &QMJsonType<QColor>::fromComplexJson);
QMJsonValue::registerFromComplexJson("QPoint", &QMJsonType<QPoint>::fromComplexJson);
QMJsonValue::registerFromComplexJson("QRect", &QMJsonType<QRect>::fromComplexJson);
QMJsonValue::registerFromComplexJson("QSize", &QMJsonType<QSize>::fromComplexJson);
#endif
}
CReporterLogger::~CReporterLogger ()
{
if (m_old_msg_handler) {
qInstallMessageHandler(m_old_msg_handler);
}
if (m_file.isOpen()) {
m_file.close();
}
if (CReporterLogger::sm_LogType == CReporter::LogSyslog) {
closelog();
}
}
int main(int argc, char *argv[])
{
qInstallMessageHandler(Log::myMessageOutput);
QApplication a(argc, argv);
Game::Instance().run();
qDebug() << "Game started.";
return a.exec();
}
