mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-01-31 20:53:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'qtHelper'

Browse source 
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
This commit is contained in:
Dirk Hohndel 2013-06-18 00:33:03 -07:00
commit 0773172f66
19 changed files with 302 additions and 252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Makefile
View file

@ -69,6 +69,7 @@ SOURCES = \
time.c \
libdivecomputer.c \
qt-gui.cpp \
qthelper.cpp \
qt-ui/divelistview.cpp \
qt-ui/maintab.cpp \
qt-ui/mainwindow.cpp \

113
device.c
View file

@ -2,119 +2,6 @@
#include "dive.h"
#include "device.h"
static struct device_info *device_info_list;
struct device_info *head_of_device_info_list(void)
{
return device_info_list;
}
void remove_dive_computer(const char *model, uint32_t deviceid)
{
free(remove_device_info(model, deviceid));
}
static int match_device_info(struct device_info *entry, const char *model, uint32_t deviceid)
{
return !strcmp(entry->model, model) && entry->deviceid == deviceid;
}
/* just find the entry for this divecomputer */
struct device_info *get_device_info(const char *model, uint32_t deviceid)
{
struct device_info *known = device_info_list;
/* a 0 deviceid doesn't get a nickname - those come from development
* versions of Subsurface that didn't store the deviceid in the divecomputer entries */
if (!deviceid || !model)
return NULL;
while (known) {
if (match_device_info(known, model, deviceid))
return known;
known = known->next;
}
return NULL;
}
/*
* Sort the device_info list, so that we write it out
* in a stable order. Otherwise we'll end up having the
* XML file have the devices listed in some arbitrary
* order, which is annoying.
*/
static void add_entry_sorted(struct device_info *entry)
{
struct device_info *p, **pp = &device_info_list;
while ((p = *pp) != NULL) {
int cmp = strcmp(p->model, entry->model);
if (cmp > 0)
break;
if (!cmp && p->deviceid > entry->deviceid)
break;
pp = &p->next;
}
entry->next = p;
*pp = entry;
}
/* Get an existing device info model or create a new one if valid */
struct device_info *create_device_info(const char *model, uint32_t deviceid)
{
struct device_info *entry;
if (!deviceid || !model || !*model)
return NULL;
entry = get_device_info(model, deviceid);
if (entry)
return entry;
entry = calloc(1, sizeof(*entry));
if (entry) {
entry->model = strdup(model);
entry->deviceid = deviceid;
add_entry_sorted(entry);
}
return entry;
}
/* do we have a DIFFERENT divecomputer of the same model? */
struct device_info *get_different_device_info(const char *model, uint32_t deviceid)
{
struct device_info *known = device_info_list;
/* a 0 deviceid matches any DC of the same model - those come from development
* versions of Subsurface that didn't store the deviceid in the divecomputer entries */
if (!deviceid)
return NULL;
if (!model)
model = "";
while (known) {
if (known->model && !strcmp(known->model, model) &&
known->deviceid != deviceid)
return known;
known = known->next;
}
return NULL;
}
struct device_info *remove_device_info(const char *model, uint32_t deviceid)
{
struct device_info *entry, **p;
if (!deviceid || !model || !*model)
return NULL;
p = &device_info_list;
while ((entry = *p) != NULL) {
if (match_device_info(entry, model, deviceid)) {
*p = entry->next;
break;
}
p = &entry->next;
}
return entry;
}
struct divecomputer* fake_dc(struct divecomputer* dc)
{
static struct sample fake[4];

19
device.h
View file

@ -6,23 +6,10 @@
extern "C" {
#endif
struct device_info {
const char *model;
uint32_t deviceid;
const char *serial_nr;
const char *firmware;
const char *nickname;
struct device_info *next;
};
extern struct device_info *get_device_info(const char *model, uint32_t deviceid);
extern struct device_info *get_different_device_info(const char *model, uint32_t deviceid);
extern struct device_info *create_device_info(const char *model, uint32_t deviceid);
extern struct device_info *remove_device_info(const char *model, uint32_t deviceid);
extern struct device_info *head_of_device_info_list(void);
extern struct divecomputer *fake_dc(struct divecomputer* dc);
extern void remove_dive_computer(const char *model, uint32_t deviceid);
extern void create_device_node(const char *model, uint32_t deviceid, const char *serial, const char *firmware, const char *nickname);
extern void call_for_each_dc(FILE *f, void (*callback)(FILE *, const char *, uint32_t,
const char *, const char *, const char *));
#ifdef __cplusplus
}

1
dive.h
View file

@ -653,7 +653,6 @@ extern void dive_list_update_dives(void);
extern void flush_divelist(struct dive *dive);
extern void set_dc_nickname(struct dive *dive);
extern const char *get_dc_nickname(const char *model, uint32_t deviceid);
extern void set_autogroup(gboolean value);
extern int total_weight(struct dive *);

2
divelist.c
View file

@ -1059,7 +1059,7 @@ static void try_to_renumber(struct dive *last, int preexisting)
void process_dives(bool is_imported, bool prefer_imported)
{
int i;
int i;
int preexisting = dive_table.preexisting;
struct dive *last;

4
helpers.h
View file

@ -9,6 +9,7 @@
#include <QString>
#include "dive.h"
#include "qthelper.h"
QString get_depth_string(depth_t depth, bool showunit);
QString get_weight_string(weight_t weight, bool showunit);
@ -18,5 +19,8 @@ QString get_pressure_string(pressure_t pressure, bool showunit);
void set_default_dive_computer(const char *vendor, const char *product);
void set_default_dive_computer_device(const char *name);
QString getSubsurfaceDataPath(QString folderToFind);
extern const QString get_dc_nickname(const char *model, uint32_t deviceid);
extern DiveComputerList dcList;
#endif /* HELPER_H */

19
libdivecomputer.c
View file

@ -578,36 +578,29 @@ static unsigned int undo_libdivecomputer_suunto_nr_changes(unsigned int serial)
static unsigned int fixup_suunto_versions(device_data_t *devdata, const dc_event_devinfo_t *devinfo)
{
struct device_info *info;
unsigned int serial = devinfo->serial;
char serial_nr[13] = "";
char firmware[13] = "";
first_temp_is_air = 1;
serial = undo_libdivecomputer_suunto_nr_changes(serial);
info = create_device_info(devdata->model, devdata->deviceid);
if (!info)
return serial;
if (!info->serial_nr && serial) {
char serial_nr[13];
if (serial) {
snprintf(serial_nr, sizeof(serial_nr), "%02d%02d%02d%02d",
(devinfo->serial >> 24) & 0xff,
(devinfo->serial >> 16) & 0xff,
(devinfo->serial >> 8) & 0xff,
(devinfo->serial >> 0) & 0xff);
info->serial_nr = strdup(serial_nr);
}
if (!info->firmware && devinfo->firmware) {
char firmware[13];
if (devinfo->firmware) {
snprintf(firmware, sizeof(firmware), "%d.%d.%d",
(devinfo->firmware >> 16) & 0xff,
(devinfo->firmware >> 8) & 0xff,
(devinfo->firmware >> 0) & 0xff);
info->firmware = strdup(firmware);
}
create_device_node(devdata->model, devdata->deviceid, serial_nr, firmware, "");
return serial;
}

13
parse-xml.c
View file

@ -1222,17 +1222,8 @@ static void dc_settings_start(void)
static void dc_settings_end(void)
{
struct device_info *info;
info = create_device_info(cur_settings.dc.model, cur_settings.dc.deviceid);
if (info) {
if (!info->serial_nr && cur_settings.dc.serial_nr)
info->serial_nr = strdup(cur_settings.dc.serial_nr);
if (!info->firmware && cur_settings.dc.firmware)
info->firmware = strdup(cur_settings.dc.firmware);
if (!info->nickname && cur_settings.dc.nickname)
info->nickname = strdup(cur_settings.dc.nickname);
}
create_device_node(cur_settings.dc.model, cur_settings.dc.deviceid, cur_settings.dc.serial_nr,
cur_settings.dc.firmware, cur_settings.dc.nickname);
reset_dc_settings();
}

67
qt-gui.cpp
View file

@ -21,6 +21,7 @@
#include "libdivecomputer.h"
#include "qt-ui/mainwindow.h"
#include "helpers.h"
#include "qthelper.h"
#include <QApplication>
#include <QFileDialog>
@ -32,10 +33,13 @@
#include <QDesktopWidget>
#include <QStyle>
#include <QDebug>
#include <QMap>
#include <QMultiMap>
const char *default_dive_computer_vendor;
const char *default_dive_computer_product;
const char *default_dive_computer_device;
DiveComputerList dcList;
class Translator: public QTranslator
{
@ -142,30 +146,15 @@ void set_filename(const char *filename, gboolean force)
existing_filename = NULL;
}
const char *get_dc_nickname(const char *model, uint32_t deviceid)
const QString get_dc_nickname(const char *model, uint32_t deviceid)
{
struct device_info *known = get_device_info(model, deviceid);
if (known) {
if (known->nickname && *known->nickname)
return known->nickname;
else
return known->model;
}
return NULL;
}
void remember_dc(const char *model, uint32_t deviceid, const char *nickname)
{
struct device_info *nn_entry;
nn_entry = create_device_info(model, deviceid);
if (!nn_entry)
return;
if (!nickname || !*nickname) {
nn_entry->nickname = NULL;
return;
}
nn_entry->nickname = strdup(nickname);
const DiveComputerNode *existNode = dcList.getExact(model, deviceid);
if (!existNode)
return QString("");
if (existNode->nickName != "")
return existNode->nickName;
else
return model;
}
void set_dc_nickname(struct dive *dive)
@ -176,16 +165,20 @@ void set_dc_nickname(struct dive *dive)
struct divecomputer *dc = &dive->dc;
while (dc) {
if (get_dc_nickname(dc->model, dc->deviceid) == NULL) {
if (dc->model && *dc->model && dc->deviceid &&
!dcList.getExact(dc->model, dc->deviceid)) {
// we don't have this one, yet
struct device_info *nn_entry = get_different_device_info(dc->model, dc->deviceid);
if (nn_entry) {
const DiveComputerNode *existNode = dcList.get(dc->model);
if (existNode) {
// we already have this model but a different deviceid
QString simpleNick(dc->model);
simpleNick.append(" (").append(QString::number(dc->deviceid, 16)).append(")");
remember_dc(dc->model, dc->deviceid, simpleNick.toUtf8().data());
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);
} else {
remember_dc(dc->model, dc->deviceid, NULL);
dcList.addDC(dc->model, dc->deviceid);
}
}
dc = dc->next;
@ -330,4 +323,20 @@ QString getSubsurfaceDataPath(QString folderToFind)
return QString("");
}
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());
}
}
#include "qt-gui.moc"

32
qt-ui/divecomputermanagementdialog.cpp
View file

@ -3,16 +3,26 @@
#include "ui_divecomputermanagementdialog.h"
#include "mainwindow.h"
#include <QMessageBox>
#include "../qthelper.h"
#include "../helpers.h"
DiveComputerManagementDialog::DiveComputerManagementDialog(QWidget* parent, Qt::WindowFlags f): QDialog(parent, f)
, ui( new Ui::DiveComputerManagementDialog())
DiveComputerManagementDialog::DiveComputerManagementDialog(QWidget* parent, Qt::WindowFlags f): QDialog(parent, f),
ui( new Ui::DiveComputerManagementDialog()),
model(0)
{
ui->setupUi(this);
model = new DiveComputerModel();
ui->tableView->setModel(model);
init();
connect(ui->tableView, SIGNAL(clicked(QModelIndex)), this, SLOT(tryRemove(QModelIndex)));
}
void DiveComputerManagementDialog::init()
{
if (model)
delete model;
model = new DiveComputerModel(dcList.dcMap);
ui->tableView->setModel(model);
}
DiveComputerManagementDialog* DiveComputerManagementDialog::instance()
{
static DiveComputerManagementDialog *self = new DiveComputerManagementDialog();
@ -44,3 +54,17 @@ void DiveComputerManagementDialog::tryRemove(const QModelIndex& index)
model->remove(index);
}
}
void DiveComputerManagementDialog::accept()
{
model->keepWorkingList();
hide();
close();
}
void DiveComputerManagementDialog::reject()
{
model->dropWorkingList();
hide();
close();
}

5
qt-ui/divecomputermanagementdialog.h
View file

@ -14,9 +14,12 @@ Q_OBJECT
public:
static DiveComputerManagementDialog *instance();
void update();
void init();
public slots:
void tryRemove(const QModelIndex& index);
void accept();
void reject();
private:
explicit DiveComputerManagementDialog(QWidget* parent = 0, Qt::WindowFlags f = 0);
@ -24,4 +27,4 @@ private:
DiveComputerModel *model;
};
#endif
#endif

