[pulseview.git] / pv / application.cpp

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2014 Martin Ling <martin-sigrok@earth.li>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <iostream>
#include <typeinfo>

#include <QDebug>
#include <QDir>
#include <QLibraryInfo>
#include <QMessageBox>
#include <QWidget>

#include <boost/version.hpp>

#ifdef ENABLE_STACKTRACE
#include <boost/stacktrace.hpp>
#endif

#ifdef ENABLE_DECODE
#include <libsigrokdecode/libsigrokdecode.h>
#endif

#include <pv/exprtk.hpp>

#include "application.hpp"
#include "config.h"
#include "globalsettings.hpp"

using std::cout;
using std::endl;
using std::exception;
using std::shared_ptr;

#ifdef ENABLE_DECODE
static gint sort_pds(gconstpointer a, gconstpointer b)
{
	const struct srd_decoder *sda, *sdb;

	sda = (const struct srd_decoder *)a;
	sdb = (const struct srd_decoder *)b;
	return strcmp(sda->id, sdb->id);
}
#endif

Application::Application(int &argc, char* argv[]) :
	QApplication(argc, argv)
{
	setApplicationVersion(PV_VERSION_STRING);
	setApplicationName("PulseView");
	setOrganizationName("sigrok");
	setOrganizationDomain("sigrok.org");
}

const QStringList Application::get_languages() const
{
	const QStringList files = QDir(":/l10n/").entryList(QStringList("*.qm"), QDir::Files);

	QStringList result;
	result << "en";  // Add default language to the set

	// Remove file extensions
	for (const QString& file : files)
		result << file.split(".").front();

	result.sort(Qt::CaseInsensitive);

	return result;
}

const QString Application::get_language_editors(const QString& language) const
{
	if (language == "de") return "Sören Apel, Uwe Hermann";
	if (language == "es_MX") return "Carlos Diaz, Ulices Avila Hernandez";
	if (language == "ja_jp") return "Yukari Shoji";
	if (language == "zh_cn") return "ZtyPro";

	return QString();
}

void Application::switch_language(const QString& language)
{
	removeTranslator(&app_translator_);
	removeTranslator(&qt_translator_);
	removeTranslator(&qtbase_translator_);

	if ((language != "C") && (language != "en")) {
		// Application translations
		QString resource = ":/l10n/" + language +".qm";
		if (app_translator_.load(resource))
			installTranslator(&app_translator_);
		else
			qWarning() << "Translation resource" << resource << "not found";

		// Qt translations
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
		QString tr_path(QLibraryInfo::path(QLibraryInfo::TranslationsPath));
#else
		QString tr_path(QLibraryInfo::location(QLibraryInfo::TranslationsPath));
#endif

		if (qt_translator_.load("qt_" + language, tr_path))
			installTranslator(&qt_translator_);
		else
			qWarning() << "QT translations for" << language << "not found at" <<
				tr_path << ", Qt translations package is probably missing";

		// Qt base translations
		if (qtbase_translator_.load("qtbase_" + language, tr_path))
			installTranslator(&qtbase_translator_);
		else
			qWarning() << "QT base translations for" << language << "not found at" <<
				tr_path << ", Qt translations package is probably missing";
	}

	if (!topLevelWidgets().empty()) {
		// Force all windows to update
		for (QWidget *widget : topLevelWidgets())
			widget->update();

		QMessageBox msg(topLevelWidgets().front());
		msg.setText(tr("Some parts of the application may still " \
				"use the previous language. Re-opening the affected windows or " \
				"restarting the application will remedy this."));
		msg.setStandardButtons(QMessageBox::Ok);
		msg.setIcon(QMessageBox::Information);
		msg.exec();
	}
}

void Application::on_setting_changed(const QString &key, const QVariant &value)
{
	if (key == pv::GlobalSettings::Key_General_Language)
		switch_language(value.toString());
}

