[Git][wxwidgets/wxwidgets][master] 13 commits: Add wxStaticTextBase::UpdateLabelOrig() and use it in all ports

[Vadim Zeitlin (@_VZ_)]

Vadim Zeitlin pushed to branch master at wxWidgets / wxWidgets


Commits:
cf9c120d by Vadim Zeitlin at 2025-10-31T15:50:13+01:00
Add wxStaticTextBase::UpdateLabelOrig() and use it in all ports

Stop modifying m_labelOrig directly in wxStaticText implementations, as
the base class needs to be aware of these changes and this function will
give it an opportunity to react to them.

No real changes yet.

- - - - -
48284877 by Vadim Zeitlin at 2025-10-31T16:03:59+01:00
Fix using outdated unwrapped label in wxStaticText

Since the changes of 65e8f2b7ca (Merge branch 'stattext-wrap',
2025-10-25), see #25925 and #25753, a wrong label could be displayed
after a sequence of calls to Wrap(), SetLabel() and Wrap() with a
different value again.

This was due to reusing outdated value of m_unwrappedLabel, even after
the actual label has changed, so the solution is to invalidate
m_unwrappedLabel in SetLabel(). Unfortunately, this results in some
rather ugly code in Wrap(), which now has to restore m_unwrappedLabel
after using it, but there doesn't seem to be any other way to do it
currently.

The ideal solution would be to separate setting the label at wx level
and the actually displayed label in different functions, but this
requires updating all ports and so won't be done for now.

See #25795.

- - - - -
66c54820 by Vadim Zeitlin at 2025-10-31T16:09:02+01:00
Simplify wxPropertyGridManager description box code

Use wxST_WRAP for the control which should wrap instead of calling
Wrap() manually.

No changes in behaviour.

Closes #25795.

- - - - -
2448754a by Blake-Madden at 2025-11-01T15:27:40+01:00
Forbid mistakenly creating wxColour from bool

Prevent the code doing this (almost surely unintentionally) from
compiling.

This required adding overloaded ctors to avoid ambiguity for the calls
that should compile.

See #25938.

- - - - -
9294eaba by Vadim Zeitlin at 2025-11-01T15:27:40+01:00
Use delegation for wxColour ctors from name too

No real changes, just use delegation for consistency with the other
ctors.

- - - - -
c7279d08 by Vadim Zeitlin at 2025-11-01T15:27:40+01:00
Fix outdated comment for DEFINE_STD_WXCOLOUR_CONSTRUCTORS()

Set() is not virtual, so don't say that it is.

- - - - -
3a83d2be by Vadim Zeitlin at 2025-11-01T15:27:40+01:00
Remove unnecessary wxColour::Init()

Initialize members in their declarations in the ports that need it and
remove separate Init() functions as well as wxColourBase::Init() which
was only needed to have something to call from the ctors in the ports
without their own Init().

No real changes, this is just a simplification.

- - - - -
229bf85a by Vadim Zeitlin at 2025-11-01T16:04:42+01:00
Remove unnecessary casts to float from wxOSX wxColourImpl

Just use a floating point constant instead of explicitly casting to
float.

- - - - -
d7b43b4f by Vadim Zeitlin at 2025-11-01T16:04:42+01:00
Get rid of DEFINE_STD_WXCOLOUR_CONSTRUCTORS() macro

This macro was always ugly and got even worse after the recent changes
adding many overloaded constructors to it, so refactor wxColour
declaration to avoid it: define port-specific wxColourImpl and inherit
the real wxColour from it, which allows us to define all these ctors in
a single place only.

There should be no changes for the existing code.

- - - - -
d4c8e395 by Eran Ifrah at 2025-11-01T16:06:17+01:00
Make menu commands in stc sample usable under macOS

On macOS, "Minimal editor" and "Document map" items placed in the
"Window" menu didn't appear in the (standard) "Window" menu at all and
so couldn't be accessed.

Temporarily work around this wxOSX bug by moving them to another menu.

Closes #25935.

Signed-off-by: Eran Ifrah <er...@codelite.org>

- - - - -
556943e7 by Vadim Zeitlin at 2025-11-01T16:08:25+01:00
Merge branch 'propgrid-fix-wrap'

Fix bug in wxStaticText affecting wxPropertyGrid and then change the
code in the latter to not rely on Wrap() at all and use wxST_WRAP
instead.

See #25941.

- - - - -
2d5f490e by Vadim Zeitlin at 2025-11-01T17:38:50+01:00
Fix broken rendering of wxGTK wxDataViewCtrl renderers

Fix wrong checks for RTL mode added in 07c1da23e2 (wxGTK: Fix
wxDataViewCustomRenderer in RTL layout, 2025-10-20).

See #25426.

Closes #25944.

- - - - -
b37a0bfb by Vadim Zeitlin at 2025-11-01T17:41:30+01:00
Merge branch 'explicit-colour-ctors'

Improve wxColour ctors.

See #25943.

- - - - -


28 changed files:

- docs/changes.txt
- include/wx/colour.h
- include/wx/generic/colour.h
- include/wx/gtk/colour.h
- include/wx/msw/colour.h
- include/wx/osx/core/colour.h
- include/wx/qt/colour.h
- include/wx/stattext.h
- include/wx/x11/colour.h
- samples/stc/stctest.cpp
- src/common/colourcmn.cpp
- src/common/stattextcmn.cpp
- src/generic/colour.cpp
- src/gtk/colour.cpp
- src/gtk/dataview.cpp
- src/gtk/stattext.cpp
- src/msw/colour.cpp
- src/msw/stattext.cpp
- src/osx/cocoa/colour.mm
- src/osx/core/colour.cpp
- src/osx/iphone/colour.mm
- src/osx/stattext_osx.cpp
- src/propgrid/manager.cpp
- src/qt/colour.cpp
- src/qt/stattext.cpp
- src/univ/stattext.cpp
- src/univ/themes/win32.cpp
- src/x11/colour.cpp