47
qt-ui/divecomputermanagementdialog.ui
View file

@ -11,7 +11,7 @@
</rect>
</property>
<property name="windowTitle">
<string>Dialog</string>
<string>Edit Dive Computer Nicknames</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
@ -21,8 +21,51 @@
</attribute>
</widget>
</item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>DiveComputerManagementDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>DiveComputerManagementDialog</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

1
qt-ui/mainwindow.cpp
View file

@ -207,6 +207,7 @@ void MainWindow::on_actionDownloadWeb_triggered()
void MainWindow::on_actionEditDeviceNames_triggered()
{
DiveComputerManagementDialog::instance()->init();
DiveComputerManagementDialog::instance()->update();
DiveComputerManagementDialog::instance()->show();
}

65
qt-ui/models.cpp
View file

@ -8,8 +8,8 @@
#include "../helpers.h"
#include "../dive.h"
#include "../device.h"
#include "../statistics.h"
#include "../statistics.h"
#include "../qthelper.h"
#include <QCoreApplication>
#include <QDebug>
@ -1172,9 +1172,10 @@ void DiveTripModel::setLayout(DiveTripModel::Layout layout)
*####################################################################
*/
DiveComputerModel::DiveComputerModel(QObject* parent): QAbstractTableModel(parent)
DiveComputerModel::DiveComputerModel(QMultiMap<QString, DiveComputerNode> &dcMap, QObject* parent): QAbstractTableModel(parent)
{
dcWorkingMap = dcMap;
numRows = 0;
}
int DiveComputerModel::columnCount(const QModelIndex& parent) const
@ -1198,17 +1199,15 @@ QVariant DiveComputerModel::headerData(int section, Qt::Orientation orientation,
QVariant DiveComputerModel::data(const QModelIndex& index, int role) const
{
struct device_info *device = head_of_device_info_list();
for(int i = 0; i < index.row(); i++){
device = device->next;
}
QList<DiveComputerNode> values = dcWorkingMap.values();
DiveComputerNode node = values.at(index.row());
QVariant ret;
if (role == Qt::DisplayRole || role == Qt::EditRole){
switch(index.column()){
case ID: ret = QString("0x").append(QString::number(device->deviceid, 16)); break;
case MODEL: ret = device->model; break;
case NICKNAME: ret = device->nickname; break;
case ID: ret = QString("0x").append(QString::number(node.deviceId, 16)); break;
case MODEL: ret = node.model; break;
case NICKNAME: ret = node.nickName; break;
}
}
@ -1225,12 +1224,8 @@ int DiveComputerModel::rowCount(const QModelIndex& parent) const
void DiveComputerModel::update()
{
int count = 0;
struct device_info *nnl = head_of_device_info_list();
while (nnl) {
nnl = nnl->next;
count++;
}
QList<DiveComputerNode> values = dcWorkingMap.values();
int count = values.count();
if(numRows){
beginRemoveRows(QModelIndex(), 0, numRows-1);
@ -1255,25 +1250,19 @@ Qt::ItemFlags DiveComputerModel::flags(const QModelIndex& index) const
bool DiveComputerModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
struct device_info *nnl = head_of_device_info_list();
for(int i = 0; i < index.row(); i++){
nnl = nnl->next;
}
QByteArray v = value.toByteArray();
nnl->nickname = strdup(v.data()); // how should I free this before setting a new one?
// set_dc_nickname(dive); -> should this be used instead?
QList<DiveComputerNode> values = dcWorkingMap.values();
DiveComputerNode node = values.at(index.row());
dcWorkingMap.remove(node.model, node);
node.nickName = value.toString();
dcWorkingMap.insert(node.model, node);
return true;
}
void DiveComputerModel::remove(const QModelIndex& i)
void DiveComputerModel::remove(const QModelIndex& index)
{
QByteArray model = data(index(i.row(), (int)MODEL)).toByteArray();
uint32_t deviceid = data(index(i.row(), (int) ID)).toUInt();
remove_dive_computer(model.data(), deviceid);
QList<DiveComputerNode> values = dcWorkingMap.values();
DiveComputerNode node = values.at(index.row());
dcWorkingMap.remove(node.model, node);
update();
}
@ -1396,3 +1385,15 @@ void YearlyStatisticsModel::update_yearly_stats()
rootItem->children.append(item);
}
}
void DiveComputerModel::dropWorkingList()
{
// how do I prevent the memory leak ?
}
void DiveComputerModel::keepWorkingList()
{
if (dcList.dcMap != dcWorkingMap)
mark_divelist_changed(TRUE);
dcList.dcMap = dcWorkingMap;
}

18
qt-ui/models.h
View file

@ -13,6 +13,7 @@
#include "../dive.h"
#include "../divelist.h"
#include "../qthelper.h"
QFont defaultModelFont();
@ -181,19 +182,22 @@ class DiveComputerModel : public QAbstractTableModel
Q_OBJECT
public:
enum {REMOVE, MODEL, ID, NICKNAME, COLUMNS};
explicit DiveComputerModel(QObject* parent = 0);
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
virtual Qt::ItemFlags flags(const QModelIndex& index) const;
virtual bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
DiveComputerModel(QMultiMap<QString, DiveComputerNode> &dcMap, QObject *parent = 0);
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
virtual Qt::ItemFlags flags(const QModelIndex& index) const;
virtual bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
void update();
void keepWorkingList();
void dropWorkingList();
public slots:
void remove(const QModelIndex& index);
private:
int numRows;
QMultiMap<QString, DiveComputerNode> dcWorkingMap;
};
class YearlyStatisticsModel : public TreeModel {

3
qt-ui/profilegraphics.cpp
View file

@ -21,6 +21,7 @@
#include "../dive.h"
#include "../profile.h"
#include "../device.h"
#include "../helpers.h"
#include <libdivecomputer/parser.h>
#include <libdivecomputer/version.h>
@ -273,7 +274,7 @@ void ProfileGraphicsView::plot(struct dive *d, bool forceRedraw)
dc = fake_dc(dc);
}
QString nick(get_dc_nickname(dc->model, dc->deviceid));
QString nick = get_dc_nickname(dc->model, dc->deviceid);
if (nick.isEmpty())
nick = QString(dc->model);

