Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'WX_3_0_BRANCH' into wxPy-3.0-branch

Browse Source
This commit is contained in:
Robin Dunn
2016-05-27 09:28:46 -07:00
parent a36e071cd4 90fa100623
commit acf7068995
14 changed files with 188 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/changes.txt
View File

@@ -581,6 +581,7 @@ All:
- Fix wxFileName::MakeRelativeTo() for directory relatively to itself. - Fix wxFileName::MakeRelativeTo() for directory relatively to itself.
- Fix wxLocale::IsOk() return true even if setting the locale failed. - Fix wxLocale::IsOk() return true even if setting the locale failed.
- Null-terminate wxApp::argv for compatibility with the real argv.
Unix: Unix:
@@ -614,6 +615,7 @@ wxGTK:
- Fix coordinates of wxSetCursorEvent propagated to parent windows. - Fix coordinates of wxSetCursorEvent propagated to parent windows.
- Fix GTK+ warnings when refreshing wxListCtrl items (Scott Talbert). - Fix GTK+ warnings when refreshing wxListCtrl items (Scott Talbert).
- Fix using wxHTTP and wxFTP from worker thread. - Fix using wxHTTP and wxFTP from worker thread.
- Make items selected from keyboard visible in wxListCtrl (Jonathan Dagresta).
wxMSW: wxMSW:

8
include/wx/cmdargs.h
View File

@@ -51,9 +51,11 @@ public:
if ( !m_argsA ) if ( !m_argsA )
{ {
const size_t count = m_args.size(); const size_t count = m_args.size();
m_argsA = new char *[count]; m_argsA = new char *[count + 1];
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
m_argsA[n] = wxStrdup(m_args[n].ToAscii()); m_argsA[n] = wxStrdup(m_args[n].ToAscii());
m_argsA[count] = NULL;
} }
return m_argsA; return m_argsA;
@@ -64,9 +66,11 @@ public:
if ( !m_argsW ) if ( !m_argsW )
{ {
const size_t count = m_args.size(); const size_t count = m_args.size();
m_argsW = new wchar_t *[count]; m_argsW = new wchar_t *[count + 1];
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
m_argsW[n] = wxStrdup(m_args[n].wc_str()); m_argsW[n] = wxStrdup(m_args[n].wc_str());
m_argsW[count] = NULL;
} }
return m_argsW; return m_argsW;

13
include/wx/math.h
View File

@@ -64,11 +64,18 @@
#ifdef __cplusplus #ifdef __cplusplus
/* Any C++11 compiler should provide isfinite() */ /*
Things are simple with C++11: we have everything we need in std.
Eventually we will only have this section and not the legacy stuff below.
*/
#if __cplusplus >= 201103 #if __cplusplus >= 201103
#include <cmath> #include <cmath>
#define wxFinite(x) std::isfinite(x) #define wxFinite(x) std::isfinite(x)
#elif defined(__VISUALC__) || defined(__BORLANDC__) || defined(__WATCOMC__) #define wxIsNaN(x) std::isnan(x)
#else /* C++98 */
#if defined(__VISUALC__) || defined(__BORLANDC__) || defined(__WATCOMC__)
#include <float.h> #include <float.h>
#define wxFinite(x) _finite(x) #define wxFinite(x) _finite(x)
#elif defined(__MINGW64_TOOLCHAIN__) || defined(__clang__) #elif defined(__MINGW64_TOOLCHAIN__) || defined(__clang__)
@@ -108,6 +115,8 @@
#define wxIsNaN(x) ((x) != (x)) #define wxIsNaN(x) ((x) != (x))
#endif #endif
#endif /* C++11/C++98 */
#ifdef __INTELC__ #ifdef __INTELC__
inline bool wxIsSameDouble(double x, double y) inline bool wxIsSameDouble(double x, double y)

34
src/expat/lib/xmlparse.c
View File

