Skip to content

Conversion functions for RgbColor #2518

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Holzhaus merged 10 commits into from
Feb 28, 2020
Merged

Conversion functions for RgbColor #2518

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
5e61696
Convert RgbColor to #RRGGBB string
uklotzde Feb 26, 2020
fbdf4e1
Simplify test names
uklotzde Feb 26, 2020
90d5860
Allow to provide a custom default string
uklotzde Feb 26, 2020
683e4c4
Add optional default parameters for RgbColor conversions
uklotzde Feb 26, 2020
ea530eb
Fix fallthrough warning
uklotzde Feb 26, 2020
0e32f6c
Add conversion functions between RgbColor and various Qt types
uklotzde Feb 27, 2020
ef7a545
Use QRgb for color codes
uklotzde Feb 28, 2020
4b190f9
Convert RgbColor from/to control values
uklotzde Feb 28, 2020
b26101b
Align conversions from QVariant to RgbColor
uklotzde Feb 28, 2020
3d4cc33
Remove confusing typedef
uklotzde Feb 28, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
43 changes: 43 additions & 0 deletions src/control/convert.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,43 @@
#pragma once

#include "util/color/rgbcolor.h"
#include "util/assert.h"

namespace mixxx {

namespace control {

constexpr double kInvalidRgbColor = -1.0;

inline double doubleFromRgbColor(RgbColor color) {
return static_cast<RgbColor::code_t>(color);
}

inline double doubleFromRgbColor(RgbColor::optional_t color) {
if (color) {
return doubleFromRgbColor(*color);
} else {
return kInvalidRgbColor;
}
}

inline RgbColor::optional_t doubleToRgbColor(double value) {
if (value >= 0) {
const auto code = static_cast<RgbColor::code_t>(value);
// If value is out of range then unused bits will be
// discarded when converting into an RgbColor. Nevertheless
// check with a debug assertion that the given value
// is in range as expected. Out of range values indicate
// programming errors in other components.
DEBUG_ASSERT(RgbColor::isValidCode(code));
return RgbColor::optional(code);
} else {
// < 0 or NaN (if non-signalling)
DEBUG_ASSERT(value == kInvalidRgbColor);
return RgbColor::nullopt();
}
}

} // namespace control

} // namespace mixxx
10 changes: 3 additions & 7 deletions src/library/basesqltablemodel.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@
#include "util/duration.h"
#include "util/assert.h"
#include "util/performancetimer.h"
#include "util/platform.h"
#include "widget/wlibrarytableview.h"

namespace {
Expand Down Expand Up @@ -724,14 +725,9 @@ QVariant BaseSqlTableModel::data(const QModelIndex& index, int role) const {
switch (role) {
case Qt::ToolTipRole:
if (column == fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COLOR)) {
const auto color = mixxx::RgbColor::optional(value);
if (color) {
value = mixxx::toQColor(color).name();
} else {
value = QString();
}
value = mixxx::RgbColor::toQString(mixxx::RgbColor::fromQVariant(value));
}
[[fallthrough]];
M_FALLTHROUGH_INTENDED;
case Qt::DisplayRole:
if (column == fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_DURATION)) {
int duration = value.toInt();
Expand Down
2 changes: 1 addition & 1 deletion src/library/basetrackcache.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -416,7 +416,7 @@ void BaseTrackCache::getTrackValueForColumn(TrackPointer pTrack,
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_BPM_LOCK) == column) {
trackValue.setValue(pTrack->isBpmLocked());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COLOR) == column) {
trackValue.setValue(toQVariant(pTrack->getColor()));
trackValue.setValue(mixxx::RgbColor::toQVariant(pTrack->getColor()));
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_LOCATION) == column) {
trackValue.setValue(pTrack->getCoverInfo().coverLocation);
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_HASH) == column ||
Expand Down
4 changes: 2 additions & 2 deletions src/library/colordelegate.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ ColorDelegate::ColorDelegate(QTableView* pTableView)
}