82
qthelper.cpp Normal file
View file

@ -0,0 +1,82 @@
#include "qthelper.h"
DiveComputerList::DiveComputerList()
{
}
DiveComputerList::~DiveComputerList()
{
dcMap.~QMap();
}
bool DiveComputerNode::operator == (const DiveComputerNode &a) const {
return this->model == a.model &&
this->deviceId == a.deviceId &&
this->firmware == a.firmware &&
this->serialNumber == a.serialNumber &&
this->nickName == a.nickName;
}
bool DiveComputerNode::operator !=(const DiveComputerNode &a) const {
return !(*this == a);
}
bool DiveComputerNode::changesValues(const DiveComputerNode &b) const
{
if (this->model != b.model || this->deviceId != b.deviceId) {
qDebug("DiveComputerNodes were not for the same DC");
return false;
}
return (b.firmware != "" && this->firmware != b.firmware) ||
(b.serialNumber != "" && this->serialNumber != b.serialNumber) ||
(b.nickName != "" && this->nickName != b.nickName);
}
const DiveComputerNode *DiveComputerList::getExact(QString m, uint32_t d)
{
if (dcMap.contains(m)) {
QList<DiveComputerNode> values = dcMap.values(m);
for (int i = 0; i < values.size(); i++)
if (values.at(i).deviceId == d)
return &values.at(i);
}
return NULL;
}
const DiveComputerNode *DiveComputerList::get(QString m)
{
if (dcMap.contains(m)) {
QList<DiveComputerNode> values = dcMap.values(m);
return &values.at(0);
}
return NULL;
}
void DiveComputerList::addDC(QString m, uint32_t d, QString n, QString s, QString f)
{
if (m == "" || d == 0)
return;
const DiveComputerNode *existNode = this->getExact(m, d);
DiveComputerNode newNode(m, d, s, f, n);
if (existNode) {
if (newNode.changesValues(*existNode)) {
if (n != "" && existNode->nickName != n)
qDebug("new nickname %s for DC model %s deviceId 0x%x", n.toUtf8().data(), m.toUtf8().data(), d);
if (f != "" && existNode->firmware != f)
qDebug("new firmware version %s for DC model %s deviceId 0x%x", f.toUtf8().data(), m.toUtf8().data(), d);
if (s != "" && existNode->serialNumber != s)
qDebug("new serial number %s for DC model %s deviceId 0x%x", s.toUtf8().data(), m.toUtf8().data(), d);
} else {
return;
}
dcMap.remove(m, *existNode);
}
dcMap.insert(m, newNode);
}
void DiveComputerList::rmDC(QString m, uint32_t d)
{
const DiveComputerNode *existNode = this->getExact(m, d);
dcMap.remove(m, *existNode);
}

