Lenheart
/
Magic_Game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

minor

This commit is contained in:
Nomango 2019-09-03 14:33:51 +08:00
parent 33f78bb5d5
commit 7e9a3f150b
6 changed files with 172 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/kiwano/2d/Canvas.h
View File

@ -163,17 +163,17 @@ namespace kiwano
Color const& color Color const& color
); );
// ﾉ靹ﾃﾏﾟﾌ<EFBFBD>ﾕﾉｫ // ﾉ靹ﾃﾂﾖﾀｪﾑﾕﾉｫ
void SetStrokeColor( void SetStrokeColor(
Color const& color Color const& color
); );
// ﾉ靹ﾃﾏﾟﾌ<EFBFBD>昮ﾈ // ﾉ靹ﾃﾂﾖﾀｪｿ昮ﾈ
void SetStrokeWidth( void SetStrokeWidth(
Float32 width Float32 width
); );
// ﾉ靹ﾃﾏﾟﾌ<EFBFBD><EFBFBD>ｽ // ﾉ靹ﾃﾂﾖﾀｪﾑ<EFBFBD>ｽ
void SetStrokeStyle( void SetStrokeStyle(
StrokeStyle stroke_style StrokeStyle stroke_style
); );
@ -222,10 +222,10 @@ namespace kiwano
// ťńČĄĚîłäŃŐÉŤ // ťńČĄĚîłäŃŐÉŤ
Color GetFillColor() const; Color GetFillColor() const;
// ｻ<>｡ﾏﾟﾌ<EFBFBD>ﾕﾉｫ // ｻ<>｡ﾂﾖﾀｪﾑﾕﾉｫ
Color GetStrokeColor() const; Color GetStrokeColor() const;
// ｻ<>｡ﾏﾟﾌ<EFBFBD>昮ﾈ // ｻ<>｡ﾂﾖﾀｪｿ昮ﾈ
Float32 GetStrokeWidth() const; Float32 GetStrokeWidth() const;
// ťńČĄť­ąĘ͸Ă÷śČ // ťńČĄť­ąĘ͸Ă÷śČ

6
src/kiwano/2d/Text.h
View File