Changes:

=====================================
docs/changes.txt
=====================================
@@ -233,6 +233,11 @@ Changes in behaviour which may result in build errors
corresponding Scintilla doesn't have any return value, so it was changed
to return void, please update your code to not use its return value.

+- Code unintentionally and mistakenly using wxColour ctor from bool that
+ previously compiled doesn't compile any longer, please fix it to use either
+ the ctor from RGB value or from string explicitly.
+
+
3.3.2: (released 2025-??-??)
----------------------------



=====================================
include/wx/colour.h
=====================================
@@ -17,29 +17,6 @@

class WXDLLIMPEXP_FWD_CORE wxColour;

-// A macro to define the standard wxColour constructors:
-//
-// It avoids the need to repeat these lines across all colour.h files, since
-// Set() is a virtual function and thus cannot be called by wxColourBase ctors
-#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
-#define wxWXCOLOUR_CTOR_FROM_CHAR \
- wxColour(const char *colourName) { Init(); Set(colourName); }
-#else // wxNO_IMPLICIT_WXSTRING_ENCODING
-#define wxWXCOLOUR_CTOR_FROM_CHAR
-#endif
-#define DEFINE_STD_WXCOLOUR_CONSTRUCTORS \
- wxColour() { Init(); } \
- wxColour(ChannelType red, \
- ChannelType green, \
- ChannelType blue, \
- ChannelType alpha = wxALPHA_OPAQUE) \
- { Init(); Set(red, green, blue, alpha); } \
- wxColour(unsigned long colRGB) { Init(); Set(colRGB ); } \
- wxColour(const wxString& colourName) { Init(); Set(colourName); } \
- wxWXCOLOUR_CTOR_FROM_CHAR \
- wxColour(const wchar_t *colourName) { Init(); Set(colourName); }
-
-
// flags for wxColour -> wxString conversion (see wxColour::GetAsString)
enum {
wxC2S_NAME = 1, // return colour name, when possible
@@ -192,10 +169,6 @@ public:
wxDECLARE_VARIANT_OBJECT_EXPORTED(wxColour, WXDLLIMPEXP_CORE);

protected:
- // Some ports need Init() and while we don't, provide a stub so that the
- // ports which don't need it are not forced to define it
- void Init() { }
-
virtual void
InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a) = 0;

@@ -244,4 +217,41 @@ WXDLLIMPEXP_CORE bool wxFromString(const wxString& str, wxColourBase* col);

#define wxColor wxColour

+// Actual wxColour class, inheriting from the port-specific implementation
+// class and defining all the overloaded constructors.
+class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour : public wxColourImpl
+{
+public:
+ wxColour() = default;
+ wxColour(ChannelType red,
+ ChannelType green,
+ ChannelType blue,
+ ChannelType alpha = wxALPHA_OPAQUE)
+ { Set(red, green, blue, alpha); }
+ wxColour(unsigned long colRGB) { Set(colRGB); }
+ wxColour(long colRGB) : wxColour(static_cast<unsigned long>(colRGB)) {}
+ wxColour(unsigned int colRGB) : wxColour(static_cast<unsigned long>(colRGB)) {}
+ wxColour(int colRGB) : wxColour(static_cast<unsigned long>(colRGB)) {}
+ wxColour(const wxString& colourName) { Set(colourName); }
+ wxColour(const wchar_t *colourName) : wxColour(wxString(colourName)) {}
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
+ wxColour(const char *colourName) : wxColour(wxString(colourName)) {}
+#endif
+ wxColour(bool) = delete;
+
+ // Also inherit port-specific constructors from the base class, if any.
+ using wxColourImpl::wxColourImpl;
+
+ // And define copy constructor and assignment operator in this class too.
+ wxColour(const wxColour& col) : wxColourImpl(col) {}
+ wxColour& operator=(const wxColour& col)
+ {
+ wxColourImpl::operator=(col);
+ return *this;
+ }
+
+private:
+ wxDECLARE_DYNAMIC_CLASS(wxColour);
+};
+
#endif // _WX_COLOUR_H_BASE_


=====================================
include/wx/generic/colour.h
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/colour.h
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Julian Smart
// Created: 01/02/97
// Copyright: (c) Julian Smart
@@ -13,20 +13,20 @@
#include "wx/object.h"

// Colour
-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour: public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl: public wxColourBase
{
public:
// constructors
// ------------
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
+ wxColourImpl() = default;

// copy ctors and assignment operators
- wxColour(const wxColour& col)
+ wxColourImpl(const wxColourImpl& col)
{
*this = col;
}

- wxColour& operator=(const wxColour& col);
+ wxColourImpl& operator=(const wxColourImpl& col);

// accessors
virtual bool IsOk() const { return m_isInit; }
@@ -37,7 +37,7 @@ public:
unsigned char Alpha() const { return m_alpha; }

// comparison
- bool operator==(const wxColour& colour) const
+ bool operator==(const wxColourImpl& colour) const
{
return (m_red == colour.m_red &&
m_green == colour.m_green &&
@@ -46,25 +46,18 @@ public:
m_isInit == colour.m_isInit);
}

- bool operator!=(const wxColour& colour) const { return !(*this == colour); }
+ bool operator!=(const wxColourImpl& colour) const { return !(*this == colour); }

protected:
-
- // Helper function
- void Init();
-
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);

private:
- bool m_isInit;
- unsigned char m_red;
- unsigned char m_blue;
- unsigned char m_green;
- unsigned char m_alpha;
-
-private:
- wxDECLARE_DYNAMIC_CLASS(wxColour);
+ bool m_isInit = false;
+ unsigned char m_red = 0;
+ unsigned char m_blue = 0;
+ unsigned char m_green = 0;
+ unsigned char m_alpha = wxALPHA_OPAQUE;
};