35
qthelper.h Normal file
View file

@ -0,0 +1,35 @@
#ifndef QTHELPER_H
#define QTHELPER_H
#include <QMultiMap>
#include <QString>
#include <stdint.h>
class DiveComputerNode {
public:
DiveComputerNode(QString m, uint32_t d, QString s, QString f, QString n) : model(m), deviceId(d), serialNumber(s), firmware(f), nickName(n) {};
bool operator ==(const DiveComputerNode &a) const;
bool operator !=(const DiveComputerNode &a) const;
bool changesValues(const DiveComputerNode &b) const;
QString model;
uint32_t deviceId;
QString serialNumber;
QString firmware;
QString nickName;
};
class DiveComputerList {
public:
DiveComputerList();
~DiveComputerList();
const DiveComputerNode *getExact(QString m, uint32_t d);
const DiveComputerNode *get(QString m);
void addDC(QString m, uint32_t d, QString n = "", QString s = "", QString f = "");
void rmDC(QString m, uint32_t d);
DiveComputerNode matchDC(QString m, uint32_t d);
DiveComputerNode matchModel(QString m);
QMultiMap<QString, struct DiveComputerNode> dcMap;
QMultiMap<QString, struct DiveComputerNode> dcWorkingMap;
};
#endif // QTHELPER_H

