mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-30 22:20:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

Dive site: replace dive->dive_site_uuid by dive_site

Browse source 
Replace the UUID reference of struct dive by a pointer to dive_site.
This commit is rather large in lines, but nevertheless quite simple
since most of the UUID->pointer work was done in previous commits.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2018-10-26 17:03:54 +02:00 committed by Dirk Hohndel
parent acd44467c1
commit 724055f0af
28 changed files with 181 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
core/datatrak.c
View file

@ -202,9 +202,9 @@ unsigned char *dt_dive_parser(unsigned char *runner, struct dive *dt_dive)
*/
snprintf(buffer, sizeof(buffer), "%s, %s", locality, dive_point);
ds = get_dive_site_by_name(buffer);
dt_dive->dive_site_uuid = ds ? ds->uuid : 0;
if (dt_dive->dive_site_uuid == 0)
dt_dive->dive_site_uuid = create_dive_site(buffer, dt_dive->when)->uuid;
dt_dive->dive_site = ds;
if (!dt_dive->dive_site)
dt_dive->dive_site = create_dive_site(buffer, dt_dive->when);
free(locality);
locality = NULL;
free(dive_point);

22
core/dive.c
View file

@ -650,7 +650,7 @@ void selective_copy_dive(const struct dive *s, struct dive *d, struct dive_compo
if (what.visibility)
d->visibility = s->visibility;
if (what.divesite)
d->dive_site_uuid = s->dive_site_uuid;
d->dive_site = s->dive_site;
if (what.tags)
STRUCTURED_LIST_COPY(struct tag_entry, s->tag_list, d->tag_list, copy_tl);
if (what.cylinders)
@ -3503,10 +3503,10 @@ struct dive *merge_dives(const struct dive *a, const struct dive *b, int offset,
join_dive_computers(res, &res->dc, &a->dc, &b->dc, cylinders_map_a, cylinders_map_b, 0);
/* we take the first dive site, unless it's empty */
if (a->dive_site_uuid && !dive_site_is_empty(get_dive_site_by_uuid(a->dive_site_uuid)))
res->dive_site_uuid = a->dive_site_uuid;
if (a->dive_site && !dive_site_is_empty(a->dive_site))
res->dive_site = a->dive_site;
else
res->dive_site_uuid = b->dive_site_uuid;
res->dive_site = b->dive_site;
fixup_dive(res);
return res;
}
@ -4075,12 +4075,12 @@ unsigned int dive_get_picture_count(struct dive *dive)
void dive_set_geodata_from_picture(struct dive *dive, struct picture *picture)
{
struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
struct dive_site *ds = dive->dive_site;
if (!dive_site_has_gps_location(ds) && has_location(&picture->location)) {
if (ds) {
ds->location = picture->location;
} else {
dive->dive_site_uuid = create_dive_site_with_gps("", &picture->location, dive->when)->uuid;
dive->dive_site = create_dive_site_with_gps("", &picture->location, dive->when);
invalidate_dive_cache(dive);
}
}
@ -4333,14 +4333,12 @@ struct dive *get_dive_from_table(int nr, struct dive_table *dt)
struct dive_site *get_dive_site_for_dive(const struct dive *dive)
{
if (dive)
return get_dive_site_by_uuid(dive->dive_site_uuid);
return NULL;
return dive->dive_site;
}
const char *get_dive_country(const struct dive *dive)
{
struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
struct dive_site *ds = dive->dive_site;
if (ds) {
int idx = taxonomy_index_for_category(&ds->taxonomy, TC_COUNTRY);
if (idx >= 0)
@ -4351,7 +4349,7 @@ const char *get_dive_country(const struct dive *dive)
const char *get_dive_location(const struct dive *dive)
{
const struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
const struct dive_site *ds = dive->dive_site;
if (ds && ds->name)
return ds->name;
return NULL;
@ -4432,7 +4430,7 @@ int dive_has_gps_location(const struct dive *dive)
{
if (!dive)
return false;
return dive_site_has_gps_location(get_dive_site_by_uuid(dive->dive_site_uuid));
return dive_site_has_gps_location(dive->dive_site);
}
struct gasmix get_gasmix(const struct dive *dive, const struct divecomputer *dc, int time, const struct event **evp, struct gasmix gasmix)

2
core/dive.h
View file

@ -310,7 +310,7 @@ struct dive {
bool selected;
bool hidden_by_filter;
timestamp_t when;
uint32_t dive_site_uuid;
struct dive_site *dive_site;
char *notes;
char *divemaster, *buddy;
int rating;

8
core/divesite.c
View file

@ -138,7 +138,7 @@ int nr_of_dives_at_dive_site(struct dive_site *ds, bool select_only)
if (!ds)
return 0;
for_each_dive(j, d) {
if (d->dive_site_uuid == ds->uuid && (!select_only || d->selected)) {
if (d->dive_site == ds && (!select_only || d->selected)) {
nr++;
}
}
@ -153,7 +153,7 @@ bool is_dive_site_used(struct dive_site *ds, bool select_only)
if (!ds)
return false;
for_each_dive(j, d) {
if (d->dive_site_uuid == ds->uuid && (!select_only || d->selected)) {
if (d->dive_site == ds && (!select_only || d->selected)) {
found = true;
break;
}
@ -318,9 +318,9 @@ void merge_dive_sites(struct dive_site *ref, struct dive_site *dive_sites[], int
continue;
for_each_dive(curr_dive, d) {
if (d->dive_site_uuid != dive_sites[i]->uuid )
if (d->dive_site != dive_sites[i] )
continue;
d->dive_site_uuid = ref->uuid;
d->dive_site = ref;
invalidate_dive_cache(d);
}
}

4
core/gpslocation.cpp
View file

@ -209,10 +209,10 @@ int GpsLocation::getGpsNum() const
static void copy_gps_location(struct gpsTracker &gps, struct dive *d)
{
struct dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
struct dive_site *ds = d->dive_site;
if (!ds) {
ds = create_dive_site(qPrintable(gps.name), gps.when);
d->dive_site_uuid = ds->uuid;
d->dive_site = ds;
}
ds->location = gps.location;
}

2
core/import-cobalt.c
View file

@ -197,7 +197,7 @@ static int cobalt_dive(void *param, int columns, char **data, char **column)
return 1;
}
sprintf(tmp, "%s / %s", location, location_site);
state->cur_dive->dive_site_uuid = find_or_create_dive_site_with_name(tmp, state->cur_dive->when)->uuid;
state->cur_dive->dive_site = find_or_create_dive_site_with_name(tmp, state->cur_dive->when);
free(tmp);
}
free(location);

2
core/import-divinglog.c
View file

@ -287,7 +287,7 @@ static int divinglog_dive(void *param, int columns, char **data, char **column)
state->cur_dive->when = (time_t)(atol(data[1]));
if (data[2])
state->cur_dive->dive_site_uuid = find_or_create_dive_site_with_name(data[2], state->cur_dive->when)->uuid;
state->cur_dive->dive_site = find_or_create_dive_site_with_name(data[2], state->cur_dive->when);
if (data[3])
utf8_string(data[3], &state->cur_dive->buddy);

2
core/libdivecomputer.c
View file

@ -596,7 +596,7 @@ static void parse_string_field(struct dive *dive, dc_field_string_t *str)
parse_location(line, &location);
if (location.lat.udeg && location.lon.udeg)
dive->dive_site_uuid = create_dive_site_with_gps(str->value, &location, time(NULL))->uuid;
dive->dive_site = create_dive_site_with_gps(str->value, &location, time(NULL));
}
}
#endif

2
core/liquivision.c
View file

@ -227,7 +227,7 @@ static void parse_dives (int log_version, const unsigned char *buf, unsigned int
// now that we have the dive time we can store the divesite
// (we need the dive time to create deterministic uuids)
if (found_divesite) {
dive->dive_site_uuid = find_or_create_dive_site_with_name(location, dive->when)->uuid;
dive->dive_site = find_or_create_dive_site_with_name(location, dive->when);
free(location);
}
//unsigned int end_time = array_uint32_le(buf + ptr);

10
core/load-git.c
View file

@ -159,9 +159,9 @@ static void parse_dive_gps(char *line, struct membuffer *str, void *_dive)
if (!ds) {
ds = get_dive_site_by_gps(&location);
if (!ds)
dive->dive_site_uuid = create_dive_site_with_gps("", &location, dive->when)->uuid;
dive->dive_site = create_dive_site_with_gps("", &location, dive->when);
else
dive->dive_site_uuid = ds->uuid;
dive->dive_site = ds;
} else {
if (dive_site_has_gps_location(ds) && !same_location(&ds->location, &location)) {
const char *coords = printGPSCoords(&location);
@ -183,9 +183,9 @@ static void parse_dive_location(char *line, struct membuffer *str, void *_dive)
if (!ds) {
ds = get_dive_site_by_name(name);
if (!ds)
dive->dive_site_uuid = create_dive_site(name, dive->when)->uuid;
dive->dive_site = create_dive_site(name, dive->when);
else
dive->dive_site_uuid = ds->uuid;
dive->dive_site = ds;
} else {
// we already had a dive site linked to the dive
if (empty_string(ds->name)) {
@ -212,7 +212,7 @@ static void parse_dive_notes(char *line, struct membuffer *str, void *_dive)
{ UNUSED(line); struct dive *dive = _dive; dive->notes = get_utf8(str); }
static void parse_dive_divesiteid(char *line, struct membuffer *str, void *_dive)
{ UNUSED(str); struct dive *dive = _dive; dive->dive_site_uuid = get_hex(line); }
{ UNUSED(str); struct dive *dive = _dive; dive->dive_site = get_dive_site_by_uuid(get_hex(line)); }
/*
* We can have multiple tags in the membuffer. They are separated by

38
core/parse-xml.c
View file

@ -558,6 +558,13 @@ static void hex_value(char *buffer, uint32_t *i)
*i = strtoul(buffer, NULL, 16);
}
static void dive_site(char *buffer, struct dive_site **ds)
{
uint32_t uuid;
hex_value(buffer, &uuid);
*ds = get_dive_site_by_uuid(uuid);
}
static void get_tripflag(char *buffer, tripflag_t *tf)
{
*tf = strcmp(buffer, "NOTRIP") ? TF_NONE : NO_TRIP;
@ -965,10 +972,9 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu
nonmatch("sample", name, buf);
}
static void divinglog_place(char *place, uint32_t *uuid, struct parser_state *state)
static void divinglog_place(char *place, struct dive_site **ds, struct parser_state *state)
{
char buffer[1024];
struct dive_site *ds;
snprintf(buffer, sizeof(buffer),
"%s%s%s%s%s",
@ -977,11 +983,9 @@ static void divinglog_place(char *place, uint32_t *uuid, struct parser_state *st
state->city ? state->city : "",
state->country ? ", " : "",
state->country ? state->country : "");
ds = get_dive_site_by_name(buffer);
if (ds)
*uuid = ds->uuid;
else
*uuid = create_dive_site(buffer, state->cur_dive->when)->uuid;
*ds = get_dive_site_by_name(buffer);
if (!*ds)
*ds = create_dive_site(buffer, state->cur_dive->when);
// TODO: capture the country / city info in the taxonomy instead
free(state->city);
@ -1006,7 +1010,7 @@ static int divinglog_dive_match(struct dive *dive, const char *name, char *buf,
MATCH("names.buddy", utf8_string, &dive->buddy) ||
MATCH("name.country", utf8_string, &state->country) ||
MATCH("name.city", utf8_string, &state->city) ||
MATCH_STATE("name.place", divinglog_place, &dive->dive_site_uuid) ||
MATCH_STATE("name.place", divinglog_place, &dive->dive_site) ||
0;
}
@ -1133,7 +1137,7 @@ static void gps_lat(char *buffer, struct dive *dive)
location.lat = parse_degrees(buffer, &end);
if (!ds) {
dive->dive_site_uuid = create_dive_site_with_gps(NULL, &location, dive->when)->uuid;
dive->dive_site = create_dive_site_with_gps(NULL, &location, dive->when);
} else {
if (ds->location.lat.udeg && ds->location.lat.udeg != location.lat.udeg)
fprintf(stderr, "Oops, changing the latitude of existing dive site id %8x name %s; not good\n", ds->uuid, ds->name ?: "(unknown)");
@ -1149,7 +1153,7 @@ static void gps_long(char *buffer, struct dive *dive)
location.lon = parse_degrees(buffer, &end);
if (!ds) {
dive->dive_site_uuid = create_dive_site_with_gps(NULL, &location, dive->when)->uuid;
dive->dive_site = create_dive_site_with_gps(NULL, &location, dive->when);
} else {
if (ds->location.lon.udeg && ds->location.lon.udeg != location.lon.udeg)
fprintf(stderr, "Oops, changing the longitude of existing dive site id %8x name %s; not good\n", ds->uuid, ds->name ?: "(unknown)");
@ -1174,12 +1178,11 @@ static void gps_location(char *buffer, struct dive_site *ds)
static void gps_in_dive(char *buffer, struct dive *dive, struct parser_state *state)
{
struct dive_site *ds = NULL;
struct dive_site *ds = dive->dive_site;
location_t location;
uint32_t uuid = dive->dive_site_uuid;
parse_location(buffer, &location);
if (uuid == 0) {
if (!ds) {
// check if we have a dive site within 20 meters of that gps fix
ds = get_dive_site_by_gps_proximity(&location, 20);
@ -1187,12 +1190,11 @@ static void gps_in_dive(char *buffer, struct dive *dive, struct parser_state *st
// found a site nearby; in case it turns out this one had a different name let's
// remember the original coordinates so we can create the correct dive site later
state->cur_location = location;
dive->dive_site_uuid = ds->uuid;
dive->dive_site = ds;
} else {
dive->dive_site_uuid = create_dive_site_with_gps("", &location, dive->when)->uuid;
dive->dive_site = create_dive_site_with_gps("", &location, dive->when);
}
} else {
ds = get_dive_site_by_uuid(uuid);
if (dive_site_has_gps_location(ds) &&
has_location(&location) && !same_location(&ds->location, &location)) {
// Houston, we have a problem
@ -1233,7 +1235,7 @@ static void try_to_fill_dive(struct dive *dive, const char *name, char *buf, str
default:
break;
}
if (MATCH("divesiteid", hex_value, &dive->dive_site_uuid))
if (MATCH("divesiteid", dive_site, &dive->dive_site))
return;
if (MATCH("number", get_index, &dive->number))
return;
@ -2120,7 +2122,7 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct dive_table *tabl
/* Measure GPS */
state.cur_location.lat.udeg = (int)((ptr[7] << 24) + (ptr[6] << 16) + (ptr[5] << 8) + (ptr[4] << 0));
state.cur_location.lon.udeg = (int)((ptr[11] << 24) + (ptr[10] << 16) + (ptr[9] << 8) + (ptr[8] << 0));
state.cur_dive->dive_site_uuid = create_dive_site_with_gps("DLF imported", &state.cur_location, state.cur_dive->when)->uuid;
state.cur_dive->dive_site = create_dive_site_with_gps("DLF imported", &state.cur_location, state.cur_dive->when);
break;
default:
break;

12
core/parse.c
View file

@ -163,7 +163,7 @@ void event_end(struct parser_state *state)
bool is_dive(struct parser_state *state)
{
return state->cur_dive &&
(state->cur_dive->dive_site_uuid || state->cur_dive->when || state->cur_dive->dc.samples);
(state->cur_dive->dive_site || state->cur_dive->when || state->cur_dive->dc.samples);
}
void reset_dc_info(struct divecomputer *dc, struct parser_state *state)
@ -417,7 +417,7 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
char *to_free = NULL;
int size = trimspace(buffer);
if(size) {
struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
struct dive_site *ds = dive->dive_site;
if (!ds) {
// if the dive doesn't have a uuid, check if there's already a dive site by this name
ds = get_dive_site_by_name(buffer);
@ -433,10 +433,10 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
// way around
struct dive_site *exact_match = get_dive_site_by_gps_and_name(buffer, &ds->location);
if (exact_match) {
dive->dive_site_uuid = exact_match->uuid;
dive->dive_site = exact_match;
} else {
struct dive_site *newds = create_dive_site(buffer, dive->when);
dive->dive_site_uuid = newds->uuid;
dive->dive_site = newds;
if (has_location(&state->cur_location)) {
// we started this uuid with GPS data, so lets use those
newds->location = state->cur_location;
@ -447,10 +447,10 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
}
} else {
// add the existing dive site to the current dive
dive->dive_site_uuid = ds->uuid;
dive->dive_site = ds;
}
} else {
dive->dive_site_uuid = create_dive_site(buffer, dive->when)->uuid;
dive->dive_site = create_dive_site(buffer, dive->when);
}
}
free(to_free);

12
core/save-git.c
View file

@ -431,17 +431,15 @@ static void create_dive_buffer(struct dive *dive, struct membuffer *b)
SAVE("visibility", visibility);
cond_put_format(dive->tripflag == NO_TRIP, b, "notrip\n");
save_tags(b, dive->tag_list);
cond_put_format(dive->dive_site_uuid && get_dive_site_by_uuid(dive->dive_site_uuid),
b, "divesiteid %08x\n", dive->dive_site_uuid);
if (verbose && dive->dive_site_uuid && !get_dive_site_by_uuid(dive->dive_site_uuid))
fprintf(stderr, "removed reference to non-existant dive site with uuid %08x\n", dive->dive_site_uuid);
cond_put_format(!!dive->dive_site, b, "divesiteid %08x\n", dive->dive_site->uuid);
if (verbose && dive->dive_site)
fprintf(stderr, "removed reference to non-existant dive site with uuid %08x\n", dive->dive_site->uuid);
save_overview(b, dive);
save_cylinder_info(b, dive);
save_weightsystem_info(b, dive);
save_dive_temperature(b, dive);
}
/*
* libgit2 has a "git_treebuilder" concept, but it's broken, and can not
* be used to do a flat tree (like the git "index") nor a recursive tree.
@ -887,8 +885,8 @@ static void save_divesites(git_repository *repo, struct dir *tree)
int j;
struct dive *d;
for_each_dive(j, d) {
if (d->dive_site_uuid == ds->uuid)
d->dive_site_uuid = 0;
if (d->dive_site == ds)
d->dive_site = NULL;
}
delete_dive_site(ds);
i--; // since we just deleted that one

11
core/save-xml.c
View file

@ -483,11 +483,8 @@ void save_one_dive_to_mb(struct membuffer *b, struct dive *dive, bool anonymize)
if (dive->visibility)
put_format(b, " visibility='%d'", dive->visibility);
save_tags(b, dive->tag_list);
if (dive->dive_site_uuid) {
if (get_dive_site_by_uuid(dive->dive_site_uuid) != NULL)
put_format(b, " divesiteid='%8x'", dive->dive_site_uuid);
else if (verbose)
fprintf(stderr, "removed reference to non-existant dive site with uuid %08x\n", dive->dive_site_uuid);
if (dive->dive_site) {
put_format(b, " divesiteid='%8x'", dive->dive_site->uuid);
}
show_date(b, dive->when);
if (dive->dc.duration.seconds > 0)
@ -602,8 +599,8 @@ void save_dives_buffer(struct membuffer *b, const bool select_only, bool anonymi
struct dive_site *ds = get_dive_site(i);
if (dive_site_is_empty(ds) || !is_dive_site_used(ds, false)) {
for_each_dive(j, d) {
if (d->dive_site_uuid == ds->uuid)
d->dive_site_uuid = 0;
if (d->dive_site == ds)
d->dive_site = NULL;
}
delete_dive_site(ds);
i--; // since we just deleted that one

4
core/subsurface-qt/DiveObjectHelper.cpp
View file

@ -112,7 +112,7 @@ QString DiveObjectHelper::location() const
QString DiveObjectHelper::gps() const
{
struct dive_site *ds = get_dive_site_by_uuid(m_dive->dive_site_uuid);
struct dive_site *ds = m_dive->dive_site;
return ds ? QString(printGPSCoords(&ds->location)) : QString();
}
@ -129,7 +129,7 @@ QString DiveObjectHelper::gps_decimal() const
QVariant DiveObjectHelper::dive_site() const
{
return QVariant::fromValue((uintptr_t)get_dive_site_by_uuid(m_dive->dive_site_uuid));
return QVariant::fromValue((uintptr_t)m_dive->dive_site);
}
QString DiveObjectHelper::duration() const

14
core/uemis-downloader.c
View file

@ -993,11 +993,11 @@ static bool process_raw_buffer(device_data_t *devdata, uint32_t deviceid, char *
int divespot_id = atoi(val);
if (divespot_id != -1) {
struct dive_site *ds = create_dive_site("from Uemis", dive->when);
dive->dive_site_uuid = ds->uuid;
dive->dive_site = ds;
uemis_mark_divelocation(dive->dc.diveid, divespot_id, ds);
}
#if UEMIS_DEBUG & 2
fprintf(debugfile, "Created divesite %d for diveid : %d\n", dive->dive_site_uuid, dive->dc.diveid);
fprintf(debugfile, "Created divesite %d for diveid : %d\n", dive->dive_site->uuid, dive->dc.diveid);
#endif
} else if (dive) {
parse_tag(dive, tag, val);
@ -1175,11 +1175,11 @@ static bool load_uemis_divespot(const char *mountpath, int divespot_id)
static void get_uemis_divespot(const char *mountpath, int divespot_id, struct dive *dive)
{
struct dive_site *nds = get_dive_site_by_uuid(dive->dive_site_uuid);
struct dive_site *nds = dive->dive_site;
if (is_divespot_mappable(divespot_id)) {
struct dive_site *ds = get_dive_site_by_divespot_id(divespot_id);
dive->dive_site_uuid = ds ? ds->uuid : 0;
dive->dive_site = ds;
} else if (nds && nds->name && strstr(nds->name,"from Uemis")) {
if (load_uemis_divespot(mountpath, divespot_id)) {
/* get the divesite based on the diveid, this should give us
@ -1195,15 +1195,15 @@ static void get_uemis_divespot(const char *mountpath, int divespot_id, struct di
/* if the uuid's are the same, the new site is a duplicate and can be deleted */
if (nds->uuid != ods->uuid) {
delete_dive_site(nds);
dive->dive_site_uuid = ods->uuid;
dive->dive_site = ods;
}
}
add_to_divespot_mapping(divespot_id, get_dive_site_by_uuid(dive->dive_site_uuid));
add_to_divespot_mapping(divespot_id, dive->dive_site);
} else {
/* if we can't load the dive site details, delete the site we
* created in process_raw_buffer
*/
delete_dive_site(get_dive_site_by_uuid(dive->dive_site_uuid));
delete_dive_site(dive->dive_site);
}
}
}

2
desktop-widgets/divelogexportdialog.cpp
View file

@ -286,7 +286,7 @@ void DiveLogExportDialog::export_TeX(const char *filename, const bool selected_o
struct tm tm;
utc_mkdate(dive->when, &tm);
dive_site *site = get_dive_site_by_uuid(dive->dive_site_uuid);
dive_site *site = dive->dive_site;
QRegExp ct("countrytag: (\\w+)");
QString country;
if (ct.indexIn(site->notes) >= 0)

4
desktop-widgets/locationinformation.cpp
View file

@ -206,7 +206,7 @@ void LocationInformationWidget::acceptChanges()
parseGpsText(ui.diveSiteCoordinates->text(), diveSite->location);
if (dive_site_is_empty(diveSite)) {
LocationInformationModel::instance()->removeRow(get_divesite_idx(diveSite));
displayed_dive.dive_site_uuid = 0;
displayed_dive.dive_site = nullptr;
diveSite = nullptr;
}
mark_divelist_changed(true);
@ -386,7 +386,7 @@ QVariant DiveLocationModel::data(const QModelIndex &index, int role) const
case Qt::DisplayRole:
return new_ds_value[index.row()];
case Qt::ToolTipRole:
return displayed_dive.dive_site_uuid ?
return displayed_dive.dive_site ?
tr("Create a new dive site, copying relevant information from the current dive.") :
tr("Create a new dive site with this name");
case Qt::DecorationRole:

6
desktop-widgets/subsurfacewebservices.cpp
View file

@ -45,7 +45,7 @@ static void copy_gps_location(struct dive *from, struct dive *to)
struct dive_site *gds = get_dive_site_for_dive(from);
if (!ds) {
// simply link to the one created for the fake dive
to->dive_site_uuid = gds->uuid;
to->dive_site = gds;
} else {
ds->latitude = gds->latitude;
ds->longitude = gds->longitude;
@ -198,10 +198,10 @@ bool DivelogsDeWebServices::prepare_dives_for_divelogs(const QString &tempfile,
/* make sure the buffer is empty and add the dive */
mb.len = 0;
struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
struct dive_site *ds = dive->dive_site;
if (ds) {
put_format(&mb, "<divelog><divesites><site uuid='%8x' name='", dive->dive_site_uuid);
put_format(&mb, "<divelog><divesites><site uuid='%8x' name='", dive->dive_site->uuid);
put_quoted(&mb, ds->name, 1, 0);
put_format(&mb, "'");
put_location(&mb, &ds->location, " gps='", "'");

33
desktop-widgets/tab-widgets/maintab.cpp
View file

@ -222,7 +222,7 @@ MainTab::~MainTab()
void MainTab::setCurrentLocationIndex()
{
if (current_dive) {
struct dive_site *ds = get_dive_site_by_uuid(current_dive->dive_site_uuid);
struct dive_site *ds = current_dive->dive_site;
if (ds)
ui.location->setCurrentDiveSite(ds);
else
@ -415,7 +415,7 @@ void MainTab::updateDiveInfo(bool clear)
if (!clear) {
struct dive_site *ds = NULL;
ds = get_dive_site_by_uuid(displayed_dive.dive_site_uuid);
ds = displayed_dive.dive_site;
if (ds) {
ui.location->setCurrentDiveSite(ds);
ui.locationTags->setText(constructLocationTags(&ds->taxonomy, true));
@ -605,7 +605,7 @@ void MainTab::updateDiveInfo(bool clear)
ui.cylinders->view()->hideColumn(CylindersModel::USE);
if (verbose)
qDebug() << "Set the current dive site:" << displayed_dive.dive_site_uuid;
qDebug() << "Set the current dive site:" << displayed_dive.dive_site->uuid;
emit diveSiteChanged();
}
@ -678,8 +678,7 @@ struct dive_site *MainTab::updateDiveSite(struct dive_site *pickedDs, dive *d)
if (!pickedDs)
return 0;
const uint32_t origUuid = d->dive_site_uuid;
struct dive_site *origDs = get_dive_site_by_uuid(origUuid);
struct dive_site *origDs = d->dive_site;
bool createdNewDive = false;
if (pickedDs == origDs)
@ -706,7 +705,7 @@ struct dive_site *MainTab::updateDiveSite(struct dive_site *pickedDs, dive *d)
}
}
d->dive_site_uuid = pickedDs->uuid;
d->dive_site = pickedDs;
qDebug() << "Setting the dive site id on the dive:" << pickedDs->uuid;
return pickedDs;
}
@ -808,8 +807,8 @@ void MainTab::acceptChanges()
if (displayed_dive.watertemp.mkelvin != cd->watertemp.mkelvin)
MODIFY_DIVES(selectedDives, EDIT_VALUE(watertemp.mkelvin));
if (displayed_dive.dive_site_uuid != cd->dive_site_uuid)
MODIFY_DIVES(selectedDives, EDIT_VALUE(dive_site_uuid));
if (displayed_dive.dive_site != cd->dive_site)
MODIFY_DIVES(selectedDives, EDIT_VALUE(dive_site));
// three text fields are somewhat special and are represented as tags
// in the UI - they need somewhat smarter handling
@ -877,10 +876,10 @@ void MainTab::acceptChanges()
}
// update the dive site for the selected dives that had the same dive site as the current dive
struct dive_site *oldDs = get_dive_site_by_uuid(cd->dive_site_uuid);
struct dive_site *newDs = 0;
struct dive_site *oldDs = cd->dive_site;
struct dive_site *newDs = nullptr;
MODIFY_DIVES(selectedDives,
if (mydive->dive_site_uuid == current_dive->dive_site_uuid)
if (mydive->dive_site == current_dive->dive_site)
newDs = updateDiveSite(!newDs ? ui.location->currDiveSite() : newDs, mydive);
);
if (oldDs && !is_dive_site_used(oldDs, false)) {
@ -893,7 +892,7 @@ void MainTab::acceptChanges()
// code below triggers an update of the display without re-initializing displayed_dive
// so let's make sure here that our data is consistent now that we have handled the
// dive sites
displayed_dive.dive_site_uuid = current_dive->dive_site_uuid;
displayed_dive.dive_site = current_dive->dive_site;
// each dive that was selected might have had the temperatures in its active divecomputer changed
// so re-populate the temperatures - easiest way to do this is by calling fixup_dive
@ -1009,7 +1008,7 @@ void MainTab::rejectChanges()
}
// the user could have edited the location and then canceled the edit
// let's get the correct location back in view
MapWidget::instance()->centerOnDiveSite(get_dive_site_by_uuid(displayed_dive.dive_site_uuid));
MapWidget::instance()->centerOnDiveSite(displayed_dive.dive_site);
// show the profile and dive info
MainWindow::instance()->graphics->replot();
MainWindow::instance()->setEnabledToolbar(true);
@ -1325,7 +1324,7 @@ void MainTab::on_location_textChanged()
// we don't want to act on the edit until editing is finished,
// but we want to mark the field so it's obvious it is being edited
QString currentLocation;
struct dive_site *ds = get_dive_site_by_uuid(displayed_dive.dive_site_uuid);
struct dive_site *ds = displayed_dive.dive_site;
if (ds)
currentLocation = ds->name;
if (ui.location->text() != currentLocation)
@ -1338,12 +1337,12 @@ void MainTab::on_location_diveSiteSelected()
return;
if (ui.location->text().isEmpty()) {
displayed_dive.dive_site_uuid = 0;
displayed_dive.dive_site = nullptr;
markChangedWidget(ui.location);
emit diveSiteChanged();
return;
} else {
if (ui.location->currDiveSite() != get_dive_site_by_uuid(displayed_dive.dive_site_uuid)) {
if (ui.location->currDiveSite() != displayed_dive.dive_site) {
markChangedWidget(ui.location);
} else {
QPalette p;
@ -1480,7 +1479,7 @@ void MainTab::showAndTriggerEditSelective(struct dive_components what)
if (what.visibility)
ui.visibility->setCurrentStars(displayed_dive.visibility);
if (what.divesite)
ui.location->setCurrentDiveSite(get_dive_site_by_uuid(displayed_dive.dive_site_uuid));
ui.location->setCurrentDiveSite(displayed_dive.dive_site);
if (what.tags) {
ui.tagWidget->setText(get_taglist_string(displayed_dive.tag_list));
}

14
map-widget/qml/MapWidget.qml
View file

@ -56,26 +56,26 @@ Item {
anchorPoint.x: 0
anchorPoint.y: mapItemImage.height
coordinate: model.coordinate
z: mapHelper.model.selectedUuid === model.uuid ? mapHelper.model.count - 1 : 0
z: mapHelper.model.selectedDs === model.divesite ? mapHelper.model.count - 1 : 0
sourceItem: Image {
id: mapItemImage
source: "qrc:///dive-location-marker" + (mapHelper.model.selectedUuid === model.uuid ? "-selected" : (mapHelper.editMode ? "-inactive" : "")) + "-icon"
source: "qrc:///dive-location-marker" + (mapHelper.model.selectedDs === model.divesite ? "-selected" : (mapHelper.editMode ? "-inactive" : "")) + "-icon"
SequentialAnimation {
id: mapItemImageAnimation
PropertyAnimation { target: mapItemImage; property: "scale"; from: 1.0; to: 0.7; duration: 120 }
PropertyAnimation { target: mapItemImage; property: "scale"; from: 0.7; to: 1.0; duration: 80 }
}
MouseArea {
drag.target: (mapHelper.editMode && mapHelper.model.selectedUuid === model.uuid) ? mapItem : undefined
drag.target: (mapHelper.editMode && mapHelper.model.selectedDs === model.divesite) ? mapItem : undefined
anchors.fill: parent
onClicked: {
if (!mapHelper.editMode)
mapHelper.model.setSelectedUuid(model.uuid, true)
mapHelper.model.setSelected(model.divesite, true)
}
onDoubleClicked: map.doubleClickHandler(mapItem.coordinate)
onReleased: {
if (mapHelper.editMode && mapHelper.model.selectedUuid === model.uuid) {
mapHelper.updateCurrentDiveSiteCoordinatesFromMap(mapHelper.model.selectedUuid, mapItem.coordinate)
if (mapHelper.editMode && mapHelper.model.selectedDs === model.divesite) {
mapHelper.updateCurrentDiveSiteCoordinatesFromMap(mapHelper.model.selectedDs, mapItem.coordinate)
}
}
}
@ -94,7 +94,7 @@ Item {
id: mapItemText
text: model.name
font.pointSize: 11.0
color: mapHelper.model.selectedUuid === model.uuid ? "white" : "lightgrey"
color: mapHelper.model.selectedDs === model.divesite ? "white" : "lightgrey"
}
}
}

25
map-widget/qmlmapwidgethelper.cpp
View file

@ -41,11 +41,11 @@ void MapWidgetHelper::centerOnDiveSite(struct dive_site *ds)
{
if (!ds || !dive_site_has_gps_location(ds)) {
// dive site with no GPS
m_mapLocationModel->setSelectedUuid(ds ? ds->uuid : 0, false);
m_mapLocationModel->setSelected(ds, false);
QMetaObject::invokeMethod(m_map, "deselectMapLocation");
} else {
// dive site with GPS
m_mapLocationModel->setSelectedUuid(ds->uuid, false);
m_mapLocationModel->setSelected(ds, false);
QGeoCoordinate dsCoord (ds->location.lat.udeg * 0.000001, ds->location.lon.udeg * 0.000001);
QMetaObject::invokeMethod(m_map, "centerOnCoordinate", Q_ARG(QVariant, QVariant::fromValue(dsCoord)));
}
@ -72,15 +72,14 @@ void MapWidgetHelper::centerOnSelectedDiveSite()
if (selDS.isEmpty()) {
// no selected dives with GPS coordinates
m_mapLocationModel->setSelectedUuid(0, false);
m_mapLocationModel->setSelected(nullptr, false);
QMetaObject::invokeMethod(m_map, "deselectMapLocation");
} else if (selDS.size() == 1) {
centerOnDiveSite(selDS[0]);
} else if (selDS.size() > 1) {
/* more than one dive sites with GPS selected.
* find the most top-left and bottom-right dive sites on the map coordinate system. */
m_mapLocationModel->setSelectedUuid(selDS[0]->uuid, false);
m_mapLocationModel->setSelected(selDS[0], false);
qreal minLat = 0.0, minLon = 0.0, maxLat = 0.0, maxLon = 0.0;
bool start = true;
for(struct dive_site *dss: selDS) {
@ -143,7 +142,7 @@ void MapWidgetHelper::reloadMapLocations()
if (dsCoord.distanceTo(coord) < MIN_DISTANCE_BETWEEN_DIVE_SITES_M)
continue;
}
location = new MapLocation(ds->uuid, dsCoord, name);
location = new MapLocation(ds, dsCoord, name);
locationList.append(location);
locations.append(ds);
locationNameMap[name] = location;
@ -169,7 +168,7 @@ void MapWidgetHelper::selectedLocationChanged(MapLocation *location)
m_selectedDiveIds.append(idx);
}
#else // the mobile version doesn't support multi-dive selection
if (ds->uuid == location->uuid())
if (ds == location->divesite())
m_selectedDiveIds.append(dive->id); // use id here instead of index
}
int last; // get latest dive chronologically
@ -200,7 +199,7 @@ void MapWidgetHelper::selectVisibleLocations()
Q_ARG(QGeoCoordinate, dsCoord));
if (!qIsNaN(point.x())) {
if (!selectedFirst) {
m_mapLocationModel->setSelectedUuid(ds->uuid, false);
m_mapLocationModel->setSelected(ds, false);
selectedFirst = true;
}
#ifndef SUBSURFACE_MOBILE // indexes on desktop
@ -262,9 +261,9 @@ void MapWidgetHelper::copyToClipboardCoordinates(QGeoCoordinate coord, bool form
prefs.coordinates_traditional = savep;
}
void MapWidgetHelper::updateCurrentDiveSiteCoordinatesFromMap(quint32 uuid, QGeoCoordinate coord)
void MapWidgetHelper::updateCurrentDiveSiteCoordinatesFromMap(struct dive_site *ds, QGeoCoordinate coord)
{
MapLocation *loc = m_mapLocationModel->getMapLocationForUuid(uuid);
MapLocation *loc = m_mapLocationModel->getMapLocation(ds);
if (loc)
loc->setCoordinate(coord);
location_t location = mk_location(coord);
@ -278,7 +277,7 @@ void MapWidgetHelper::updateDiveSiteCoordinates(struct dive_site *ds, const loca
const qreal latitude_r = location.lat.udeg * 0.000001;
const qreal longitude_r = location.lon.udeg * 0.000001;
QGeoCoordinate coord(latitude_r, longitude_r);
m_mapLocationModel->updateMapLocationCoordinates(ds->uuid, coord);
m_mapLocationModel->updateMapLocationCoordinates(ds, coord);
QMetaObject::invokeMethod(m_map, "centerOnCoordinate", Q_ARG(QVariant, QVariant::fromValue(coord)));
}
@ -295,12 +294,12 @@ void MapWidgetHelper::enterEditMode(struct dive_site *ds)
return;
m_editMode = true;
MapLocation *exists = m_mapLocationModel->getMapLocationForUuid(ds->uuid);
MapLocation *exists = m_mapLocationModel->getMapLocation(ds);
QGeoCoordinate coord;
// if divesite doesn't exist in the model, add a new MapLocation.
if (!exists) {
coord = m_map->property("center").value<QGeoCoordinate>();
m_mapLocationModel->add(new MapLocation(ds->uuid, coord, QString(ds->name)));
m_mapLocationModel->add(new MapLocation(ds, coord, QString(ds->name)));
} else {
coord = exists->coordinate();
}

2
map-widget/qmlmapwidgethelper.h
View file

@ -34,7 +34,7 @@ public:
Q_INVOKABLE void reloadMapLocations();
Q_INVOKABLE void copyToClipboardCoordinates(QGeoCoordinate coord, bool formatTraditional);
Q_INVOKABLE void calculateSmallCircleRadius(QGeoCoordinate coord);
Q_INVOKABLE void updateCurrentDiveSiteCoordinatesFromMap(quint32 uuid, QGeoCoordinate coord);
Q_INVOKABLE void updateCurrentDiveSiteCoordinatesFromMap(struct dive_site *ds, QGeoCoordinate coord);
Q_INVOKABLE void selectVisibleLocations();
void updateDiveSiteCoordinates(struct dive_site *ds, const location_t &);
void enterEditMode(struct dive_site *ds);

4
mobile-widgets/qmlmanager.cpp
View file

@ -760,7 +760,7 @@ static void setupDivesite(struct dive *d, struct dive_site *ds, double lat, doub
if (ds) {
ds->location = location;
} else {
d->dive_site_uuid = create_dive_site_with_gps(locationtext, &location, d->when)->uuid;
d->dive_site = create_dive_site_with_gps(locationtext, &location, d->when);
}
}
@ -881,7 +881,7 @@ bool QMLManager::checkLocation(DiveObjectHelper *myDive, struct dive *d, QString
if (!ds && !location.isEmpty()) {
ds = create_dive_site(qPrintable(location), d->when);
}
d->dive_site_uuid = ds ? ds->uuid : 0;
d->dive_site = ds;
}
// now make sure that the GPS coordinates match - if the user changed the name but not
// the GPS coordinates, this still does the right thing as the now new dive site will

2
qt-models/filtermodels.cpp
View file

@ -589,7 +589,7 @@ void MultiFilterSortModel::divesDeleted(const QVector<dive *> &dives)
bool MultiFilterSortModel::showDive(const struct dive *d) const
{
if (curr_dive_site) {
dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
dive_site *ds = d->dive_site;
if (!ds)
return false;
return same_string(ds->name, curr_dive_site->name) || ds->uuid == curr_dive_site->uuid;

67
qt-models/maplocationmodel.cpp
View file

@ -1,26 +1,31 @@
// SPDX-License-Identifier: GPL-2.0
#include <QDebug>
#include "maplocationmodel.h"
#include "core/divesite.h"
const char *MapLocation::PROPERTY_NAME_COORDINATE = "coordinate";
const char *MapLocation::PROPERTY_NAME_UUID = "uuid";
const char *MapLocation::PROPERTY_NAME_DIVESITE = "divesite";
const char *MapLocation::PROPERTY_NAME_NAME = "name";
MapLocation::MapLocation()
MapLocation::MapLocation() : m_ds(nullptr)
{
m_uuid = 0;
}
MapLocation::MapLocation(quint32 uuid, QGeoCoordinate coord, QString name) :
m_uuid(uuid), m_coordinate(coord), m_name(name)
MapLocation::MapLocation(struct dive_site *ds, QGeoCoordinate coord, QString name) :
m_ds(ds), m_coordinate(coord), m_name(name)
{
}
QVariant MapLocation::getRole(int role) const
{
switch (role) {
case Roles::RoleUuid:
return QVariant::fromValue(m_uuid);
case Roles::RoleDivesite:
// To pass the dive site as an opaque object to QML, we convert it to uintptr_t.
// This type is guaranteed to hold a full pointer, therefore false equivalence
// owing to truncation can happen. The more logical type would of course be void *,
// but in tests all QVariant<void *> compared equal. It is unclear whether this is
// a bug in a certain version of QML or QML is inredibly broken by design.
return QVariant::fromValue((uintptr_t)m_ds);
case Roles::RoleCoordinate:
return QVariant::fromValue(m_coordinate);
case Roles::RoleName:
@ -46,17 +51,23 @@ void MapLocation::setCoordinateNoEmit(QGeoCoordinate coord)
m_coordinate = coord;
}
quint32 MapLocation::uuid()
struct dive_site *MapLocation::divesite()
{
return m_uuid;
return m_ds;
}
MapLocationModel::MapLocationModel(QObject *parent) : QAbstractListModel(parent)
QVariant MapLocation::divesiteVariant()
{
m_roles[MapLocation::Roles::RoleUuid] = MapLocation::PROPERTY_NAME_UUID;
// See comment on uintptr_t above
return QVariant::fromValue((uintptr_t)m_ds);
}
MapLocationModel::MapLocationModel(QObject *parent) : QAbstractListModel(parent),
m_selectedDs(nullptr)
{
m_roles[MapLocation::Roles::RoleDivesite] = MapLocation::PROPERTY_NAME_DIVESITE;
m_roles[MapLocation::Roles::RoleCoordinate] = MapLocation::PROPERTY_NAME_COORDINATE;
m_roles[MapLocation::Roles::RoleName] = MapLocation::PROPERTY_NAME_NAME;
m_selectedUuid = 0;
}
MapLocationModel::~MapLocationModel()
@ -120,36 +131,44 @@ void MapLocationModel::clear()
endRemoveRows();
}
void MapLocationModel::setSelectedUuid(QVariant uuid, QVariant fromClick)
void MapLocationModel::setSelected(struct dive_site *ds, bool fromClick)
{
m_selectedUuid = qvariant_cast<quint32>(uuid);
m_selectedDs = ds;
emit selectedDsChanged();
if (fromClick)
emit selectedLocationChanged(getMapLocation(m_selectedDs));
}
void MapLocationModel::setSelected(QVariant divesite, QVariant fromClick)
{
// See comment on uintptr_t above
struct dive_site *ds = (struct dive_site *)qvariant_cast<uintptr_t>(divesite);
const bool fromClickBool = qvariant_cast<bool>(fromClick);
emit selectedUuidChanged();
if (fromClickBool)
emit selectedLocationChanged(getMapLocationForUuid(m_selectedUuid));
setSelected(ds, fromClickBool);
}
quint32 MapLocationModel::selectedUuid()
QVariant MapLocationModel::selectedDs()
{
return m_selectedUuid;
// See comment on uintptr_t above
return QVariant::fromValue((uintptr_t)m_selectedDs);
}
MapLocation *MapLocationModel::getMapLocationForUuid(quint32 uuid)
MapLocation *MapLocationModel::getMapLocation(const struct dive_site *ds)
{
MapLocation *location;
foreach(location, m_mapLocations) {
if (uuid == location->uuid())
if (ds == location->divesite())
return location;
}
return NULL;
}
void MapLocationModel::updateMapLocationCoordinates(quint32 uuid, QGeoCoordinate coord)
void MapLocationModel::updateMapLocationCoordinates(const struct dive_site *ds, QGeoCoordinate coord)
{
MapLocation *location;
int row = 0;
foreach(location, m_mapLocations) {
if (uuid == location->uuid()) {
if (ds == location->divesite()) {
location->setCoordinateNoEmit(coord);
emit dataChanged(createIndex(0, row), createIndex(0, row));
return;
@ -157,5 +176,5 @@ void MapLocationModel::updateMapLocationCoordinates(quint32 uuid, QGeoCoordinate
row++;
}
// should not happen, as this should be called only when editing an existing marker
qWarning() << "MapLocationModel::updateMapLocationCoordinates(): cannot find MapLocation for uuid:" << uuid;
qWarning() << "MapLocationModel::updateMapLocationCoordinates(): cannot find MapLocation for uuid:" << (ds ? ds->uuid : 0);
}

28
qt-models/maplocationmodel.h
View file

@ -12,32 +12,33 @@
class MapLocation : public QObject
{
Q_OBJECT
Q_PROPERTY(quint32 uuid READ uuid)
Q_PROPERTY(QVariant divesite READ divesiteVariant)
Q_PROPERTY(QGeoCoordinate coordinate READ coordinate WRITE setCoordinate NOTIFY coordinateChanged)
Q_PROPERTY(QString name MEMBER m_name)
public:
static const char *PROPERTY_NAME_COORDINATE;
static const char *PROPERTY_NAME_UUID;
static const char *PROPERTY_NAME_DIVESITE;
static const char *PROPERTY_NAME_NAME;
explicit MapLocation();
explicit MapLocation(quint32 uuid, QGeoCoordinate coord, QString name);
explicit MapLocation(struct dive_site *ds, QGeoCoordinate coord, QString name);
QVariant getRole(int role) const;
QGeoCoordinate coordinate();
void setCoordinate(QGeoCoordinate coord);
void setCoordinateNoEmit(QGeoCoordinate coord);
quint32 uuid();
QVariant divesiteVariant();
struct dive_site *divesite();
enum Roles {
RoleUuid = Qt::UserRole + 1,
RoleDivesite = Qt::UserRole + 1,
RoleCoordinate,
RoleName
};
private:
quint32 m_uuid;
struct dive_site *m_ds;
QGeoCoordinate m_coordinate;
QString m_name;
@ -49,7 +50,7 @@ class MapLocationModel : public QAbstractListModel
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
Q_PROPERTY(quint32 selectedUuid READ selectedUuid NOTIFY selectedUuidChanged)
Q_PROPERTY(QVariant selectedDs READ selectedDs NOTIFY selectedDsChanged)
public:
MapLocationModel(QObject *parent = NULL);
@ -62,10 +63,11 @@ public:
void add(MapLocation *);
void addList(QVector<MapLocation *>);
void clear();
MapLocation *getMapLocationForUuid(quint32 uuid);
void updateMapLocationCoordinates(quint32 uuid, QGeoCoordinate coord);
Q_INVOKABLE void setSelectedUuid(QVariant uuid, QVariant fromClick = true);
quint32 selectedUuid();
MapLocation *getMapLocation(const struct dive_site *ds);
void updateMapLocationCoordinates(const struct dive_site *ds, QGeoCoordinate coord);
void setSelected(struct dive_site *ds, bool fromClick = true);
Q_INVOKABLE void setSelected(QVariant divesite, QVariant fromClick = true);
QVariant selectedDs();
protected:
QHash<int, QByteArray> roleNames() const override;
@ -73,11 +75,11 @@ protected:
private:
QVector<MapLocation *> m_mapLocations;
QHash<int, QByteArray> m_roles;
quint32 m_selectedUuid;
struct dive_site *m_selectedDs;
signals:
void countChanged(int c);
void selectedUuidChanged();
void selectedDsChanged();
void selectedLocationChanged(MapLocation *);
};

12
smtk-import/smartrak.c
View file

@ -315,7 +315,7 @@ static void smtk_wreck_site(MdbHandle *mdb, char *site_idx, struct dive_site *ds
* Location format:
* | Idx | Text | Province | Country | Depth |
*/
static void smtk_build_location(MdbHandle *mdb, char *idx, timestamp_t when, uint32_t *location)
static void smtk_build_location(MdbHandle *mdb, char *idx, timestamp_t when, struct dive_site **location)
{
MdbTableDef *table;
MdbColumn *col[MDB_MAX_COLS];
@ -376,13 +376,11 @@ static void smtk_build_location(MdbHandle *mdb, char *idx, timestamp_t when, uin
ds = get_dive_site_by_name(str);
if (!ds) {
if (!has_location(&loc))
*location = create_dive_site(str, when)->uuid;
ds = create_dive_site(str, when);
else
*location = create_dive_site_with_gps(str, &loc, when)->uuid;
ds = get_dive_site_by_uuid(*location);
} else {
*location = ds->uuid;
ds = create_dive_site_with_gps(str, &loc, when);
}
*location = ds;
smtk_free(bound_values, table->num_cols);
/* Insert site notes */
@ -1065,7 +1063,7 @@ void smartrak_import(const char *file, struct dive_table *divetable)
smtkdive->visibility = strtod(col[coln(VISIBILITY)]->bind_ptr, NULL) > 25 ? 5 : lrint(strtod(col[13]->bind_ptr, NULL) / 5);
smtkdive->weightsystem[0].weight.grams = lrint(strtod(col[coln(WEIGHT)]->bind_ptr, NULL) * 1000);
smtkdive->suit = copy_string(suit_list[atoi(col[coln(SUITIDX)]->bind_ptr) - 1]);
smtk_build_location(mdb_clon, col[coln(SITEIDX)]->bind_ptr, smtkdive->when, &smtkdive->dive_site_uuid);
smtk_build_location(mdb_clon, col[coln(SITEIDX)]->bind_ptr, smtkdive->when, &smtkdive->dive_site);
smtkdive->buddy = smtk_locate_buddy(mdb_clon, col[0]->bind_ptr, buddy_list);
smtk_parse_relations(mdb_clon, smtkdive, col[0]->bind_ptr, "Type", "TypeRelation", type_list, true);
smtk_parse_relations(mdb_clon, smtkdive, col[0]->bind_ptr, "Activity", "ActivityRelation", activity_list, false);