#endif // _WX_GENERIC_COLOUR_H_


=====================================
include/wx/gtk/colour.h
=====================================
@@ -17,19 +17,20 @@ typedef struct _GdkRGBA GdkRGBA;
// wxColour
//-----------------------------------------------------------------------------

-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour : public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl : public wxColourBase
{
public:
- // constructors
+ wxColourImpl() = default;
+
+ // port-specific constructors
// ------------
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
- wxColour(const GdkColor& gdkColor);
+ wxColourImpl(const GdkColor& gdkColor);
#ifdef __WXGTK3__
- wxColour(const GdkRGBA& gdkRGBA);
+ wxColourImpl(const GdkRGBA& gdkRGBA);
#endif

- bool operator==(const wxColour& col) const;
- bool operator!=(const wxColour& col) const { return !(*this == col); }
+ bool operator==(const wxColourImpl& col) const;
+ bool operator!=(const wxColourImpl& col) const { return !(*this == col); }

unsigned char Red() const override;
unsigned char Green() const override;
@@ -48,8 +49,6 @@ public:
protected:
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) override;
-
- wxDECLARE_DYNAMIC_CLASS(wxColour);
};

#endif // _WX_GTK_COLOUR_H_


=====================================
include/wx/msw/colour.h
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/colour.h
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Julian Smart
// Created: 01/02/97
// Copyright: (c) Julian Smart
@@ -16,12 +16,12 @@
// Colour
// ----------------------------------------------------------------------------

-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour : public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl : public wxColourBase
{
public:
// constructors
// ------------
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
+ wxColourImpl() = default;

// accessors
// ---------
@@ -34,7 +34,7 @@ public:
unsigned char Alpha() const override { return m_alpha ; }

// comparison
- bool operator==(const wxColour& colour) const
+ bool operator==(const wxColourImpl& colour) const
{
return m_isInit == colour.m_isInit
&& m_red == colour.m_red
@@ -43,29 +43,23 @@ public:
&& m_alpha == colour.m_alpha;
}

- bool operator!=(const wxColour& colour) const { return !(*this == colour); }
+ bool operator!=(const wxColourImpl& colour) const { return !(*this == colour); }

WXCOLORREF GetPixel() const { return m_pixel; }

public:
- WXCOLORREF m_pixel;
+ WXCOLORREF m_pixel = 0;

protected:
- // Helper function
- void Init();
-
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) override;

private:
- bool m_isInit;
- unsigned char m_red;
- unsigned char m_blue;
- unsigned char m_green;
- unsigned char m_alpha;
-
-private:
- wxDECLARE_DYNAMIC_CLASS(wxColour);
+ bool m_isInit = false;
+ unsigned char m_red = 0;
+ unsigned char m_blue = 0;
+ unsigned char m_green = 0;
+ unsigned char m_alpha = wxALPHA_TRANSPARENT;
};

#endif // _WX_COLOUR_H_


=====================================
include/wx/osx/core/colour.h
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/colour.h
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Stefan Csomor
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
@@ -18,12 +18,12 @@
struct RGBColor;

// Colour
-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour: public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl: public wxColourBase
{
public:
// constructors
// ------------
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
+ wxColourImpl() = default;

// default copy ctor and dtor are ok

@@ -36,14 +36,14 @@ public:
virtual bool IsSolid() const override;

// comparison
- bool operator == (const wxColour& colour) const;
- bool operator != (const wxColour& colour) const { return !(*this == colour); }
+ bool operator == (const wxColourImpl& colour) const;
+ bool operator != (const wxColourImpl& colour) const { return !(*this == colour); }

// CoreGraphics CGColor
// --------------------

// This ctor does take ownership of the color.
- wxColour( CGColorRef col );
+ wxColourImpl( CGColorRef col );

// don't take ownership of the returned value
CGColorRef GetCGColor() const;
@@ -54,12 +54,12 @@ public:
#if wxOSX_USE_COCOA_OR_CARBON
// Quickdraw RGBColor
// ------------------
- wxColour(const RGBColor& col);
+ wxColourImpl(const RGBColor& col);
void GetRGBColor( RGBColor *col ) const;
#endif

// This ctor does not take ownership of the color.
- explicit wxColour(WXColor color);
+ explicit wxColourImpl(WXColor color);

WXColor OSXGetWXColor() const;
WXImage OSXGetWXPatternImage() const;
@@ -87,10 +87,6 @@ public:

virtual wxGDIRefData *CreateGDIRefData() const override;
wxNODISCARD virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const override;
-
-private:
-
- wxDECLARE_DYNAMIC_CLASS(wxColour);
};

class wxColourRefData : public wxGDIRefData


=====================================
include/wx/qt/colour.h
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/colour.h
-// Purpose: wxColour class implementation for wxQt
+// Purpose: wxColourImpl class for wxQt
// Author: Kolya Kosenko
// Created: 2010-05-12
// Copyright: (c) 2010 Kolya Kosenko
@@ -12,11 +12,11 @@

class QColor;

-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour : public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl : public wxColourBase
{
public:
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
- wxColour(const QColor& color);
+ wxColourImpl() = default;
+ wxColourImpl(const QColor& color);

virtual bool IsOk() const override { return m_valid; }

@@ -25,22 +25,22 @@ public:
ChannelType Blue() const override { return m_blue; }
ChannelType Alpha() const override { return m_alpha; }

- bool operator==(const wxColour& color) const;
- bool operator!=(const wxColour& color) const;
+ bool operator==(const wxColourImpl& color) const;
+ bool operator!=(const wxColourImpl& color) const;

int GetPixel() const;

QColor GetQColor() const;

protected:
- void Init();
virtual void InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a) override;

private:
- ChannelType m_red, m_green, m_blue, m_alpha;
- bool m_valid;
-
- wxDECLARE_DYNAMIC_CLASS(wxColour);
+ ChannelType m_red = 0,
+ m_green = 0,
+ m_blue = 0,
+ m_alpha = wxALPHA_TRANSPARENT;
+ bool m_valid = false;
};

