From c3ce92830d41004bde5109e97ae78800efcd6fa8 Mon Sep 17 00:00:00 2001 From: Mirek Fidler Date: Fri, 6 Dec 2024 10:05:57 +0100 Subject: [PATCH] Dynamic skin changes --- examples/Color/Color.upp | 2 +- examples/UWord/UWord.cpp | 2 + reference/ThemeChangeSensitive/MyApp.h | 16 ++ reference/ThemeChangeSensitive/MyApp.lay | 18 ++ .../ThemeChangeSensitive/SkinSensitive.lay | 3 + .../ThemeChangeSensitive.upp | 11 + reference/ThemeChangeSensitive/main.cpp | 91 ++++++ uppsrc/CodeEditor/Style.cpp | 2 + uppsrc/CodeEditor/hl_color.i | 1 + uppsrc/Core/Color.cpp | 175 +++++------- uppsrc/Core/Color.h | 39 ++- uppsrc/Core/Core.h | 2 +- uppsrc/Core/Function.h | 2 +- uppsrc/Core/Ops.h | 5 + uppsrc/Core/Stream.h | 4 - uppsrc/Core/src.tpp/Color_en-us.tpp | 52 +++- uppsrc/CtrlCore/Ctrl.cpp | 62 +++-- uppsrc/CtrlCore/CtrlCore.h | 16 +- uppsrc/CtrlCore/CtrlKbd.cpp | 14 + uppsrc/CtrlCore/GtkApp.cpp | 10 + uppsrc/CtrlCore/GtkCtrl.h | 2 + uppsrc/CtrlCore/Win32Proc.cpp | 10 +- uppsrc/CtrlCore/src.tpp/Ctrl_en-us.tpp | 41 +++ .../CtrlCore/srcdoc.tpp/Resolution_en-us.tpp | 17 +- uppsrc/CtrlLib/ArrayCtrl.cpp | 6 + uppsrc/CtrlLib/ArrayCtrl.h | 6 +- uppsrc/CtrlLib/Ch.h | 5 + uppsrc/CtrlLib/ChGtk3.cpp | 11 +- uppsrc/CtrlLib/ChWin32.cpp | 22 +- uppsrc/CtrlLib/ColorPusher.cpp | 2 +- uppsrc/CtrlLib/Ctrl.iml | 260 +++++++++--------- uppsrc/CtrlLib/CtrlLib.upp | 1 - uppsrc/CtrlLib/CtrlLibInit.cpp | 9 +- uppsrc/CtrlLib/DateTimeCtrl.cpp | 4 +- uppsrc/CtrlLib/FileSel.cpp | 5 + uppsrc/CtrlLib/FileSel.h | 1 + .../appdoc.tpp/DlgSelectColor_cs-cz.tpp | 140 ---------- uppsrc/CtrlLib/srcdoc.tpp/MenuCb_en-us.tpp | 127 --------- .../srcdoc.tpp/RoundingDoubles_en-us.tpp | 140 ---------- uppsrc/CtrlLib/srcdoc.tpp/Updater_en-us.tpp | 57 ---- uppsrc/Draw/Cham.cpp | 2 + uppsrc/Draw/Cham.h | 15 +- uppsrc/Draw/Image.cpp | 13 +- uppsrc/Draw/Image.h | 4 + uppsrc/Draw/Iml.cpp | 33 ++- uppsrc/Draw/MakeCache.cpp | 1 + uppsrc/Draw/SColors.cpp | 5 +- uppsrc/Draw/src.tpp/ImageBuffer_en-us.tpp | 2 +- .../Draw/srcdoc.tpp/UhdAndDarkTheme_en-us.tpp | 55 +++- uppsrc/RichEdit/Editor.cpp | 24 +- uppsrc/RichEdit/RichEdit.h | 5 + uppsrc/TabBar/FileTabs.cpp | 6 +- uppsrc/TabBar/TabBar.cpp | 6 +- uppsrc/ide/Config.cpp | 7 +- uppsrc/ide/Debuggers/GdbData.cpp | 2 +- uppsrc/ide/LayDes/laylib.cpp | 2 +- uppsrc/ide/RepoSync.cpp | 8 +- uppsrc/ide/Setup.cpp | 18 +- uppsrc/ide/UppHub.cpp | 17 +- uppsrc/ide/UppWspc.cpp | 10 +- uppsrc/ide/ide.h | 3 +- uppsrc/ide/ide.lay | 68 ++--- uppsrc/ide/idewin.cpp | 11 +- uppsrc/ide/main.cpp | 1 + upptst/RichTextNumbering/main.cpp | 2 +- upptst/TestChStyle/TestChStyle.h | 2 + upptst/TestChStyle/TestChStyle.lay | 115 ++++---- upptst/TestChStyle/main.cpp | 49 ++-- 68 files changed, 930 insertions(+), 949 deletions(-) create mode 100644 reference/ThemeChangeSensitive/MyApp.h create mode 100644 reference/ThemeChangeSensitive/MyApp.lay create mode 100644 reference/ThemeChangeSensitive/SkinSensitive.lay create mode 100644 reference/ThemeChangeSensitive/ThemeChangeSensitive.upp create mode 100644 reference/ThemeChangeSensitive/main.cpp delete mode 100644 uppsrc/CtrlLib/appdoc.tpp/DlgSelectColor_cs-cz.tpp delete mode 100644 uppsrc/CtrlLib/srcdoc.tpp/MenuCb_en-us.tpp delete mode 100644 uppsrc/CtrlLib/srcdoc.tpp/RoundingDoubles_en-us.tpp delete mode 100644 uppsrc/CtrlLib/srcdoc.tpp/Updater_en-us.tpp diff --git a/examples/Color/Color.upp b/examples/Color/Color.upp index 1001e278e..952d00f99 100644 --- a/examples/Color/Color.upp +++ b/examples/Color/Color.upp @@ -1,4 +1,4 @@ -description "Paints text using different colors"; +description "Paints text using different colors\377"; uses CtrlLib; diff --git a/examples/UWord/UWord.cpp b/examples/UWord/UWord.cpp index bda87fcc0..a4c69d688 100644 --- a/examples/UWord/UWord.cpp +++ b/examples/UWord/UWord.cpp @@ -280,6 +280,8 @@ GUI_APP_MAIN StdLogSetup(LOG_FILE|LOG_ELAPSED); SetLanguage(LNG_ENGLISH); SetDefaultCharset(CHARSET_UTF8); + + Ctrl::SkinChangeSensitive(); UWordFs().Type("QTF files", "*.qtf") .Type("RTF files", "*.rtf") diff --git a/reference/ThemeChangeSensitive/MyApp.h b/reference/ThemeChangeSensitive/MyApp.h new file mode 100644 index 000000000..a56fde4a8 --- /dev/null +++ b/reference/ThemeChangeSensitive/MyApp.h @@ -0,0 +1,16 @@ +#ifndef _SkinSensitive_SkinSensitive_h +#define _SkinSensitive_SkinSensitive_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +class SkinSensitive : public WithSkinSensitiveLayout { +public: + SkinSensitive(); +}; + +#endif diff --git a/reference/ThemeChangeSensitive/MyApp.lay b/reference/ThemeChangeSensitive/MyApp.lay new file mode 100644 index 000000000..fdc82fef5 --- /dev/null +++ b/reference/ThemeChangeSensitive/MyApp.lay @@ -0,0 +1,18 @@ +LAYOUT(MyAppLayout, 644, 348) + ITEM(Upp::ArrayCtrl, list1, LeftPosZ(4, 156).TopPosZ(4, 148)) + ITEM(Upp::ArrayCtrl, list2, LeftPosZ(164, 156).TopPosZ(4, 148)) + ITEM(Upp::ArrayCtrl, list3, LeftPosZ(324, 156).TopPosZ(4, 148)) + ITEM(Upp::ArrayCtrl, list4, LeftPosZ(484, 156).TopPosZ(4, 148)) + ITEM(Upp::Button, std, SetLabel(t_("Set Standard skin")).LeftPosZ(4, 112).TopPosZ(284, 24)) + ITEM(Upp::Button, dark, SetLabel(t_("Set Standard dark skin")).LeftPosZ(120, 140).TopPosZ(284, 24)) + ITEM(Upp::Button, host, SetLabel(t_("Set Host platform skin")).LeftPosZ(264, 140).TopPosZ(284, 24)) + ITEM(Upp::Button, toggle, SetLabel(t_("Toggle dark")).LeftPosZ(4, 104).TopPosZ(316, 24)) + ITEM(Upp::Label, info, SetLabel(t_("In debug mode, the prefined key for Toggle dark is Ctrl+Num[*]")).LeftPosZ(112, 328).TopPosZ(316, 24)) + ITEM(Upp::ImageCtrl, img1, LeftPosZ(4, 60).TopPosZ(156, 36)) + ITEM(Upp::ImageCtrl, img2, LeftPosZ(4, 60).TopPosZ(196, 36)) + ITEM(Upp::ImageCtrl, img3, LeftPosZ(4, 60).TopPosZ(236, 36)) + ITEM(Upp::Label, dv___12, SetLabel(t_("This image is sourced as iml constant and automatically adjusts to theme changes")).LeftPosZ(68, 452).TopPosZ(156, 36)) + ITEM(Upp::Label, dv___13, SetLabel(t_("This image is created and does not change when theme changes")).LeftPosZ(68, 452).TopPosZ(196, 36)) + ITEM(Upp::Label, dv___14, SetLabel(t_("This image is created but is changed by Skin method")).LeftPosZ(68, 452).TopPosZ(236, 36)) +END_LAYOUT + diff --git a/reference/ThemeChangeSensitive/SkinSensitive.lay b/reference/ThemeChangeSensitive/SkinSensitive.lay new file mode 100644 index 000000000..0c71b94d3 --- /dev/null +++ b/reference/ThemeChangeSensitive/SkinSensitive.lay @@ -0,0 +1,3 @@ +LAYOUT(MyAppLayout, 200, 100) +END_LAYOUT + diff --git a/reference/ThemeChangeSensitive/ThemeChangeSensitive.upp b/reference/ThemeChangeSensitive/ThemeChangeSensitive.upp new file mode 100644 index 000000000..fbd8c7d8c --- /dev/null +++ b/reference/ThemeChangeSensitive/ThemeChangeSensitive.upp @@ -0,0 +1,11 @@ +uses + CtrlLib; + +file + MyApp.h, + main.cpp, + MyApp.lay; + +mainconfig + "" = "GUI"; + diff --git a/reference/ThemeChangeSensitive/main.cpp b/reference/ThemeChangeSensitive/main.cpp new file mode 100644 index 000000000..120140b8a --- /dev/null +++ b/reference/ThemeChangeSensitive/main.cpp @@ -0,0 +1,91 @@ +#include + +#ifndef _SkinSensitive_SkinSensitive_h +#define _SkinSensitive_SkinSensitive_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +struct MyApp : public WithMyAppLayout { + virtual void Skin(); + + Image MakeImage(); + + MyApp(); +}; + +#endif + +Image MyApp::MakeImage() +{ // make some image in a way that reflects dark/light mode + Size sz = CtrlImg::HandCursor().GetSize(); + ImageDraw iw(sz.cx, sz.cy); + iw.DrawRect(sz, SColorFace()); + iw.DrawImage(0, 0, CtrlImg::HandCursor()); // HandCursor is adjusted wrt dark/light + iw.DrawRect(sz.cx / 2, sz.cy / 2, DPI(5), DPI(5), SColorHighlight()); // SColorHighlight is adjusted wrt dark/light + return iw; +} + +void MyApp::Skin() +{ // called on opening window and on theme change + list4.Clear(); // just refill the list with new colors + list4.Add(AttrText("Blend(SRed, SYellow)").NormalInk(Blend(SRed(), SYellow())).Bold()); + list4.Add(AttrText("SLtBlue").NormalInk(SBlue().Resolved()).Bold()); // Resolved converts SBlue to normal color, just as does Blend + list4.Add(AttrText("Blend(SRed, SLtBlue)").NormalInk(Blend(SRed(), SLtBlue())).Bold()); + + img3.SetImage(MakeImage()); +} + +MyApp::MyApp() +{ + CtrlLayout(*this, "How to dynamically react to theme changes"); + list1.AddColumn("Ignoring skin change"); + list1.NoCursor(); + list1.Add(AttrText("Blend(Red, Yellow)").NormalInk(Blend(SRed(), SYellow())).Bold()); + list1.Add(AttrText("SBlue").NormalInk(SBlue().Resolved()).Bold()); // Resolved converts SBlue to normal color, just as does Blend, for testing + list1.Add(AttrText("Blend(Red, LtBlue)").NormalInk(Blend(SRed(), SLtBlue())).Bold()); + + list2.AddColumn("Using AColor"); + list2.NoCursor(); + list2.Add(AttrText("Blend(Red, Yellow)").NormalInk(AColor(Blend(Red(), Yellow()))).Bold()); // Light theme color that gets adjusted if theme is dark + list2.Add(AttrText("SLtBlue").NormalInk(AColor(Blue())).Bold()); + list2.Add(AttrText("Blend(Red, LtBlue)").NormalInk(AColor(Blend(Red(), LtBlue()))).Bold()); + + list3.AddColumn("Using SColor"); + list3.NoCursor(); + static SColor ry([] { return Blend(SRed(), SYellow()); }); // Gets reevaluated on skin change + static SColor rb([] { return Blend(SRed(), SLtBlue()); }); + list3.Add(AttrText("Blend(Red, Yellow)").NormalInk(ry).Bold()); + list3.Add(AttrText("SLtBlue").NormalInk(SBlue()).Bold()); // SBlue is different based on skin + list3.Add(AttrText("Blend(Red, LtBlue)").NormalInk(rb).Bold()); + + list4.AddColumn("Reloaded with Skin"); + list4.NoCursor(); + + img1.SetImage(CtrlImg::HandCursor()); // iml image constants react to theme changes (even theirs copies) + img2.SetImage(MakeImage()); // the image copy is stored just once and does not reflect theme changes + + std << [=] { Ctrl::SetSkin(ChStdSkin); }; + dark << [=] { Ctrl::SetSkin(ChDarkSkin); }; + host << [=] { Ctrl::SetSkin(ChHostSkin); }; + + toggle << [=] { Ctrl::SwapDarkLight(); }; + +#ifndef _DEBUG + info = "Predefined key for Toggle dark was set to Space"; +#endif +} + +GUI_APP_MAIN +{ +#ifndef _DEBUG + Ctrl::SwapDarkLightKey(K_SPACE); // just to demonstrate that toggle key can be activated in Release mode too and/or different +#endif + + Ctrl::SkinChangeSensitive(); // activate changes of skin (theme) when host theme changes + MyApp().Run(); +} diff --git a/uppsrc/CodeEditor/Style.cpp b/uppsrc/CodeEditor/Style.cpp index 3fa03586a..8b18ff8af 100644 --- a/uppsrc/CodeEditor/Style.cpp +++ b/uppsrc/CodeEditor/Style.cpp @@ -196,6 +196,7 @@ void HighlightSetup::DarkTheme(bool host) SetHlStyle(PAPER_WARNING, Color(21, 21, 0)); SetHlStyle(SHOW_LINE, Color(27, 75, 26)); SetHlStyle(SHOW_COLUMN, Color(56, 33, 29)); + SetHlStyle(SHOW_BORDER, Color(70, 50, 50)); SetHlStyle(WHITESPACE, Color(68, 128, 176)); SetHlStyle(WARN_WHITESPACE, Color(206, 141, 141)); @@ -261,6 +262,7 @@ void HighlightSetup::WhiteTheme(bool host) SetHlStyle(SHOW_LINE, Color(199, 247, 198)); SetHlStyle(SHOW_COLUMN, Color(247, 224, 220)); + SetHlStyle(SHOW_BORDER, Color(250, 220, 220)); SetHlStyle(INK_NORMAL, Black()); SetHlStyle(INK_DISABLED, Color(109, 109, 109)); diff --git a/uppsrc/CodeEditor/hl_color.i b/uppsrc/CodeEditor/hl_color.i index 7282aa08f..3facce763 100644 --- a/uppsrc/CodeEditor/hl_color.i +++ b/uppsrc/CodeEditor/hl_color.i @@ -62,6 +62,7 @@ HL_COLOR(PAPER_ERROR_FILE, t_("Current file errors"), 0) HL_COLOR(PAPER_WARNING, t_("Warning in compiler messages"), 0) HL_COLOR(SHOW_LINE, t_("Current line highlight"), 0) HL_COLOR(SHOW_COLUMN, t_("Current column highlight"), 0) +HL_COLOR(SHOW_BORDER, t_("Border column highlight"), 0) HL_COLOR(WHITESPACE, t_("Whitespaces"), 1) HL_COLOR(WARN_WHITESPACE, t_("Misplaced tabs and spaces"), 1) diff --git a/uppsrc/Core/Color.cpp b/uppsrc/Core/Color.cpp index 89d6b5f8d..adf70e3e1 100644 --- a/uppsrc/Core/Color.cpp +++ b/uppsrc/Core/Color.cpp @@ -94,11 +94,75 @@ double ContrastRatio(Color c1, Color c2) { return (max(rl1, rl2) + 0.05) / (min(rl1, rl2) + 0.05); } +static const int s_Max = 1024; +static std::atomic s_color_ii; +static Color s_color[s_Max]; +static Color (*s_color_fn[s_Max])(); + +SColor::SColor(Color (*fn)()) +{ + int ii = s_color_ii++; + ASSERT(ii < s_Max); // number of SColors is limited + ii = min(ii, s_Max - 1); + s_color_fn[ii] = fn; + if(fn) + s_color[ii] = (*fn)(); + color = ii | SCOLOR; +} + +#ifdef _DEBUG +SColor::~SColor() +{ + ASSERT(!IsMainRunning()); // SColor cannot be stack variable +} +#endif + +void SColor::Refresh() +{ + int n = min((int)s_color_ii, s_Max - 1); + for(int i = 0; i < n; i++) + if(s_color_fn[i]) + s_color[i] = (*s_color_fn[i])(); +} + +void SColor::Write(Color c, Color val) +{ + int ii = c.GetRaw() & VBITS; + ASSERT((c.GetRaw() & SCOLOR) && ii >= 0 && ii < s_Max); + if(ii >= 0 && ii < s_Max) { + ASSERT(!s_color_fn[ii]); + s_color[ii] = val.Resolved(); + } +} + +bool AColor_dark_mode__; + dword Color::Get() const { if(IsNullInstance()) return 0; - dword c = color; - return c & 0xffffff; + if(color & SPECIAL) + return 0; + dword val = color & VBITS; + if(color & ACOLOR) { + Color c = FromRaw(val); + if(AColor_dark_mode__) + return DarkThemeCached(c).color; + return val; + } + if(color & SCOLOR) + return val < s_Max ? s_color[val].color : 0; + return color & VBITS; +} + +String Color::ToString() const { + if(IsNull(*this)) + return "Color(Null)"; + if(color & SCOLOR) + return Format("SColor(%d) -> Color(%d, %d, %d)", int(color & VBITS), GetR(), GetG(), GetB()); + int ii = GetSpecial(); + if(ii >= 0) + return Format("Color::Special(%d)", ii); + return Format("Color(%d, %d, %d)", GetR(), GetG(), GetB()); } template <> @@ -172,7 +236,7 @@ void Color::Xmlize(XmlIO& xio) if(IsNull(r)) *this = Null; else - *this = Color(r, g, b); + *this = Color(r, g, b); } RGBA operator*(int alpha, Color c) @@ -186,15 +250,6 @@ RGBA operator*(int alpha, Color c) return r; } -template<> -String AsString(const Color& c) { - if(IsNull(c)) - return "Color(Null)"; - if(c.GetRaw() & 0x80000000) - return Format("Color(%d, 0)", int(c.GetRaw() & ~0x80000000)); - return Format("Color(%d, %d, %d)", c.GetR(), c.GetG(), c.GetB()); -} - String ColorToHtml(Color color) { return IsNull(color) ? Null : Format("#%02X%02X%02X", color.GetR(), color.GetG(), color.GetB()); @@ -260,8 +315,6 @@ int Grayscale2(const Color& c) return (c.GetR() + c.GetG() + c.GetB()) / 3; } -#if 1 - double C_R = 0.32; double C_G = 0.5; double C_B = 0.2; @@ -302,91 +355,12 @@ Color DarkTheme(Color color) Saturate255(int(b + saturation))); } - -#else // older worse algorithm - -double DarkTheme_c[3] = { 0.3, 0.5, 0.2 }; -int DarkTheme_middle = 155; - -Color DarkTheme(Color color) -{ - if(IsNull(color)) - return Null; - - double v[3]; - v[0] = color.GetR(); - v[1] = color.GetG(); - v[2] = color.GetB(); - -// this represent physiological perception of brightness of R,G,B. Sum = 1 - static double *c = DarkTheme_c; // with this set, blues and reds are more pronounced - - double m0 = c[0] * v[0] + c[1] * v[1] + c[2] * v[2]; // base brightness - - const int middle = DarkTheme_middle; // this value represents gamma-like feature, imbalance of perception of dark vs bright - const double up = (256.0 - middle) / middle; - const double down = 1 / up; - - double m; // target brightness - if(m0 < middle) - m = middle + (middle - m0) * up; - else - m = middle - (m0 - middle) * down; - - int i0 = 0; - int i1 = 1; - int i2 = 2; - - if(v[i0] > v[i1]) - Swap(i0, i1); - if(v[i1] > v[i2]) - Swap(i1, i2); - if(v[i0] > v[i1]) - Swap(i0, i1); - - if(m0 < m) { - m -= m0; - double a = min(v[i2] + m, 255.0) - v[i2]; - v[i0] += a; - v[i1] += a; - v[i2] += a; - m -= a; - - a = min(v[i1] + m / (c[i0] + c[i1]), 255.0) - v[i1]; - v[i0] += a; - v[i1] += a; - m -= (c[i0] + c[i1]) * a; - - v[i0] = min(v[i0] + m / c[i1], 255.0); - } - else { - m = m0 - m; - double a = v[i0] - max(v[i0] - m, 0.0); - v[i0] -= a; - v[i1] -= a; - v[i2] -= a; - m -= a; - - a = v[i1] - max(v[i1] - m / (c[i1] + c[i2]), 0.0); - v[i1] -= a; - v[i2] -= a; - m -= (c[i1] + c[i2]) * a; - - v[i2] = max(v[i2] - m / c[i2], 0.0); - } - - return Color((int)v[0], (int)v[1], (int)v[2]); -} - -#endif - Color DarkThemeCached(Color c) { - const int N = 8; + const int N = 256; // must be 2^N thread_local struct Cache { Color icolor[N]; Color ocolor[N]; - int ii = 0; Cache() { for(int i = 0; i < N; i++) { @@ -395,13 +369,12 @@ Color DarkThemeCached(Color c) } } } cache; - #define DO(i) if(cache.icolor[i] == c) return cache.ocolor[i]; - DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7); - cache.ii = (cache.ii + 1) & (N - 1); - cache.icolor[cache.ii] = c; - c = DarkTheme(c); - cache.ocolor[cache.ii] = c; - return c; + + int i = FoldHash32(c.GetRaw()) & (N - 1); + if(cache.icolor[i] == c) + return cache.ocolor[i]; + cache.icolor[i] = c; + return cache.ocolor[i] = DarkTheme(cache.icolor[i]); } } diff --git a/uppsrc/Core/Color.h b/uppsrc/Core/Color.h index a8abf99ea..ea7cc2f4e 100644 --- a/uppsrc/Core/Color.h +++ b/uppsrc/Core/Color.h @@ -42,8 +42,16 @@ class Color : public ValueType > { protected: dword color; - dword Get() const; + enum { + SPECIAL = 0x80000000, // special "non-colors" + SCOLOR = 0x40000000, // SColor - colors defined by function + ACOLOR = 0x20000000, // light colors that get automatically converted in dark mode + VBITS = 0xffffff, + }; + dword Get() const; + void SetSpecial(int n) { color = SPECIAL | n; } + public: dword GetRaw() const { return color; } @@ -75,10 +83,12 @@ public: Color(Color (*fn)()) { color = (*fn)().color; } + String ToString() const; + static Color FromRaw(dword co) { Color c; c.color = co; return c; } - static Color Special(int n) { Color c; c.color = 0x80000000 | n; return c; } + static Color Special(int n) { Color c; c.SetSpecial(n); return c; } - int GetSpecial() const { return color & 0x80000000 ? color & 0x7fffffff : -1; } + int GetSpecial() const { return color & SPECIAL ? color & 0x7fffffff : -1; } #ifdef PLATFORM_WIN32 operator COLORREF() const { return (COLORREF) Get(); } @@ -87,10 +97,29 @@ public: operator dword() const { return Get(); } #endif + Color Resolved() { return FromRaw(Get()); } + private: Color(int); }; +struct SColor : Color { // this is supposed to be static / global + static void Refresh(); + static void Write(Color c, Color val); + + SColor(Color (*fn)() = NULL); + explicit SColor(Color c) : SColor() { Write(*this, c); } + void operator=(Color c) { Write(*this, c); } +#ifdef _DEBUG + ~SColor(); +#endif +}; + +struct AColor : Color { + AColor(Color c) { color = c.Resolved().GetRaw() | ACOLOR; } // works for Null as well... + AColor(int r, int g, int b) : AColor(Color(r, g, b)) {} +}; + RGBA operator*(int alpha, Color c); inline Color StraightColor(RGBA rgba) { return Color(rgba.r, rgba.g, rgba.b); } @@ -100,10 +129,6 @@ typedef Color (*ColorF)(); inline hash_t GetHashValue(Color c) { return c.GetHashValue(); } inline Color Nvl(Color a, Color b) { return IsNull(a) ? b : a; } -template<> -String AsString(const Color& c); - - inline Color GrayColor(int a = 128) { return Color(a, a, a); } inline Color Black() { return Color(0, 0, 0); } diff --git a/uppsrc/Core/Core.h b/uppsrc/Core/Core.h index e05e417bd..da7fe04b0 100644 --- a/uppsrc/Core/Core.h +++ b/uppsrc/Core/Core.h @@ -1,7 +1,7 @@ #ifndef CORE_H #define CORE_H -#define UPP_VERSION 0x20240900 +#define UPP_VERSION 0x20241100 #ifndef flagMT #define flagMT // MT is now always on diff --git a/uppsrc/Core/Function.h b/uppsrc/Core/Function.h index a73954046..eab974920 100644 --- a/uppsrc/Core/Function.h +++ b/uppsrc/Core/Function.h @@ -84,7 +84,7 @@ public: WrapperBase *b = ptr; ptr = new Wrapper2(*this, pick(fn)); Free(b); return *this; } Res operator()(ArgTypes... args) const { return ptr ? ptr->Execute(args...) : Res(); } - + operator bool() const { return ptr; } void Clear() { Free(ptr); ptr = NULL; } diff --git a/uppsrc/Core/Ops.h b/uppsrc/Core/Ops.h index b349cefb9..dc36a13f2 100644 --- a/uppsrc/Core/Ops.h +++ b/uppsrc/Core/Ops.h @@ -161,6 +161,11 @@ inline dword FoldHash(dword h) #endif +inline dword FoldHash32(dword h) +{ + return SwapEndian32(0x8e86671b * h); +} + inline byte Saturate255(int x) { return byte(~(x >> 24) & (x | (-(x >> 8) >> 24)) & 0xff); } force_inline diff --git a/uppsrc/Core/Stream.h b/uppsrc/Core/Stream.h index 9e0478c13..4317ca4c5 100644 --- a/uppsrc/Core/Stream.h +++ b/uppsrc/Core/Stream.h @@ -1,7 +1,3 @@ -#ifdef _DEBUG -#define NEWBLOCKSTREAM -#endif - enum { STRM_ERROR = 0x20, STRM_READ = 0x10, diff --git a/uppsrc/Core/src.tpp/Color_en-us.tpp b/uppsrc/Core/src.tpp/Color_en-us.tpp index 07c65c7b0..ef3722e4b 100644 --- a/uppsrc/Core/src.tpp/Color_en-us.tpp +++ b/uppsrc/Core/src.tpp/Color_en-us.tpp @@ -54,7 +54,7 @@ Color are needed instead of global Color constants on many platforms, because often global variables are not allowed when using dynamic libraries.&] [s7; [%-*@3 fn]-|Pointer to a function returning Color.&] -[s0; &] +[s3;%- &] [s4;%- &] [s5;:Color`:`:Color`(RGBA`):%- [* Color]([_^RGBA^ RGBA]_[*@3 rgba])&] [s2; Conversion from a RGBA structure [%-*@3 rgba].&] @@ -147,7 +147,7 @@ F_[*@3 cr])&] [s2; Creates Color from COLORREF.&] [s7; [%-*C@3 cr]-|COLORREF.&] [s7; [*/ Return value]-|Color.&] -[s3; &] +[s3;%- &] [s4;%- &] [s5;:Color`:`:operator dword`(`)const:%- [* operator_dword]()_[@(0.0.255) const]&] [s6;%- Not available on Win32&] @@ -158,16 +158,53 @@ etRaw]().&] [s5;:Color`:`:operator RGBA`(`)const:%- [* operator_RGBA]()_[@(0.0.255) const]&] [s2; Returns a RGBA structure containing the color information.&] [s3;%- &] +[s4;%- &] +[s5;:Upp`:`:Color`:`:ToString`(`)const:%- String [* ToString]() [@(0.0.255) const]&] +[s2; Converts Color to textual form.&] [s0; &] +[ {{10000@(113.42.0) [s0; [*@(229)4 SColor]]}}&] +[s3;%- &] +[s1;:Upp`:`:SColor:%- [@(0.0.255) struct ][*3 SColor][3 ][@(0.0.255)3 :][3 +Color]&] +[s2; This creates special kind of `"logical`" color constant that +is defined by function which is reevaluated on GUI theme change, +thus allowing color to react to the new theme. Instances of this +class must have static storage duration (cannot be stack nor +thread variables). Number of SColor definitions is limited for +performance reasons to about 1000. The SColor instances can be +copied to normal Color while maintaining its dynamic feature.&] +[s0; &] +[ {{10000F(128)G(128)@1 [s0; [* Constructor Detail]]}}&] +[s3; &] +[s5;:Upp`:`:SColor`:`:SColor`(Color`(`*`)`(`)`):%- [* SColor](Color +([@(0.0.255) `*]fn)() [@(0.0.255) `=] [@3 0])&] +[s2; Creates SColor with color definition function.&] +[s0; &] +[ {{10000@(113.42.0) [s0; [*@(229)4 AColor]]}}&] +[s3;%- &] +[s1;:Upp`:`:AColor:%- [@(0.0.255) struct ][*3 AColor][3 ][@(0.0.255)3 :][3 +Color]&] +[s2; This special kind of Color logical constant is created from +normal color. In light theme, color is used unchanged. In dark +theme, color is adjusted using [%-* DarkThemeCached] function. +The AColor instances can be copied to normal Color while maintaining +its dynamic feature. [/ (Unlike SColor there are no limitations +with respect to storage duration).]&] +[s0; &] +[ {{10000F(128)G(128)@1 [s0; [* Constructor Detail]]}}&] +[s3;%- &] +[s5;:Upp`:`:AColor`:`:AColor`(Color`):%- [* AColor](Color [*@3 c])&] +[s5;:Upp`:`:AColor`:`:AColor`(int`,int`,int`):%- [* AColor]([@(0.0.255) int] +[*@3 r], [@(0.0.255) int] [*@3 g], [@(0.0.255) int] [*@3 b])&] +[s2; Creates AColor.&] [s0; &] -[s0;%- &] [ {{10000@(113.42.0) [s0; [*@(229)4 Utility functions]]}}&] [s3;%- &] [s5;:GetRValue`(dword`):%- [@(0.0.255) int]_[* GetRValue]([_^dword^ dword]_[*@3 c])&] [s2; Returns red component from a platform specific value.&] [s7; [%-*C@3 c]-|Platform specific value.&] [s7; [*/ Return value]-|Red component.&] -[s3; &] +[s3;%- &] [s4;%- &] [s5;:GetGValue`(dword`):%- [@(0.0.255) int]_[* GetGValue]([_^dword^ dword]_[*@3 c])&] [s2; Returns green component from a platform specific value.&] @@ -205,13 +242,6 @@ etRaw]().&] [s7; [*/ Return value]-|a if not Null, b otherwise.&] [s3; &] [s4;%- &] -[s5;:AsString`(const Color`&`):%- [@(0.0.255) template]_<>_[_^String^ String]_[* AsString]( -[@(0.0.255) const]_[_^Color^ Color][@(0.0.255) `&]_[*@3 c])&] -[s2; Converts Color to textual form.&] -[s7; [%-*C@3 c]-|Color.&] -[s7; [*/ Return value]-|Textual form.&] -[s3; &] -[s4;%- &] [s5;:RGBtoHSV`(double`,double`,double`,double`&`,double`&`,double`&`):%- [@(0.0.255) vo id]_[* RGBtoHSV]([@(0.0.255) double]_[*@3 r], [@(0.0.255) double]_[*@3 g], [@(0.0.255) double]_[*@3 b], [@(0.0.255) double`&]_[*@3 h], [@(0.0.255) double`&]_[*@3 s], diff --git a/uppsrc/CtrlCore/Ctrl.cpp b/uppsrc/CtrlCore/Ctrl.cpp index 9261b6ebb..10796ec9f 100644 --- a/uppsrc/CtrlCore/Ctrl.cpp +++ b/uppsrc/CtrlCore/Ctrl.cpp @@ -209,6 +209,8 @@ void Ctrl::StateH(int reason) if((*statehook()[i])(this, reason)) return; StateDeep(reason); + if(reason == OPEN) + DoSkin(); FullRefreshCleanup(); } @@ -462,12 +464,12 @@ String Desc(const Ctrl *ctrl) s << " \"" << q << '\"'; const Ctrl *top = ctrl->GetTopWindow(); if(top && top != ctrl) { - String q = top->GetDesc(); - if(IsNull(q)) - s << " (" << typeid(*top).name() << ")"; - else - s << " (\"" << q << "\")"; - } + String q = top->GetDesc(); + if(IsNull(q)) + s << " (" << typeid(*top).name() << ")"; + else + s << " (\"" << q << "\")"; + } return s; } @@ -699,13 +701,6 @@ Size Ctrl::Dsize; Size Ctrl::Csize; bool Ctrl::IsNoLayoutZoom; -/* -void InitRichTextZoom() -{ - SetRichTextStdScreenZoom(96 * GetTextSize(sZoomText, StdFont()).cy / 13, 600); - Ctrl::ReSkin(); -} -*/ void InitRichTextZoom() { Size h = 96 * Ctrl::Bsize / Ctrl::Dsize; @@ -925,9 +920,10 @@ INITBLOCK { whenSetStdFont = &Ctrl::ReSkin; } -void (*Ctrl::skin)(); +void (**Ctrl::skin)(); +int Ctrl::skini; -void CtrlSetDefaultSkin(void (*_skin)()) +void CtrlSetDefaultSkin(void (**_skin)()) { Ctrl::skin = _skin; } @@ -935,7 +931,7 @@ void CtrlSetDefaultSkin(void (*_skin)()) void Ctrl::SetSkin(void (*_skin)()) { GuiLock __; - skin = _skin; + skin[0] = _skin; ReSkin(); } @@ -947,21 +943,49 @@ void Ctrl::ReSkin() return; lock++; ChReset(); - Iml::ResetAll(); Csize.cx = Dsize.cx = IsNoLayoutZoom; - if(skin) - (*skin)(); + Iml::SkinAll(); + if(skin[skini]) + (*skin[skini])(); Csize.cx = Dsize.cx = IsNoLayoutZoom; Csizeinit(); ChFinish(); Vector ctrl = GetTopCtrls(); for(int i = 0; i < ctrl.GetCount(); i++) { ctrl[i]->RefreshLayoutDeep(); + ctrl[i]->DoSkin(); ctrl[i]->RefreshFrame(); } lock--; } +static bool s_skin_change_sensitive; + +void Ctrl::SkinChangeSensitive(bool b) +{ + s_skin_change_sensitive = b; +} + +void Ctrl::PostReSkin() +{ // use timer so that it is done just once if there are multiple windows + static TimeCallback tm; + if(s_skin_change_sensitive) + tm.KillPost([=] { ReSkin(); }); +} + +void Ctrl::DoSkin() +{ + for(Ctrl& q : *this) + q.DoSkin(); + Skin(); +} + +void Ctrl::SwapDarkLight() +{ + skini = skini ? 0 : IsDarkTheme() ? 1 : 2; + ReSkin(); +} + CH_INT(GUI_GlobalStyle, GUISTYLE_CLASSIC); CH_INT(GUI_DragFullWindow, 1); CH_INT(GUI_PopUpEffect, GUIEFFECT_SLIDE); diff --git a/uppsrc/CtrlCore/CtrlCore.h b/uppsrc/CtrlCore/CtrlCore.h index 0457a036a..209942633 100644 --- a/uppsrc/CtrlCore/CtrlCore.h +++ b/uppsrc/CtrlCore/CtrlCore.h @@ -775,14 +775,15 @@ private: static Size Csize; static bool IsNoLayoutZoom; static void Csizeinit(); - static void (*skin)(); + static void (**skin)(); // [0] - default, [1] - std light, [2] - std dark (1, 2 for debug mode testing) + static int skini; // normally 0, allows changing skin in debug mode (to test dark skin), with Ctrl-Alt-Shift-F12 static void (*cancel_preedit)(); friend void InitRichTextZoom(); friend void AvoidPaintingCheck__(); friend dword GetKeyStateSafe(dword what); - friend void CtrlSetDefaultSkin(void (*_skin)()); + friend void CtrlSetDefaultSkin(void (**_skin)()); friend class DHCtrl; friend class TopFrameDraw; friend class ViewDraw; @@ -1057,6 +1058,8 @@ public: virtual String GetDesc() const; virtual void SetMinSize(Size sz) {} + + virtual void Skin() {} Event<> WhenAction; @@ -1397,10 +1400,15 @@ public: static void SetUHDEnabled(bool set = true); static bool IsUHDEnabled(); - + static void SetDarkThemeEnabled(bool set = true); static bool IsDarkThemeEnabled(); + static void SkinChangeSensitive(bool b = true); + + static void SwapDarkLight(); + static void SwapDarkLightKey(dword key); + static bool ClickFocus(); static void ClickFocus(bool cf); @@ -1424,6 +1432,8 @@ public: static void GlobalBackBuffer(bool b = true); static void ReSkin(); + static void PostReSkin(); + void DoSkin(); String Name() const; static String Name(Ctrl *ctrl); diff --git a/uppsrc/CtrlCore/CtrlKbd.cpp b/uppsrc/CtrlCore/CtrlKbd.cpp index 2f24bd758..ca785f4fa 100644 --- a/uppsrc/CtrlCore/CtrlKbd.cpp +++ b/uppsrc/CtrlCore/CtrlKbd.cpp @@ -12,9 +12,19 @@ bool Ctrl::ignorekeyup; Ptr Ctrl::defferedSetFocus; Vector< Ptr > Ctrl::defferedChildLostFocus; +static dword s_swapdarklight_key +#ifdef _DEBUG += K_CTRL|K_MULTIPLY +#endif +; static bool s_hotkey; +void Ctrl::SwapDarkLightKey(dword key) +{ + s_swapdarklight_key = key; +} + void Ctrl::RefreshAccessKeys() { GuiLock __; @@ -48,6 +58,10 @@ bool Ctrl::DispatchKey(dword keycode, int count) LLOG("DispatchKey " << keycode << " (0x" << Sprintf("%08x", keycode) << ", " << GetKeyDesc(keycode) << "), count:" << count << " focusCtrl:" << UPP::Name(focusCtrl) << " focusCtrlWnd:" << UPP::Name(focusCtrlWnd)); +#if defined(_DEBUG) || defined(flagDEBUGCODE) + if(s_swapdarklight_key && keycode == s_swapdarklight_key) + SwapDarkLight(); +#endif if((keycode & K_KEYUP) && ignorekeyup) { ignorekeyup = false; diff --git a/uppsrc/CtrlCore/GtkApp.cpp b/uppsrc/CtrlCore/GtkApp.cpp index 9bbea7cca..5471eda34 100644 --- a/uppsrc/CtrlCore/GtkApp.cpp +++ b/uppsrc/CtrlCore/GtkApp.cpp @@ -61,6 +61,11 @@ bool RunningOnWayland() return running_on_wayland; } +void Ctrl::ThemeChanged(void *) +{ + PostReSkin(); +} + void InitGtkApp(int argc, char **argv, const char **envptr) { LLOG(rmsecs() << " InitGtkApp"); @@ -91,6 +96,11 @@ void InitGtkApp(int argc, char **argv, const char **envptr) #if CATCH_ERRORS g_log_set_default_handler (CatchError, 0); #endif + GtkSettings *settings = gtk_settings_get_default (); + if(settings) { + g_signal_connect_swapped(settings, "notify::gtk-theme-name", G_CALLBACK(Ctrl::ThemeChanged), NULL); + g_signal_connect_swapped(settings, "notify::gtk-application-prefer-dark-theme", G_CALLBACK(Ctrl::ThemeChanged), NULL); + } } void ExitGtkApp() diff --git a/uppsrc/CtrlCore/GtkCtrl.h b/uppsrc/CtrlCore/GtkCtrl.h index 40dce63f7..f77436787 100644 --- a/uppsrc/CtrlCore/GtkCtrl.h +++ b/uppsrc/CtrlCore/GtkCtrl.h @@ -10,6 +10,8 @@ static void AddEvent(gpointer user_data, int type, const Value& value, GdkEvent *event); static void FetchEvents(bool may_block); + static void ThemeChanged(void *); + /* _DBG_ static void AddEvent(gpointer user_data, int type, const Value& value); diff --git a/uppsrc/CtrlCore/Win32Proc.cpp b/uppsrc/CtrlCore/Win32Proc.cpp index e954ba797..72e9e3d18 100644 --- a/uppsrc/CtrlCore/Win32Proc.cpp +++ b/uppsrc/CtrlCore/Win32Proc.cpp @@ -593,9 +593,6 @@ LRESULT Ctrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) { case WM_ACTIVATE: LLOG("WM_ACTIVATE " << Name() << ", wParam = " << (int)wParam << ", focusCtrlWnd = " << UPP::Name(focusCtrlWnd) << ", raw = " << (void *)::GetFocus()); ignorekeyup = true; - case 0x031A: // WM_THEMECHANGED - XpClear(); - break; case WM_SETFOCUS: LLOG("WM_SETFOCUS " << Name() << ", focusCtrlWnd = " << UPP::Name(focusCtrlWnd) << ", raw = " << (void *)::GetFocus()); if(this != focusCtrlWnd || focusCtrl && focusCtrlWnd != focusCtrl->GetTopCtrl()) { // second condition fixes popup issue when clicking dialog parent @@ -664,13 +661,10 @@ LRESULT Ctrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) { } return 0L; #endif -/* case WM_SETTINGCHANGE: + case WM_SETTINGCHANGE: case 0x031A: // WM_THEMECHANGED - ReSkin(); - RefreshLayoutDeep(); - RefreshFrame(); + PostReSkin(); break; -*/ /* case WM_IME_COMPOSITION: HIMC himc = ImmGetContext(hwnd); diff --git a/uppsrc/CtrlCore/src.tpp/Ctrl_en-us.tpp b/uppsrc/CtrlCore/src.tpp/Ctrl_en-us.tpp index 93cb9adad..8ace54977 100644 --- a/uppsrc/CtrlCore/src.tpp/Ctrl_en-us.tpp +++ b/uppsrc/CtrlCore/src.tpp/Ctrl_en-us.tpp @@ -2513,6 +2513,14 @@ be statically overloaded to receive minimal size of layout.&] [s7;i1120;a17; [%-*C@3 sz]-|Minimal size of layout.&] [s3;%- &] [s4;%- &] +[s5;:Upp`:`:Ctrl`:`:Skin`(`):%- [@(0.0.255) void] [* Skin]()&] +[s2; Called when the application skin (e.g. widget appearance, system +colors or dark / light theme switch) changes. It is called in +children first order. Application should use this to adjust colors, +which might actually include resetting some widgets and data +content.&] +[s3;%- &] +[s4;%- &] [s5;:Ctrl`:`:Csizeinit`(`):%- [@(0.0.255) static] [@(0.0.255) void]_[* Csizeinit]()&] [s2;b17;a17; Sets zoom factor used to scale layouts (to scale zoomed positioning methods like LeftPosZ). Horizontal distances are @@ -2561,8 +2569,41 @@ ize]_[*@3 sz])&] [s5;:Ctrl`:`:NoLayoutZoom`(`):%- [@(0.0.255) static] [@(0.0.255) void]_[* NoLayoutZoom]()&] [s2;b17;a17; Sets scaling factor to (1, 1). Same as SetZoomSize(Size(1, 1), Size(1, 1)).&] +[s3;%- &] +[s4;%- &] +[s5;:Upp`:`:Ctrl`:`:SetSkin`(void`(`*`)`(`)`):%- [@(0.0.255) static] +[@(0.0.255) void] [* SetSkin]([@(0.0.255) void] ([@(0.0.255) `*][*@3 skin])())&] +[s2; Sets the GUI theme. [%-*@3 skin] is routine that sets appearance +of everything, by altering predefined SColors, changing images +and changing widget appearance through `::StyleDefault().Write(). +See CtrlLib/Ch.cpp for example.&] +[s3;%- &] +[s4;%- &] +[s5;:Upp`:`:Ctrl`:`:SkinChangeSensitive`(bool`):%- [@(0.0.255) static] +[@(0.0.255) void] [* SkinChangeSensitive]([@(0.0.255) bool] [*@3 b] [@(0.0.255) `=] +[@(0.0.255) true])&] +[s2; If not active (which is default), the appearance of U`+`+ application +is established once at the start and does not change if user +switches host platform theme. If active, U`+`+ changes appearance +when host platform theme changes. Note that activating this feature +requires additional work and thorough testing to make sure that +all colors adequately react to changes between light and dark +modes.&] [s3; &] [s4;%- &] +[s5;:Upp`:`:Ctrl`:`:SwapDarkLight`(`):%- [@(0.0.255) static] [@(0.0.255) void] +[* SwapDarkLight]()&] +[s2; This debugging feature toggles between dark and light mode to +make skin change sensitive application development easier.&] +[s3;%- &] +[s4;%- &] +[s5;:Upp`:`:Ctrl`:`:SwapDarkLightKey`(dword`):%- [@(0.0.255) static] +[@(0.0.255) void] [* SwapDarkLightKey](dword [*@3 key])&] +[s2; This sets a special key that when presses calls SwapDarkLight. +0 means no key. Normally, in debug mode Ctrl`+Num`[`*`] is the +default key, in release mode default is 0.&] +[s3;%- &] +[s4;%- &] [s5;:Upp`:`:Ctrl`:`:SetUHDEnabled`(bool`):%- [@(0.0.255) void]_[* SetUHDEnabled]([@(0.0.255) b ool]_[*@3 set])&] [s2; Informs host platform that application is UHD ready. Default diff --git a/uppsrc/CtrlCore/srcdoc.tpp/Resolution_en-us.tpp b/uppsrc/CtrlCore/srcdoc.tpp/Resolution_en-us.tpp index 87e0434dc..cabb102a0 100644 --- a/uppsrc/CtrlCore/srcdoc.tpp/Resolution_en-us.tpp +++ b/uppsrc/CtrlCore/srcdoc.tpp/Resolution_en-us.tpp @@ -41,19 +41,18 @@ size between 12`-22. When GUI font gets bigger, there starts to be a problem with Images (e.g. button icons) being too small. This is typical for UHD display.&] [s0; &] -[s0; To resolve this problem, upscaled Images need to provided in -this case. This is not a problem for Images that are created +[s0; To resolve this problem, upscaled Images need to be provided +in this case. This is not a problem for Images that are created by code (because they can easily incorporate scaling factor into the algorithm), but would be a problem for images from .iml resources.&] [s0; &] -[s0; To this means, Image has Resolution info. This can have 3 values -`- Standard, UHD, None. This info can be adjusted in Icon designed -(right click Image name and choose Image..., or double`-click -Image name)&] +[s0; To this means, iml Image has UHD flag. This info can be adjusted +in Icon designed (right click Image name and choose Image..., +or double`-click Image name)&] [s0; &] [s0;= -@@image:924&1250 -(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) +@@image:924&1482 +(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) &] [s0; &] [s0; U`+`+ can be switched to [^topic`:`/`/Draw`/src`/UHD`$en`-us`#Upp`:`:SetUHDMode`(bool`)^ `" @@ -61,7 +60,7 @@ UHD`" mode]. In this mode, if icon is retrieved from .iml and it is in Standard resolution, it is upscaled 2x (relatively smart algorithm is used so that it looks quite fine on UHD display). Correspondingly, in standard mode, UHD resolution icons are downscaled. -Icons with `"None`" resolution are left intact.&] +Icons with `"Fixed size`" are left intact.&] [s0; &] [s0; It is also possible and preferable to have both standard and UHD variants in the same .iml file. If this the case, UHD variant diff --git a/uppsrc/CtrlLib/ArrayCtrl.cpp b/uppsrc/CtrlLib/ArrayCtrl.cpp index b8644cb9f..d1263d02a 100644 --- a/uppsrc/CtrlLib/ArrayCtrl.cpp +++ b/uppsrc/CtrlLib/ArrayCtrl.cpp @@ -4,6 +4,12 @@ namespace Upp { #define LTIMING(x) // DTIMING(x) +Color SColorEvenRow() +{ + static SColor s([] { return Blend(SColorMark, SColorPaper, 220); }); + return s; +} + ArrayCtrl::Column::Column() { convert = NULL; edit = NULL; diff --git a/uppsrc/CtrlLib/ArrayCtrl.h b/uppsrc/CtrlLib/ArrayCtrl.h index b0cddf457..887518915 100644 --- a/uppsrc/CtrlLib/ArrayCtrl.h +++ b/uppsrc/CtrlLib/ArrayCtrl.h @@ -10,6 +10,8 @@ Callback1&> DefaultCtrlFactory() return callback(DefaultCtrlFactoryFn); } +Color SColorEvenRow(); + class ArrayCtrl : public Ctrl { public: virtual void CancelMode(); @@ -684,8 +686,8 @@ public: ArrayCtrl& Grid(bool b = true) { return VertGrid(b).HorzGrid(b); } ArrayCtrl& NoGrid() { return Grid(false); } ArrayCtrl& GridColor(Color c) { gridcolor = c; return *this; } - ArrayCtrl& EvenRowColor(Color paper = Blend(SColorMark, SColorPaper, 220), Color ink = SColorText); - ArrayCtrl& OddRowColor(Color paper = SColorInfo, Color ink = SColorText); + ArrayCtrl& EvenRowColor(Color paper = SColorEvenRow(), Color ink = SColorText); + ArrayCtrl& OddRowColor(Color paper = SColorInfo(), Color ink = SColorText); ArrayCtrl& NoCursor(bool b = true) { nocursor = b; return *this; } ArrayCtrl& MouseMoveCursor(bool b = true) { mousemove = b; return *this; } ArrayCtrl& NoMouseMoveCursor() { return MouseMoveCursor(false); } diff --git a/uppsrc/CtrlLib/Ch.h b/uppsrc/CtrlLib/Ch.h index 1d672d966..752c6970a 100644 --- a/uppsrc/CtrlLib/Ch.h +++ b/uppsrc/CtrlLib/Ch.h @@ -9,6 +9,11 @@ void ChFlatSkin(); void ChFlatDarkSkin(); void ChFlatGraySkin(); +#ifdef PLATFORM_WIN32 +void ChHostSkinLight(); +void ChHostSkinDark(); +#endif + Vector> GetAllChSkins(); enum { diff --git a/uppsrc/CtrlLib/ChGtk3.cpp b/uppsrc/CtrlLib/ChGtk3.cpp index 68857984a..6200028b9 100644 --- a/uppsrc/CtrlLib/ChGtk3.cpp +++ b/uppsrc/CtrlLib/ChGtk3.cpp @@ -443,12 +443,11 @@ void ChHostSkin() { ScrollBar::Style& s = ScrollBar::StyleDefault().Write(); - static gboolean stepper; - static gint minslider; - ONCELOCK { - static GtkWidget *proto = (GtkWidget *)gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL); // to get style params - gtk_widget_style_get(proto, "has-backward-stepper", &stepper, "min-slider-length", &minslider, NULL); - } + gboolean stepper; + gint minslider; + GtkWidget *proto = (GtkWidget *)gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL); // to get style params + gtk_widget_style_get(proto, "has-backward-stepper", &stepper, "min-slider-length", &minslider, NULL); + g_object_unref(proto); if(!stepper) s.arrowsize = 0; Gtk_New("scrollbar.horizontal.bottom"); diff --git a/uppsrc/CtrlLib/ChWin32.cpp b/uppsrc/CtrlLib/ChWin32.cpp index 12bfe4dce..a2e79e69c 100644 --- a/uppsrc/CtrlLib/ChWin32.cpp +++ b/uppsrc/CtrlLib/ChWin32.cpp @@ -380,7 +380,7 @@ bool IsSystemThemeDark() return GetEnv("UPP_DARKMODE__") == "1" ? !b : b; } -void ChHostSkin() +void ChHostSkin0() { if(Ctrl::IsUHDEnabled()) { HRESULT (STDAPICALLTYPE *SetProcessDpiAwareness)(int); @@ -395,8 +395,6 @@ void ChHostSkin() } } - sEmulateDarkTheme = Ctrl::IsDarkThemeEnabled() && IsSystemThemeDark() && !IsDark(Color::FromCR(GetSysColor(COLOR_WINDOW))); - NONCLIENTMETRICSW ncm; #if (WINVER >= 0x0600 && !defined(__MINGW32_VERSION)) ncm.cbSize = sizeof(ncm) - sizeof(ncm.iPaddedBorderWidth); // WinXP does not like it... @@ -742,6 +740,24 @@ void ChHostSkin() ChClassicSkin(); } +void ChHostSkin() +{ + sEmulateDarkTheme = Ctrl::IsDarkThemeEnabled() && IsSystemThemeDark() && !IsDark(Color::FromCR(GetSysColor(COLOR_WINDOW))); + ChHostSkin0(); +} + +void ChHostSkinLight() +{ + sEmulateDarkTheme = false; + ChHostSkin0(); +} + +void ChHostSkinDark() +{ + sEmulateDarkTheme = true; + ChHostSkin0(); +} + } #endif diff --git a/uppsrc/CtrlLib/ColorPusher.cpp b/uppsrc/CtrlLib/ColorPusher.cpp index 4821fa4f6..f276775b5 100644 --- a/uppsrc/CtrlLib/ColorPusher.cpp +++ b/uppsrc/CtrlLib/ColorPusher.cpp @@ -18,7 +18,7 @@ void ColorPusher::Paint(Draw& w) voidtext, StdFont(), SColorText()); else { auto DrawColor = [&](int x, int y, int cx, int cy) { - if(color.GetSpecial() >= 0) { + if(color.GetSpecial() >= 0 && color.GetSpecial() < 18) { Color c = RealizeColor(color); w.DrawRect(x, y, cx / 2, cy, c); w.DrawRect(x + cx / 2, y, cx - cx / 2, cy, DarkTheme(c)); diff --git a/uppsrc/CtrlLib/Ctrl.iml b/uppsrc/CtrlLib/Ctrl.iml index 26e836347..1c5ee13d9 100644 --- a/uppsrc/CtrlLib/Ctrl.iml +++ b/uppsrc/CtrlLib/Ctrl.iml @@ -1016,48 +1016,48 @@ IMAGE_DATA(177,36,121,75,73,73,141,55,253,31,56,115,124,157,0,0,0,0,0,0,0,0,0,0, IMAGE_END_DATA(3200, 18) IMAGE_BEGIN_DATA -IMAGE_DATA(120,156,237,157,93,76,91,101,24,199,201,230,149,49,25,209,196,196,11,111,77,100,102,217,2,94,232,110,77,212,11,227) -IMAGE_DATA(141,81,47,182,101,137,209,160,67,157,204,161,219,112,131,77,230,116,147,201,128,169,115,48,153,176,249,193,230,198,156,211) -IMAGE_DATA(11,103,208,100,113,140,209,66,203,96,124,13,246,129,180,12,218,158,126,156,246,244,227,241,20,44,235,224,61,165,125,125) -IMAGE_DATA(207,251,84,120,254,225,23,104,195,211,247,252,127,79,9,92,80,200,201,205,201,205,89,72,57,125,32,207,58,112,126,141) -IMAGE_DATA(54,248,251,186,36,214,106,191,213,21,12,222,191,108,233,131,247,221,187,100,217,108,150,46,201,185,39,49,111,63,89,16) -IMAGE_DATA(140,197,162,0,16,211,223,226,76,127,28,86,157,48,244,71,97,104,160,181,48,152,96,232,194,102,181,173,229,181,145,103) -IMAGE_DATA(86,231,190,152,152,191,220,184,202,29,139,168,16,188,89,9,254,161,42,240,15,31,129,192,72,51,196,194,46,253,161,124) -IMAGE_DATA(16,139,120,117,60,211,183,195,147,16,82,125,161,179,85,143,217,19,243,29,13,249,74,84,243,232,179,53,224,27,168,6) -IMAGE_DATA(165,187,28,38,218,222,0,231,165,34,112,217,42,192,213,85,6,46,235,86,152,180,148,232,20,235,215,229,0,75,211,42) -IMAGE_DATA(111,98,190,251,120,190,22,14,140,129,203,94,3,147,29,123,192,209,186,9,2,142,139,250,153,202,191,103,199,223,187,103) -IMAGE_DATA(206,143,119,179,53,21,168,51,243,71,31,215,166,186,71,131,58,1,128,136,127,106,46,18,232,133,224,104,13,168,55,42) -IMAGE_DATA(32,112,173,4,252,253,133,224,235,93,3,17,95,15,216,234,243,103,230,237,117,5,161,88,36,0,17,229,47,8,187,126) -IMAGE_DATA(5,237,118,51,132,198,14,235,115,123,33,48,92,10,129,129,34,240,95,93,11,190,43,207,131,215,246,20,68,188,86,176) -IMAGE_DATA(29,74,154,175,45,8,70,53,5,180,137,51,16,114,52,234,103,214,130,122,93,63,115,40,126,230,171,224,235,121,9,188) -IMAGE_DATA(246,103,65,233,92,13,158,142,149,16,86,218,193,86,125,103,222,182,63,95,141,105,46,125,182,1,130,183,170,64,29,41) -IMAGE_DATA(215,103,139,193,223,247,138,62,251,130,126,230,211,160,88,159,0,207,229,21,224,190,244,136,62,223,6,241,153,196,252,159) -IMAGE_DATA(101,43,70,199,71,44,110,165,191,41,234,235,175,7,111,223,65,240,246,86,130,183,103,55,40,246,29,160,216,182,128,167) -IMAGE_DATA(171,24,60,214,34,240,88,94,7,213,209,26,107,175,88,233,78,204,175,123,242,129,141,251,94,126,248,216,133,109,143,58) -IMAGE_DATA(59,119,45,87,83,178,115,185,218,94,150,231,41,125,238,161,106,49,207,254,255,150,194,245,57,235,177,175,129,66,161,80) -IMAGE_DATA(40,20,10,133,66,161,80,40,20,10,133,66,161,80,40,20,10,133,66,201,202,116,150,231,169,50,192,238,153,109,145,229) -IMAGE_DATA(157,118,48,55,24,238,105,15,211,97,249,136,255,242,136,153,208,14,166,35,219,59,237,224,78,48,221,167,218,3,182,23) -IMAGE_DATA(89,201,6,247,139,117,7,217,242,220,95,172,59,200,54,247,70,59,88,168,123,200,86,255,70,59,88,104,63,247,102,179) -IMAGE_DATA(255,197,176,135,255,131,127,217,123,32,255,248,123,37,255,248,123,32,255,11,127,7,60,254,101,126,63,196,38,155,252,99) -IMAGE_DATA(187,88,136,59,72,215,63,182,3,108,48,253,179,174,39,232,60,1,33,231,41,8,141,183,76,189,208,79,155,56,11,218) -IMAGE_DATA(228,185,233,23,12,78,254,146,33,231,56,248,153,143,248,117,166,129,172,29,204,231,127,246,53,136,236,152,62,63,137,227) -IMAGE_DATA(246,153,140,48,123,7,169,252,207,113,111,82,199,249,105,17,70,104,252,116,198,152,185,131,116,253,155,221,49,53,167,196) -IMAGE_DATA(225,252,145,11,217,254,103,239,92,70,71,99,78,10,228,4,23,102,125,13,164,227,95,86,71,99,154,197,225,248,129,27) -IMAGE_DATA(60,255,242,58,178,249,94,24,193,177,239,184,65,243,47,177,35,155,111,197,241,247,113,110,176,252,203,236,200,230,152,56) -IMAGE_DATA(70,155,184,65,243,47,177,35,155,70,129,124,195,13,154,127,137,29,217,28,21,138,122,171,129,11,60,255,242,58,178,249) -IMAGE_DATA(90,44,55,143,112,129,229,95,102,71,54,245,98,185,81,199,5,154,127,137,29,217,28,22,203,245,175,184,64,243,47,177) -IMAGE_DATA(35,155,67,66,9,140,124,201,5,154,127,137,29,217,124,33,152,207,185,192,242,47,179,35,155,131,98,25,174,229,2,207) -IMAGE_DATA(191,188,142,108,106,196,114,173,154,11,52,255,18,59,178,57,32,148,169,63,106,202,1,154,127,137,29,217,124,38,150,193) -IMAGE_DATA(253,92,96,249,151,217,145,77,165,96,62,229,2,205,191,196,142,108,246,9,197,55,176,151,11,60,255,242,58,178,249,68) -IMAGE_DATA(44,253,31,115,129,229,95,102,71,54,123,196,210,247,17,23,104,254,37,118,100,179,91,44,87,43,184,64,243,47,177,35) -IMAGE_DATA(155,15,133,226,237,221,197,5,154,127,137,29,217,236,20,76,57,23,88,254,101,118,100,83,38,150,158,29,92,224,249,151) -IMAGE_DATA(215,145,205,118,177,92,249,128,11,52,255,18,59,178,41,21,138,210,189,141,11,52,255,18,59,26,179,85,28,246,45,92) -IMAGE_DATA(96,249,151,217,209,152,247,5,242,30,23,104,254,37,118,52,166,68,28,182,205,92,224,249,151,215,209,152,119,133,225,233) -IMAGE_DATA(218,196,5,154,127,137,29,141,41,22,71,231,59,25,147,236,195,44,255,201,59,72,190,79,86,199,212,108,20,135,245,237) -IMAGE_DATA(140,49,195,61,107,7,76,255,146,58,166,230,45,129,188,153,17,102,61,247,89,254,19,59,184,203,191,132,142,243,83,36) -IMAGE_DATA(4,183,101,67,70,152,237,222,104,7,119,251,55,183,227,12,214,185,247,121,172,27,146,30,123,246,237,248,63,48,100,127) -IMAGE_DATA(142,59,113,159,197,96,110,30,88,30,204,114,159,206,14,22,59,102,187,167,29,224,187,167,29,224,122,167,80,40,20,10) -IMAGE_DATA(133,66,161,80,40,20,10,133,66,161,80,40,20,10,133,66,161,80,178,57,255,0,27,36,49,163,0,0,0,0,0,0) +IMAGE_DATA(120,156,237,157,93,76,91,101,24,199,9,243,202,152,140,104,98,226,133,183,38,50,179,108,1,47,116,183,38,234,133,241) +IMAGE_DATA(198,168,23,219,178,196,104,208,161,78,230,208,109,232,96,147,57,221,100,50,96,234,28,76,38,108,126,176,185,49,231,244) +IMAGE_DATA(194,25,52,89,148,49,90,104,25,12,10,131,125,32,45,131,182,167,31,167,61,45,125,60,5,203,58,120,79,105,95,223) +IMAGE_DATA(243,62,21,158,127,248,5,218,240,244,61,255,223,83,2,23,20,114,243,114,242,114,22,83,78,31,200,183,58,206,175,213) +IMAGE_DATA(6,127,91,159,196,58,237,215,250,194,193,123,151,47,187,255,158,187,115,151,207,101,89,110,206,93,137,121,251,201,194,80) +IMAGE_DATA(44,54,5,0,49,253,45,206,204,199,17,213,5,67,191,23,133,29,109,69,161,4,67,23,182,168,237,173,175,140,60,181) +IMAGE_DATA(38,239,249,196,252,165,166,213,158,88,84,133,208,141,42,8,12,85,67,96,248,8,4,71,90,32,22,113,235,15,229,135) +IMAGE_DATA(88,212,167,227,157,185,29,153,132,176,234,15,159,173,126,196,158,152,239,108,44,80,166,52,175,62,91,11,126,71,13,40) +IMAGE_DATA(61,21,48,209,254,26,184,46,22,131,219,86,9,238,238,114,112,91,183,193,164,165,84,167,68,191,46,39,88,154,87,251) +IMAGE_DATA(18,243,61,199,11,180,72,112,12,220,246,90,152,236,220,3,206,182,205,16,116,254,165,159,169,252,123,118,252,189,103,246) +IMAGE_DATA(252,120,55,91,115,161,58,59,127,244,81,109,186,251,84,72,39,8,16,13,76,207,69,131,125,16,26,173,5,245,122,37) +IMAGE_DATA(4,175,150,66,96,160,8,252,125,107,33,234,239,5,91,67,193,236,188,189,190,48,28,139,6,33,170,252,9,17,247,47) +IMAGE_DATA(160,221,106,129,240,216,97,125,110,47,4,135,203,32,232,40,134,192,149,117,224,191,252,44,248,108,79,64,212,103,5,219) +IMAGE_DATA(161,164,249,186,194,208,148,166,128,54,113,6,194,206,38,253,204,58,80,175,233,103,14,197,207,124,25,252,189,47,128,207) +IMAGE_DATA(254,52,40,93,107,192,219,185,10,34,74,7,216,106,110,207,219,246,23,168,49,205,173,207,54,66,232,102,53,168,35,21) +IMAGE_DATA(250,108,9,4,250,95,210,103,159,211,207,124,18,20,235,99,224,189,180,18,60,23,31,210,231,219,33,62,147,152,255,163) +IMAGE_DATA(124,229,232,248,136,197,163,12,52,79,249,7,26,192,215,127,16,124,125,85,224,235,221,13,138,125,7,40,182,173,224,237) +IMAGE_DATA(46,1,175,181,24,188,150,87,65,117,182,197,58,42,87,121,18,243,235,31,191,111,211,190,23,31,60,118,97,251,195,174) +IMAGE_DATA(174,93,43,212,148,236,92,161,118,148,231,123,203,158,121,160,70,204,179,255,191,37,127,67,206,6,236,107,160,80,40,20) +IMAGE_DATA(10,133,66,161,80,40,20,10,133,66,161,80,40,20,10,133,66,161,80,178,50,93,21,249,170,12,176,123,102,91,100,121) +IMAGE_DATA(167,29,204,15,134,123,218,195,76,88,62,226,191,60,98,38,180,131,153,200,246,78,59,184,29,76,247,169,246,128,237,69) +IMAGE_DATA(86,178,193,253,82,221,65,182,60,247,151,234,14,178,205,189,209,14,22,235,30,178,213,191,209,14,22,219,207,189,217,236) +IMAGE_DATA(127,41,236,225,255,224,95,246,30,200,63,254,94,201,63,254,30,200,255,226,223,1,143,127,153,223,15,177,201,38,255,216) +IMAGE_DATA(46,22,227,14,210,245,143,237,0,27,76,255,172,235,9,185,78,64,216,117,10,194,227,173,211,47,244,211,38,206,130,54) +IMAGE_DATA(121,110,230,5,131,147,63,103,200,57,14,126,226,35,126,157,105,32,107,7,11,249,159,123,13,34,59,166,207,143,226,184) +IMAGE_DATA(117,38,35,204,222,65,42,255,243,220,155,212,113,97,90,133,17,30,63,157,49,102,238,32,93,255,102,119,76,205,41,113) +IMAGE_DATA(184,126,224,66,182,255,185,59,151,209,209,152,147,2,57,193,133,89,95,3,233,248,151,213,209,152,22,113,56,191,231,6) +IMAGE_DATA(207,191,188,142,108,190,19,70,104,236,91,110,208,252,75,236,200,230,27,113,252,125,156,27,44,255,50,59,178,57,38,142) +IMAGE_DATA(209,102,110,208,252,75,236,200,166,73,32,95,115,131,230,95,98,71,54,71,133,162,222,108,228,2,207,191,188,142,108,190) +IMAGE_DATA(18,203,141,35,92,96,249,151,217,145,77,131,88,174,215,115,129,230,95,98,71,54,135,197,114,237,75,46,208,252,75,236) +IMAGE_DATA(200,230,144,80,130,35,95,112,129,230,95,98,71,54,159,11,230,51,46,176,252,203,236,200,230,160,88,134,235,184,192,243) +IMAGE_DATA(47,175,35,155,90,177,92,173,225,2,205,191,196,142,108,14,8,101,250,143,154,114,128,230,95,98,71,54,159,138,101,112) +IMAGE_DATA(63,23,88,254,101,118,100,83,37,152,79,184,64,243,47,177,35,155,125,66,241,59,246,114,129,231,95,94,71,54,31,139) +IMAGE_DATA(101,224,35,46,176,252,203,236,200,102,143,88,250,63,228,2,205,191,196,142,108,118,139,229,74,37,23,104,254,37,118,100) +IMAGE_DATA(243,129,80,124,125,187,184,64,243,47,177,35,155,157,130,169,224,2,203,191,204,142,108,202,197,210,187,131,11,60,255,242) +IMAGE_DATA(58,178,121,95,44,151,223,227,2,205,191,196,142,108,202,132,162,244,108,231,2,205,191,196,142,198,108,19,135,125,43,23) +IMAGE_DATA(88,254,101,118,52,230,93,129,188,195,5,154,127,137,29,141,41,21,135,109,11,23,120,254,229,117,52,230,109,97,120,187) +IMAGE_DATA(55,115,129,230,95,98,71,99,74,196,209,245,86,198,36,251,48,203,127,242,14,146,239,147,213,49,53,155,196,97,125,51) +IMAGE_DATA(99,204,112,207,218,1,211,191,164,142,169,121,67,32,175,103,132,89,207,125,150,255,196,14,238,240,47,161,227,194,20,11) +IMAGE_DATA(193,99,217,152,17,102,187,55,218,193,157,254,205,237,56,139,117,254,125,94,235,198,164,199,158,123,59,254,15,12,217,159) +IMAGE_DATA(227,73,220,103,49,152,91,0,150,7,179,220,167,179,131,165,142,217,238,105,7,248,238,105,7,184,222,41,20,10,133,66) +IMAGE_DATA(161,80,40,20,10,133,66,161,80,40,20,10,133,66,161,80,40,148,108,206,63,94,52,49,103,0,0,0,0,0,0,0) IMAGE_END_DATA(1344, 2) IMAGE_BEGIN_DATA @@ -1841,94 +1841,94 @@ IMAGE_DATA(208,110,49,240,205,32,233,249,83,229,216,196,249,251,47,203,118,104,1 IMAGE_END_DATA(800, 5) IMAGE_BEGIN_DATA -IMAGE_DATA(120,156,237,156,187,111,92,69,20,198,247,79,136,168,145,72,157,42,37,157,211,32,81,65,26,23,41,144,82,165,160,74) -IMAGE_DATA(153,42,118,25,65,26,10,36,68,129,210,32,69,145,66,71,148,6,201,66,66,136,138,68,4,194,35,137,9,142,193,113) -IMAGE_DATA(98,123,189,126,96,199,9,195,206,189,119,246,206,227,156,51,231,204,204,238,94,59,158,232,211,134,189,119,94,191,239,220) -IMAGE_DATA(51,179,179,75,190,61,209,59,209,83,115,61,180,188,241,65,239,199,55,231,122,202,150,126,15,175,225,213,251,100,168,133) -IMAGE_DATA(161,126,104,180,208,188,71,180,83,213,245,235,249,106,218,241,219,24,213,189,5,212,185,220,244,109,174,221,10,219,168,198) -IMAGE_DATA(140,245,59,188,246,253,226,130,122,251,179,183,218,54,22,234,247,157,190,177,49,15,239,211,37,104,163,25,131,211,247,101) -IMAGE_DATA(151,121,165,203,117,125,167,141,133,118,12,149,188,190,168,178,180,177,168,70,227,45,85,63,99,252,185,252,114,253,43,17) -IMAGE_DATA(63,185,241,91,226,249,1,219,225,60,191,177,100,64,151,83,179,189,222,188,170,95,83,235,26,97,109,216,247,217,247,232) -IMAGE_DATA(255,158,83,238,43,84,230,213,181,107,95,87,130,239,193,234,213,125,159,57,243,105,85,119,97,97,65,233,191,135,227,164) -IMAGE_DATA(234,207,171,249,249,27,85,61,93,223,29,67,108,252,117,223,186,190,153,131,59,134,24,191,182,111,211,86,56,6,204,63) -IMAGE_DATA(183,111,155,35,206,1,235,187,157,35,60,6,154,57,38,124,12,117,223,39,79,126,164,92,62,243,163,113,224,99,104,57) -IMAGE_DATA(193,237,183,215,225,123,234,190,245,53,151,93,120,29,190,103,46,24,171,91,223,191,14,221,147,94,78,232,100,144,90,78) -IMAGE_DATA(159,62,61,163,39,165,95,83,235,26,225,109,204,204,181,19,159,25,165,45,40,64,224,250,243,234,234,213,175,212,165,75) -IMAGE_DATA(215,193,0,196,235,233,82,155,127,229,202,77,117,251,246,55,96,128,208,245,231,213,197,139,95,86,245,116,253,235,215,111) -IMAGE_DATA(143,198,16,31,255,169,217,179,103,63,175,234,235,58,186,174,61,134,56,191,186,111,221,134,153,135,63,6,220,63,183,239) -IMAGE_DATA(94,239,228,12,52,134,216,188,235,190,195,100,96,143,1,99,62,238,100,0,143,33,63,25,156,63,127,173,186,166,95,161) -IMAGE_DATA(100,96,174,195,247,76,55,25,196,118,6,179,231,206,157,83,144,244,53,162,217,170,222,251,179,239,168,239,238,221,84,107) -IMAGE_DATA(234,142,35,253,158,190,134,180,51,107,215,123,174,238,6,245,205,123,166,29,187,13,221,166,221,231,23,55,62,54,247,84) -IMAGE_DATA(210,127,215,239,217,99,105,198,49,234,187,190,118,183,146,63,7,211,103,123,207,157,209,24,220,190,239,130,175,80,125,51) -IMAGE_DATA(6,45,187,111,87,245,92,222,125,239,140,53,254,246,26,167,190,59,151,187,130,250,208,184,101,245,241,190,221,250,216,248) -IMAGE_DATA(180,119,212,216,76,44,65,99,124,238,189,66,99,51,49,132,141,161,238,159,236,27,140,223,86,126,60,192,241,91,224,249) -IMAGE_DATA(73,126,126,63,60,223,211,127,14,79,185,112,225,130,74,209,180,199,125,24,75,42,235,99,79,210,203,184,153,31,123,17) -IMAGE_DATA(22,9,167,125,181,105,169,223,104,67,237,141,180,222,104,173,210,191,195,37,72,235,216,139,176,196,56,188,80,219,67,109) -IMAGE_DATA(89,26,84,162,61,128,249,215,122,214,104,85,237,14,245,186,250,64,205,249,64,237,52,218,110,248,135,30,236,59,30,240) -IMAGE_DATA(159,1,159,255,174,122,218,104,229,181,240,129,230,190,219,104,39,226,193,128,225,129,148,127,237,193,142,250,231,72,250,128) -IMAGE_DATA(205,231,229,144,132,214,193,72,187,128,15,148,7,62,255,126,214,51,96,60,168,245,247,145,240,1,230,190,231,201,246,129) -IMAGE_DATA(242,64,146,135,242,249,215,90,62,148,30,224,49,191,223,136,227,65,155,139,248,207,128,191,14,24,254,107,201,252,183,17) -IMAGE_DATA(15,186,234,3,52,206,87,67,50,175,70,236,247,17,31,40,15,224,60,52,254,103,96,185,241,224,73,165,174,123,0,179) -IMAGE_DATA(127,1,8,243,1,247,64,254,12,148,203,65,219,35,15,150,58,235,1,206,253,160,81,232,3,230,1,253,12,248,235,128) -IMAGE_DATA(255,121,96,156,252,107,15,32,31,186,197,254,32,34,200,131,189,168,7,220,28,4,237,131,114,215,0,159,255,150,250,171) -IMAGE_DATA(19,30,208,236,95,122,226,122,64,63,3,189,230,203,13,142,168,103,32,151,255,180,61,192,217,215,188,255,243,20,250,224) -IMAGE_DATA(175,7,240,51,32,225,77,137,147,131,164,252,183,212,227,169,120,192,99,255,202,19,238,1,244,12,148,226,30,250,80,150) -IMAGE_DATA(255,164,61,128,215,218,150,63,204,222,247,128,230,143,177,163,215,128,190,208,7,106,13,144,241,223,82,127,78,196,3,122) -IMAGE_DATA(159,3,177,55,127,48,15,194,28,4,177,146,173,193,27,108,15,56,159,1,184,252,7,99,246,0,254,92,69,197,190,255) -IMAGE_DATA(135,122,6,106,254,33,247,148,61,80,187,255,225,121,80,142,255,64,45,142,205,3,255,44,161,52,127,159,203,203,228,61) -IMAGE_DATA(168,187,255,228,123,80,134,191,239,65,105,246,33,255,252,252,3,49,73,255,12,16,238,255,121,30,140,135,127,174,7,240) -IMAGE_DATA(25,230,126,227,129,255,57,87,190,254,66,44,210,62,131,209,103,16,50,254,242,245,215,230,63,80,143,138,121,0,159,31) -IMAGE_DATA(227,252,165,251,207,124,254,188,51,160,24,127,173,212,253,39,196,127,160,30,102,243,135,99,191,245,32,204,65,242,207,95) -IMAGE_DATA(113,254,216,25,144,252,12,110,154,252,83,60,176,235,30,52,231,147,248,51,96,123,192,59,127,160,88,196,207,224,186,202) -IMAGE_DATA(255,209,136,255,102,198,51,224,178,223,5,248,115,60,160,207,223,36,252,75,157,191,241,60,72,225,191,8,242,223,84,15) -IMAGE_DATA(146,60,8,249,67,30,236,35,30,240,206,159,227,252,203,159,63,151,227,223,178,47,205,223,101,191,3,240,199,60,192,124) -IMAGE_DATA(128,191,127,137,177,24,199,247,47,233,252,151,26,133,177,15,241,223,180,248,75,61,8,249,199,60,112,125,104,189,104,5) -IMAGE_DATA(125,255,200,227,95,246,251,71,62,127,247,251,71,217,218,155,206,223,95,179,221,223,229,196,60,8,125,160,190,247,141,177) -IMAGE_DATA(208,42,253,253,123,156,127,137,189,15,205,159,242,192,190,71,207,251,160,146,207,63,230,1,79,124,254,229,126,127,50,89) -IMAGE_DATA(254,15,26,253,81,41,133,127,204,131,52,31,218,239,218,101,252,243,127,127,53,30,254,248,218,43,225,239,178,55,115,134) -IMAGE_DATA(60,136,249,64,203,254,221,91,156,127,217,223,31,242,248,195,185,159,187,246,98,252,251,234,119,210,3,152,63,215,131,93) -IMAGE_DATA(139,171,235,135,255,190,95,47,206,190,220,239,111,39,151,123,92,254,125,49,255,1,211,3,200,7,174,218,54,98,236,75) -IMAGE_DATA(252,254,124,178,185,95,198,223,126,95,207,207,204,25,242,0,247,129,227,5,84,103,219,105,91,206,254,112,228,158,90,191) -IMAGE_DATA(129,30,248,252,113,15,184,62,112,68,113,47,193,126,242,185,167,36,127,215,3,252,89,104,125,224,120,177,13,112,135,99) -IMAGE_DATA(30,103,79,237,119,114,98,127,188,185,135,207,191,239,205,27,243,0,246,130,47,168,45,104,159,227,178,15,115,62,149,119) -IMAGE_DATA(242,99,191,100,238,225,243,167,60,192,124,224,120,129,213,27,20,100,47,201,59,165,206,251,211,249,187,236,55,188,249,110) -IMAGE_DATA(38,250,192,21,197,93,194,30,255,157,109,94,236,151,205,61,90,27,234,215,224,60,194,200,228,85,185,15,92,63,194,58) -IMAGE_DATA(124,238,18,246,227,139,253,156,220,211,31,178,167,249,175,19,30,64,62,80,94,224,130,153,251,220,227,236,169,156,79,197) -IMAGE_DATA(62,135,125,110,236,167,243,247,61,224,250,208,250,1,139,170,19,114,159,12,251,156,216,79,203,61,60,254,235,214,220,49) -IMAGE_DATA(15,98,62,112,4,181,185,225,244,45,205,57,113,246,101,99,95,154,123,54,212,125,130,191,137,45,202,7,204,11,202,151) -IMAGE_DATA(216,253,126,188,83,49,79,179,199,248,67,236,39,25,251,50,254,190,7,152,15,28,47,104,230,52,119,44,223,228,178,231) -IMAGE_DATA(236,247,115,98,31,207,61,20,255,122,94,107,108,31,96,63,226,130,218,160,185,167,179,231,229,157,114,177,31,203,61,113) -IMAGE_DATA(254,181,246,162,62,224,126,240,132,181,231,246,235,114,199,217,235,223,209,202,216,115,242,78,249,216,167,249,63,11,230,27) -IMAGE_DATA(250,64,121,145,170,176,15,154,123,58,123,105,222,129,247,251,233,177,191,161,126,137,240,15,61,192,125,200,241,2,110,15) -IMAGE_DATA(234,219,231,14,253,91,26,121,236,169,188,83,54,246,121,252,113,31,194,245,33,95,97,126,231,197,60,159,189,52,231,115) -IMAGE_DATA(242,78,74,236,199,248,175,54,242,231,141,121,145,230,7,206,27,98,238,199,124,248,111,200,148,97,159,187,230,242,98,159) -IMAGE_DATA(226,111,230,71,251,64,121,145,42,172,31,138,123,200,158,247,249,150,155,243,57,121,135,183,223,183,249,175,123,252,253,51) -IMAGE_DATA(208,122,94,190,15,148,23,41,126,80,109,173,178,184,27,81,231,58,52,123,105,206,231,172,185,178,216,135,206,255,221,121) -IMAGE_DATA(174,38,120,145,34,136,57,205,221,252,255,42,225,89,114,42,123,40,231,167,229,29,73,236,135,252,87,128,121,83,94,164) -IMAGE_DATA(248,177,42,96,14,115,183,217,251,103,249,165,217,99,121,7,94,115,241,216,95,87,63,51,249,175,16,62,60,245,120,97) -IMAGE_DATA(158,192,130,234,226,253,172,160,236,225,216,135,62,91,241,216,99,235,45,111,191,67,239,247,77,236,203,249,199,124,160,61) -IMAGE_DATA(145,177,230,115,55,121,190,229,191,92,128,189,52,231,83,121,7,142,125,140,191,239,129,153,35,236,5,215,15,137,224,126) -IMAGE_DATA(66,230,238,222,198,230,79,113,135,247,57,41,236,169,253,14,157,119,40,246,24,127,91,184,23,82,79,232,118,96,230,254) -IMAGE_DATA(158,178,206,53,134,63,47,230,203,176,231,231,157,251,78,222,145,241,55,115,132,89,196,189,144,137,207,188,93,95,91,246) -IMAGE_DATA(79,138,179,79,207,249,120,236,175,171,123,36,127,220,3,218,11,174,55,220,250,48,115,127,95,3,241,199,242,77,73,246) -IMAGE_DATA(105,57,63,22,251,48,255,101,130,5,151,101,25,230,208,218,218,242,95,202,136,249,92,246,84,206,151,197,190,207,191,245) -IMAGE_DATA(192,8,99,196,241,71,82,119,89,81,220,113,254,210,152,207,103,143,229,124,42,239,80,252,125,15,204,220,125,38,114,63) -IMAGE_DATA(248,188,41,230,97,158,137,197,124,105,246,242,188,195,141,125,152,191,61,239,229,136,31,233,218,142,50,231,112,135,99,62) -IMAGE_DATA(198,126,179,56,123,55,246,165,252,105,15,96,63,242,132,181,15,51,143,115,167,98,190,251,236,67,254,102,222,20,167,146) -IMAGE_DATA(130,153,135,249,29,231,158,150,111,82,217,195,57,63,135,63,238,129,175,113,177,166,152,75,185,79,154,125,94,236,67,252) -IMAGE_DATA(105,15,74,139,203,92,202,29,203,55,227,103,159,194,223,247,192,231,177,93,105,92,172,41,230,143,193,223,58,80,220,241) -IMAGE_DATA(152,31,15,251,117,245,83,54,123,232,25,160,89,149,18,204,220,196,57,196,222,245,0,227,14,199,60,126,166,144,202,190) -IMAGE_DATA(76,236,227,30,248,92,74,115,134,243,75,140,125,235,65,137,152,239,6,123,200,3,30,183,28,185,204,7,141,56,236,141) -IMAGE_DATA(120,49,95,158,125,169,188,67,241,175,61,176,25,149,225,12,49,183,115,186,156,63,28,243,97,190,25,15,251,146,252,227) -IMAGE_DATA(30,164,107,128,240,246,37,227,159,27,243,221,98,143,121,208,242,241,57,198,132,115,198,246,49,114,254,20,119,89,204,119) -IMAGE_DATA(129,125,220,131,18,242,247,141,169,252,185,49,127,184,216,227,30,60,42,194,24,218,183,219,251,24,9,123,89,204,99,249) -IMAGE_DATA(166,123,236,105,15,114,229,242,134,246,49,49,246,113,238,220,152,239,46,123,220,131,135,81,182,182,96,206,212,190,29,247) -IMAGE_DATA(64,206,61,45,223,116,133,61,230,65,156,169,140,53,180,143,161,115,140,148,59,63,223,116,141,189,41,254,152,106,31,98) -IMAGE_DATA(60,57,146,48,79,231,30,198,124,60,223,116,133,189,41,249,30,132,172,211,152,75,185,83,49,127,56,216,155,2,141,179) -IMAGE_DATA(246,1,103,139,243,150,50,231,112,207,143,249,174,178,183,11,199,131,62,139,51,143,185,156,251,209,137,121,172,96,177,195) -IMAGE_DATA(99,77,241,198,152,167,112,63,58,49,143,21,108,62,174,23,20,235,60,230,28,238,212,24,167,205,175,84,161,125,192,121) -IMAGE_DATA(243,153,31,115,231,20,106,206,90,33,107,25,243,24,247,88,255,211,230,51,169,18,227,224,122,146,198,92,210,199,180,121) -IMAGE_DATA(76,179,72,56,149,212,180,231,221,197,114,204,188,123,229,40,179,254,31,240,28,99,244,0,0,0,0,0,0,0,0,0) +IMAGE_DATA(120,156,237,156,187,111,92,69,20,198,87,252,5,17,53,18,169,83,165,164,115,26,36,42,72,227,34,5,82,170,20,84) +IMAGE_DATA(41,83,197,46,35,72,67,129,132,40,80,26,164,40,82,232,136,210,32,89,72,8,81,145,136,64,120,36,49,193,49,56) +IMAGE_DATA(78,236,181,215,15,236,56,97,216,185,247,206,222,121,156,115,230,156,153,217,221,107,227,137,62,109,216,123,231,245,251,206) +IMAGE_DATA(61,51,59,187,228,155,19,189,19,61,53,215,67,203,235,239,247,126,120,99,174,167,108,233,247,240,26,94,189,143,135,90) +IMAGE_DATA(24,234,251,70,11,205,123,68,59,85,93,191,158,175,166,29,191,141,81,221,91,64,157,203,77,223,230,218,173,176,141,106) +IMAGE_DATA(204,88,191,195,107,223,45,46,168,183,62,125,179,109,99,161,126,223,233,27,27,243,240,62,93,130,54,154,49,56,125,95) +IMAGE_DATA(118,153,87,186,92,215,119,218,88,104,199,80,201,235,139,42,75,253,69,53,26,111,169,250,25,227,207,229,151,235,95,137) +IMAGE_DATA(248,201,141,223,18,207,15,216,14,231,249,141,37,3,186,156,154,237,245,230,85,253,154,90,215,8,107,195,190,207,190,71) +IMAGE_DATA(255,247,156,114,95,161,50,175,174,93,251,170,18,124,15,86,175,238,251,204,153,79,170,186,11,11,11,74,255,61,28,39) +IMAGE_DATA(85,127,94,205,207,223,168,234,233,250,238,24,98,227,175,251,214,245,205,28,220,49,196,248,181,125,155,182,194,49,96,254) +IMAGE_DATA(185,125,219,28,113,14,88,223,237,28,225,49,208,204,49,225,99,168,251,62,121,242,67,229,242,153,31,141,3,31,67,203) +IMAGE_DATA(9,110,191,189,14,223,83,247,173,175,185,236,194,235,240,61,115,193,88,221,250,254,117,232,158,244,114,66,39,131,212,114) +IMAGE_DATA(250,244,233,25,61,41,253,154,90,215,8,111,99,102,174,157,248,204,40,109,65,1,2,215,159,87,87,175,126,169,46,93) +IMAGE_DATA(186,14,6,32,94,79,151,218,252,43,87,110,170,219,183,191,6,3,132,174,63,175,46,94,252,162,170,167,235,95,191,126) +IMAGE_DATA(123,52,134,248,248,79,205,158,61,251,89,85,95,215,209,117,237,49,196,249,213,125,235,54,204,60,252,49,224,254,185,125) +IMAGE_DATA(247,122,39,103,160,49,196,230,93,247,29,38,3,123,12,24,243,113,39,3,120,12,249,201,224,252,249,107,213,53,253,10) +IMAGE_DATA(37,3,115,29,190,103,186,201,224,181,200,206,96,246,220,185,115,10,146,190,70,180,91,213,123,111,246,109,245,237,189,155) +IMAGE_DATA(106,77,221,113,164,223,211,215,144,118,102,237,122,207,213,221,160,190,121,207,180,99,183,161,219,180,251,252,252,198,71,230) +IMAGE_DATA(158,74,250,239,250,61,123,44,205,56,70,125,215,215,238,86,242,231,96,250,108,239,185,51,26,131,219,247,93,240,21,170) +IMAGE_DATA(111,198,160,101,247,237,170,158,203,59,239,158,177,198,223,94,227,212,119,231,114,87,80,31,26,183,172,62,222,183,91,31) +IMAGE_DATA(27,159,246,142,26,155,137,37,104,140,207,189,87,104,108,38,134,176,49,212,253,147,125,131,241,219,202,143,7,56,126,11) +IMAGE_DATA(60,63,201,207,239,7,231,123,250,207,225,41,23,46,92,80,41,154,246,184,15,99,73,101,125,236,73,122,25,55,243,99) +IMAGE_DATA(47,194,34,225,180,175,54,45,109,52,234,171,189,145,214,27,173,85,250,103,184,4,105,29,123,17,150,24,135,23,106,123) +IMAGE_DATA(168,45,75,131,74,180,7,48,255,90,207,26,173,170,221,161,254,175,62,80,115,62,80,59,141,182,27,254,161,7,251,142) +IMAGE_DATA(7,252,103,192,231,191,171,158,54,90,249,95,248,64,115,223,109,180,19,241,96,192,240,64,202,191,246,96,71,253,125,36) +IMAGE_DATA(125,192,230,243,114,72,66,235,96,164,93,192,7,202,3,159,255,70,214,51,96,60,168,245,215,145,240,1,230,190,231,201) +IMAGE_DATA(246,129,242,64,146,135,242,249,215,90,62,148,30,224,49,191,223,136,227,65,155,139,248,207,128,191,14,24,254,107,201,252) +IMAGE_DATA(183,17,15,186,234,3,52,206,87,67,50,175,70,236,247,17,31,40,15,224,60,52,254,103,96,185,241,224,73,165,174,123) +IMAGE_DATA(0,179,127,1,8,243,1,247,64,254,12,148,203,65,219,35,15,150,58,235,1,206,253,160,81,232,3,230,1,253,12,248) +IMAGE_DATA(235,128,255,121,96,156,252,107,15,32,31,186,197,254,32,34,200,131,189,168,7,220,28,4,237,131,114,215,0,159,255,150) +IMAGE_DATA(250,179,19,30,208,236,95,122,226,122,64,63,3,189,230,203,13,142,168,103,32,151,255,180,61,192,217,215,188,255,245,20) +IMAGE_DATA(250,224,175,7,240,51,32,225,77,137,147,131,164,252,183,212,227,169,120,192,99,255,202,19,238,1,244,12,148,226,30,250) +IMAGE_DATA(80,150,255,164,61,128,215,218,150,63,204,222,247,128,230,143,177,163,215,128,13,161,15,212,26,32,227,191,165,254,152,136) +IMAGE_DATA(7,244,62,7,98,111,254,96,30,132,57,8,98,37,91,131,251,108,15,56,159,1,184,252,7,99,246,0,254,92,69,197) +IMAGE_DATA(190,255,135,122,6,106,254,33,247,148,61,80,187,255,225,121,80,142,255,64,45,142,205,3,255,44,161,52,127,159,203,203) +IMAGE_DATA(228,61,168,187,255,228,123,80,134,191,239,65,105,246,33,255,252,252,3,49,73,255,12,16,238,255,121,30,140,135,127,174) +IMAGE_DATA(7,240,25,230,126,227,129,255,57,87,190,254,66,44,210,62,131,209,103,16,50,254,242,245,215,230,63,80,143,138,121,0) +IMAGE_DATA(159,31,227,252,165,251,207,124,254,188,51,160,24,127,173,212,253,39,196,127,160,30,102,243,135,99,191,245,32,204,65,242) +IMAGE_DATA(207,95,113,254,216,25,144,252,12,110,154,252,83,60,176,235,30,52,231,147,248,51,96,123,192,59,127,160,88,196,207,224) +IMAGE_DATA(186,202,255,209,136,255,102,198,51,224,178,223,5,248,115,60,160,207,223,36,252,75,157,191,241,60,72,225,191,8,242,223) +IMAGE_DATA(84,15,146,60,8,249,67,30,236,35,30,240,206,159,227,252,203,159,63,151,227,223,178,47,205,223,101,191,3,240,199,60) +IMAGE_DATA(192,124,128,191,127,137,177,24,199,247,47,233,252,151,26,133,177,15,241,223,180,248,75,61,8,249,199,60,112,125,104,189) +IMAGE_DATA(104,5,125,255,200,227,95,246,251,71,62,127,247,251,71,217,218,155,206,223,95,179,221,223,229,196,60,8,125,160,190,247) +IMAGE_DATA(141,177,208,42,253,253,123,156,127,137,189,15,205,159,242,192,190,71,207,251,160,146,207,63,230,1,79,124,254,229,126,127) +IMAGE_DATA(50,89,254,15,26,253,94,41,133,127,204,131,52,31,218,239,218,101,252,243,127,127,53,30,254,248,218,43,225,239,178,55) +IMAGE_DATA(115,134,60,136,249,64,203,254,221,91,156,127,217,223,31,242,248,195,185,159,187,246,98,252,55,212,111,164,7,48,127,174) +IMAGE_DATA(7,187,22,87,215,15,255,125,191,94,156,125,185,223,223,78,46,247,184,252,55,196,252,7,76,15,32,31,184,106,219,136) +IMAGE_DATA(177,47,241,251,243,201,230,126,25,127,251,125,61,63,51,103,200,3,220,7,142,23,80,157,109,167,109,57,251,195,145,123) +IMAGE_DATA(106,253,10,122,224,243,199,61,224,250,192,17,197,189,4,251,201,231,158,146,252,93,15,240,103,161,245,129,227,197,54,192) +IMAGE_DATA(29,142,121,156,61,181,223,201,137,253,241,230,30,62,255,13,111,222,152,7,176,23,124,65,109,65,251,28,151,125,152,243) +IMAGE_DATA(169,188,147,31,251,37,115,15,159,63,229,1,230,3,199,11,172,222,160,32,123,73,222,41,117,222,159,206,223,101,223,247) +IMAGE_DATA(230,187,153,232,3,87,20,119,9,123,252,119,182,121,177,95,54,247,104,245,213,47,193,121,132,145,201,171,114,31,184,126) +IMAGE_DATA(132,117,248,220,37,236,199,23,251,57,185,103,99,200,158,230,191,78,120,0,249,64,121,129,11,102,238,115,143,179,167,114) +IMAGE_DATA(62,21,251,28,246,185,177,159,206,223,247,128,235,67,235,7,44,170,78,200,125,50,236,115,98,63,45,247,240,248,175,91) +IMAGE_DATA(115,199,60,136,249,192,17,212,102,223,233,91,154,115,226,236,203,198,190,52,247,244,213,125,130,191,137,45,202,7,204,11) +IMAGE_DATA(202,151,216,253,126,188,83,49,79,179,199,248,67,236,39,25,251,50,254,190,7,152,15,28,47,104,230,52,119,44,223,228) +IMAGE_DATA(178,231,236,247,115,98,31,207,61,20,255,122,94,107,108,31,96,63,226,130,218,160,185,167,179,231,229,157,114,177,31,203) +IMAGE_DATA(61,113,254,181,246,162,62,224,126,240,132,181,231,246,235,114,199,217,235,223,209,202,216,115,242,78,249,216,167,249,63,11) +IMAGE_DATA(230,27,250,64,121,145,170,176,15,154,123,58,123,105,222,129,247,251,233,177,223,87,63,71,248,135,30,224,62,228,120,1) +IMAGE_DATA(183,7,245,237,115,135,254,45,141,60,246,84,222,41,27,251,60,254,184,15,225,250,144,175,48,191,243,98,158,207,94,154) +IMAGE_DATA(243,57,121,39,37,246,99,252,87,27,249,243,198,188,72,243,3,231,13,49,247,99,62,252,55,100,202,176,207,93,115,121) +IMAGE_DATA(177,79,241,55,243,163,125,160,188,72,21,214,15,197,61,100,207,251,124,203,205,249,156,188,195,219,239,219,252,215,61,254) +IMAGE_DATA(254,25,104,61,47,223,7,202,139,20,63,168,182,86,89,220,141,168,115,29,154,189,52,231,115,214,92,89,236,67,231,255) +IMAGE_DATA(238,60,87,19,188,72,17,196,156,230,110,254,127,149,240,44,57,149,61,148,243,211,242,142,36,246,67,254,43,192,188,41) +IMAGE_DATA(47,82,252,88,21,48,135,185,219,236,253,179,252,210,236,177,188,3,175,185,120,236,175,171,159,152,252,87,8,31,158,122) +IMAGE_DATA(188,48,79,96,65,117,241,126,86,80,246,112,236,67,159,173,120,236,177,245,150,183,223,161,247,251,38,246,229,252,99,62) +IMAGE_DATA(208,158,200,88,243,185,155,60,223,242,95,46,192,94,154,243,169,188,3,199,62,198,223,247,192,204,17,246,130,235,135,68) +IMAGE_DATA(112,63,33,115,119,111,99,243,167,184,195,251,156,20,246,212,126,135,206,59,20,123,140,191,45,220,11,169,39,116,59,48) +IMAGE_DATA(115,127,79,89,231,26,195,159,23,243,101,216,243,243,206,125,39,239,200,248,155,57,194,44,226,94,200,196,103,222,174,175) +IMAGE_DATA(45,251,39,197,217,167,231,124,60,246,215,213,61,146,63,238,1,237,5,215,27,110,125,152,185,191,175,129,248,99,249,166) +IMAGE_DATA(36,251,180,156,31,139,125,152,255,50,193,130,203,178,12,115,104,109,109,249,47,101,196,124,46,123,42,231,203,98,223,231) +IMAGE_DATA(223,122,96,132,49,226,248,35,169,187,172,40,238,56,127,105,204,231,179,199,114,62,149,119,40,254,190,7,102,238,62,19) +IMAGE_DATA(185,31,124,222,20,243,48,207,196,98,190,52,123,121,222,225,198,62,204,223,158,247,114,196,143,116,109,71,153,115,184,195) +IMAGE_DATA(49,31,99,191,89,156,189,27,251,82,254,180,7,176,31,121,194,218,135,153,199,185,83,49,223,125,246,33,127,51,111,138) +IMAGE_DATA(83,73,193,204,195,252,142,115,79,203,55,169,236,225,156,159,195,31,247,192,215,184,88,83,204,165,220,39,205,62,47,246) +IMAGE_DATA(33,254,180,7,165,197,101,46,229,142,229,155,241,179,79,225,239,123,224,243,216,174,52,46,214,20,243,199,224,111,29,40) +IMAGE_DATA(238,120,204,143,135,253,186,250,49,155,61,244,12,208,172,74,9,102,110,226,28,98,239,122,128,113,135,99,30,63,83,72) +IMAGE_DATA(101,95,38,246,113,15,124,46,165,57,195,249,37,198,190,245,160,68,204,119,131,61,228,1,143,91,142,92,230,131,70,28) +IMAGE_DATA(246,70,188,152,47,207,190,84,222,161,248,215,30,216,140,202,112,134,152,219,57,93,206,31,142,249,48,223,140,135,125,73) +IMAGE_DATA(254,113,15,210,53,64,120,251,146,241,207,141,249,110,177,199,60,104,249,248,28,99,194,57,99,251,24,57,127,138,187,44) +IMAGE_DATA(230,187,192,62,238,65,9,249,251,198,84,254,220,152,63,92,236,113,15,30,21,97,12,237,219,237,125,140,132,189,44,230) +IMAGE_DATA(177,124,211,61,246,180,7,185,114,121,67,251,152,24,251,56,119,110,204,119,151,61,238,193,195,40,91,91,48,103,106,223) +IMAGE_DATA(142,123,32,231,158,150,111,186,194,30,243,32,206,84,198,26,218,199,208,57,70,202,157,159,111,186,198,222,20,127,76,181) +IMAGE_DATA(15,49,158,28,73,152,167,115,15,99,62,158,111,186,194,222,148,124,15,66,214,105,204,165,220,169,152,63,28,236,77,129) +IMAGE_DATA(198,89,251,128,179,197,121,75,153,115,184,231,199,124,87,217,219,133,227,193,6,139,51,143,185,156,251,209,137,121,172,96) +IMAGE_DATA(177,195,99,77,241,198,152,167,112,63,58,49,143,21,108,62,174,23,20,235,60,230,28,238,212,24,167,205,175,84,161,125) +IMAGE_DATA(192,121,243,153,31,115,231,20,106,206,90,33,107,25,243,24,247,88,255,211,230,51,169,18,227,224,122,146,198,92,210,199) +IMAGE_DATA(180,121,76,179,72,56,149,212,180,231,221,197,114,204,188,123,229,40,179,254,15,24,110,99,246,0,0,0,0,0,0,0) IMAGE_END_DATA(2816, 5) IMAGE_BEGIN_DATA diff --git a/uppsrc/CtrlLib/CtrlLib.upp b/uppsrc/CtrlLib/CtrlLib.upp index 6ee749841..f624496af 100644 --- a/uppsrc/CtrlLib/CtrlLib.upp +++ b/uppsrc/CtrlLib/CtrlLib.upp @@ -129,6 +129,5 @@ file Info readonly separator, src.tpp, srcdoc.tpp, - appdoc.tpp, Copying; diff --git a/uppsrc/CtrlLib/CtrlLibInit.cpp b/uppsrc/CtrlLib/CtrlLibInit.cpp index ac2ad9a75..cdd834837 100644 --- a/uppsrc/CtrlLib/CtrlLibInit.cpp +++ b/uppsrc/CtrlLib/CtrlLibInit.cpp @@ -5,14 +5,19 @@ namespace Upp { #define TFILE #include -void CtrlSetDefaultSkin(void (*_skin)()); +void CtrlSetDefaultSkin(void (**_skin)()); extern Size (*extGetSmartTextSize)(const char *text, Font font, int cx); extern void (*extDrawSmartText)(Draw& draw, int x, int y, int cx, const char *text, Font font, Color ink, int accesskey, Color qtf_ink); INITIALIZER(CtrlLib) { - CtrlSetDefaultSkin(ChHostSkin); + static void (*skin[3])() = { + ChHostSkin, + ChStdSkin, + ChDarkSkin, + }; + CtrlSetDefaultSkin(skin); extGetSmartTextSize = GetSmartTextSize; diff --git a/uppsrc/CtrlLib/DateTimeCtrl.cpp b/uppsrc/CtrlLib/DateTimeCtrl.cpp index e31134e41..c8dbd9f8c 100644 --- a/uppsrc/CtrlLib/DateTimeCtrl.cpp +++ b/uppsrc/CtrlLib/DateTimeCtrl.cpp @@ -1531,13 +1531,13 @@ CH_STYLE(Calendar, Style, StyleDefault) bgmain = SColorPaper; bgtoday = SColorPaper; - bgselect = AdjustIfDark(Color(255, 254, 220)); + bgselect = AColor(255, 254, 220); fgmain = SColorText; fgtoday = SBlack; fgselect = SBlack; - outofmonth = AdjustIfDark(Color(180, 180, 180)); + outofmonth = AColor(180, 180, 180); curdate = SWhite; today = SColorText; selecttoday = SColorMark; diff --git a/uppsrc/CtrlLib/FileSel.cpp b/uppsrc/CtrlLib/FileSel.cpp index b3fd728b8..92ef56964 100644 --- a/uppsrc/CtrlLib/FileSel.cpp +++ b/uppsrc/CtrlLib/FileSel.cpp @@ -1449,6 +1449,11 @@ void FileSel::Activate() TopWindow::Activate(); } +void FileSel::Skin() +{ + Reload(); +} + bool FileSel::Key(dword key, int count) { switch(key) { case K_F9: diff --git a/uppsrc/CtrlLib/FileSel.h b/uppsrc/CtrlLib/FileSel.h index c76c36420..ac4ae2fe5 100644 --- a/uppsrc/CtrlLib/FileSel.h +++ b/uppsrc/CtrlLib/FileSel.h @@ -175,6 +175,7 @@ class FileSel : public WithFileSelectorLayout { public: virtual bool Key(dword key, int count); virtual void Activate(); + virtual void Skin(); private: SizeGrip sizegrip; diff --git a/uppsrc/CtrlLib/appdoc.tpp/DlgSelectColor_cs-cz.tpp b/uppsrc/CtrlLib/appdoc.tpp/DlgSelectColor_cs-cz.tpp deleted file mode 100644 index 9de5ba42b..000000000 --- a/uppsrc/CtrlLib/appdoc.tpp/DlgSelectColor_cs-cz.tpp +++ /dev/null @@ -1,140 +0,0 @@ -topic "Výběr barvy"; -[b100;a50;K* $$1,0#23046025415494101427921008701515:Paragraph] -[ $$0,0#00000000000000000000000000000000:Default] -[{_}%CS-CZ -[s0; Dialog slouží k_výběru barvy. Barvu je dle potřeby možno -zadat v_několika barevných prostorech nebo vybrat z palety -často používaných barev. Uživatelské palety je možno načítat -a ukládat na disk.&] -[s1; Společné položky&] -[s0; Nehledě na aktivní záložku (barevný prostor pro volbu barvy) -se ve spodní části dialogu zobrazuje numerická hodnota barvy -v barevných prostorech [* RGB] (červená `- modrá `- zelená) -a [* HSV] (odstín `- sytost `- jas). V_obou případech je povolený -rozsah hodnot [* 0 .. 255]. V_případě, že znáte tyto číselné -hodnoty pro požadovanou barvu, můžete je přímo vepsat do -příslušných editačních polí; hodnoty závislých parametrů -se automaticky přepočítají.&] -[s0; &] -[s0; -@@image:90&90/16 -(AxIAEgAAAO7/AAAAAHiclZHdDcMgDITZf4Nu0IcuBElVqQk/SYdIDaeeTCUEWCfrOPt7sLiu6TLGSH/N1ON+I7W/n4OqqG0dlKb8tppeyY7/o/ZMSW+JU02FkqPDQHwyrCi/5NwvMPA0eqqpWHLpEG/RCYymUsmlQ6R0AlNRweU8OBh4Gj3V1FHy47cpBuKTYUXFkkfXEqeaOqPt/rLsiCoq2UFp6pPsoEiJmVL3llZ9AflbUxs=) - Tlačítko nastaví do aktuální barvy [* prázdnou barvu]. Prázdná -barva má význam obvykle v_situacích, kdy chcete zrušit dříve -vybranou barvu nebo pokud chcete vyjádřit, že se má vybraná -barva chápat jako průhledná.&] -[s0; &] -[s0; -@@image:89&89/8 -(AxIAEgAAAO7/AAAAAHicnZFZCsJAEAX7/jfwBn54oVlEMLOph4hDGp+vJwqOTRGSCkVnWdfpEZF+vMzM6XhAla5nINuwYUy1REU2JdtjQDJc5SUqXEEypkpRMdVLMlyVFIG+l34r9oqpcmDelfUdrmoOjHoNh1tctRwGsG7wpip+gNex5+pW/B6sY2mq6vfwOkiu7tV9BOtgTNXcN/T34ZKrR3M/gqqfTCH/zhN7qqp0) - Tlačítko umožňuje načíst barevný odstín z okna jiné -aplikace na monitoru. Pokud v_prostoru tlačítka stisknete levé -tlačítko myši a kurzor za současného držení tohoto tlačítka -přetáhnete nad libovolné místo pracovní plochy monitoru, -aktuální barva se nastaví na hodnotu barvy pixelu na tomto -koncovém místě.&] -[s1; Záložka [/ Paleta]&] -[s0; Záložka umožňuje volbu barvy výběrem z_palety standardních -nebo často používaných barev. Přetahováním s_přidržením -levého tlačítka myši můžete mezi sebou zaměňovat jednotlivé -položky palety.&] -[s0;= -@@image:1612&2212 -(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) -&] -[s0; &] -[s0; Kliknutím pravého tlačítka myši v_prostoru palety lze vyvolat -lokální nabídku umožňující změnit velikost palety, uložit -paletu na disk a načíst paletu z disku:&] -[s0; &] -[s0; -@@image:856&1075 -(A4kArAAAAFT/AAAAAHic7Z3dces2EEb14IbS1q0ibdwO8pA20kMayENm1IOvx57hpbGLJUDh5yNxMGc8FASC4h4BkrCU/Pz/3yfo8Xg8Pv6+U8TK33/93NRMf5LAHtTIghpZUCMLamS5mZqvc7kHbdU8PkttoGrj+dXe3Qs1c9UEe6EmDtcWn/2GtbbVJPfam27/ts99Ze5YtpPcg58ueoya4PSDCMTROxw1wdEPvd9VjevIDpNcBOwz3zVersYe3fVVIvdmanIn68YqF9vTauKaBdWURL7EXWHMX1FTeNBbqtm2kwmtsHEQsaRNsG8wodkat5Orq4GGtFXz/nhYpp/jRWHUyIIaWVAjy17NHz/+AR1QIwtqZEGNLKiRRVlN7UMK2jfsahjN1eyvP3zxHFvF88RjaNiViBrbiYKahoe+mZptBAU39zvaSntzfyw7Tt32Qf+5Q5Q/fn01wTm6EpPguDXuXm7/JX2WH6Kkq6AfQTWHYUme4SVqDvd6XY17iPfv5fB0rqumNoy1I+u0mlxNbkzF26gZrKbk0Mpq3AG+v1kyNdlOqmaVEjW5B2k7qTodZTWX4Cpn2njUmOzz9BNEDTQHNbKgRhauDZAFNbKgRhar5qMG5pJT806ZXXJqQATUyIIaWVAjC2pkQY0sqJEFNbIMUJP7HvH+i8zNO78BbdXYb3nH0Uu+kx40rq2/AXPVvB5q1JwLVKIm+Z0E95cW3N9ScPdKjphrcF2GqdnfVdgs6Dm3V3CUyzFdTe1rjR1rhz1flLlqbGWsJteeUdNWTdV7hsNOqp4Al3DX/HNNMuEkIXJf0G2Qc68swV57O4Wz3GpqOiEexh60VdPpl50W9NJcDTQENbKgRhbUyIIaWVAjC2pkQY0ss9QULjivTPPlzfJFKncdrHDfFZio5rCr6cGZS4+kwOGac1LjNrO7rMYYNbkGh5Ur0ymVlhsOsZoLJVPuocbNdrl77QWhpl8C2g1yydxVoi+3750YoOZpJrR9zfP7hBb0gBoQYYAa/tmQrBo4B2pkQY0sqJEFNbKgRharZvrvGkFOTY+fKqJUlZwaEAE1sqBGFtTIghpZXDV/lhVsTlHzX0FBDWrWZJYaLm3qoebt7S2nJkjuB2rw0kTN22dpqwbOqdlEbF5iNe7fp7lgJlcPVWq+XCReatW4bWw91KqxXgI1uQ177Zmth3I17nipVWNf9HP1UKUmecUpUeOKQE0PNW4pV/NkQputBnqrqU2V/t7R+2UnrqRtqAYUQI0sqJEFNbKgRhYS0LLwuUYW1MgyUo1d/DxsWXXXzWiuJrdWtr+3XOKyXpqraZUgW0rBRDXJCLJrzrbx1jJps5SyfhOaDWZQf6Lm9vR7GxAnyx7fC2qk1LjtUSOlhlEzQI194d4qbWBL3gagppUa6K3mdALaQhq6rRpQADWyoEYW1MiCGllIQMvC5xpZUCPLeDXxkstSSzEj1cRry4dq8CKrBgarcfOeNt1pF6IXp0cC2o18chfTmoIaNwtjB4ib61mZkaPGNggGF/R485yLcyAFNePVPI/eBjy/T3FMaF3VQD81pxPQfPe5txpQADWyoEYW1MiCGllIQMvC5xpZUCNLbzWtVl0WXL3pnUorDGncbEEvV1GzJsPU2FXlJL9mt4OkzwrMTaUFToPGizBMTTIW7AhCzRQ1QeQPG6CmawI6F/kSd1Z0vH0bhl0b4E5ohSMINa3UQD81pxPQFtLQbdWAAqiRBTWybGo+NkCNB0W4/AKY91l+) -&] -[s0; &] -[s0; Význam jednotlivých funkcí nabídky je následující:&] -[s0; &] -[s0;i150;O0; [* Nastavit barvu]: přepíše vybranou položku palety -na aktuálně vybranou barvu.&] -[s0;i150;O0; [* Standardní paleta]: obnoví výchozí paletu 16 základních -barev (jako na obrázku).&] -[s0;i150;O0; [* Uložit jako]: zobrazí dialog pro výběr souboru a -do uživatelem zvoleného souboru uloží hodnoty jednotlivých -barev palety.&] -[s0;i150;O0; [* Načíst]: zobrazí dialog pro výběr souboru a ze -zvoleného souboru načte barvy palety.&] -[s0;i150;O0; [* Malá]: nastaví režim zobrazení palety 4 x 4 polí -(celkem 16 barev).&] -[s0;i150;O0; [* Střední]: nastaví režim zobrazení palety 8 x 8 -polí(64 barev).&] -[s0;i150;O0; [* Velká]: nastaví režim zobrazení palety 16 x 16 polí -(256 barev).&] -[s0;i150;O0; [* Vlastní]: zobrazí dialog umožňující uživateli -zadat vlastní počet polí v_zobrazené paletě:&] -[s0;= &] -[s0;= -@@image:1337&575 -(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) -&] -[s1; Záložka [/ Kolo]&] -[s0; Záložka umožňuje zadat barvu výběrem z_barevného kola. -Azimut na barevném kole udává odstín barvy, vzdálenost od -středu odpovídá sytosti barvy (uprostřed kola je šedivá -nebo bílá barva, na obvodu jsou plně syté barvy). Volba jasu -barvy se provádí pomocí samostatného posuvníku napravo od -barevného kola.&] -[s0;/ &] -[s0;= -@@image:1612&2212 -(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) -&] -[s1; Záložka [/ Odstín]&] -[s0; Při volbě barvy na základě odstínu se jas a sytost barvy -vybírá z_obdélníkové mapy, odstín se volí zvlášť pomocí -samostatného posuvníku na pravé straně dialogu.&] -[s0; &] -[s0;= -@@image:1612&2212 -(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) -&] -[s1; Záložka [/ RGB]&] -[s0; Záložka umožňuje výběr barvy pomocí tří posuvníků -udávajících přímo zastoupení barevných složek R, G, B -(červená, zelená, modrá). Každý posuvník zobrazuje vedle -sebe dva sloupce s_barevným gradientem:&] -[s0;i150;O0; [* levý sloupec] obsahuje gradient, ve kterém se aktuální -barva kombinuje s_různým zastoupením barevné složky příslušného -posuvníku;&] -[s0;i150;O0; [* pravý sloupec] zobrazuje gradient čisté barvy posuvníku.&] -[s0; &] -[s0;= -@@image:1612&2212 -(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) -&] -[s1; Záložka [/ HSV]&] -[s0; Záložka umožňuje výběr barvy pomocí tří posuvníků -odpovídajícím parametrům barvy v prostoru HSV (hue `= [* odstín], -saturation `= [* sytost], value `= [* jas]). Každý posuvník zobrazuje -vedle sebe dva sloupce s_barevným gradientem:&] -[s0;i150;O0; [* levý sloupec] obsahuje gradient, ve kterém se v_aktuální -barvě nahradí parametr barvy příslušející posuvníku (H, -S, nebo V) celou dostupnou škálou tohoto parametru..&] -[s0;i150;O0; [* pravý sloupec] zobrazuje gradient vyznačující škálu -příslušného parametru (škála odstínů při plné sytosti -a jasu, škála sytostí při plném jasu, škála jasu).&] -[s0;= -@@image:1612&2212 -(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) -&] -[s1; Ukončení dialogu&] -[s0; -@@image:400&109/25 -(A1AAFgAAAOr/AAAAAHic7Y8xDsMgEAT5/w/ygxT5kDFWCmNw4kckKAU6cdcuihZWI7RscxrnhstnjEjfJ3se91vjG/eNGMs3EKN9jz0QY/jGQIz2TTFAqefkYnYElu+K46fTdl1waN98rCDKCXORL5o/8e0jO32L75k8iHLCXOSLpqdvI1W7Lj19X8lDqefkYnYEhm/2xGjfd16Imb7XuRDT+JYvPW5mgHwBpeCoqQ==) - [* Enter] ukončí dialog a potvrdí vybranou barvu.&] -[s0; &] -[s0; -@@image:401&109/25 -(A1AAFgAAAOr/AAAAAHic5ZRRCsMgDEBz/xvsBvvohWotg2m16w7RyQoSFbtBAhtJeARNYuj76b4rCgBI+aYjhusl+7r7LB7s690sntLXigf7Ls6Kp/D1VjzYN3hLB1AcV5a1XJS+E5G33YfKb8G+cZmIpFVt5YjeFeeq287T4fXtGfXO55O9t3/l++U3U7pcvmswjKS1OeMKvUtBs+8jGCL4n1MVq4F8xWPtud1GpPCNRjzYd4ujeDT7PtdRPGp900EJoC9er1M8wg==) - [* Esc] opustí dialog bez výběru barvy.&] -[s0; &] -[s0; ]] \ No newline at end of file diff --git a/uppsrc/CtrlLib/srcdoc.tpp/MenuCb_en-us.tpp b/uppsrc/CtrlLib/srcdoc.tpp/MenuCb_en-us.tpp deleted file mode 100644 index eb92d9f2f..000000000 --- a/uppsrc/CtrlLib/srcdoc.tpp/MenuCb_en-us.tpp +++ /dev/null @@ -1,127 +0,0 @@ -topic "About Callbacks and Bars"; -[l288;i1120;a17;O9;~~~.1408;2 $$1,0#10431211400427159095818037425705:param] -[a83;*R6 $$2,5#31310162474203024125188417583966:caption] -[b83;*4 $$3,5#07864147445237544204411237157677:title] -[i288;O9;C2 $$4,6#40027414424643823182269349404212:item] -[b42;a42;2 $$5,5#45413000475342174754091244180557:text] -[l288;b17;a17;2 $$6,6#27521748481378242620020725143825:desc] -[l321;t246;C@5;1 $$7,7#20902679421464641399138805415013:code] -[b2503;2 $$8,0#65142375456100023862071332075487:separator] -[*@(0.0.255)2 $$9,0#83433469410354161042741608181528:base] -[t4167;C2 $$10,0#37138531426314131251341829483380:class] -[l288;a17;*1 $$11,11#70004532496200323422659154056402:requirement] -[i417;b42;a42;O9;~~~.416;2 $$12,12#10566046415157235020018451313112:tparam] -[b167;C2 $$13,13#92430459443460461911108080531343:item1] -[i288;a42;O9;C2 $$14,14#77422149456609303542238260500223:item2] -[*@2$(0.128.128)2 $$15,15#34511555403152284025741354420178:NewsDate] -[l321;*C$7;2 $$16,16#03451589433145915344929335295360:result] -[l321;b83;a83;*C$7;2 $$17,17#07531550463529505371228428965313:result`-line] -[l160;t4167;*C+117 $$18,5#88603949442205825958800053222425:package`-title] -[2 $$19,0#53580023442335529039900623488521:gap] -[t4167;C2 $$20,20#70211524482531209251820423858195:class`-nested] -[b50;2 $$21,21#03324558446220344731010354752573:Par] -[2 $$0,0#00000000000000000000000000000000:Default] -[{_}%EN-US -[s2; About Callbacks and Bars&] -[s0; This article discusses callback types and function overloads -involved in Bar operations (MenuBar, ToolBar). The Bar class -is a base class of BarCtrl which is a base class of MenuBar and -ToolBar.&] -[s0; &] -[s0; The typical pattern you can see in U`+`+ code for handling Bars -looks like this:&] -[s0; &] -[s7; void HelloWorld`::About()&] -[s7; `{&] -[s7; -|...&] -[s7; `}&] -[s7; &] -[s7; void HelloWorld`::FileMenu(Bar`& bar)&] -[s7; `{&] -[s7; -|bar.Add(`"About..`", THISBACK(About));&] -[s7; -|bar.Separator();&] -[s7; -|bar.Add(`"Exit`", THISBACK(Close));&] -[s7; `}&] -[s7; &] -[s7; void HelloWorld`::FileMenu2(Bar`& bar, int val)&] -[s7; `{&] -[s7; -|bar.Add(`"About..`", THISBACK(About));&] -[s7; -|if (val `=`= 1)&] -[s7; -|`{&] -[s7; -|-|bar.Separator();&] -[s7; -|-|bar.Add(`"Exit`", THISBACK(Close));&] -[s7; -|`}&] -[s7; `}&] -[s7; &] -[s7; HelloWorld`::HelloWorld()&] -[s7; `{&] -[s7; -|menu.Add(`"File`", THISBACK(FileMenu));&] -[s7; -|menu.Add(`"File2`",THISBACK1(FileMenu2,0);&] -[s0; &] -[s0; Here THISBACK macro expands to &] -[s0; &] -[s0; -|[* callback](this, `&HelloWorld`::FileMenu)&] -[s0; &] -[s0; [* callback] is an overloaded non member template function which -has overloads that allow the member function being called back -to have none, 1,2,3 or 4 arguments. Hence the FileMenu function -can have none, 1,2,3,or 4 parameters and the appropriate overload -of [* callback] will be selected. When the target called back -function is called (e.g. FileMenu), the actual arguments that -are passed to it are provided by the event dispatcher which knows -how many arguments it needs to pass for a particular event. -In the example above, the HelloWorld constructor calls the [* callback -]function which creates a Callback object (on the heap) containing -the identity of the target function (FileMenu) to be called. - The menu.Add function stores the address of the Callback object -which will be used to call the FileMenu function when an event -is triggered. There are several different Callback classes, -including the Callback1MethodAction class, which is used for -the above case. The Callback classes are functors and usually -have a member function named Execute that is called by the event -dispatching mechanism. For the Callback1MethodAction class, -the Execute member function takes one parameter (provided by -the event dispatcher) which is passed to the target callback -function FileMenu.&] -[s0; &] -[s0; There is also a THISBACK1 macro, which allows specification -of an additional value that is passed to the called back function -(e.g. FileMenu2) when an event is triggered.&] -[s0; &] -[s0; The THISBACK1 macro in the above example expands to &] -[s0; &] -[s0; -|[* callback1](this, `&HelloWorld`::FileMenu2, 0)&] -[s0; &] -[s0; The FileMenu2 function takes two parameters, the first of which -is supplied by the event dispatcher and the second comes from -the additional value 0 specified in the invocation of THISBACK1. - A possible use for this is to allow the target function to be -called from multiple places., each of which identifies itself -using the additional parameter. For the above example, the Callback -object involved is of type CallbackMethodActionArg1.and this -object stores the additional value (0 in this case) to be passed -to the FileMenu2 function when an event is triggered. If you -use the THISBACK1 macro with a member function that takes only -one argument then the Callback object is of type CallbackMethodActionArg.&] -[s0; &] -[s0; There is also a THISBACK2 macro which allows two additional -arguments. The member function used with THISBACK, can have -0,1,2,3 or 4 parameters. For THISBACK1, the member function -must have at least one parameter and for THISBACK2 the member -function can have 2,3 or 4 parameters.&] -[s0; &] -[s0; If the member function used in the THISBACK macros is overloaded -(e.g. FileMenu(int)) then the code won`'t compile. In this case -you have to use a forwarding member function that is not overloaded. -(You can`'t supply argument types when you take the address of -a member function. If the function is overloaded, the one that`'s -chosen depends on the target, but in this case the target is -also overloaded so it can`'t be resolved).&] -[s0; &] -[s0; In the above example, the Add member function of Bar is an overloaded -function and which Add function that is used depends on the return -value of the [* callback] function. For the FileMenu example above, -the return type of the [* callback] function is Callback1. -(In U`+`+, Callback classes start with upper case C and callback -functions have lower case c). &] -[s0; ]] \ No newline at end of file diff --git a/uppsrc/CtrlLib/srcdoc.tpp/RoundingDoubles_en-us.tpp b/uppsrc/CtrlLib/srcdoc.tpp/RoundingDoubles_en-us.tpp deleted file mode 100644 index eb9a05d87..000000000 --- a/uppsrc/CtrlLib/srcdoc.tpp/RoundingDoubles_en-us.tpp +++ /dev/null @@ -1,140 +0,0 @@ -TITLE("About rounding double values") -COMPRESSED -120,156,165,88,139,110,219,200,21,253,149,193,58,222,149,109, -90,153,23,95,82,11,108,234,56,133,129,54,27,36,187,192, -182,134,107,142,197,145,60,48,69,170,36,21,219,187,221,124, -123,207,29,82,15,63,148,71,43,195,182,68,206,125,157,123, -238,153,161,206,37,123,241,130,7,124,143,127,225,53,122,109, -167,102,89,180,23,231,133,76,146,177,139,185,30,27,17,143, -127,74,199,159,62,125,26,166,169,28,147,43,1,87,130,107, -37,164,16,154,115,45,99,17,166,60,13,19,145,112,21,107, -25,198,60,28,45,76,109,230,23,231,38,81,227,195,247,17, -172,100,16,238,41,161,4,23,145,212,88,197,21,151,90,200, -80,36,137,22,113,152,168,52,138,70,19,179,104,93,85,94, -156,95,145,29,172,20,172,120,156,68,90,192,70,135,82,197, -161,134,173,214,66,224,189,8,227,40,142,71,173,107,11,11, -27,17,197,99,163,229,248,132,178,212,65,180,135,236,100,12, -83,45,117,164,85,34,149,72,164,140,82,165,83,141,180,133, -28,185,214,34,201,43,216,144,29,153,133,8,168,67,45,20, -240,208,113,168,176,44,198,127,205,83,33,17,53,225,97,136, -128,246,110,5,18,225,67,118,17,194,201,56,164,213,137,78, -132,138,19,169,101,36,145,0,143,81,36,69,15,71,185,109, -38,176,83,82,140,91,164,52,62,249,49,28,11,24,199,65, -188,39,121,202,101,20,167,8,136,100,81,176,74,83,161,18, -4,212,34,228,66,141,38,85,78,69,202,144,171,49,108,18, -116,33,130,99,15,73,24,9,228,43,85,130,136,177,80,10, -127,67,157,196,163,198,82,31,218,170,190,56,63,252,113,192, -135,124,40,195,240,128,242,77,97,158,40,173,148,142,82,45, -184,66,20,248,208,4,87,196,209,73,17,202,100,116,101,26, -132,108,53,1,123,66,157,39,22,1,118,149,132,10,145,35, -252,65,71,81,158,2,50,50,213,137,82,9,31,77,10,211, -52,91,240,28,82,137,66,4,66,236,197,132,106,168,164,78, -9,26,37,1,175,140,194,84,0,223,48,210,92,142,106,251, -239,165,171,237,220,150,0,216,129,24,227,85,115,122,18,34, -151,142,132,50,16,18,52,12,163,136,19,90,33,184,32,85, -8,184,185,72,52,50,194,15,26,220,246,60,244,220,240,188, -16,42,16,106,47,149,90,33,147,84,107,0,0,7,34,21, -66,240,4,63,168,12,176,120,102,8,164,224,139,232,194,119, -230,58,16,122,47,6,129,209,167,84,83,248,84,17,124,18, -232,203,136,135,104,131,236,204,37,129,46,95,0,118,33,19, -250,61,32,251,48,16,24,4,100,40,194,16,101,43,0,45, -19,148,30,2,121,229,201,45,226,100,244,214,222,54,175,77, -107,123,182,28,158,188,232,104,38,162,64,68,123,156,236,195, -36,69,251,132,38,248,148,214,169,76,149,10,101,26,170,136, -3,198,166,155,99,50,166,89,242,115,184,118,18,7,34,198, -88,161,212,48,68,241,222,12,133,199,130,82,145,73,26,17, -8,189,147,236,184,112,37,229,1,94,140,59,42,28,158,28, -9,17,147,163,4,211,146,36,17,87,41,176,0,4,60,4, -205,161,4,9,250,140,54,75,204,0,73,193,228,198,204,108, -118,220,207,233,239,151,127,236,159,190,61,254,229,3,59,111, -228,152,189,186,170,150,45,171,171,101,153,187,114,198,242,106, -121,85,88,246,209,20,75,219,124,127,113,222,240,49,251,208, -154,50,55,117,206,78,216,220,180,215,172,112,87,181,169,239, -89,110,167,200,173,97,237,109,181,113,48,93,150,19,18,145, -102,212,91,247,255,166,69,85,213,44,59,238,86,194,168,98, -237,181,101,165,53,40,180,101,101,85,102,199,179,218,2,244, -154,214,154,150,221,186,246,154,114,203,237,196,205,77,193,114, -55,115,109,19,48,55,180,195,103,124,15,178,99,57,68,147, -179,63,111,125,214,254,115,118,172,130,254,226,246,130,100,40, -31,124,234,238,37,15,125,79,172,43,190,144,118,81,221,254, -15,73,147,227,173,156,215,31,87,41,203,160,187,182,202,178, -255,176,181,58,245,111,211,135,110,207,74,102,242,220,81,11, -250,100,27,203,154,85,7,215,221,9,216,47,217,81,118,180, -238,225,192,149,236,164,170,237,203,101,235,138,225,245,1,51, -108,106,111,89,53,101,72,159,85,183,229,118,59,227,49,59, -223,231,252,152,115,230,202,150,77,61,54,131,158,58,119,7, -227,139,231,22,117,40,127,97,145,175,235,209,154,77,109,63, -251,98,38,213,252,10,57,111,40,55,120,212,20,120,178,51, -91,7,159,227,216,243,55,187,78,174,237,113,99,97,129,215, -71,91,220,31,248,214,178,182,6,130,198,163,11,108,186,158, -195,83,111,50,220,13,146,43,170,153,224,171,218,242,167,245, -247,119,220,162,186,197,58,111,178,115,81,89,213,32,151,251, -205,174,253,5,20,36,251,158,217,187,69,85,66,190,119,96, -183,238,63,155,152,146,93,89,182,108,108,78,5,204,77,233, -22,203,2,208,120,84,170,58,7,16,115,51,43,93,187,204, -237,186,214,102,216,23,2,108,218,101,13,63,180,186,195,116, -131,60,115,172,89,78,0,214,53,208,17,60,251,151,99,127, -2,83,41,73,95,29,130,23,19,31,172,233,111,15,26,76, -77,145,83,70,181,197,13,15,57,155,154,166,13,24,124,20, -22,239,216,20,2,130,72,77,85,26,170,121,85,106,115,16, -108,0,65,131,76,217,96,229,188,33,10,251,254,228,171,94, -211,101,170,180,117,77,99,88,118,232,131,175,220,4,236,246, -218,214,118,115,127,64,38,93,153,192,168,3,250,0,226,135, -164,49,44,116,179,177,115,151,29,79,138,138,64,164,218,107, -232,38,203,206,69,0,207,7,59,200,208,119,204,179,183,126, -216,191,94,45,118,182,221,143,208,55,218,208,68,125,214,100, -55,69,124,138,108,134,94,148,27,166,251,126,251,75,229,114, -126,133,94,131,26,217,101,118,137,202,93,78,111,122,239,80, -20,72,222,186,155,126,72,112,117,77,169,131,71,114,248,170, -40,8,86,83,20,65,135,173,155,47,138,173,33,191,175,150, -12,147,202,76,115,227,183,25,112,193,129,197,203,186,70,239, -192,149,178,106,217,2,3,235,59,121,5,5,118,109,246,67, -179,205,38,48,231,222,167,65,142,231,126,157,29,206,134,143, -246,169,94,203,64,169,173,189,33,103,47,87,131,73,151,143, -24,31,134,7,68,160,245,197,135,78,254,130,248,72,184,6, -71,141,47,99,208,113,107,85,196,178,161,26,60,191,30,239, -155,157,154,64,191,59,58,99,74,45,212,156,77,157,45,114, -16,29,53,55,80,232,130,53,213,220,182,215,100,105,216,149, -163,158,78,167,182,238,121,108,218,117,168,220,206,209,75,76, -69,75,107,125,22,240,65,147,96,218,182,51,255,108,111,187, -110,14,217,217,212,187,4,28,55,196,161,170,219,45,222,120, -63,195,235,128,110,102,63,32,47,108,39,121,63,108,5,228, -116,231,145,96,139,169,22,209,30,179,55,251,253,241,149,227, -255,188,121,157,93,126,56,251,235,91,70,47,244,134,223,113, -76,218,203,151,32,205,173,185,111,168,253,11,139,232,141,155, -149,108,144,29,97,6,159,119,242,254,244,111,108,203,137,244, -78,214,76,93,109,221,139,194,76,104,103,244,204,94,205,204, -238,172,178,203,211,95,223,245,30,245,206,180,0,220,74,112, -216,64,216,236,72,238,112,121,242,234,29,60,110,146,76,188, -75,60,161,185,22,185,157,250,1,216,242,116,186,179,216,127, -158,190,255,105,83,44,158,33,200,207,141,181,11,146,74,87, -80,131,126,179,117,133,66,5,30,79,112,114,220,225,231,205, -217,175,91,160,73,190,93,226,146,116,195,221,65,5,49,134, -221,238,56,232,168,241,186,147,205,231,93,18,96,27,151,250, -137,203,85,125,152,133,175,117,156,253,241,68,8,63,180,53, -21,185,122,109,155,191,246,77,125,86,29,187,247,211,194,204, -154,29,123,235,215,133,248,146,115,95,123,255,25,115,157,93, -34,138,191,246,77,81,222,184,187,175,10,244,77,78,79,239, -22,255,111,246,27,73,252,7,196,131,206,28,212,215,238,80, -138,81,88,216,218,239,201,166,152,87,216,224,77,121,15,117, -54,51,215,109,240,131,205,102,127,208,139,212,70,183,134,148, -42,196,11,71,219,26,226,133,199,145,7,168,223,5,171,137, -13,216,25,78,35,139,69,229,3,147,126,118,71,141,188,218, -210,80,236,54,174,48,53,229,228,117,251,239,247,239,73,152, -59,103,195,39,219,100,109,105,111,233,132,216,128,153,215,164, -149,254,187,147,94,218,79,161,217,189,49,59,107,217,181,161, -211,8,5,171,114,58,252,20,152,148,119,168,195,214,37,201, -181,195,89,169,177,109,179,62,164,244,210,220,116,189,161,81, -127,219,85,215,47,118,205,250,224,54,179,165,173,87,199,54, -250,102,100,137,97,129,226,116,91,225,250,164,234,143,186,94, -212,135,236,231,254,113,141,204,205,106,110,55,130,255,232,201, -197,15,34,246,201,231,181,123,83,40,12,241,254,233,49,132, -174,14,251,98,7,217,119,251,186,204,190,123,194,142,193,138, -30,166,104,170,21,71,216,28,91,12,169,84,247,56,131,156, -78,178,227,166,189,47,214,32,217,26,9,22,238,198,178,125, -61,195,161,149,237,171,105,183,251,147,249,126,185,89,71,144, -121,119,211,194,222,57,98,212,144,61,76,225,109,229,65,4, -198,125,178,100,98,38,132,39,14,15,125,239,128,207,73,85, -126,180,117,95,116,176,105,8,164,129,110,211,151,54,204,127, -7,99,253,54,187,77,133,46,146,98,23,255,5,245,137,37, -33, \ No newline at end of file diff --git a/uppsrc/CtrlLib/srcdoc.tpp/Updater_en-us.tpp b/uppsrc/CtrlLib/srcdoc.tpp/Updater_en-us.tpp deleted file mode 100644 index 5e113dbde..000000000 --- a/uppsrc/CtrlLib/srcdoc.tpp/Updater_en-us.tpp +++ /dev/null @@ -1,57 +0,0 @@ -topic "About Updater"; -[2 $$0,0#00000000000000000000000000000000:Default] -[l288;i704;a17;O9;~~~.992;2 $$1,0#10431211400427159095818037425705:param] -[a83;*R6 $$2,5#31310162474203024125188417583966:caption] -[b83;*2 $$3,5#07864147445237544204411237157677:title] -[i288;b167;a42;O9;C2 $$4,6#40027414424643823182269349404212:item] -[b42;a42;2 $$5,5#45413000475342174754091244180557:text] -[l288;a17;2 $$6,6#27521748481378242620020725143825:desc] -[l321;t246;C@5;1 $$7,7#20902679421464641399138805415013:code] -[b2503;2 $$8,0#65142375456100023862071332075487:separator] -[*@(0.0.255)2 $$9,0#83433469410354161042741608181528:base] -[t4167;C2 $$10,0#37138531426314131251341829483380:class] -[l288;a17;*1 $$11,11#70004532496200323422659154056402:requirement] -[i417;b42;a42;O9;~~~.416;2 $$12,12#10566046415157235020018451313112:tparam] -[b167;C2 $$13,13#92430459443460461911108080531343:item1] -[i288;a42;O9;C2 $$14,14#77422149456609303542238260500223:item2] -[*@2$(0.128.128)2 $$15,15#34511555403152284025741354420178:NewsDate] -[l321;*C$7;2 $$16,16#03451589433145915344929335295360:result] -[l321;b83;a83;*C$7;2 $$17,17#07531550463529505371228428965313:result`-line] -[l160;t4167;*C+117 $$18,5#88603949442205825958800053222425:package`-title] -[{_}%EN-US -[s2; About Updater&] -[s0; Updater.exe and related CtrlLib routines can save a lot of maintainance -costs when deploying new application versions at large client`'s -side.&] -[s0; &] -[s0; The ideas is this: New version is placed to the network drive. -When user starts his local application, it checks network directory -for the new version. If there is any, application starts updater -and exits. Updater overwrites current version with new one and -restarts it. Note that the need for updater is caused by fact -that .exe cannot overwrite itself.&] -[s0; &] -[s0; See CtrlLib/Update for details.&] -[s0; &] -[s0; Now the funny part is that it can update even more than itself -`- it is used to update any files in app directory. So updater.exe -itself is updated by application. Last development has gone even -so far, that Oracle client installation is `"updated`", that -in fact means that deploying our Oracle apps can be done by copying -two files to clients directory `- app itself and `"q.ini`" file, -which basically contains information about network directory -in UPDATE`=[/ path ]entry.&] -[s0; &] -[s0; Example `- this is how some of our app GUI`_APP`_MAIN looks -like:&] -[s0; &] -[s7; GUI`_APP`_MAIN&] -[s7; `{&] -[s7; -|SelfUpdate(); // SelfUpdate updates updater.exe first and then -app itself&] -[s7; -|UpdateFile(`"cs`-cz.scd`"); // Update czech spelling checker&] -[s7; -|UpdateFile(`"logo.bmp`"); // Update company logo to be used -in reports&] -[s0; &] -[s0; &] -[s0; ] \ No newline at end of file diff --git a/uppsrc/Draw/Cham.cpp b/uppsrc/Draw/Cham.cpp index 70244d6e3..0ecfb9629 100644 --- a/uppsrc/Draw/Cham.cpp +++ b/uppsrc/Draw/Cham.cpp @@ -422,6 +422,8 @@ void ChFinish() sChStyle()[i].init(); sIsDarkColorFace = IsDark(SColorFace()); sLabelTextColorMismatch = IsDark(SColorText()) != IsDark(SColorLabel()); + for(int i = 0; i < 5; i++) // repeat to propagate changes + SColor::Refresh(); } Value sChOp(Draw& w, const Rect& r, const Value& v, int op, Color ink) diff --git a/uppsrc/Draw/Cham.h b/uppsrc/Draw/Cham.h index 1f5fd4e33..0a62eddaf 100644 --- a/uppsrc/Draw/Cham.h +++ b/uppsrc/Draw/Cham.h @@ -46,15 +46,11 @@ bool IsDarkColorFace(); template struct ChStyle { - byte status; - byte registered; - T *standard; + byte status = 0; // 0 - has to be initialised or written, 1 - initialised, 2 - was written + byte registered = 0; // 0 - not yet registered - const T& Standard() const { return *standard; } T& Write() const { T& x = *(T *)this; x.status = 2; ChInvalidate(); return x; } void Assign(const T& src) { *(T *)this = src; } - - ChStyle() { status = 0; registered = 0; standard = NULL; } }; #define CH_STYLE(klass, type, style) \ @@ -69,20 +65,17 @@ void COMBINE5(klass, __, type, __, style)::InitIt() { \ \ const klass::type& klass::style() \ { \ - static COMBINE5(klass, __, type, __, style) b, standard; \ + static COMBINE5(klass, __, type, __, style) b; \ if(b.status == 0) { \ ChRegisterStyle__(b.status, b.registered, COMBINE5(klass, __, type, __, style)::InitIt); \ b.Init(); \ b.status = 1; \ - standard = b; \ - standard.standard = b.standard = &standard; \ } \ return b; \ } \ \ void COMBINE5(klass, __, type, __, style)::Init() - // CH_VAR0 allows inserting action into _Write (missing ending '}') #define CH_VAR0(chtype, type, name, init) \ chtype& COMBINE(ch_var__, name)(); \ @@ -105,7 +98,7 @@ void COMBINE(name, _Write)(type v) { COMBINE(ch_var__, name)().Write().value = v #define CH_VAR(chtype, type, name, init) CH_VAR0(chtype, type, name, init) } -struct ChColor : ChStyle { Color value; }; +struct ChColor : ChStyle { SColor value; }; #define CH_COLOR(name, init) CH_VAR(ChColor, Color, name, init) struct ChInt : ChStyle { int value; }; diff --git a/uppsrc/Draw/Image.cpp b/uppsrc/Draw/Image.cpp index 2d6be9801..fbd1ce39b 100644 --- a/uppsrc/Draw/Image.cpp +++ b/uppsrc/Draw/Image.cpp @@ -323,6 +323,14 @@ String Image::ToString() const return String("Image ").Cat() << GetSize(); } +void Image::Data::NewSerial() +{ + INTERLOCKED { + static int64 gserial; + serial = ++gserial; + } +} + Image::Data::Data(ImageBuffer& b) : buffer(b) { @@ -330,10 +338,7 @@ Image::Data::Data(ImageBuffer& b) paintonly = false; refcount = 1; aux_data = 0; - INTERLOCKED { - static int64 gserial; - serial = ++gserial; - } + NewSerial(); } void Image::SetAuxData(uint64 adata) diff --git a/uppsrc/Draw/Image.h b/uppsrc/Draw/Image.h index 8d87899b1..430f5ee4c 100644 --- a/uppsrc/Draw/Image.h +++ b/uppsrc/Draw/Image.h @@ -155,6 +155,7 @@ private: uint64 aux_data; int paintcount; + void NewSerial(); void Retain() { AtomicInc(refcount); } void Release() { if(AtomicDec(refcount) == 0) delete this; } @@ -178,6 +179,7 @@ private: friend struct scImageMaker; void SetAuxData(uint64 data); + friend void iml_ReplaceAll(Image& tgt, Image& src); public: Size GetSize() const { return data ? data->buffer.GetSize() : Size(0, 0); } @@ -313,6 +315,7 @@ class Iml { public: void Reset(); + void Skin(); int GetCount() const { return map.GetCount(); } String GetId(int i) const { return map.GetKey(i); } Image Get(int i); @@ -330,6 +333,7 @@ public: void GlobalFlag(dword f) { global_flags |= f; } static void ResetAll(); // clears all .iml caches + static void SkinAll(); // reskins all .iml caches }; void Register(const char *imageclass, Iml& iml); diff --git a/uppsrc/Draw/Iml.cpp b/uppsrc/Draw/Iml.cpp index d5a65ca70..20dc02e6a 100644 --- a/uppsrc/Draw/Iml.cpp +++ b/uppsrc/Draw/Iml.cpp @@ -41,6 +41,16 @@ Vector UnpackImlData(const String& d) return UnpackImlData(~d, d.GetLength()); } +void iml_ReplaceAll(Image& tgt, Image& src) +{ // this very special function replaces all unmodified instances of Image with new content + if(tgt.GetSize() == src.GetSize() && tgt.data) { + tgt.data->buffer = src.data->buffer; + tgt.data->NewSerial(); + } + else + tgt = src; +} + void Iml::Init(int n) { for(int i = 0; i < n; i++) @@ -53,11 +63,23 @@ void Iml::Reset() m.loaded = false; } +void Iml::Skin() +{ + for(int i = 0; i < map.GetCount(); i++) + if(map[i].loaded) { + map[i].loaded = false; + Get(i); + } +} + static StaticMutex sImlLock; void Iml::Set(int i, const Image& img) { // TODO: MT - map[i].image = img; + Image h = img; // make sure h has refcount 1, basically 'clone' + ImageBuffer ib = h; + h = ib; + iml_ReplaceAll(map[i].image, h); map[i].loaded = true; } @@ -67,7 +89,8 @@ Image Iml::Get(int i) if(!m.loaded) { Mutex::Lock __(sImlLock); if(!m.loaded) { - m.image = MakeImlImage(GetId(i), [&](int mode, const String& id) { return GetRaw(mode, id); }, global_flags); + Image h = MakeImlImage(GetId(i), [&](int mode, const String& id) { return GetRaw(mode, id); }, global_flags); + iml_ReplaceAll(m.image, h); m.loaded = true; } } @@ -180,6 +203,12 @@ void Iml::ResetAll() GetIml(i).Reset(); } +void Iml::SkinAll() +{ + for(int i = 0; i < GetImlCount(); i++) + GetIml(i).Skin(); +} + static StaticCriticalSection sImgMapLock; static VectorMap& sImgMap() diff --git a/uppsrc/Draw/MakeCache.cpp b/uppsrc/Draw/MakeCache.cpp index 659de0c43..9c34bda3a 100644 --- a/uppsrc/Draw/MakeCache.cpp +++ b/uppsrc/Draw/MakeCache.cpp @@ -12,6 +12,7 @@ struct scImageMaker : ValueMaker { StringBuffer s; s.Cat(typeid(*m).name()); RawCat(s, paintonly); + RawCat(s, IsDarkTheme()); s.Cat(m->Key()); return String(s); } diff --git a/uppsrc/Draw/SColors.cpp b/uppsrc/Draw/SColors.cpp index 6b017516b..861510635 100644 --- a/uppsrc/Draw/SColors.cpp +++ b/uppsrc/Draw/SColors.cpp @@ -22,12 +22,13 @@ CH_COLOR(SLtMagenta, AdjustIfDark(LtMagenta())); CH_COLOR(SLtCyan, AdjustIfDark(LtCyan())); bool dark_theme__; +extern bool AColor_dark_mode__; #define CH_END } // to avoid } highlighting problem CH_VAR0(ChColor, Color, SColorPaper, White()) - dark_theme__ = IsDark(SColorPaper()); - Iml::ResetAll(); + AColor_dark_mode__ = dark_theme__ = IsDark(SColorPaper()); + Iml::SkinAll(); CH_END CH_COLOR(SColorFace, SLtGray()); diff --git a/uppsrc/Draw/src.tpp/ImageBuffer_en-us.tpp b/uppsrc/Draw/src.tpp/ImageBuffer_en-us.tpp index 9c1c604b9..e03dbc4d9 100644 --- a/uppsrc/Draw/src.tpp/ImageBuffer_en-us.tpp +++ b/uppsrc/Draw/src.tpp/ImageBuffer_en-us.tpp @@ -181,7 +181,7 @@ performance in certain contexts. Default is false.&] ge][*@(0.0.255) `&][* _][*@3 img][* )]&] [s5;:ImageBuffer`:`:operator`=`(ImageBuffer`&`): [*@(0.0.255) void][* _operator`=(][*_^ImageBuffer^ I mageBuffer][*@(0.0.255) `&][* _][*@3 img][* )]&] -[s2;%% Assigns pixels of [%-*@3 img] to ImageBuffer. [%-*@3 img] is cleared +[s2;%% Moves pixels of [%-*@3 img] to ImageBuffer. [%-*@3 img] is cleared and empty after this operation, price paid for low`-cost constant time operation.&] [s3; &] diff --git a/uppsrc/Draw/srcdoc.tpp/UhdAndDarkTheme_en-us.tpp b/uppsrc/Draw/srcdoc.tpp/UhdAndDarkTheme_en-us.tpp index c3b456214..2c3b8612d 100644 --- a/uppsrc/Draw/srcdoc.tpp/UhdAndDarkTheme_en-us.tpp +++ b/uppsrc/Draw/srcdoc.tpp/UhdAndDarkTheme_en-us.tpp @@ -1,7 +1,7 @@ topic "Supporting UHD displays and Dark theme"; [l288;i1120;a17;O9;~~~.1408;2 $$1,0#10431211400427159095818037425705:param] [a83;*R6 $$2,5#31310162474203024125188417583966:caption] -[H4;b83;*4 $$3,5#07864147445237544204411237157677:title] +[H4;b83;m`.;N1;*4 $$3,5#07864147445237544204411237157677:title] [i288;O9;C2 $$4,6#40027414424643823182269349404212:item] [b42;a42;ph2 $$5,5#45413000475342174754091244180557:text] [l288;b17;a17;2 $$6,6#27521748481378242620020725143825:desc] @@ -34,7 +34,7 @@ adjustment]&] [s0; [^topic`:`/`/Draw`/srcdoc`/UhdAndDarkTheme`_en`-us`#4^ 4. Iml files]&] [s0; &] -[s3;:1: 1. GUI mode detection&] +[s3;:1: GUI mode detection&] [s5; UHD mode is activated when standard GUI font is larger than 24 pixels. Dark theme mode is activated if [* IsDark]([* SColorPaper]()), which means that grayscale value of default background is less @@ -44,7 +44,7 @@ with dark theme, UHD resolution with light theme, UHD resolution with dark theme.&] [s5; [* IsUHDMode() ]and [* IsDarkTheme() ]functions return respective current GUI status.&] -[s3;:2: 2. Scaling GUI for actual GUI font and UHD resolution&] +[s3;:2: Scaling GUI for actual GUI font and UHD resolution&] [s5; U`+`+ coordinates in drawing operations are always in real pixels for screen targets. U`+`+ provides various functions to adjust GUI elements metrics to host platform font size and UHD mode. @@ -82,7 +82,7 @@ by 2, otherwise returns it unchanged.] :: [s5; Returns [* b] if UHD is active, [* a] otherwise.]}}&] [s5; Usually [* DPI ]functions are used if the value is Image related, `'Z`' functions if it is text size related.&] -[s3;:3: 3. Color adjustment&] +[s3;:3: Color adjustment&] [s5; If application is specifying any colors, these colors need to be adjusted for dark theme. This can be often done by using [^topic`:`/`/Draw`/src`/Colors`_en`-us^ p redefined colors]. Sometimes only the light theme color is available @@ -90,7 +90,7 @@ that needs to be converted to the dark theme `- this can be done using [* DarkTheme ]function. Alternatively [* AdjustIfDark] converts the color with [* DarkTheme] only if dark theme mode is currently active.&] -[s3;:4: 4. Iml files&] +[s3;:4: Iml files&] [s5; Iml files most often contain images that are used in GUI interface. Obviously, these images must be usually different for any of 4 GUI modes.&] @@ -138,4 +138,47 @@ macros:&] [s7; #define [* FIXED`_SIZE]&] [s7; &] [s7; #include &] -[s0; ]] \ No newline at end of file +[s0; &] +[s3;:4: Reacting to theme changes&] +[s5; Before 2025.1 U`+`+ release, the application skin was loaded +from host platform just once at the start of execution and any +if user changed host platform theme, this was not reflected in +the application. Also changing to user defined or some predefined +skin required restart of application to work properly.&] +[s5; Since 2025.1, application can be made to react to host platform +changes and can change skins without restart with a call to Ctrl`::SkinChangeSensi +tive() (e.g. in GUI`_APP`_MAIN). However, this poses development +challenges with switching between light theme and dark theme.&] +[s5; While application can easily react in Paint to current mode, +situation is much more complicated when colors or images are +used as attributes of widgets or widget contents. For example +ArrayCtrl`::EvenRowColor can be called by developer to define +some color that is appropriate for light theme, theme but when +the theme is switched can be no longer viable.&] +[s5; U`+`+ provides several tools to handle this problem:&] +[s5;i150;O0; All .iml images are now considered `"special logical +constants`" whose appearance changes according to current theme +(dark / light) `- this applies to all copies as well.&] +[s5;i150;O0; [^topic`:`/`/Draw`/src`/Colors`_en`-us^ Predefined colors] +constants are also `"special logical constants`" that are interpreted +differently after theme switch.&] +[s5;i150;O0; Special logical type of Color `- SColor `- that is defined +by function that is reevaluated after theme switch, e.g.&] +[s7; static SColor light`_highlight(`[`] `{ return Blend(SColorHighlight(), +SColorPaper()) `});&] +[s0; &] +[s5;i150;O0; Another special logical type of Color `- AColor `- which +should be defined as light theme color value, but when in dark +theme, adjusts its value to the dark theme (with DarkThemeCached +function)&] +[s5;i150;O0; RichText / QTF can use DarkThemeCached to adjust colors, +which is automatically done e.g. in Labels or RichTextCtrl when +rendered on dark backgrounds&] +[s5;i150;O0; If everything else fails, Ctrl`::Skin virtual function +is always called on widget opening and on theme changes giving +developer chance to alter colors are required&] +[s5; To simplify testing, in debug mode Ctrl `+ Num`[`*`] toggles +quickly between light and dark theme `- that way developer can +check whether colors adjust correctly to the situation.&] +[s5; Demonstration of these features is in reference/ThemeChangeSensitive +example.]] \ No newline at end of file diff --git a/uppsrc/RichEdit/Editor.cpp b/uppsrc/RichEdit/Editor.cpp index de818f455..3e4fab7fa 100644 --- a/uppsrc/RichEdit/Editor.cpp +++ b/uppsrc/RichEdit/Editor.cpp @@ -608,6 +608,18 @@ void StdIndexEntryDlg(String& s) EditText(s, t_("Index Entry"), t_("Index entry"), CharFilterAscii128, 1000); } +void RichEdit::Skin() +{ + adjustunits.Image(RichEditImg::AdjustUnits()); + ink.ColorImage(RichEditImg::InkColor()) + .NullImage(RichEditImg::NullInkColor()) + .StaticImage(RichEditImg::ColorA()); + paper.ColorImage(RichEditImg::PaperColor()) + .NullImage(RichEditImg::NullPaperColor()) + .StaticImage(RichEditImg::ColorA()); + DoRefreshBar(); +} + RichEdit::RichEdit() { floating_zoom = Null; @@ -651,7 +663,6 @@ RichEdit::RichEdit() Layout(); SetSb(); - adjustunits.Image(RichEditImg::AdjustUnits()); adjustunits <<= THISBACK(SetupUnits); ruler.Add(adjustunits.RightPosZ(4, 16).VSizePosZ(2, 2)); @@ -710,13 +721,7 @@ RichEdit::RichEdit() gototable.WhenSelect = THISBACK(Goto); - ink.ColorImage(RichEditImg::InkColor()) - .NullImage(RichEditImg::NullInkColor()) - .StaticImage(RichEditImg::ColorA()); ink.NotNull(); - paper.ColorImage(RichEditImg::PaperColor()) - .NullImage(RichEditImg::NullPaperColor()) - .StaticImage(RichEditImg::ColorA()); ink <<= THISBACK(SetInk); ink.Tip(t_("Text color")); paper <<= THISBACK(SetPaper); @@ -768,6 +773,11 @@ void RichEditWithToolBar::RefreshBar() toolbar.Set(THISBACK(TheBar)); } +void RichEditWithToolBar::Skin() +{ + RefreshBar(); +} + void RichEdit::EvaluateFields() { WhenStartEvaluating(); diff --git a/uppsrc/RichEdit/RichEdit.h b/uppsrc/RichEdit/RichEdit.h index c73711525..e8206c436 100644 --- a/uppsrc/RichEdit/RichEdit.h +++ b/uppsrc/RichEdit/RichEdit.h @@ -226,6 +226,7 @@ public: virtual Point GetPreedit(); virtual Font GetPreeditFont(); virtual Rect GetCaret() const; + virtual void Skin(); private: virtual int GetCharAt(int64 i) const { return GetChar((int)i); } @@ -855,6 +856,10 @@ public: }; class RichEditWithToolBar : public RichEdit { +public: + virtual void Skin(); + +private: ToolBar toolbar; bool extended; void RefreshBar(); diff --git a/uppsrc/TabBar/FileTabs.cpp b/uppsrc/TabBar/FileTabs.cpp index b7aaea889..1da300d97 100644 --- a/uppsrc/TabBar/FileTabs.cpp +++ b/uppsrc/TabBar/FileTabs.cpp @@ -175,10 +175,10 @@ FileTabs& FileTabs::operator<<(const FileTabs &src) FileTabs::FileTabs() : stackedicons(false), greyedicons(true), -filecolor(SColorLabel), -extcolor(IsDark(SColorFace()) ? Blend(White, LtBlue) : LtBlue) +filecolor(SColorLabel) { - + static SColor se([] { return IsDark(SColorFace()) ? Blend(White, LtBlue) : LtBlue; }); + extcolor = se; } } diff --git a/uppsrc/TabBar/TabBar.cpp b/uppsrc/TabBar/TabBar.cpp index f7c7a9587..6c77e261c 100644 --- a/uppsrc/TabBar/TabBar.cpp +++ b/uppsrc/TabBar/TabBar.cpp @@ -1151,7 +1151,7 @@ void TabBar::PaintTab(Draw &w, const Size &sz, int n, bool enable, bool dragsamp bool ac = (n == active && enable); bool hl = (n == highlight && enable) || (stacking && highlight >= 0 && tabs[highlight].stack == t.stack); - int c = align == LEFT ? cnt - n : n; + int c = align == LEFT ? cnt - n : n; int lx = n > 0 ? s.extendleft : 0; int x = t.pos.x - sc.GetPos() - lx + s.margin; @@ -2696,7 +2696,7 @@ TabBar::Style& TabBar::Style::GroupSeparators(Value horz, Value vert) TabBar::Style& TabBar::Style::DefaultGroupSeparators() { - return GroupSeparators(TabBarImg::SEP(), TabBarImg::SEPV()); + return GroupSeparators(TabBarImg::SEP(), TabBarImg::SEPV()); } Vector TabBar::GetKeys() const @@ -2723,7 +2723,7 @@ TabBar& TabBar::CopyBaseSettings(const TabBar& src) crosses_side = src.crosses_side; grouping = src.grouping; contextmenu = src.contextmenu; - autoscrollhide = src.autoscrollhide; + autoscrollhide = src.autoscrollhide; nosel = src.nosel; nohl = src.nohl; inactivedisabled = src.inactivedisabled; diff --git a/uppsrc/ide/Config.cpp b/uppsrc/ide/Config.cpp index 88b3307bd..74fd11270 100644 --- a/uppsrc/ide/Config.cpp +++ b/uppsrc/ide/Config.cpp @@ -187,7 +187,7 @@ void Sentinel(Stream& s, const char *txt) void Ide::Serialize(Stream& s) { - int version = 30; + int version = 31; Sentinel(s, "before 12341234"); s.Magic(0x12341234); Sentinel(s, "after magic"); @@ -254,6 +254,8 @@ void Ide::Serialize(Stream& s) s % hilite_if_endif; s % hilite_bracket; s % hilite_ifdef; + if(version >= 31) + s % hl_custom; if(version >= 3) s % thousands_separator; if(version >= 5) @@ -293,7 +295,8 @@ void Ide::Serialize(Stream& s) } s % editor.commentdp; s % bordercolumn; - s % bordercolor; + Color dummy_color; + s % dummy_color; if(version >= 20) s % find_pick_sel % find_pick_text % deactivate_save; s % hydra1_threads; diff --git a/uppsrc/ide/Debuggers/GdbData.cpp b/uppsrc/ide/Debuggers/GdbData.cpp index 0b460b0f4..d145d82d4 100644 --- a/uppsrc/ide/Debuggers/GdbData.cpp +++ b/uppsrc/ide/Debuggers/GdbData.cpp @@ -266,7 +266,7 @@ void Gdb::Cpu() while(!ss.IsEof()) { String ln = ss.GetLine(); cpu.Add(AttrText(ln).SetFont(Courier(Ctrl::HorzLayoutZoom(12))) - .Paper(even ? Blend(SColorMark, SColorPaper, 220) : SColorPaper) + .Paper(even ? SColorEvenRow() : SColorPaper()) .Ink(SColorText)); even = !even; } diff --git a/uppsrc/ide/LayDes/laylib.cpp b/uppsrc/ide/LayDes/laylib.cpp index 7b791fc3c..ac2cfe6d0 100644 --- a/uppsrc/ide/LayDes/laylib.cpp +++ b/uppsrc/ide/LayDes/laylib.cpp @@ -43,7 +43,7 @@ EscValue EscColor(Color c) { EscValue v; if(c.GetSpecial() >= 0) - c = AdjustIfDark(RealizeColor(c)); + c = AColor(RealizeColor(c)); if(!IsNull(c)) { v.MapSet("r", c.GetR()); v.MapSet("g", c.GetG()); diff --git a/uppsrc/ide/RepoSync.cpp b/uppsrc/ide/RepoSync.cpp index 0dfc1bc93..64b7a5895 100644 --- a/uppsrc/ide/RepoSync.cpp +++ b/uppsrc/ide/RepoSync.cpp @@ -174,7 +174,7 @@ bool RepoSync::ListSvn(const String& path) if(action == ADD && IsConflictFile(file)) { action = DELETEC; an = "Delete (conflict resolved)"; - color = AdjustIfDark(Black()); + color = AColor(Black()); } else { static const char *as[] = { @@ -182,7 +182,7 @@ bool RepoSync::ListSvn(const String& path) }; static Color c[] = { LtBlue, Magenta, Green, LtRed, LtMagenta }; an = as[action]; - color = AdjustIfDark(c[action]); + color = AColor(c[action]); } } if(pass == action < 0 && action != DELETEC) { @@ -238,7 +238,7 @@ bool RepoSync::ListGit(const String& path) }; static Color c[] = { LtBlue, Magenta, Green, LtRed, LtMagenta }; an = as[action]; - color = AdjustIfDark(c[action]); + color = AColor(c[action]); } int ii = list.GetCount(); list.Add(action, file, Null, AttrText(action < 0 ? h : file).Ink(color)); @@ -288,7 +288,7 @@ void RepoSync::SyncList() return cfg.Find(s) >= 0; }; int hi = list.GetCount(); - Color bk = AdjustIfDark(LtYellow()); + Color bk = AColor(LtYellow()); list.Add(REPOSITORY, path, AttrText().Paper(bk), AttrText(path).Bold().Paper(bk), diff --git a/uppsrc/ide/Setup.cpp b/uppsrc/ide/Setup.cpp index 5f697b956..b9ba23144 100644 --- a/uppsrc/ide/Setup.cpp +++ b/uppsrc/ide/Setup.cpp @@ -158,7 +158,7 @@ void Ide::UpdateFormat(CodeEditor& editor) editor.LineNumbers(line_numbers); editor.AutoEnclose(auto_enclose); editor.MarkLines(mark_lines); - editor.BorderColumn(bordercolumn, bordercolor); + editor.BorderColumn(bordercolumn, this->editor.GetHlStyle(CodeEditor::SHOW_BORDER).color); editor.PersistentFindReplace(persistent_find_replace); editor.FindReplaceRestorePos(find_replace_restore_pos); editor.Refresh(); @@ -381,6 +381,8 @@ void Ide::SetupFormat() { (hlt.thousands_separator, thousands_separator) (hlt.hline, hline) (hlt.vline, vline) + (hlt.bordercolumn, bordercolumn) + (hlt.hl_custom, hl_custom) (edt.indent_spaces, indent_spaces) (edt.no_parenthesis_indent, no_parenthesis_indent) @@ -390,8 +392,6 @@ void Ide::SetupFormat() { (edt.lineends, line_endings) (edt.numbers, line_numbers) (edt.bookmark_pos, bookmark_pos) - (edt.bordercolumn, bordercolumn) - (edt.bordercolor, bordercolor) (edt.findpicksel, find_pick_sel) (edt.findpicktext, find_pick_text) (edt.deactivate_save, deactivate_save) @@ -457,6 +457,7 @@ void Ide::SetupFormat() { edt.tabsize.WhenAction = rtvr <<= hlt.hlstyle.WhenCtrlsAction = ed.WhenAction = tf.WhenAction = con.WhenAction = f1.WhenAction = f2.WhenAction = dlg.Breaker(222); + hlt.hlstyle.WhenCtrlsAction << [&] { hlt.hl_custom <<= true; }; ide.showtimeafter <<= Nvl((Date)FileGetTime(ConfigFile("version")), GetSysDate() - 1); hlt.hl_restore <<= dlg.Breaker(333); hlt.hl_restore_white <<= dlg.Breaker(334); @@ -464,6 +465,8 @@ void Ide::SetupFormat() { for(auto sk : GetAllChSkins()) ide.chstyle.Add(ide.chstyle.GetCount(), sk.b); + + ide.chstyle << dlg.Breaker(336); String usc_path = GetHomeDirFile("usc.path"); ide.uscpath <<= LoadFile(usc_path); @@ -530,24 +533,33 @@ void Ide::SetupFormat() { SetupEditor(); ReadHlStyles(hlt.hlstyle); hlstyle_is_default = true; + hlt.hl_custom <<= true; } if(c == 334 && PromptYesNo("Set white theme?")) { editor.WhiteTheme(false); SetupEditor(); ReadHlStyles(hlt.hlstyle); hlstyle_is_default = false; + hlt.hl_custom <<= true; } if(c == 335 && PromptYesNo("Set dark theme?")) { editor.DarkTheme(false); SetupEditor(); ReadHlStyles(hlt.hlstyle); hlstyle_is_default = false; + hlt.hl_custom <<= true; + } + if(c == 336) { + auto v = GetAllChSkins(); + Ctrl::SetSkin(v[clamp((int)~ide.chstyle, 0, v.GetCount() - 1)].a); } } FileSetTime(ConfigFile("version"), ToTime(~ide.showtimeafter)); FinishConfig(); SaveConfig(); + auto v = GetAllChSkins(); + Ctrl::SetSkin(v[clamp(chstyle, 0, v.GetCount() - 1)].a); if(HasLibClang()) { for(int cpp = 0; cpp < 2; cpp++) { diff --git a/uppsrc/ide/UppHub.cpp b/uppsrc/ide/UppHub.cpp index 1c2376480..631d5316c 100644 --- a/uppsrc/ide/UppHub.cpp +++ b/uppsrc/ide/UppHub.cpp @@ -14,13 +14,20 @@ struct UppHubNest : Moveable { String branch; }; +static Color s_Make(Color c) { return Blend(SColorPaper(), c, IsDarkTheme() ? 60 : 20); } + Color StatusPaper(const String& status) { - return Blend(SColorPaper(), decode(status, "broken", SLtRed(), - "experimental", SLtYellow(), - "stable", SLtGreen(), - "rolling", SLtCyan(), - SColorPaper()), IsDarkTheme() ? 60 : 20); + static SColor broken([] { return s_Make(SLtRed()); }); + static SColor experimental([] { return s_Make(SLtYellow()); }); + static SColor stable([] { return s_Make(SLtGreen()); }); + static SColor rolling([] { return s_Make(SLtCyan()); }); + + return decode(status, "broken", broken, + "experimental", experimental, + "stable", stable, + "rolling", rolling, + SColorPaper()); } void VerifyUppHubRequirements() diff --git a/uppsrc/ide/UppWspc.cpp b/uppsrc/ide/UppWspc.cpp index c781104b6..b3d99e778 100644 --- a/uppsrc/ide/UppWspc.cpp +++ b/uppsrc/ide/UppWspc.cpp @@ -128,15 +128,15 @@ void WorkspaceWork::ScanWorkspace() { fnt.Bold(); if(pi.italic) fnt.Italic(); - package.Add(pk, Null, fnt, Nvl(AdjustIfDark(pi.ink), SColorText()), false, 0, Null, SColorMark); + package.Add(pk, Null, fnt, Nvl(AColor(pi.ink), SColorText()), false, 0, Null, SColorMark); } if(!organizer) { if(main.GetCount()) - package.Add(prjaux, IdeImg::PrjAux(), ListFont(), AdjustIfDark(Magenta)); - package.Add(ideaux, IdeImg::IdeAux(), ListFont(), AdjustIfDark(Magenta)); - package.Add(tempaux, IdeImg::TempAux(), ListFont(), AdjustIfDark(Magenta)); + package.Add(prjaux, IdeImg::PrjAux(), ListFont(), AColor(Magenta())); + package.Add(ideaux, IdeImg::IdeAux(), ListFont(), AColor(Magenta())); + package.Add(tempaux, IdeImg::TempAux(), ListFont(), AColor(Magenta())); if(main.GetCount()) - package.Add(METAPACKAGE, IdeImg::Meta(), ListFont(), AdjustIfDark(Red)); + package.Add(METAPACKAGE, IdeImg::Meta(), ListFont(), AColor(Red())); } package.SetCursor(0); diff --git a/uppsrc/ide/ide.h b/uppsrc/ide/ide.h index c4601bc24..7cfaf34d4 100644 --- a/uppsrc/ide/ide.h +++ b/uppsrc/ide/ide.h @@ -380,6 +380,7 @@ public: virtual void DeactivateBy(Ctrl *new_focus); virtual void Activate(); virtual void Layout(); + virtual void Skin(); virtual bool IsVerbose() const; virtual void PutConsole(const char *s); @@ -640,7 +641,6 @@ public: bool deactivate_save; int insert_include; int bordercolumn; - Color bordercolor; bool persistent_find_replace; bool find_replace_restore_pos; int spellcheck_comments; @@ -672,6 +672,7 @@ public: byte hilite_scope; int hilite_bracket; int hilite_ifdef; + bool hl_custom = false; bool barline; bool qtfsel; diff --git a/uppsrc/ide/ide.lay b/uppsrc/ide/ide.lay index 7004b0634..628613c60 100644 --- a/uppsrc/ide/ide.lay +++ b/uppsrc/ide/ide.lay @@ -530,22 +530,25 @@ LAYOUT(SetupFontLayout, 528, 312) ITEM(Upp::Button, defaults, SetLabel(t_("Restore defaults")).RightPosZ(8, 116).BottomPosZ(4, 24)) END_LAYOUT -LAYOUT(SetupHlLayout, 544, 344) - ITEM(Upp::ArrayCtrl, hlstyle, LeftPosZ(4, 360).VSizePosZ(4, 8)) +LAYOUT(SetupHlLayout, 544, 364) + ITEM(Upp::ArrayCtrl, hlstyle, LeftPosZ(4, 360).VSizePosZ(4, 4)) ITEM(Upp::Label, dv___1, SetLabel(t_("Scope highlighting")).LeftPosZ(372, 160).TopPosZ(4, 16)) ITEM(Upp::Switch, hilite_scope, SetLabel(t_("None\n2 colors\n5 colors")).LeftPosZ(372, 188).TopPosZ(20, 20)) ITEM(Upp::Label, dv___3, SetLabel(t_("Matching bracket highlighting")).LeftPosZ(372, 160).TopPosZ(52, 16)) ITEM(Upp::Switch, hilite_bracket, SetLabel(t_("None\nNormal\nFlashing")).LeftPosZ(372, 180).TopPosZ(68, 20)) ITEM(Upp::Label, dv___5, SetLabel(t_("#else/#elif/#endif info")).LeftPosZ(372, 160).TopPosZ(100, 16)) ITEM(Upp::Switch, hilite_ifdef, SetLabel(t_("None\nNormal\nWith line number")).LeftPosZ(372, 196).TopPosZ(120, 60)) - ITEM(Upp::Option, hilite_if_endif, SetLabel(t_("#if/#endif tracing")).LeftPosZ(372, 160).TopPosZ(184, 18)) - ITEM(Upp::Option, thousands_separator, SetLabel(t_("Thousands separator")).LeftPosZ(372, 160).TopPosZ(204, 18)) - ITEM(Upp::Option, hline, SetLabel(t_("Line")).LeftPosZ(432, 160).TopPosZ(228, 18)) - ITEM(Upp::Option, vline, SetLabel(t_("Column")).LeftPosZ(472, 84).TopPosZ(228, 18)) - ITEM(Upp::Button, hl_restore, SetLabel(t_("Restore default colors")).HSizePosZ(368, 4).BottomPosZ(56, 20)) - ITEM(Upp::Button, hl_restore_dark, SetLabel(t_("Dark theme")).HSizePosZ(368, 4).BottomPosZ(8, 20)) - ITEM(Upp::Button, hl_restore_white, SetLabel(t_("White theme")).HSizePosZ(368, 4).BottomPosZ(32, 20)) - ITEM(Upp::Label, dv___14, SetLabel(t_("Current")).LeftPosZ(372, 40).TopPosZ(228, 18)) + ITEM(Upp::Option, hilite_if_endif, SetLabel(t_("#if/#endif tracing")).LeftPosZ(372, 160).TopPosZ(180, 18)) + ITEM(Upp::Option, thousands_separator, SetLabel(t_("Thousands separator")).LeftPosZ(372, 160).TopPosZ(200, 18)) + ITEM(Upp::Option, hline, SetLabel(t_("Line")).LeftPosZ(432, 160).TopPosZ(224, 18)) + ITEM(Upp::Option, vline, SetLabel(t_("Column")).LeftPosZ(472, 84).TopPosZ(224, 18)) + ITEM(Upp::Button, hl_restore, SetLabel(t_("Restore default colors")).HSizePosZ(368, 4).BottomPosZ(52, 20)) + ITEM(Upp::Button, hl_restore_dark, SetLabel(t_("Dark theme")).HSizePosZ(368, 4).BottomPosZ(4, 20)) + ITEM(Upp::Button, hl_restore_white, SetLabel(t_("White theme")).HSizePosZ(368, 4).BottomPosZ(28, 20)) + ITEM(Upp::Label, dv___14, SetLabel(t_("Current")).LeftPosZ(372, 40).TopPosZ(224, 18)) + ITEM(Upp::Option, hl_custom, SetLabel(t_("Custom colors")).LeftPosZ(372, 172).VSizePosZ(272, 76)) + ITEM(Upp::Label, dv___16, SetLabel(t_("Paint line at column")).HSizePosZ(372, 64).TopPosZ(248, 19)) + ITEM(Upp::EditIntSpin, bordercolumn, Min(0).LeftPosZ(484, 52).TopPosZ(248, 19)) END_LAYOUT LAYOUT(SetupEditorLayout, 544, 344) @@ -553,37 +556,34 @@ LAYOUT(SetupEditorLayout, 544, 344) ITEM(Upp::EditIntSpin, tabsize, LeftPosZ(116, 52).TopPosZ(4, 19)) ITEM(Upp::Label, dv___2, SetLabel(t_("Indent")).LeftPosZ(4, 108).TopPosZ(24, 19)) ITEM(Upp::EditIntSpin, indent_amount, LeftPosZ(116, 52).TopPosZ(24, 19)) - ITEM(Upp::Label, dv___4, SetLabel(t_("Paint line at column")).HSizePosZ(4, 432).TopPosZ(44, 19)) - ITEM(Upp::EditIntSpin, bordercolumn, Min(0).LeftPosZ(116, 52).TopPosZ(44, 19)) - ITEM(Upp::ColorPusher, bordercolor, LeftPosZ(172, 48).TopPosZ(44, 20)) - ITEM(Upp::Label, dv___7, SetLabel(t_("Default charset")).LeftPosZ(4, 108).TopPosZ(64, 19)) - ITEM(Upp::DropList, charset, LeftPosZ(116, 104).TopPosZ(64, 19)) - ITEM(Upp::Label, dv___9, SetLabel(t_("Line endings")).LeftPosZ(4, 108).TopPosZ(84, 19)) - ITEM(Upp::DropList, lineends, LeftPosZ(116, 160).TopPosZ(84, 19)) - ITEM(Upp::Option, showtabs, SetLabel(t_("Show tabs and line endings")).LeftPosZ(4, 272).TopPosZ(108, 16)) - ITEM(Upp::Option, showspaces, SetLabel(t_("Show spaces")).LeftPosZ(4, 272).TopPosZ(124, 16)) - ITEM(Upp::Option, warnwhitespace, SetLabel(t_("Show possibly misplaced tabs and spaces")).LeftPosZ(4, 272).TopPosZ(140, 16)) - ITEM(Upp::Option, indent_spaces, SetLabel(t_("Indent using spaces")).HSizePosZ(4, 268).TopPosZ(156, 16)) - ITEM(Upp::Option, no_parenthesis_indent, SetLabel(t_("No indent after parenthesis")).LeftPosZ(4, 272).TopPosZ(172, 16)) - ITEM(Upp::Option, numbers, SetLabel(t_("Show line numbers")).LeftPosZ(4, 272).TopPosZ(188, 16)) - ITEM(Upp::Option, bookmark_pos, SetLabel(t_("Bookmarks restore position")).LeftPosZ(4, 272).TopPosZ(204, 16)) - ITEM(Upp::Option, findpicksel, SetLabel(t_("Find picks selection")).LeftPosZ(4, 272).TopPosZ(220, 16)) - ITEM(Upp::Option, findpicktext, SetLabel(t_("Find picks selection or text")).LeftPosZ(4, 272).TopPosZ(236, 16)) - ITEM(Upp::Option, deactivate_save, SetLabel(t_("Save file on TheIde window deactivation")).LeftPosZ(4, 272).TopPosZ(252, 16)) - ITEM(Upp::Option, persistent_find_replace, SetLabel(t_("Do not close Find/Replace dialog automatically")).LeftPosZ(4, 272).TopPosZ(268, 16)) - ITEM(Upp::Option, find_replace_restore_pos, SetLabel(t_("Restore position on canceling incremental search")).LeftPosZ(4, 272).TopPosZ(284, 16)) - ITEM(Upp::Option, block_caret, SetLabel(t_("Full block caret")).LeftPosZ(4, 272).TopPosZ(300, 16)) - ITEM(Upp::Option, bar_branch, SetLabel(t_("Show git branch in editor bar")).LeftPosZ(4, 372).TopPosZ(316, 16)) + ITEM(Upp::Label, dv___4, SetLabel(t_("Default charset")).LeftPosZ(4, 108).TopPosZ(44, 19)) + ITEM(Upp::DropList, charset, LeftPosZ(116, 104).TopPosZ(44, 19)) + ITEM(Upp::Label, dv___6, SetLabel(t_("Line endings")).LeftPosZ(4, 108).TopPosZ(64, 19)) + ITEM(Upp::DropList, lineends, LeftPosZ(116, 160).TopPosZ(64, 19)) + ITEM(Upp::Option, showtabs, SetLabel(t_("Show tabs and line endings")).LeftPosZ(4, 272).TopPosZ(88, 16)) + ITEM(Upp::Option, showspaces, SetLabel(t_("Show spaces")).LeftPosZ(4, 272).TopPosZ(104, 16)) + ITEM(Upp::Option, warnwhitespace, SetLabel(t_("Show possibly misplaced tabs and spaces")).LeftPosZ(4, 272).TopPosZ(120, 16)) + ITEM(Upp::Option, indent_spaces, SetLabel(t_("Indent using spaces")).HSizePosZ(4, 268).TopPosZ(136, 16)) + ITEM(Upp::Option, no_parenthesis_indent, SetLabel(t_("No indent after parenthesis")).LeftPosZ(4, 272).TopPosZ(152, 16)) + ITEM(Upp::Option, numbers, SetLabel(t_("Show line numbers")).LeftPosZ(4, 272).TopPosZ(168, 16)) + ITEM(Upp::Option, bookmark_pos, SetLabel(t_("Bookmarks restore position")).LeftPosZ(4, 272).TopPosZ(184, 16)) + ITEM(Upp::Option, findpicksel, SetLabel(t_("Find picks selection")).LeftPosZ(4, 272).TopPosZ(200, 16)) + ITEM(Upp::Option, findpicktext, SetLabel(t_("Find picks selection or text")).LeftPosZ(4, 272).TopPosZ(216, 16)) + ITEM(Upp::Option, deactivate_save, SetLabel(t_("Save file on TheIde window deactivation")).LeftPosZ(4, 272).TopPosZ(232, 16)) + ITEM(Upp::Option, persistent_find_replace, SetLabel(t_("Do not close Find/Replace dialog automatically")).LeftPosZ(4, 272).TopPosZ(248, 16)) + ITEM(Upp::Option, find_replace_restore_pos, SetLabel(t_("Restore position on canceling incremental search")).LeftPosZ(4, 272).TopPosZ(264, 16)) + ITEM(Upp::Option, block_caret, SetLabel(t_("Full block caret")).LeftPosZ(4, 272).TopPosZ(280, 16)) + ITEM(Upp::Option, bar_branch, SetLabel(t_("Show git branch in editor bar")).LeftPosZ(4, 272).TopPosZ(296, 16)) ITEM(Upp::Option, wordwrap_comments, SetLabel(t_("Wordwrap comments")).LeftPosZ(304, 224).TopPosZ(140, 16)) - ITEM(Upp::Label, dv___26, SetLabel(t_("File Tabs")).LeftPosZ(304, 64).TopPosZ(4, 19)) + ITEM(Upp::Label, dv___23, SetLabel(t_("File Tabs")).LeftPosZ(304, 64).TopPosZ(4, 19)) ITEM(Upp::DropList, filetabs, LeftPosZ(372, 64).TopPosZ(4, 19)) - ITEM(Upp::Label, dv___28, SetLabel(t_("Crosses")).LeftPosZ(304, 64).TopPosZ(24, 19)) + ITEM(Upp::Label, dv___25, SetLabel(t_("Crosses")).LeftPosZ(304, 64).TopPosZ(24, 19)) ITEM(Upp::DropList, tabs_crosses, LeftPosZ(372, 64).TopPosZ(24, 19)) ITEM(Upp::Option, tabs_icons, SetLabel(t_("Icons")).LeftPosZ(304, 132).TopPosZ(44, 16)) ITEM(Upp::Option, tabs_grouping, SetLabel(t_("Group by file folders")).LeftPosZ(304, 132).TopPosZ(60, 16)) ITEM(Upp::Option, tabs_stacking, SetLabel(t_("Stacking")).LeftPosZ(304, 132).TopPosZ(76, 16)) ITEM(Upp::Option, tabs_serialize, SetLabel(t_("Persistent tabs")).LeftPosZ(304, 132).TopPosZ(92, 16)) - ITEM(Upp::Label, dv___34, SetLabel(t_("Spellcheck comments")).LeftPosZ(304, 120).TopPosZ(116, 19)) + ITEM(Upp::Label, dv___31, SetLabel(t_("Spellcheck comments")).LeftPosZ(304, 120).TopPosZ(116, 19)) ITEM(Upp::DropList, spellcheck_comments, LeftPosZ(428, 92).TopPosZ(116, 19)) END_LAYOUT diff --git a/uppsrc/ide/idewin.cpp b/uppsrc/ide/idewin.cpp index 154094c41..1ff6e99dc 100644 --- a/uppsrc/ide/idewin.cpp +++ b/uppsrc/ide/idewin.cpp @@ -4,6 +4,16 @@ #define IMAGEFILE #include +void Ide::Skin() +{ + SetToolBar(); + ScanWorkspace(); + if(!hl_custom) { + editor.DefaultHlStyles(); + UpdateFormat(); + } +} + void Ide::ToggleVerboseBuild() { console.verbosebuild = !console.verbosebuild; @@ -569,7 +579,6 @@ Ide::Ide() editor.NoCutLine(); bordercolumn = 96; - bordercolor = SColorFace(); state_icon = -1; diff --git a/uppsrc/ide/main.cpp b/uppsrc/ide/main.cpp index daa5645aa..a24096b78 100644 --- a/uppsrc/ide/main.cpp +++ b/uppsrc/ide/main.cpp @@ -223,6 +223,7 @@ void AppMain___() Ctrl::SetUHDEnabled(); Ctrl::SetDarkThemeEnabled(); + Ctrl::SkinChangeSensitive(); Ctrl::SetAppName("TheIDE"); SetLanguage(LNG_ENGLISH); diff --git a/upptst/RichTextNumbering/main.cpp b/upptst/RichTextNumbering/main.cpp index bfead0f3c..f422759ca 100644 --- a/upptst/RichTextNumbering/main.cpp +++ b/upptst/RichTextNumbering/main.cpp @@ -15,5 +15,5 @@ GUI_APP_MAIN win.Add(edit.SizePos()); win.Run(); - DDUMP(AsCString(edit.GetQTF())); + RDUMP(AsCString(edit.GetQTF())); } diff --git a/upptst/TestChStyle/TestChStyle.h b/upptst/TestChStyle/TestChStyle.h index 32b22d807..2d6144f49 100644 --- a/upptst/TestChStyle/TestChStyle.h +++ b/upptst/TestChStyle/TestChStyle.h @@ -14,6 +14,8 @@ struct Sample : public Ctrl { class TestChStyle : public WithTestChStyleLayout { public: + virtual void Skin(); + typedef TestChStyle CLASSNAME; ToolBar bar; diff --git a/upptst/TestChStyle/TestChStyle.lay b/upptst/TestChStyle/TestChStyle.lay index 1f865ae92..59988efcb 100644 --- a/upptst/TestChStyle/TestChStyle.lay +++ b/upptst/TestChStyle/TestChStyle.lay @@ -1,61 +1,62 @@ LAYOUT(TestChStyleLayout, 972, 492) - ITEM(OptionBox, dv___0, SetLabel(t_("OptionBox")).LeftPosZ(12, 140).TopPosZ(324, 128)) - ITEM(EditString, readonly, SetEditable(false).LeftPosZ(20, 80).TopPosZ(52, 19)) - ITEM(DropList, dl_readonly, SetEditable(false).LeftPosZ(108, 96).TopPosZ(52, 19)) - ITEM(WithDropChoice, dc_readonly, SetEditable(false).LeftPosZ(212, 96).TopPosZ(52, 19)) - ITEM(EditString, disabled, LeftPosZ(20, 80).TopPosZ(76, 19)) - ITEM(DropList, dl_disabled, LeftPosZ(108, 96).TopPosZ(76, 19)) - ITEM(WithDropChoice, dc_disabled, LeftPosZ(212, 96).TopPosZ(76, 19)) - ITEM(EditString, normal1, LeftPosZ(20, 80).TopPosZ(28, 19)) - ITEM(DropList, dl_normal1, LeftPosZ(108, 96).TopPosZ(28, 19)) - ITEM(WithDropChoice, dc_normal1, LeftPosZ(212, 96).TopPosZ(28, 19)) - ITEM(DropTime, dv___10, LeftPosZ(20, 120).TopPosZ(100, 19)) - ITEM(DropDate, dv___11, LeftPosZ(144, 104).TopPosZ(100, 19)) - ITEM(LabelBox, dv___12, SetLabel(t_("LabelBox")).LeftPosZ(316, 148).TopPosZ(24, 104)) - ITEM(Label, dv___13, SetLabel(t_("Label")).LeftPosZ(324, 40).TopPosZ(52, 19)) - ITEM(DropTime, tm_dis, LeftPosZ(20, 120).TopPosZ(124, 19)) - ITEM(DropDate, dt_dis, LeftPosZ(144, 104).TopPosZ(124, 19)) - ITEM(EditIntSpin, spin_sides, LeftPosZ(20, 64).TopPosZ(148, 19)) - ITEM(Option, dv___17, ThreeState(true).SetLabel(t_("Option")).LeftPosZ(92, 80).TopPosZ(148, 16)) - ITEM(EditIntSpin, dis1, LeftPosZ(20, 64).TopPosZ(172, 19)) - ITEM(Option, option1, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(168, 16)) - ITEM(Switch, dv___20, SetLabel(t_("One\nTwo")).LeftPosZ(176, 84).TopPosZ(148, 40)) - ITEM(Option, option2, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(188, 16)) - ITEM(EditIntSpin, dis2, LeftPosZ(20, 64).TopPosZ(196, 19)) - ITEM(Option, option3, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(208, 16)) - ITEM(Switch, switch1, SetLabel(t_("One\nTwo")).LeftPosZ(176, 84).TopPosZ(192, 40)) - ITEM(TabCtrl, tab, LeftPosZ(316, 150).TopPosZ(136, 100)) - ITEM(Label, dv___26, SetLabel(t_("This is label")).SetInk(Cyan).LeftPosZ(16, 168).TopPosZ(240, 19)) - ITEM(DropTime, dv___27, LeftPosZ(316, 120).TopPosZ(244, 19)) - ITEM(SliderCtrl, dv___28, LeftPosZ(16, 64).TopPosZ(272, 24)) - ITEM(Button, dis, SetLabel(t_("disabled")).LeftPosZ(88, 56).TopPosZ(272, 24)) - ITEM(ArrayCtrl, dv___30, LeftPosZ(260, 52).TopPosZ(188, 100)) - ITEM(ProgressIndicator, pi1, LeftPosZ(180, 192).TopPosZ(296, 12)) - ITEM(ProgressIndicator, pi2, LeftPosZ(180, 192).TopPosZ(312, 12)) - ITEM(ProgressIndicator, pi5, LeftPosZ(180, 192).TopPosZ(328, 24)) - ITEM(ProgressIndicator, pi3, LeftPosZ(380, 24).TopPosZ(296, 148)) - ITEM(ProgressIndicator, pi4, LeftPosZ(412, 24).TopPosZ(296, 148)) - ITEM(SliderCtrl, dv___36, LeftPosZ(180, 20).VCenterPosZ(80, 158)) + ITEM(Upp::OptionBox, dv___0, SetLabel(t_("OptionBox")).LeftPosZ(12, 140).TopPosZ(324, 128)) + ITEM(Upp::EditString, readonly, SetEditable(false).LeftPosZ(20, 80).TopPosZ(52, 19)) + ITEM(Upp::DropList, dl_readonly, SetEditable(false).LeftPosZ(108, 96).TopPosZ(52, 19)) + ITEM(Upp::WithDropChoice, dc_readonly, SetEditable(false).LeftPosZ(212, 96).TopPosZ(52, 19)) + ITEM(Upp::EditString, disabled, LeftPosZ(20, 80).TopPosZ(76, 19)) + ITEM(Upp::DropList, dl_disabled, LeftPosZ(108, 96).TopPosZ(76, 19)) + ITEM(Upp::WithDropChoice, dc_disabled, LeftPosZ(212, 96).TopPosZ(76, 19)) + ITEM(Upp::EditString, normal1, LeftPosZ(20, 80).TopPosZ(28, 19)) + ITEM(Upp::DropList, dl_normal1, LeftPosZ(108, 96).TopPosZ(28, 19)) + ITEM(Upp::WithDropChoice, dc_normal1, LeftPosZ(212, 96).TopPosZ(28, 19)) + ITEM(Upp::DropTime, dv___10, LeftPosZ(20, 120).TopPosZ(100, 19)) + ITEM(Upp::DropDate, dv___11, LeftPosZ(144, 104).TopPosZ(100, 19)) + ITEM(Upp::LabelBox, dv___12, SetLabel(t_("LabelBox")).LeftPosZ(316, 148).TopPosZ(24, 104)) + ITEM(Upp::Label, dv___13, SetLabel(t_("Label")).LeftPosZ(324, 40).TopPosZ(52, 19)) + ITEM(Upp::DropTime, tm_dis, LeftPosZ(20, 120).TopPosZ(124, 19)) + ITEM(Upp::DropDate, dt_dis, LeftPosZ(144, 104).TopPosZ(124, 19)) + ITEM(Upp::EditIntSpin, spin_sides, LeftPosZ(20, 64).TopPosZ(148, 19)) + ITEM(Upp::Option, dv___17, ThreeState(true).SetLabel(t_("Option")).LeftPosZ(92, 80).TopPosZ(148, 16)) + ITEM(Upp::EditIntSpin, dis1, LeftPosZ(20, 64).TopPosZ(172, 19)) + ITEM(Upp::Option, option1, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(168, 16)) + ITEM(Upp::Switch, dv___20, SetLabel(t_("One\nTwo")).LeftPosZ(176, 84).TopPosZ(148, 40)) + ITEM(Upp::Option, option2, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(188, 16)) + ITEM(Upp::EditIntSpin, dis2, LeftPosZ(20, 64).TopPosZ(196, 19)) + ITEM(Upp::Option, option3, ThreeState(true).SetLabel(t_("Disabled")).LeftPosZ(92, 80).TopPosZ(208, 16)) + ITEM(Upp::Switch, switch1, SetLabel(t_("One\nTwo")).LeftPosZ(176, 84).TopPosZ(192, 40)) + ITEM(Upp::TabCtrl, tab, LeftPosZ(316, 150).TopPosZ(136, 100)) + ITEM(Upp::Label, dv___26, SetLabel(t_("This is label")).SetInk(Upp::Cyan).LeftPosZ(16, 168).TopPosZ(240, 19)) + ITEM(Upp::DropTime, dv___27, LeftPosZ(316, 120).TopPosZ(244, 19)) + ITEM(Upp::SliderCtrl, dv___28, LeftPosZ(16, 64).TopPosZ(272, 24)) + ITEM(Upp::Button, dis, SetLabel(t_("disabled")).LeftPosZ(88, 56).TopPosZ(272, 24)) + ITEM(Upp::ArrayCtrl, dv___30, LeftPosZ(260, 52).TopPosZ(188, 100)) + ITEM(Upp::ProgressIndicator, pi1, LeftPosZ(180, 192).TopPosZ(296, 12)) + ITEM(Upp::ProgressIndicator, pi2, LeftPosZ(180, 192).TopPosZ(312, 12)) + ITEM(Upp::ProgressIndicator, pi5, LeftPosZ(180, 192).TopPosZ(328, 24)) + ITEM(Upp::ProgressIndicator, pi3, LeftPosZ(380, 24).TopPosZ(296, 148)) + ITEM(Upp::ProgressIndicator, pi4, LeftPosZ(412, 24).TopPosZ(296, 148)) + ITEM(Upp::SliderCtrl, dv___36, LeftPosZ(180, 20).VCenterPosZ(80, 158)) UNTYPED(sample, LeftPosZ(212, 160).TopPosZ(364, 80)) - ITEM(DropList, dl_empty, LeftPosZ(480, 96).TopPosZ(4, 19)) - ITEM(WithDropChoice, dc_empty, LeftPosZ(480, 96).TopPosZ(28, 19)) - ITEM(DataPusher, dv___40, LeftPosZ(480, 152).TopPosZ(52, 24)) - ITEM(EditString, es_error, LeftPosZ(480, 164).TopPosZ(80, 19)) - ITEM(WithDropChoice, dc_error, LeftPosZ(480, 96).TopPosZ(104, 19)) - ITEM(WithDropChoice, dc_error2, LeftPosZ(580, 96).TopPosZ(104, 19)) - ITEM(EditIntSpin, dv___44, LeftPosZ(476, 64).TopPosZ(132, 56)) - ITEM(EditIntSpin, dv___45, LeftPosZ(552, 36).TopPosZ(132, 19)) - ITEM(EditString, normal, LeftPosZ(492, 180).TopPosZ(204, 48)) - ITEM(DropList, dl_normal, LeftPosZ(492, 180).TopPosZ(256, 44)) - ITEM(WithDropChoice, dc_normal, LeftPosZ(492, 180).TopPosZ(304, 44)) - ITEM(ArrayCtrl, list, LeftPosZ(492, 176).TopPosZ(352, 136)) - ITEM(Button, ok, SetLabel(t_("OK")).LeftPosZ(304, 80).TopPosZ(464, 20)) - ITEM(Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(392, 80).TopPosZ(464, 20)) - ITEM(ColorPusher, color, LeftPosZ(152, 64).TopPosZ(264, 24)) - ITEM(DropTree, droptree, LeftPosZ(316, 120).TopPosZ(268, 19)) - ITEM(TreeCtrl, dv___54, LeftPosZ(696, 152).TopPosZ(12, 196)) - ITEM(RichTextView, dv___55, LeftPosZ(696, 152).TopPosZ(348, 136)) - ITEM(ColumnList, dv___56, LeftPosZ(696, 152).TopPosZ(212, 132)) - ITEM(DropList, skin, LeftPosZ(12, 164).TopPosZ(464, 19)) + ITEM(Upp::DropList, dl_empty, LeftPosZ(480, 96).TopPosZ(4, 19)) + ITEM(Upp::WithDropChoice, dc_empty, LeftPosZ(480, 96).TopPosZ(28, 19)) + ITEM(Upp::DataPusher, dv___40, LeftPosZ(480, 152).TopPosZ(52, 24)) + ITEM(Upp::EditString, es_error, LeftPosZ(480, 164).TopPosZ(80, 19)) + ITEM(Upp::WithDropChoice, dc_error, LeftPosZ(480, 96).TopPosZ(104, 19)) + ITEM(Upp::WithDropChoice, dc_error2, LeftPosZ(580, 96).TopPosZ(104, 19)) + ITEM(Upp::EditIntSpin, dv___44, LeftPosZ(476, 64).TopPosZ(132, 56)) + ITEM(Upp::EditIntSpin, dv___45, LeftPosZ(552, 36).TopPosZ(132, 19)) + ITEM(Upp::EditString, normal, LeftPosZ(492, 180).TopPosZ(204, 48)) + ITEM(Upp::DropList, dl_normal, LeftPosZ(492, 180).TopPosZ(256, 44)) + ITEM(Upp::WithDropChoice, dc_normal, LeftPosZ(492, 180).TopPosZ(304, 44)) + ITEM(Upp::ArrayCtrl, list, LeftPosZ(492, 176).TopPosZ(352, 136)) + ITEM(Upp::ArrayCtrl, list2, LeftPosZ(852, 116).TopPosZ(12, 196)) + ITEM(Upp::Button, ok, SetLabel(t_("OK")).LeftPosZ(304, 80).TopPosZ(464, 20)) + ITEM(Upp::Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(392, 80).TopPosZ(464, 20)) + ITEM(Upp::ColorPusher, color, LeftPosZ(152, 64).TopPosZ(264, 24)) + ITEM(Upp::DropTree, droptree, LeftPosZ(316, 120).TopPosZ(268, 19)) + ITEM(Upp::TreeCtrl, dv___55, LeftPosZ(696, 152).TopPosZ(12, 196)) + ITEM(Upp::RichTextView, dv___56, LeftPosZ(696, 152).TopPosZ(348, 136)) + ITEM(Upp::ColumnList, dv___57, LeftPosZ(696, 152).TopPosZ(212, 132)) + ITEM(Upp::DropList, skin, LeftPosZ(12, 164).TopPosZ(464, 19)) END_LAYOUT diff --git a/upptst/TestChStyle/main.cpp b/upptst/TestChStyle/main.cpp index ab5f6690b..2f2589634 100644 --- a/upptst/TestChStyle/main.cpp +++ b/upptst/TestChStyle/main.cpp @@ -14,26 +14,8 @@ void Dc(WithDropChoice& dc) dc <<= "Case1"; } -TestChStyle::TestChStyle() +void TestChStyle::Skin() { - AddFrame(menu); - menu.Sub("Something", [=](Bar& bar) { - bar.Add("Open..", [] { SelectFileOpen("*"); }); - bar.Add("Information..", [] { PromptOK("information."); }); - bar.Add("Exclamation..", [] { Exclamation("exclamation!"); }); - bar.Add("Question..", [] { PromptYesNo("question?"); }); - bar.Add("Error..", [] { ErrorYesNo("error?"); }); - bar.Add(false, "Disabled", [] {}); - static bool check; - bar.Add("Check", [] { check = !check; }).Check(check); - bar.Add("Check", CtrlImg::open(), [] { check = !check; }).Check(check); - static bool radio; - bar.Add("Radio", [] { radio = !radio; }).Radio(radio); - bar.Separator(); - bar.Sub("Submenu", [](Bar& bar) { bar.Add("Something", []{}); }); - }); - - AddFrame(bar); bar.Set([](Bar& bar) { bar.Add(CtrlImg::open(), [] { FileSelNative fs; @@ -65,6 +47,28 @@ TestChStyle::TestChStyle() PromptOK(~fs); }).Tip("This is test"); }); +} + +TestChStyle::TestChStyle() +{ + AddFrame(menu); + menu.Sub("Something", [=](Bar& bar) { + bar.Add("Open..", [] { SelectFileOpen("*"); }); + bar.Add("Information..", [] { PromptOK("information."); }); + bar.Add("Exclamation..", [] { Exclamation("exclamation!"); }); + bar.Add("Question..", [] { PromptYesNo("question?"); }); + bar.Add("Error..", [] { ErrorYesNo("error?"); }); + bar.Add(false, "Disabled", [] {}); + static bool check; + bar.Add("Check", [] { check = !check; }).Check(check); + bar.Add("Check", CtrlImg::open(), [] { check = !check; }).Check(check); + static bool radio; + bar.Add("Radio", [] { radio = !radio; }).Radio(radio); + bar.Separator(); + bar.Sub("Submenu", [](Bar& bar) { bar.Add("Something", []{}); }); + }); + + AddFrame(bar); CtrlLayoutOKCancel(*this, "Window title"); @@ -127,6 +131,7 @@ TestChStyle::TestChStyle() pi5.Percent(); list.HeaderObject().Absolute(); + list.OddRowColor(); list.AddColumn("Col", 50).Sorting(); list.AddColumn("Col", 50).Sorting(); list.AddColumn("Col", 50).Sorting(); @@ -135,6 +140,12 @@ TestChStyle::TestChStyle() list.Add("Some very very very long text to invoke DisplayPopup"); for(int i = 0; i < 50; i++) list.Add(i); + + list2.AddColumn("Col"); + list2.EvenRowColor(); + list2.OddRowColor(); + for(int i = 0; i < 50; i++) + list2.Add(i); es_error.Error(); es_error.NullText(CtrlImg::Computer());