2017-04-27 18:26:05 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2016-04-05 05:02:03 +00:00
|
|
|
#include "desktop-widgets/simplewidgets.h"
|
|
|
|
#include "qt-models/filtermodels.h"
|
2013-06-04 21:51:27 +00:00
|
|
|
|
2013-09-27 15:52:01 +00:00
|
|
|
#include <QProcess>
|
2014-02-13 15:43:55 +00:00
|
|
|
#include <QFileDialog>
|
2014-04-25 17:39:40 +00:00
|
|
|
#include <QShortcut>
|
2014-06-19 18:42:05 +00:00
|
|
|
#include <QCalendarWidget>
|
2015-02-09 20:58:40 +00:00
|
|
|
#include <QKeyEvent>
|
2015-02-11 15:58:23 +00:00
|
|
|
#include <QAction>
|
2015-11-16 04:56:24 +00:00
|
|
|
#include <QDesktopServices>
|
|
|
|
#include <QToolTip>
|
2019-02-02 14:42:57 +00:00
|
|
|
#include <QClipboard>
|
2015-01-17 09:43:52 +00:00
|
|
|
|
2016-04-05 05:02:03 +00:00
|
|
|
#include "core/file.h"
|
2019-03-04 22:20:29 +00:00
|
|
|
#include "core/divesite.h"
|
2016-04-05 05:02:03 +00:00
|
|
|
#include "desktop-widgets/mainwindow.h"
|
2018-06-03 20:15:19 +00:00
|
|
|
#include "core/qthelper.h"
|
2014-11-25 20:22:02 +00:00
|
|
|
#include "libdivecomputer/parser.h"
|
2016-04-05 05:02:03 +00:00
|
|
|
#include "desktop-widgets/divelistview.h"
|
2019-11-24 14:02:34 +00:00
|
|
|
#include "core/selection.h"
|
2015-09-03 18:56:37 +00:00
|
|
|
#include "profile-widget/profilewidget2.h"
|
2019-11-13 14:08:40 +00:00
|
|
|
#include "commands/command.h"
|
2018-03-15 19:21:40 +00:00
|
|
|
#include "core/metadata.h"
|
2019-05-30 16:29:36 +00:00
|
|
|
#include "core/tag.h"
|
2019-07-15 21:44:39 +00:00
|
|
|
#include "core/divelist.h" // for mark_divelist_changed
|
2013-06-17 16:41:00 +00:00
|
|
|
|
2013-06-04 21:51:27 +00:00
|
|
|
double MinMaxAvgWidget::average() const
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
return avgValue->text().toDouble();
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
double MinMaxAvgWidget::maximum() const
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
return maxValue->text().toDouble();
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
2019-05-31 17:28:45 +00:00
|
|
|
|
2013-06-04 21:51:27 +00:00
|
|
|
double MinMaxAvgWidget::minimum() const
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
return minValue->text().toDouble();
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
2019-05-31 17:28:45 +00:00
|
|
|
MinMaxAvgWidget::MinMaxAvgWidget(QWidget *parent) : QWidget(parent)
|
2014-01-16 04:50:56 +00:00
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgIco = new QLabel(this);
|
|
|
|
avgIco->setPixmap(QIcon(":value-average-icon").pixmap(16, 16));
|
|
|
|
avgIco->setToolTip(gettextFromC::tr("Average"));
|
|
|
|
minIco = new QLabel(this);
|
|
|
|
minIco->setPixmap(QIcon(":value-minimum-icon").pixmap(16, 16));
|
|
|
|
minIco->setToolTip(gettextFromC::tr("Minimum"));
|
|
|
|
maxIco = new QLabel(this);
|
|
|
|
maxIco->setPixmap(QIcon(":value-maximum-icon").pixmap(16, 16));
|
|
|
|
maxIco->setToolTip(gettextFromC::tr("Maximum"));
|
|
|
|
avgValue = new QLabel(this);
|
|
|
|
minValue = new QLabel(this);
|
|
|
|
maxValue = new QLabel(this);
|
2013-11-30 17:18:02 +00:00
|
|
|
|
2019-05-31 17:28:45 +00:00
|
|
|
QGridLayout *formLayout = new QGridLayout;
|
|
|
|
formLayout->addWidget(maxIco, 0, 0);
|
|
|
|
formLayout->addWidget(maxValue, 0, 1);
|
|
|
|
formLayout->addWidget(avgIco, 1, 0);
|
|
|
|
formLayout->addWidget(avgValue, 1, 1);
|
|
|
|
formLayout->addWidget(minIco, 2, 0);
|
|
|
|
formLayout->addWidget(minValue, 2, 1);
|
|
|
|
setLayout(formLayout);
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MinMaxAvgWidget::clear()
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgValue->setText(QString());
|
|
|
|
maxValue->setText(QString());
|
|
|
|
minValue->setText(QString());
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MinMaxAvgWidget::setAverage(double average)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgValue->setText(QString::number(average));
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MinMaxAvgWidget::setMaximum(double maximum)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
maxValue->setText(QString::number(maximum));
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
void MinMaxAvgWidget::setMinimum(double minimum)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
minValue->setText(QString::number(minimum));
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void MinMaxAvgWidget::setAverage(const QString &average)
|
2013-06-04 21:51:27 +00:00
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgValue->setText(average);
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void MinMaxAvgWidget::setMaximum(const QString &maximum)
|
2013-06-04 21:51:27 +00:00
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
maxValue->setText(maximum);
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void MinMaxAvgWidget::setMinimum(const QString &minimum)
|
2013-06-04 21:51:27 +00:00
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
minValue->setText(minimum);
|
2013-06-04 21:51:27 +00:00
|
|
|
}
|
2013-06-17 16:41:00 +00:00
|
|
|
|
2014-05-30 22:46:55 +00:00
|
|
|
void MinMaxAvgWidget::overrideMinToolTipText(const QString &newTip)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
minIco->setToolTip(newTip);
|
|
|
|
minValue->setToolTip(newTip);
|
2014-11-17 18:40:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MinMaxAvgWidget::overrideAvgToolTipText(const QString &newTip)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgIco->setToolTip(newTip);
|
|
|
|
avgValue->setToolTip(newTip);
|
2014-05-30 22:46:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MinMaxAvgWidget::overrideMaxToolTipText(const QString &newTip)
|
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
maxIco->setToolTip(newTip);
|
|
|
|
maxValue->setToolTip(newTip);
|
2014-05-30 22:46:55 +00:00
|
|
|
}
|
|
|
|
|
2019-05-31 17:28:45 +00:00
|
|
|
void MinMaxAvgWidget::setAvgVisibility(bool visible)
|
2017-01-10 15:56:55 +00:00
|
|
|
{
|
2019-05-31 17:28:45 +00:00
|
|
|
avgIco->setVisible(visible);
|
|
|
|
avgValue->setVisible(visible);
|
2017-01-10 15:56:55 +00:00
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
RenumberDialog *RenumberDialog::instance()
|
2013-06-17 16:41:00 +00:00
|
|
|
{
|
2014-02-28 04:09:57 +00:00
|
|
|
static RenumberDialog *self = new RenumberDialog(MainWindow::instance());
|
2013-06-17 16:41:00 +00:00
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2014-05-19 21:11:32 +00:00
|
|
|
void RenumberDialog::renumberOnlySelected(bool selected)
|
|
|
|
{
|
|
|
|
if (selected && amount_selected == 1)
|
2016-12-27 21:10:18 +00:00
|
|
|
ui.renumberText->setText(tr("New number"));
|
2014-05-19 21:11:32 +00:00
|
|
|
else
|
2016-12-27 21:10:18 +00:00
|
|
|
ui.renumberText->setText(tr("New starting number"));
|
|
|
|
|
|
|
|
if (selected)
|
|
|
|
ui.groupBox->setTitle(tr("Renumber selected dives"));
|
|
|
|
else
|
|
|
|
ui.groupBox->setTitle(tr("Renumber all dives"));
|
|
|
|
|
2014-05-19 21:11:32 +00:00
|
|
|
selectedOnly = selected;
|
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void RenumberDialog::buttonClicked(QAbstractButton *button)
|
2013-06-17 16:41:00 +00:00
|
|
|
{
|
2015-02-28 04:42:37 +00:00
|
|
|
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
|
Undo: fix multi-level undo of delete-dive and remove-dive-from-trip
The original undo-code was fundamentally broken. Not only did it leak
resources (copied trips were never freed), it also kept references
to trips or dives that could be changed by other commands. Thus,
anything more than a single undo could lead to crashes.
Two ways of fixing this were considered
1) Don't store pointers, but unique dive-ids and trip-ids.
Whereas such unique ids exist for dives, they would have to be
implemented for trips.
2) Don't free objects in the backend.
Instead, take ownership of deleted objects in the undo-object.
Thus, all references in previous undo-objects are guaranteed to
still exist (unless the objects are deleted elsewhere).
After some contemplation, the second method was chosen, because
it is significantly less intrusive. While touching the undo-objects,
clearly separate backend from ui-code, such that they can ultimately
be reused for mobile.
Note that if other parts of the code delete dives, crashes can still
be provoked. Notable examples are split/merge dives. These will have
to be fixed later. Nevertheless, the new code is a significant
improvement over the old state.
While touching the code, implement proper translation string based
on Qt's plural-feature (using %n).
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-07-19 12:44:27 +00:00
|
|
|
// we remember a list from dive uuid to a new number
|
2018-07-30 13:55:29 +00:00
|
|
|
QVector<QPair<dive *, int>> renumberedDives;
|
2015-02-28 04:42:37 +00:00
|
|
|
int i;
|
2015-06-15 04:49:34 +00:00
|
|
|
int newNr = ui.spinBox->value();
|
2018-07-30 13:55:29 +00:00
|
|
|
struct dive *d;
|
|
|
|
for_each_dive (i, d) {
|
|
|
|
if (!selectedOnly || d->selected) {
|
|
|
|
invalidate_dive_cache(d);
|
|
|
|
renumberedDives.append({ d, newNr++ });
|
2016-04-03 22:31:59 +00:00
|
|
|
}
|
2015-02-28 04:42:37 +00:00
|
|
|
}
|
2018-07-23 21:41:23 +00:00
|
|
|
Command::renumberDives(renumberedDives);
|
2015-02-28 04:42:37 +00:00
|
|
|
}
|
2013-06-17 16:41:00 +00:00
|
|
|
}
|
|
|
|
|
2014-05-19 21:11:32 +00:00
|
|
|
RenumberDialog::RenumberDialog(QWidget *parent) : QDialog(parent), selectedOnly(false)
|
2014-11-25 20:22:02 +00:00
|
|
|
{
|
|
|
|
ui.setupUi(this);
|
|
|
|
connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
|
|
|
|
QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
|
|
|
|
connect(close, SIGNAL(activated()), this, SLOT(close()));
|
|
|
|
QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
|
|
|
|
connect(quit, SIGNAL(activated()), parent, SLOT(close()));
|
|
|
|
}
|
|
|
|
|
|
|
|
SetpointDialog *SetpointDialog::instance()
|
|
|
|
{
|
|
|
|
static SetpointDialog *self = new SetpointDialog(MainWindow::instance());
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetpointDialog::setpointData(struct divecomputer *divecomputer, int second)
|
|
|
|
{
|
|
|
|
dc = divecomputer;
|
2014-12-15 22:33:16 +00:00
|
|
|
time = second < 0 ? 0 : second;
|
2014-11-25 20:22:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SetpointDialog::buttonClicked(QAbstractButton *button)
|
|
|
|
{
|
2016-04-03 22:31:59 +00:00
|
|
|
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole && dc) {
|
2018-10-13 09:52:08 +00:00
|
|
|
add_event(dc, time, SAMPLE_EVENT_PO2, 0, (int)(1000.0 * ui.spinbox->value()),
|
2017-02-21 17:04:00 +00:00
|
|
|
QT_TRANSLATE_NOOP("gettextFromC", "SP change"));
|
2016-04-03 22:31:59 +00:00
|
|
|
invalidate_dive_cache(current_dive);
|
|
|
|
}
|
2014-11-26 13:22:41 +00:00
|
|
|
mark_divelist_changed(true);
|
2018-10-12 13:07:40 +00:00
|
|
|
MainWindow::instance()->graphics->replot();
|
2014-11-25 20:22:02 +00:00
|
|
|
}
|
|
|
|
|
2017-12-24 16:39:21 +00:00
|
|
|
SetpointDialog::SetpointDialog(QWidget *parent) : QDialog(parent),
|
2017-12-28 18:32:05 +00:00
|
|
|
dc(0), time(0)
|
2013-06-17 16:41:00 +00:00
|
|
|
{
|
2013-10-03 18:54:25 +00:00
|
|
|
ui.setupUi(this);
|
2014-02-28 04:09:57 +00:00
|
|
|
connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
|
2014-04-25 18:32:02 +00:00
|
|
|
QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
|
|
|
|
connect(close, SIGNAL(activated()), this, SLOT(close()));
|
|
|
|
QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
|
|
|
|
connect(quit, SIGNAL(activated()), parent, SLOT(close()));
|
2013-06-17 16:41:00 +00:00
|
|
|
}
|
2013-09-27 15:52:01 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
ShiftTimesDialog *ShiftTimesDialog::instance()
|
2013-11-18 13:53:05 +00:00
|
|
|
{
|
2014-02-28 04:09:57 +00:00
|
|
|
static ShiftTimesDialog *self = new ShiftTimesDialog(MainWindow::instance());
|
2013-11-18 13:53:05 +00:00
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void ShiftTimesDialog::buttonClicked(QAbstractButton *button)
|
2013-11-18 13:53:05 +00:00
|
|
|
{
|
|
|
|
int amount;
|
|
|
|
|
2014-01-16 04:50:56 +00:00
|
|
|
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
|
2013-11-18 13:53:05 +00:00
|
|
|
amount = ui.timeEdit->time().hour() * 3600 + ui.timeEdit->time().minute() * 60;
|
|
|
|
if (ui.backwards->isChecked())
|
|
|
|
amount *= -1;
|
2013-11-18 18:00:39 +00:00
|
|
|
if (amount != 0) {
|
|
|
|
// DANGER, DANGER - this could get our dive_table unsorted...
|
2015-02-14 17:12:05 +00:00
|
|
|
int i;
|
2018-07-22 07:23:47 +00:00
|
|
|
struct dive *d;
|
|
|
|
QVector<dive *> affectedDives;
|
|
|
|
for_each_dive (i, d) {
|
|
|
|
if (d->selected)
|
|
|
|
affectedDives.append(d);
|
2015-02-14 17:12:05 +00:00
|
|
|
}
|
2018-07-23 21:41:23 +00:00
|
|
|
Command::shiftTime(affectedDives, amount);
|
2013-11-18 18:00:39 +00:00
|
|
|
}
|
2013-11-18 13:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-21 16:09:09 +00:00
|
|
|
void ShiftTimesDialog::showEvent(QShowEvent*)
|
2014-03-20 20:57:49 +00:00
|
|
|
{
|
|
|
|
ui.timeEdit->setTime(QTime(0, 0, 0, 0));
|
2014-05-22 18:40:22 +00:00
|
|
|
when = get_times(); //get time of first selected dive
|
2014-03-20 20:57:49 +00:00
|
|
|
ui.currentTime->setText(get_dive_date_string(when));
|
|
|
|
ui.shiftedTime->setText(get_dive_date_string(when));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ShiftTimesDialog::changeTime()
|
|
|
|
{
|
|
|
|
int amount;
|
|
|
|
|
|
|
|
amount = ui.timeEdit->time().hour() * 3600 + ui.timeEdit->time().minute() * 60;
|
|
|
|
if (ui.backwards->isChecked())
|
|
|
|
amount *= -1;
|
|
|
|
|
2014-05-22 18:40:22 +00:00
|
|
|
ui.shiftedTime->setText(get_dive_date_string(amount + when));
|
2014-03-20 20:57:49 +00:00
|
|
|
}
|
|
|
|
|
2017-12-24 16:39:21 +00:00
|
|
|
ShiftTimesDialog::ShiftTimesDialog(QWidget *parent) : QDialog(parent),
|
2015-06-22 05:19:59 +00:00
|
|
|
when(0)
|
2013-11-18 13:53:05 +00:00
|
|
|
{
|
|
|
|
ui.setupUi(this);
|
2014-02-28 04:09:57 +00:00
|
|
|
connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
|
2014-03-20 20:57:49 +00:00
|
|
|
connect(ui.timeEdit, SIGNAL(timeChanged(const QTime)), this, SLOT(changeTime()));
|
|
|
|
connect(ui.backwards, SIGNAL(toggled(bool)), this, SLOT(changeTime()));
|
2014-04-25 17:39:40 +00:00
|
|
|
QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
|
|
|
|
connect(close, SIGNAL(activated()), this, SLOT(close()));
|
|
|
|
QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
|
|
|
|
connect(quit, SIGNAL(activated()), parent, SLOT(close()));
|
2013-11-18 13:53:05 +00:00
|
|
|
}
|
2014-01-27 13:44:26 +00:00
|
|
|
|
2014-02-28 04:09:57 +00:00
|
|
|
void ShiftImageTimesDialog::buttonClicked(QAbstractButton *button)
|
2014-01-27 13:44:26 +00:00
|
|
|
{
|
|
|
|
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
|
2014-02-08 22:56:47 +00:00
|
|
|
m_amount = ui.timeEdit->time().hour() * 3600 + ui.timeEdit->time().minute() * 60;
|
2014-01-27 13:44:26 +00:00
|
|
|
if (ui.backwards->isChecked())
|
2014-02-08 22:56:47 +00:00
|
|
|
m_amount *= -1;
|
2014-01-27 13:44:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-13 15:43:55 +00:00
|
|
|
void ShiftImageTimesDialog::syncCameraClicked()
|
|
|
|
{
|
|
|
|
QPixmap picture;
|
|
|
|
QStringList fileNames = QFileDialog::getOpenFileNames(this,
|
2014-07-11 17:39:03 +00:00
|
|
|
tr("Open image file"),
|
2014-02-18 23:26:36 +00:00
|
|
|
DiveListView::lastUsedImageDir(),
|
2017-10-27 12:52:27 +00:00
|
|
|
tr("Image files") + " (*.jpg *.jpeg)");
|
2014-02-13 15:43:55 +00:00
|
|
|
if (fileNames.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
picture.load(fileNames.at(0));
|
2014-02-19 10:34:54 +00:00
|
|
|
ui.displayDC->setEnabled(true);
|
2014-02-28 04:09:57 +00:00
|
|
|
QGraphicsScene *scene = new QGraphicsScene(this);
|
2014-02-13 15:43:55 +00:00
|
|
|
|
|
|
|
scene->addPixmap(picture.scaled(ui.DCImage->size()));
|
|
|
|
ui.DCImage->setScene(scene);
|
2015-03-14 14:35:47 +00:00
|
|
|
|
2018-02-25 12:51:41 +00:00
|
|
|
dcImageEpoch = picture_get_timestamp(qPrintable(fileNames.at(0)));
|
2016-06-22 20:46:22 +00:00
|
|
|
QDateTime dcDateTime = QDateTime::fromTime_t(dcImageEpoch, Qt::UTC);
|
2014-02-13 15:43:55 +00:00
|
|
|
ui.dcTime->setDateTime(dcDateTime);
|
|
|
|
connect(ui.dcTime, SIGNAL(dateTimeChanged(const QDateTime &)), this, SLOT(dcDateTimeChanged(const QDateTime &)));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ShiftImageTimesDialog::dcDateTimeChanged(const QDateTime &newDateTime)
|
|
|
|
{
|
2015-09-21 15:46:17 +00:00
|
|
|
QDateTime newtime(newDateTime);
|
2014-02-13 15:43:55 +00:00
|
|
|
if (!dcImageEpoch)
|
|
|
|
return;
|
2015-09-21 15:46:17 +00:00
|
|
|
newtime.setTimeSpec(Qt::UTC);
|
2015-10-21 13:52:09 +00:00
|
|
|
setOffset(newtime.toTime_t() - dcImageEpoch);
|
2014-02-13 15:43:55 +00:00
|
|
|
}
|
|
|
|
|
2015-09-11 09:31:02 +00:00
|
|
|
void ShiftImageTimesDialog::matchAllImagesToggled(bool state)
|
|
|
|
{
|
|
|
|
matchAllImages = state;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ShiftImageTimesDialog::matchAll()
|
|
|
|
{
|
|
|
|
return matchAllImages;
|
|
|
|
}
|
|
|
|
|
2017-12-24 16:39:21 +00:00
|
|
|
ShiftImageTimesDialog::ShiftImageTimesDialog(QWidget *parent, QStringList fileNames) : QDialog(parent),
|
2015-10-02 02:02:26 +00:00
|
|
|
fileNames(fileNames),
|
|
|
|
m_amount(0),
|
|
|
|
matchAllImages(false)
|
2014-01-27 13:44:26 +00:00
|
|
|
{
|
|
|
|
ui.setupUi(this);
|
2014-02-28 04:09:57 +00:00
|
|
|
connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
|
2014-02-13 15:43:55 +00:00
|
|
|
connect(ui.syncCamera, SIGNAL(clicked()), this, SLOT(syncCameraClicked()));
|
2015-03-14 16:44:24 +00:00
|
|
|
connect(ui.timeEdit, SIGNAL(timeChanged(const QTime &)), this, SLOT(timeEditChanged(const QTime &)));
|
2017-04-30 20:24:08 +00:00
|
|
|
connect(ui.backwards, SIGNAL(toggled(bool)), this, SLOT(timeEditChanged()));
|
2015-09-11 09:31:02 +00:00
|
|
|
connect(ui.matchAllImages, SIGNAL(toggled(bool)), this, SLOT(matchAllImagesToggled(bool)));
|
2014-02-28 04:09:57 +00:00
|
|
|
dcImageEpoch = (time_t)0;
|
2017-12-24 16:39:21 +00:00
|
|
|
|
2018-09-17 15:34:13 +00:00
|
|
|
// Get times of all files. 0 means that the time couldn't be determined.
|
|
|
|
int numFiles = fileNames.size();
|
|
|
|
timestamps.resize(numFiles);
|
|
|
|
for (int i = 0; i < numFiles; ++i)
|
|
|
|
timestamps[i] = picture_get_timestamp(qPrintable(fileNames[i]));
|
2017-04-30 20:24:08 +00:00
|
|
|
updateInvalid();
|
2014-01-27 13:44:26 +00:00
|
|
|
}
|
2013-11-18 13:53:05 +00:00
|
|
|
|
2014-02-13 15:43:55 +00:00
|
|
|
time_t ShiftImageTimesDialog::amount() const
|
2014-02-08 22:56:47 +00:00
|
|
|
{
|
|
|
|
return m_amount;
|
|
|
|
}
|
|
|
|
|
2014-02-13 15:43:55 +00:00
|
|
|
void ShiftImageTimesDialog::setOffset(time_t offset)
|
2014-02-12 15:46:17 +00:00
|
|
|
{
|
|
|
|
if (offset >= 0) {
|
2014-02-19 10:34:54 +00:00
|
|
|
ui.forward->setChecked(true);
|
2014-02-12 15:46:17 +00:00
|
|
|
} else {
|
2014-02-19 10:34:54 +00:00
|
|
|
ui.backwards->setChecked(true);
|
2014-02-12 15:46:17 +00:00
|
|
|
offset *= -1;
|
|
|
|
}
|
2014-02-18 05:50:35 +00:00
|
|
|
ui.timeEdit->setTime(QTime(offset / 3600, (offset % 3600) / 60, offset % 60));
|
2014-02-12 15:46:17 +00:00
|
|
|
}
|
|
|
|
|
2015-03-14 16:44:24 +00:00
|
|
|
void ShiftImageTimesDialog::updateInvalid()
|
|
|
|
{
|
|
|
|
bool allValid = true;
|
|
|
|
ui.warningLabel->hide();
|
2017-04-30 18:31:56 +00:00
|
|
|
ui.invalidFilesText->hide();
|
2017-04-30 20:24:08 +00:00
|
|
|
QDateTime time_first = QDateTime::fromTime_t(first_selected_dive()->when, Qt::UTC);
|
|
|
|
QDateTime time_last = QDateTime::fromTime_t(last_selected_dive()->when, Qt::UTC);
|
2019-05-15 14:42:14 +00:00
|
|
|
if (first_selected_dive() == last_selected_dive()) {
|
2017-04-30 20:24:08 +00:00
|
|
|
ui.invalidFilesText->setPlainText(tr("Selected dive date/time") + ": " + time_first.toString());
|
2019-05-15 14:42:14 +00:00
|
|
|
} else {
|
2017-04-30 20:24:08 +00:00
|
|
|
ui.invalidFilesText->setPlainText(tr("First selected dive date/time") + ": " + time_first.toString());
|
|
|
|
ui.invalidFilesText->append(tr("Last selected dive date/time") + ": " + time_last.toString());
|
|
|
|
}
|
|
|
|
ui.invalidFilesText->append(tr("\nFiles with inappropriate date/time") + ":");
|
2015-03-14 16:44:24 +00:00
|
|
|
|
2018-09-17 15:34:13 +00:00
|
|
|
int numFiles = fileNames.size();
|
|
|
|
for (int i = 0; i < numFiles; ++i) {
|
|
|
|
if (picture_check_valid_time(timestamps[i], m_amount))
|
2015-03-14 16:44:24 +00:00
|
|
|
continue;
|
|
|
|
|
2018-09-17 15:34:13 +00:00
|
|
|
// We've found an invalid image
|
|
|
|
time_first.setTime_t(timestamps[i] + m_amount);
|
|
|
|
if (timestamps[i] == 0)
|
|
|
|
ui.invalidFilesText->append(fileNames[i] + " - " + tr("No Exif date/time found"));
|
2017-05-05 16:50:51 +00:00
|
|
|
else
|
2018-09-17 15:34:13 +00:00
|
|
|
ui.invalidFilesText->append(fileNames[i] + " - " + time_first.toString());
|
2015-03-14 16:44:24 +00:00
|
|
|
allValid = false;
|
|
|
|
}
|
|
|
|
|
2017-12-24 16:39:21 +00:00
|
|
|
if (!allValid) {
|
2015-03-14 16:44:24 +00:00
|
|
|
ui.warningLabel->show();
|
2017-04-30 18:31:56 +00:00
|
|
|
ui.invalidFilesText->show();
|
2015-03-14 16:44:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ShiftImageTimesDialog::timeEditChanged(const QTime &time)
|
|
|
|
{
|
2018-06-17 18:22:55 +00:00
|
|
|
QDateTimeEdit::Section timeEditSection = ui.timeEdit->currentSection();
|
|
|
|
ui.timeEdit->setEnabled(false);
|
2015-03-14 16:44:24 +00:00
|
|
|
m_amount = time.hour() * 3600 + time.minute() * 60;
|
|
|
|
if (ui.backwards->isChecked())
|
2017-12-24 16:39:21 +00:00
|
|
|
m_amount *= -1;
|
2015-03-14 16:44:24 +00:00
|
|
|
updateInvalid();
|
2018-06-17 18:22:55 +00:00
|
|
|
ui.timeEdit->setEnabled(true);
|
|
|
|
ui.timeEdit->setFocus();
|
|
|
|
ui.timeEdit->setSelectedSection(timeEditSection);
|
2015-03-14 16:44:24 +00:00
|
|
|
}
|
|
|
|
|
2017-04-30 20:24:08 +00:00
|
|
|
void ShiftImageTimesDialog::timeEditChanged()
|
|
|
|
{
|
2017-06-10 20:02:23 +00:00
|
|
|
if ((m_amount > 0) == ui.backwards->isChecked())
|
2017-12-24 16:39:21 +00:00
|
|
|
m_amount *= -1;
|
|
|
|
if (m_amount)
|
|
|
|
updateInvalid();
|
2017-04-30 20:24:08 +00:00
|
|
|
}
|
|
|
|
|
2015-04-24 15:10:55 +00:00
|
|
|
URLDialog::URLDialog(QWidget *parent) : QDialog(parent)
|
|
|
|
{
|
|
|
|
ui.setupUi(this);
|
|
|
|
QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
|
|
|
|
connect(close, SIGNAL(activated()), this, SLOT(close()));
|
|
|
|
QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
|
|
|
|
connect(quit, SIGNAL(activated()), parent, SLOT(close()));
|
|
|
|
}
|
|
|
|
|
|
|
|
QString URLDialog::url() const
|
|
|
|
{
|
2017-01-11 09:25:07 +00:00
|
|
|
return ui.urlField->text();
|
2015-04-24 15:10:55 +00:00
|
|
|
}
|
|
|
|
|
2013-09-27 15:52:01 +00:00
|
|
|
bool isGnome3Session()
|
|
|
|
{
|
|
|
|
#if defined(QT_OS_WIW) || defined(QT_OS_MAC)
|
|
|
|
return false;
|
|
|
|
#else
|
|
|
|
if (qApp->style()->objectName() != "gtk+")
|
|
|
|
return false;
|
|
|
|
QProcess p;
|
2014-02-28 04:09:57 +00:00
|
|
|
p.start("pidof", QStringList() << "gnome-shell");
|
2013-09-27 15:52:01 +00:00
|
|
|
p.waitForFinished(-1);
|
|
|
|
QString p_stdout = p.readAllStandardOutput();
|
|
|
|
return !p_stdout.isEmpty();
|
|
|
|
#endif
|
|
|
|
}
|
2014-06-19 16:42:49 +00:00
|
|
|
|
2014-08-16 15:32:23 +00:00
|
|
|
#define COMPONENT_FROM_UI(_component) what->_component = ui._component->isChecked()
|
|
|
|
#define UI_FROM_COMPONENT(_component) ui._component->setChecked(what->_component)
|
|
|
|
|
2014-09-17 22:39:49 +00:00
|
|
|
DiveComponentSelection::DiveComponentSelection(QWidget *parent, struct dive *target, struct dive_components *_what) : targetDive(target)
|
2014-08-16 15:32:23 +00:00
|
|
|
{
|
|
|
|
ui.setupUi(this);
|
|
|
|
what = _what;
|
2015-02-13 04:58:03 +00:00
|
|
|
UI_FROM_COMPONENT(divesite);
|
2014-08-16 15:32:23 +00:00
|
|
|
UI_FROM_COMPONENT(divemaster);
|
|
|
|
UI_FROM_COMPONENT(buddy);
|
|
|
|
UI_FROM_COMPONENT(rating);
|
|
|
|
UI_FROM_COMPONENT(visibility);
|
|
|
|
UI_FROM_COMPONENT(notes);
|
|
|
|
UI_FROM_COMPONENT(suit);
|
2014-08-17 00:35:44 +00:00
|
|
|
UI_FROM_COMPONENT(tags);
|
2014-08-16 15:32:23 +00:00
|
|
|
UI_FROM_COMPONENT(cylinders);
|
|
|
|
UI_FROM_COMPONENT(weights);
|
|
|
|
connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
|
|
|
|
QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
|
|
|
|
connect(close, SIGNAL(activated()), this, SLOT(close()));
|
|
|
|
QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
|
|
|
|
connect(quit, SIGNAL(activated()), parent, SLOT(close()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void DiveComponentSelection::buttonClicked(QAbstractButton *button)
|
|
|
|
{
|
|
|
|
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
|
2015-02-13 04:58:03 +00:00
|
|
|
COMPONENT_FROM_UI(divesite);
|
2014-08-16 15:32:23 +00:00
|
|
|
COMPONENT_FROM_UI(divemaster);
|
|
|
|
COMPONENT_FROM_UI(buddy);
|
|
|
|
COMPONENT_FROM_UI(rating);
|
|
|
|
COMPONENT_FROM_UI(visibility);
|
|
|
|
COMPONENT_FROM_UI(notes);
|
|
|
|
COMPONENT_FROM_UI(suit);
|
2014-08-17 00:35:44 +00:00
|
|
|
COMPONENT_FROM_UI(tags);
|
2014-08-16 15:32:23 +00:00
|
|
|
COMPONENT_FROM_UI(cylinders);
|
|
|
|
COMPONENT_FROM_UI(weights);
|
2014-08-17 00:33:09 +00:00
|
|
|
selective_copy_dive(&displayed_dive, targetDive, *what, true);
|
2019-02-02 14:42:57 +00:00
|
|
|
QClipboard *clipboard = QApplication::clipboard();
|
|
|
|
QTextStream text;
|
|
|
|
QString cliptext;
|
|
|
|
text.setString(&cliptext);
|
2019-05-28 20:54:58 +00:00
|
|
|
if (what->divesite && displayed_dive.dive_site)
|
2019-02-02 14:42:57 +00:00
|
|
|
text << tr("Dive site: ") << displayed_dive.dive_site->name << "\n";
|
|
|
|
if (what->divemaster)
|
|
|
|
text << tr("Dive master: ") << displayed_dive.divemaster << "\n";
|
|
|
|
if (what->buddy)
|
|
|
|
text << tr("Buddy: ") << displayed_dive.buddy << "\n";
|
|
|
|
if (what->rating)
|
|
|
|
text << tr("Rating: ") + QString("*").repeated(displayed_dive.rating) << "\n";
|
|
|
|
if (what->visibility)
|
|
|
|
text << tr("Visibility: ") + QString("*").repeated(displayed_dive.visibility) << "\n";
|
|
|
|
if (what->notes)
|
|
|
|
text << tr("Notes:\n") << displayed_dive.notes << "\n";
|
|
|
|
if (what->suit)
|
|
|
|
text << tr("Suit: ") << displayed_dive.suit << "\n";
|
|
|
|
if (what-> tags) {
|
|
|
|
text << tr("Tags: ");
|
|
|
|
tag_entry *entry = displayed_dive.tag_list;
|
|
|
|
while (entry) {
|
|
|
|
text << entry->tag->name << " ";
|
|
|
|
entry = entry->next;
|
|
|
|
}
|
|
|
|
text << "\n";
|
|
|
|
}
|
|
|
|
if (what->cylinders) {
|
|
|
|
int cyl;
|
|
|
|
text << tr("Cylinders:\n");
|
2019-08-04 16:44:57 +00:00
|
|
|
for (cyl = 0; cyl < displayed_dive.cylinders.nr; cyl++) {
|
2019-02-02 14:42:57 +00:00
|
|
|
if (is_cylinder_used(&displayed_dive, cyl))
|
2019-08-04 20:13:49 +00:00
|
|
|
text << get_cylinder(&displayed_dive, cyl)->type.description << " " << gasname(get_cylinder(&displayed_dive, cyl)->gasmix) << "\n";
|
2019-02-02 14:42:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (what->weights) {
|
|
|
|
int w;
|
|
|
|
text << tr("Weights:\n");
|
2019-06-26 15:21:03 +00:00
|
|
|
for (w = 0; w < displayed_dive.weightsystems.nr; w++) {
|
|
|
|
weightsystem_t ws = displayed_dive.weightsystems.weightsystems[w];
|
|
|
|
text << ws.description << ws.weight.grams / 1000 << "kg\n";
|
2019-02-02 14:42:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
clipboard->setText(cliptext);
|
2014-08-16 15:32:23 +00:00
|
|
|
}
|
|
|
|
}
|
2014-09-17 17:17:41 +00:00
|
|
|
|
2015-11-16 04:56:24 +00:00
|
|
|
TextHyperlinkEventFilter::TextHyperlinkEventFilter(QTextEdit *txtEdit) : QObject(txtEdit),
|
|
|
|
textEdit(txtEdit),
|
|
|
|
scrollView(textEdit->viewport())
|
|
|
|
{
|
|
|
|
// If you install the filter on textEdit, you fail to capture any clicks.
|
|
|
|
// The clicks go to the viewport. http://stackoverflow.com/a/31582977/10278
|
|
|
|
textEdit->viewport()->installEventFilter(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TextHyperlinkEventFilter::eventFilter(QObject *target, QEvent *evt)
|
|
|
|
{
|
|
|
|
if (target != scrollView)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (evt->type() != QEvent::MouseButtonPress &&
|
|
|
|
evt->type() != QEvent::ToolTip)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// --------------------
|
|
|
|
|
|
|
|
// Note: Qt knows that on Mac OSX, ctrl (and Control) are the command key.
|
|
|
|
const bool isCtrlClick = evt->type() == QEvent::MouseButtonPress &&
|
|
|
|
static_cast<QMouseEvent *>(evt)->modifiers() & Qt::ControlModifier &&
|
|
|
|
static_cast<QMouseEvent *>(evt)->button() == Qt::LeftButton;
|
|
|
|
|
|
|
|
const bool isTooltip = evt->type() == QEvent::ToolTip;
|
|
|
|
|
|
|
|
QString urlUnderCursor;
|
|
|
|
|
|
|
|
if (isCtrlClick || isTooltip) {
|
|
|
|
QTextCursor cursor = isCtrlClick ?
|
|
|
|
textEdit->cursorForPosition(static_cast<QMouseEvent *>(evt)->pos()) :
|
|
|
|
textEdit->cursorForPosition(static_cast<QHelpEvent *>(evt)->pos());
|
|
|
|
|
|
|
|
urlUnderCursor = tryToFormulateUrl(&cursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isCtrlClick) {
|
|
|
|
handleUrlClick(urlUnderCursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isTooltip) {
|
|
|
|
handleUrlTooltip(urlUnderCursor, static_cast<QHelpEvent *>(evt)->globalPos());
|
|
|
|
}
|
|
|
|
|
|
|
|
// 'return true' would mean that all event handling stops for this event.
|
|
|
|
// 'return false' lets Qt continue propagating the event to the target.
|
|
|
|
// Since our URL behavior is meant as 'additive' and not necessarily mutually
|
|
|
|
// exclusive with any default behaviors, it seems ok to return false to
|
|
|
|
// avoid unintentially hijacking any 'normal' event handling.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TextHyperlinkEventFilter::handleUrlClick(const QString &urlStr)
|
|
|
|
{
|
|
|
|
if (!urlStr.isEmpty()) {
|
|
|
|
QUrl url(urlStr, QUrl::StrictMode);
|
|
|
|
QDesktopServices::openUrl(url);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TextHyperlinkEventFilter::handleUrlTooltip(const QString &urlStr, const QPoint &pos)
|
|
|
|
{
|
|
|
|
if (urlStr.isEmpty()) {
|
|
|
|
QToolTip::hideText();
|
|
|
|
} else {
|
|
|
|
// per Qt docs, QKeySequence::toString does localization "tr()" on strings like Ctrl.
|
|
|
|
// Note: Qt knows that on Mac OSX, ctrl (and Control) are the command key.
|
2018-01-01 20:49:19 +00:00
|
|
|
const QString ctrlKeyName = QKeySequence(Qt::CTRL).toString(QKeySequence::NativeText);
|
2015-11-16 04:56:24 +00:00
|
|
|
// ctrlKeyName comes with a trailing '+', as in: 'Ctrl+'
|
|
|
|
QToolTip::showText(pos, tr("%1click to visit %2").arg(ctrlKeyName).arg(urlStr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TextHyperlinkEventFilter::stringMeetsOurUrlRequirements(const QString &maybeUrlStr)
|
|
|
|
{
|
|
|
|
QUrl url(maybeUrlStr, QUrl::StrictMode);
|
2017-04-18 21:41:55 +00:00
|
|
|
return url.isValid() && (!url.scheme().isEmpty()) && ((!url.authority().isEmpty()) || (!url.path().isEmpty()));
|
2015-11-16 04:56:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QString TextHyperlinkEventFilter::tryToFormulateUrl(QTextCursor *cursor)
|
|
|
|
{
|
|
|
|
// tryToFormulateUrl exists because WordUnderCursor will not
|
|
|
|
// treat "http://m.abc.def" as a word.
|
|
|
|
|
|
|
|
// tryToFormulateUrl invokes fromCursorTilWhitespace two times (once
|
|
|
|
// with a forward moving cursor and once in the backwards direction) in
|
|
|
|
// order to expand the selection to try to capture a complete string
|
|
|
|
// like "http://m.abc.def"
|
|
|
|
|
|
|
|
// loosely inspired by advice here: http://stackoverflow.com/q/19262064/10278
|
|
|
|
|
|
|
|
cursor->select(QTextCursor::WordUnderCursor);
|
|
|
|
QString maybeUrlStr = cursor->selectedText();
|
|
|
|
|
|
|
|
const bool soFarSoGood = !maybeUrlStr.simplified().replace(" ", "").isEmpty();
|
|
|
|
|
|
|
|
if (soFarSoGood && !stringMeetsOurUrlRequirements(maybeUrlStr)) {
|
|
|
|
// If we don't yet have a full url, try to expand til we get one. Note:
|
|
|
|
// after requesting WordUnderCursor, empirically (all platforms, in
|
|
|
|
// Qt5), the 'anchor' is just past the end of the word.
|
|
|
|
|
|
|
|
QTextCursor cursor2(*cursor);
|
|
|
|
QString left = fromCursorTilWhitespace(cursor, true /*searchBackwards*/);
|
|
|
|
QString right = fromCursorTilWhitespace(&cursor2, false);
|
|
|
|
maybeUrlStr = left + right;
|
|
|
|
}
|
|
|
|
|
2020-01-06 20:33:08 +00:00
|
|
|
return stringMeetsOurUrlRequirements(maybeUrlStr) ? maybeUrlStr : QString();
|
2015-11-16 04:56:24 +00:00
|
|
|
}
|
|
|
|
|
2020-02-06 21:56:10 +00:00
|
|
|
QString TextHyperlinkEventFilter::fromCursorTilWhitespace(QTextCursor *cursor, bool searchBackwards)
|
2015-11-16 04:56:24 +00:00
|
|
|
{
|
|
|
|
// fromCursorTilWhitespace calls cursor->movePosition repeatedly, while
|
|
|
|
// preserving the original 'anchor' (qt terminology) of the cursor.
|
|
|
|
// We widen the selection with 'movePosition' until hitting any whitespace.
|
|
|
|
|
|
|
|
QString result;
|
|
|
|
QString grownText;
|
|
|
|
QString noSpaces;
|
|
|
|
bool movedOk = false;
|
2017-04-18 21:35:43 +00:00
|
|
|
int oldSize = -1;
|
2015-11-16 04:56:24 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
result = grownText; // this is a no-op on the first visit.
|
|
|
|
|
|
|
|
if (searchBackwards) {
|
|
|
|
movedOk = cursor->movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor);
|
|
|
|
} else {
|
|
|
|
movedOk = cursor->movePosition(QTextCursor::NextWord, QTextCursor::KeepAnchor);
|
|
|
|
}
|
|
|
|
|
|
|
|
grownText = cursor->selectedText();
|
2017-12-24 16:39:21 +00:00
|
|
|
if (grownText.size() == oldSize)
|
|
|
|
movedOk = false;
|
2017-04-18 21:35:43 +00:00
|
|
|
oldSize = grownText.size();
|
2015-11-16 04:56:24 +00:00
|
|
|
noSpaces = grownText.simplified().replace(" ", "");
|
|
|
|
} while (grownText == noSpaces && movedOk);
|
|
|
|
|
|
|
|
// while growing the selection forwards, we have an extra step to do:
|
|
|
|
if (!searchBackwards) {
|
|
|
|
/*
|
|
|
|
The cursor keeps jumping to the start of the next word.
|
|
|
|
(for example) in the string "mn.abcd.edu is the spot" you land at
|
|
|
|
m,a,e,i (the 'i' in 'is). if we stop at e, then we only capture
|
|
|
|
"mn.abcd." for the url (wrong). So we have to go to 'i', to
|
|
|
|
capture "mn.abcd.edu " (with trailing space), and then clean it up.
|
|
|
|
*/
|
|
|
|
QStringList list = grownText.split(QRegExp("\\s"), QString::SkipEmptyParts);
|
|
|
|
if (!list.isEmpty()) {
|
|
|
|
result = list[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|