#endif // _WX_QT_COLOUR_H_


=====================================
include/wx/stattext.h
=====================================
@@ -79,6 +79,13 @@ protected: // functions required for wxST_ELLIPSIZE_* support
// display.
void UpdateLabel();

+ // This helper function must be called to update m_labelOrig instead of
+ // doing it directly.
+ //
+ // It returns false if the label didn't change.
+ bool UpdateLabelOrig(const wxString& label);
+
+
// If m_currentWrap is non-zero, contains the label value before wrapping it.
// This is used to allow re-wrapping it at different widths. Note that
// wxControlBase::m_labelOrig is changed when Wrap() is called and so can't


=====================================
include/wx/x11/colour.h
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/x11/colour.h
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Julian Smart, Robert Roebling
// Created: 17/09/98
// Copyright: (c) Julian Smart, Robert Roebling
@@ -25,21 +25,19 @@ class WXDLLIMPEXP_FWD_CORE wxPaintDC;
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxWindow;

-class WXDLLIMPEXP_FWD_CORE wxColour;
-
//-----------------------------------------------------------------------------
-// wxColour
+// wxColourImpl
//-----------------------------------------------------------------------------

-class WXDLLIMPEXP_CORE wxWARN_UNUSED wxColour : public wxColourBase
+class WXDLLIMPEXP_CORE wxColourImpl : public wxColourBase
{
public:
// constructors
// ------------
- DEFINE_STD_WXCOLOUR_CONSTRUCTORS
+ wxColourImpl() = default;

- bool operator==(const wxColour& col) const;
- bool operator!=(const wxColour& col) const { return !(*this == col); }
+ bool operator==(const wxColourImpl& col) const;
+ bool operator!=(const wxColourImpl& col) const { return !(*this == col); }

unsigned char Red() const;
unsigned char Green() const;
@@ -59,9 +57,6 @@ protected:
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);

virtual bool FromString(const wxString& str);
-
-private:
- wxDECLARE_DYNAMIC_CLASS(wxColour);
};

#endif // _WX_COLOUR_H_


=====================================
samples/stc/stctest.cpp
=====================================
@@ -540,6 +540,9 @@ void AppFrame::CreateMenu ()
menuView->AppendCheckItem (myID_WHITESPACE, _("Show white&space"));
menuView->AppendSeparator();
menuView->Append (myID_USECHARSET, _("Use &code page of .."), menuCharset);
+ menuView->AppendSeparator();
+ menuView->Append(myID_WINDOW_MINIMAL, _("&Minimal editor"));
+ menuView->Append(myID_WINDOW_DOCMAP, _("Document &map\tF2"));

// Annotations menu
wxMenu* menuAnnotations = new wxMenu;
@@ -614,11 +617,6 @@ void AppFrame::CreateMenu ()
#endif
menuExtra->AppendCheckItem (myID_CUSTOM_POPUP, _("C&ustom context menu"));

- // Window menu
- wxMenu *menuWindow = new wxMenu;
- menuWindow->Append(myID_WINDOW_MINIMAL, _("&Minimal editor"));
- menuWindow->Append(myID_WINDOW_DOCMAP, _("Document &map\tF2"));
-
// Help menu
wxMenu *menuHelp = new wxMenu;
menuHelp->Append (wxID_ABOUT, _("&About ..\tCtrl+D"));
@@ -630,7 +628,6 @@ void AppFrame::CreateMenu ()
m_menuBar->Append (menuAnnotations, _("&Annotations"));
m_menuBar->Append (menuIndicators, _("&Indicators"));
m_menuBar->Append (menuExtra, _("E&xtra"));
- m_menuBar->Append (menuWindow, _("&Window"));
m_menuBar->Append (menuHelp, _("&Help"));
SetMenuBar (m_menuBar);



=====================================
src/common/colourcmn.cpp
=====================================
@@ -406,5 +406,3 @@ bool wxFromString(const wxString& str, wxColourBase *col)

return col->Set(str);
}
-
-


=====================================
src/common/stattextcmn.cpp
=====================================
@@ -263,18 +263,22 @@ void wxStaticTextBase::Wrap(int width)

m_currentWrap = width;

- // Allow for repeated calls to Wrap with different values
- if (m_unwrappedLabel.empty())
- {
- m_unwrappedLabel = GetLabel();
- }
- else
+ // Allow for repeated calls to Wrap() with different values by storing the
+ // original label, before wrapping it. We also need to preserve the value
+ // of the unwrapped label if it's already set because the calls to
+ // SetLabel() (including from inside wxLabelWrapper) reset it.
+ auto const unwrappedLabel = m_unwrappedLabel.empty()
+ ? GetLabel()
+ : m_unwrappedLabel;
+ if ( !m_unwrappedLabel.empty() )
{
SetLabel( m_unwrappedLabel );
}
wxLabelWrapper wrapper;
wrapper.WrapLabel(this, width);
InvalidateBestSize();
+
+ m_unwrappedLabel = unwrappedLabel;
}

wxSize
@@ -347,6 +351,20 @@ void wxStaticTextBase::AutoResizeIfNecessary()
SetSize(GetBestSize());
}

+bool wxStaticTextBase::UpdateLabelOrig(const wxString& label)
+{
+ if ( label == m_labelOrig )
+ return false;
+
+ m_labelOrig = label;
+
+ // We need to clear the existing unwrapped label as it doesn't correspond
+ // to the new value of the actual label any longer.
+ m_unwrappedLabel.clear();
+
+ return true;
+}
+
// ----------------------------------------------------------------------------
// wxStaticTextBase - generic implementation for wxST_ELLIPSIZE_* support
// ----------------------------------------------------------------------------


