From 5a90d2b671f01f29043ab82f909440de0abfa362 Mon Sep 17 00:00:00 2001 From: Dana Jansens Date: Mon, 13 Jan 2003 04:46:50 +0000 Subject: [PATCH] otk using ustring for shit that draws. expended its inferface yet some more. --- otk/focuslabel.cc | 2 +- otk/focuslabel.hh | 6 +-- otk/label.cc | 2 +- otk/label.hh | 6 +-- otk/ustring.cc | 104 ++++++++++++++++++++++++++++++++++++++++------ otk/ustring.hh | 35 ++++++++++++---- 6 files changed, 125 insertions(+), 30 deletions(-) diff --git a/otk/focuslabel.cc b/otk/focuslabel.cc index 397a2cac..79c1507f 100644 --- a/otk/focuslabel.cc +++ b/otk/focuslabel.cc @@ -41,7 +41,7 @@ void FocusLabel::update(void) : style()->getTextUnfocus()); unsigned int sidemargin = style()->getBevelWidth() * 2; - std::string t = _text; // the actual text to draw + ustring t = _text; // the actual text to draw int x = sidemargin; // x coord for the text // find a string that will fit inside the area for text diff --git a/otk/focuslabel.hh b/otk/focuslabel.hh index 54a7f06f..ea9f9b66 100644 --- a/otk/focuslabel.hh +++ b/otk/focuslabel.hh @@ -14,8 +14,8 @@ public: FocusLabel(Widget *parent); ~FocusLabel(); - inline const std::string &getText(void) const { return _text; } - void setText(const std::string &text) { _text = text; _dirty = true; } + inline const ustring &getText(void) const { return _text; } + void setText(const ustring &text) { _text = text; _dirty = true; } void update(void); @@ -25,7 +25,7 @@ private: //! Object used by Xft to render to the drawable XftDraw *_xftdraw; //! Text displayed in the label - std::string _text; + ustring _text; }; } diff --git a/otk/label.cc b/otk/label.cc index 6b6a8e35..05ed6cfa 100644 --- a/otk/label.cc +++ b/otk/label.cc @@ -35,7 +35,7 @@ void Label::update(void) const Font *ft = style()->getFont(); unsigned int sidemargin = style()->getBevelWidth() * 2; - std::string t = _text; // the actual text to draw + ustring t = _text; // the actual text to draw int x = sidemargin; // x coord for the text // find a string that will fit inside the area for text diff --git a/otk/label.hh b/otk/label.hh index 0366c262..ad938f10 100644 --- a/otk/label.hh +++ b/otk/label.hh @@ -14,8 +14,8 @@ public: Label(Widget *parent); ~Label(); - inline const std::string &getText(void) const { return _text; } - void setText(const std::string &text) { _text = text; _dirty = true; } + inline const ustring &getText(void) const { return _text; } + void setText(const ustring &text) { _text = text; _dirty = true; } void update(void); @@ -25,7 +25,7 @@ private: //! Object used by Xft to render to the drawable XftDraw *_xftdraw; //! Text displayed in the label - std::string _text; + ustring _text; }; } diff --git a/otk/ustring.cc b/otk/ustring.cc index a04c08cf..8f3cdfc4 100644 --- a/otk/ustring.cc +++ b/otk/ustring.cc @@ -12,6 +12,63 @@ extern "C" { namespace otk { +// helper functions + +static ustring::size_type utf8_find_offset(const char *str, const char *pos) +{ + ustring::size_type offset = 0; + + while (str < pos) { + str += g_utf8_skip[*str]; + offset += g_utf8_skip[*str]; + } + + return offset; +} + +// First overload: stop on '\0' character. +ustring::size_type utf8_byte_offset(const char* str, ustring::size_type offset) +{ + if(offset == ustring::npos) + return ustring::npos; + + const char* p = str; + + for(; offset != 0; --offset) + { + if(*p == '\0') + return ustring::npos; + + p += g_utf8_skip[*p]; + } + + return (p - str); +} + +// Second overload: stop when reaching maxlen. +ustring::size_type utf8_byte_offset(const char* str, ustring::size_type offset, + ustring::size_type maxlen) +{ + if(offset == ustring::npos) + return ustring::npos; + + const char *const pend = str + maxlen; + const char* p = str; + + for(; offset != 0; --offset) + { + if(p >= pend) + return ustring::npos; + + p += g_utf8_skip[*p]; + } + + return (p - str); +} + + +// ustring methods + ustring::ustring() { } @@ -61,23 +118,11 @@ ustring& ustring::operator+=(char c) return *this; } -static ustring::size_type find_utf8_offset(const char *str, const char *pos) -{ - ustring::size_type offset = 0; - - while (str < pos) { - str += g_utf8_skip[*str]; - offset += g_utf8_skip[*str]; - } - - return offset; -} - ustring::size_type ustring::size() const { if (_utf8) { const char *const pdata = _string.data(); - return find_utf8_offset(pdata, pdata + _string.size()); + return utf8_find_offset(pdata, pdata + _string.size()); } else return _string.size(); } @@ -97,6 +142,39 @@ ustring::size_type ustring::max_size() const return _string.max_size(); } +void ustring::clear() +{ + _string.erase(); +} + +ustring& ustring::erase(ustring::size_type i, ustring::size_type n) +{ + if (_utf8) { + // find a proper offset + size_type utf_i = utf8_byte_offset(_string.c_str(), i); + if (utf_i != npos) { + // if the offset is not npos, find a proper length for 'n' + size_type utf_n = utf8_byte_offset(_string.data() + utf_i, n, + _string.size() - utf_i); + _string.erase(utf_i, utf_n); + } + } else + _string.erase(i, n); + + return *this; +} + +void ustring::resize(ustring::size_type n, char c) +{ + if (_utf8) { + const size_type size_now = size(); + if(n < size_now) + erase(n, npos); + else if(n > size_now) + _string.append(n - size_now, c); + } else + _string.resize(n, c); +} const char* ustring::data() const { diff --git a/otk/ustring.hh b/otk/ustring.hh index 02111a33..ef94440c 100644 --- a/otk/ustring.hh +++ b/otk/ustring.hh @@ -7,6 +7,7 @@ */ extern "C" { +/* #ifdef HAVE_STDINT_H # include #else @@ -14,17 +15,20 @@ extern "C" { # include # endif #endif +*/ } #include namespace otk { +/* #ifdef HAVE_STDINT_H typedef uint32_t unichar; #else typedef u_int32_t unichar; #endif +*/ #ifndef DOXYGEN_IGNORE @@ -40,6 +44,8 @@ const char g_utf8_skip[256] = { 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1 }; +#endif // DOXYGEN_IGNORE + //! The iterator type for ustring /*! Note this is not a random access iterator but a bidirectional one, since all @@ -51,20 +57,22 @@ const char g_utf8_skip[256] = { write operation would invalidate all other iterators pointing into the same string. */ +/* template class ustring_Iterator { public: typedef std::bidirectional_iterator_tag iterator_category; - typedef unichar value_type; + //typedef unichar value_type; typedef std::string::difference_type difference_type; - typedef value_type reference; + //typedef value_type reference; typedef void pointer; inline ustring_Iterator() {} inline ustring_Iterator(const ustring_Iterator& other) : _pos(other.base()) {} + inline value_type operator*() const { // get a unicode character from the iterator's position @@ -88,6 +96,7 @@ public: return result; } + inline ustring_Iterator & operator++() { pos_ += g_utf8_skip[static_cast(*pos_)]; return *this; @@ -103,8 +112,7 @@ public: private: T _pos; }; - -#endif // DOXYGEN_IGNORE +*/ //! This class provides a simple wrapper to a std::string that can be encoded //! as UTF-8. The ustring::utf() member specifies if the given string is UTF-8 @@ -127,12 +135,12 @@ public: typedef std::string::size_type size_type; typedef std::string::difference_type difference_type; - typedef unichar value_type; - typedef unichar & reference; - typedef const unichar & const_reference; + //typedef unichar value_type; + //typedef unichar & reference; + //typedef const unichar & const_reference; - typedef ustring_Iterator iterator; - typedef ustring_Iterator const_iterator; + //typedef ustring_Iterator iterator; + //typedef ustring_Iterator const_iterator; static const size_type npos = std::string::npos; @@ -159,6 +167,15 @@ public: ustring::size_type capacity() const; ustring::size_type max_size() const; + // erase substrings + + void clear(); + ustring& erase(size_type i, size_type n=npos); + + // change the string's size + + void resize(size_type n, char c='\0'); + // internal data const char* data() const; -- 2.39.2