Auto status change to "Under Review"
@@ -1,151 +1,151 | |||||
1 | #include <Data/ArrayData.h> |
|
1 | #include <Data/ArrayData.h> | |
2 | #include <Data/OptionalAxis.h> |
|
2 | #include <Data/OptionalAxis.h> | |
3 |
|
3 | |||
4 | #include <QObject> |
|
4 | #include <QObject> | |
5 | #include <QtTest> |
|
5 | #include <QtTest> | |
6 |
|
6 | |||
7 | Q_DECLARE_METATYPE(OptionalAxis) |
|
7 | Q_DECLARE_METATYPE(OptionalAxis) | |
8 | Q_DECLARE_METATYPE(Unit) |
|
8 | Q_DECLARE_METATYPE(Unit) | |
9 |
|
9 | |||
10 | class TestOptionalAxis : public QObject { |
|
10 | class TestOptionalAxis : public QObject { | |
11 | Q_OBJECT |
|
11 | Q_OBJECT | |
12 |
|
12 | |||
13 | private slots: |
|
13 | private slots: | |
14 | /// Tests the creation of a undefined axis |
|
14 | /// Tests the creation of a undefined axis | |
15 | void testNotDefinedAxisCtor(); |
|
15 | void testNotDefinedAxisCtor(); | |
16 |
|
16 | |||
17 | /// Tests the creation of a undefined axis |
|
17 | /// Tests the creation of a undefined axis | |
18 | void testDefinedAxisCtor_data(); |
|
18 | void testDefinedAxisCtor_data(); | |
19 | void testDefinedAxisCtor(); |
|
19 | void testDefinedAxisCtor(); | |
20 |
|
20 | |||
21 | /// Tests @sa OptionalAxis::at() method |
|
21 | /// Tests @sa OptionalAxis::at() method | |
22 | void testAt_data(); |
|
22 | void testAt_data(); | |
23 | void testAt(); |
|
23 | void testAt(); | |
24 |
|
24 | |||
25 | /// Tests @sa OptionalAxis::size() method |
|
25 | /// Tests @sa OptionalAxis::size() method | |
26 | void testSize_data(); |
|
26 | void testSize_data(); | |
27 | void testSize(); |
|
27 | void testSize(); | |
28 |
|
28 | |||
29 | /// Tests @sa OptionalAxis::unit() method |
|
29 | /// Tests @sa OptionalAxis::unit() method | |
30 | void testUnit_data(); |
|
30 | void testUnit_data(); | |
31 | void testUnit(); |
|
31 | void testUnit(); | |
32 | }; |
|
32 | }; | |
33 |
|
33 | |||
34 | void TestOptionalAxis::testNotDefinedAxisCtor() |
|
34 | void TestOptionalAxis::testNotDefinedAxisCtor() | |
35 | { |
|
35 | { | |
36 | OptionalAxis notDefinedAxis{}; |
|
36 | OptionalAxis notDefinedAxis{}; | |
37 | QVERIFY(!notDefinedAxis.isDefined()); |
|
37 | QVERIFY(!notDefinedAxis.isDefined()); | |
38 | } |
|
38 | } | |
39 |
|
39 | |||
40 | void TestOptionalAxis::testDefinedAxisCtor_data() |
|
40 | void TestOptionalAxis::testDefinedAxisCtor_data() | |
41 | { |
|
41 | { | |
42 | QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis |
|
42 | QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis | |
43 | QTest::addColumn<std::vector<double> >( |
|
43 | QTest::addColumn<std::vector<double> >( | |
44 | "data"); // Values assigned to the axis when 'noData' flag is set to false |
|
44 | "data"); // Values assigned to the axis when 'noData' flag is set to false | |
45 | QTest::addColumn<Unit>("unit"); // Unit assigned to the axis |
|
45 | QTest::addColumn<Unit>("unit"); // Unit assigned to the axis | |
46 |
|
46 | |||
47 | QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"}; |
|
47 | QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"}; | |
48 | QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"}; |
|
48 | QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"}; | |
49 | } |
|
49 | } | |
50 |
|
50 | |||
51 | void TestOptionalAxis::testDefinedAxisCtor() |
|
51 | void TestOptionalAxis::testDefinedAxisCtor() | |
52 | { |
|
52 | { | |
53 | QFETCH(bool, noData); |
|
53 | QFETCH(bool, noData); | |
54 | QFETCH(Unit, unit); |
|
54 | QFETCH(Unit, unit); | |
55 |
|
55 | |||
56 | // When there is no data, we expect that the constructor returns exception |
|
56 | // When there is no data, we expect that the constructor returns exception | |
57 | if (noData) { |
|
57 | if (noData) { | |
58 | QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument); |
|
58 | QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument); | |
59 | } |
|
59 | } | |
60 | else { |
|
60 | else { | |
61 | QFETCH(std::vector<double>, data); |
|
61 | QFETCH(std::vector<double>, data); | |
62 |
|
62 | |||
63 | OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit}; |
|
63 | OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit}; | |
64 | QVERIFY(axis.isDefined()); |
|
64 | QVERIFY(axis.isDefined()); | |
65 | } |
|
65 | } | |
66 | } |
|
66 | } | |
67 |
|
67 | |||
68 | void TestOptionalAxis::testAt_data() |
|
68 | void TestOptionalAxis::testAt_data() | |
69 | { |
|
69 | { | |
70 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) |
|
70 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) | |
71 | QTest::addColumn<int>("index"); // Index to test in the axis |
|
71 | QTest::addColumn<int>("index"); // Index to test in the axis | |
72 | QTest::addColumn<double>("expectedValue"); // Expected axis value for the index |
|
72 | QTest::addColumn<double>("expectedValue"); // Expected axis value for the index | |
73 |
|
73 | |||
74 | OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), |
|
74 | OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), | |
75 | Unit{"Hz"}}; |
|
75 | Unit{"Hz"}}; | |
76 |
|
76 | |||
77 | QTest::newRow("data1") << definedAxis << 0 << 1.; |
|
77 | QTest::newRow("data1") << definedAxis << 0 << 1.; | |
78 | QTest::newRow("data2") << definedAxis << 1 << 2.; |
|
78 | QTest::newRow("data2") << definedAxis << 1 << 2.; | |
79 | QTest::newRow("data3") << definedAxis << 2 << 3.; |
|
79 | QTest::newRow("data3") << definedAxis << 2 << 3.; | |
80 | QTest::newRow("data4 (index out of bounds)") |
|
80 | QTest::newRow("data4 (index out of bounds)") | |
81 | << definedAxis << 3 |
|
81 | << definedAxis << 3 | |
82 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index |
|
82 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index | |
83 | QTest::newRow("data5 (index out of bounds)") |
|
83 | QTest::newRow("data5 (index out of bounds)") | |
84 | << definedAxis << -1 |
|
84 | << definedAxis << -1 | |
85 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index |
|
85 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index | |
86 | QTest::newRow("data6 (axis not defined)") |
|
86 | QTest::newRow("data6 (axis not defined)") | |
87 | << OptionalAxis{} << 0 |
|
87 | << OptionalAxis{} << 0 | |
88 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis |
|
88 | << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis | |
89 | } |
|
89 | } | |
90 |
|
90 | |||
91 | void TestOptionalAxis::testAt() |
|
91 | void TestOptionalAxis::testAt() | |
92 | { |
|
92 | { | |
93 | QFETCH(OptionalAxis, axis); |
|
93 | QFETCH(OptionalAxis, axis); | |
94 | QFETCH(int, index); |
|
94 | QFETCH(int, index); | |
95 | QFETCH(double, expectedValue); |
|
95 | QFETCH(double, expectedValue); | |
96 |
|
96 | |||
97 | auto value = axis.at(index); |
|
97 | auto value = axis.at(index); | |
98 | QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue); |
|
98 | QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue); | |
99 | } |
|
99 | } | |
100 |
|
100 | |||
101 | void TestOptionalAxis::testSize_data() |
|
101 | void TestOptionalAxis::testSize_data() | |
102 | { |
|
102 | { | |
103 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) |
|
103 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) | |
104 | QTest::addColumn<int>("expectedSize"); // Expected number of data in the axis |
|
104 | QTest::addColumn<int>("expectedSize"); // Expected number of data in the axis | |
105 |
|
105 | |||
106 | // Lambda that creates default defined axis (with the values passed in parameter) |
|
106 | // Lambda that creates default defined axis (with the values passed in parameter) | |
107 | auto axis = [](std::vector<double> values) { |
|
107 | auto axis = [](std::vector<double> values) { | |
108 | return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}}; |
|
108 | return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}}; | |
109 | }; |
|
109 | }; | |
110 |
|
110 | |||
111 | QTest::newRow("data1") << axis({}) << 0; |
|
111 | QTest::newRow("data1") << axis({}) << 0; | |
112 | QTest::newRow("data2") << axis({1, 2, 3}) << 3; |
|
112 | QTest::newRow("data2") << axis({1, 2, 3}) << 3; | |
113 | QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4; |
|
113 | QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4; | |
114 | QTest::newRow("data4 (axis not defined)") |
|
114 | QTest::newRow("data4 (axis not defined)") << OptionalAxis{} | |
115 |
|
|
115 | << 0; // Expects 0 for undefined axis | |
116 | } |
|
116 | } | |
117 |
|
117 | |||
118 | void TestOptionalAxis::testSize() |
|
118 | void TestOptionalAxis::testSize() | |
119 | { |
|
119 | { | |
120 | QFETCH(OptionalAxis, axis); |
|
120 | QFETCH(OptionalAxis, axis); | |
121 | QFETCH(int, expectedSize); |
|
121 | QFETCH(int, expectedSize); | |
122 |
|
122 | |||
123 | QCOMPARE(axis.size(), expectedSize); |
|
123 | QCOMPARE(axis.size(), expectedSize); | |
124 | } |
|
124 | } | |
125 |
|
125 | |||
126 | void TestOptionalAxis::testUnit_data() |
|
126 | void TestOptionalAxis::testUnit_data() | |
127 | { |
|
127 | { | |
128 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) |
|
128 | QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not) | |
129 | QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis |
|
129 | QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis | |
130 |
|
130 | |||
131 | // Lambda that creates default defined axis (with the unit passed in parameter) |
|
131 | // Lambda that creates default defined axis (with the unit passed in parameter) | |
132 | auto axis = [](Unit unit) { |
|
132 | auto axis = [](Unit unit) { | |
133 | return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit}; |
|
133 | return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit}; | |
134 | }; |
|
134 | }; | |
135 |
|
135 | |||
136 | QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"}; |
|
136 | QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"}; | |
137 | QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true}; |
|
137 | QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true}; | |
138 | QTest::newRow("data3 (axis not defined)") |
|
138 | QTest::newRow("data3 (axis not defined)") << OptionalAxis{} | |
139 |
|
|
139 | << Unit{}; // Expects default unit for undefined axis | |
140 | } |
|
140 | } | |
141 |
|
141 | |||
142 | void TestOptionalAxis::testUnit() |
|
142 | void TestOptionalAxis::testUnit() | |
143 | { |
|
143 | { | |
144 | QFETCH(OptionalAxis, axis); |
|
144 | QFETCH(OptionalAxis, axis); | |
145 | QFETCH(Unit, expectedUnit); |
|
145 | QFETCH(Unit, expectedUnit); | |
146 |
|
146 | |||
147 | QCOMPARE(axis.unit(), expectedUnit); |
|
147 | QCOMPARE(axis.unit(), expectedUnit); | |
148 | } |
|
148 | } | |
149 |
|
149 | |||
150 | QTEST_MAIN(TestOptionalAxis) |
|
150 | QTEST_MAIN(TestOptionalAxis) | |
151 | #include "TestOptionalAxis.moc" |
|
151 | #include "TestOptionalAxis.moc" |
@@ -1,426 +1,426 | |||||
1 | #include "Data/ScalarSeries.h" |
|
1 | #include "Data/ScalarSeries.h" | |
2 |
|
2 | |||
3 | #include "DataSeriesBuilders.h" |
|
3 | #include "DataSeriesBuilders.h" | |
4 | #include "DataSeriesUtils.h" |
|
4 | #include "DataSeriesUtils.h" | |
5 |
|
5 | |||
6 | #include <QObject> |
|
6 | #include <QObject> | |
7 | #include <QtTest> |
|
7 | #include <QtTest> | |
8 |
|
8 | |||
9 | /** |
|
9 | /** | |
10 | * @brief The TestScalarSeries class defines unit tests on scalar series. |
|
10 | * @brief The TestScalarSeries class defines unit tests on scalar series. | |
11 | * |
|
11 | * | |
12 | * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils) |
|
12 | * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils) | |
13 | */ |
|
13 | */ | |
14 | class TestScalarSeries : public QObject { |
|
14 | class TestScalarSeries : public QObject { | |
15 | Q_OBJECT |
|
15 | Q_OBJECT | |
16 | private slots: |
|
16 | private slots: | |
17 | /// Tests construction of a scalar series |
|
17 | /// Tests construction of a scalar series | |
18 | void testCtor_data(); |
|
18 | void testCtor_data(); | |
19 | void testCtor(); |
|
19 | void testCtor(); | |
20 |
|
20 | |||
21 | /// Tests merge of two scalar series |
|
21 | /// Tests merge of two scalar series | |
22 | void testMerge_data(); |
|
22 | void testMerge_data(); | |
23 | void testMerge(); |
|
23 | void testMerge(); | |
24 |
|
24 | |||
25 | /// Tests merge of a vector series in a scalar series |
|
25 | /// Tests merge of a vector series in a scalar series | |
26 | void testMergeWithVector_data(); |
|
26 | void testMergeWithVector_data(); | |
27 | void testMergeWithVector(); |
|
27 | void testMergeWithVector(); | |
28 |
|
28 | |||
29 | /// Tests get min x-axis data of a scalar series |
|
29 | /// Tests get min x-axis data of a scalar series | |
30 | void testMinXAxisData_data(); |
|
30 | void testMinXAxisData_data(); | |
31 | void testMinXAxisData(); |
|
31 | void testMinXAxisData(); | |
32 |
|
32 | |||
33 | /// Tests get max x-axis data of a scalar series |
|
33 | /// Tests get max x-axis data of a scalar series | |
34 | void testMaxXAxisData_data(); |
|
34 | void testMaxXAxisData_data(); | |
35 | void testMaxXAxisData(); |
|
35 | void testMaxXAxisData(); | |
36 |
|
36 | |||
37 | /// Tests purge of a scalar series |
|
37 | /// Tests purge of a scalar series | |
38 | void testPurge_data(); |
|
38 | void testPurge_data(); | |
39 | void testPurge(); |
|
39 | void testPurge(); | |
40 |
|
40 | |||
41 | /// Tests get x-axis range of a scalar series |
|
41 | /// Tests get x-axis range of a scalar series | |
42 | void testXAxisRange_data(); |
|
42 | void testXAxisRange_data(); | |
43 | void testXAxisRange(); |
|
43 | void testXAxisRange(); | |
44 |
|
44 | |||
45 | /// Tests get values bounds of a scalar series |
|
45 | /// Tests get values bounds of a scalar series | |
46 | void testValuesBounds_data(); |
|
46 | void testValuesBounds_data(); | |
47 | void testValuesBounds(); |
|
47 | void testValuesBounds(); | |
48 | }; |
|
48 | }; | |
49 |
|
49 | |||
50 | void TestScalarSeries::testCtor_data() |
|
50 | void TestScalarSeries::testCtor_data() | |
51 | { |
|
51 | { | |
52 | // x-axis data |
|
52 | // x-axis data | |
53 | QTest::addColumn<DataContainer>("xAxisData"); |
|
53 | QTest::addColumn<DataContainer>("xAxisData"); | |
54 | // values data |
|
54 | // values data | |
55 | QTest::addColumn<DataContainer>("valuesData"); |
|
55 | QTest::addColumn<DataContainer>("valuesData"); | |
56 |
|
56 | |||
57 | // construction expected to be valid |
|
57 | // construction expected to be valid | |
58 | QTest::addColumn<bool>("expectOK"); |
|
58 | QTest::addColumn<bool>("expectOK"); | |
59 | // expected x-axis data (when construction is valid) |
|
59 | // expected x-axis data (when construction is valid) | |
60 | QTest::addColumn<DataContainer>("expectedXAxisData"); |
|
60 | QTest::addColumn<DataContainer>("expectedXAxisData"); | |
61 | // expected values data (when construction is valid) |
|
61 | // expected values data (when construction is valid) | |
62 | QTest::addColumn<DataContainer>("expectedValuesData"); |
|
62 | QTest::addColumn<DataContainer>("expectedValuesData"); | |
63 |
|
63 | |||
64 | QTest::newRow("invalidData (different sizes of vectors)") |
|
64 | QTest::newRow("invalidData (different sizes of vectors)") | |
65 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << false |
|
65 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << false | |
66 | << DataContainer{} << DataContainer{}; |
|
66 | << DataContainer{} << DataContainer{}; | |
67 |
|
67 | |||
68 | QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.} |
|
68 | QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.} | |
69 | << DataContainer{100., 200., 300., 400., 500.} << true |
|
69 | << DataContainer{100., 200., 300., 400., 500.} << true | |
70 | << DataContainer{1., 2., 3., 4., 5.} |
|
70 | << DataContainer{1., 2., 3., 4., 5.} | |
71 | << DataContainer{100., 200., 300., 400., 500.}; |
|
71 | << DataContainer{100., 200., 300., 400., 500.}; | |
72 |
|
72 | |||
73 | QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.} |
|
73 | QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.} | |
74 | << DataContainer{100., 200., 300., 400., 500.} << true |
|
74 | << DataContainer{100., 200., 300., 400., 500.} << true | |
75 | << DataContainer{1., 2., 3., 4., 5.} |
|
75 | << DataContainer{1., 2., 3., 4., 5.} | |
76 | << DataContainer{500., 400., 300., 200., 100.}; |
|
76 | << DataContainer{500., 400., 300., 200., 100.}; | |
77 |
|
77 | |||
78 | QTest::newRow("unsortedData2") |
|
78 | QTest::newRow("unsortedData2") | |
79 | << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} << true |
|
79 | << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} << true | |
80 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.}; |
|
80 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.}; | |
81 | } |
|
81 | } | |
82 |
|
82 | |||
83 | void TestScalarSeries::testCtor() |
|
83 | void TestScalarSeries::testCtor() | |
84 | { |
|
84 | { | |
85 | // Creates series |
|
85 | // Creates series | |
86 | QFETCH(DataContainer, xAxisData); |
|
86 | QFETCH(DataContainer, xAxisData); | |
87 | QFETCH(DataContainer, valuesData); |
|
87 | QFETCH(DataContainer, valuesData); | |
88 | QFETCH(bool, expectOK); |
|
88 | QFETCH(bool, expectOK); | |
89 |
|
89 | |||
90 | if (expectOK) { |
|
90 | if (expectOK) { | |
91 | auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), |
|
91 | auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), | |
92 | Unit{}, Unit{}); |
|
92 | Unit{}, Unit{}); | |
93 |
|
93 | |||
94 | // Validates results : we check that the data series is sorted on its x-axis data |
|
94 | // Validates results : we check that the data series is sorted on its x-axis data | |
95 | QFETCH(DataContainer, expectedXAxisData); |
|
95 | QFETCH(DataContainer, expectedXAxisData); | |
96 | QFETCH(DataContainer, expectedValuesData); |
|
96 | QFETCH(DataContainer, expectedValuesData); | |
97 |
|
97 | |||
98 | validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData); |
|
98 | validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData); | |
99 | } |
|
99 | } | |
100 | else { |
|
100 | else { | |
101 | QVERIFY_EXCEPTION_THROWN(std::make_shared<ScalarSeries>( |
|
101 | QVERIFY_EXCEPTION_THROWN(std::make_shared<ScalarSeries>( | |
102 | std::move(xAxisData), std::move(valuesData), Unit{}, Unit{}), |
|
102 | std::move(xAxisData), std::move(valuesData), Unit{}, Unit{}), | |
103 | std::invalid_argument); |
|
103 | std::invalid_argument); | |
104 | } |
|
104 | } | |
105 | } |
|
105 | } | |
106 |
|
106 | |||
107 | void TestScalarSeries::testMerge_data() |
|
107 | void TestScalarSeries::testMerge_data() | |
108 | { |
|
108 | { | |
109 | testMerge_struct<ScalarSeries, DataContainer>(); |
|
109 | testMerge_struct<ScalarSeries, DataContainer>(); | |
110 |
|
110 | |||
111 | QTest::newRow("sortedMerge") << ScalarBuilder{} |
|
111 | QTest::newRow("sortedMerge") << ScalarBuilder{} | |
112 | .setX({1., 2., 3., 4., 5.}) |
|
112 | .setX({1., 2., 3., 4., 5.}) | |
113 | .setValues({100., 200., 300., 400., 500.}) |
|
113 | .setValues({100., 200., 300., 400., 500.}) | |
114 | .build() |
|
114 | .build() | |
115 | << ScalarBuilder{} |
|
115 | << ScalarBuilder{} | |
116 | .setX({6., 7., 8., 9., 10.}) |
|
116 | .setX({6., 7., 8., 9., 10.}) | |
117 | .setValues({600., 700., 800., 900., 1000.}) |
|
117 | .setValues({600., 700., 800., 900., 1000.}) | |
118 | .build() |
|
118 | .build() | |
119 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} |
|
119 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} | |
120 | << DataContainer{100., 200., 300., 400., 500., |
|
120 | << DataContainer{100., 200., 300., 400., 500., | |
121 | 600., 700., 800., 900., 1000.}; |
|
121 | 600., 700., 800., 900., 1000.}; | |
122 |
|
122 | |||
123 | QTest::newRow("unsortedMerge") |
|
123 | QTest::newRow("unsortedMerge") | |
124 | << ScalarBuilder{} |
|
124 | << ScalarBuilder{} | |
125 | .setX({6., 7., 8., 9., 10.}) |
|
125 | .setX({6., 7., 8., 9., 10.}) | |
126 | .setValues({600., 700., 800., 900., 1000.}) |
|
126 | .setValues({600., 700., 800., 900., 1000.}) | |
127 | .build() |
|
127 | .build() | |
128 | << ScalarBuilder{} |
|
128 | << ScalarBuilder{} | |
129 | .setX({1., 2., 3., 4., 5.}) |
|
129 | .setX({1., 2., 3., 4., 5.}) | |
130 | .setValues({100., 200., 300., 400., 500.}) |
|
130 | .setValues({100., 200., 300., 400., 500.}) | |
131 | .build() |
|
131 | .build() | |
132 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} |
|
132 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} | |
133 | << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.}; |
|
133 | << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.}; | |
134 |
|
134 | |||
135 | QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)") |
|
135 | QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)") | |
136 | << ScalarBuilder{} |
|
136 | << ScalarBuilder{} | |
137 | .setX({1., 2., 8., 9., 10}) |
|
137 | .setX({1., 2., 8., 9., 10}) | |
138 | .setValues({100., 200., 800., 900., 1000.}) |
|
138 | .setValues({100., 200., 800., 900., 1000.}) | |
139 | .build() |
|
139 | .build() | |
140 | << ScalarBuilder{} |
|
140 | << ScalarBuilder{} | |
141 | .setX({3., 4., 5., 6., 7.}) |
|
141 | .setX({3., 4., 5., 6., 7.}) | |
142 | .setValues({300., 400., 500., 600., 700.}) |
|
142 | .setValues({300., 400., 500., 600., 700.}) | |
143 | .build() |
|
143 | .build() | |
144 | << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.}; |
|
144 | << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.}; | |
145 |
|
145 | |||
146 | QTest::newRow("unsortedMerge3") |
|
146 | QTest::newRow("unsortedMerge3") | |
147 | << ScalarBuilder{} |
|
147 | << ScalarBuilder{} | |
148 | .setX({3., 4., 5., 7., 8}) |
|
148 | .setX({3., 4., 5., 7., 8}) | |
149 | .setValues({300., 400., 500., 700., 800.}) |
|
149 | .setValues({300., 400., 500., 700., 800.}) | |
150 | .build() |
|
150 | .build() | |
151 | << ScalarBuilder{} |
|
151 | << ScalarBuilder{} | |
152 | .setX({1., 2., 3., 7., 10.}) |
|
152 | .setX({1., 2., 3., 7., 10.}) | |
153 | .setValues({100., 200., 333., 777., 1000.}) |
|
153 | .setValues({100., 200., 333., 777., 1000.}) | |
154 | .build() |
|
154 | .build() | |
155 | << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.} |
|
155 | << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.} | |
156 | << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.}; |
|
156 | << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.}; | |
157 |
|
157 | |||
158 | QTest::newRow("emptySource") << ScalarBuilder{} |
|
158 | QTest::newRow("emptySource") << ScalarBuilder{} | |
159 | .setX({3., 4., 5., 7., 8}) |
|
159 | .setX({3., 4., 5., 7., 8}) | |
160 | .setValues({300., 400., 500., 700., 800.}) |
|
160 | .setValues({300., 400., 500., 700., 800.}) | |
161 | .build() |
|
161 | .build() | |
162 | << ScalarBuilder{}.setX({}).setValues({}).build() |
|
162 | << ScalarBuilder{}.setX({}).setValues({}).build() | |
163 | << DataContainer{3., 4., 5., 7., 8.} |
|
163 | << DataContainer{3., 4., 5., 7., 8.} | |
164 | << DataContainer{300., 400., 500., 700., 800.}; |
|
164 | << DataContainer{300., 400., 500., 700., 800.}; | |
165 | } |
|
165 | } | |
166 |
|
166 | |||
167 | void TestScalarSeries::testMerge() |
|
167 | void TestScalarSeries::testMerge() | |
168 | { |
|
168 | { | |
169 | testMerge_t<ScalarSeries, DataContainer>(); |
|
169 | testMerge_t<ScalarSeries, DataContainer>(); | |
170 | } |
|
170 | } | |
171 |
|
171 | |||
172 | void TestScalarSeries::testMergeWithVector_data() |
|
172 | void TestScalarSeries::testMergeWithVector_data() | |
173 | { |
|
173 | { | |
174 | testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>(); |
|
174 | testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>(); | |
175 |
|
175 | |||
176 | QTest::newRow("mergeVectorInScalar") |
|
176 | QTest::newRow("mergeVectorInScalar") << ScalarBuilder{} | |
177 | << ScalarBuilder{} |
|
|||
178 | .setX({1., 2., 3., 4., 5.}) |
|
177 | .setX({1., 2., 3., 4., 5.}) | |
179 | .setValues({100., 200., 300., 400., 500.}) |
|
178 | .setValues({100., 200., 300., 400., 500.}) | |
180 | .build() |
|
179 | .build() | |
181 | << VectorBuilder{} |
|
180 | << VectorBuilder{} | |
182 | .setX({6., 7., 8., 9., 10.}) |
|
181 | .setX({6., 7., 8., 9., 10.}) | |
183 | .setXValues({600., 700., 800., 900., 1000.}) |
|
182 | .setXValues({600., 700., 800., 900., 1000.}) | |
184 | .setYValues({610., 710., 810., 910., 1010.}) |
|
183 | .setYValues({610., 710., 810., 910., 1010.}) | |
185 | .setZValues({620., 720., 820., 920., 1020.}) |
|
184 | .setZValues({620., 720., 820., 920., 1020.}) | |
186 | .build() |
|
185 | .build() | |
187 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.}; |
|
186 | << DataContainer{1., 2., 3., 4., 5.} | |
|
187 | << DataContainer{100., 200., 300., 400., 500.}; | |||
188 | } |
|
188 | } | |
189 |
|
189 | |||
190 | void TestScalarSeries::testMergeWithVector() |
|
190 | void TestScalarSeries::testMergeWithVector() | |
191 | { |
|
191 | { | |
192 | testMergeDifferentTypes_t<VectorSeries, ScalarSeries>(); |
|
192 | testMergeDifferentTypes_t<VectorSeries, ScalarSeries>(); | |
193 | } |
|
193 | } | |
194 |
|
194 | |||
195 | void TestScalarSeries::testMinXAxisData_data() |
|
195 | void TestScalarSeries::testMinXAxisData_data() | |
196 | { |
|
196 | { | |
197 | testMinXAxisData_struct<ScalarSeries>(); |
|
197 | testMinXAxisData_struct<ScalarSeries>(); | |
198 |
|
198 | |||
199 | QTest::newRow("minData1") << ScalarBuilder{} |
|
199 | QTest::newRow("minData1") << ScalarBuilder{} | |
200 | .setX({1., 2., 3., 4., 5.}) |
|
200 | .setX({1., 2., 3., 4., 5.}) | |
201 | .setValues({100., 200., 300., 400., 500.}) |
|
201 | .setValues({100., 200., 300., 400., 500.}) | |
202 | .build() |
|
202 | .build() | |
203 | << 0. << true << 1.; |
|
203 | << 0. << true << 1.; | |
204 | QTest::newRow("minData2") << ScalarBuilder{} |
|
204 | QTest::newRow("minData2") << ScalarBuilder{} | |
205 | .setX({1., 2., 3., 4., 5.}) |
|
205 | .setX({1., 2., 3., 4., 5.}) | |
206 | .setValues({100., 200., 300., 400., 500.}) |
|
206 | .setValues({100., 200., 300., 400., 500.}) | |
207 | .build() |
|
207 | .build() | |
208 | << 1. << true << 1.; |
|
208 | << 1. << true << 1.; | |
209 | QTest::newRow("minData3") << ScalarBuilder{} |
|
209 | QTest::newRow("minData3") << ScalarBuilder{} | |
210 | .setX({1., 2., 3., 4., 5.}) |
|
210 | .setX({1., 2., 3., 4., 5.}) | |
211 | .setValues({100., 200., 300., 400., 500.}) |
|
211 | .setValues({100., 200., 300., 400., 500.}) | |
212 | .build() |
|
212 | .build() | |
213 | << 1.1 << true << 2.; |
|
213 | << 1.1 << true << 2.; | |
214 | QTest::newRow("minData4") << ScalarBuilder{} |
|
214 | QTest::newRow("minData4") << ScalarBuilder{} | |
215 | .setX({1., 2., 3., 4., 5.}) |
|
215 | .setX({1., 2., 3., 4., 5.}) | |
216 | .setValues({100., 200., 300., 400., 500.}) |
|
216 | .setValues({100., 200., 300., 400., 500.}) | |
217 | .build() |
|
217 | .build() | |
218 | << 5. << true << 5.; |
|
218 | << 5. << true << 5.; | |
219 | QTest::newRow("minData5") << ScalarBuilder{} |
|
219 | QTest::newRow("minData5") << ScalarBuilder{} | |
220 | .setX({1., 2., 3., 4., 5.}) |
|
220 | .setX({1., 2., 3., 4., 5.}) | |
221 | .setValues({100., 200., 300., 400., 500.}) |
|
221 | .setValues({100., 200., 300., 400., 500.}) | |
222 | .build() |
|
222 | .build() | |
223 | << 5.1 << false << std::numeric_limits<double>::quiet_NaN(); |
|
223 | << 5.1 << false << std::numeric_limits<double>::quiet_NaN(); | |
224 | QTest::newRow("minData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false |
|
224 | QTest::newRow("minData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false | |
225 | << std::numeric_limits<double>::quiet_NaN(); |
|
225 | << std::numeric_limits<double>::quiet_NaN(); | |
226 | } |
|
226 | } | |
227 |
|
227 | |||
228 | void TestScalarSeries::testMinXAxisData() |
|
228 | void TestScalarSeries::testMinXAxisData() | |
229 | { |
|
229 | { | |
230 | testMinXAxisData_t<ScalarSeries>(); |
|
230 | testMinXAxisData_t<ScalarSeries>(); | |
231 | } |
|
231 | } | |
232 |
|
232 | |||
233 | void TestScalarSeries::testMaxXAxisData_data() |
|
233 | void TestScalarSeries::testMaxXAxisData_data() | |
234 | { |
|
234 | { | |
235 | testMaxXAxisData_struct<ScalarSeries>(); |
|
235 | testMaxXAxisData_struct<ScalarSeries>(); | |
236 |
|
236 | |||
237 | QTest::newRow("maxData1") << ScalarBuilder{} |
|
237 | QTest::newRow("maxData1") << ScalarBuilder{} | |
238 | .setX({1., 2., 3., 4., 5.}) |
|
238 | .setX({1., 2., 3., 4., 5.}) | |
239 | .setValues({100., 200., 300., 400., 500.}) |
|
239 | .setValues({100., 200., 300., 400., 500.}) | |
240 | .build() |
|
240 | .build() | |
241 | << 6. << true << 5.; |
|
241 | << 6. << true << 5.; | |
242 | QTest::newRow("maxData2") << ScalarBuilder{} |
|
242 | QTest::newRow("maxData2") << ScalarBuilder{} | |
243 | .setX({1., 2., 3., 4., 5.}) |
|
243 | .setX({1., 2., 3., 4., 5.}) | |
244 | .setValues({100., 200., 300., 400., 500.}) |
|
244 | .setValues({100., 200., 300., 400., 500.}) | |
245 | .build() |
|
245 | .build() | |
246 | << 5. << true << 5.; |
|
246 | << 5. << true << 5.; | |
247 | QTest::newRow("maxData3") << ScalarBuilder{} |
|
247 | QTest::newRow("maxData3") << ScalarBuilder{} | |
248 | .setX({1., 2., 3., 4., 5.}) |
|
248 | .setX({1., 2., 3., 4., 5.}) | |
249 | .setValues({100., 200., 300., 400., 500.}) |
|
249 | .setValues({100., 200., 300., 400., 500.}) | |
250 | .build() |
|
250 | .build() | |
251 | << 4.9 << true << 4.; |
|
251 | << 4.9 << true << 4.; | |
252 | QTest::newRow("maxData4") << ScalarBuilder{} |
|
252 | QTest::newRow("maxData4") << ScalarBuilder{} | |
253 | .setX({1., 2., 3., 4., 5.}) |
|
253 | .setX({1., 2., 3., 4., 5.}) | |
254 | .setValues({100., 200., 300., 400., 500.}) |
|
254 | .setValues({100., 200., 300., 400., 500.}) | |
255 | .build() |
|
255 | .build() | |
256 | << 1.1 << true << 1.; |
|
256 | << 1.1 << true << 1.; | |
257 | QTest::newRow("maxData5") << ScalarBuilder{} |
|
257 | QTest::newRow("maxData5") << ScalarBuilder{} | |
258 | .setX({1., 2., 3., 4., 5.}) |
|
258 | .setX({1., 2., 3., 4., 5.}) | |
259 | .setValues({100., 200., 300., 400., 500.}) |
|
259 | .setValues({100., 200., 300., 400., 500.}) | |
260 | .build() |
|
260 | .build() | |
261 | << 1. << true << 1.; |
|
261 | << 1. << true << 1.; | |
262 | QTest::newRow("maxData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false |
|
262 | QTest::newRow("maxData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false | |
263 | << std::numeric_limits<double>::quiet_NaN(); |
|
263 | << std::numeric_limits<double>::quiet_NaN(); | |
264 | } |
|
264 | } | |
265 |
|
265 | |||
266 | void TestScalarSeries::testMaxXAxisData() |
|
266 | void TestScalarSeries::testMaxXAxisData() | |
267 | { |
|
267 | { | |
268 | testMaxXAxisData_t<ScalarSeries>(); |
|
268 | testMaxXAxisData_t<ScalarSeries>(); | |
269 | } |
|
269 | } | |
270 |
|
270 | |||
271 | void TestScalarSeries::testPurge_data() |
|
271 | void TestScalarSeries::testPurge_data() | |
272 | { |
|
272 | { | |
273 | testPurge_struct<ScalarSeries>(); |
|
273 | testPurge_struct<ScalarSeries>(); | |
274 |
|
274 | |||
275 | QTest::newRow("purgeScalar") << ScalarBuilder{} |
|
275 | QTest::newRow("purgeScalar") << ScalarBuilder{} | |
276 | .setX({1., 2., 3., 4., 5.}) |
|
276 | .setX({1., 2., 3., 4., 5.}) | |
277 | .setValues({100., 200., 300., 400., 500.}) |
|
277 | .setValues({100., 200., 300., 400., 500.}) | |
278 | .build() |
|
278 | .build() | |
279 | << 2. << 4. << DataContainer{2., 3., 4.} |
|
279 | << 2. << 4. << DataContainer{2., 3., 4.} | |
280 | << std::vector<DataContainer>{{200., 300., 400.}}; |
|
280 | << std::vector<DataContainer>{{200., 300., 400.}}; | |
281 | QTest::newRow("purgeScalar1 (min/max swap)") |
|
281 | QTest::newRow("purgeScalar1 (min/max swap)") << ScalarBuilder{} | |
282 | << ScalarBuilder{} |
|
|||
283 | .setX({1., 2., 3., 4., 5.}) |
|
282 | .setX({1., 2., 3., 4., 5.}) | |
284 | .setValues({100., 200., 300., 400., 500.}) |
|
283 | .setValues({100., 200., 300., 400., 500.}) | |
285 | .build() |
|
284 | .build() | |
286 | << 4. << 2. << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}}; |
|
285 | << 4. << 2. << DataContainer{2., 3., 4.} | |
|
286 | << std::vector<DataContainer>{{200., 300., 400.}}; | |||
287 | QTest::newRow("purgeScalar2") << ScalarBuilder{} |
|
287 | QTest::newRow("purgeScalar2") << ScalarBuilder{} | |
288 | .setX({1., 2., 3., 4., 5.}) |
|
288 | .setX({1., 2., 3., 4., 5.}) | |
289 | .setValues({100., 200., 300., 400., 500.}) |
|
289 | .setValues({100., 200., 300., 400., 500.}) | |
290 | .build() |
|
290 | .build() | |
291 | << 0. << 2.5 << DataContainer{1., 2.} |
|
291 | << 0. << 2.5 << DataContainer{1., 2.} | |
292 | << std::vector<DataContainer>{{100., 200.}}; |
|
292 | << std::vector<DataContainer>{{100., 200.}}; | |
293 | QTest::newRow("purgeScalar3") << ScalarBuilder{} |
|
293 | QTest::newRow("purgeScalar3") << ScalarBuilder{} | |
294 | .setX({1., 2., 3., 4., 5.}) |
|
294 | .setX({1., 2., 3., 4., 5.}) | |
295 | .setValues({100., 200., 300., 400., 500.}) |
|
295 | .setValues({100., 200., 300., 400., 500.}) | |
296 | .build() |
|
296 | .build() | |
297 | << 3.5 << 7. << DataContainer{4., 5.} |
|
297 | << 3.5 << 7. << DataContainer{4., 5.} | |
298 | << std::vector<DataContainer>{{400., 500.}}; |
|
298 | << std::vector<DataContainer>{{400., 500.}}; | |
299 | QTest::newRow("purgeScalar4") << ScalarBuilder{} |
|
299 | QTest::newRow("purgeScalar4") << ScalarBuilder{} | |
300 | .setX({1., 2., 3., 4., 5.}) |
|
300 | .setX({1., 2., 3., 4., 5.}) | |
301 | .setValues({100., 200., 300., 400., 500.}) |
|
301 | .setValues({100., 200., 300., 400., 500.}) | |
302 | .build() |
|
302 | .build() | |
303 | << 0. << 7. << DataContainer{1., 2., 3., 4., 5.} |
|
303 | << 0. << 7. << DataContainer{1., 2., 3., 4., 5.} | |
304 | << std::vector<DataContainer>{{100., 200., 300., 400., 500.}}; |
|
304 | << std::vector<DataContainer>{{100., 200., 300., 400., 500.}}; | |
305 | QTest::newRow("purgeScalar5") << ScalarBuilder{} |
|
305 | QTest::newRow("purgeScalar5") << ScalarBuilder{} | |
306 | .setX({1., 2., 3., 4., 5.}) |
|
306 | .setX({1., 2., 3., 4., 5.}) | |
307 | .setValues({100., 200., 300., 400., 500.}) |
|
307 | .setValues({100., 200., 300., 400., 500.}) | |
308 | .build() |
|
308 | .build() | |
309 | << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}}; |
|
309 | << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}}; | |
310 | } |
|
310 | } | |
311 |
|
311 | |||
312 | void TestScalarSeries::testPurge() |
|
312 | void TestScalarSeries::testPurge() | |
313 | { |
|
313 | { | |
314 | testPurge_t<ScalarSeries>(); |
|
314 | testPurge_t<ScalarSeries>(); | |
315 | } |
|
315 | } | |
316 |
|
316 | |||
317 | void TestScalarSeries::testXAxisRange_data() |
|
317 | void TestScalarSeries::testXAxisRange_data() | |
318 | { |
|
318 | { | |
319 | testXAxisRange_struct<ScalarSeries>(); |
|
319 | testXAxisRange_struct<ScalarSeries>(); | |
320 |
|
320 | |||
321 | QTest::newRow("xAxisRange") << ScalarBuilder{} |
|
321 | QTest::newRow("xAxisRange") << ScalarBuilder{} | |
322 | .setX({1., 2., 3., 4., 5.}) |
|
322 | .setX({1., 2., 3., 4., 5.}) | |
323 | .setValues({100., 200., 300., 400., 500.}) |
|
323 | .setValues({100., 200., 300., 400., 500.}) | |
324 | .build() |
|
324 | .build() | |
325 | << -1. << 3.2 << DataContainer{1., 2., 3.} |
|
325 | << -1. << 3.2 << DataContainer{1., 2., 3.} | |
326 | << DataContainer{100., 200., 300.}; |
|
326 | << DataContainer{100., 200., 300.}; | |
327 | QTest::newRow("xAxisRange1 (min/max swap)") |
|
327 | QTest::newRow("xAxisRange1 (min/max swap)") << ScalarBuilder{} | |
328 | << ScalarBuilder{} |
|
|||
329 | .setX({1., 2., 3., 4., 5.}) |
|
328 | .setX({1., 2., 3., 4., 5.}) | |
330 | .setValues({100., 200., 300., 400., 500.}) |
|
329 | .setValues({100., 200., 300., 400., 500.}) | |
331 | .build() |
|
330 | .build() | |
332 | << 3.2 << -1. << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.}; |
|
331 | << 3.2 << -1. << DataContainer{1., 2., 3.} | |
|
332 | << DataContainer{100., 200., 300.}; | |||
333 | QTest::newRow("xAxisRange2") << ScalarBuilder{} |
|
333 | QTest::newRow("xAxisRange2") << ScalarBuilder{} | |
334 | .setX({1., 2., 3., 4., 5.}) |
|
334 | .setX({1., 2., 3., 4., 5.}) | |
335 | .setValues({100., 200., 300., 400., 500.}) |
|
335 | .setValues({100., 200., 300., 400., 500.}) | |
336 | .build() |
|
336 | .build() | |
337 | << 1. << 4. << DataContainer{1., 2., 3., 4.} |
|
337 | << 1. << 4. << DataContainer{1., 2., 3., 4.} | |
338 | << DataContainer{100., 200., 300., 400.}; |
|
338 | << DataContainer{100., 200., 300., 400.}; | |
339 | QTest::newRow("xAxisRange3") << ScalarBuilder{} |
|
339 | QTest::newRow("xAxisRange3") << ScalarBuilder{} | |
340 | .setX({1., 2., 3., 4., 5.}) |
|
340 | .setX({1., 2., 3., 4., 5.}) | |
341 | .setValues({100., 200., 300., 400., 500.}) |
|
341 | .setValues({100., 200., 300., 400., 500.}) | |
342 | .build() |
|
342 | .build() | |
343 | << 1. << 3.9 << DataContainer{1., 2., 3.} |
|
343 | << 1. << 3.9 << DataContainer{1., 2., 3.} | |
344 | << DataContainer{100., 200., 300.}; |
|
344 | << DataContainer{100., 200., 300.}; | |
345 | QTest::newRow("xAxisRange4") << ScalarBuilder{} |
|
345 | QTest::newRow("xAxisRange4") << ScalarBuilder{} | |
346 | .setX({1., 2., 3., 4., 5.}) |
|
346 | .setX({1., 2., 3., 4., 5.}) | |
347 | .setValues({100., 200., 300., 400., 500.}) |
|
347 | .setValues({100., 200., 300., 400., 500.}) | |
348 | .build() |
|
348 | .build() | |
349 | << 0. << 0.9 << DataContainer{} << DataContainer{}; |
|
349 | << 0. << 0.9 << DataContainer{} << DataContainer{}; | |
350 | QTest::newRow("xAxisRange5") << ScalarBuilder{} |
|
350 | QTest::newRow("xAxisRange5") << ScalarBuilder{} | |
351 | .setX({1., 2., 3., 4., 5.}) |
|
351 | .setX({1., 2., 3., 4., 5.}) | |
352 | .setValues({100., 200., 300., 400., 500.}) |
|
352 | .setValues({100., 200., 300., 400., 500.}) | |
353 | .build() |
|
353 | .build() | |
354 | << 0. << 1. << DataContainer{1.} << DataContainer{100.}; |
|
354 | << 0. << 1. << DataContainer{1.} << DataContainer{100.}; | |
355 | QTest::newRow("xAxisRange6") << ScalarBuilder{} |
|
355 | QTest::newRow("xAxisRange6") << ScalarBuilder{} | |
356 | .setX({1., 2., 3., 4., 5.}) |
|
356 | .setX({1., 2., 3., 4., 5.}) | |
357 | .setValues({100., 200., 300., 400., 500.}) |
|
357 | .setValues({100., 200., 300., 400., 500.}) | |
358 | .build() |
|
358 | .build() | |
359 | << 2.1 << 6. << DataContainer{3., 4., 5.} |
|
359 | << 2.1 << 6. << DataContainer{3., 4., 5.} | |
360 | << DataContainer{300., 400., 500.}; |
|
360 | << DataContainer{300., 400., 500.}; | |
361 | QTest::newRow("xAxisRange7") << ScalarBuilder{} |
|
361 | QTest::newRow("xAxisRange7") << ScalarBuilder{} | |
362 | .setX({1., 2., 3., 4., 5.}) |
|
362 | .setX({1., 2., 3., 4., 5.}) | |
363 | .setValues({100., 200., 300., 400., 500.}) |
|
363 | .setValues({100., 200., 300., 400., 500.}) | |
364 | .build() |
|
364 | .build() | |
365 | << 6. << 9. << DataContainer{} << DataContainer{}; |
|
365 | << 6. << 9. << DataContainer{} << DataContainer{}; | |
366 | QTest::newRow("xAxisRange8") << ScalarBuilder{} |
|
366 | QTest::newRow("xAxisRange8") << ScalarBuilder{} | |
367 | .setX({1., 2., 3., 4., 5.}) |
|
367 | .setX({1., 2., 3., 4., 5.}) | |
368 | .setValues({100., 200., 300., 400., 500.}) |
|
368 | .setValues({100., 200., 300., 400., 500.}) | |
369 | .build() |
|
369 | .build() | |
370 | << 5. << 9. << DataContainer{5.} << DataContainer{500.}; |
|
370 | << 5. << 9. << DataContainer{5.} << DataContainer{500.}; | |
371 | } |
|
371 | } | |
372 |
|
372 | |||
373 | void TestScalarSeries::testXAxisRange() |
|
373 | void TestScalarSeries::testXAxisRange() | |
374 | { |
|
374 | { | |
375 | testXAxisRange_t<ScalarSeries>(); |
|
375 | testXAxisRange_t<ScalarSeries>(); | |
376 | } |
|
376 | } | |
377 |
|
377 | |||
378 | void TestScalarSeries::testValuesBounds_data() |
|
378 | void TestScalarSeries::testValuesBounds_data() | |
379 | { |
|
379 | { | |
380 | testValuesBounds_struct<ScalarSeries>(); |
|
380 | testValuesBounds_struct<ScalarSeries>(); | |
381 |
|
381 | |||
382 | auto nan = std::numeric_limits<double>::quiet_NaN(); |
|
382 | auto nan = std::numeric_limits<double>::quiet_NaN(); | |
383 |
|
383 | |||
384 | QTest::newRow("scalarBounds1") << ScalarBuilder{} |
|
384 | QTest::newRow("scalarBounds1") << ScalarBuilder{} | |
385 | .setX({1., 2., 3., 4., 5.}) |
|
385 | .setX({1., 2., 3., 4., 5.}) | |
386 | .setValues({100., 200., 300., 400., 500.}) |
|
386 | .setValues({100., 200., 300., 400., 500.}) | |
387 | .build() |
|
387 | .build() | |
388 | << 0. << 6. << true << 100. << 500.; |
|
388 | << 0. << 6. << true << 100. << 500.; | |
389 | QTest::newRow("scalarBounds2") << ScalarBuilder{} |
|
389 | QTest::newRow("scalarBounds2") << ScalarBuilder{} | |
390 | .setX({1., 2., 3., 4., 5.}) |
|
390 | .setX({1., 2., 3., 4., 5.}) | |
391 | .setValues({100., 200., 300., 400., 500.}) |
|
391 | .setValues({100., 200., 300., 400., 500.}) | |
392 | .build() |
|
392 | .build() | |
393 | << 2. << 4. << true << 200. << 400.; |
|
393 | << 2. << 4. << true << 200. << 400.; | |
394 | QTest::newRow("scalarBounds3") << ScalarBuilder{} |
|
394 | QTest::newRow("scalarBounds3") << ScalarBuilder{} | |
395 | .setX({1., 2., 3., 4., 5.}) |
|
395 | .setX({1., 2., 3., 4., 5.}) | |
396 | .setValues({100., 200., 300., 400., 500.}) |
|
396 | .setValues({100., 200., 300., 400., 500.}) | |
397 | .build() |
|
397 | .build() | |
398 | << 0. << 0.5 << false << nan << nan; |
|
398 | << 0. << 0.5 << false << nan << nan; | |
399 | QTest::newRow("scalarBounds4") << ScalarBuilder{} |
|
399 | QTest::newRow("scalarBounds4") << ScalarBuilder{} | |
400 | .setX({1., 2., 3., 4., 5.}) |
|
400 | .setX({1., 2., 3., 4., 5.}) | |
401 | .setValues({100., 200., 300., 400., 500.}) |
|
401 | .setValues({100., 200., 300., 400., 500.}) | |
402 | .build() |
|
402 | .build() | |
403 | << 5.1 << 6. << false << nan << nan; |
|
403 | << 5.1 << 6. << false << nan << nan; | |
404 | QTest::newRow("scalarBounds5") |
|
404 | QTest::newRow("scalarBounds5") << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0. | |
405 | << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0. << 2. << true << 100. << 100.; |
|
405 | << 2. << true << 100. << 100.; | |
406 | QTest::newRow("scalarBounds6") |
|
406 | QTest::newRow("scalarBounds6") << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2. | |
407 | << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2. << false << nan << nan; |
|
407 | << false << nan << nan; | |
408 |
|
408 | |||
409 | // Tests with NaN values: NaN values are not included in min/max search |
|
409 | // Tests with NaN values: NaN values are not included in min/max search | |
410 | QTest::newRow("scalarBounds7") << ScalarBuilder{} |
|
410 | QTest::newRow("scalarBounds7") << ScalarBuilder{} | |
411 | .setX({1., 2., 3., 4., 5.}) |
|
411 | .setX({1., 2., 3., 4., 5.}) | |
412 | .setValues({nan, 200., 300., 400., nan}) |
|
412 | .setValues({nan, 200., 300., 400., nan}) | |
413 | .build() |
|
413 | .build() | |
414 | << 0. << 6. << true << 200. << 400.; |
|
414 | << 0. << 6. << true << 200. << 400.; | |
415 | QTest::newRow("scalarBounds8") |
|
415 | QTest::newRow("scalarBounds8") | |
416 | << ScalarBuilder{}.setX({1., 2., 3., 4., 5.}).setValues({nan, nan, nan, nan, nan}).build() |
|
416 | << ScalarBuilder{}.setX({1., 2., 3., 4., 5.}).setValues({nan, nan, nan, nan, nan}).build() | |
417 | << 0. << 6. << true << nan << nan; |
|
417 | << 0. << 6. << true << nan << nan; | |
418 | } |
|
418 | } | |
419 |
|
419 | |||
420 | void TestScalarSeries::testValuesBounds() |
|
420 | void TestScalarSeries::testValuesBounds() | |
421 | { |
|
421 | { | |
422 | testValuesBounds_t<ScalarSeries>(); |
|
422 | testValuesBounds_t<ScalarSeries>(); | |
423 | } |
|
423 | } | |
424 |
|
424 | |||
425 | QTEST_MAIN(TestScalarSeries) |
|
425 | QTEST_MAIN(TestScalarSeries) | |
426 | #include "TestScalarSeries.moc" |
|
426 | #include "TestScalarSeries.moc" |
@@ -1,45 +1,47 | |||||
1 | #include "DataSource/DataSourceTreeWidget.h" |
|
1 | #include "DataSource/DataSourceTreeWidget.h" | |
2 | #include "Common/MimeTypesDef.h" |
|
2 | #include "Common/MimeTypesDef.h" | |
3 | #include "DataSource/DataSourceController.h" |
|
3 | #include "DataSource/DataSourceController.h" | |
4 | #include "DataSource/DataSourceItem.h" |
|
4 | #include "DataSource/DataSourceItem.h" | |
5 | #include "DataSource/DataSourceTreeWidgetItem.h" |
|
5 | #include "DataSource/DataSourceTreeWidgetItem.h" | |
6 |
|
6 | |||
7 | #include "DragAndDrop/DragDropHelper.h" |
|
7 | #include "DragAndDrop/DragDropHelper.h" | |
8 | #include "SqpApplication.h" |
|
8 | #include "SqpApplication.h" | |
9 |
|
9 | |||
10 | #include <QMimeData> |
|
10 | #include <QMimeData> | |
11 |
|
11 | |||
12 |
DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) |
|
12 | DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) | |
|
13 | { | |||
|
14 | } | |||
13 |
|
15 | |||
14 | QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) const |
|
16 | QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) const | |
15 | { |
|
17 | { | |
16 | auto mimeData = new QMimeData; |
|
18 | auto mimeData = new QMimeData; | |
17 |
|
19 | |||
18 | // Basic check to ensure the item are correctly typed |
|
20 | // Basic check to ensure the item are correctly typed | |
19 | Q_ASSERT(items.isEmpty() || dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr); |
|
21 | Q_ASSERT(items.isEmpty() || dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr); | |
20 |
|
22 | |||
21 | QVariantList productData; |
|
23 | QVariantList productData; | |
22 |
|
24 | |||
23 | for (auto item : items) { |
|
25 | for (auto item : items) { | |
24 | auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item); |
|
26 | auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item); | |
25 | auto dataSource = dataSourceTreeItem->data(); |
|
27 | auto dataSource = dataSourceTreeItem->data(); | |
26 |
|
28 | |||
27 | if (dataSource->type() == DataSourceItemType::COMPONENT |
|
29 | if (dataSource->type() == DataSourceItemType::COMPONENT | |
28 | || dataSource->type() == DataSourceItemType::PRODUCT) { |
|
30 | || dataSource->type() == DataSourceItemType::PRODUCT) { | |
29 | auto metaData = dataSource->data(); |
|
31 | auto metaData = dataSource->data(); | |
30 | productData << metaData; |
|
32 | productData << metaData; | |
31 | } |
|
33 | } | |
32 | } |
|
34 | } | |
33 |
|
35 | |||
34 | auto encodedData = sqpApp->dataSourceController().mimeDataForProductsData(productData); |
|
36 | auto encodedData = sqpApp->dataSourceController().mimeDataForProductsData(productData); | |
35 | mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData); |
|
37 | mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData); | |
36 |
|
38 | |||
37 | return mimeData; |
|
39 | return mimeData; | |
38 | } |
|
40 | } | |
39 |
|
41 | |||
40 | void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions) |
|
42 | void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions) | |
41 | { |
|
43 | { | |
42 | // Resets the drag&drop operations before it's starting |
|
44 | // Resets the drag&drop operations before it's starting | |
43 | sqpApp->dragDropHelper().resetDragAndDrop(); |
|
45 | sqpApp->dragDropHelper().resetDragAndDrop(); | |
44 | QTreeWidget::startDrag(supportedActions); |
|
46 | QTreeWidget::startDrag(supportedActions); | |
45 | } |
|
47 | } |
@@ -1,292 +1,294 | |||||
1 | #include "DragAndDrop/DragDropHelper.h" |
|
1 | #include "DragAndDrop/DragDropHelper.h" | |
2 | #include "DragAndDrop/DragDropScroller.h" |
|
2 | #include "DragAndDrop/DragDropScroller.h" | |
3 | #include "DragAndDrop/DragDropTabSwitcher.h" |
|
3 | #include "DragAndDrop/DragDropTabSwitcher.h" | |
4 | #include "SqpApplication.h" |
|
4 | #include "SqpApplication.h" | |
5 | #include "Visualization/VisualizationDragDropContainer.h" |
|
5 | #include "Visualization/VisualizationDragDropContainer.h" | |
6 | #include "Visualization/VisualizationDragWidget.h" |
|
6 | #include "Visualization/VisualizationDragWidget.h" | |
7 | #include "Visualization/VisualizationWidget.h" |
|
7 | #include "Visualization/VisualizationWidget.h" | |
8 | #include "Visualization/operations/FindVariableOperation.h" |
|
8 | #include "Visualization/operations/FindVariableOperation.h" | |
9 |
|
9 | |||
10 | #include "Variable/Variable.h" |
|
10 | #include "Variable/Variable.h" | |
11 | #include "Variable/VariableController.h" |
|
11 | #include "Variable/VariableController.h" | |
12 |
|
12 | |||
13 | #include "Common/MimeTypesDef.h" |
|
13 | #include "Common/MimeTypesDef.h" | |
14 | #include "Common/VisualizationDef.h" |
|
14 | #include "Common/VisualizationDef.h" | |
15 |
|
15 | |||
16 | #include <QDir> |
|
16 | #include <QDir> | |
17 | #include <QLabel> |
|
17 | #include <QLabel> | |
18 | #include <QUrl> |
|
18 | #include <QUrl> | |
19 | #include <QVBoxLayout> |
|
19 | #include <QVBoxLayout> | |
20 |
|
20 | |||
21 |
|
21 | |||
22 | Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper") |
|
22 | Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper") | |
23 |
|
23 | |||
24 |
|
24 | |||
25 | struct DragDropHelper::DragDropHelperPrivate { |
|
25 | struct DragDropHelper::DragDropHelperPrivate { | |
26 |
|
26 | |||
27 | VisualizationDragWidget *m_CurrentDragWidget = nullptr; |
|
27 | VisualizationDragWidget *m_CurrentDragWidget = nullptr; | |
28 | std::unique_ptr<QWidget> m_PlaceHolder = nullptr; |
|
28 | std::unique_ptr<QWidget> m_PlaceHolder = nullptr; | |
29 | QLabel *m_PlaceHolderLabel; |
|
29 | QLabel *m_PlaceHolderLabel; | |
30 | QWidget *m_PlaceBackground; |
|
30 | QWidget *m_PlaceBackground; | |
31 | std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr; |
|
31 | std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr; | |
32 | std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr; |
|
32 | std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr; | |
33 | QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using |
|
33 | QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using | |
34 | // QTemporaryFile to have a name which is not generated. |
|
34 | // QTemporaryFile to have a name which is not generated. | |
35 |
|
35 | |||
36 | VisualizationDragWidget *m_HighlightedDragWidget = nullptr; |
|
36 | VisualizationDragWidget *m_HighlightedDragWidget = nullptr; | |
37 |
|
37 | |||
38 | QMetaObject::Connection m_DragWidgetDestroyedConnection; |
|
38 | QMetaObject::Connection m_DragWidgetDestroyedConnection; | |
39 | QMetaObject::Connection m_HighlightedWidgetDestroyedConnection; |
|
39 | QMetaObject::Connection m_HighlightedWidgetDestroyedConnection; | |
40 |
|
40 | |||
41 | QList<QWidget *> m_WidgetToClose; |
|
41 | QList<QWidget *> m_WidgetToClose; | |
42 |
|
42 | |||
43 | explicit DragDropHelperPrivate() |
|
43 | explicit DragDropHelperPrivate() | |
44 | : m_PlaceHolder{std::make_unique<QWidget>()}, |
|
44 | : m_PlaceHolder{std::make_unique<QWidget>()}, | |
45 | m_DragDropScroller{std::make_unique<DragDropScroller>()}, |
|
45 | m_DragDropScroller{std::make_unique<DragDropScroller>()}, | |
46 | m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()} |
|
46 | m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()} | |
47 | { |
|
47 | { | |
48 |
|
48 | |||
49 | auto layout = new QVBoxLayout{m_PlaceHolder.get()}; |
|
49 | auto layout = new QVBoxLayout{m_PlaceHolder.get()}; | |
50 | layout->setSpacing(0); |
|
50 | layout->setSpacing(0); | |
51 | layout->setContentsMargins(0, 0, 0, 0); |
|
51 | layout->setContentsMargins(0, 0, 0, 0); | |
52 |
|
52 | |||
53 | m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()}; |
|
53 | m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()}; | |
54 | m_PlaceHolderLabel->setMinimumHeight(25); |
|
54 | m_PlaceHolderLabel->setMinimumHeight(25); | |
55 | layout->addWidget(m_PlaceHolderLabel); |
|
55 | layout->addWidget(m_PlaceHolderLabel); | |
56 |
|
56 | |||
57 | m_PlaceBackground = new QWidget{m_PlaceHolder.get()}; |
|
57 | m_PlaceBackground = new QWidget{m_PlaceHolder.get()}; | |
58 | m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); |
|
58 | m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); | |
59 | layout->addWidget(m_PlaceBackground); |
|
59 | layout->addWidget(m_PlaceBackground); | |
60 |
|
60 | |||
61 | sqpApp->installEventFilter(m_DragDropScroller.get()); |
|
61 | sqpApp->installEventFilter(m_DragDropScroller.get()); | |
62 | sqpApp->installEventFilter(m_DragDropTabSwitcher.get()); |
|
62 | sqpApp->installEventFilter(m_DragDropTabSwitcher.get()); | |
63 |
|
63 | |||
64 | m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png"); |
|
64 | m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png"); | |
65 | } |
|
65 | } | |
66 |
|
66 | |||
67 | void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const |
|
67 | void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const | |
68 | { |
|
68 | { | |
69 | if (m_CurrentDragWidget) { |
|
69 | if (m_CurrentDragWidget) { | |
70 | m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size()); |
|
70 | m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size()); | |
71 | m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy()); |
|
71 | m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy()); | |
72 | } |
|
72 | } | |
73 | else { |
|
73 | else { | |
74 | // Configuration of the placeHolder when there is no dragWidget |
|
74 | // Configuration of the placeHolder when there is no dragWidget | |
75 | // (for instance with a drag from a variable) |
|
75 | // (for instance with a drag from a variable) | |
76 |
|
76 | |||
77 | m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT); |
|
77 | m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT); | |
78 | m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); |
|
78 | m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); | |
79 | } |
|
79 | } | |
80 |
|
80 | |||
81 | switch (type) { |
|
81 | switch (type) { | |
82 | case DragDropHelper::PlaceHolderType::Graph: |
|
82 | case DragDropHelper::PlaceHolderType::Graph: | |
83 | m_PlaceBackground->setStyleSheet( |
|
83 | m_PlaceBackground->setStyleSheet( | |
84 | "background-color: #BBD5EE; border: 1px solid #2A7FD4"); |
|
84 | "background-color: #BBD5EE; border: 1px solid #2A7FD4"); | |
85 | break; |
|
85 | break; | |
86 | case DragDropHelper::PlaceHolderType::Zone: |
|
86 | case DragDropHelper::PlaceHolderType::Zone: | |
87 | case DragDropHelper::PlaceHolderType::Default: |
|
87 | case DragDropHelper::PlaceHolderType::Default: | |
88 | m_PlaceBackground->setStyleSheet( |
|
88 | m_PlaceBackground->setStyleSheet( | |
89 | "background-color: #BBD5EE; border: 2px solid #2A7FD4"); |
|
89 | "background-color: #BBD5EE; border: 2px solid #2A7FD4"); | |
90 | m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4"); |
|
90 | m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4"); | |
91 | break; |
|
91 | break; | |
92 | } |
|
92 | } | |
93 |
|
93 | |||
94 | m_PlaceHolderLabel->setText(topLabelText); |
|
94 | m_PlaceHolderLabel->setText(topLabelText); | |
95 | m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty()); |
|
95 | m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty()); | |
96 | } |
|
96 | } | |
97 | }; |
|
97 | }; | |
98 |
|
98 | |||
99 |
|
99 | |||
100 |
DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} |
|
100 | DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} | |
|
101 | { | |||
|
102 | } | |||
101 |
|
103 | |||
102 | DragDropHelper::~DragDropHelper() |
|
104 | DragDropHelper::~DragDropHelper() | |
103 | { |
|
105 | { | |
104 | QFile::remove(impl->m_ImageTempUrl); |
|
106 | QFile::remove(impl->m_ImageTempUrl); | |
105 | } |
|
107 | } | |
106 |
|
108 | |||
107 | void DragDropHelper::resetDragAndDrop() |
|
109 | void DragDropHelper::resetDragAndDrop() | |
108 | { |
|
110 | { | |
109 | setCurrentDragWidget(nullptr); |
|
111 | setCurrentDragWidget(nullptr); | |
110 | impl->m_HighlightedDragWidget = nullptr; |
|
112 | impl->m_HighlightedDragWidget = nullptr; | |
111 | } |
|
113 | } | |
112 |
|
114 | |||
113 | void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget) |
|
115 | void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget) | |
114 | { |
|
116 | { | |
115 | if (impl->m_CurrentDragWidget) { |
|
117 | if (impl->m_CurrentDragWidget) { | |
116 |
|
118 | |||
117 | QObject::disconnect(impl->m_DragWidgetDestroyedConnection); |
|
119 | QObject::disconnect(impl->m_DragWidgetDestroyedConnection); | |
118 | } |
|
120 | } | |
119 |
|
121 | |||
120 | if (dragWidget) { |
|
122 | if (dragWidget) { | |
121 | // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed |
|
123 | // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed | |
122 | impl->m_DragWidgetDestroyedConnection |
|
124 | impl->m_DragWidgetDestroyedConnection | |
123 | = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed, |
|
125 | = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed, | |
124 | [this]() { impl->m_CurrentDragWidget = nullptr; }); |
|
126 | [this]() { impl->m_CurrentDragWidget = nullptr; }); | |
125 | } |
|
127 | } | |
126 |
|
128 | |||
127 | impl->m_CurrentDragWidget = dragWidget; |
|
129 | impl->m_CurrentDragWidget = dragWidget; | |
128 | } |
|
130 | } | |
129 |
|
131 | |||
130 | VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const |
|
132 | VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const | |
131 | { |
|
133 | { | |
132 | return impl->m_CurrentDragWidget; |
|
134 | return impl->m_CurrentDragWidget; | |
133 | } |
|
135 | } | |
134 |
|
136 | |||
135 | QWidget &DragDropHelper::placeHolder() const |
|
137 | QWidget &DragDropHelper::placeHolder() const | |
136 | { |
|
138 | { | |
137 | return *impl->m_PlaceHolder; |
|
139 | return *impl->m_PlaceHolder; | |
138 | } |
|
140 | } | |
139 |
|
141 | |||
140 | void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type, |
|
142 | void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type, | |
141 | const QString &topLabelText) |
|
143 | const QString &topLabelText) | |
142 | { |
|
144 | { | |
143 | removePlaceHolder(); |
|
145 | removePlaceHolder(); | |
144 | impl->preparePlaceHolder(type, topLabelText); |
|
146 | impl->preparePlaceHolder(type, topLabelText); | |
145 | layout->insertWidget(index, impl->m_PlaceHolder.get()); |
|
147 | layout->insertWidget(index, impl->m_PlaceHolder.get()); | |
146 | impl->m_PlaceHolder->show(); |
|
148 | impl->m_PlaceHolder->show(); | |
147 | } |
|
149 | } | |
148 |
|
150 | |||
149 | void DragDropHelper::removePlaceHolder() |
|
151 | void DragDropHelper::removePlaceHolder() | |
150 | { |
|
152 | { | |
151 | auto parentWidget = impl->m_PlaceHolder->parentWidget(); |
|
153 | auto parentWidget = impl->m_PlaceHolder->parentWidget(); | |
152 | if (parentWidget) { |
|
154 | if (parentWidget) { | |
153 | parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get()); |
|
155 | parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get()); | |
154 | impl->m_PlaceHolder->setParent(nullptr); |
|
156 | impl->m_PlaceHolder->setParent(nullptr); | |
155 | impl->m_PlaceHolder->hide(); |
|
157 | impl->m_PlaceHolder->hide(); | |
156 | } |
|
158 | } | |
157 | } |
|
159 | } | |
158 |
|
160 | |||
159 | bool DragDropHelper::isPlaceHolderSet() const |
|
161 | bool DragDropHelper::isPlaceHolderSet() const | |
160 | { |
|
162 | { | |
161 | return impl->m_PlaceHolder->parentWidget(); |
|
163 | return impl->m_PlaceHolder->parentWidget(); | |
162 | } |
|
164 | } | |
163 |
|
165 | |||
164 | void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea) |
|
166 | void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea) | |
165 | { |
|
167 | { | |
166 | impl->m_DragDropScroller->addScrollArea(scrollArea); |
|
168 | impl->m_DragDropScroller->addScrollArea(scrollArea); | |
167 | } |
|
169 | } | |
168 |
|
170 | |||
169 | void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea) |
|
171 | void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea) | |
170 | { |
|
172 | { | |
171 | impl->m_DragDropScroller->removeScrollArea(scrollArea); |
|
173 | impl->m_DragDropScroller->removeScrollArea(scrollArea); | |
172 | } |
|
174 | } | |
173 |
|
175 | |||
174 | void DragDropHelper::addDragDropTabBar(QTabBar *tabBar) |
|
176 | void DragDropHelper::addDragDropTabBar(QTabBar *tabBar) | |
175 | { |
|
177 | { | |
176 | impl->m_DragDropTabSwitcher->addTabBar(tabBar); |
|
178 | impl->m_DragDropTabSwitcher->addTabBar(tabBar); | |
177 | } |
|
179 | } | |
178 |
|
180 | |||
179 | void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar) |
|
181 | void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar) | |
180 | { |
|
182 | { | |
181 | impl->m_DragDropTabSwitcher->removeTabBar(tabBar); |
|
183 | impl->m_DragDropTabSwitcher->removeTabBar(tabBar); | |
182 | } |
|
184 | } | |
183 |
|
185 | |||
184 | QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const |
|
186 | QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const | |
185 | { |
|
187 | { | |
186 | image.save(impl->m_ImageTempUrl); |
|
188 | image.save(impl->m_ImageTempUrl); | |
187 | return QUrl::fromLocalFile(impl->m_ImageTempUrl); |
|
189 | return QUrl::fromLocalFile(impl->m_ImageTempUrl); | |
188 | } |
|
190 | } | |
189 |
|
191 | |||
190 | void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget) |
|
192 | void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget) | |
191 | { |
|
193 | { | |
192 | if (impl->m_HighlightedDragWidget) { |
|
194 | if (impl->m_HighlightedDragWidget) { | |
193 | impl->m_HighlightedDragWidget->highlightForMerge(false); |
|
195 | impl->m_HighlightedDragWidget->highlightForMerge(false); | |
194 | QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection); |
|
196 | QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection); | |
195 | } |
|
197 | } | |
196 |
|
198 | |||
197 | if (dragWidget) { |
|
199 | if (dragWidget) { | |
198 | dragWidget->highlightForMerge(true); |
|
200 | dragWidget->highlightForMerge(true); | |
199 |
|
201 | |||
200 | // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed |
|
202 | // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed | |
201 | impl->m_DragWidgetDestroyedConnection |
|
203 | impl->m_DragWidgetDestroyedConnection | |
202 | = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed, |
|
204 | = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed, | |
203 | [this]() { impl->m_HighlightedDragWidget = nullptr; }); |
|
205 | [this]() { impl->m_HighlightedDragWidget = nullptr; }); | |
204 | } |
|
206 | } | |
205 |
|
207 | |||
206 | impl->m_HighlightedDragWidget = dragWidget; |
|
208 | impl->m_HighlightedDragWidget = dragWidget; | |
207 | } |
|
209 | } | |
208 |
|
210 | |||
209 | VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const |
|
211 | VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const | |
210 | { |
|
212 | { | |
211 | return impl->m_HighlightedDragWidget; |
|
213 | return impl->m_HighlightedDragWidget; | |
212 | } |
|
214 | } | |
213 |
|
215 | |||
214 | void DragDropHelper::delayedCloseWidget(QWidget *widget) |
|
216 | void DragDropHelper::delayedCloseWidget(QWidget *widget) | |
215 | { |
|
217 | { | |
216 | widget->hide(); |
|
218 | widget->hide(); | |
217 | impl->m_WidgetToClose << widget; |
|
219 | impl->m_WidgetToClose << widget; | |
218 | } |
|
220 | } | |
219 |
|
221 | |||
220 | void DragDropHelper::doCloseWidgets() |
|
222 | void DragDropHelper::doCloseWidgets() | |
221 | { |
|
223 | { | |
222 | for (auto widget : impl->m_WidgetToClose) { |
|
224 | for (auto widget : impl->m_WidgetToClose) { | |
223 | widget->close(); |
|
225 | widget->close(); | |
224 | } |
|
226 | } | |
225 |
|
227 | |||
226 | impl->m_WidgetToClose.clear(); |
|
228 | impl->m_WidgetToClose.clear(); | |
227 | } |
|
229 | } | |
228 |
|
230 | |||
229 | bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData, |
|
231 | bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData, | |
230 | VisualizationDragDropContainer *dropContainer) |
|
232 | VisualizationDragDropContainer *dropContainer) | |
231 | { |
|
233 | { | |
232 | if (!mimeData || !dropContainer) { |
|
234 | if (!mimeData || !dropContainer) { | |
233 | qCWarning(LOG_DragDropHelper()) << QObject::tr( |
|
235 | qCWarning(LOG_DragDropHelper()) << QObject::tr( | |
234 | "DragDropHelper::checkMimeDataForVisualization, invalid input parameters."); |
|
236 | "DragDropHelper::checkMimeDataForVisualization, invalid input parameters."); | |
235 | Q_ASSERT(false); |
|
237 | Q_ASSERT(false); | |
236 | return false; |
|
238 | return false; | |
237 | } |
|
239 | } | |
238 |
|
240 | |||
239 | auto result = false; |
|
241 | auto result = false; | |
240 |
|
242 | |||
241 | if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) { |
|
243 | if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) { | |
242 | auto variables = sqpApp->variableController().variablesForMimeData( |
|
244 | auto variables = sqpApp->variableController().variablesForMimeData( | |
243 | mimeData->data(MIME_TYPE_VARIABLE_LIST)); |
|
245 | mimeData->data(MIME_TYPE_VARIABLE_LIST)); | |
244 |
|
246 | |||
245 | if (variables.count() == 1) { |
|
247 | if (variables.count() == 1) { | |
246 |
|
248 | |||
247 | auto variable = variables.first(); |
|
249 | auto variable = variables.first(); | |
248 | if (variable->dataSeries() != nullptr) { |
|
250 | if (variable->dataSeries() != nullptr) { | |
249 |
|
251 | |||
250 | // Check that the variable is not already in a graph |
|
252 | // Check that the variable is not already in a graph | |
251 |
|
253 | |||
252 | auto parent = dropContainer->parentWidget(); |
|
254 | auto parent = dropContainer->parentWidget(); | |
253 | while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) { |
|
255 | while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) { | |
254 | parent = parent->parentWidget(); // Search for the top level VisualizationWidget |
|
256 | parent = parent->parentWidget(); // Search for the top level VisualizationWidget | |
255 | } |
|
257 | } | |
256 |
|
258 | |||
257 | if (parent) { |
|
259 | if (parent) { | |
258 | auto visualizationWidget = static_cast<VisualizationWidget *>(parent); |
|
260 | auto visualizationWidget = static_cast<VisualizationWidget *>(parent); | |
259 |
|
261 | |||
260 | FindVariableOperation findVariableOperation{variable}; |
|
262 | FindVariableOperation findVariableOperation{variable}; | |
261 | visualizationWidget->accept(&findVariableOperation); |
|
263 | visualizationWidget->accept(&findVariableOperation); | |
262 | auto variableContainers = findVariableOperation.result(); |
|
264 | auto variableContainers = findVariableOperation.result(); | |
263 | if (variableContainers.empty()) { |
|
265 | if (variableContainers.empty()) { | |
264 | result = true; |
|
266 | result = true; | |
265 | } |
|
267 | } | |
266 | else { |
|
268 | else { | |
267 | // result = false: the variable already exist in the visualisation |
|
269 | // result = false: the variable already exist in the visualisation | |
268 | } |
|
270 | } | |
269 | } |
|
271 | } | |
270 | else { |
|
272 | else { | |
271 | qCWarning(LOG_DragDropHelper()) << QObject::tr( |
|
273 | qCWarning(LOG_DragDropHelper()) << QObject::tr( | |
272 | "DragDropHelper::checkMimeDataForVisualization, the parent " |
|
274 | "DragDropHelper::checkMimeDataForVisualization, the parent " | |
273 | "VisualizationWidget cannot be found. Cannot check if the variable is " |
|
275 | "VisualizationWidget cannot be found. Cannot check if the variable is " | |
274 | "already used or not."); |
|
276 | "already used or not."); | |
275 | } |
|
277 | } | |
276 | } |
|
278 | } | |
277 | else { |
|
279 | else { | |
278 | // result = false: the variable is not fully loaded |
|
280 | // result = false: the variable is not fully loaded | |
279 | } |
|
281 | } | |
280 | } |
|
282 | } | |
281 | else { |
|
283 | else { | |
282 | // result = false: cannot drop multiple variables in the visualisation |
|
284 | // result = false: cannot drop multiple variables in the visualisation | |
283 | } |
|
285 | } | |
284 | } |
|
286 | } | |
285 | else { |
|
287 | else { | |
286 | // Other MIME data |
|
288 | // Other MIME data | |
287 | // no special rules, accepted by default |
|
289 | // no special rules, accepted by default | |
288 | result = true; |
|
290 | result = true; | |
289 | } |
|
291 | } | |
290 |
|
292 | |||
291 | return result; |
|
293 | return result; | |
292 | } |
|
294 | } |
@@ -1,13 +1,15 | |||||
1 | #include "Variable/VariableInspectorTableView.h" |
|
1 | #include "Variable/VariableInspectorTableView.h" | |
2 |
|
2 | |||
3 | #include "DragAndDrop/DragDropHelper.h" |
|
3 | #include "DragAndDrop/DragDropHelper.h" | |
4 | #include "SqpApplication.h" |
|
4 | #include "SqpApplication.h" | |
5 |
|
5 | |||
6 |
VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent) |
|
6 | VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent) | |
|
7 | { | |||
|
8 | } | |||
7 |
|
9 | |||
8 | void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions) |
|
10 | void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions) | |
9 | { |
|
11 | { | |
10 | // Resets the drag&drop operations before it's starting |
|
12 | // Resets the drag&drop operations before it's starting | |
11 | sqpApp->dragDropHelper().resetDragAndDrop(); |
|
13 | sqpApp->dragDropHelper().resetDragAndDrop(); | |
12 | QTableView::startDrag(supportedActions); |
|
14 | QTableView::startDrag(supportedActions); | |
13 | } |
|
15 | } |
General Comments 1
You need to be logged in to leave comments.
Login now