=====================================
src/generic/colour.cpp
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/generic/colour.cpp
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Julian Smart
// Created: 01/02/97
// Copyright: (c) Julian Smart
@@ -19,16 +19,7 @@

// Colour

-void wxColour::Init()
-{
- m_red =
- m_blue =
- m_green = 0;
- m_alpha = wxALPHA_OPAQUE;
- m_isInit = false;
-}
-
-void wxColour::InitRGBA(unsigned char r,
+void wxColourImpl::InitRGBA(unsigned char r,
unsigned char g,
unsigned char b,
unsigned char a)
@@ -40,7 +31,7 @@ void wxColour::InitRGBA(unsigned char r,
m_isInit = true;
}

-wxColour& wxColour::operator=(const wxColour& col)
+wxColourImpl& wxColourImpl::operator=(const wxColourImpl& col)
{
m_red = col.m_red;
m_green = col.m_green;


=====================================
src/gtk/colour.cpp
=====================================
@@ -16,7 +16,7 @@
#include "wx/math.h"

//-----------------------------------------------------------------------------
-// wxColour
+// wxColourImpl
//-----------------------------------------------------------------------------

class wxColourRefData : public wxGDIRefData
@@ -123,23 +123,23 @@ void wxColourRefData::AllocColour( GdkColormap *cmap )
#define SHIFT 8

#ifdef __WXGTK3__
-wxColour::wxColour(const GdkRGBA& gdkRGBA)
+wxColourImpl::wxColourImpl(const GdkRGBA& gdkRGBA)
{
m_refData = new wxColourRefData(gdkRGBA);
}

-wxColour::wxColour(const GdkColor& gdkColor)
+wxColourImpl::wxColourImpl(const GdkColor& gdkColor)
{
m_refData = new wxColourRefData(gdkColor);
}
#else
-wxColour::wxColour(const GdkColor& gdkColor)
+wxColourImpl::wxColourImpl(const GdkColor& gdkColor)
{
m_refData = new wxColourRefData(gdkColor.red, gdkColor.green, gdkColor.blue);
}
#endif

-bool wxColour::operator == ( const wxColour& col ) const
+bool wxColourImpl::operator == ( const wxColourImpl& col ) const
{
if (m_refData == col.m_refData)
return true;
@@ -161,7 +161,7 @@ bool wxColour::operator == ( const wxColour& col ) const
refData->m_alpha == that_refData->m_alpha;
}

-void wxColour::InitRGBA(unsigned char red, unsigned char green, unsigned char blue,
+void wxColourImpl::InitRGBA(unsigned char red, unsigned char green, unsigned char blue,
unsigned char alpha)
{
UnRef();
@@ -177,7 +177,7 @@ void wxColour::InitRGBA(unsigned char red, unsigned char green, unsigned char bl
#endif
}

-unsigned char wxColour::Red() const
+unsigned char wxColourImpl::Red() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -188,7 +188,7 @@ unsigned char wxColour::Red() const
#endif
}

-unsigned char wxColour::Green() const
+unsigned char wxColourImpl::Green() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -199,7 +199,7 @@ unsigned char wxColour::Green() const
#endif
}

-unsigned char wxColour::Blue() const
+unsigned char wxColourImpl::Blue() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -210,7 +210,7 @@ unsigned char wxColour::Blue() const
#endif
}

-unsigned char wxColour::Alpha() const
+unsigned char wxColourImpl::Alpha() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -218,14 +218,14 @@ unsigned char wxColour::Alpha() const
}

#ifndef __WXGTK3__
-void wxColour::CalcPixel( GdkColormap *cmap )
+void wxColourImpl::CalcPixel( GdkColormap *cmap )
{
if (!IsOk()) return;

M_COLDATA->AllocColour( cmap );
}

-int wxColour::GetPixel() const
+int wxColourImpl::GetPixel() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -233,7 +233,7 @@ int wxColour::GetPixel() const
}
#endif

-const GdkColor *wxColour::GetColor() const
+const GdkColor *wxColourImpl::GetColor() const
{
wxCHECK_MSG( IsOk(), nullptr, wxT("invalid colour") );

@@ -245,7 +245,7 @@ const GdkColor *wxColour::GetColor() const
}

