procxx
/
kepka
mirror of https://github.com/procxx/kepka.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Fix pattern wallpapers with themes.

This commit is contained in:
John Preston 2019-01-29 13:57:29 +03:00
parent df0fe0a460
commit fd8e9dad92
5 changed files with 80 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Telegram/SourceFiles/mainwidget.cpp
View File

@ -1596,7 +1596,7 @@ void MainWidget::setReadyChatBackground(
? Data::DefaultWallPaper() ? Data::DefaultWallPaper()
: background; : background;
Background()->setImage(ready, std::move(image)); Background()->set(ready, std::move(image));
const auto tile = Data::IsLegacy1DefaultWallPaper(ready); const auto tile = Data::IsLegacy1DefaultWallPaper(ready);
Background()->setTile(tile); Background()->setTile(tile);
Ui::ForceFullRepaint(this); Ui::ForceFullRepaint(this);

2
Telegram/SourceFiles/settings/settings_chat.cpp
View File

@ -409,7 +409,7 @@ void ChooseFromFile(not_null<QWidget*> parent) {
4096 * image.width()); 4096 * image.width());
} }
Window::Theme::Background()->setImage( Window::Theme::Background()->set(
Data::CustomWallPaper(), Data::CustomWallPaper(),
std::move(image)); std::move(image));
Window::Theme::Background()->setTile(false); Window::Theme::Background()->setTile(false);

10
Telegram/SourceFiles/storage/localstorage.cpp
View File

@ -4076,16 +4076,16 @@ bool readBackground() {
|| Data::IsDefaultWallPaper(*paper)) { || Data::IsDefaultWallPaper(*paper)) {
_backgroundCanWrite = false; _backgroundCanWrite = false;
if (isOldEmptyImage || bg.version < 8005) { if (isOldEmptyImage || bg.version < 8005) {
Window::Theme::Background()->setImage(Data::DefaultWallPaper()); Window::Theme::Background()->set(Data::DefaultWallPaper());
Window::Theme::Background()->setTile(false); Window::Theme::Background()->setTile(false);
} else { } else {
Window::Theme::Background()->setImage(*paper); Window::Theme::Background()->set(*paper);
} }
_backgroundCanWrite = true; _backgroundCanWrite = true;
return true; return true;
} else if (Data::IsThemeWallPaper(*paper) && imageData.isEmpty()) { } else if (Data::IsThemeWallPaper(*paper) && imageData.isEmpty()) {
_backgroundCanWrite = false; _backgroundCanWrite = false;
Window::Theme::Background()->setImage(*paper); Window::Theme::Background()->set(*paper);
_backgroundCanWrite = true; _backgroundCanWrite = true;
return true; return true;
} }
@ -4132,9 +4132,9 @@ bool readBackground() {
image = QImage(); image = QImage();
} }
} }
if (!image.isNull()|| paper->backgroundColor()) { if (!image.isNull() || paper->backgroundColor()) {
_backgroundCanWrite = false; _backgroundCanWrite = false;
Window::Theme::Background()->setImage(*paper, std::move(image)); Window::Theme::Background()->set(*paper, std::move(image));
_backgroundCanWrite = true; _backgroundCanWrite = true;
return true; return true;
} }

121
Telegram/SourceFiles/window/themes/window_theme.cpp
View File