void Application::collect_version_info(pv::DeviceManager &device_manager)
{
	// Library versions and features
	version_info_.emplace_back(applicationName(), applicationVersion());
	version_info_.emplace_back("Qt", qVersion());
	version_info_.emplace_back("glibmm", PV_GLIBMM_VERSION);
	version_info_.emplace_back("Boost", BOOST_LIB_VERSION);
	version_info_.emplace_back("exprtk", QString::fromUtf8(exprtk::information::date));

	version_info_.emplace_back("libsigrok", QString("%1/%2 (rt: %3/%4)")
		.arg(SR_PACKAGE_VERSION_STRING, SR_LIB_VERSION_STRING,
		sr_package_version_string_get(), sr_lib_version_string_get()));

	GSList *l_orig = sr_buildinfo_libs_get();
	for (GSList *l = l_orig; l; l = l->next) {
		GSList *m = (GSList *)l->data;
		const char *lib = (const char *)m->data;
		const char *version = (const char *)m->next->data;
		version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
		g_slist_free_full(m, g_free);
	}
	g_slist_free(l_orig);

	char *host = sr_buildinfo_host_get();
	version_info_.emplace_back(" - Host", QString(host));
	g_free(host);

	char *scpi_backends = sr_buildinfo_scpi_backends_get();
	version_info_.emplace_back(" - SCPI backends", QString(scpi_backends));
	g_free(scpi_backends);

#ifdef ENABLE_DECODE
	struct srd_decoder *dec;

	version_info_.emplace_back("libsigrokdecode", QString("%1/%2 (rt: %3/%4)")
		.arg(SRD_PACKAGE_VERSION_STRING, SRD_LIB_VERSION_STRING,
		srd_package_version_string_get(), srd_lib_version_string_get()));

	l_orig = srd_buildinfo_libs_get();
	for (GSList *l = l_orig; l; l = l->next) {
		GSList *m = (GSList *)l->data;
		const char *lib = (const char *)m->data;
		const char *version = (const char *)m->next->data;
		version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
		g_slist_free_full(m, g_free);
	}
	g_slist_free(l_orig);

	host = srd_buildinfo_host_get();
	version_info_.emplace_back(" - Host", QString(host));
	g_free(host);
#endif

	// Firmware paths
	l_orig = sr_resourcepaths_get(SR_RESOURCE_FIRMWARE);
	for (GSList *l = l_orig; l; l = l->next)
		fw_path_list_.emplace_back((char*)l->data);
	g_slist_free_full(l_orig, g_free);

	// PD paths
#ifdef ENABLE_DECODE
	l_orig = srd_searchpaths_get();
	for (GSList *l = l_orig; l; l = l->next)
		pd_path_list_.emplace_back((char*)l->data);
	g_slist_free_full(l_orig, g_free);
#endif

	// Device drivers
	for (auto& entry : device_manager.context()->drivers())
		if (device_manager.driver_supported(entry.second))
			driver_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
				QString::fromUtf8(entry.second->long_name().c_str()));

	// Input formats
	for (auto& entry : device_manager.context()->input_formats())
		input_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
			QString::fromUtf8(entry.second->description().c_str()));

	// Output formats
	for (auto& entry : device_manager.context()->output_formats())
		output_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
			QString::fromUtf8(entry.second->description().c_str()));

	// Protocol decoders
#ifdef ENABLE_DECODE
	GSList *sl = g_slist_copy((GSList *)srd_decoder_list());
	sl = g_slist_sort(sl, sort_pds);
	for (const GSList *l = sl; l; l = l->next) {
		dec = (struct srd_decoder *)l->data;
		pd_list_.emplace_back(QString::fromUtf8(dec->id),
			QString::fromUtf8(dec->longname));
	}
	g_slist_free(sl);
#endif
}

void Application::print_version_info()
{
	cout << PV_TITLE << " " << PV_VERSION_STRING << endl;

	cout << endl << "Libraries and features:" << endl;
	for (pair<QString, QString>& entry : version_info_)
		cout << "  " << entry.first.toStdString() << " " << entry.second.toStdString() << endl;

	cout << endl << "Firmware search paths:" << endl;
	for (QString& entry : fw_path_list_)
		cout << "  " << entry.toStdString() << endl;

	cout << endl << "Protocol decoder search paths:" << endl;
	for (QString& entry : pd_path_list_)
		cout << "  " << entry.toStdString() << endl;

	cout << endl << "Supported hardware drivers:" << endl;
	for (pair<QString, QString>& entry : driver_list_)
		cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
		entry.second.toStdString() << endl;

	cout << endl << "Supported input formats:" << endl;
	for (pair<QString, QString>& entry : input_format_list_)
		cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
		entry.second.toStdString() << endl;

	cout << endl << "Supported output formats:" << endl;
	for (pair<QString, QString>& entry : output_format_list_)
		cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
		entry.second.toStdString() << endl;

#ifdef ENABLE_DECODE
	cout << endl << "Supported protocol decoders:" << endl;
	for (pair<QString, QString>& entry : pd_list_)
		cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
		entry.second.toStdString() << endl;
#endif
}