27
save-xml.c
View file

@ -512,24 +512,20 @@ static void save_trip(FILE *f, dive_trip_t *trip)
fprintf(f, "</trip>\n");
}
static void save_one_device(FILE *f, struct device_info *info)
static void save_one_device(FILE *f, const char * model, uint32_t deviceid,
const char *nickname, const char *serial_nr, const char *firmware)
{
const char *nickname, *serial_nr, *firmware;
/* Nicknames that are empty or the same as the device model are not interesting */
nickname = info->nickname;
if (nickname) {
if (!*nickname || !strcmp(info->model, nickname))
if (!*nickname || !strcmp(model, nickname))
nickname = NULL;
}
/* Serial numbers that are empty are not interesting */
serial_nr = info->serial_nr;
if (serial_nr && !*serial_nr)
serial_nr = NULL;
/* Firmware strings that are empty are not interesting */
firmware = info->firmware;
if (firmware && !*firmware)
firmware = NULL;
@ -538,25 +534,14 @@ static void save_one_device(FILE *f, struct device_info *info)
return;
fprintf(f, "<divecomputerid");
show_utf8(f, info->model, " model='", "'", 1);
fprintf(f, " deviceid='%08x'", info->deviceid);
show_utf8(f, model, " model='", "'", 1);
fprintf(f, " deviceid='%08x'", deviceid);
show_utf8(f, serial_nr, " serial='", "'", 1);
show_utf8(f, firmware, " firmware='", "'", 1);
show_utf8(f, nickname, " nickname='", "'", 1);
fprintf(f, "/>\n");
}
static void save_device_info(FILE *f)
{
struct device_info *info;
info = head_of_device_info_list();
while (info) {
save_one_device(f, info);
info = info->next;
}
}
#define VERSION 2
void save_dives(const char *filename)
@ -578,7 +563,7 @@ void save_dives_logic(const char *filename, const gboolean select_only)
fprintf(f, "<divelog program='subsurface' version='%d'>\n<settings>\n", VERSION);
/* save the dive computer nicknames, if any */
save_device_info(f);
call_for_each_dc(f, save_one_device);
if (autogroup)
fprintf(f, "<autogroup state='1' />\n");
fprintf(f, "</settings>\n<dives>\n");