@ -788,13 +788,13 @@ bool loadTheme(const QByteArray &content, Cached &cache, Instance *out = nullptr
return true; return true;
} }
QImage prepareBackgroundImage(QImage &&image) { QImage validateBackgroundImage(QImage image) {
if (image.format() != QImage::Format_ARGB32_Premultiplied) { if (image.format() != QImage::Format_ARGB32_Premultiplied) {
image = std::move(image).convertToFormat( image = std::move(image).convertToFormat(
QImage::Format_ARGB32_Premultiplied); QImage::Format_ARGB32_Premultiplied);
} }
image.setDevicePixelRatio(cRetinaFactor()); image.setDevicePixelRatio(cRetinaFactor());
return std::move(image); return image;
} }
void adjustColor(style::color color, float64 hue, float64 saturation) { void adjustColor(style::color color, float64 hue, float64 saturation) {
@ -834,21 +834,19 @@ ChatBackground::ChatBackground() : _adjustableColors({
} }
void ChatBackground::setThemeData(QImage &&themeImage, bool themeTile) { void ChatBackground::setThemeData(QImage &&themeImage, bool themeTile) {
_themeImage = prepareBackgroundImage(std::move(themeImage)); _themeImage = validateBackgroundImage(std::move(themeImage));
_themeTile = themeTile; _themeTile = themeTile;
} }
void ChatBackground::start() { void ChatBackground::start() {
if (Data::details::IsUninitializedWallPaper(_paper)) { if (Data::details::IsUninitializedWallPaper(_paper)) {
if (!Local::readBackground()) { if (!Local::readBackground()) {
setImage(Data::ThemeWallPaper()); set(Data::ThemeWallPaper());
} }
} }
} }
void ChatBackground::setImage( void ChatBackground::set(const Data::WallPaper &paper, QImage image) {
const Data::WallPaper &paper,
QImage &&image) {
if (image.format() != QImage::Format_ARGB32_Premultiplied) { if (image.format() != QImage::Format_ARGB32_Premultiplied) {
image = std::move(image).convertToFormat( image = std::move(image).convertToFormat(
QImage::Format_ARGB32_Premultiplied); QImage::Format_ARGB32_Premultiplied);
@ -872,15 +870,17 @@ void ChatBackground::setImage(
} }
if (Data::IsThemeWallPaper(_paper)) { if (Data::IsThemeWallPaper(_paper)) {
(nightMode() ? _tileNightValue : _tileDayValue) = _themeTile; (nightMode() ? _tileNightValue : _tileDayValue) = _themeTile;
setPreparedImage(QImage(_themeImage)); setPreparedImage(_themeImage, _themeImage);
} else if (Data::details::IsTestingThemeWallPaper(_paper) } else if (Data::details::IsTestingThemeWallPaper(_paper)
|| Data::details::IsTestingDefaultWallPaper(_paper) || Data::details::IsTestingDefaultWallPaper(_paper)
|| Data::details::IsTestingEditorWallPaper(_paper)) { || Data::details::IsTestingEditorWallPaper(_paper)) {
if (Data::details::IsTestingDefaultWallPaper(_paper) || image.isNull()) { if (Data::details::IsTestingDefaultWallPaper(_paper)
|| image.isNull()) {
image.load(qsl(":/gui/art/bg.jpg")); image.load(qsl(":/gui/art/bg.jpg"));
setPaper(Data::details::TestingDefaultWallPaper()); setPaper(Data::details::TestingDefaultWallPaper());
} }
setPreparedImage(prepareBackgroundImage(std::move(image))); image = validateBackgroundImage(std::move(image));
setPreparedImage(image, image);
} else { } else {
if (Data::IsLegacy1DefaultWallPaper(_paper)) { if (Data::IsLegacy1DefaultWallPaper(_paper)) {
image.load(qsl(":/gui/art/bg_initial.jpg")); image.load(qsl(":/gui/art/bg_initial.jpg"));
@ -903,12 +903,15 @@ void ChatBackground::setImage(
: image)); : image));
if (const auto fill = _paper.backgroundColor()) { if (const auto fill = _paper.backgroundColor()) {
if (_paper.isPattern() && !image.isNull()) { if (_paper.isPattern() && !image.isNull()) {
setPreparedImage(Data::PreparePatternImage( auto prepared = validateBackgroundImage(
std::move(image), Data::PreparePatternImage(
*fill, image,
PatternColor(*fill), *fill,
_paper.patternIntensity())); PatternColor(*fill),
_paper.patternIntensity()));
setPreparedImage(std::move(image), std::move(prepared));
} else { } else {
_original = QImage();
_pixmap = QPixmap(); _pixmap = QPixmap();
_pixmapForTiled = QPixmap(); _pixmapForTiled = QPixmap();
if (adjustPaletteRequired()) { if (adjustPaletteRequired()) {
@ -916,11 +919,14 @@ void ChatBackground::setImage(
} }
} }
} else { } else {
setPreparedImage(prepareBackgroundImage(std::move(image))); image = validateBackgroundImage(std::move(image));
setPreparedImage(image, image);
} }
} }
Assert((!_pixmap.isNull() && !_pixmapForTiled.isNull()) Assert(colorForFill()
|| colorForFill()); || (!_original.isNull()
&& !_pixmap.isNull()
&& !_pixmapForTiled.isNull()));
notify(BackgroundUpdate(BackgroundUpdate::Type::New, tile())); notify(BackgroundUpdate(BackgroundUpdate::Type::New, tile()));
if (needResetAdjustable) { if (needResetAdjustable) {
@ -929,23 +935,31 @@ void ChatBackground::setImage(
} }
} }
void ChatBackground::setPreparedImage(QImage &&image) { void ChatBackground::setPreparedImage(QImage original, QImage prepared) {
Expects(image.format() == QImage::Format_ARGB32_Premultiplied); Expects(original.format() == QImage::Format_ARGB32_Premultiplied);
Expects(original.width() > 0 && original.height() > 0);
image.setDevicePixelRatio(cRetinaFactor()); Expects(prepared.format() == QImage::Format_ARGB32_Premultiplied);
Expects(prepared.width() > 0 && prepared.height() > 0);
_original = std::move(original);
if (adjustPaletteRequired()) { if (adjustPaletteRequired()) {
adjustPaletteUsingBackground(image); adjustPaletteUsingBackground(prepared);
} }
preparePixmaps(std::move(prepared));
}
auto width = image.width(); void ChatBackground::preparePixmaps(QImage image) {
auto height = image.height(); const auto width = image.width();
Assert(width > 0 && height > 0); const auto height = image.height();
auto isSmallForTiled = (width < kMinimumTiledSize || height < kMinimumTiledSize); const auto isSmallForTiled = (width < kMinimumTiledSize)
|| (height < kMinimumTiledSize);
if (isSmallForTiled) { if (isSmallForTiled) {
auto repeatTimesX = qCeil(kMinimumTiledSize / float64(width)); const auto repeatTimesX = qCeil(kMinimumTiledSize / (1. * width));
auto repeatTimesY = qCeil(kMinimumTiledSize / float64(height)); const auto repeatTimesY = qCeil(kMinimumTiledSize / (1. * height));
auto imageForTiled = QImage(width * repeatTimesX, height * repeatTimesY, QImage::Format_ARGB32_Premultiplied); auto imageForTiled = QImage(
width * repeatTimesX,
height * repeatTimesY,
QImage::Format_ARGB32_Premultiplied);
imageForTiled.setDevicePixelRatio(image.devicePixelRatio()); imageForTiled.setDevicePixelRatio(image.devicePixelRatio());
auto imageForTiledBytes = imageForTiled.bits(); auto imageForTiledBytes = imageForTiled.bits();
auto bytesInLine = width * sizeof(uint32); auto bytesInLine = width * sizeof(uint32);
@ -996,15 +1010,13 @@ bool ChatBackground::adjustPaletteRequired() {
return !usingDefaultBackground(); return !usingDefaultBackground();
} }
void ChatBackground::adjustPaletteUsingBackground(const QImage &img) { void ChatBackground::adjustPaletteUsingBackground(const QImage &image) {
Assert(img.format() == QImage::Format_ARGB32_Premultiplied);
uint64 components[3] = { 0 }; uint64 components[3] = { 0 };
uint64 componentsScroll[3] = { 0 }; uint64 componentsScroll[3] = { 0 };
auto w = img.width(); const auto w = image.width();
auto h = img.height(); const auto h = image.height();
auto size = w * h; const auto size = w * h;
if (auto pix = img.constBits()) { if (const auto pix = image.constBits()) {
for (auto i = 0, l = size * 4; i != l; i += 4) { for (auto i = 0, l = size * 4; i != l; i += 4) {
components[2] += pix[i + 0]; components[2] += pix[i + 0];
components[1] += pix[i + 1]; components[1] += pix[i + 1];
@ -1043,7 +1055,7 @@ QImage ChatBackground::createCurrentImage() const {
result.fill(*fill); result.fill(*fill);
return result; return result;
} }
return pixmap().toImage(); // #TODO patterns return pixmap().toImage();
} }
bool ChatBackground::tile() const { bool ChatBackground::tile() const {
@ -1118,15 +1130,15 @@ void ChatBackground::reset() {
|| Data::details::IsTestingDefaultWallPaper(_paper)) { || Data::details::IsTestingDefaultWallPaper(_paper)) {
if (_themeImage.isNull()) { if (_themeImage.isNull()) {
_paperForRevert = Data::DefaultWallPaper(); _paperForRevert = Data::DefaultWallPaper();
_imageForRevert = QImage(); _originalForRevert = QImage();
_tileForRevert = false; _tileForRevert = false;
} else { } else {
_paperForRevert = Data::ThemeWallPaper(); _paperForRevert = Data::ThemeWallPaper();
_imageForRevert = _themeImage; _originalForRevert = _themeImage;
_tileForRevert = _themeTile; _tileForRevert = _themeTile;
} }
} else { } else {
setImage(Data::ThemeWallPaper()); set(Data::ThemeWallPaper());
restoreAdjustableColors(); restoreAdjustableColors();
notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true); notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true);
notify(BackgroundUpdate(BackgroundUpdate::Type::ApplyingTheme, tile()), true); notify(BackgroundUpdate(BackgroundUpdate::Type::ApplyingTheme, tile()), true);
@ -1138,7 +1150,7 @@ void ChatBackground::saveForRevert() {
if (!Data::details::IsTestingThemeWallPaper(_paper) if (!Data::details::IsTestingThemeWallPaper(_paper)
&& !Data::details::IsTestingDefaultWallPaper(_paper)) { && !Data::details::IsTestingDefaultWallPaper(_paper)) {
_paperForRevert = _paper; _paperForRevert = _paper;
_imageForRevert = std::move(_pixmap).toImage(); _originalForRevert = std::move(_original);
_tileForRevert = tile(); _tileForRevert = tile();
} }
} }
@ -1165,24 +1177,26 @@ void ChatBackground::setTestingTheme(Instance &&theme) {
|| (Data::IsDefaultWallPaper(_paper) || (Data::IsDefaultWallPaper(_paper)
&& !nightMode() && !nightMode()
&& _themeAbsolutePath.isEmpty()); && _themeAbsolutePath.isEmpty());
if (AreTestingTheme() && IsPaletteTestingPath(GlobalApplying.pathAbsolute)) { if (AreTestingTheme()
&& IsPaletteTestingPath(GlobalApplying.pathAbsolute)) {
// Grab current background image if it is not already custom // Grab current background image if it is not already custom
// Use prepared pixmap, not original image, because we're
// for sure switching to a non-pattern wall-paper (testing editor).
if (!Data::IsCustomWallPaper(_paper)) { if (!Data::IsCustomWallPaper(_paper)) {
saveForRevert(); saveForRevert();
setImage( set(
Data::details::TestingEditorWallPaper(), Data::details::TestingEditorWallPaper(),
std::move(_pixmap).toImage()); std::move(_pixmap).toImage());
} }
} else if (switchToThemeBackground) { } else if (switchToThemeBackground) {
saveForRevert(); saveForRevert();
setImage( set(
Data::details::TestingThemeWallPaper(), Data::details::TestingThemeWallPaper(),
std::move(theme.background)); std::move(theme.background));
setTile(theme.tiled); setTile(theme.tiled);
} else { } else {
// Apply current background image so that service bg colors are recounted. // Apply current background image so that service bg colors are recounted.
// #TODO patterns set(_paper, std::move(_original));
setImage(_paper, std::move(_pixmap).toImage());
} }
notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true); notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true);
} }
@ -1192,7 +1206,7 @@ void ChatBackground::setTestingDefaultTheme() {
saveAdjustableColors(); saveAdjustableColors();
saveForRevert(); saveForRevert();
setImage(Data::details::TestingDefaultWallPaper()); set(Data::details::TestingDefaultWallPaper());
setTile(false); setTile(false);
notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true); notify(BackgroundUpdate(BackgroundUpdate::Type::TestingTheme, tile()), true);
} }
@ -1208,7 +1222,7 @@ void ChatBackground::keepApplied(const QString &path, bool write) {
} }
} else if (Data::details::IsTestingThemeWallPaper(_paper)) { } else if (Data::details::IsTestingThemeWallPaper(_paper)) {
setPaper(Data::ThemeWallPaper()); setPaper(Data::ThemeWallPaper());
_themeImage = prepareBackgroundImage(_pixmap.toImage()); _themeImage = validateBackgroundImage(base::duplicate(_original));
_themeTile = tile(); _themeTile = tile();
if (write) { if (write) {
writeNewBackgroundSettings(); writeNewBackgroundSettings();
@ -1249,7 +1263,7 @@ void ChatBackground::writeNewBackgroundSettings() {
((Data::IsThemeWallPaper(_paper) ((Data::IsThemeWallPaper(_paper)
|| Data::IsDefaultWallPaper(_paper)) || Data::IsDefaultWallPaper(_paper))
? QImage() ? QImage()
: _pixmap.toImage())); // #TODO patterns : _original));
} }
void ChatBackground::revert() { void ChatBackground::revert() {
@ -1257,11 +1271,10 @@ void ChatBackground::revert() {
|| Data::details::IsTestingDefaultWallPaper(_paper) || Data::details::IsTestingDefaultWallPaper(_paper)
|| Data::details::IsTestingEditorWallPaper(_paper)) { || Data::details::IsTestingEditorWallPaper(_paper)) {
setTile(_tileForRevert); setTile(_tileForRevert);
setImage(_paperForRevert, std::move(_imageForRevert)); set(_paperForRevert, std::move(_originalForRevert));
} else { } else {
// Apply current background image so that service bg colors are recounted. // Apply current background image so that service bg colors are recounted.
// #TODO patterns set(_paper, std::move(_original));
setImage(_paper, std::move(_pixmap).toImage());
} }
notify(BackgroundUpdate(BackgroundUpdate::Type::RevertingTheme, tile()), true); notify(BackgroundUpdate(BackgroundUpdate::Type::RevertingTheme, tile()), true);
} }
@ -1329,7 +1342,7 @@ void ChatBackground::toggleNightMode(std::optional<QString> themePath) {
} }
Local::writeSettings(); Local::writeSettings();
if (!settingDefault && !Local::readBackground()) { if (!settingDefault && !Local::readBackground()) {
setImage(Data::ThemeWallPaper()); set(Data::ThemeWallPaper());
} }
}; };
} }

