pv/application.cpp

   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";
  90
  91         return QString();
  92 }
  93
  94 void Application::switch_language(const QString& language)
  95 {
  96         removeTranslator(&app_translator_);
  97         removeTranslator(&qt_translator_);
  98         removeTranslator(&qtbase_translator_);
  99
 100         if ((language != "C") && (language != "en")) {
 101                 // Application translations
 102                 QString resource = ":/l10n/" + language +".qm";
 103                 if (app_translator_.load(resource))
 104                         installTranslator(&app_translator_);
 105                 else
 106                         qWarning() << "Translation resource" << resource << "not found";
 107
 108                 // Qt translations
 109                 QString tr_path(QLibraryInfo::location(QLibraryInfo::TranslationsPath));
 110
 111                 if (qt_translator_.load("qt_" + language, tr_path))
 112                         installTranslator(&qt_translator_);
 113                 else
 114                         qWarning() << "QT translations for" << language << "not found at" <<
 115                                 tr_path << ", Qt translations package is probably missing";
 116
 117                 // Qt base translations
 118                 if (qtbase_translator_.load("qtbase_" + language, tr_path))
 119                         installTranslator(&qtbase_translator_);
 120                 else
 121                         qWarning() << "QT base translations for" << language << "not found at" <<
 122                                 tr_path << ", Qt translations package is probably missing";
 123         }
 124
 125         if (!topLevelWidgets().empty()) {
 126                 // Force all windows to update
 127                 for (QWidget *widget : topLevelWidgets())
 128                         widget->update();
 129
 130                 QMessageBox msg(topLevelWidgets().front());
 131                 msg.setText(tr("Some parts of the application may still " \
 132                                 "use the previous language. Re-opening the affected windows or " \
 133                                 "restarting the application will remedy this."));
 134                 msg.setStandardButtons(QMessageBox::Ok);
 135                 msg.setIcon(QMessageBox::Information);
 136                 msg.exec();
 137         }
 138 }
 139
 140 void Application::on_setting_changed(const QString &key, const QVariant &value)
 141 {
 142         if (key == pv::GlobalSettings::Key_General_Language)
 143                 switch_language(value.toString());
 144 }
 145
 146 void Application::collect_version_info(shared_ptr<sigrok::Context> context)
 147 {
 148         // Library versions and features
 149         version_info_.emplace_back(applicationName(), applicationVersion());
 150         version_info_.emplace_back("Qt", qVersion());
 151         version_info_.emplace_back("glibmm", PV_GLIBMM_VERSION);
 152         version_info_.emplace_back("Boost", BOOST_LIB_VERSION);
 153         version_info_.emplace_back("exprtk", QString::fromUtf8(exprtk::information::date));
 154
 155         version_info_.emplace_back("libsigrok", QString("%1/%2 (rt: %3/%4)")
 156                 .arg(SR_PACKAGE_VERSION_STRING, SR_LIB_VERSION_STRING,
 157                 sr_package_version_string_get(), sr_lib_version_string_get()));
 158
 159         GSList *l_orig = sr_buildinfo_libs_get();
 160         for (GSList *l = l_orig; l; l = l->next) {
 161                 GSList *m = (GSList *)l->data;
 162                 const char *lib = (const char *)m->data;
 163                 const char *version = (const char *)m->next->data;
 164                 version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
 165                 g_slist_free_full(m, g_free);
 166         }
 167         g_slist_free(l_orig);
 168
 169         char *host = sr_buildinfo_host_get();
 170         version_info_.emplace_back(" - Host", QString(host));
 171         g_free(host);
 172
 173         char *scpi_backends = sr_buildinfo_scpi_backends_get();
 174         version_info_.emplace_back(" - SCPI backends", QString(scpi_backends));
 175         g_free(scpi_backends);
 176
 177 #ifdef ENABLE_DECODE
 178         struct srd_decoder *dec;
 179
 180         version_info_.emplace_back("libsigrokdecode", QString("%1/%2 (rt: %3/%4)")
 181                 .arg(SRD_PACKAGE_VERSION_STRING, SRD_LIB_VERSION_STRING,
 182                 srd_package_version_string_get(), srd_lib_version_string_get()));
 183
 184         l_orig = srd_buildinfo_libs_get();
 185         for (GSList *l = l_orig; l; l = l->next) {
 186                 GSList *m = (GSList *)l->data;
 187                 const char *lib = (const char *)m->data;
 188                 const char *version = (const char *)m->next->data;
 189                 version_info_.emplace_back(QString(" - %1").arg(QString(lib)), QString(version));
 190                 g_slist_free_full(m, g_free);
 191         }
 192         g_slist_free(l_orig);
 193
 194         host = srd_buildinfo_host_get();
 195         version_info_.emplace_back(" - Host", QString(host));
 196         g_free(host);
 197 #endif
 198
 199         // Firmware paths
 200         l_orig = sr_resourcepaths_get(SR_RESOURCE_FIRMWARE);
 201         for (GSList *l = l_orig; l; l = l->next)
 202                 fw_path_list_.emplace_back((char*)l->data);
 203         g_slist_free_full(l_orig, g_free);
 204
 205         // PD paths
 206 #ifdef ENABLE_DECODE
 207         l_orig = srd_searchpaths_get();
 208         for (GSList *l = l_orig; l; l = l->next)
 209                 pd_path_list_.emplace_back((char*)l->data);
 210         g_slist_free_full(l_orig, g_free);
 211 #endif
 212
 213         // Device drivers
 214         for (auto& entry : context->drivers())
 215                 driver_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
 216                         QString::fromUtf8(entry.second->long_name().c_str()));
 217
 218         // Input formats
 219         for (auto& entry : context->input_formats())
 220                 input_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
 221                         QString::fromUtf8(entry.second->description().c_str()));
 222
 223         // Output formats
 224         for (auto& entry : context->output_formats())
 225                 output_format_list_.emplace_back(QString::fromUtf8(entry.first.c_str()),
 226                         QString::fromUtf8(entry.second->description().c_str()));
 227
 228         // Protocol decoders
 229 #ifdef ENABLE_DECODE
 230         GSList *sl = g_slist_copy((GSList *)srd_decoder_list());
 231         sl = g_slist_sort(sl, sort_pds);
 232         for (const GSList *l = sl; l; l = l->next) {
 233                 dec = (struct srd_decoder *)l->data;
 234                 pd_list_.emplace_back(QString::fromUtf8(dec->id),
 235                         QString::fromUtf8(dec->longname));
 236         }
 237         g_slist_free(sl);
 238 #endif
 239 }
 240
 241 void Application::print_version_info()
 242 {
 243         cout << PV_TITLE << " " << PV_VERSION_STRING << endl;
 244
 245         cout << endl << "Libraries and features:" << endl;
 246         for (pair<QString, QString>& entry : version_info_)
 247                 cout << "  " << entry.first.toStdString() << " " << entry.second.toStdString() << endl;
 248
 249         cout << endl << "Firmware search paths:" << endl;
 250         for (QString& entry : fw_path_list_)
 251                 cout << "  " << entry.toStdString() << endl;
 252
 253         cout << endl << "Protocol decoder search paths:" << endl;
 254         for (QString& entry : pd_path_list_)
 255                 cout << "  " << entry.toStdString() << endl;
 256
 257         cout << endl << "Supported hardware drivers:" << endl;
 258         for (pair<QString, QString>& entry : driver_list_)
 259                 cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
 260                 entry.second.toStdString() << endl;
 261
 262         cout << endl << "Supported input formats:" << endl;
 263         for (pair<QString, QString>& entry : input_format_list_)
 264                 cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
 265                 entry.second.toStdString() << endl;
 266
 267         cout << endl << "Supported output formats:" << endl;
 268         for (pair<QString, QString>& entry : output_format_list_)
 269                 cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
 270                 entry.second.toStdString() << endl;
 271
 272 #ifdef ENABLE_DECODE
 273         cout << endl << "Supported protocol decoders:" << endl;
 274         for (pair<QString, QString>& entry : pd_list_)
 275                 cout << "  " << entry.first.leftJustified(21, ' ').toStdString() <<
 276                 entry.second.toStdString() << endl;
 277 #endif
 278 }
 279
 280 vector< pair<QString, QString> > Application::get_version_info() const
 281 {
 282         return version_info_;
 283 }
 284
 285 vector<QString> Application::get_fw_path_list() const
 286 {
 287         return fw_path_list_;
 288 }
 289
 290 vector<QString> Application::get_pd_path_list() const
 291 {
 292         return pd_path_list_;
 293 }
 294
 295 vector< pair<QString, QString> > Application::get_driver_list() const
 296 {
 297         return driver_list_;
 298 }
 299
 300 vector< pair<QString, QString> > Application::get_input_format_list() const
 301 {
 302         return input_format_list_;
 303 }
 304
 305 vector< pair<QString, QString> > Application::get_output_format_list() const
 306 {
 307         return output_format_list_;
 308 }
 309
 310 vector< pair<QString, QString> > Application::get_pd_list() const
 311 {
 312         return pd_list_;
 313 }
 314
 315 bool Application::notify(QObject *receiver, QEvent *event)
 316 {
 317         try {
 318                 return QApplication::notify(receiver, event);
 319         } catch (exception& e) {
 320                 qDebug().nospace() << "Caught exception of type " << \
 321                         typeid(e).name() << " (" << e.what() << ")";
 322 #ifdef ENABLE_STACKTRACE
 323                 throw e;
 324 #else
 325                 exit(1);
 326 #endif
 327                 return false;
 328         }
 329 }