@@ -2439,11 +2439,11 @@ doContent(XML_Parser parser,
for (;;) { for (;;) {
int bufSize; int bufSize;
int convLen; int convLen;
XmlConvert(enc, const enum XML_Convert_Result convert_res = XmlConvert(enc,
&fromPtr, rawNameEnd, &fromPtr, rawNameEnd,
(ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1); (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
convLen = (int)(toPtr - (XML_Char *)tag->buf); convLen = (int)(toPtr - (XML_Char *)tag->buf);
if (fromPtr == rawNameEnd) { if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
tag->name.strLen = convLen; tag->name.strLen = convLen;
break; break;
} }
@@ -2664,11 +2664,11 @@ doContent(XML_Parser parser,
if (MUST_CONVERT(enc, s)) { if (MUST_CONVERT(enc, s)) {
for (;;) { for (;;) {
ICHAR *dataPtr = (ICHAR *)dataBuf; ICHAR *dataPtr = (ICHAR *)dataBuf;
XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s; *eventEndPP = s;
charDataHandler(handlerArg, dataBuf, charDataHandler(handlerArg, dataBuf,
(int)(dataPtr - (ICHAR *)dataBuf)); (int)(dataPtr - (ICHAR *)dataBuf));
if (s == next) if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break; break;
*eventPP = s; *eventPP = s;
} }
@@ -3274,11 +3274,11 @@ doCdataSection(XML_Parser parser,
if (MUST_CONVERT(enc, s)) { if (MUST_CONVERT(enc, s)) {
for (;;) { for (;;) {
ICHAR *dataPtr = (ICHAR *)dataBuf; ICHAR *dataPtr = (ICHAR *)dataBuf;
XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = next; *eventEndPP = next;
charDataHandler(handlerArg, dataBuf, charDataHandler(handlerArg, dataBuf,
(int)(dataPtr - (ICHAR *)dataBuf)); (int)(dataPtr - (ICHAR *)dataBuf));
if (s == next) if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break; break;
*eventPP = s; *eventPP = s;
} }
@@ -5356,6 +5356,7 @@ reportDefault(XML_Parser parser, const ENCODING *enc,
const char *s, const char *end) const char *s, const char *end)
{ {
if (MUST_CONVERT(enc, s)) { if (MUST_CONVERT(enc, s)) {
enum XML_Convert_Result convert_res;
const char **eventPP; const char **eventPP;
const char **eventEndPP; const char **eventEndPP;
if (enc == encoding) { if (enc == encoding) {
@@ -5368,11 +5369,11 @@ reportDefault(XML_Parser parser, const ENCODING *enc,
} }
do { do {
ICHAR *dataPtr = (ICHAR *)dataBuf; ICHAR *dataPtr = (ICHAR *)dataBuf;
XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s; *eventEndPP = s;
defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf)); defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
*eventPP = s; *eventPP = s;
} while (s != end); } while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
} }
else else
defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s)); defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
@@ -6177,8 +6178,8 @@ poolAppend(STRING_POOL *pool, const ENCODING *enc,
if (!pool->ptr && !poolGrow(pool)) if (!pool->ptr && !poolGrow(pool))
return NULL; return NULL;
for (;;) { for (;;) {
XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end); const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
if (ptr == end) if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
break; break;
if (!poolGrow(pool)) if (!poolGrow(pool))
return NULL; return NULL;
@@ -6262,8 +6263,13 @@ poolGrow(STRING_POOL *pool)
} }
} }
if (pool->blocks && pool->start == pool->blocks->s) { if (pool->blocks && pool->start == pool->blocks->s) {
int blockSize = (int)(pool->end - pool->start)*2; BLOCK *temp;
BLOCK *temp = (BLOCK *) int blockSize = (int)((unsigned)(pool->end - pool->start)*2U);
if (blockSize < 0)
return XML_FALSE;
temp = (BLOCK *)
pool->mem->realloc_fcn(pool->blocks, pool->mem->realloc_fcn(pool->blocks,
(offsetof(BLOCK, s) (offsetof(BLOCK, s)
+ blockSize * sizeof(XML_Char))); + blockSize * sizeof(XML_Char)));
@@ -6278,6 +6284,10 @@ poolGrow(STRING_POOL *pool)
else { else {
BLOCK *tem; BLOCK *tem;
int blockSize = (int)(pool->end - pool->start); int blockSize = (int)(pool->end - pool->start);
if (blockSize < 0)
return XML_FALSE;
if (blockSize < INIT_BLOCK_SIZE) if (blockSize < INIT_BLOCK_SIZE)
blockSize = INIT_BLOCK_SIZE; blockSize = INIT_BLOCK_SIZE;
else else

115
src/expat/lib/xmltok.c
View File

@@ -322,39 +322,55 @@ enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
UTF8_cval4 = 0xf0 UTF8_cval4 = 0xf0
}; };
static void PTRCALL static enum XML_Convert_Result PTRCALL
utf8_toUtf8(const ENCODING *enc, utf8_toUtf8(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
char **toP, const char *toLim) char **toP, const char *toLim)
{ {
enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
char *to; char *to;
const char *from; const char *from;
if (fromLim - *fromP > toLim - *toP) { if (fromLim - *fromP > toLim - *toP) {
/* Avoid copying partial characters. */ /* Avoid copying partial characters. */
res = XML_CONVERT_OUTPUT_EXHAUSTED;
for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--) for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
if (((unsigned char)fromLim[-1] & 0xc0) != 0x80) if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
break; break;
} }
for (to = *toP, from = *fromP; from != fromLim; from++, to++) for (to = *toP, from = *fromP; (from < fromLim) && (to < toLim); from++, to++)
*to = *from; *to = *from;
*fromP = from; *fromP = from;
*toP = to; *toP = to;
if ((to == toLim) && (from < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return res;
} }
static void PTRCALL static enum XML_Convert_Result PTRCALL
utf8_toUtf16(const ENCODING *enc, utf8_toUtf16(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) unsigned short **toP, const unsigned short *toLim)
{ {
enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
unsigned short *to = *toP; unsigned short *to = *toP;
const char *from = *fromP; const char *from = *fromP;
while (from != fromLim && to != toLim) { while (from < fromLim && to < toLim) {
switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) { switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
case BT_LEAD2: case BT_LEAD2:
if (fromLim - from < 2) {
res = XML_CONVERT_INPUT_INCOMPLETE;
break;
}
*to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f)); *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
from += 2; from += 2;
break; break;
case BT_LEAD3: case BT_LEAD3:
if (fromLim - from < 3) {
res = XML_CONVERT_INPUT_INCOMPLETE;
break;
}
*to++ = (unsigned short)(((from[0] & 0xf) << 12) *to++ = (unsigned short)(((from[0] & 0xf) << 12)
| ((from[1] & 0x3f) << 6) | (from[2] & 0x3f)); | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
from += 3; from += 3;
@@ -362,8 +378,14 @@ utf8_toUtf16(const ENCODING *enc,
case BT_LEAD4: case BT_LEAD4:
{ {
unsigned long n; unsigned long n;
if (to + 1 == toLim) if (toLim - to < 2) {
res = XML_CONVERT_OUTPUT_EXHAUSTED;
goto after; goto after;
}
if (fromLim - from < 4) {
res = XML_CONVERT_INPUT_INCOMPLETE;
goto after;
}
n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12) n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
| ((from[2] & 0x3f) << 6) | (from[3] & 0x3f); | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
n -= 0x10000; n -= 0x10000;
@@ -381,6 +403,7 @@ utf8_toUtf16(const ENCODING *enc,
after: after:
*fromP = from; *fromP = from;
*toP = to; *toP = to;
return res;
} }
#ifdef XML_NS #ifdef XML_NS
@@ -429,7 +452,7 @@ static const struct normal_encoding internal_utf8_encoding = {
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_) STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
}; };
static void PTRCALL static enum XML_Convert_Result PTRCALL
latin1_toUtf8(const ENCODING *enc, latin1_toUtf8(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
char **toP, const char *toLim) char **toP, const char *toLim)
@@ -437,30 +460,35 @@ latin1_toUtf8(const ENCODING *enc,
for (;;) { for (;;) {
unsigned char c; unsigned char c;
if (*fromP == fromLim) if (*fromP == fromLim)
break; return XML_CONVERT_COMPLETED;
c = (unsigned char)**fromP; c = (unsigned char)**fromP;
if (c & 0x80) { if (c & 0x80) {
if (toLim - *toP < 2) if (toLim - *toP < 2)
break; return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = (char)((c >> 6) | UTF8_cval2); *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
*(*toP)++ = (char)((c & 0x3f) | 0x80); *(*toP)++ = (char)((c & 0x3f) | 0x80);
(*fromP)++; (*fromP)++;
} }
else { else {
if (*toP == toLim) if (*toP == toLim)
break; return XML_CONVERT_OUTPUT_EXHAUSTED;
*(*toP)++ = *(*fromP)++; *(*toP)++ = *(*fromP)++;
} }
} }
} }
static void PTRCALL static enum XML_Convert_Result PTRCALL
latin1_toUtf16(const ENCODING *enc, latin1_toUtf16(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) unsigned short **toP, const unsigned short *toLim)
{ {
while (*fromP != fromLim && *toP != toLim) while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = (unsigned char)*(*fromP)++; *(*toP)++ = (unsigned char)*(*fromP)++;
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
} }
#ifdef XML_NS #ifdef XML_NS
@@ -487,13 +515,18 @@ static const struct normal_encoding latin1_encoding = {
STANDARD_VTABLE(sb_) STANDARD_VTABLE(sb_)
}; };
static void PTRCALL static enum XML_Convert_Result PTRCALL
ascii_toUtf8(const ENCODING *enc, ascii_toUtf8(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
char **toP, const char *toLim) char **toP, const char *toLim)
{ {
while (*fromP != fromLim && *toP != toLim) while (*fromP < fromLim && *toP < toLim)
*(*toP)++ = *(*fromP)++; *(*toP)++ = *(*fromP)++;
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
} }
#ifdef XML_NS #ifdef XML_NS
@@ -540,13 +573,14 @@ unicode_byte_type(char hi, char lo)
} }
#define DEFINE_UTF16_TO_UTF8(E) \ #define DEFINE_UTF16_TO_UTF8(E) \
static void PTRCALL \ static enum XML_Convert_Result PTRCALL \
E ## toUtf8(const ENCODING *enc, \ E ## toUtf8(const ENCODING *enc, \
const char **fromP, const char *fromLim, \ const char **fromP, const char *fromLim, \
char **toP, const char *toLim) \ char **toP, const char *toLim) \
{ \ { \
const char *from; \ const char *from = *fromP; \
for (from = *fromP; from != fromLim; from += 2) { \ fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \
for (; from < fromLim; from += 2) { \
int plane; \ int plane; \
unsigned char lo2; \ unsigned char lo2; \
unsigned char lo = GET_LO(from); \ unsigned char lo = GET_LO(from); \
@@ -556,7 +590,7 @@ E ## toUtf8(const ENCODING *enc, \
if (lo < 0x80) { \ if (lo < 0x80) { \
if (*toP == toLim) { \ if (*toP == toLim) { \
*fromP = from; \ *fromP = from; \
return; \ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \ } \
*(*toP)++ = lo; \ *(*toP)++ = lo; \
break; \ break; \
@@ -566,7 +600,7 @@ E ## toUtf8(const ENCODING *enc, \
case 0x4: case 0x5: case 0x6: case 0x7: \ case 0x4: case 0x5: case 0x6: case 0x7: \
if (toLim - *toP < 2) { \ if (toLim - *toP < 2) { \
*fromP = from; \ *fromP = from; \
return; \ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \ } \
*(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \ *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \
*(*toP)++ = ((lo & 0x3f) | 0x80); \ *(*toP)++ = ((lo & 0x3f) | 0x80); \
@@ -574,7 +608,7 @@ E ## toUtf8(const ENCODING *enc, \
default: \ default: \
if (toLim - *toP < 3) { \ if (toLim - *toP < 3) { \
*fromP = from; \ *fromP = from; \
return; \ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \ } \
/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \ /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
*(*toP)++ = ((hi >> 4) | UTF8_cval3); \ *(*toP)++ = ((hi >> 4) | UTF8_cval3); \
@@ -584,7 +618,11 @@ E ## toUtf8(const ENCODING *enc, \
case 0xD8: case 0xD9: case 0xDA: case 0xDB: \ case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
if (toLim - *toP < 4) { \ if (toLim - *toP < 4) { \
*fromP = from; \ *fromP = from; \
return; \ return XML_CONVERT_OUTPUT_EXHAUSTED; \
} \
if (fromLim - from < 4) { \
*fromP = from; \
return XML_CONVERT_INPUT_INCOMPLETE; \
} \ } \
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \ plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
*(*toP)++ = ((plane >> 2) | UTF8_cval4); \ *(*toP)++ = ((plane >> 2) | UTF8_cval4); \
@@ -600,20 +638,32 @@ E ## toUtf8(const ENCODING *enc, \
} \ } \
} \ } \
*fromP = from; \ *fromP = from; \
if (from < fromLim) \
return XML_CONVERT_INPUT_INCOMPLETE; \
else \
return XML_CONVERT_COMPLETED; \
} }
#define DEFINE_UTF16_TO_UTF16(E) \ #define DEFINE_UTF16_TO_UTF16(E) \
static void PTRCALL \ static enum XML_Convert_Result PTRCALL \
E ## toUtf16(const ENCODING *enc, \ E ## toUtf16(const ENCODING *enc, \
const char **fromP, const char *fromLim, \ const char **fromP, const char *fromLim, \
unsigned short **toP, const unsigned short *toLim) \ unsigned short **toP, const unsigned short *toLim) \
{ \ { \
enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */ \
/* Avoid copying first half only of surrogate */ \ /* Avoid copying first half only of surrogate */ \
if (fromLim - *fromP > ((toLim - *toP) << 1) \ if (fromLim - *fromP > ((toLim - *toP) << 1) \
&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \ && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
fromLim -= 2; \ fromLim -= 2; \
for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \ res = XML_CONVERT_INPUT_INCOMPLETE; \
} \
for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
*(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \ *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
if ((*toP == toLim) && (*fromP < fromLim)) \
return XML_CONVERT_OUTPUT_EXHAUSTED; \
else \
return res; \
} }
#define SET2(ptr, ch) \ #define SET2(ptr, ch) \
@@ -1292,7 +1342,7 @@ unknown_isInvalid(const ENCODING *enc, const char *p)
return (c & ~0xFFFF) || checkCharRefNumber(c) < 0; return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
} }
static void PTRCALL static enum XML_Convert_Result PTRCALL
unknown_toUtf8(const ENCODING *enc, unknown_toUtf8(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
char **toP, const char *toLim) char **toP, const char *toLim)
@@ -1303,21 +1353,21 @@ unknown_toUtf8(const ENCODING *enc,
const char *utf8; const char *utf8;
int n; int n;
if (*fromP == fromLim) if (*fromP == fromLim)
break; return XML_CONVERT_COMPLETED;
utf8 = uenc->utf8[(unsigned char)**fromP]; utf8 = uenc->utf8[(unsigned char)**fromP];
n = *utf8++; n = *utf8++;
if (n == 0) { if (n == 0) {
int c = uenc->convert(uenc->userData, *fromP); int c = uenc->convert(uenc->userData, *fromP);
n = XmlUtf8Encode(c, buf); n = XmlUtf8Encode(c, buf);
if (n > toLim - *toP) if (n > toLim - *toP)
break; return XML_CONVERT_OUTPUT_EXHAUSTED;
utf8 = buf; utf8 = buf;
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP] *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
- (BT_LEAD2 - 2)); - (BT_LEAD2 - 2));
} }
else { else {
if (n > toLim - *toP) if (n > toLim - *toP)
break; return XML_CONVERT_OUTPUT_EXHAUSTED;
(*fromP)++; (*fromP)++;
} }
do { do {
@@ -1326,13 +1376,13 @@ unknown_toUtf8(const ENCODING *enc,
} }
} }
static void PTRCALL static enum XML_Convert_Result PTRCALL
unknown_toUtf16(const ENCODING *enc, unknown_toUtf16(const ENCODING *enc,
const char **fromP, const char *fromLim, const char **fromP, const char *fromLim,
unsigned short **toP, const unsigned short *toLim) unsigned short **toP, const unsigned short *toLim)
{ {
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc); const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
while (*fromP != fromLim && *toP != toLim) { while (*fromP < fromLim && *toP < toLim) {
unsigned short c = uenc->utf16[(unsigned char)**fromP]; unsigned short c = uenc->utf16[(unsigned char)**fromP];
if (c == 0) { if (c == 0) {
c = (unsigned short) c = (unsigned short)
@@ -1344,6 +1394,11 @@ unknown_toUtf16(const ENCODING *enc,
(*fromP)++; (*fromP)++;
*(*toP)++ = c; *(*toP)++ = c;
} }
if ((*toP == toLim) && (*fromP < fromLim))
return XML_CONVERT_OUTPUT_EXHAUSTED;
else
return XML_CONVERT_COMPLETED;
} }
ENCODING * ENCODING *
@@ -1507,7 +1562,7 @@ initScan(const ENCODING * const *encodingTable,
{ {
const ENCODING **encPtr; const ENCODING **encPtr;
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
encPtr = enc->encPtr; encPtr = enc->encPtr;
if (ptr + 1 == end) { if (ptr + 1 == end) {

10
src/expat/lib/xmltok.h
View File

@@ -130,6 +130,12 @@ typedef int (PTRCALL *SCANNER)(const ENCODING *,
const char *, const char *,
const char **); const char **);
enum XML_Convert_Result {
XML_CONVERT_COMPLETED = 0,
XML_CONVERT_INPUT_INCOMPLETE = 1,
XML_CONVERT_OUTPUT_EXHAUSTED = 2 /* and therefore potentially input remaining as well */
};
struct encoding { struct encoding {
SCANNER scanners[XML_N_STATES]; SCANNER scanners[XML_N_STATES];
SCANNER literalScanners[XML_N_LITERAL_TYPES]; SCANNER literalScanners[XML_N_LITERAL_TYPES];
@@ -158,12 +164,12 @@ struct encoding {
const char *ptr, const char *ptr,
const char *end, const char *end,
const char **badPtr); const char **badPtr);
void (PTRCALL *utf8Convert)(const ENCODING *enc, enum XML_Convert_Result (PTRCALL *utf8Convert)(const ENCODING *enc,
const char **fromP, const char **fromP,
const char *fromLim, const char *fromLim,
char **toP, char **toP,
const char *toLim); const char *toLim);
void (PTRCALL *utf16Convert)(const ENCODING *enc, enum XML_Convert_Result (PTRCALL *utf16Convert)(const ENCODING *enc,
const char **fromP, const char **fromP,
const char *fromLim, const char *fromLim,
unsigned short **toP, unsigned short **toP,

62
src/expat/lib/xmltok_impl.c
View File

@@ -93,13 +93,13 @@ static int PTRCALL
PREFIX(scanComment)(const ENCODING *enc, const char *ptr, PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
if (ptr != end) { if (ptr < end) {
if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
ptr += MINBPC(enc); ptr += MINBPC(enc);
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr) INVALID_CASES(ptr, nextTokPtr)
case BT_MINUS: case BT_MINUS:
@@ -147,7 +147,7 @@ PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_PERCNT: case BT_PERCNT:
if (ptr + MINBPC(enc) == end) if (ptr + MINBPC(enc) == end)
@@ -233,7 +233,7 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF: case BT_S: case BT_CR: case BT_LF:
@@ -242,7 +242,7 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
ptr += MINBPC(enc); ptr += MINBPC(enc);
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr) INVALID_CASES(ptr, nextTokPtr)
case BT_QUEST: case BT_QUEST:
@@ -305,7 +305,7 @@ static int PTRCALL
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
size_t n = end - ptr; size_t n = end - ptr;
@@ -348,7 +348,7 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
ptr += MINBPC(enc); ptr += MINBPC(enc);
break; break;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \ #define LEAD_CASE(n) \
case BT_LEAD ## n: \ case BT_LEAD ## n: \
@@ -391,11 +391,11 @@ PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF: case BT_S: case BT_CR: case BT_LF:
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_CR: case BT_LF: case BT_S: case BT_CR: case BT_LF:
break; break;
@@ -432,7 +432,7 @@ static int PTRCALL
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
if (ptr != end) { if (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT: case BT_DIGIT:
case BT_HEX: case BT_HEX:
@@ -441,7 +441,7 @@ PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT: case BT_DIGIT:
case BT_HEX: case BT_HEX:
@@ -464,7 +464,7 @@ static int PTRCALL
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
if (ptr != end) { if (ptr < end) {
if (CHAR_MATCHES(enc, ptr, ASCII_x)) if (CHAR_MATCHES(enc, ptr, ASCII_x))
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
@@ -474,7 +474,7 @@ PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) { for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT: case BT_DIGIT:
break; break;
@@ -506,7 +506,7 @@ PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI: case BT_SEMI:
@@ -529,7 +529,7 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
#ifdef XML_NS #ifdef XML_NS
int hadColon = 0; int hadColon = 0;
#endif #endif
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS #ifdef XML_NS
@@ -716,7 +716,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
hadColon = 0; hadColon = 0;
#endif #endif
/* we have a start-tag */ /* we have a start-tag */
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS #ifdef XML_NS
@@ -740,7 +740,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
case BT_S: case BT_CR: case BT_LF: case BT_S: case BT_CR: case BT_LF:
{ {
ptr += MINBPC(enc); ptr += MINBPC(enc);
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_GT: case BT_GT:
@@ -785,7 +785,7 @@ static int PTRCALL
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr)
{ {
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
size_t n = end - ptr; size_t n = end - ptr;
@@ -832,7 +832,7 @@ PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
ptr += MINBPC(enc); ptr += MINBPC(enc);
break; break;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \ #define LEAD_CASE(n) \
case BT_LEAD ## n: \ case BT_LEAD ## n: \
@@ -895,7 +895,7 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_SEMI: case BT_SEMI:
@@ -921,7 +921,7 @@ PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_CR: case BT_LF: case BT_S: case BT_CR: case BT_LF: case BT_S:
@@ -941,7 +941,7 @@ PREFIX(scanLit)(int open, const ENCODING *enc,
const char *ptr, const char *end, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr)
{ {
while (ptr != end) { while (ptr < end) {
int t = BYTE_TYPE(enc, ptr); int t = BYTE_TYPE(enc, ptr);
switch (t) { switch (t) {
INVALID_CASES(ptr, nextTokPtr) INVALID_CASES(ptr, nextTokPtr)
@@ -973,7 +973,7 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr)
{ {
int tok; int tok;
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
size_t n = end - ptr; size_t n = end - ptr;
@@ -1141,7 +1141,7 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_GT: case BT_RPAR: case BT_COMMA: case BT_GT: case BT_RPAR: case BT_COMMA:
@@ -1204,10 +1204,10 @@ PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
const char *start; const char *start;
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
start = ptr; start = ptr;
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \ #define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break; case BT_LEAD ## n: ptr += n; break;
@@ -1262,10 +1262,10 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
const char *end, const char **nextTokPtr) const char *end, const char **nextTokPtr)
{ {
const char *start; const char *start;
if (ptr == end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
start = ptr; start = ptr;
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \ #define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break; case BT_LEAD ## n: ptr += n; break;
@@ -1326,7 +1326,7 @@ PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
end = ptr + n; end = ptr + n;
} }
} }
while (ptr != end) { while (ptr < end) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
INVALID_CASES(ptr, nextTokPtr) INVALID_CASES(ptr, nextTokPtr)
case BT_LT: case BT_LT:
@@ -1373,7 +1373,7 @@ PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
{ {
ptr += MINBPC(enc); ptr += MINBPC(enc);
end -= MINBPC(enc); end -= MINBPC(enc);
for (; ptr != end; ptr += MINBPC(enc)) { for (; ptr < end; ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT: case BT_DIGIT:
case BT_HEX: case BT_HEX:
@@ -1760,7 +1760,7 @@ PREFIX(updatePosition)(const ENCODING *enc,
case BT_CR: case BT_CR:
pos->lineNumber++; pos->lineNumber++;
ptr += MINBPC(enc); ptr += MINBPC(enc);
if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF) if (ptr < end && BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc); ptr += MINBPC(enc);
pos->columnNumber = (XML_Size)-1; pos->columnNumber = (XML_Size)-1;
break; break;

2
src/generic/datavgen.cpp
View File

@@ -4006,7 +4006,7 @@ bool wxDataViewMainWindow::TryAdvanceCurrentColumn(wxDataViewTreeNode *node, boo
{ {
if ( forward ) if ( forward )
{ {
m_currentCol = GetOwner()->GetColumnAt(1); m_currentCol = GetOwner()->GetColumnAt(0);
m_currentColSetByKeyboard = true; m_currentColSetByKeyboard = true;
RefreshRow(m_currentRow); RefreshRow(m_currentRow);
return true; return true;

1
src/generic/listctrl.cpp
View File

@@ -2994,6 +2994,7 @@ void wxListMainWindow::OnChar( wxKeyEvent &event )
SetItemState(item, SetItemState(item,
wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED, wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED,
wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED); wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED);
EnsureVisible(item);
// Reset the bell flag if it had been temporarily disabled // Reset the bell flag if it had been temporarily disabled
// before. // before.

7
src/gtk/cursor.cpp
View File

@@ -385,6 +385,9 @@ bool wxIsBusy()
void wxSetCursor( const wxCursor& cursor ) void wxSetCursor( const wxCursor& cursor )
{ {
g_globalCursor = cursor; if (cursor.IsOk() || g_globalCursor.IsOk())
SetGlobalCursor(cursor); {
g_globalCursor = cursor;
SetGlobalCursor(cursor);
}
} }

7
src/gtk/menu.cpp
View File

@@ -141,7 +141,12 @@ void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long st
m_menubar = gtk_menu_bar_new(); m_menubar = gtk_menu_bar_new();
if (style & wxMB_DOCKABLE) if ((style & wxMB_DOCKABLE)
#ifdef __WXGTK3__
// using GtkHandleBox prevents menubar from drawing with GTK+ >= 3.19.7
&& gtk_check_version(3,19,7)
#endif
)
{ {
m_widget = gtk_handle_box_new(); m_widget = gtk_handle_box_new();
gtk_container_add(GTK_CONTAINER(m_widget), m_menubar); gtk_container_add(GTK_CONTAINER(m_widget), m_menubar);

7
src/gtk/textctrl.cpp
View File

@@ -1823,16 +1823,13 @@ void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
GdkRGBA fg_orig, bg_orig; GdkRGBA fg_orig, bg_orig;
GtkStyleContext* context = gtk_widget_get_style_context(m_text); GtkStyleContext* context = gtk_widget_get_style_context(m_text);
gtk_style_context_save(context);
if (IsMultiLine()) if (IsMultiLine())
{
gtk_style_context_save(context);
gtk_style_context_add_class(context, GTK_STYLE_CLASS_VIEW); gtk_style_context_add_class(context, GTK_STYLE_CLASS_VIEW);
}
gtk_style_context_set_state(context, selectedFocused); gtk_style_context_set_state(context, selectedFocused);
gtk_style_context_get_color(context, selectedFocused, &fg_orig); gtk_style_context_get_color(context, selectedFocused, &fg_orig);
gtk_style_context_get_background_color(context, selectedFocused, &bg_orig); gtk_style_context_get_background_color(context, selectedFocused, &bg_orig);
if (IsMultiLine()) gtk_style_context_restore(context);
gtk_style_context_restore(context);
if (fg_ok) if (fg_ok)
gtk_widget_override_color(m_text, selectedFocused, &fg_orig); gtk_widget_override_color(m_text, selectedFocused, &fg_orig);

7
src/gtk/toolbar.cpp
View File

@@ -388,7 +388,12 @@ bool wxToolBar::Create( wxWindow *parent,
#endif #endif
GtkSetStyle(); GtkSetStyle();
if (style & wxTB_DOCKABLE) if ((style & wxTB_DOCKABLE)
#ifdef __WXGTK3__
// using GtkHandleBox prevents toolbar from drawing with GTK+ >= 3.19.7
&& gtk_check_version(3,19,7)
#endif
)
{ {
m_widget = gtk_handle_box_new(); m_widget = gtk_handle_box_new();

2
src/gtk/toplevel.cpp
View File

@@ -43,7 +43,9 @@
#define HAS_CLIENT_DECOR #define HAS_CLIENT_DECOR
#endif #endif
#ifdef GDK_WINDOWING_MIR #ifdef GDK_WINDOWING_MIR
extern "C" {
#include <gdk/gdkmir.h> #include <gdk/gdkmir.h>
}
#define HAS_CLIENT_DECOR #define HAS_CLIENT_DECOR
#endif #endif
#ifdef GDK_WINDOWING_BROADWAY #ifdef GDK_WINDOWING_BROADWAY