10
Telegram/SourceFiles/window/themes/window_theme.h
View File

@ -177,7 +177,7 @@ public:
// This method is setting the default (themed) image if none was set yet. // This method is setting the default (themed) image if none was set yet.
void start(); void start();
void setImage(const Data::WallPaper &paper, QImage &&image = QImage()); void set(const Data::WallPaper &paper, QImage image = QImage());
void setTile(bool tile); void setTile(bool tile);
void setTileDayValue(bool tile); void setTileDayValue(bool tile);
void setTileNightValue(bool tile); void setTileNightValue(bool tile);
@ -215,12 +215,13 @@ private:
void ensureStarted(); void ensureStarted();
void saveForRevert(); void saveForRevert();
void setPreparedImage(QImage &&image); void setPreparedImage(QImage original, QImage prepared);
void preparePixmaps(QImage image);
void writeNewBackgroundSettings(); void writeNewBackgroundSettings();
void setPaper(const Data::WallPaper &paper); void setPaper(const Data::WallPaper &paper);
[[nodiscard]] bool adjustPaletteRequired(); [[nodiscard]] bool adjustPaletteRequired();
void adjustPaletteUsingBackground(const QImage &img); void adjustPaletteUsingBackground(const QImage &image);
void adjustPaletteUsingColor(QColor color); void adjustPaletteUsingColor(QColor color);
void restoreAdjustableColors(); void restoreAdjustableColors();
@ -240,6 +241,7 @@ private:
Data::WallPaper _paper = Data::details::UninitializedWallPaper(); Data::WallPaper _paper = Data::details::UninitializedWallPaper();
std::optional<QColor> _paperColor; std::optional<QColor> _paperColor;
QImage _original;
QPixmap _pixmap; QPixmap _pixmap;
QPixmap _pixmapForTiled; QPixmap _pixmapForTiled;
bool _nightMode = false; bool _nightMode = false;
@ -252,7 +254,7 @@ private:
Data::WallPaper _paperForRevert Data::WallPaper _paperForRevert
= Data::details::UninitializedWallPaper(); = Data::details::UninitializedWallPaper();
QImage _imageForRevert; QImage _originalForRevert;
bool _tileForRevert = false; bool _tileForRevert = false;
std::vector<AdjustableColor> _adjustableColors; std::vector<AdjustableColor> _adjustableColors;