void ColorDelegate::paintItem(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {
const auto color = mixxx::RgbColor::optional(index.data());
const auto color = mixxx::RgbColor::fromQVariant(index.data());

if (!color) {
// Filter out track color that is hidden
Expand All @@ -23,7 +23,7 @@ void ColorDelegate::paintItem(QPainter* painter, const QStyleOptionViewItem& opt
return;
}

painter->fillRect(option.rect, toQColor(color));
painter->fillRect(option.rect, mixxx::RgbColor::toQColor(color));

// Paint transparent highlight if row is selected
if (option.state & QStyle::State_Selected) {
Expand Down
4 changes: 2 additions & 2 deletions src/library/dao/trackdao.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -463,7 +463,7 @@ namespace {
pTrackLibraryQuery->bindValue(":tracknumber", track.getTrackNumber());
pTrackLibraryQuery->bindValue(":tracktotal", track.getTrackTotal());
pTrackLibraryQuery->bindValue(":filetype", track.getType());
pTrackLibraryQuery->bindValue(":color", toQVariant(track.getColor()));
pTrackLibraryQuery->bindValue(":color", mixxx::RgbColor::toQVariant(track.getColor()));
pTrackLibraryQuery->bindValue(":comment", track.getComment());
pTrackLibraryQuery->bindValue(":url", track.getURL());
pTrackLibraryQuery->bindValue(":duration", track.getDuration());
Expand Down Expand Up @@ -985,7 +985,7 @@ bool setTrackTotal(const QSqlRecord& record, const int column,

bool setTrackColor(const QSqlRecord& record, const int column,
TrackPointer pTrack) {
pTrack->setColor(mixxx::RgbColor::optional(record.value(column)));
pTrack->setColor(mixxx::RgbColor::fromQVariant(record.value(column)));
return false;
}

Expand Down
118 changes: 80 additions & 38 deletions src/test/rgbcolor_test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,63 +3,105 @@
#include <gtest/gtest.h>

#include "test/mixxxtest.h"
#include "control/convert.h"

namespace mixxx {

TEST(RgbColorTest, OptionalRgbColorFromInvalidQColor) {
EXPECT_FALSE(RgbColor::optional(QColor()));
EXPECT_EQ(RgbColor::nullopt(), RgbColor::optional(QColor()));
TEST(RgbColorTest, fromInvalidQColor) {
EXPECT_FALSE(RgbColor::fromQColor(QColor()));
EXPECT_EQ(RgbColor::nullopt(), RgbColor::fromQColor(QColor()));
}

TEST(RgbColorTest, OptionalRgbColorFromQColorWithoutAlpha) {
EXPECT_TRUE(RgbColor::optional(QColor::fromRgb(0x000000)));
EXPECT_EQ(0x000000, *RgbColor::optional(QColor::fromRgb(0x000000)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgb(0xFF0000)));
EXPECT_EQ(RgbColor::optional(0xFF0000), RgbColor::optional(QColor::fromRgb(0xFF0000)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgb(0x00FF00)));
EXPECT_EQ(RgbColor::optional(0x00FF00), RgbColor::optional(QColor::fromRgb(0x00FF00)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgb(0x0000FF)));
EXPECT_EQ(RgbColor::optional(0x0000FF), RgbColor::optional(QColor::fromRgb(0x0000FF)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgb(0xFFFFFF)));
EXPECT_EQ(RgbColor::optional(0xFFFFFF), RgbColor::optional(QColor::fromRgb(0xFFFFFF)));
TEST(RgbColorTest, fromQColorWithoutAlpha) {
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgb(0x000000)));
EXPECT_EQ(RgbColor::optional(0x000000), RgbColor::fromQColor(QColor::fromRgb(0x000000)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgb(0xFF0000)));
EXPECT_EQ(RgbColor::optional(0xFF0000), RgbColor::fromQColor(QColor::fromRgb(0xFF0000)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgb(0x00FF00)));
EXPECT_EQ(RgbColor::optional(0x00FF00), RgbColor::fromQColor(QColor::fromRgb(0x00FF00)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgb(0x0000FF)));
EXPECT_EQ(RgbColor::optional(0x0000FF), RgbColor::fromQColor(QColor::fromRgb(0x0000FF)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgb(0xFFFFFF)));
EXPECT_EQ(RgbColor::optional(0xFFFFFF), RgbColor::fromQColor(QColor::fromRgb(0xFFFFFF)));
}

TEST(RgbColorTest, OptionalRgbColorFromQColorWithAlpha) {
EXPECT_TRUE(RgbColor::optional(QColor::fromRgba(0xAA000000)));
EXPECT_EQ(RgbColor::optional(0x000000), RgbColor::optional(QColor::fromRgba(0xAA000000)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgba(0xAAFF0000)));
EXPECT_EQ(RgbColor::optional(0xFF0000), RgbColor::optional(QColor::fromRgba(0xAAFF0000)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgba(0xAA00FF00)));
EXPECT_EQ(RgbColor::optional(0x00FF00), RgbColor::optional(QColor::fromRgba(0xAA00FF00)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgba(0xAA0000FF)));
EXPECT_EQ(RgbColor::optional(0x0000FF), RgbColor::optional(QColor::fromRgba(0xAA0000FF)));
EXPECT_TRUE(RgbColor::optional(QColor::fromRgba(0xAAFFFFFF)));
EXPECT_EQ(RgbColor::optional(0xFFFFFF), RgbColor::optional(QColor::fromRgba(0xAAFFFFFF)));
TEST(RgbColorTest, fromQColorWithAlpha) {
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgba(0xAA000000)));
EXPECT_EQ(RgbColor::optional(0x000000), RgbColor::fromQColor(QColor::fromRgba(0xAA000000)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgba(0xAAFF0000)));
EXPECT_EQ(RgbColor::optional(0xFF0000), RgbColor::fromQColor(QColor::fromRgba(0xAAFF0000)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgba(0xAA00FF00)));
EXPECT_EQ(RgbColor::optional(0x00FF00), RgbColor::fromQColor(QColor::fromRgba(0xAA00FF00)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgba(0xAA0000FF)));
EXPECT_EQ(RgbColor::optional(0x0000FF), RgbColor::fromQColor(QColor::fromRgba(0xAA0000FF)));
EXPECT_TRUE(RgbColor::fromQColor(QColor::fromRgba(0xAAFFFFFF)));
EXPECT_EQ(RgbColor::optional(0xFFFFFF), RgbColor::fromQColor(QColor::fromRgba(0xAAFFFFFF)));
}

TEST(RgbColorTest,RgbColorToQColor) {
EXPECT_EQ(QColor::fromRgb(0x123456), toQColor(RgbColor(0x123456)));
TEST(RgbColorTest, toQColor) {
EXPECT_EQ(QColor::fromRgb(0x123456),
RgbColor::toQColor(RgbColor(0x123456)));
}

TEST(RgbColorTest, OptionalRgbColorToQColor) {
EXPECT_EQ(QColor(), toQColor(RgbColor::nullopt()));
TEST(RgbColorTest, toQColorOptional) {
EXPECT_EQ(QColor(),
RgbColor::toQColor(RgbColor::nullopt()));
EXPECT_EQ(QColor::fromRgba(0xAABBCCDD),
toQColor(RgbColor::nullopt(), QColor::fromRgba(0xAABBCCDD)));
RgbColor::toQColor(RgbColor::nullopt(), QColor::fromRgba(0xAABBCCDD)));
EXPECT_EQ(QColor::fromRgb(0x123456),
toQColor(RgbColor::optional(QColor::fromRgba(0xAA123456))));
RgbColor::toQColor(RgbColor::fromQColor(QColor::fromRgba(0xAA123456))));
EXPECT_EQ(QColor::fromRgb(0x123456),
toQColor(RgbColor::optional(QColor::fromRgba(0xAA123456)), QColor::fromRgba(0xAABBCCDD)));
RgbColor::toQColor(RgbColor::fromQColor(QColor::fromRgba(0xAA123456)), QColor::fromRgba(0xAABBCCDD)));
}

TEST(RgbColorTest, RgbColorToQVariant) {
EXPECT_EQ(QVariant(), toQVariant(RgbColor::nullopt()));
EXPECT_EQ(QVariant(0x123456), toQVariant(RgbColor(0x123456)));
TEST(RgbColorTest, toQVariant) {
EXPECT_EQ(QVariant(0x123456),
RgbColor::toQVariant(RgbColor(0x123456)));
}

TEST(RgbColorTest, OptionalRgbColorToQVariant) {
EXPECT_EQ(QVariant(), toQVariant(RgbColor::nullopt()));
TEST(RgbColorTest, toQVariantOptional) {
EXPECT_EQ(QVariant(),
RgbColor::toQVariant(RgbColor::nullopt()));
EXPECT_EQ(QVariant(0x123456),
toQVariant(RgbColor::optional(QColor::fromRgba(0xAA123456))));
RgbColor::toQVariant(RgbColor::fromQColor(QColor::fromRgba(0xAA123456))));
}

TEST(RgbColorTest, toQString) {
EXPECT_EQ(QString("#123456"),
RgbColor::toQString(RgbColor(0x123456)));
}

TEST(RgbColorTest, toQStringOptional) {
EXPECT_EQ(QString(),
RgbColor::toQString(RgbColor::nullopt()));
EXPECT_EQ(QString("None"),
RgbColor::toQString(RgbColor::nullopt(), QStringLiteral("None")));
EXPECT_EQ(QString("#123456"),
RgbColor::toQString(RgbColor::fromQColor(QColor::fromRgba(0xAA123456))));
EXPECT_EQ(QString("#123456"),
RgbColor::toQString(RgbColor::fromQColor(QColor::fromRgba(0xAA123456)), QStringLiteral("None")));
}

TEST(RgbColorTest, fromControlValue) {
EXPECT_EQ(RgbColor::nullopt(),
control::doubleToRgbColor(control::kInvalidRgbColor));
EXPECT_EQ(RgbColor::optional(0),
control::doubleToRgbColor(0));
EXPECT_EQ(RgbColor::optional(0xFEDCBA),
control::doubleToRgbColor(0xFEDCBA));
}

TEST(RgbColorTest, toControlValue) {
EXPECT_EQ(control::kInvalidRgbColor,
control::doubleFromRgbColor(RgbColor::nullopt()));
EXPECT_EQ(0.0,
control::doubleFromRgbColor(RgbColor(0)));
EXPECT_EQ(0.0,
control::doubleFromRgbColor(RgbColor::optional(0)));
EXPECT_EQ(16702650.0,
control::doubleFromRgbColor(RgbColor::optional(0xFEDCBA)));
EXPECT_EQ(16702650.0,
control::doubleFromRgbColor(RgbColor::optional(0xFEDCBA)));
}

} // namespace mixxx
Loading