← Back to branch summary

~ubuntu-branches/ubuntu/saucy/goldencheetah/saucy

« back to all changes in this revision

Viewing changes to src/LTMTool.cpp

  • Committer: Package Import Robot
  • Author(s): KURASHIKI Satoru
  • Date: 2013-08-18 07:02:45 UTC
  • mfrom: (4.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20130818070245-zgdvb47e1k3mtgil
Tags: 3.0-3
http://bugs.debian.org/719571
debian/control: remove needless dependency. (Closes: #719571)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/LTMTool.cpp
34
34
#include "RideMetadata.h"
35
35
#include "SpecialFields.h"
36
36
 
37
 
LTMTool::LTMTool(MainWindow *parent, const QDir &home) : QWidget(parent), home(home), main(parent)
 
37
LTMTool::LTMTool(MainWindow *parent, const QDir &home, bool multi) : QWidget(parent), home(home), main(parent), active(false), _amFiltered(false)
38
38
{
 
39
    setStyleSheet("QFrame { FrameStyle = QFrame::NoFrame };"
 
40
                  "QWidget { background = Qt::white; border:0 px; margin: 2px; };");
 
41
 
39
42
    // get application settings
40
 
    boost::shared_ptr<QSettings> appsettings = GetApplicationSettings();
41
 
    useMetricUnits = appsettings->value(GC_UNIT).toString() == "Metric";
 
43
    useMetricUnits = main->useMetricUnits;
42
44
 
43
45
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
44
46
    mainLayout->setContentsMargins(0,0,0,0);
45
 
 
46
 
    dateRangeTree = new QTreeWidget;
47
 
    dateRangeTree->setColumnCount(1);
48
 
    dateRangeTree->setSelectionMode(QAbstractItemView::SingleSelection);
49
 
    dateRangeTree->header()->hide();
50
 
    dateRangeTree->setAlternatingRowColors (true);
51
 
    dateRangeTree->setIndentation(5);
52
 
    allDateRanges = new QTreeWidgetItem(dateRangeTree, ROOT_TYPE);
53
 
    allDateRanges->setText(0, tr("Date Range"));
54
 
    readSeasons();
55
 
    dateRangeTree->expandItem(allDateRanges);
56
 
    dateRangeTree->setContextMenuPolicy(Qt::CustomContextMenu);
 
47
    mainLayout->setSpacing(0);
 
48
    setContentsMargins(0,0,0,0);
 
49
 
 
50
    QWidget *basicsettings = new QWidget(this);
 
51
    mainLayout->addWidget(basicsettings);
 
52
    QFormLayout *basicsettingsLayout = new QFormLayout(basicsettings);
 
53
    basicsettingsLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
 
54
 
 
55
#ifdef GC_HAVE_LUCENE
 
56
    searchBox = new SearchFilterBox(this, main);
 
57
    connect(searchBox, SIGNAL(searchClear()), this, SLOT(clearFilter()));
 
58
    connect(searchBox, SIGNAL(searchResults(QStringList)), this, SLOT(setFilter(QStringList)));
 
59
 
 
60
    basicsettingsLayout->addRow(new QLabel(tr("Filter")), searchBox);
 
61
    basicsettingsLayout->addRow(new QLabel(tr(""))); // spacing
 
62
#endif
 
63
 
 
64
    // Basic Controls
 
65
    QWidget *basic = new QWidget(this);
 
66
    basic->setContentsMargins(0,0,0,0);
 
67
    QVBoxLayout *basicLayout = new QVBoxLayout(basic);
 
68
    basicLayout->setContentsMargins(0,0,0,0);
 
69
    basicLayout->setSpacing(0);
 
70
 
 
71
    QLabel *presetLabel = new QLabel(tr("Chart"));
 
72
    QFont sameFont = presetLabel->font();
 
73
#ifdef Q_OS_MAC // possibly needed on others too
 
74
    sameFont.setPointSize(sameFont.pointSize() + 2);
 
75
#endif
 
76
    presetPicker = new QComboBox;
 
77
    presetPicker->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 
78
    QHBoxLayout *presetrow = new QHBoxLayout;
 
79
    presetrow->setSpacing(5);
 
80
    presetrow->addWidget(presetLabel);
 
81
    presetrow->addWidget(presetPicker);
 
82
    presetrow->addStretch();
 
83
    basicLayout->addLayout(presetrow);
 
84
    basicLayout->addStretch();
 
85
 
 
86
    dateSetting = new DateSettingsEdit(this);
 
87
    basicsettingsLayout->addRow(new QLabel(tr("Date range")), dateSetting);
 
88
    basicsettingsLayout->addRow(new QLabel(tr(""))); // spacing
 
89
 
 
90
    groupBy = new QComboBox;
 
91
    groupBy->addItem(tr("Days"), LTM_DAY);
 
92
    groupBy->addItem(tr("Weeks"), LTM_WEEK);
 
93
    groupBy->addItem(tr("Months"), LTM_MONTH);
 
94
    groupBy->addItem(tr("Years"), LTM_YEAR);
 
95
    groupBy->addItem(tr("Time Of Day"), LTM_TOD);
 
96
    groupBy->setCurrentIndex(0);
 
97
    basicsettingsLayout->addRow(new QLabel(tr("Group by")), groupBy);
 
98
    basicsettingsLayout->addRow(new QLabel(tr(""))); // spacing
 
99
 
 
100
    shadeZones = new QCheckBox(tr("Shade Zones"));
 
101
    basicsettingsLayout->addRow(new QLabel(""), shadeZones);
 
102
 
 
103
    showLegend = new QCheckBox(tr("Show Legend"));
 
104
    basicsettingsLayout->addRow(new QLabel(""), showLegend);
 
105
 
 
106
    showEvents = new QCheckBox(tr("Show Events"));
 
107
    basicsettingsLayout->addRow(new QLabel(""), showEvents);
 
108
 
 
109
    // controls
 
110
    saveButton = new QPushButton(tr("Add"));
 
111
    manageButton = new QPushButton(tr("Manage"));
 
112
    QHBoxLayout *buttons = new QHBoxLayout;
 
113
    buttons->addWidget(manageButton);
 
114
    buttons->addStretch();
 
115
    buttons->addWidget(saveButton);
 
116
    basicLayout->addStretch();
 
117
    basicLayout->addLayout(buttons);
57
118
 
58
119
    metricTree = new QTreeWidget;
 
120
#ifdef Q_OS_MAC
 
121
    metricTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
 
122
#endif
59
123
    metricTree->setColumnCount(1);
60
 
    metricTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
124
    if (multi)
 
125
        metricTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
126
    else
 
127
        metricTree->setSelectionMode(QAbstractItemView::SingleSelection);
61
128
    metricTree->header()->hide();
62
 
    metricTree->setAlternatingRowColors (true);
 
129
    //metricTree->setFrameStyle(QFrame::NoFrame);
 
130
    //metricTree->setAlternatingRowColors (true);
63
131
    metricTree->setIndentation(5);
64
132
    allMetrics = new QTreeWidgetItem(metricTree, ROOT_TYPE);
65
133
    allMetrics->setText(0, tr("Metric"));
82
150
        adds.symbolStyle = symbolStyle(factory.metricType(i));
83
151
        adds.smooth = false;
84
152
        adds.trend = false;
85
 
        adds.topN = 5; // show top 5 by default always
 
153
        adds.topN = 1; // show top 1 by default always
86
154
        QTextEdit processHTML(adds.metric->name()); // process html encoding of(TM)
87
155
        adds.name   = processHTML.toPlainText();
88
156
 
89
157
        // set default for the user overiddable fields
90
158
        adds.uname  = adds.name;
 
159
        adds.units = "";
91
160
        adds.uunits = adds.metric->units(useMetricUnits);
92
161
 
93
162
        // default units to metric name if it is blank
109
178
    skibaLTS.symbolStyle = QwtSymbol::NoSymbol;
110
179
    skibaLTS.smooth = false;
111
180
    skibaLTS.trend = false;
112
 
    skibaLTS.topN = 5;
 
181
    skibaLTS.topN = 1;
113
182
    skibaLTS.uname = skibaLTS.name = tr("Skiba Long Term Stress");
 
183
    skibaLTS.units = "Stress";
114
184
    skibaLTS.uunits = tr("Stress");
115
185
    metrics.append(skibaLTS);
116
186
 
123
193
    skibaSTS.symbolStyle = QwtSymbol::NoSymbol;
124
194
    skibaSTS.smooth = false;
125
195
    skibaSTS.trend = false;
126
 
    skibaSTS.topN = 5;
 
196
    skibaSTS.topN = 1;
127
197
    skibaSTS.uname = skibaSTS.name = tr("Skiba Short Term Stress");
 
198
    skibaSTS.units = "Stress";
128
199
    skibaSTS.uunits = tr("Stress");
129
200
    metrics.append(skibaSTS);
130
201
 
139
210
    skibaSB.trend = false;
140
211
    skibaSB.topN = 1;
141
212
    skibaSB.uname = skibaSB.name = tr("Skiba Stress Balance");
 
213
    skibaSB.units = "Stress Balance";
142
214
    skibaSB.uunits = tr("Stress Balance");
143
215
    metrics.append(skibaSB);
144
216
 
153
225
    skibaSTR.trend = false;
154
226
    skibaSTR.topN = 1;
155
227
    skibaSTR.uname = skibaSTR.name = tr("Skiba STS Ramp");
 
228
    skibaSTR.units = "Ramp";
156
229
    skibaSTR.uunits = tr("Ramp");
157
230
    metrics.append(skibaSTR);
158
231
 
167
240
    skibaLTR.trend = false;
168
241
    skibaLTR.topN = 1;
169
242
    skibaLTR.uname = skibaLTR.name = tr("Skiba LTS Ramp");
 
243
    skibaLTR.units = "Ramp";
170
244
    skibaLTR.uunits = tr("Ramp");
171
245
    metrics.append(skibaLTR);
172
246
 
180
254
    danielsLTS.symbolStyle = QwtSymbol::NoSymbol;
181
255
    danielsLTS.smooth = false;
182
256
    danielsLTS.trend = false;
183
 
    danielsLTS.topN = 5;
 
257
    danielsLTS.topN = 1;
184
258
    danielsLTS.uname = danielsLTS.name = tr("Daniels Long Term Stress");
 
259
    danielsLTS.units = "Stress";
185
260
    danielsLTS.uunits = tr("Stress");
186
261
    metrics.append(danielsLTS);
187
262
 
194
269
    danielsSTS.symbolStyle = QwtSymbol::NoSymbol;
195
270
    danielsSTS.smooth = false;
196
271
    danielsSTS.trend = false;
197
 
    danielsSTS.topN = 5;
 
272
    danielsSTS.topN = 1;
198
273
    danielsSTS.uname = danielsSTS.name = tr("Daniels Short Term Stress");
 
274
    danielsSTS.units = "Stress";
199
275
    danielsSTS.uunits = tr("Stress");
200
276
    metrics.append(danielsSTS);
201
277
 
210
286
    danielsSB.trend = false;
211
287
    danielsSB.topN = 1;
212
288
    danielsSB.uname = danielsSB.name = tr("Daniels Stress Balance");
 
289
    danielsSB.units = "Stress Balance";
213
290
    danielsSB.uunits = tr("Stress Balance");
214
291
    metrics.append(danielsSB);
215
292
 
224
301
    danielsSTR.trend = false;
225
302
    danielsSTR.topN = 1;
226
303
    danielsSTR.uname = danielsSTR.name = tr("Daniels STS Ramp");
 
304
    danielsSTR.units = "Ramp";
227
305
    danielsSTR.uunits = tr("Ramp");
228
306
    metrics.append(danielsSTR);
229
307
 
238
316
    danielsLTR.trend = false;
239
317
    danielsLTR.topN = 1;
240
318
    danielsLTR.uname = danielsLTR.name = tr("Daniels LTS Ramp");
 
319
    danielsLTR.units = "Ramp";
241
320
    danielsLTR.uunits = tr("Ramp");
242
321
    metrics.append(danielsLTR);
243
322
 
 
323
    // total work
 
324
    MetricDetail workLTS;
 
325
    workLTS.type = METRIC_PM;
 
326
    workLTS.symbol = "work_lts";
 
327
    workLTS.metric = NULL; // not a factory metric
 
328
    workLTS.penColor = QColor(Qt::blue);
 
329
    workLTS.curveStyle = QwtPlotCurve::Lines;
 
330
    workLTS.symbolStyle = QwtSymbol::NoSymbol;
 
331
    workLTS.smooth = false;
 
332
    workLTS.trend = false;
 
333
    workLTS.topN = 1;
 
334
    workLTS.uname = workLTS.name = tr("Work (Kj) Long Term Stress");
 
335
    workLTS.units = "Stress (Kj)";
 
336
    workLTS.uunits = tr("Stress (Kj)");
 
337
    metrics.append(workLTS);
 
338
 
 
339
    MetricDetail workSTS;
 
340
    workSTS.type = METRIC_PM;
 
341
    workSTS.symbol = "work_sts";
 
342
    workSTS.metric = NULL; // not a factory metric
 
343
    workSTS.penColor = QColor(Qt::magenta);
 
344
    workSTS.curveStyle = QwtPlotCurve::Lines;
 
345
    workSTS.symbolStyle = QwtSymbol::NoSymbol;
 
346
    workSTS.smooth = false;
 
347
    workSTS.trend = false;
 
348
    workSTS.topN = 1;
 
349
    workSTS.uname = workSTS.name = tr("Work (Kj) Short Term Stress");
 
350
    workSTS.units = "Stress (Kj)";
 
351
    workSTS.uunits = tr("Stress (Kj)");
 
352
    metrics.append(workSTS);
 
353
 
 
354
    MetricDetail workSB;
 
355
    workSB.type = METRIC_PM;
 
356
    workSB.symbol = "work_sb";
 
357
    workSB.metric = NULL; // not a factory metric
 
358
    workSB.penColor = QColor(Qt::yellow);
 
359
    workSB.curveStyle = QwtPlotCurve::Steps;
 
360
    workSB.symbolStyle = QwtSymbol::NoSymbol;
 
361
    workSB.smooth = false;
 
362
    workSB.trend = false;
 
363
    workSB.topN = 1;
 
364
    workSB.uname = workSB.name = tr("Work (Kj) Stress Balance");
 
365
    workSB.units = "Stress Balance";
 
366
    workSB.uunits = tr("Stress Balance");
 
367
    metrics.append(workSB);
 
368
 
 
369
    MetricDetail workSTR;
 
370
    workSTR.type = METRIC_PM;
 
371
    workSTR.symbol = "work_sr";
 
372
    workSTR.metric = NULL; // not a factory metric
 
373
    workSTR.penColor = QColor(Qt::darkGreen);
 
374
    workSTR.curveStyle = QwtPlotCurve::Steps;
 
375
    workSTR.symbolStyle = QwtSymbol::NoSymbol;
 
376
    workSTR.smooth = false;
 
377
    workSTR.trend = false;
 
378
    workSTR.topN = 1;
 
379
    workSTR.uname = workSTR.name = tr("Work (Kj) STS Ramp");
 
380
    workSTR.units = "Ramp";
 
381
    workSTR.uunits = tr("Ramp");
 
382
    metrics.append(workSTR);
 
383
 
 
384
    MetricDetail workLTR;
 
385
    workLTR.type = METRIC_PM;
 
386
    workLTR.symbol = "work_lr";
 
387
    workLTR.metric = NULL; // not a factory metric
 
388
    workLTR.penColor = QColor(Qt::darkBlue);
 
389
    workLTR.curveStyle = QwtPlotCurve::Steps;
 
390
    workLTR.symbolStyle = QwtSymbol::NoSymbol;
 
391
    workLTR.smooth = false;
 
392
    workLTR.trend = false;
 
393
    workLTR.topN = 1;
 
394
    workLTR.uname = workLTR.name = tr("Work (Kj) LTS Ramp");
 
395
    workLTR.units = "Ramp";
 
396
    workLTR.uunits = tr("Ramp");
 
397
    metrics.append(workLTR);
 
398
 
 
399
    // total distance
 
400
    MetricDetail distanceLTS;
 
401
    distanceLTS.type = METRIC_PM;
 
402
    distanceLTS.symbol = "distance_lts";
 
403
    distanceLTS.metric = NULL; // not a factory metric
 
404
    distanceLTS.penColor = QColor(Qt::blue);
 
405
    distanceLTS.curveStyle = QwtPlotCurve::Lines;
 
406
    distanceLTS.symbolStyle = QwtSymbol::NoSymbol;
 
407
    distanceLTS.smooth = false;
 
408
    distanceLTS.trend = false;
 
409
    distanceLTS.topN = 1;
 
410
    distanceLTS.uname = distanceLTS.name = tr("Distance (km|mi) Long Term Stress");
 
411
    distanceLTS.units = "Stress (km|mi)";
 
412
    distanceLTS.uunits = tr("Stress (km|mi)");
 
413
    metrics.append(distanceLTS);
 
414
 
 
415
    MetricDetail distanceSTS;
 
416
    distanceSTS.type = METRIC_PM;
 
417
    distanceSTS.symbol = "distance_sts";
 
418
    distanceSTS.metric = NULL; // not a factory metric
 
419
    distanceSTS.penColor = QColor(Qt::magenta);
 
420
    distanceSTS.curveStyle = QwtPlotCurve::Lines;
 
421
    distanceSTS.symbolStyle = QwtSymbol::NoSymbol;
 
422
    distanceSTS.smooth = false;
 
423
    distanceSTS.trend = false;
 
424
    distanceSTS.topN = 1;
 
425
    distanceSTS.uname = distanceSTS.name = tr("Distance (km|mi) Short Term Stress");
 
426
    distanceSTS.units = "Stress (km|mi)";
 
427
    distanceSTS.uunits = tr("Stress (km|mi)");
 
428
    metrics.append(distanceSTS);
 
429
 
 
430
    MetricDetail distanceSB;
 
431
    distanceSB.type = METRIC_PM;
 
432
    distanceSB.symbol = "distance_sb";
 
433
    distanceSB.metric = NULL; // not a factory metric
 
434
    distanceSB.penColor = QColor(Qt::yellow);
 
435
    distanceSB.curveStyle = QwtPlotCurve::Steps;
 
436
    distanceSB.symbolStyle = QwtSymbol::NoSymbol;
 
437
    distanceSB.smooth = false;
 
438
    distanceSB.trend = false;
 
439
    distanceSB.topN = 1;
 
440
    distanceSB.uname = distanceSB.name = tr("Distance (km|mi) Stress Balance");
 
441
    distanceSB.units = "Stress Balance";
 
442
    distanceSB.uunits = tr("Stress Balance");
 
443
    metrics.append(distanceSB);
 
444
 
 
445
    MetricDetail distanceSTR;
 
446
    distanceSTR.type = METRIC_PM;
 
447
    distanceSTR.symbol = "distance_sr";
 
448
    distanceSTR.metric = NULL; // not a factory metric
 
449
    distanceSTR.penColor = QColor(Qt::darkGreen);
 
450
    distanceSTR.curveStyle = QwtPlotCurve::Steps;
 
451
    distanceSTR.symbolStyle = QwtSymbol::NoSymbol;
 
452
    distanceSTR.smooth = false;
 
453
    distanceSTR.trend = false;
 
454
    distanceSTR.topN = 1;
 
455
    distanceSTR.uname = distanceSTR.name = tr("Distance (km|mi) STS Ramp");
 
456
    distanceSTR.units = "Ramp";
 
457
    distanceSTR.uunits = tr("Ramp");
 
458
    metrics.append(distanceSTR);
 
459
 
 
460
    MetricDetail distanceLTR;
 
461
    distanceLTR.type = METRIC_PM;
 
462
    distanceLTR.symbol = "distance_lr";
 
463
    distanceLTR.metric = NULL; // not a factory metric
 
464
    distanceLTR.penColor = QColor(Qt::darkBlue);
 
465
    distanceLTR.curveStyle = QwtPlotCurve::Steps;
 
466
    distanceLTR.symbolStyle = QwtSymbol::NoSymbol;
 
467
    distanceLTR.smooth = false;
 
468
    distanceLTR.trend = false;
 
469
    distanceLTR.topN = 1;
 
470
    distanceLTR.uname = distanceLTR.name = tr("Distance (km|mi) LTS Ramp");
 
471
    distanceLTR.units = "Ramp";
 
472
    distanceLTR.uunits = tr("Ramp");
 
473
    metrics.append(distanceLTR);
 
474
 
 
475
    // COGGAN LTS
 
476
    MetricDetail cogganCTL;
 
477
    cogganCTL.type = METRIC_PM;
 
478
    cogganCTL.symbol = "coggan_ctl";
 
479
    cogganCTL.metric = NULL; // not a factory metric
 
480
    cogganCTL.penColor = QColor(Qt::blue);
 
481
    cogganCTL.curveStyle = QwtPlotCurve::Lines;
 
482
    cogganCTL.symbolStyle = QwtSymbol::NoSymbol;
 
483
    cogganCTL.smooth = false;
 
484
    cogganCTL.trend = false;
 
485
    cogganCTL.topN = 1;
 
486
    cogganCTL.uname = cogganCTL.name = tr("Coggan Chronic Training Load");
 
487
    cogganCTL.units = "CTL";
 
488
    cogganCTL.uunits = "CTL";
 
489
    metrics.append(cogganCTL);
 
490
 
 
491
    MetricDetail cogganATL;
 
492
    cogganATL.type = METRIC_PM;
 
493
    cogganATL.symbol = "coggan_atl";
 
494
    cogganATL.metric = NULL; // not a factory metric
 
495
    cogganATL.penColor = QColor(Qt::magenta);
 
496
    cogganATL.curveStyle = QwtPlotCurve::Lines;
 
497
    cogganATL.symbolStyle = QwtSymbol::NoSymbol;
 
498
    cogganATL.smooth = false;
 
499
    cogganATL.trend = false;
 
500
    cogganATL.topN = 1;
 
501
    cogganATL.uname = cogganATL.name = tr("Coggan Acute Training Load");
 
502
    cogganATL.units = "ATL";
 
503
    cogganATL.uunits = "ATL";
 
504
    metrics.append(cogganATL);
 
505
 
 
506
    MetricDetail cogganTSB;
 
507
    cogganTSB.type = METRIC_PM;
 
508
    cogganTSB.symbol = "coggan_tsb";
 
509
    cogganTSB.metric = NULL; // not a factory metric
 
510
    cogganTSB.penColor = QColor(Qt::yellow);
 
511
    cogganTSB.curveStyle = QwtPlotCurve::Steps;
 
512
    cogganTSB.symbolStyle = QwtSymbol::NoSymbol;
 
513
    cogganTSB.smooth = false;
 
514
    cogganTSB.trend = false;
 
515
    cogganTSB.topN = 1;
 
516
    cogganTSB.uname = cogganTSB.name = tr("Coggan Training Stress Balance");
 
517
    cogganTSB.units = "TSB";
 
518
    cogganTSB.uunits = "TSB";
 
519
    metrics.append(cogganTSB);
 
520
 
 
521
    MetricDetail cogganSTR;
 
522
    cogganSTR.type = METRIC_PM;
 
523
    cogganSTR.symbol = "coggan_sr";
 
524
    cogganSTR.metric = NULL; // not a factory metric
 
525
    cogganSTR.penColor = QColor(Qt::darkGreen);
 
526
    cogganSTR.curveStyle = QwtPlotCurve::Steps;
 
527
    cogganSTR.symbolStyle = QwtSymbol::NoSymbol;
 
528
    cogganSTR.smooth = false;
 
529
    cogganSTR.trend = false;
 
530
    cogganSTR.topN = 1;
 
531
    cogganSTR.uname = cogganSTR.name = tr("Coggan STS Ramp");
 
532
    cogganSTR.units = "Ramp";
 
533
    cogganSTR.uunits = tr("Ramp");
 
534
    metrics.append(cogganSTR);
 
535
 
 
536
    MetricDetail cogganLTR;
 
537
    cogganLTR.type = METRIC_PM;
 
538
    cogganLTR.symbol = "coggan_lr";
 
539
    cogganLTR.metric = NULL; // not a factory metric
 
540
    cogganLTR.penColor = QColor(Qt::darkBlue);
 
541
    cogganLTR.curveStyle = QwtPlotCurve::Steps;
 
542
    cogganLTR.symbolStyle = QwtSymbol::NoSymbol;
 
543
    cogganLTR.smooth = false;
 
544
    cogganLTR.trend = false;
 
545
    cogganLTR.topN = 1;
 
546
    cogganLTR.uname = cogganLTR.name = tr("Coggan LTS Ramp");
 
547
    cogganLTR.units = "Ramp";
 
548
    cogganLTR.uunits = tr("Ramp");
 
549
    metrics.append(cogganLTR);
 
550
 
244
551
    // TRIMP LTS
245
552
    MetricDetail trimpLTS;
246
553
    trimpLTS.type = METRIC_PM;
251
558
    trimpLTS.symbolStyle = QwtSymbol::NoSymbol;
252
559
    trimpLTS.smooth = false;
253
560
    trimpLTS.trend = false;
254
 
    trimpLTS.topN = 5;
 
561
    trimpLTS.topN = 1;
255
562
    trimpLTS.uname = trimpLTS.name = tr("TRIMP Long Term Stress");
256
563
    trimpLTS.uunits = tr("Stress");
257
564
    metrics.append(trimpLTS);
265
572
    trimpSTS.symbolStyle = QwtSymbol::NoSymbol;
266
573
    trimpSTS.smooth = false;
267
574
    trimpSTS.trend = false;
268
 
    trimpSTS.topN = 5;
 
575
    trimpSTS.topN = 1;
269
576
    trimpSTS.uname = trimpSTS.name = tr("TRIMP Short Term Stress");
 
577
    trimpSTS.units = "Stress";
270
578
    trimpSTS.uunits = tr("Stress");
271
579
    metrics.append(trimpSTS);
272
580
 
281
589
    trimpSB.trend = false;
282
590
    trimpSB.topN = 1;
283
591
    trimpSB.uname = trimpSB.name = tr("TRIMP Stress Balance");
 
592
    trimpSB.units = "Stress Balance";
284
593
    trimpSB.uunits = tr("Stress Balance");
285
594
    metrics.append(trimpSB);
286
595
 
295
604
    trimpSTR.trend = false;
296
605
    trimpSTR.topN = 1;
297
606
    trimpSTR.uname = trimpSTR.name = tr("TRIMP STS Ramp");
 
607
    trimpSTR.units = "Ramp";
298
608
    trimpSTR.uunits = tr("Ramp");
299
609
    metrics.append(trimpSTR);
300
610
 
309
619
    trimpLTR.trend = false;
310
620
    trimpLTR.topN = 1;
311
621
    trimpLTR.uname = trimpLTR.name = tr("TRIMP LTS Ramp");
 
622
    trimpLTR.units = "Ramp";
312
623
    trimpLTR.uunits = tr("Ramp");
313
624
    metrics.append(trimpLTR);
314
625
 
315
 
 
 
626
    // metadata metrics
316
627
    SpecialFields sp;
317
628
    foreach (FieldDefinition field, main->rideMetadata()->getFields()) {
318
629
        if (!sp.isMetric(field.name) && (field.type == 3 || field.type == 4)) {
319
630
            MetricDetail metametric;
320
631
            metametric.type = METRIC_META;
321
632
            QString underscored = field.name;
322
 
            metametric.symbol = underscored.replace(" ", "_"); //XXX other special chars!!!
 
633
            metametric.symbol = underscored.replace(" ", "_");
323
634
            metametric.metric = NULL; // not a factory metric
324
635
            metametric.penColor = QColor(Qt::blue);
325
636
            metametric.curveStyle = QwtPlotCurve::Lines;
326
637
            metametric.symbolStyle = QwtSymbol::NoSymbol;
327
638
            metametric.smooth = false;
328
639
            metametric.trend = false;
329
 
            metametric.topN = 5;
330
 
#ifdef ENABLE_METRICS_TRANSLATION
 
640
            metametric.topN = 1;
331
641
            metametric.uname = metametric.name = sp.displayName(field.name);
332
 
#else
333
 
            metametric.uname = metametric.name = field.name;
334
 
#endif
 
642
            metametric.units = "";
335
643
            metametric.uunits = "";
336
644
            metrics.append(metametric);
337
645
        }
338
646
    }
339
647
 
 
648
    // measures
 
649
    QList<FieldDefinition> measureDefinitions;
 
650
    QList<KeywordDefinition> keywordDefinitions; //NOTE: not used in measures.xml
 
651
    QString filename = main->home.absolutePath()+"/measures.xml";
 
652
    QString colorfield;
 
653
    if (!QFile(filename).exists()) filename = ":/xml/measures.xml";
 
654
    RideMetadata::readXML(filename, keywordDefinitions, measureDefinitions, colorfield);
 
655
 
 
656
    foreach (FieldDefinition field, measureDefinitions) {
 
657
        if (!sp.isMetric(field.name) && (field.type == 3 || field.type == 4)) {
 
658
            MetricDetail measure;
 
659
            measure.type = METRIC_MEASURE;
 
660
            QString underscored = field.name;
 
661
            measure.symbol = field.name; // we don't bother with '_' for measures
 
662
            measure.metric = NULL; // not a factory metric
 
663
            measure.penColor = QColor(Qt::blue);
 
664
            measure.curveStyle = QwtPlotCurve::Lines;
 
665
            measure.symbolStyle = QwtSymbol::NoSymbol;
 
666
            measure.smooth = false;
 
667
            measure.trend = false;
 
668
            measure.topN = 1;
 
669
            measure.uname = "";
 
670
            measure.name = QString("%1 (m)").arg(sp.displayName(field.name));
 
671
            measure.units = "";
 
672
            measure.uunits = "";
 
673
            metrics.append(measure);
 
674
        }
 
675
    }
 
676
 
340
677
    // sort the list
341
678
    qSort(metrics);
342
679
 
347
684
    }
348
685
    metricTree->expandItem(allMetrics);
349
686
 
 
687
    // read charts.xml and populate the picker
 
688
    LTMSettings reader;
 
689
    reader.readChartXML(home, presets);
 
690
    // translate default chart names
 
691
    translateDefaultCharts(presets);
 
692
    for(int i=0; i<presets.count(); i++)
 
693
        presetPicker->addItem(presets[i].name, i);
 
694
    presetPicker->setCurrentIndex(-1);
 
695
 
350
696
    configChanged(); // will reset the metric tree
351
697
 
352
 
    ltmSplitter = new QSplitter;
353
 
    ltmSplitter->setContentsMargins(0,0,0,0);
354
 
    ltmSplitter->setOrientation(Qt::Vertical);
355
 
 
356
 
    mainLayout->addWidget(ltmSplitter);
357
 
    ltmSplitter->addWidget(dateRangeTree);
358
 
    ltmSplitter->setCollapsible(0, true);
359
 
    ltmSplitter->addWidget(metricTree);
360
 
    ltmSplitter->setCollapsible(1, true);
361
 
 
362
 
    connect(dateRangeTree,SIGNAL(itemSelectionChanged()),
363
 
            this, SLOT(dateRangeTreeWidgetSelectionChanged()));
 
698
    tabs = new QTabWidget(this);
 
699
 
 
700
    mainLayout->addWidget(tabs);
 
701
    basic->setContentsMargins(20,20,20,20);
 
702
 
 
703
    // metric tree in a container for spacing etc
 
704
    QWidget *metricContainer = new QWidget(this);
 
705
    metricContainer->setContentsMargins(20,20,20,20);
 
706
    QVBoxLayout *metricContainerLayout = new QVBoxLayout(metricContainer);
 
707
    metricContainerLayout->setContentsMargins(0,0,0,0);
 
708
    metricContainerLayout->setSpacing(0);
 
709
    metricContainerLayout->addWidget(metricTree);
 
710
 
 
711
    tabs->addTab(basicsettings, tr("Basic"));
 
712
    tabs->addTab(basic, tr("Preset"));
 
713
    tabs->addTab(metricContainer, tr("Custom"));
 
714
 
364
715
    connect(metricTree,SIGNAL(itemSelectionChanged()),
365
716
            this, SLOT(metricTreeWidgetSelectionChanged()));
366
717
    connect(main, SIGNAL(configChanged()),
367
718
            this, SLOT(configChanged()));
368
 
    connect(dateRangeTree,SIGNAL(customContextMenuRequested(const QPoint &)),
369
 
            this, SLOT(dateRangePopup(const QPoint &)));
370
719
    connect(metricTree,SIGNAL(customContextMenuRequested(const QPoint &)),
371
720
            this, SLOT(metricTreePopup(const QPoint &)));
372
 
    connect(dateRangeTree,SIGNAL(itemChanged(QTreeWidgetItem *,int)),
373
 
            this, SLOT(dateRangeChanged(QTreeWidgetItem*, int)));
374
 
}
375
721
 
376
 
void
377
 
LTMTool::selectDateRange(int index)
378
 
{
379
 
    allDateRanges->child(index)->setSelected(true);
 
722
    // switched between one or other
 
723
    connect(dateSetting, SIGNAL(useStandardRange()), this, SIGNAL(useStandardRange()));
 
724
    connect(dateSetting, SIGNAL(useCustomRange(DateRange)), this, SIGNAL(useCustomRange(DateRange)));
 
725
    connect(dateSetting, SIGNAL(useThruToday()), this, SIGNAL(useThruToday()));
380
726
}
381
727
 
382
728
QwtPlotCurve::CurveStyle
409
755
{
410
756
}
411
757
 
412
 
/*----------------------------------------------------------------------
413
 
 * Selections Made
414
 
 *----------------------------------------------------------------------*/
415
 
 
416
 
void
417
 
LTMTool::dateRangeTreeWidgetSelectionChanged()
418
 
{
419
 
    if (dateRangeTree->selectedItems().isEmpty()) dateRange = NULL;
420
 
    else {
421
 
        QTreeWidgetItem *which = dateRangeTree->selectedItems().first();
422
 
        if (which != allDateRanges) {
423
 
            dateRange = &seasons.at(allDateRanges->indexOfChild(which));
424
 
        } else {
425
 
            dateRange = NULL;
426
 
        }
427
 
    }
428
 
    dateRangeSelected(dateRange);
429
 
}
430
 
 
431
758
void
432
759
LTMTool::metricTreeWidgetSelectionChanged()
433
760
{
435
762
}
436
763
 
437
764
/*----------------------------------------------------------------------
438
 
 * Date ranges from Seasons.xml
 
765
 * Metric settings
439
766
 *--------------------------------------------------------------------*/
440
 
void LTMTool::readSeasons()
441
 
{
442
 
    QFile seasonFile(home.absolutePath() + "/seasons.xml");
443
 
    QXmlInputSource source( &seasonFile );
444
 
    QXmlSimpleReader xmlReader;
445
 
    SeasonParser( handler );
446
 
    xmlReader.setContentHandler(&handler);
447
 
    xmlReader.setErrorHandler(&handler);
448
 
    xmlReader.parse( source );
449
 
    seasons = handler.getSeasons();
450
 
 
451
 
    int i;
452
 
    for (i=0; i <seasons.count(); i++) {
453
 
        Season season = seasons.at(i);
454
 
        QTreeWidgetItem *add = new QTreeWidgetItem(allDateRanges, USER_DATE);
455
 
        add->setText(0, season.getName());
456
 
    }
457
 
    Season season;
458
 
    QDate today = QDate::currentDate();
459
 
    QDate eom = QDate(today.year(), today.month(), today.daysInMonth());
460
 
 
461
 
    // add Default Date Ranges
462
 
    season.setName(tr("All Dates"));
463
 
    season.setType(Season::temporary);
464
 
    season.setStart(QDate::currentDate().addYears(-50));
465
 
    season.setEnd(QDate::currentDate().addYears(50));
466
 
    seasons.append(season);
467
 
 
468
 
    season.setName(tr("This Year"));
469
 
    season.setType(Season::temporary);
470
 
    season.setStart(QDate(today.year(), 1,1));
471
 
    season.setEnd(QDate(today.year(), 12, 31));
472
 
    seasons.append(season);
473
 
 
474
 
    season.setName(tr("This Month"));
475
 
    season.setType(Season::temporary);
476
 
    season.setStart(QDate(today.year(), today.month(),1));
477
 
    season.setEnd(eom);
478
 
    seasons.append(season);
479
 
 
480
 
    season.setName(tr("This Week"));
481
 
    season.setType(Season::temporary);
482
 
    // from Mon-Sun
483
 
    QDate wstart = QDate::currentDate();
484
 
    wstart = wstart.addDays(Qt::Monday - wstart.dayOfWeek());
485
 
    QDate wend = wstart.addDays(6); // first day + 6 more
486
 
    season.setStart(wstart);
487
 
    season.setEnd(wend);
488
 
    seasons.append(season);
489
 
 
490
 
    season.setName(tr("Last 7 days"));
491
 
    season.setType(Season::temporary);
492
 
    season.setStart(today.addDays(-6)); // today plus previous 6
493
 
    season.setEnd(today);
494
 
    seasons.append(season);
495
 
 
496
 
    season.setName(tr("Last 14 days"));
497
 
    season.setType(Season::temporary);
498
 
    season.setStart(today.addDays(-13));
499
 
    season.setEnd(today);
500
 
    seasons.append(season);
501
 
 
502
 
    season.setName(tr("Last 28 days"));
503
 
    season.setType(Season::temporary);
504
 
    season.setStart(today.addDays(-27));
505
 
    season.setEnd(today);
506
 
    seasons.append(season);
507
 
 
508
 
    season.setName(tr("Last 3 months"));
509
 
    season.setType(Season::temporary);
510
 
    season.setEnd(today);
511
 
    season.setStart(today.addMonths(-3));
512
 
    seasons.append(season);
513
 
 
514
 
    season.setName(tr("Last 6 months"));
515
 
    season.setType(Season::temporary);
516
 
    season.setEnd(today);
517
 
    season.setStart(today.addMonths(-6));
518
 
    seasons.append(season);
519
 
 
520
 
    season.setName(tr("Last 12 months"));
521
 
    season.setType(Season::temporary);
522
 
    season.setEnd(today);
523
 
    season.setStart(today.addMonths(-12));
524
 
    seasons.append(season);
525
 
 
526
 
    for (;i <seasons.count(); i++) {
527
 
        Season season = seasons.at(i);
528
 
        QTreeWidgetItem *add = new QTreeWidgetItem(allDateRanges, SYS_DATE);
529
 
        add->setText(0, season.getName());
530
 
    }
531
 
    dateRangeTree->expandItem(allDateRanges);
532
 
}
533
 
 
534
767
QString
535
768
LTMTool::metricName(QTreeWidgetItem *item)
536
769
{
557
790
}
558
791
 
559
792
 
560
 
int
561
 
LTMTool::newSeason(QString name, QDate start, QDate end, int type)
562
 
{
563
 
    Season add;
564
 
    add.setName(name);
565
 
    add.setStart(start);
566
 
    add.setEnd(end);
567
 
    add.setType(type);
568
 
    seasons.insert(0, add);
569
 
 
570
 
    // save changes away
571
 
    writeSeasons();
572
 
 
573
 
    QTreeWidgetItem *item = new QTreeWidgetItem(USER_DATE);
574
 
    item->setText(0, add.getName());
575
 
    allDateRanges->insertChild(0, item);
576
 
    return 0; // always add at the top
577
 
}
578
 
 
579
 
void
580
 
LTMTool::updateSeason(int index, QString name, QDate start, QDate end, int type)
581
 
{
582
 
    seasons[index].setName(name);
583
 
    seasons[index].setStart(start);
584
 
    seasons[index].setEnd(end);
585
 
    seasons[index].setType(type);
586
 
    allDateRanges->child(index)->setText(0, name);
587
 
 
588
 
    // save changes away
589
 
    writeSeasons();
590
 
 
591
 
}
592
 
 
593
 
void
594
 
LTMTool::dateRangePopup(QPoint pos)
595
 
{
596
 
    QTreeWidgetItem *item = dateRangeTree->itemAt(pos);
597
 
    if (item != NULL && item->type() != ROOT_TYPE && item->type() != SYS_DATE) {
598
 
 
599
 
        // save context
600
 
        activeDateRange = item;
601
 
 
602
 
        // create context menu
603
 
        QMenu menu(dateRangeTree);
604
 
        QAction *rename = new QAction(tr("Rename range"), dateRangeTree);
605
 
        QAction *edit = new QAction(tr("Edit details"), dateRangeTree);
606
 
        QAction *del = new QAction(tr("Delete range"), dateRangeTree);
607
 
        menu.addAction(rename);
608
 
        menu.addAction(edit);
609
 
        menu.addAction(del);
610
 
 
611
 
        // connect menu to functions
612
 
        connect(rename, SIGNAL(triggered(void)), this, SLOT(renameRange(void)));
613
 
        connect(edit, SIGNAL(triggered(void)), this, SLOT(editRange(void)));
614
 
        connect(del, SIGNAL(triggered(void)), this, SLOT(deleteRange(void)));
615
 
 
616
 
        // execute the menu
617
 
        menu.exec(dateRangeTree->mapToGlobal(pos));
618
 
    }
619
 
}
620
 
 
621
 
void
622
 
LTMTool::renameRange()
623
 
{
624
 
    // go edit the name
625
 
    activeDateRange->setFlags(activeDateRange->flags() | Qt::ItemIsEditable);
626
 
    dateRangeTree->editItem(activeDateRange, 0);
627
 
}
628
 
 
629
 
void
630
 
LTMTool::dateRangeChanged(QTreeWidgetItem*item, int)
631
 
{
632
 
    if (item != activeDateRange) return;
633
 
 
634
 
    int index = allDateRanges->indexOfChild(item);
635
 
    seasons[index].setName(item->text(0));
636
 
 
637
 
    // save changes away
638
 
    writeSeasons();
639
 
 
640
 
    // signal date selected changed
641
 
    dateRangeSelected(&seasons[index]);
642
 
}
643
 
 
644
 
void
645
 
LTMTool::editRange()
646
 
{
647
 
    // throw up modal dialog box to edit all the season
648
 
    // fields.
649
 
    int index = allDateRanges->indexOfChild(activeDateRange);
650
 
    EditSeasonDialog dialog(main, &seasons[index]);
651
 
 
652
 
    if (dialog.exec()) {
653
 
        // update name
654
 
        activeDateRange->setText(0, seasons[index].getName());
655
 
 
656
 
        // save changes away
657
 
        writeSeasons();
658
 
 
659
 
        // signal its changed!
660
 
        dateRangeSelected(&seasons[index]);
661
 
    }
662
 
}
663
 
 
664
 
void
665
 
LTMTool::deleteRange()
666
 
{
667
 
    // now delete!
668
 
    int index = allDateRanges->indexOfChild(activeDateRange);
669
 
    delete allDateRanges->takeChild(index);
670
 
    seasons.removeAt(index);
671
 
 
672
 
    // now update season.xml
673
 
    writeSeasons();
674
 
}
675
 
 
676
 
void
677
 
LTMTool::writeSeasons()
678
 
{
679
 
    // update seasons.xml
680
 
    QString file = QString(home.absolutePath() + "/seasons.xml");
681
 
    SeasonParser::serialize(file, seasons);
682
 
}
683
793
 
684
794
void
685
795
LTMTool::metricTreePopup(QPoint pos)
724
834
    int index = allMetrics->indexOfChild(activeMetric);
725
835
    QColorDialog picker(main);
726
836
    picker.setCurrentColor(metrics[index].penColor);
727
 
    QColor color = picker.getColor();
 
837
 
 
838
    // don't use native dialog, since there is a nasty bug causing focus loss
 
839
    // see https://bugreports.qt-project.org/browse/QTBUG-14889
 
840
    QColor color = picker.getColor(metrics[index].penColor, this, tr("Choose Metric Color"), QColorDialog::DontUseNativeDialog);
728
841
 
729
842
    // if we got a good color use it and notify others
730
843
    if (color.isValid()) {
734
847
}
735
848
 
736
849
void
 
850
LTMTool::selectMetric(QString symbol)
 
851
{
 
852
    for (int i=0; i<metrics.count(); i++) {
 
853
        if (metrics[i].symbol == symbol) {
 
854
            allMetrics->child(i)->setSelected(true);
 
855
        }
 
856
    }
 
857
}
 
858
 
 
859
void
737
860
LTMTool::applySettings(LTMSettings *settings)
738
861
{
739
862
    disconnect(metricTree,SIGNAL(itemSelectionChanged()), this, SLOT(metricTreeWidgetSelectionChanged()));
808
931
    curveStyle->addItem(tr("Dots"), QwtPlotCurve::Dots);
809
932
    curveStyle->setCurrentIndex(curveStyle->findData(metricDetail->curveStyle));
810
933
 
 
934
    QLabel *stackLabel = new QLabel(tr("Stack"));
 
935
    stack = new QCheckBox("", this);
 
936
    stack->setChecked(metricDetail->stack);
 
937
 
811
938
 
812
939
    QLabel *symbol = new QLabel(tr("Symbol"));
813
940
    curveSymbol = new QComboBox(this);
824
951
    QLabel *color = new QLabel(tr("Color"));
825
952
    curveColor = new QPushButton(this);
826
953
 
 
954
    QLabel *fill = new QLabel(tr("Fill curve"));
 
955
    fillCurve = new QCheckBox("", this);
 
956
    fillCurve->setChecked(metricDetail->fillCurve);
 
957
 
827
958
    // color background...
828
959
    penColor = metricDetail->penColor;
829
960
    setButtonIcon(penColor);
836
967
    showBest->setSingleStep(1.0);
837
968
    showBest->setValue(metricDetail->topN);
838
969
 
 
970
    QLabel *outN = new QLabel(tr("Highlight Outliers"));
 
971
    showOut = new QDoubleSpinBox(this);
 
972
    showOut->setDecimals(0);
 
973
    showOut->setMinimum(0);
 
974
    showOut->setMaximum(999);
 
975
    showOut->setSingleStep(1.0);
 
976
    showOut->setValue(metricDetail->topOut);
 
977
 
839
978
    QLabel *baseline = new QLabel(tr("Baseline"));
840
979
    baseLine = new QDoubleSpinBox(this);
841
980
    baseLine->setDecimals(0);
859
998
    grid->addWidget(curveStyle, 2,1);
860
999
    grid->addWidget(symbol, 3,0);
861
1000
    grid->addWidget(curveSymbol, 3,1);
862
 
    grid->addWidget(color, 4,0);
863
 
    grid->addWidget(curveColor, 4,1);
864
 
    grid->addWidget(topN, 5,0);
865
 
    grid->addWidget(showBest, 5,1);
866
 
    grid->addWidget(baseline, 6, 0);
867
 
    grid->addWidget(baseLine, 6,1);
868
 
    grid->addWidget(curveSmooth, 7,1);
869
 
    grid->addWidget(curveTrend, 8,1);
 
1001
    grid->addWidget(stackLabel, 4, 0);
 
1002
    grid->addWidget(stack, 4, 1);
 
1003
    grid->addWidget(color, 5,0);
 
1004
    grid->addWidget(curveColor, 5,1);
 
1005
    grid->addWidget(fill, 6,0);
 
1006
    grid->addWidget(fillCurve, 6,1);
 
1007
    grid->addWidget(topN, 7,0);
 
1008
    grid->addWidget(showBest, 7,1);
 
1009
    grid->addWidget(outN, 8,0);
 
1010
    grid->addWidget(showOut, 8,1);
 
1011
    grid->addWidget(baseline, 9, 0);
 
1012
    grid->addWidget(baseLine, 9,1);
 
1013
    grid->addWidget(curveSmooth, 10,1);
 
1014
    grid->addWidget(curveTrend, 11,1);
870
1015
 
871
1016
    mainLayout->addLayout(grid);
872
 
    mainLayout->addStretch();
873
1017
 
874
1018
    // Buttons
875
1019
    QHBoxLayout *buttonLayout = new QHBoxLayout;
902
1046
    metricDetail->smooth = curveSmooth->isChecked();
903
1047
    metricDetail->trend = curveTrend->isChecked();
904
1048
    metricDetail->topN = showBest->value();
 
1049
    metricDetail->topOut = showOut->value();
905
1050
    metricDetail->baseline = baseLine->value();
906
1051
    metricDetail->curveStyle = styleMap[curveStyle->currentIndex()];
907
1052
    metricDetail->symbolStyle = symbolMap[curveSymbol->currentIndex()];
908
1053
    metricDetail->penColor = penColor;
 
1054
    metricDetail->fillCurve = fillCurve->isChecked();
909
1055
    metricDetail->uname = userName->text();
910
1056
    metricDetail->uunits = userUnits->text();
 
1057
    metricDetail->stack = stack->isChecked();
911
1058
    accept();
912
1059
}
913
1060
void
921
1068
{
922
1069
    QColorDialog picker(mainWindow);
923
1070
    picker.setCurrentColor(penColor);
924
 
    QColor color = picker.getColor();
 
1071
 
 
1072
    // don't use native dialog, since there is a nasty bug causing focus loss
 
1073
    // see https://bugreports.qt-project.org/browse/QTBUG-14889
 
1074
    QColor color = picker.getColor(metricDetail->penColor, this, tr("Choose Metric Color"), QColorDialog::DontUseNativeDialog);
925
1075
 
926
1076
    if (color.isValid()) {
927
1077
        setButtonIcon(penColor=color);
948
1098
}
949
1099
 
950
1100
void
 
1101
LTMTool::clearFilter()
 
1102
{
 
1103
    filenames.clear();
 
1104
    _amFiltered = false;
 
1105
 
 
1106
    emit filterChanged();
 
1107
}
 
1108
 
 
1109
void
 
1110
LTMTool::setFilter(QStringList files)
 
1111
{
 
1112
        _amFiltered = true;
 
1113
        filenames = files;
 
1114
 
 
1115
        emit filterChanged();
 
1116
}
 
1117
 
 
1118
void
951
1119
LTMTool::translateDefaultCharts(QList<LTMSettings>&charts)
952
1120
{
953
1121
    // Map default (english) chart name to external (Localized) name
954
1122
    // New default charts need to be added to this list to be translated
955
1123
    QMap<QString, QString> chartNameMap;
956
 
    chartNameMap.insert("Aerobic Power", tr("Aerobic Power"));
957
 
    chartNameMap.insert("Anaerobic Power", tr("Anaerobic Power"));
958
 
    chartNameMap.insert("Critical Power Trend", tr("Critical Power Trend"));
959
 
    chartNameMap.insert("Power & Speed Trend", tr("Power & Speed Trend"));
960
 
    chartNameMap.insert("Cardiovascular Response", tr("Cardiovascular Response"));
961
 
    chartNameMap.insert("Training Mix", tr("Training Mix"));
962
 
    chartNameMap.insert("Tempo & Threshold Time", tr("Tempo & Threshold Time"));
963
 
    chartNameMap.insert("Time & Distance", tr("Time & Distance"));
964
 
    chartNameMap.insert("Daniels Power", tr("Daniels Power"));
965
 
    chartNameMap.insert("Skiba Power", tr("Skiba Power"));
966
 
    chartNameMap.insert("Skiba PM", tr("Skiba PM"));
967
 
    chartNameMap.insert("Daniels PM", tr("Daniels PM"));
 
1124
        chartNameMap.insert("PMC", tr("PMC"));
 
1125
        chartNameMap.insert("Track Weight", tr("Track Weight"));
 
1126
        chartNameMap.insert("Time In Power Zone (Stacked)", tr("Time In Power Zone (Stacked)"));
 
1127
        chartNameMap.insert("Time In Power Zone (Bar)", tr("Time In Power Zone (Bar)"));
 
1128
        chartNameMap.insert("Time In HR Zone", tr("Time In HR Zone"));
 
1129
        chartNameMap.insert("Power Distribution", tr("Power Distribution"));
 
1130
        chartNameMap.insert("KPI Tracker", tr("KPI Tracker"));
 
1131
        chartNameMap.insert("Critical Power Trend", tr("Critical Power Trend"));
 
1132
        chartNameMap.insert("Aerobic Power", tr("Aerobic Power"));
 
1133
        chartNameMap.insert("Aerobic WPK", tr("Aerobic WPK"));
 
1134
        chartNameMap.insert("Power Variance", tr("Power Variance"));
 
1135
        chartNameMap.insert("Power Profile", tr("Power Profile"));
 
1136
        chartNameMap.insert("Anaerobic Power", tr("Anaerobic Power"));
 
1137
        chartNameMap.insert("Anaerobic WPK", tr("Anaerobic WPK"));
 
1138
        chartNameMap.insert("Power & Speed Trend", tr("Power & Speed Trend"));
 
1139
        chartNameMap.insert("Cardiovascular Response", tr("Cardiovascular Response"));
 
1140
        chartNameMap.insert("Tempo & Threshold Time", tr("Tempo & Threshold Time"));
 
1141
        chartNameMap.insert("Training Mix", tr("Training Mix"));
 
1142
        chartNameMap.insert("Time & Distance", tr("Time & Distance"));
 
1143
        chartNameMap.insert("Skiba Power", tr("Skiba Power"));
 
1144
        chartNameMap.insert("Daniels Power", tr("Daniels Power"));
 
1145
        chartNameMap.insert("PM Ramp & Peak", tr("PM Ramp & Peak"));
 
1146
        chartNameMap.insert("Skiba PM", tr("Skiba PM"));
 
1147
        chartNameMap.insert("Daniels PM", tr("Daniels PM"));
 
1148
        chartNameMap.insert("Device Reliability", tr("Device Reliability"));
 
1149
        chartNameMap.insert("Withings Weight", tr("Withings Weight"));
 
1150
        chartNameMap.insert("Stress and Distance", tr("Stress and Distance"));
 
1151
        chartNameMap.insert("Calories vs Duration", tr("Calories vs Duration"));
968
1152
 
969
1153
    for(int i=0; i<charts.count(); i++) {
970
1154
        // Replace chart name for localized version, default to english name
971
1155
        charts[i].name = chartNameMap.value(charts[i].name, charts[i].name);
972
 
        // For each metric in chart
973
 
        for (int j=0; j<charts[i].metrics.count(); j++) {
974
 
            if (charts[i].metrics[j].uname == charts[i].metrics[j].name) { // Default uname
975
 
                for (int k=0; k<metrics.count(); k++) // Look in metrics list
976
 
                    if (metrics[k].symbol == charts[i].metrics[j].symbol) { // Replace with default translated values
977
 
                        charts[i].metrics[j].name = metrics[k].name;
978
 
                        charts[i].metrics[j].uname = metrics[k].uname;
979
 
                        charts[i].metrics[j].uunits = metrics[k].uunits;
980
 
                        break;
981
 
                    }
 
1156
    }
 
1157
}
 
1158
 
 
1159
// metricDetails gives access to the metric details catalog by symbol
 
1160
MetricDetail*
 
1161
LTMTool::metricDetails(QString symbol)
 
1162
{
 
1163
    for(int i = 0; i < metrics.count(); i++)
 
1164
        if (metrics[i].symbol == symbol)
 
1165
            return &metrics[i];
 
1166
    return NULL;
 
1167
}
 
1168
 
 
1169
void
 
1170
LTMTool::translateMetrics(MainWindow *main, const QDir &home, LTMSettings *settings)
 
1171
{
 
1172
    static QMap<QString, QString> unitsMap;
 
1173
    // LTMTool instance is created to have access to metrics catalog
 
1174
    LTMTool* ltmTool = new LTMTool(main, home, false);
 
1175
    if (unitsMap.isEmpty()) {
 
1176
        foreach(MetricDetail metric, ltmTool->metrics) {
 
1177
            if (metric.units != "")  // translate units
 
1178
                    unitsMap.insert(metric.units, metric.uunits);
 
1179
            if (metric.uunits != "") // keep already translated the same
 
1180
                    unitsMap.insert(metric.uunits, metric.uunits);
 
1181
        }
 
1182
    }
 
1183
    for (int j=0; j < settings->metrics.count(); j++) {
 
1184
        if (settings->metrics[j].uname == settings->metrics[j].name) {
 
1185
            MetricDetail* mdp = ltmTool->metricDetails(settings->metrics[j].symbol);
 
1186
            if (mdp != NULL) {
 
1187
                // Replace with default translated name
 
1188
                settings->metrics[j].name = mdp->name;
 
1189
                settings->metrics[j].uname = mdp->uname;
 
1190
                // replace with translated units, if available
 
1191
                if (settings->metrics[j].uunits != "")
 
1192
                    settings->metrics[j].uunits = unitsMap.value(settings->metrics[j].uunits,
 
1193
                                                                 mdp->uunits);
982
1194
            }
983
1195
        }
984
1196
    }
 
1197
    delete ltmTool;
985
1198
}