#ifdef __WXGTK3__
-wxColour::operator const GdkRGBA*() const
+wxColourImpl::operator const GdkRGBA*() const
{
const GdkRGBA* c = nullptr;
if (IsOk())


=====================================
src/gtk/dataview.cpp
=====================================
@@ -1657,7 +1657,7 @@ gtk_wx_cell_renderer_render (GtkCellRenderer *renderer,
wxDataViewCustomRenderer::GTKRenderParams renderParams;
wxRect rect(wxRectFromGDKRect(cell_area));
#ifdef __WXGTK3__
- const bool isRTL = wxWindow::GTKGetLayout(widget);
+ const bool isRTL = wxWindow::GTKGetLayout(widget) == wxLayout_RightToLeft;
if (isRTL)
{
cairo_scale(cr, -1, 1);
@@ -2834,7 +2834,8 @@ void wxDataViewCustomRenderer::RenderText( const wxString &text,
cell_area.width -= xoffset;

#ifdef __WXGTK3__
- const bool isRTL = wxWindow::GTKGetLayout(m_renderParams->widget);
+ const bool isRTL =
+ wxWindow::GTKGetLayout(m_renderParams->widget) == wxLayout_RightToLeft;
if (isRTL)
{
cairo_save(m_renderParams->cr);


=====================================
src/gtk/stattext.cpp
=====================================
@@ -152,11 +152,9 @@ void wxStaticText::GTKDoSetLabel(GTKLabelSetter setter, const wxString& label)

void wxStaticText::SetLabel(const wxString& label)
{
- if ( label == m_labelOrig )
+ if ( !UpdateLabelOrig(label) )
return;

- m_labelOrig = label;
-
GTKDoSetLabel(&wxStaticText::GTKSetLabelForLabel, label);
}

@@ -168,7 +166,7 @@ bool wxStaticText::DoSetLabelMarkup(const wxString& markup)
if ( stripped.empty() && !markup.empty() )
return false;

- m_labelOrig = stripped;
+ UpdateLabelOrig(stripped);

GTKDoSetLabel(&wxStaticText::GTKSetLabelWithMarkupForLabel, markup);



=====================================
src/msw/colour.cpp
=====================================
@@ -23,18 +23,8 @@

// Colour

-void wxColour::Init()
-{
- m_isInit = false;
- m_pixel = 0;
- m_alpha =
- m_red =
- m_blue =
- m_green = 0;
-}
-
-void wxColour::InitRGBA(unsigned char r, unsigned char g, unsigned char b,
- unsigned char a)
+void wxColourImpl::InitRGBA(unsigned char r, unsigned char g, unsigned char b,
+ unsigned char a)
{
m_red = r;
m_green = g;


=====================================
src/msw/stattext.cpp
=====================================
@@ -217,7 +217,7 @@ wxStaticText::MSWHandleMessage(WXLRESULT *result,
void wxStaticText::SetLabel(const wxString& label)
{
// If the label doesn't really change, avoid flicker by not doing anything.
- if ( label == m_labelOrig )
+ if ( !UpdateLabelOrig(label) )
return;

#if wxUSE_MARKUP
@@ -248,10 +248,6 @@ void wxStaticText::SetLabel(const wxString& label)
updateStyle.Apply();
#endif // SS_ENDELLIPSIS

- // save the label in m_labelOrig with both the markup (if any) and
- // the mnemonics characters (if any)
- m_labelOrig = label;
-
#ifdef SS_ENDELLIPSIS
if ( updateStyle.IsOn(SS_ENDELLIPSIS) )
WXSetVisibleLabel(GetLabel());
@@ -298,7 +294,7 @@ bool wxStaticText::DoSetLabelMarkup(const wxString& markup)
if ( label.empty() && !markup.empty() )
return false;

- m_labelOrig = label;
+ UpdateLabelOrig(label);

// Don't do anything if the label didn't change.
if ( m_markupText && !m_markupText->SetMarkup(markup) )


=====================================
src/osx/cocoa/colour.mm
=====================================
@@ -182,17 +182,17 @@ WX_NSImage wxNSColorRefData::GetWXPatternImage() const
return nullptr;
}

-wxGDIRefData* wxColour::CreateGDIRefData() const
+wxGDIRefData* wxColourImpl::CreateGDIRefData() const
{
return new wxNSColorRefData(0.0, 0.0, 0.0);
}

-wxColour::wxColour(WX_NSColor col)
+wxColourImpl::wxColourImpl(WX_NSColor col)
{
m_refData = new wxNSColorRefData(col);
}

-wxColour::wxColour(CGColorRef col)
+wxColourImpl::wxColourImpl(CGColorRef col)
{
m_refData = new wxNSColorRefData([[NSColor colorWithCGColor:col] retain]);
// as per contract CGColorRef is not retained


=====================================
src/osx/core/colour.cpp
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/osx/core/colour.cpp
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Stefan Csomor
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
@@ -156,7 +156,7 @@ WXImage wxCGColorRefData::GetWXPatternImage() const
#define M_COLDATA static_cast<wxColourRefData*>(m_refData)

#if wxOSX_USE_COCOA_OR_CARBON
-wxColour::wxColour(const RGBColor& col)
+wxColourImpl::wxColourImpl(const RGBColor& col)
{
InitRGBA((float)(col.red / 65535.0), (float)(col.green / 65535.0),
(float)(col.blue / 65535.0), (float)1.0 );
@@ -164,7 +164,7 @@ wxColour::wxColour(const RGBColor& col)
#endif

#if !wxOSX_USE_COCOA_OR_IPHONE
-wxColour::wxColour(CGColorRef col)
+wxColourImpl::wxColourImpl(CGColorRef col)
{
wxASSERT_MSG(col != nullptr, "Invalid CoreGraphics Color");

@@ -172,35 +172,35 @@ wxColour::wxColour(CGColorRef col)
}
#endif

-wxColour::ChannelType wxColour::Red() const
+wxColourImpl::ChannelType wxColourImpl::Red() const
{
wxCHECK_MSG( IsOk(), 0, "invalid colour" );

return wxRound(M_COLDATA->Red() * 255.0);
}

-wxColour::ChannelType wxColour::Green() const
+wxColourImpl::ChannelType wxColourImpl::Green() const
{
wxCHECK_MSG( IsOk(), 0, "invalid colour" );

return wxRound(M_COLDATA->Green() * 255.0);
}

-wxColour::ChannelType wxColour::Blue() const
+wxColourImpl::ChannelType wxColourImpl::Blue() const
{
wxCHECK_MSG( IsOk(), 0, "invalid colour" );

return wxRound(M_COLDATA->Blue() * 255.0);
}

-wxColour::ChannelType wxColour::Alpha() const
+wxColourImpl::ChannelType wxColourImpl::Alpha() const
{
wxCHECK_MSG( IsOk(), 0, "invalid colour" );

return wxRound(M_COLDATA->Alpha() * 255.0);
}

-bool wxColour::IsSolid() const
+bool wxColourImpl::IsSolid() const
{
wxCHECK_MSG( IsOk(), false, "invalid colour" );

@@ -208,7 +208,7 @@ bool wxColour::IsSolid() const
}

#if wxOSX_USE_COCOA_OR_CARBON
-void wxColour::GetRGBColor(RGBColor* col) const
+void wxColourImpl::GetRGBColor(RGBColor* col) const
{
wxCHECK_RET( IsOk(), "invalid colour" );

@@ -218,28 +218,28 @@ void wxColour::GetRGBColor(RGBColor* col) const
}
#endif

-CGColorRef wxColour::GetCGColor() const
+CGColorRef wxColourImpl::GetCGColor() const
{
wxCHECK_MSG( IsOk(), nullptr, "invalid colour" );

return M_COLDATA->GetCGColor();
}

-WXColor wxColour::OSXGetWXColor() const
+WXColor wxColourImpl::OSXGetWXColor() const
{
wxCHECK_MSG( IsOk(), nullptr, "invalid colour" );

return M_COLDATA->GetWXColor();
}

-WXImage wxColour::OSXGetWXPatternImage() const
+WXImage wxColourImpl::OSXGetWXPatternImage() const
{
wxCHECK_MSG( IsOk(), nullptr, "invalid colour" );

return M_COLDATA->GetWXPatternImage();
}

-bool wxColour::operator==(const wxColour& other) const
+bool wxColourImpl::operator==(const wxColourImpl& other) const
{
if (m_refData == other.m_refData)
return true;
@@ -250,17 +250,17 @@ bool wxColour::operator==(const wxColour& other) const
return CGColorEqualToColor(GetCGColor(), other.GetCGColor());
}

-wxGDIRefData* wxColour::CloneGDIRefData(const wxGDIRefData* data) const
+wxGDIRefData* wxColourImpl::CloneGDIRefData(const wxGDIRefData* data) const
{
return static_cast<const wxColourRefData*>(data)->Clone();
}

-void wxColour::InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a)
+void wxColourImpl::InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a)
{
- InitRGBA((float)(r / 255.0), (float)(g / 255.0), (float)(b / 255.0), (float)(a / 255.0));
+ InitRGBA(r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f);
}

-void wxColour::InitRGBA(float r, float g, float b, float a)
+void wxColourImpl::InitRGBA(float r, float g, float b, float a)
{
UnRef();
m_refData = new wxCGColorRefData(r,g,b,a);


=====================================
src/osx/iphone/colour.mm
=====================================
@@ -177,17 +177,17 @@ WXImage wxUIColorRefData::GetWXPatternImage() const
return nullptr;
}

-wxGDIRefData* wxColour::CreateGDIRefData() const
+wxGDIRefData* wxColourImpl::CreateGDIRefData() const
{
return new wxUIColorRefData(0.0, 0.0, 0.0, 1.0);
}

-wxColour::wxColour(WXColor col)
+wxColourImpl::wxColourImpl(WXColor col)
{
m_refData = new wxUIColorRefData(col);
}

-wxColour::wxColour(CGColorRef col)
+wxColourImpl::wxColourImpl(CGColorRef col)
{
m_refData = new wxUIColorRefData([[UIColor colorWithCGColor:col] retain]);
// as per contract CGColorRef is not retained


=====================================
src/osx/stattext_osx.cpp
=====================================
@@ -57,11 +57,9 @@ bool wxStaticText::Create( wxWindow *parent,

void wxStaticText::SetLabel(const wxString& label)
{
- if ( label == m_labelOrig )
+ if ( !UpdateLabelOrig(label) )
return;

- m_labelOrig = label;
-
// middle/end ellipsization is handled by the OS:
if ( HasFlag(wxST_ELLIPSIZE_END) || HasFlag(wxST_ELLIPSIZE_MIDDLE)
#if wxOSX_USE_COCOA // Cocoa has all three modes


=====================================
src/propgrid/manager.cpp
=====================================
@@ -1475,7 +1475,6 @@ void wxPropertyGridManager::UpdateDescriptionBox( int new_splittery, int new_wid
}
else
{
- m_pTxtHelpCaption->Wrap(-1);
m_pTxtHelpCaption->Show( true );
if ( cnt_hei <= 2 )
{
@@ -1484,7 +1483,6 @@ void wxPropertyGridManager::UpdateDescriptionBox( int new_splittery, int new_wid
else
{
m_pTxtHelpContent->SetSize(3,cnt_y,use_width,cnt_hei);
- m_pTxtHelpContent->Wrap(use_width);
m_pTxtHelpContent->Show( true );
}
}
@@ -1841,7 +1839,9 @@ void wxPropertyGridManager::RecreateControls()
wxString(),
wxDefaultPosition,
wxDefaultSize,
- wxALIGN_LEFT|wxST_NO_AUTORESIZE);
+ wxALIGN_LEFT|
+ wxST_NO_AUTORESIZE|
+ wxST_WRAP);
m_pTxtHelpContent->SetCursor( *wxSTANDARD_CURSOR );
}



=====================================
src/qt/colour.cpp
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/qt/colour.cpp
-// Purpose: wxColour class implementation for wxQt
+// Purpose: wxColourImpl class for wxQt
// Author: Kolya Kosenko
// Created: 2010-05-12
// Copyright: (c) 2010 Kolya Kosenko
@@ -20,41 +20,35 @@

#include <QtGui/QColor>

-wxColour::wxColour(const QColor& color)
+wxColourImpl::wxColourImpl(const QColor& color)
{
InitRGBA(color.red(), color.green(), color.blue(), color.alpha());
}

-bool wxColour::operator==(const wxColour& color) const
+bool wxColourImpl::operator==(const wxColourImpl& color) const
{
return m_red == color.m_red && m_green == color.m_green && m_blue == color.m_blue && m_alpha == color.m_alpha;
}

-bool wxColour::operator!=(const wxColour& color) const
+bool wxColourImpl::operator!=(const wxColourImpl& color) const
{
return !(*this == color);
}

-int wxColour::GetPixel() const
+int wxColourImpl::GetPixel() const
{
- wxMISSING_IMPLEMENTATION( "wxColour::GetPixel" );
+ wxMISSING_IMPLEMENTATION( "wxColourImpl::GetPixel" );
return 0;
}

-QColor wxColour::GetQColor() const
+QColor wxColourImpl::GetQColor() const
{
if ( m_valid )
return QColor(m_red, m_green, m_blue, m_alpha);
return QColor();
}

-void wxColour::Init()
-{
- m_red = m_green = m_blue = m_alpha = 0;
- m_valid = false;
-}
-
-void wxColour::InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a)
+void wxColourImpl::InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a)
{
m_red = r; m_green = g; m_blue = b; m_alpha = a;
m_valid = true;


=====================================
src/qt/stattext.cpp
=====================================
@@ -91,13 +91,9 @@ QLabel* wxStaticText::GetQLabel() const
void wxStaticText::SetLabel(const wxString& label)
{
// If the label doesn't really change, avoid flicker by not doing anything.
- if ( label == m_labelOrig )
+ if ( !UpdateLabelOrig(label) )
return;

- // save the label in m_labelOrig with both the markup (if any) and
- // the mnemonics characters (if any)
- m_labelOrig = label;
-
WXSetVisibleLabel(GetEllipsizedLabel());

AutoResizeIfNecessary();


=====================================
src/univ/stattext.cpp
=====================================
@@ -66,12 +66,9 @@ void wxStaticText::DoDraw(wxControlRenderer *renderer)

void wxStaticText::SetLabel(const wxString& str)
{
- if ( str == m_labelOrig )
+ if ( !UpdateLabelOrig(str) )
return;

- // save original label
- m_labelOrig = str;
-
// draw as real label the abbreviated version of it
WXSetVisibleLabel(GetEllipsizedLabel());
}


=====================================
src/univ/themes/win32.cpp
=====================================
@@ -2214,7 +2214,7 @@ void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
"w ",
" w",
};
- dc.SetBrush(wxBrush(stipple_xpm));
+ dc.SetBrush(wxBitmap(stipple_xpm));

dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));


=====================================
src/x11/colour.cpp
=====================================
@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/x11/colour.cpp
-// Purpose: wxColour class
+// Purpose: wxColourImpl class
// Author: Julian Smart, Robert Roebling
// Created: 17/09/98
// Copyright: (c) Julian Smart, Robert Roebling
@@ -20,7 +20,7 @@
#include "wx/x11/private.h"

//-----------------------------------------------------------------------------
-// wxColour
+// wxColourImpl
//-----------------------------------------------------------------------------

class wxColourRefData : public wxGDIRefData
@@ -66,7 +66,7 @@ public:
WXColormap m_colormap;
bool m_hasPixel;

- friend class wxColour;
+ friend class wxColourImpl;

// reference counter for systems with <= 8-Bit display
static unsigned short colMapAllocCounter[ 256 ];
@@ -140,7 +140,7 @@ void wxColourRefData::AllocColour( WXColormap cmap )

#define SHIFT (8*(sizeof(short int)-sizeof(char)))

-bool wxColour::operator == ( const wxColour& col ) const
+bool wxColourImpl::operator == ( const wxColourImpl& col ) const
{
if (m_refData == col.m_refData) return true;

@@ -155,17 +155,17 @@ bool wxColour::operator == ( const wxColour& col ) const

}

-wxGDIRefData *wxColour::CreateGDIRefData() const
+wxGDIRefData *wxColourImpl::CreateGDIRefData() const
{
return new wxColourRefData;
}

-wxGDIRefData *wxColour::CloneGDIRefData(const wxGDIRefData *data) const
+wxGDIRefData *wxColourImpl::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxColourRefData(*(wxColourRefData *)data);
}

-void wxColour::InitRGBA(unsigned char red, unsigned char green, unsigned char blue,
+void wxColourImpl::InitRGBA(unsigned char red, unsigned char green, unsigned char blue,
unsigned char WXUNUSED(alpha))
{
UnRef();
@@ -183,7 +183,7 @@ void wxColour::InitRGBA(unsigned char red, unsigned char green, unsigned char bl
M_COLDATA->m_color.pixel = 0;
}

-unsigned char wxColour::Red() const
+unsigned char wxColourImpl::Red() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -194,7 +194,7 @@ unsigned char wxColour::Red() const
#endif
}

-unsigned char wxColour::Green() const
+unsigned char wxColourImpl::Green() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -205,7 +205,7 @@ unsigned char wxColour::Green() const
#endif
}

-unsigned char wxColour::Blue() const
+unsigned char wxColourImpl::Blue() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

@@ -216,7 +216,7 @@ unsigned char wxColour::Blue() const
#endif
}

-void wxColour::CalcPixel( WXColormap cmap )
+void wxColourImpl::CalcPixel( WXColormap cmap )
{
wxCHECK_RET( IsOk(), wxT("invalid colour") );

@@ -225,21 +225,21 @@ void wxColour::CalcPixel( WXColormap cmap )
M_COLDATA->AllocColour( cmap );
}

-unsigned long wxColour::GetPixel() const
+unsigned long wxColourImpl::GetPixel() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid colour") );

return M_COLDATA->m_color.pixel;
}

-WXColor *wxColour::GetColor() const
+WXColor *wxColourImpl::GetColor() const
{
wxCHECK_MSG( IsOk(), nullptr, wxT("invalid colour") );

return (WXColor*) &M_COLDATA->m_color;
}

-bool wxColour::FromString(const wxString& name)
+bool wxColourImpl::FromString(const wxString& name)
{
Display *dpy = wxGlobalDisplay();
WXColormap colormap = wxTheApp->GetMainColormap( dpy );



View it on GitLab: https://gitlab.com/wxwidgets/wxwidgets/-/compare/4bf58e23b69480166b34d326ce06385e6c97f916...b37a0bfbccdf6f4e51580490074c9cdd338ab357

--
View it on GitLab: https://gitlab.com/wxwidgets/wxwidgets/-/compare/4bf58e23b69480166b34d326ce06385e6c97f916...b37a0bfbccdf6f4e51580490074c9cdd338ab357
You're receiving this email because of your account on gitlab.com.