vector< pair<QString, QString> > Application::get_version_info() const
{
	return version_info_;
}

vector<QString> Application::get_fw_path_list() const
{
	return fw_path_list_;
}

vector<QString> Application::get_pd_path_list() const
{
	return pd_path_list_;
}

vector< pair<QString, QString> > Application::get_driver_list() const
{
	return driver_list_;
}

vector< pair<QString, QString> > Application::get_input_format_list() const
{
	return input_format_list_;
}

vector< pair<QString, QString> > Application::get_output_format_list() const
{
	return output_format_list_;
}

vector< pair<QString, QString> > Application::get_pd_list() const
{
	return pd_list_;
}

bool Application::notify(QObject *receiver, QEvent *event)
{
	try {
		return QApplication::notify(receiver, event);
	} catch (exception& e) {
		qDebug().nospace() << "Caught exception of type " << \
			typeid(e).name() << " (" << e.what() << ")";
#ifdef ENABLE_STACKTRACE
		throw e;
#else
		exit(1);
#endif
		return false;
	}
}
Commit	Line	Data
	1	/*
	2	* This file is part of the PulseView project.
	3	*
	4	* Copyright (C) 2014 Martin Ling <martin-sigrok@earth.li>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <iostream>
	21	#include <typeinfo>
	22
	23	#include <QDebug>
	24	#include <QDir>
	25	#include <QLibraryInfo>
	26	#include <QMessageBox>
	27	#include <QWidget>
	28
	29	#include <boost/version.hpp>
	30
	31	#ifdef ENABLE_STACKTRACE
	32	#include <boost/stacktrace.hpp>
	33	#endif
	34
	35	#ifdef ENABLE_DECODE
	36	#include <libsigrokdecode/libsigrokdecode.h>
	37	#endif
	38
	39	#include <pv/exprtk.hpp>
	40
	41	#include "application.hpp"
	42	#include "config.h"
	43	#include "globalsettings.hpp"
	44
	45	using std::cout;
	46	using std::endl;
	47	using std::exception;
	48	using std::shared_ptr;
	49
	50	#ifdef ENABLE_DECODE
	51	static gint sort_pds(gconstpointer a, gconstpointer b)
	52	{
	53	const struct srd_decoder sda, sdb;
	54
	55	sda = (const struct srd_decoder *)a;
	56	sdb = (const struct srd_decoder *)b;
	57	return strcmp(sda->id, sdb->id);
	58	}
	59	#endif
	60
	61	Application::Application(int &argc, char* argv[]) :
	62	QApplication(argc, argv)
	63	{
	64	setApplicationVersion(PV_VERSION_STRING);
	65	setApplicationName("PulseView");
	66	setOrganizationName("sigrok");
	67	setOrganizationDomain("sigrok.org");
	68	}
	69
	70	const QStringList Application::get_languages() const
	71	{
	72	const QStringList files = QDir(":/l10n/").entryList(QStringList("*.qm"), QDir::Files);
	73
	74	QStringList result;
	75	result << "en"; // Add default language to the set
	76
	77	// Remove file extensions
	78	for (const QString& file : files)
	79	result << file.split(".").front();
	80
	81	result.sort(Qt::CaseInsensitive);
	82
	83	return result;
	84	}
	85
	86	const QString Application::get_language_editors(const QString& language) const
	87	{
	88	if (language == "de") return "Sören Apel, Uwe Hermann";
	89	if (language == "es_MX") return "Carlos Diaz, Ulices Avila Hernandez";
	90	if (language == "ja_jp") return "Yukari Shoji";
	91	if (language == "zh_cn") return "ZtyPro";
	92
	93	return QString();
	94	}
	95
	96	void Application::switch_language(const QString& language)
	97	{
	98	removeTranslator(&app_translator_);
	99	removeTranslator(&qt_translator_);
	100	removeTranslator(&qtbase_translator_);
	101
	102	if ((language != "C") && (language != "en")) {
	103	// Application translations
	104	QString resource = ":/l10n/" + language +".qm";
	105	if (app_translator_.load(resource))
	106	installTranslator(&app_translator_);
	107	else
	108	qWarning() << "Translation resource" << resource << "not found";
	109
	110	// Qt translations
	111	#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
	112	QString tr_path(QLibraryInfo::path(QLibraryInfo::TranslationsPath));
	113	#else
	114	QString tr_path(QLibraryInfo::location(QLibraryInfo::TranslationsPath));
	115	#endif
	116
	117	if (qt_translator_.load("qt_" + language, tr_path))
	118	installTranslator(&qt_translator_);
	119	else
	120	qWarning() << "QT translations for" << language << "not found at" <<
	121	tr_path << ", Qt translations package is probably missing";
	122
	123	// Qt base translations
	124	if (qtbase_translator_.load("qtbase_" + language, tr_path))
	125	installTranslator(&qtbase_translator_);
	126	else
	127	qWarning() << "QT base translations for" << language << "not found at" <<
	128	tr_path << ", Qt translations package is probably missing";
	129	}
	130
	131	if (!topLevelWidgets().empty()) {
	132	// Force all windows to update
	133	for (QWidget *widget : topLevelWidgets())
	134	widget->update();
	135
	136	QMessageBox msg(topLevelWidgets().front());
	137	msg.setText(tr("Some parts of the application may still " \
	138	"use the previous language. Re-opening the affected windows or " \
	139	"restarting the application will remedy this."));
	140	msg.setStandardButtons(QMessageBox::Ok);
	141	msg.setIcon(QMessageBox::Information);
	142	msg.exec();
	143	}
	144	}
	145
	146	void Application::on_setting_changed(const QString &key, const QVariant &value)
	147	{
	148	if (key == pv::GlobalSettings::Key_General_Language)
	149	switch_language(value.toString());
	150	}
	151
	152	void Application::collect_version_info(pv::DeviceManager &device_manager)
	153	{
	154	// Library versions and features
	155	version_info_.emplace_back(applicationName(), applicationVersion());
	156	version_info_.emplace_back("Qt", qVersion());
	157	version_info_.emplace_back("glibmm", PV_GLIBMM_VERSION);
	158	version_info_.emplace_back("Boost", BOOST_LIB_VERSION);
	159	version_info_.emplace_back("exprtk", QString::fromUtf8(exprtk::information::date));
	160
	161	version_info_.emplace_back("libsigrok", QString("%1/%2 (rt: %3/%4)")
	162	.arg(SR_PACKAGE_VERSION_STRING, SR_LIB_VERSION_STRING,
	163	sr_package_version_string_get(), sr_lib_version_string_get()));
	164
	165	GSList *l_orig = sr_buildinfo_libs_get();
	166	for (GSList *l = l_orig; l; l = l->next) {
	167	GSList m = (GSList )l->data;
	168	const char lib = (const char )m->data;
	169	const char version = (const char )m->next->data;
	170	version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
	171	g_slist_free_full(m, g_free);
	172	}
	173	g_slist_free(l_orig);
	174
	175	char *host = sr_buildinfo_host_get();
	176	version_info_.emplace_back(" - Host", QString(host));
	177	g_free(host);
	178
	179	char *scpi_backends = sr_buildinfo_scpi_backends_get();
	180	version_info_.emplace_back(" - SCPI backends", QString(scpi_backends));
	181	g_free(scpi_backends);
	182
	183	#ifdef ENABLE_DECODE
	184	struct srd_decoder *dec;
	185
	186	version_info_.emplace_back("libsigrokdecode", QString("%1/%2 (rt: %3/%4)")
	187	.arg(SRD_PACKAGE_VERSION_STRING, SRD_LIB_VERSION_STRING,
	188	srd_package_version_string_get(), srd_lib_version_string_get()));
	189
	190	l_orig = srd_buildinfo_libs_get();
	191	for (GSList *l = l_orig; l; l = l->next) {
	192	GSList m = (GSList )l->data;
	193	const char lib = (const char )m->data;
	194	const char version = (const char )m->next->data;
	195	version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
	196	g_slist_free_full(m, g_free);
	197	}
	198	g_slist_free(l_orig);
	199
	200	host = srd_buildinfo_host_get();
	201	version_info_.emplace_back(" - Host", QString(host));
	202	g_free(host);
	203	#endif
	204
	205	// Firmware paths
	206	l_orig = sr_resourcepaths_get(SR_RESOURCE_FIRMWARE);
	207	for (GSList *l = l_orig; l; l = l->next)
	208	fw_path_list_.emplace_back((char*)l->data);
	209	g_slist_free_full(l_orig, g_free);
	210
	211	// PD paths
	212	#ifdef ENABLE_DECODE
	213	l_orig = srd_searchpaths_get();
	214	for (GSList *l = l_orig; l; l = l->next)
	215	pd_path_list_.emplace_back((char*)l->data);
	216	g_slist_free_full(l_orig, g_free);
	217	#endif
	218
	219	// Device drivers
	220	for (auto& entry : device_manager.context()->drivers())
	221	if (device_manager.driver_supported(entry.second))
	222	driver_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
	223	QString::fromUtf8(entry.second->long_name().c_str()));
	224
	225	// Input formats
	226	for (auto& entry : device_manager.context()->input_formats())
	227	input_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
	228	QString::fromUtf8(entry.second->description().c_str()));
	229
	230	// Output formats
	231	for (auto& entry : device_manager.context()->output_formats())
	232	output_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
	233	QString::fromUtf8(entry.second->description().c_str()));
	234
	235	// Protocol decoders
	236	#ifdef ENABLE_DECODE
	237	GSList sl = g_slist_copy((GSList )srd_decoder_list());
	238	sl = g_slist_sort(sl, sort_pds);
	239	for (const GSList *l = sl; l; l = l->next) {
	240	dec = (struct srd_decoder *)l->data;
	241	pd_list_.emplace_back(QString::fromUtf8(dec->id),
	242	QString::fromUtf8(dec->longname));
	243	}
	244	g_slist_free(sl);
	245	#endif
	246	}
	247
	248	void Application::print_version_info()
	249	{
	250	cout << PV_TITLE << " " << PV_VERSION_STRING << endl;
	251
	252	cout << endl << "Libraries and features:" << endl;
	253	for (pair<QString, QString>& entry : version_info_)
	254	cout << " " << entry.first.toStdString() << " " << entry.second.toStdString() << endl;
	255
	256	cout << endl << "Firmware search paths:" << endl;
	257	for (QString& entry : fw_path_list_)
	258	cout << " " << entry.toStdString() << endl;
	259
	260	cout << endl << "Protocol decoder search paths:" << endl;
	261	for (QString& entry : pd_path_list_)
	262	cout << " " << entry.toStdString() << endl;
	263
	264	cout << endl << "Supported hardware drivers:" << endl;
	265	for (pair<QString, QString>& entry : driver_list_)
	266	cout << " " << entry.first.leftJustified(21, ' ').toStdString() <<
	267	entry.second.toStdString() << endl;
	268
	269	cout << endl << "Supported input formats:" << endl;
	270	for (pair<QString, QString>& entry : input_format_list_)
	271	cout << " " << entry.first.leftJustified(21, ' ').toStdString() <<
	272	entry.second.toStdString() << endl;
	273
	274	cout << endl << "Supported output formats:" << endl;
	275	for (pair<QString, QString>& entry : output_format_list_)
	276	cout << " " << entry.first.leftJustified(21, ' ').toStdString() <<
	277	entry.second.toStdString() << endl;
	278
	279	#ifdef ENABLE_DECODE
	280	cout << endl << "Supported protocol decoders:" << endl;
	281	for (pair<QString, QString>& entry : pd_list_)
	282	cout << " " << entry.first.leftJustified(21, ' ').toStdString() <<
	283	entry.second.toStdString() << endl;
	284	#endif
	285	}
	286
	287	vector< pair<QString, QString> > Application::get_version_info() const
	288	{
	289	return version_info_;
	290	}
	291
	292	vector<QString> Application::get_fw_path_list() const
	293	{
	294	return fw_path_list_;
	295	}
	296
	297	vector<QString> Application::get_pd_path_list() const
	298	{
	299	return pd_path_list_;
	300	}
	301
	302	vector< pair<QString, QString> > Application::get_driver_list() const
	303	{
	304	return driver_list_;
	305	}
	306
	307	vector< pair<QString, QString> > Application::get_input_format_list() const
	308	{
	309	return input_format_list_;
	310	}
	311
	312	vector< pair<QString, QString> > Application::get_output_format_list() const
	313	{
	314	return output_format_list_;
	315	}
	316
	317	vector< pair<QString, QString> > Application::get_pd_list() const
	318	{
	319	return pd_list_;
	320	}
	321
	322	bool Application::notify(QObject receiver, QEvent event)
	323	{
	324	try {
	325	return QApplication::notify(receiver, event);
	326	} catch (exception& e) {
	327	qDebug().nospace() << "Caught exception of type " << \
	328	typeid(e).name() << " (" << e.what() << ")";
	329	#ifdef ENABLE_STACKTRACE
	330	throw e;
	331	#else
	332	exit(1);
	333	#endif
	334	return false;
	335	}
	336	}