2013-05-03 18:04:51 +00:00
|
|
|
/* qt-gui.cpp */
|
|
|
|
/* Qt UI implementation */
|
2011-09-20 19:40:34 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
2012-01-03 05:53:33 +00:00
|
|
|
#include <unistd.h>
|
2012-09-09 16:06:44 +00:00
|
|
|
#include <sys/stat.h>
|
2013-01-05 20:56:45 +00:00
|
|
|
#include <sys/time.h>
|
2013-01-05 20:16:02 +00:00
|
|
|
#include <ctype.h>
|
2011-09-20 19:40:34 +00:00
|
|
|
|
|
|
|
#include "dive.h"
|
|
|
|
#include "divelist.h"
|
|
|
|
#include "display.h"
|
2012-09-25 14:28:47 +00:00
|
|
|
#include "uemis.h"
|
2013-01-09 20:07:09 +00:00
|
|
|
#include "device.h"
|
2013-01-18 01:05:48 +00:00
|
|
|
#include "webservice.h"
|
2011-09-20 19:40:34 +00:00
|
|
|
#include "libdivecomputer.h"
|
2013-04-07 22:20:43 +00:00
|
|
|
#include "qt-ui/mainwindow.h"
|
2013-05-23 06:24:33 +00:00
|
|
|
#include "helpers.h"
|
2013-06-17 22:58:26 +00:00
|
|
|
#include "qthelper.h"
|
2011-09-20 19:40:34 +00:00
|
|
|
|
2013-05-03 18:04:51 +00:00
|
|
|
#include <QApplication>
|
|
|
|
#include <QFileDialog>
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QStringList>
|
|
|
|
#include <QTextCodec>
|
|
|
|
#include <QTranslator>
|
2013-05-10 04:37:21 +00:00
|
|
|
#include <QSettings>
|
2013-05-10 16:24:06 +00:00
|
|
|
#include <QDesktopWidget>
|
2013-05-31 07:43:38 +00:00
|
|
|
#include <QStyle>
|
|
|
|
#include <QDebug>
|
2013-06-17 22:58:26 +00:00
|
|
|
#include <QMap>
|
|
|
|
#include <QMultiMap>
|
2013-07-13 12:42:26 +00:00
|
|
|
#include <QNetworkProxy>
|
2013-09-20 23:41:42 +00:00
|
|
|
#include <QDateTime>
|
|
|
|
#include <QRegExp>
|
2013-10-09 05:25:02 +00:00
|
|
|
#include <QLibraryInfo>
|
2013-04-07 22:20:43 +00:00
|
|
|
|
2013-10-06 15:55:58 +00:00
|
|
|
#include <gettextfromc.h>
|
2013-10-10 05:48:35 +00:00
|
|
|
|
|
|
|
// this will create a warning when executing lupdate
|
2013-10-10 07:15:21 +00:00
|
|
|
#define translate(_context, arg) gettextFromC::instance()->tr(arg)
|
2013-10-06 15:55:58 +00:00
|
|
|
|
2013-05-23 06:24:33 +00:00
|
|
|
const char *default_dive_computer_vendor;
|
|
|
|
const char *default_dive_computer_product;
|
|
|
|
const char *default_dive_computer_device;
|
2013-06-17 22:58:26 +00:00
|
|
|
DiveComputerList dcList;
|
2013-05-23 06:24:33 +00:00
|
|
|
|
2013-05-03 18:04:51 +00:00
|
|
|
static QApplication *application = NULL;
|
2013-09-18 15:27:24 +00:00
|
|
|
static MainWindow *window = NULL;
|
2013-04-02 16:49:17 +00:00
|
|
|
|
2013-05-03 18:04:51 +00:00
|
|
|
int error_count;
|
|
|
|
const char *existing_filename;
|
2013-04-02 16:49:17 +00:00
|
|
|
|
2013-05-24 01:36:18 +00:00
|
|
|
const char *getSetting(QSettings &s, QString name)
|
2013-05-23 06:24:33 +00:00
|
|
|
{
|
|
|
|
QVariant v;
|
|
|
|
v = s.value(name);
|
|
|
|
if (v.isValid()) {
|
2013-05-28 18:21:27 +00:00
|
|
|
return strdup(v.toString().toUtf8().data());
|
2013-05-23 06:24:33 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-11-02 00:09:15 +00:00
|
|
|
void init_ui(int *argcp, char ***argvp)
|
2011-09-20 19:40:34 +00:00
|
|
|
{
|
2013-05-10 04:37:21 +00:00
|
|
|
QVariant v;
|
2013-05-31 07:43:38 +00:00
|
|
|
|
2013-04-22 13:45:57 +00:00
|
|
|
application = new QApplication(*argcp, *argvp);
|
2013-04-25 22:28:31 +00:00
|
|
|
|
2013-09-09 07:46:02 +00:00
|
|
|
// tell Qt to use system proxies
|
|
|
|
// note: on Linux, "system" == "environment variables"
|
|
|
|
QNetworkProxyFactory::setUseSystemConfiguration(true);
|
2013-07-13 12:42:26 +00:00
|
|
|
|
2013-04-25 22:28:31 +00:00
|
|
|
#if QT_VERSION < 0x050000
|
|
|
|
// ask QString in Qt 4 to interpret all char* as UTF-8,
|
|
|
|
// like Qt 5 does.
|
|
|
|
// 106 is "UTF-8", this is faster than lookup by name
|
|
|
|
// [http://www.iana.org/assignments/character-sets/character-sets.xml]
|
|
|
|
QTextCodec::setCodecForCStrings(QTextCodec::codecForMib(106));
|
|
|
|
#endif
|
2013-05-22 03:31:56 +00:00
|
|
|
QCoreApplication::setOrganizationName("Subsurface");
|
|
|
|
QCoreApplication::setOrganizationDomain("subsurface.hohndel.org");
|
|
|
|
QCoreApplication::setApplicationName("Subsurface");
|
2013-10-04 20:21:31 +00:00
|
|
|
xslt_path = strdup(getSubsurfaceDataPath("xslt").toAscii().data());
|
2013-04-25 22:28:31 +00:00
|
|
|
|
2013-10-09 05:25:02 +00:00
|
|
|
QLocale loc;
|
2013-10-10 19:26:03 +00:00
|
|
|
QString uiLang = loc.uiLanguages().first();
|
|
|
|
// there's a stupid Qt bug on MacOS where uiLanguages doesn't give us the country info
|
|
|
|
if (!uiLang.contains('-') && uiLang != loc.bcp47Name()) {
|
|
|
|
QLocale loc2(loc.bcp47Name());
|
|
|
|
loc = loc2;
|
|
|
|
uiLang = loc2.uiLanguages().first();
|
|
|
|
}
|
|
|
|
|
2013-10-10 00:55:31 +00:00
|
|
|
// we don't have translations for English - if we don't check for this
|
|
|
|
// Qt will proceed to load the second language in preference order - not what we want
|
|
|
|
// on Linux this tends to be en-US, but on the Mac it's just en
|
2013-10-10 19:26:03 +00:00
|
|
|
if (!uiLang.startsWith("en")) {
|
2013-10-09 05:25:02 +00:00
|
|
|
qtTranslator = new QTranslator;
|
|
|
|
if (qtTranslator->load(loc,"qt", "_", QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
|
|
|
|
application->installTranslator(qtTranslator);
|
|
|
|
} else {
|
2013-10-11 18:03:12 +00:00
|
|
|
qDebug() << "can't find Qt localization for locale" << uiLang <<
|
|
|
|
"searching in" << QLibraryInfo::location(QLibraryInfo::TranslationsPath);
|
2013-10-09 05:25:02 +00:00
|
|
|
}
|
|
|
|
ssrfTranslator = new QTranslator;
|
2013-10-10 19:34:47 +00:00
|
|
|
if (ssrfTranslator->load(loc,"subsurface", "_") ||
|
|
|
|
ssrfTranslator->load(loc,"subsurface", "_", getSubsurfaceDataPath("translations")) ||
|
|
|
|
ssrfTranslator->load(loc,"subsurface", "_", getSubsurfaceDataPath("../translations"))) {
|
2013-10-09 05:25:02 +00:00
|
|
|
application->installTranslator(ssrfTranslator);
|
|
|
|
} else {
|
2013-10-10 19:26:03 +00:00
|
|
|
qDebug() << "can't find Subsurface localization for locale" << uiLang;
|
2013-10-09 05:25:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 06:24:33 +00:00
|
|
|
QSettings s;
|
|
|
|
s.beginGroup("GeneralSettings");
|
|
|
|
prefs.default_filename = getSetting(s, "default_filename");
|
|
|
|
s.endGroup();
|
|
|
|
s.beginGroup("DiveComputer");
|
|
|
|
default_dive_computer_vendor = getSetting(s, "dive_computer_vendor");
|
|
|
|
default_dive_computer_product = getSetting(s,"dive_computer_product");
|
|
|
|
default_dive_computer_device = getSetting(s, "dive_computer_device");
|
|
|
|
s.endGroup();
|
2013-09-09 08:59:03 +00:00
|
|
|
|
2013-09-18 15:27:24 +00:00
|
|
|
window = new MainWindow();
|
2013-09-09 08:59:03 +00:00
|
|
|
window->show();
|
|
|
|
if (existing_filename && existing_filename[0] != '\0')
|
|
|
|
window->setTitle(MWTF_FILENAME);
|
|
|
|
else
|
|
|
|
window->setTitle(MWTF_DEFAULT);
|
|
|
|
|
2011-09-20 19:40:34 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void run_ui(void)
|
|
|
|
{
|
2013-04-01 10:57:51 +00:00
|
|
|
application->exec();
|
2011-09-20 19:40:34 +00:00
|
|
|
}
|
|
|
|
|
2012-05-02 17:03:48 +00:00
|
|
|
void exit_ui(void)
|
|
|
|
{
|
2013-09-18 15:27:24 +00:00
|
|
|
delete window;
|
2013-04-01 10:57:51 +00:00
|
|
|
delete application;
|
2012-09-13 17:46:09 +00:00
|
|
|
if (existing_filename)
|
2012-09-16 03:51:06 +00:00
|
|
|
free((void *)existing_filename);
|
2013-05-23 06:24:33 +00:00
|
|
|
if (default_dive_computer_device)
|
|
|
|
free((void *)default_dive_computer_device);
|
2012-05-02 17:03:48 +00:00
|
|
|
}
|
|
|
|
|
2013-10-05 07:29:09 +00:00
|
|
|
void set_filename(const char *filename, bool force)
|
2011-09-21 04:50:26 +00:00
|
|
|
{
|
2012-09-10 19:27:00 +00:00
|
|
|
if (!force && existing_filename)
|
|
|
|
return;
|
2012-09-16 03:51:06 +00:00
|
|
|
free((void *)existing_filename);
|
2012-07-31 17:55:41 +00:00
|
|
|
if (filename)
|
2011-09-21 04:50:26 +00:00
|
|
|
existing_filename = strdup(filename);
|
2012-11-10 14:32:06 +00:00
|
|
|
else
|
|
|
|
existing_filename = NULL;
|
2011-09-21 04:50:26 +00:00
|
|
|
}
|
2012-12-13 06:26:29 +00:00
|
|
|
|
2013-06-17 22:58:26 +00:00
|
|
|
const QString get_dc_nickname(const char *model, uint32_t deviceid)
|
2012-12-22 05:00:06 +00:00
|
|
|
{
|
2013-06-17 22:58:26 +00:00
|
|
|
const DiveComputerNode *existNode = dcList.getExact(model, deviceid);
|
|
|
|
if (!existNode)
|
2013-09-09 07:48:03 +00:00
|
|
|
return QString();
|
|
|
|
else if (!existNode->nickName.isEmpty())
|
2013-06-17 22:58:26 +00:00
|
|
|
return existNode->nickName;
|
|
|
|
else
|
|
|
|
return model;
|
2013-06-17 18:48:58 +00:00
|
|
|
}
|
|
|
|
|
2012-12-13 06:26:29 +00:00
|
|
|
void set_dc_nickname(struct dive *dive)
|
|
|
|
{
|
2013-06-17 18:48:58 +00:00
|
|
|
if (!dive)
|
|
|
|
return;
|
|
|
|
|
|
|
|
struct divecomputer *dc = &dive->dc;
|
|
|
|
|
|
|
|
while (dc) {
|
2013-06-17 22:58:26 +00:00
|
|
|
if (dc->model && *dc->model && dc->deviceid &&
|
|
|
|
!dcList.getExact(dc->model, dc->deviceid)) {
|
2013-06-17 18:48:58 +00:00
|
|
|
// we don't have this one, yet
|
2013-06-17 22:58:26 +00:00
|
|
|
const DiveComputerNode *existNode = dcList.get(dc->model);
|
|
|
|
if (existNode) {
|
2013-06-17 18:48:58 +00:00
|
|
|
// we already have this model but a different deviceid
|
|
|
|
QString simpleNick(dc->model);
|
2013-06-17 22:58:26 +00:00
|
|
|
if (dc->deviceid == 0)
|
|
|
|
simpleNick.append(" (unknown deviceid)");
|
|
|
|
else
|
|
|
|
simpleNick.append(" (").append(QString::number(dc->deviceid, 16)).append(")");
|
|
|
|
dcList.addDC(dc->model, dc->deviceid, simpleNick);
|
2013-06-17 18:48:58 +00:00
|
|
|
} else {
|
2013-06-17 22:58:26 +00:00
|
|
|
dcList.addDC(dc->model, dc->deviceid);
|
2013-06-17 18:48:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
dc = dc->next;
|
|
|
|
}
|
2012-12-13 06:26:29 +00:00
|
|
|
}
|
2013-02-05 23:10:40 +00:00
|
|
|
|
2013-09-22 19:37:49 +00:00
|
|
|
QString get_depth_string(int mm, bool showunit, bool showdecimal)
|
2013-05-07 03:36:37 +00:00
|
|
|
{
|
|
|
|
if (prefs.units.length == units::METERS) {
|
2013-09-22 19:37:49 +00:00
|
|
|
double meters = mm / 1000.0;
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(meters, 0, 'f', (showdecimal && meters < 20.0) ? 1 : 0 ).arg(showunit ? translate("gettextFromC","m") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
} else {
|
2013-09-22 19:37:49 +00:00
|
|
|
double feet = mm_to_feet(mm);
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(feet, 0, 'f', showdecimal ? 1 : 0). arg(showunit ? translate("gettextFromC","ft") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-22 19:37:49 +00:00
|
|
|
QString get_depth_string(depth_t depth, bool showunit, bool showdecimal)
|
|
|
|
{
|
|
|
|
return get_depth_string(depth.mm, showunit, showdecimal);
|
|
|
|
}
|
|
|
|
|
2013-06-18 17:48:46 +00:00
|
|
|
QString get_depth_unit()
|
|
|
|
{
|
|
|
|
if (prefs.units.length == units::METERS)
|
|
|
|
return "m";
|
|
|
|
else
|
|
|
|
return "ft";
|
|
|
|
}
|
|
|
|
|
2013-05-07 03:36:37 +00:00
|
|
|
QString get_weight_string(weight_t weight, bool showunit)
|
|
|
|
{
|
2013-10-04 18:39:33 +00:00
|
|
|
QString str = weight_string (weight.grams);
|
|
|
|
if (get_units()->weight == units::KG) {
|
2013-10-10 05:48:35 +00:00
|
|
|
str = QString ("%1%2").arg(str).arg(showunit ? translate("gettextFromC","kg") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
} else {
|
2013-10-10 05:48:35 +00:00
|
|
|
str = QString ("%1%2").arg(str).arg(showunit ? translate("gettextFromC","lbs") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
2013-10-04 18:39:33 +00:00
|
|
|
return (str);
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
|
|
|
|
2013-06-18 17:48:46 +00:00
|
|
|
QString get_weight_unit()
|
|
|
|
{
|
|
|
|
if (prefs.units.weight == units::KG)
|
|
|
|
return "kg";
|
|
|
|
else
|
|
|
|
return "lbs";
|
|
|
|
}
|
|
|
|
|
2013-10-03 14:50:38 +00:00
|
|
|
/* these methods retrieve used gas per cylinder */
|
|
|
|
static unsigned start_pressure(cylinder_t *cyl)
|
|
|
|
{
|
|
|
|
return cyl->start.mbar ? : cyl->sample_start.mbar;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned end_pressure(cylinder_t *cyl)
|
|
|
|
{
|
|
|
|
return cyl->end.mbar ? : cyl->sample_end.mbar;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString get_cylinder_used_gas_string(cylinder_t *cyl, bool showunit)
|
|
|
|
{
|
|
|
|
int decimals;
|
|
|
|
const char *unit;
|
|
|
|
double gas_usage;
|
|
|
|
/* Get the cylinder gas use in mbar */
|
|
|
|
gas_usage = start_pressure(cyl) - end_pressure(cyl);
|
|
|
|
/* Can we turn it into a volume? */
|
|
|
|
if (cyl->type.size.mliter) {
|
|
|
|
gas_usage = bar_to_atm(gas_usage / 1000);
|
|
|
|
gas_usage *= cyl->type.size.mliter;
|
|
|
|
gas_usage = get_volume_units(gas_usage, &decimals, &unit);
|
|
|
|
} else {
|
|
|
|
gas_usage = get_pressure_units(gas_usage, &unit);
|
|
|
|
decimals = 0;
|
|
|
|
}
|
2013-10-10 05:48:35 +00:00
|
|
|
// translate("gettextFromC","%.*f %s"
|
2013-10-03 14:50:38 +00:00
|
|
|
return QString("%1 %2").arg(gas_usage, 0, 'f', decimals).arg(showunit ? unit : "");
|
|
|
|
}
|
|
|
|
|
2013-05-07 03:36:37 +00:00
|
|
|
QString get_temperature_string(temperature_t temp, bool showunit)
|
|
|
|
{
|
2013-10-08 08:32:08 +00:00
|
|
|
if (temp.mkelvin == 0) {
|
|
|
|
return ""; //temperature not defined
|
|
|
|
} else if (prefs.units.temperature == units::CELSIUS) {
|
2013-05-07 03:36:37 +00:00
|
|
|
double celsius = mkelvin_to_C(temp.mkelvin);
|
2013-05-10 22:56:05 +00:00
|
|
|
return QString("%1%2%3").arg(celsius, 0, 'f', 1).arg(showunit ? (UTF8_DEGREE): "")
|
2013-10-10 05:48:35 +00:00
|
|
|
.arg(showunit ? translate("gettextFromC","C") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
} else {
|
|
|
|
double fahrenheit = mkelvin_to_F(temp.mkelvin);
|
2013-05-10 22:56:05 +00:00
|
|
|
return QString("%1%2%3").arg(fahrenheit, 0, 'f', 1).arg(showunit ? (UTF8_DEGREE): "")
|
2013-10-10 05:48:35 +00:00
|
|
|
.arg(showunit ? translate("gettextFromC","F") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-18 17:48:46 +00:00
|
|
|
QString get_temp_unit()
|
|
|
|
{
|
|
|
|
if (prefs.units.temperature == units::CELSIUS)
|
|
|
|
return QString(UTF8_DEGREE "C");
|
|
|
|
else
|
|
|
|
return QString(UTF8_DEGREE "F");
|
|
|
|
}
|
|
|
|
|
2013-05-07 03:36:37 +00:00
|
|
|
QString get_volume_string(volume_t volume, bool showunit)
|
|
|
|
{
|
|
|
|
if (prefs.units.volume == units::LITER) {
|
|
|
|
double liter = volume.mliter / 1000.0;
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(liter, 0, 'f', liter >= 40.0 ? 0 : 1 ).arg(showunit ? translate("gettextFromC","l") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
} else {
|
|
|
|
double cuft = ml_to_cuft(volume.mliter);
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(cuft, 0, 'f', cuft >= 20.0 ? 0 : (cuft >= 2.0 ? 1 : 2)).arg(showunit ? translate("gettextFromC","cuft") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-18 17:48:46 +00:00
|
|
|
QString get_volume_unit()
|
|
|
|
{
|
|
|
|
if (prefs.units.volume == units::LITER)
|
|
|
|
return "l";
|
|
|
|
else
|
|
|
|
return "cuft";
|
|
|
|
}
|
|
|
|
|
2013-05-07 03:36:37 +00:00
|
|
|
QString get_pressure_string(pressure_t pressure, bool showunit)
|
|
|
|
{
|
|
|
|
if (prefs.units.pressure == units::BAR) {
|
|
|
|
double bar = pressure.mbar / 1000.0;
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(bar, 0, 'f', 1).arg(showunit ? translate("gettextFromC","bar") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
} else {
|
|
|
|
double psi = mbar_to_PSI(pressure.mbar);
|
2013-10-10 05:48:35 +00:00
|
|
|
return QString("%1%2").arg(psi, 0, 'f', 0).arg(showunit ? translate("gettextFromC","psi") : "");
|
2013-05-07 03:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
2013-04-01 10:57:51 +00:00
|
|
|
|
2013-05-10 16:24:06 +00:00
|
|
|
double get_screen_dpi()
|
|
|
|
{
|
|
|
|
QDesktopWidget *mydesk = application->desktop();
|
|
|
|
return mydesk->physicalDpiX();
|
|
|
|
}
|
2013-05-23 06:24:33 +00:00
|
|
|
|
|
|
|
int is_default_dive_computer(const char *vendor, const char *product)
|
|
|
|
{
|
|
|
|
return default_dive_computer_vendor && !strcmp(vendor, default_dive_computer_vendor) &&
|
|
|
|
default_dive_computer_product && !strcmp(product, default_dive_computer_product);
|
|
|
|
}
|
|
|
|
|
|
|
|
int is_default_dive_computer_device(const char *name)
|
|
|
|
{
|
|
|
|
return default_dive_computer_device && !strcmp(name, default_dive_computer_device);
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_default_dive_computer(const char *vendor, const char *product)
|
|
|
|
{
|
|
|
|
QSettings s;
|
|
|
|
|
|
|
|
if (!vendor || !*vendor)
|
|
|
|
return;
|
|
|
|
if (!product || !*product)
|
|
|
|
return;
|
|
|
|
if (is_default_dive_computer(vendor, product))
|
|
|
|
return;
|
|
|
|
if (default_dive_computer_vendor)
|
|
|
|
free((void *)default_dive_computer_vendor);
|
|
|
|
if (default_dive_computer_product)
|
|
|
|
free((void *)default_dive_computer_product);
|
|
|
|
default_dive_computer_vendor = strdup(vendor);
|
|
|
|
default_dive_computer_product = strdup(product);
|
|
|
|
s.beginGroup("DiveComputer");
|
|
|
|
s.setValue("dive_computer_vendor", vendor);
|
|
|
|
s.setValue("dive_computer_product", product);
|
|
|
|
s.endGroup();
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_default_dive_computer_device(const char *name)
|
|
|
|
{
|
|
|
|
QSettings s;
|
|
|
|
|
|
|
|
if (!name || !*name)
|
|
|
|
return;
|
|
|
|
if (is_default_dive_computer_device(name))
|
|
|
|
return;
|
|
|
|
if (default_dive_computer_device)
|
|
|
|
free((void *)default_dive_computer_device);
|
|
|
|
default_dive_computer_device = strdup(name);
|
|
|
|
s.beginGroup("DiveComputer");
|
|
|
|
s.setValue("dive_computer_device", name);
|
|
|
|
s.endGroup();
|
|
|
|
}
|
|
|
|
|
2013-05-30 21:26:08 +00:00
|
|
|
QString getSubsurfaceDataPath(QString folderToFind)
|
|
|
|
{
|
|
|
|
QString execdir;
|
|
|
|
QDir folder;
|
|
|
|
|
|
|
|
// first check if we are running in the build dir, so this
|
|
|
|
// is just subdirectory of the current directory
|
2013-10-13 15:43:13 +00:00
|
|
|
execdir = QDir::currentPath();
|
2013-05-30 21:26:08 +00:00
|
|
|
folder = QDir(execdir.append(QDir::separator()).append(folderToFind));
|
|
|
|
if (folder.exists())
|
|
|
|
return folder.absolutePath();
|
|
|
|
|
|
|
|
// next check for the Linux typical $(prefix)/share/subsurface
|
|
|
|
execdir = QCoreApplication::applicationDirPath();
|
|
|
|
folder = QDir(execdir.replace("bin", "share/subsurface/").append(folderToFind));
|
|
|
|
if (folder.exists())
|
|
|
|
return folder.absolutePath();
|
|
|
|
|
|
|
|
// then look for the usual location on a Mac
|
|
|
|
execdir = QCoreApplication::applicationDirPath();
|
|
|
|
folder = QDir(execdir.append("/../Resources/share/").append(folderToFind));
|
|
|
|
if (folder.exists())
|
|
|
|
return folder.absolutePath();
|
|
|
|
return QString("");
|
|
|
|
}
|
|
|
|
|
2013-06-17 22:58:26 +00:00
|
|
|
void create_device_node(const char *model, uint32_t deviceid, const char *serial, const char *firmware, const char *nickname)
|
|
|
|
{
|
|
|
|
dcList.addDC(model, deviceid, nickname, serial, firmware);
|
|
|
|
}
|
|
|
|
|
|
|
|
void call_for_each_dc(FILE *f, void (*callback)(FILE *, const char *, uint32_t,
|
|
|
|
const char *, const char *, const char *))
|
|
|
|
{
|
|
|
|
QList<DiveComputerNode> values = dcList.dcMap.values();
|
|
|
|
for (int i = 0; i < values.size(); i++) {
|
|
|
|
const DiveComputerNode *node = &values.at(i);
|
|
|
|
callback(f, node->model.toUtf8().data(), node->deviceId, node->nickName.toUtf8().data(),
|
|
|
|
node->serialNumber.toUtf8().data(), node->firmware.toUtf8().data());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-20 23:41:42 +00:00
|
|
|
int gettimezoneoffset()
|
|
|
|
{
|
|
|
|
QDateTime dt1 = QDateTime::currentDateTime();
|
|
|
|
QDateTime dt2 = dt1.toUTC();
|
|
|
|
dt1.setTimeSpec(Qt::UTC);
|
|
|
|
return dt2.secsTo(dt1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int parseTemperatureToMkelvin(const QString& text)
|
|
|
|
{
|
|
|
|
int mkelvin;
|
|
|
|
QString numOnly = text;
|
|
|
|
numOnly.replace(",",".").remove(QRegExp("[^0-9.]"));
|
|
|
|
if (numOnly == "")
|
|
|
|
return 0;
|
|
|
|
double number = numOnly.toDouble();
|
|
|
|
switch (prefs.units.temperature) {
|
|
|
|
case units::CELSIUS:
|
|
|
|
mkelvin = C_to_mkelvin(number);
|
|
|
|
break;
|
|
|
|
case units::FAHRENHEIT:
|
|
|
|
mkelvin = F_to_mkelvin(number);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mkelvin = 0;
|
|
|
|
}
|
|
|
|
return mkelvin;
|
|
|
|
|
|
|
|
}
|
2013-10-16 22:00:17 +00:00
|
|
|
|
|
|
|
QString get_dive_date_string(timestamp_t when)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
|
|
|
utc_mkdate(when, &tm);
|
|
|
|
return translate("gettextFromC", "%1, %2 %3, %4 %5:%6")
|
|
|
|
.arg(weekday(tm.tm_wday))
|
|
|
|
.arg(monthname(tm.tm_mon))
|
|
|
|
.arg(tm.tm_mday)
|
|
|
|
.arg(tm.tm_year + 1900)
|
|
|
|
.arg(tm.tm_hour, 2, 10, QChar('0'))
|
|
|
|
.arg(tm.tm_min, 2, 10, QChar('0'));
|
|
|
|
}
|
|
|
|
|
|
|
|
QString get_short_dive_date_string(timestamp_t when)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
|
|
|
utc_mkdate(when, &tm);
|
|
|
|
return translate("gettextFromC", "%1 %2, %3\n%4:%5")
|
|
|
|
.arg(monthname(tm.tm_mon))
|
|
|
|
.arg(tm.tm_mday)
|
|
|
|
.arg(tm.tm_year + 1900)
|
|
|
|
.arg(tm.tm_hour, 2, 10, QChar('0'))
|
|
|
|
.arg(tm.tm_min, 2, 10, QChar('0'));
|
|
|
|
}
|
|
|
|
|
|
|
|
QString get_trip_date_string(timestamp_t when, int nr)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
|
|
|
utc_mkdate(when, &tm);
|
|
|
|
if (nr != 1)
|
|
|
|
return translate("gettextFromC", "%1 %2 (%3 dives)")
|
|
|
|
.arg(monthname(tm.tm_mon))
|
|
|
|
.arg(tm.tm_year + 1900)
|
|
|
|
.arg(nr);
|
|
|
|
else
|
|
|
|
return translate("gettextFromC", "%1 %2 (1 dive)")
|
|
|
|
.arg(monthname(tm.tm_mon))
|
|
|
|
.arg(tm.tm_year + 1900);
|
|
|
|
}
|