@ -35,17 +35,17 @@ namespace kiwano
String const& text /* 文字内容 */ String const& text /* 文字内容 */
); );
explicit Text( Text(
String const& text, /* 文字内容 */ String const& text, /* 文字内容 */
const Font& font /* 字体 */ const Font& font /* 字体 */
); );
explicit Text( Text(
String const& text, /* 文字内容 */ String const& text, /* 文字内容 */
const TextStyle& style /* 文本样式 */ const TextStyle& style /* 文本样式 */
); );
explicit Text( Text(
String const& text, /* 文字内容 */ String const& text, /* 文字内容 */
const Font& font, /* 字体 */ const Font& font, /* 字体 */
const TextStyle& style /* 文本样式 */ const TextStyle& style /* 文本样式 */

223
src/kiwano/core/string.hpp
View File

@ -35,7 +35,7 @@ inline namespace core
// //
// basic_string<> // basic_string<>
// Lightweight ::std::basic_string<>-like class // Lightweight std::basic_string<>-like class
// When using basic_string<> with a c-style string (char* or wchar_t*), constructor and operator=() just hold // When using basic_string<> with a c-style string (char* or wchar_t*), constructor and operator=() just hold
// a pointer to the character array but don't copy its content, considering performance issues. // a pointer to the character array but don't copy its content, considering performance issues.
// Use assign() and basic_string<>::cstr() to work fine with c-style strings. // Use assign() and basic_string<>::cstr() to work fine with c-style strings.
@ -48,11 +48,11 @@ public:
template <typename _Ty> template <typename _Ty>
struct iterator_impl struct iterator_impl
{ {
using iterator_category = typename ::std::iterator_traits<_Ty*>::iterator_category; using iterator_category = typename std::iterator_traits<_Ty*>::iterator_category;
using value_type = typename ::std::iterator_traits<_Ty*>::value_type; using value_type = typename std::iterator_traits<_Ty*>::value_type;
using difference_type = typename ::std::iterator_traits<_Ty*>::difference_type; using difference_type = typename std::iterator_traits<_Ty*>::difference_type;
using pointer = typename ::std::iterator_traits<_Ty*>::pointer; using pointer = typename std::iterator_traits<_Ty*>::pointer;
using reference = typename ::std::iterator_traits<_Ty*>::reference; using reference = typename std::iterator_traits<_Ty*>::reference;
// disable warning 4996 // disable warning 4996
using _Unchecked_type = _Ty; using _Unchecked_type = _Ty;
@ -101,16 +101,16 @@ public:
using const_reference = const value_type &; using const_reference = const value_type &;
using iterator = iterator_impl<value_type>; using iterator = iterator_impl<value_type>;
using const_iterator = iterator_impl<const value_type>; using const_iterator = iterator_impl<const value_type>;
using reverse_iterator = ::std::reverse_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = ::std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using traits_type = ::std::char_traits<value_type>; using traits_type = std::char_traits<value_type>;
using allocator_type = ::std::allocator<value_type>; using allocator_type = std::allocator<value_type>;
basic_string(); basic_string();
basic_string(const char_type* cstr, bool const_str = true); basic_string(const char_type* cstr, bool const_str = true);
basic_string(const char_type* cstr, size_type count); basic_string(const char_type* cstr, size_type count);
basic_string(size_type count, char_type ch); basic_string(size_type count, char_type ch);
basic_string(::std::basic_string<char_type> const& str); basic_string(std::basic_string<char_type> const& str);
basic_string(basic_string const& rhs); basic_string(basic_string const& rhs);
basic_string(basic_string const& rhs, size_type pos, size_type count = npos); basic_string(basic_string const& rhs, size_type pos, size_type count = npos);
basic_string(basic_string && rhs) noexcept; basic_string(basic_string && rhs) noexcept;
@ -140,7 +140,7 @@ public:
basic_string& append(basic_string const& other, size_type pos, size_type count = npos); basic_string& append(basic_string const& other, size_type pos, size_type count = npos);
inline basic_string& append(const char_type* cstr) { return append(cstr, traits_type::length(cstr)); } inline basic_string& append(const char_type* cstr) { return append(cstr, traits_type::length(cstr)); }
inline basic_string& append(basic_string const& other) { return append(other.const_str_, 0, npos); } inline basic_string& append(basic_string const& other) { return append(other.const_str_, 0, npos); }
inline basic_string& append(::std::basic_string<char_type> const& other) { return append(other.c_str()); } inline basic_string& append(std::basic_string<char_type> const& other) { return append(other.c_str()); }
size_type find(const char_type ch, size_type offset = 0) const; size_type find(const char_type ch, size_type offset = 0) const;
size_type find(const char_type* const str, size_type offset, size_type count) const; size_type find(const char_type* const str, size_type offset, size_type count) const;
@ -170,7 +170,7 @@ public:
basic_string& assign(const char_type* cstr, size_type count); basic_string& assign(const char_type* cstr, size_type count);
inline basic_string& assign(const char_type* cstr) { basic_string(cstr, false).swap(*this); return *this; } inline basic_string& assign(const char_type* cstr) { basic_string(cstr, false).swap(*this); return *this; }
inline basic_string& assign(basic_string const& rhs) { basic_string{ rhs }.swap(*this); return *this; } inline basic_string& assign(basic_string const& rhs) { basic_string{ rhs }.swap(*this); return *this; }
inline basic_string& assign(::std::basic_string<char_type> const& rhs) { basic_string{ rhs }.swap(*this); return *this; } inline basic_string& assign(std::basic_string<char_type> const& rhs) { basic_string{ rhs }.swap(*this); return *this; }
basic_string& assign(basic_string const& rhs, size_type pos, size_type count = npos); basic_string& assign(basic_string const& rhs, size_type pos, size_type count = npos);
template <typename _Iter> template <typename _Iter>
@ -191,7 +191,7 @@ public:
inline iterator insert(const_iterator pos, char_type ch) { return insert(pos, 1, ch); } inline iterator insert(const_iterator pos, char_type ch) { return insert(pos, 1, ch); }
inline void push_back(const char_type ch) { append(1, ch); } inline void push_back(const char_type ch) { append(1, ch); }
inline char_type pop_back() { if (empty()) throw ::std::out_of_range("pop_back() called on empty string"); check_operability(); char_type ch = str_[--size_]; str_[size_] = value_type(); return ch; } inline char_type pop_back() { if (empty()) throw std::out_of_range("pop_back() called on empty string"); check_operability(); char_type ch = str_[--size_]; str_[size_] = value_type(); return ch; }
size_type copy(char_type* cstr, size_type count, size_type pos = 0) const; size_type copy(char_type* cstr, size_type count, size_type pos = 0) const;
@ -227,14 +227,14 @@ public:
inline reverse_iterator rend() { check_operability(); return reverse_iterator(begin()); } inline reverse_iterator rend() { check_operability(); return reverse_iterator(begin()); }
inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
inline const_reverse_iterator crend() const { return rend(); } inline const_reverse_iterator crend() const { return rend(); }
inline reference front() { if (empty()) throw ::std::out_of_range("front() called on empty string"); check_operability(); return str_[0]; } inline reference front() { if (empty()) throw std::out_of_range("front() called on empty string"); check_operability(); return str_[0]; }
inline const_reference front() const { if (empty()) throw ::std::out_of_range("front() called on empty string"); return const_str_[0]; } inline const_reference front() const { if (empty()) throw std::out_of_range("front() called on empty string"); return const_str_[0]; }
inline reference back() { if (empty()) throw ::std::out_of_range("back() called on empty string"); check_operability(); return str_[size_ - 1]; } inline reference back() { if (empty()) throw std::out_of_range("back() called on empty string"); check_operability(); return str_[size_ - 1]; }
inline const_reference back() const { if (empty()) throw ::std::out_of_range("back() called on empty string"); return const_str_[size_ - 1]; } inline const_reference back() const { if (empty()) throw std::out_of_range("back() called on empty string"); return const_str_[size_ - 1]; }
public: public:
inline char_type operator[](size_type off) const { if (off >= size_) throw ::std::out_of_range("string subscript out of range"); return const_str_[off]; } inline char_type operator[](size_type off) const { if (off >= size_) throw std::out_of_range("string subscript out of range"); return const_str_[off]; }
inline char_type& operator[](size_type off) { if (off >= size_) throw ::std::out_of_range("string subscript out of range"); check_operability(); return str_[off]; } inline char_type& operator[](size_type off) { if (off >= size_) throw std::out_of_range("string subscript out of range"); check_operability(); return str_[off]; }
public: public:
inline const basic_string operator+(const char_type ch) const { return basic_string{ *this }.append(1, ch); } inline const basic_string operator+(const char_type ch) const { return basic_string{ *this }.append(1, ch); }
@ -247,7 +247,7 @@ public:
public: public:
inline basic_string& operator=(const char_type* cstr) { if (const_str_ != cstr) basic_string{ cstr }.swap(*this); return *this; } inline basic_string& operator=(const char_type* cstr) { if (const_str_ != cstr) basic_string{ cstr }.swap(*this); return *this; }
inline basic_string& operator=(::std::basic_string<char_type> const& rhs) { basic_string{ rhs }.swap(*this); return *this; } inline basic_string& operator=(std::basic_string<char_type> const& rhs) { basic_string{ rhs }.swap(*this); return *this; }
inline basic_string& operator=(basic_string const& rhs) { if (this != &rhs) basic_string{ rhs }.swap(*this); return *this; } inline basic_string& operator=(basic_string const& rhs) { if (this != &rhs) basic_string{ rhs }.swap(*this); return *this; }
inline basic_string& operator=(basic_string && rhs) noexcept { if (this != &rhs) basic_string{ rhs }.swap(*this); return *this; } inline basic_string& operator=(basic_string && rhs) noexcept { if (this != &rhs) basic_string{ rhs }.swap(*this); return *this; }
@ -269,13 +269,13 @@ private:
void discard_const_data(); void discard_const_data();
void check_operability(); void check_operability();
void check_offset(size_type offset) const { if (offset > size()) throw ::std::out_of_range("invalid string position"); } void check_offset(size_type offset) const { if (offset > size()) throw std::out_of_range("invalid string position"); }
size_type clamp_suffix_size(size_type off, size_type count) const { return ::std::min(size() - off, count); } size_type clamp_suffix_size(size_type off, size_type count) const { return std::min(size() - off, count); }
template <typename _Iter> template <typename _Iter>
void assign_iter(_Iter first, _Iter last) void assign_iter(_Iter first, _Iter last)
{ {
size_type diff = static_cast<size_type>(::std::distance(first, last)); size_type diff = static_cast<size_type>(std::distance(first, last));
if (diff == 0) if (diff == 0)
return; return;
@ -375,17 +375,10 @@ inline bool operator>=(basic_string<_CharTy> const& lhs, basic_string<_CharTy> c
// //
template <typename _CharTy> template <typename _CharTy>
::std::basic_ostream<typename basic_string<_CharTy>::char_type>& operator<<(::std::basic_ostream<typename basic_string<_CharTy>::char_type>& os, const basic_string<_CharTy>& str); std::basic_ostream<typename basic_string<_CharTy>::char_type>& operator<<(std::basic_ostream<typename basic_string<_CharTy>::char_type>& os, const basic_string<_CharTy>& str);
template <typename _CharTy> template <typename _CharTy>
::std::basic_istream<typename basic_string<_CharTy>::char_type>& operator>>(::std::basic_istream<typename basic_string<_CharTy>::char_type>& is, basic_string<_CharTy>& str); std::basic_istream<typename basic_string<_CharTy>::char_type>& operator>>(std::basic_istream<typename basic_string<_CharTy>::char_type>& is, basic_string<_CharTy>& str);
//
// string && wstring
//
using string = ::kiwano::core::basic_string<char>;
using wstring = ::kiwano::core::basic_string<WChar>;
// //
@ -419,37 +412,45 @@ basic_string<_CharTy> to_basic_string(Float64 val);
template <typename _CharTy> template <typename _CharTy>
basic_string<_CharTy> to_basic_string(long double val); basic_string<_CharTy> to_basic_string(long double val);
string to_string(Int32 val);
string to_string(UInt32 val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(Float32 val);
string to_string(Float64 val);
string to_string(long double val);
wstring to_wstring(Int32 val);
wstring to_wstring(UInt32 val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(Float32 val);
wstring to_wstring(Float64 val);
wstring to_wstring(long double val);
// //
// format_wstring // format_string
// //
template <typename ..._Args> template <typename ..._Args>
basic_string<char> format_string(const char* const fmt, _Args&&... args); basic_string<char> format_string(const char* const fmt, _Args&& ... args);
template <typename ..._Args> template <typename ..._Args>
basic_string<WChar> format_string(const WChar* const fmt, _Args&& ... args); basic_string<WChar> format_string(const WChar* const fmt, _Args&& ... args);
//
// string && wstring
//
using string = ::kiwano::core::basic_string<char>;
using wstring = ::kiwano::core::basic_string<WChar>;
inline string to_string(Int32 val) { return to_basic_string<char>(val); }
inline string to_string(UInt32 val) { return to_basic_string<char>(val); }
inline string to_string(long val) { return to_basic_string<char>(val); }
inline string to_string(unsigned long val) { return to_basic_string<char>(val); }
inline string to_string(long long val) { return to_basic_string<char>(val); }
inline string to_string(unsigned long long val) { return to_basic_string<char>(val); }
inline string to_string(Float32 val) { return to_basic_string<char>(val); }
inline string to_string(Float64 val) { return to_basic_string<char>(val); }
inline string to_string(long double val) { return to_basic_string<char>(val); }
inline wstring to_wstring(Int32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(UInt32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(unsigned long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(unsigned long long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(Float32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(Float64 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long double val) { return to_basic_string<WChar>(val); }
} // inline namespace core } // inline namespace core
} // namespace kiwano } // namespace kiwano
@ -499,7 +500,7 @@ namespace __string_details
{ {
if (count != 0 && first_size != 0) if (count != 0 && first_size != 0)
{ {
for (auto iter = first + ::std::min(pos, first_size - 1); ; --iter) for (auto iter = first + std::min(pos, first_size - 1); ; --iter)
{ {
if (typename _Traits::find(second, count, *iter)) if (typename _Traits::find(second, count, *iter))
{ {
@ -577,7 +578,7 @@ inline namespace core
} }
template <typename _CharTy> template <typename _CharTy>
inline basic_string<_CharTy>::basic_string(::std::basic_string<char_type> const& str) inline basic_string<_CharTy>::basic_string(std::basic_string<char_type> const& str)
: basic_string(str.c_str(), false) : basic_string(str.c_str(), false)
{ {
} }
@ -927,7 +928,7 @@ inline namespace core
{ {
size_type count1 = size(); size_type count1 = size();
size_type count2 = traits_type::length(str); size_type count2 = traits_type::length(str);
size_type rlen = ::std::min(count1, count2); size_type rlen = std::min(count1, count2);
Int32 ret = traits_type::compare(const_str_, str, rlen); Int32 ret = traits_type::compare(const_str_, str, rlen);
if (ret != 0) if (ret != 0)
@ -966,7 +967,7 @@ inline namespace core
if (offset >= size_) if (offset >= size_)
return basic_string<_CharTy>::npos; return basic_string<_CharTy>::npos;
const_iterator citer = ::std::find_first_of(cbegin().base() + offset, cend().base(), str, str + count); const_iterator citer = std::find_first_of(cbegin().base() + offset, cend().base(), str, str + count);
return (citer != cend()) ? (citer - cbegin()) : basic_string<_CharTy>::npos; return (citer != cend()) ? (citer - cbegin()) : basic_string<_CharTy>::npos;
} }
@ -976,7 +977,7 @@ inline namespace core
if (pos == 0 || pos > size_ || pos == npos) if (pos == 0 || pos > size_ || pos == npos)
return npos; return npos;
const_reverse_iterator criter = ::std::find(crbegin(), crend(), ch); const_reverse_iterator criter = std::find(crbegin(), crend(), ch);
return (criter != crend()) ? (criter.base() - cbegin()) : basic_string<_CharTy>::npos; return (criter != crend()) ? (criter.base() - cbegin()) : basic_string<_CharTy>::npos;
} }
@ -1124,12 +1125,12 @@ inline namespace core
template <typename _CharTy> template <typename _CharTy>
inline void basic_string<_CharTy>::swap(basic_string& rhs) noexcept inline void basic_string<_CharTy>::swap(basic_string& rhs) noexcept
{ {
::std::swap(const_str_, rhs.const_str_); std::swap(const_str_, rhs.const_str_);
::std::swap(size_, rhs.size_); std::swap(size_, rhs.size_);
::std::swap(capacity_, rhs.capacity_); std::swap(capacity_, rhs.capacity_);
// swap const datas // swap const datas
::std::swap(*const_cast<bool*>(&operable_), *const_cast<bool*>(&rhs.operable_)); std::swap(*const_cast<bool*>(&operable_), *const_cast<bool*>(&rhs.operable_));
} }
template <typename _CharTy> template <typename _CharTy>
@ -1193,7 +1194,7 @@ inline namespace core
template <typename ..._Args> template <typename ..._Args>
inline basic_string<_CharTy> basic_string<_CharTy>::format(const char_type* fmt, _Args&& ... args) inline basic_string<_CharTy> basic_string<_CharTy>::format(const char_type* fmt, _Args&& ... args)
{ {
return ::kiwano::format_string(fmt, ::std::forward<_Args>(args)...); return ::kiwano::format_string(fmt, std::forward<_Args>(args)...);
} }
// //
@ -1201,18 +1202,18 @@ inline namespace core
// //
template <typename _CharTy> template <typename _CharTy>
inline ::std::basic_ostream<typename basic_string<_CharTy>::char_type>& operator<<(::std::basic_ostream<typename basic_string<_CharTy>::char_type>& os, const basic_string<_CharTy>& str) inline std::basic_ostream<typename basic_string<_CharTy>::char_type>& operator<<(std::basic_ostream<typename basic_string<_CharTy>::char_type>& os, const basic_string<_CharTy>& str)
{ {
using ostream = ::std::basic_ostream<typename basic_string<_CharTy>::char_type, typename basic_string<_CharTy>::traits_type>; using ostream = std::basic_ostream<typename basic_string<_CharTy>::char_type, typename basic_string<_CharTy>::traits_type>;
using size_type = typename basic_string<_CharTy>::size_type; using size_type = typename basic_string<_CharTy>::size_type;
using traits = typename basic_string<_CharTy>::traits_type; using traits = typename basic_string<_CharTy>::traits_type;
const ostream::sentry ok(os); const ostream::sentry ok(os);
::std::ios_base::iostate state = ::std::ios_base::goodbit; std::ios_base::iostate state = std::ios_base::goodbit;
if (!ok) if (!ok)
{ {
state |= ::std::ios_base::badbit; state |= std::ios_base::badbit;
} }
else else
{ {
@ -1221,22 +1222,22 @@ inline namespace core
try try
{ {
if ((os.flags() & ::std::ios_base::adjustfield) != ::std::ios_base::left) if ((os.flags() & std::ios_base::adjustfield) != std::ios_base::left)
{ {
for (; 0 < pad; --pad) for (; 0 < pad; --pad)
{ {
if (traits::eq_int_type(traits::eof(), os.rdbuf()->sputc(os.fill()))) if (traits::eq_int_type(traits::eof(), os.rdbuf()->sputc(os.fill())))
{ {
state |= ::std::ios_base::badbit; state |= std::ios_base::badbit;
break; break;
} }
} }
} }
if (state == ::std::ios_base::goodbit if (state == std::ios_base::goodbit
&& os.rdbuf()->sputn(str.data(), (::std::streamsize)str_size) != (::std::streamsize)str_size) && os.rdbuf()->sputn(str.data(), (std::streamsize)str_size) != (std::streamsize)str_size)
{ {
state |= ::std::ios_base::badbit; state |= std::ios_base::badbit;
} }
else else
{ {
@ -1244,7 +1245,7 @@ inline namespace core
{ {
if (traits::eq_int_type(traits::eof(), os.rdbuf()->sputc(os.fill()))) if (traits::eq_int_type(traits::eof(), os.rdbuf()->sputc(os.fill())))
{ {
state |= ::std::ios_base::badbit; state |= std::ios_base::badbit;
break; break;
} }
} }
@ -1253,7 +1254,7 @@ inline namespace core
} }
catch (...) catch (...)
{ {
os.setstate(::std::ios_base::badbit, true); os.setstate(std::ios_base::badbit, true);
} }
} }
@ -1262,20 +1263,20 @@ inline namespace core
} }
template <typename _CharTy> template <typename _CharTy>
inline ::std::basic_istream<typename basic_string<_CharTy>::char_type>& operator>>(::std::basic_istream<typename basic_string<_CharTy>::char_type>& is, basic_string<_CharTy>& str) inline std::basic_istream<typename basic_string<_CharTy>::char_type>& operator>>(std::basic_istream<typename basic_string<_CharTy>::char_type>& is, basic_string<_CharTy>& str)
{ {
using ctype = ::std::ctype<typename basic_string<_CharTy>::char_type>; using ctype = std::ctype<typename basic_string<_CharTy>::char_type>;
using istream = ::std::basic_istream<typename basic_string<_CharTy>::char_type, typename basic_string<_CharTy>::traits_type>; using istream = std::basic_istream<typename basic_string<_CharTy>::char_type, typename basic_string<_CharTy>::traits_type>;
using size_type = typename basic_string<_CharTy>::size_type; using size_type = typename basic_string<_CharTy>::size_type;
using traits = typename basic_string<_CharTy>::traits_type; using traits = typename basic_string<_CharTy>::traits_type;
bool changed = false; bool changed = false;
const istream::sentry ok(is); const istream::sentry ok(is);
::std::ios_base::iostate state = ::std::ios_base::goodbit; std::ios_base::iostate state = std::ios_base::goodbit;
if (ok) if (ok)
{ {
const ctype& ctype_fac = ::std::use_facet<ctype>(is.getloc()); const ctype& ctype_fac = std::use_facet<ctype>(is.getloc());
str.erase(); str.erase();
try try
{ {
@ -1286,7 +1287,7 @@ inline namespace core
{ {
if (traits::eq_int_type(traits::eof(), meta)) if (traits::eq_int_type(traits::eof(), meta))
{ {
state |= ::std::ios_base::eofbit; state |= std::ios_base::eofbit;
break; break;
} }
else if (ctype_fac.is(ctype::space, traits::to_char_type(meta))) else if (ctype_fac.is(ctype::space, traits::to_char_type(meta)))
@ -1302,13 +1303,13 @@ inline namespace core
} }
catch (...) catch (...)
{ {
is.setstate(::std::ios_base::badbit, true); is.setstate(std::ios_base::badbit, true);
} }
} }
is.width(0); is.width(0);
if (!changed) if (!changed)
state |= ::std::ios_base::failbit; state |= std::ios_base::failbit;
is.setstate(state); is.setstate(state);
return is; return is;
} }
@ -1388,35 +1389,15 @@ inline namespace core
return (__to_string_detail::FloatingToString<_CharTy>::convert(val)); return (__to_string_detail::FloatingToString<_CharTy>::convert(val));
} }
inline string to_string(Int32 val) { return to_basic_string<char>(val); }
inline string to_string(UInt32 val) { return to_basic_string<char>(val); }
inline string to_string(long val) { return to_basic_string<char>(val); }
inline string to_string(unsigned long val) { return to_basic_string<char>(val); }
inline string to_string(long long val) { return to_basic_string<char>(val); }
inline string to_string(unsigned long long val) { return to_basic_string<char>(val); }
inline string to_string(Float32 val) { return to_basic_string<char>(val); }
inline string to_string(Float64 val) { return to_basic_string<char>(val); }
inline string to_string(long double val) { return to_basic_string<char>(val); }
inline wstring to_wstring(Int32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(UInt32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(unsigned long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(unsigned long long val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(Float32 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(Float64 val) { return to_basic_string<WChar>(val); }
inline wstring to_wstring(long double val) { return to_basic_string<WChar>(val); }
template <typename ..._Args> template <typename ..._Args>
inline basic_string<char> format_string(const char* const fmt, _Args&& ... args) inline basic_string<char> format_string(const char* const fmt, _Args&& ... args)
{ {
using string_type = basic_string<char>; using string_type = basic_string<char>;
const auto len = static_cast<typename string_type::size_type>(::_scprintf(fmt, ::std::forward<_Args>(args)...)); const auto len = static_cast<typename string_type::size_type>(::_scprintf(fmt, std::forward<_Args>(args)...));
if (len) if (len)
{ {
string_type str(len, '\0'); string_type str(len, '\0');
::sprintf_s(&str[0], len + 1, fmt, ::std::forward<_Args>(args)...); ::sprintf_s(&str[0], len + 1, fmt, std::forward<_Args>(args)...);
return str; return str;
} }
return string_type{}; return string_type{};
@ -1426,11 +1407,11 @@ inline namespace core
inline basic_string<WChar> format_string(const WChar* const fmt, _Args&& ... args) inline basic_string<WChar> format_string(const WChar* const fmt, _Args&& ... args)
{ {
using string_type = basic_string<WChar>; using string_type = basic_string<WChar>;
const auto len = static_cast<typename string_type::size_type>(::_scwprintf(fmt, ::std::forward<_Args>(args)...)); const auto len = static_cast<typename string_type::size_type>(::_scwprintf(fmt, std::forward<_Args>(args)...));
if (len) if (len)
{ {
string_type str(len, L'\0'); string_type str(len, L'\0');
::swprintf_s(&str[0], len + 1, fmt, ::std::forward<_Args>(args)...); ::swprintf_s(&str[0], len + 1, fmt, std::forward<_Args>(args)...);
return str; return str;
} }
return string_type{}; return string_type{};
@ -1441,7 +1422,7 @@ inline namespace core
template <typename _Ty, typename _Elem> template <typename _Ty, typename _Elem>
_Elem* __IntegerToStringBufferEnd(const _Ty val, _Elem* const buffer_end) _Elem* __IntegerToStringBufferEnd(const _Ty val, _Elem* const buffer_end)
{ {
using _UTy = ::std::make_unsigned_t<_Ty>; using _UTy = std::make_unsigned_t<_Ty>;
_Elem* next = buffer_end; _Elem* next = buffer_end;
auto uval = static_cast<_UTy>(val); auto uval = static_cast<_UTy>(val);
@ -1467,12 +1448,12 @@ inline namespace core
template <typename _Ty> template <typename _Ty>
static basic_string<char> convert(const _Ty val) static basic_string<char> convert(const _Ty val)
{ {
static_assert(::std::is_integral<_Ty>::value, "_Ty must be integral"); static_assert(std::is_integral<_Ty>::value, "_Ty must be integral");
using _Elem = typename basic_string<char>::traits_type::char_type; using _Elem = typename basic_string<char>::traits_type::char_type;
_Elem buffer[21]; _Elem buffer[21];
_Elem* const buffer_end = ::std::end(buffer); _Elem* const buffer_end = std::end(buffer);
_Elem* buffer_begin = __IntegerToStringBufferEnd(val, buffer_end); _Elem* buffer_begin = __IntegerToStringBufferEnd(val, buffer_end);
return basic_string<char>(buffer_begin, buffer_end); return basic_string<char>(buffer_begin, buffer_end);
@ -1485,12 +1466,12 @@ inline namespace core
template <typename _Ty> template <typename _Ty>
static basic_string<WChar> convert(const _Ty val) static basic_string<WChar> convert(const _Ty val)
{ {
static_assert(::std::is_integral<_Ty>::value, "_Ty must be integral"); static_assert(std::is_integral<_Ty>::value, "_Ty must be integral");
using _Elem = typename basic_string<WChar>::traits_type::char_type; using _Elem = typename basic_string<WChar>::traits_type::char_type;
_Elem buffer[21]; _Elem buffer[21];
_Elem* const buffer_end = ::std::end(buffer); _Elem* const buffer_end = std::end(buffer);
_Elem* buffer_begin = __IntegerToStringBufferEnd(val, buffer_end); _Elem* buffer_begin = __IntegerToStringBufferEnd(val, buffer_end);
return basic_string<WChar>(buffer_begin, buffer_end); return basic_string<WChar>(buffer_begin, buffer_end);
@ -1564,7 +1545,7 @@ public:
, loc_() , loc_()
, conv_num_(0) , conv_num_(0)
{ {
loc_ = ::std::locale(loc_, cvt_); loc_ = std::locale(loc_, cvt_);
} }
virtual ~string_convert() { } virtual ~string_convert() { }
@ -1580,7 +1561,7 @@ public:
wide_string from_bytes(const char* ptr) wide_string from_bytes(const char* ptr)
{ {
return from_bytes(ptr, ptr + ::std::strlen(ptr)); return from_bytes(ptr, ptr + std::strlen(ptr));
} }
wide_string from_bytes(const byte_string& byte_str) wide_string from_bytes(const byte_string& byte_str)
@ -1617,7 +1598,7 @@ public:
} }
else else
{ {
throw (::std::range_error("bad conversion")); throw (std::range_error("bad conversion"));
} }
break; break;
} }
@ -1632,7 +1613,7 @@ public:
} }
default: default:
throw (::std::range_error("bad conversion")); throw (std::range_error("bad conversion"));
} }
} }
return wstr; return wstr;
@ -1685,7 +1666,7 @@ public:
} }
else else
{ {
throw (::std::range_error("bad conversion")); throw (std::range_error("bad conversion"));
} }
break; break;
} }
@ -1700,7 +1681,7 @@ public:
} }
default: default:
throw (::std::range_error("bad conversion")); throw (std::range_error("bad conversion"));
} }
} }
return bstr; return bstr;
@ -1711,13 +1692,13 @@ public:
private: private:
const codecvt_type* cvt_; const codecvt_type* cvt_;
::std::locale loc_; std::locale loc_;
state_type state_; state_type state_;
UInt32 conv_num_; UInt32 conv_num_;
}; };
class chs_codecvt class chs_codecvt
: public ::std::codecvt_byname<WChar, char, ::std::mbstate_t> : public std::codecvt_byname<WChar, char, std::mbstate_t>
{ {
public: public:
chs_codecvt() : codecvt_byname("chs") {} chs_codecvt() : codecvt_byname("chs") {}

100
src/kiwano/core/vector.hpp
View File

@ -31,7 +31,7 @@ inline namespace core
// //
// ArrayManager<> with memory operations // vector_memory_manager<> with memory operations
// //
namespace __vector_details namespace __vector_details
{ {
@ -64,77 +64,77 @@ public:
using initializer_list = std::initializer_list<value_type>; using initializer_list = std::initializer_list<value_type>;
public: public:
inline vector() : size_(0), capacity_(0), data_(nullptr) { } inline vector() : size_(0), capacity_(0), data_(nullptr) { }
inline vector(size_type count) : vector() { reserve(count); } inline vector(size_type count) : vector() { reserve(count); }
inline vector(size_type count, const _Ty& val) : vector() { assign(count, val); } inline vector(size_type count, const _Ty& val) : vector() { assign(count, val); }
inline vector(initializer_list list) : vector() { assign(list); } inline vector(initializer_list list) : vector() { assign(list); }
inline vector(const vector& src) : vector() { assign(src); } inline vector(const vector& src) : vector() { assign(src); }
inline vector(vector&& src) noexcept : vector() { swap(src); } inline vector(vector&& src) noexcept : vector() { swap(src); }
inline ~vector() { destroy(); } inline ~vector() { destroy(); }
template <typename _Iter> template <typename _Iter>
inline vector(_Iter first, _Iter last) : vector() { assign(first, last); } inline vector(_Iter first, _Iter last) : vector() { assign(first, last); }
inline vector& operator=(const vector& src) { if (&src != this) { resize(src.size_); manager::copy_data(begin(), src.cbegin(), size_); } return (*this); } inline vector& operator=(const vector& src) { if (&src != this) { resize(src.size_); manager::copy_data(begin(), src.cbegin(), size_); } return (*this); }
inline vector& operator=(vector&& src) noexcept { swap(src); return *this; } inline vector& operator=(vector&& src) noexcept { swap(src); return *this; }
inline vector& operator=(initializer_list list) { if (list.size()) { assign(list.begin(), list.end()); } else clear(); return (*this); } inline vector& operator=(initializer_list list) { if (list.size()) { assign(list.begin(), list.end()); } else clear(); return (*this); }
inline vector& assign(size_type count, const _Ty& val) { if (count > 0) { resize(count); manager::copy_data(begin(), count, val); } else clear(); return (*this); } inline vector& assign(size_type count, const _Ty& val) { if (count > 0) { resize(count); manager::copy_data(begin(), count, val); } else clear(); return (*this); }
inline vector& assign(const vector& src) { return operator=(src); } inline vector& assign(const vector& src) { return operator=(src); }
inline vector& assign(initializer_list list) { return operator=(list); } inline vector& assign(initializer_list list) { return operator=(list); }
template <typename _Iter> template <typename _Iter>
inline void assign(_Iter first, _Iter last) { auto diff = std::distance(first, last); resize((size_type)diff); auto data = begin(); while (first != last) (*data++) = (*first++); } inline void assign(_Iter first, _Iter last) { auto diff = std::distance(first, last); resize((size_type)diff); auto data = begin(); while (first != last) (*data++) = (*first++); }
inline void clear() { destroy(); size_ = capacity_ = 0; data_ = nullptr; } inline void clear() { destroy(); size_ = capacity_ = 0; data_ = nullptr; }
inline void swap(vector& rhs) noexcept { std::swap(size_, rhs.size_); std::swap(capacity_, rhs.capacity_); std::swap(data_, rhs.data_); } inline void swap(vector& rhs) noexcept { std::swap(size_, rhs.size_); std::swap(capacity_, rhs.capacity_); std::swap(data_, rhs.data_); }
inline void resize(size_type new_size) { resize(new_size, _Ty()); } inline void resize(size_type new_size) { resize(new_size, _Ty()); }
void resize(size_type new_size, const _Ty& v); void resize(size_type new_size, const _Ty& v);
void reserve(size_type new_capacity); void reserve(size_type new_capacity);
inline void push_back(const _Ty& val) { resize(size_ + 1, val); } inline void push_back(const _Ty& val) { resize(size_ + 1, val); }
inline void pop_back() { if (empty()) throw std::out_of_range("pop() called on empty vector"); resize(size_ - 1); } inline void pop_back() { if (empty()) throw std::out_of_range("pop() called on empty vector"); resize(size_ - 1); }
inline void push_front(const _Ty& val) { if (size_ == 0) push_back(val); else insert(begin(), val); } inline void push_front(const _Ty& val) { if (size_ == 0) push_back(val); else insert(begin(), val); }
inline iterator erase(const_iterator where) { return erase(where, where + 1); } inline iterator erase(const_iterator where) { return erase(where, where + 1); }
iterator erase(const_iterator first, const_iterator last); iterator erase(const_iterator first, const_iterator last);
iterator insert(const_iterator where, const _Ty& v); iterator insert(const_iterator where, const _Ty& v);
inline bool empty() const { return size_ == 0; } inline bool empty() const { return size_ == 0; }
inline size_type size() const { return size_; } inline size_type size() const { return size_; }
inline size_type size_in_bytes() const { return size_ * ((size_type)sizeof(_Ty)); } inline size_type size_in_bytes() const { return size_ * ((size_type)sizeof(_Ty)); }
inline size_type capacity() const { return capacity_; } inline size_type capacity() const { return capacity_; }
inline reference operator[](size_type off) { if (off < 0 || off >= size_) throw std::out_of_range("vector subscript out of range"); return data_[off]; } inline reference operator[](size_type off) { if (off < 0 || off >= size_) throw std::out_of_range("vector subscript out of range"); return data_[off]; }
inline const_reference operator[](size_type off) const { if (off < 0 || off >= size_) throw std::out_of_range("vector subscript out of range"); return data_[off]; } inline const_reference operator[](size_type off) const { if (off < 0 || off >= size_) throw std::out_of_range("vector subscript out of range"); return data_[off]; }
inline bool contains(const _Ty& v) const { auto data = cbegin(); const auto data_end = cend(); while (data != data_end) if (*(data++) == v) return true; return false; } inline bool contains(const _Ty& v) const { auto data = cbegin(); const auto data_end = cend(); while (data != data_end) if (*(data++) == v) return true; return false; }
inline size_type index_of(const_iterator it) const { check_offset(it - cbegin(), "invalid array position"); return it - data_; } inline size_type index_of(const_iterator it) const { check_offset(it - cbegin(), "invalid array position"); return it - data_; }
inline iterator begin() { return iterator(data_); } inline iterator begin() { return iterator(data_); }
inline const_iterator begin() const { return const_iterator(data_); } inline const_iterator begin() const { return const_iterator(data_); }
inline const_iterator cbegin() const { return begin(); } inline const_iterator cbegin() const { return begin(); }
inline iterator end() { return iterator(data_ + size_); } inline iterator end() { return iterator(data_ + size_); }
inline const_iterator end() const { return const_iterator(data_ + size_); } inline const_iterator end() const { return const_iterator(data_ + size_); }
inline const_iterator cend() const { return end(); } inline const_iterator cend() const { return end(); }
inline reverse_iterator rbegin() { return reverse_iterator(end()); } inline reverse_iterator rbegin() { return reverse_iterator(end()); }
inline const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } inline const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
inline const_reverse_iterator crbegin() const { return rbegin(); } inline const_reverse_iterator crbegin() const { return rbegin(); }
inline reverse_iterator rend() { return reverse_iterator(begin()); } inline reverse_iterator rend() { return reverse_iterator(begin()); }
inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
inline const_reverse_iterator crend() const { return rend(); } inline const_reverse_iterator crend() const { return rend(); }
inline reference front() { if (empty()) throw std::out_of_range("front() called on empty array"); return data_[0]; } inline reference front() { if (empty()) throw std::out_of_range("front() called on empty array"); return data_[0]; }
inline const_reference front() const { if (empty()) throw std::out_of_range("front() called on empty array"); return data_[0]; } inline const_reference front() const { if (empty()) throw std::out_of_range("front() called on empty array"); return data_[0]; }
inline reference back() { if (empty()) throw std::out_of_range("back() called on empty array"); return data_[size_ - 1]; } inline reference back() { if (empty()) throw std::out_of_range("back() called on empty array"); return data_[size_ - 1]; }
inline const_reference back() const { if (empty()) throw std::out_of_range("back() called on empty array"); return data_[size_ - 1]; } inline const_reference back() const { if (empty()) throw std::out_of_range("back() called on empty array"); return data_[size_ - 1]; }
private: private:
inline size_type grow_capacity(size_type sz) const { size_type new_capacity = capacity_ ? (capacity_ + capacity_ / 2) : 8; return new_capacity > sz ? new_capacity : sz; } inline size_type grow_capacity(size_type sz) const { size_type new_capacity = capacity_ ? (capacity_ + capacity_ / 2) : 8; return new_capacity > sz ? new_capacity : sz; }
inline void check_offset(const size_type off) const { if (off < 0 || off >= size_) throw std::out_of_range("invalid vector position"); } inline void check_offset(const size_type off) const { if (off < 0 || off >= size_) throw std::out_of_range("invalid vector position"); }
inline void destroy() { manager::destroy(data_, size_); manager::deallocate(data_, capacity_); } inline void destroy() { manager::destroy(data_, size_); manager::deallocate(data_, capacity_); }
protected: protected:
size_type size_; size_type size_;
size_type capacity_; size_type capacity_;

10
src/kiwano/renderer/Color.h
View File

@ -58,6 +58,16 @@ namespace kiwano
Float32 alpha Float32 alpha
); );
inline bool operator== (const Color& rhs) const
{
return r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a;
}
inline bool operator!= (const Color& rhs) const
{
return !((*this) == rhs);
}
public: public:
enum Value : UInt32 enum Value : UInt32
{ {

4
src/kiwano/renderer/win32/TextRenderer.cpp
View File

@ -352,7 +352,7 @@ namespace kiwano
pRT_->DrawGeometry( pRT_->DrawGeometry(
pTransformedGeometry, pTransformedGeometry,
pBrush_, pBrush_,
fOutlineWidth, fOutlineWidth * 2,
pCurrStrokeStyle_ pCurrStrokeStyle_
); );
} }
@ -421,7 +421,7 @@ namespace kiwano
pRT_->DrawGeometry( pRT_->DrawGeometry(
pTransformedGeometry, pTransformedGeometry,
pBrush_, pBrush_,
fOutlineWidth, fOutlineWidth * 2,
pCurrStrokeStyle_ pCurrStrokeStyle_
); );
} }