From 74061b4e2d33d7e2101c4edda26cfc2a1294f32b Mon Sep 17 00:00:00 2001 From: Dana Jansens Date: Sun, 12 Jan 2003 21:17:26 +0000 Subject: [PATCH] use "userstring" for all user viewable strings --- otk/focuslabel.cc | 2 +- otk/focuslabel.hh | 7 ++-- otk/font.cc | 22 ++++-------- otk/font.hh | 17 +++++++-- otk/label.cc | 2 +- otk/label.hh | 7 ++-- otk/property.cc | 68 +++++++++++++++++++---------------- otk/property.hh | 13 +++---- otk/userstring.hh | 90 +++++++++++++++++++++++++++++++++++++++++++---- 9 files changed, 156 insertions(+), 72 deletions(-) diff --git a/otk/focuslabel.cc b/otk/focuslabel.cc index 397a2cac..e82fa1ed 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 + userstring 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..b3db6074 100644 --- a/otk/focuslabel.hh +++ b/otk/focuslabel.hh @@ -4,6 +4,7 @@ #include "focuswidget.hh" #include "font.hh" +#include "userstring.hh" namespace otk { @@ -14,8 +15,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 userstring &getText(void) const { return _text; } + void setText(const userstring &text) { _text = text; _dirty = true; } void update(void); @@ -25,7 +26,7 @@ private: //! Object used by Xft to render to the drawable XftDraw *_xftdraw; //! Text displayed in the label - std::string _text; + userstring _text; }; } diff --git a/otk/font.cc b/otk/font.cc index 0f1ad8c1..6932971c 100644 --- a/otk/font.cc +++ b/otk/font.cc @@ -10,15 +10,7 @@ extern "C" { #endif // HAVE_STDLIB_H } -#include -#include - -using std::string; -using std::cerr; -using std::endl; - #include "font.hh" -#include "util.hh" #include "display.hh" #include "color.hh" #include "screeninfo.hh" @@ -34,10 +26,10 @@ extern "C" { namespace otk { -string Font::_fallback_font = "fixed"; +std::string Font::_fallback_font = "fixed"; bool Font::_xft_init = false; -Font::Font(int screen_num, const string &fontstring, +Font::Font(int screen_num, const std::string &fontstring, bool shadow, unsigned char offset, unsigned char tint) : _screen_num(screen_num), _fontstring(fontstring), @@ -86,7 +78,7 @@ Font::~Font(void) void Font::drawString(XftDraw *d, int x, int y, const Color &color, - const string &string, bool utf8) const + const userstring &string) const { assert(d); @@ -98,7 +90,7 @@ void Font::drawString(XftDraw *d, int x, int y, const Color &color, c.color.alpha = _tint | _tint << 8; // transparent shadow c.pixel = BlackPixel(Display::display, _screen_num); - if (utf8) + if (string.utf8()) XftDrawStringUtf8(d, &c, _xftfont, x + _offset, _xftfont->ascent + y + _offset, (FcChar8*)string.c_str(), string.size()); @@ -115,7 +107,7 @@ void Font::drawString(XftDraw *d, int x, int y, const Color &color, c.pixel = color.pixel(); c.color.alpha = 0xff | 0xff << 8; // no transparency in Color yet - if (utf8) + if (string.utf8()) XftDrawStringUtf8(d, &c, _xftfont, x, _xftfont->ascent + y, (FcChar8*)string.c_str(), string.size()); else @@ -126,11 +118,11 @@ void Font::drawString(XftDraw *d, int x, int y, const Color &color, } -unsigned int Font::measureString(const string &string, bool utf8) const +unsigned int Font::measureString(const userstring &string) const { XGlyphInfo info; - if (utf8) + if (string.utf8()) XftTextExtentsUtf8(Display::display, _xftfont, (FcChar8*)string.c_str(), string.size(), &info); else diff --git a/otk/font.hh b/otk/font.hh index 9091b9bc..8e736d8e 100644 --- a/otk/font.hh +++ b/otk/font.hh @@ -2,6 +2,8 @@ #ifndef __font_hh #define __font_hh +#include "userstring.hh" + extern "C" { #include #define _XFT_NO_COMPAT_ // no Xft 1 API @@ -9,6 +11,7 @@ extern "C" { } #include + #include namespace otk { @@ -57,16 +60,24 @@ public: unsigned int height() const; unsigned int maxCharWidth() const; - unsigned int measureString(const std::string &string, - bool utf8 = false) const; + //! Measures the length of a string + /*! + @param string The string to measure, it should be UTF8 encoded. + */ + unsigned int measureString(const userstring &string) const; //! Draws a string into an XftDraw object /*! Be Warned: If you use an XftDraw object and a color, or a font from different screens, you WILL have unpredictable results! :) + @param d The drawable to render into. + @param x The X offset onto the drawable at which to start drawing. + @param x The Y offset onto the drawable at which to start drawing. + @param color The color to use for drawing the text. + @param string The string to draw, it should be UTF8 encoded. */ void drawString(XftDraw *d, int x, int y, const Color &color, - const std::string &string, bool utf8 = false) const; + const userstring &string) const; }; } diff --git a/otk/label.cc b/otk/label.cc index 6b6a8e35..cacbb08e 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 + userstring 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..94ebe0b3 100644 --- a/otk/label.hh +++ b/otk/label.hh @@ -4,6 +4,7 @@ #include "widget.hh" #include "font.hh" +#include "userstring.hh" namespace otk { @@ -14,8 +15,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 userstring &getText(void) const { return _text; } + void setText(const userstring &text) { _text = text; _dirty = true; } void update(void); @@ -25,7 +26,7 @@ private: //! Object used by Xft to render to the drawable XftDraw *_xftdraw; //! Text displayed in the label - std::string _text; + userstring _text; }; } diff --git a/otk/property.cc b/otk/property.cc index ad9eacc9..77bdfb03 100644 --- a/otk/property.cc +++ b/otk/property.cc @@ -163,7 +163,7 @@ Property::~Property() */ Atom Property::create(const char *name) const { - Atom a = XInternAtom(Display::display, name, False); + Atom a = XInternAtom(Display::display, name, false); assert(a); return a; } @@ -196,7 +196,7 @@ void Property::set(Window win, Atoms atom, Atoms type, assert(atom >= 0 && atom < NUM_ATOMS); assert(type >= 0 && type < NUM_ATOMS); set(win, _atoms[atom], _atoms[type], - reinterpret_cast(&value), 32, 1, False); + reinterpret_cast(&value), 32, 1, false); } @@ -209,7 +209,7 @@ void Property::set(Window win, Atoms atom, Atoms type, assert(atom >= 0 && atom < NUM_ATOMS); assert(type >= 0 && type < NUM_ATOMS); set(win, _atoms[atom], _atoms[type], - reinterpret_cast(value), 32, elements, False); + reinterpret_cast(value), 32, elements, false); } @@ -217,7 +217,7 @@ void Property::set(Window win, Atoms atom, Atoms type, * Set an string property value on a window. */ void Property::set(Window win, Atoms atom, StringType type, - const std::string &value) const + const userstring &value) const { assert(atom >= 0 && atom < NUM_ATOMS); assert(type >= 0 && type < NUM_STRING_TYPE); @@ -226,11 +226,11 @@ void Property::set(Window win, Atoms atom, StringType type, switch (type) { case ascii: t = _atoms[Atom_String]; break; case utf8: t = _atoms[Atom_Utf8]; break; - default: assert(False); return; // unhandled StringType + default: assert(false); return; // unhandled StringType } set(win, _atoms[atom], t, reinterpret_cast(const_cast(value.c_str())), - 8, value.size() + 1, False); // add 1 to the size to include the null + 8, value.size() + 1, false); // add 1 to the size to include the null } @@ -238,7 +238,7 @@ void Property::set(Window win, Atoms atom, StringType type, * Set an array of string property values on a window. */ void Property::set(Window win, Atoms atom, StringType type, - const StringVect &strings) const + const userstring::vector &strings) const { assert(atom >= 0 && atom < NUM_ATOMS); assert(type >= 0 && type < NUM_STRING_TYPE); @@ -247,26 +247,26 @@ void Property::set(Window win, Atoms atom, StringType type, switch (type) { case ascii: t = _atoms[Atom_String]; break; case utf8: t = _atoms[Atom_Utf8]; break; - default: assert(False); return; // unhandled StringType + default: assert(false); return; // unhandled StringType } std::string value; - StringVect::const_iterator it = strings.begin(); - const StringVect::const_iterator end = strings.end(); + userstring::vector::const_iterator it = strings.begin(); + const userstring::vector::const_iterator end = strings.end(); for (; it != end; ++it) value += *it + '\0'; set(win, _atoms[atom], t, reinterpret_cast(const_cast(value.c_str())), - 8, value.size(), False); + 8, value.size(), false); } /* * Internal get function used by all of the typed get functions. * Gets an property's value from a window. - * Returns True if the property was successfully retrieved; False if the + * Returns true if the property was successfully retrieved; false if the * property did not exist on the window, or has a different type/size format * than the user tried to retrieve. */ @@ -283,11 +283,11 @@ bool Property::get(Window win, Atom atom, Atom type, unsigned long ret_bytes; int result; unsigned long maxread = *nelements; - bool ret = False; + bool ret = false; // try get the first element result = XGetWindowProperty(Display::display, win, atom, 0l, 1l, - False, AnyPropertyType, &ret_type, &ret_size, + false, AnyPropertyType, &ret_type, &ret_size, nelements, &ret_bytes, &c_val); ret = (result == Success && ret_type == type && ret_size == size && *nelements > 0); @@ -305,7 +305,7 @@ bool Property::get(Window win, Atom atom, Atom type, if (remain > size/8 * (signed)maxread) // dont get more than the max remain = size/8 * (signed)maxread; result = XGetWindowProperty(Display::display, win, atom, 0l, - remain, False, type, &ret_type, &ret_size, + remain, false, type, &ret_type, &ret_size, nelements, &ret_bytes, &c_val); ret = (result == Success && ret_type == type && ret_size == size && ret_bytes == 0); @@ -352,10 +352,10 @@ bool Property::get(Window win, Atoms atom, Atoms type, unsigned long num = 1; if (! get(win, _atoms[atom], _atoms[type], &num, reinterpret_cast(&temp), 32)) - return False; + return false; *value = temp[0]; delete [] temp; - return True; + return true; } @@ -363,20 +363,25 @@ bool Property::get(Window win, Atoms atom, Atoms type, * Gets an string property's value from a window. */ bool Property::get(Window win, Atoms atom, StringType type, - std::string *value) const + userstring *value) const { unsigned long n = 1; - StringVect s; + userstring::vector s; if (get(win, atom, type, &n, &s)) { *value = s[0]; - return True; + switch (type) { + case ascii: value->setUtf8(false); break; + case utf8: value->setUtf8(true); break; + default: assert(false); return false; // unhandled StringType + } + return true; } - return False; + return false; } bool Property::get(Window win, Atoms atom, StringType type, - unsigned long *nelements, StringVect *strings) const + unsigned long *nelements, userstring::vector *strings) const { assert(atom >= 0 && atom < NUM_ATOMS); assert(type >= 0 && type < NUM_STRING_TYPE); @@ -384,26 +389,27 @@ bool Property::get(Window win, Atoms atom, StringType type, assert(*nelements > 0); Atom t; + bool isutf8; switch (type) { - case ascii: t = _atoms[Atom_String]; break; - case utf8: t = _atoms[Atom_Utf8]; break; - default: assert(False); return False; // unhandled StringType + case ascii: t = _atoms[Atom_String]; isutf8 = false; break; + case utf8: t = _atoms[Atom_Utf8]; isutf8 = true; break; + default: assert(false); return false; // unhandled StringType } unsigned char *value; unsigned long elements = (unsigned) -1; if (!get(win, _atoms[atom], t, &elements, &value, 8) || elements < 1) - return False; + return false; - std::string s(reinterpret_cast(value), elements); + userstring s(reinterpret_cast(value), elements, isutf8); delete [] value; - std::string::const_iterator it = s.begin(), end = s.end(); + userstring::const_iterator it = s.begin(), end = s.end(); unsigned long num = 0; while(num < *nelements) { - std::string::const_iterator tmp = it; // current string.begin() + userstring::const_iterator tmp = it; // current string.begin() it = std::find(tmp, end, '\0'); // look for null between tmp and end - strings->push_back(std::string(tmp, it)); // s[tmp:it) + strings->push_back(userstring(tmp, it, isutf8)); // s[tmp:it) ++num; if (it == end) break; ++it; @@ -412,7 +418,7 @@ bool Property::get(Window win, Atoms atom, StringType type, *nelements = num; - return True; + return true; } diff --git a/otk/property.hh b/otk/property.hh index 7f4ae266..e942bfd2 100644 --- a/otk/property.hh +++ b/otk/property.hh @@ -14,8 +14,8 @@ extern "C" { } #include -#include +#include "userstring.hh" #include "screeninfo.hh" namespace otk { @@ -175,9 +175,6 @@ private: int size) const; public: - //! A list of strings - typedef std::vector StringVect; - //! Constructs a new Atom object /*! CAUTION: This constructor uses Display::display, so ensure that it is @@ -220,7 +217,7 @@ public: @param value The string to set the property to */ void set(Window win, Atoms atom, StringType type, - const std::string &value) const; + const userstring &value) const; //! Sets a string-array property on a window to a new value /*! @param win The window id of the window on which to set the property's value @@ -231,7 +228,7 @@ public: @param strings A list of strings to set the property to */ void set(Window win, Atoms atom, StringType type, - const StringVect &strings) const; + const userstring::vector &strings) const; //! Gets the value of a property on a window /*! @@ -284,7 +281,7 @@ public: @return true if retrieval of the specified property with the specified type was successful; otherwise, false */ - bool get(Window win, Atoms atom, StringType type, std::string *value) const; + bool get(Window win, Atoms atom, StringType type, userstring *value) const; //! Gets strings from the value of a property on a window /*! @param win The window id of the window to get the property value from @@ -303,7 +300,7 @@ public: type was successful; otherwise, false */ bool get(Window win, Atoms atom, StringType type, - unsigned long *nelements, StringVect *strings) const; + unsigned long *nelements, userstring::vector *strings) const; //! Removes a property from a window /*! diff --git a/otk/userstring.hh b/otk/userstring.hh index 0690f802..601d54e4 100644 --- a/otk/userstring.hh +++ b/otk/userstring.hh @@ -3,26 +3,102 @@ #define __userstring_hh #include +#include + +extern "C" { +#include +} //! userstring is a std::string with an extra flag specifying if the string is //! UTF-8 encoded. class userstring : public std::string { +public: + //! A vector of userstrings + typedef std::vector vector; + private: bool _utf8; public: userstring(bool utf8) : std::string(), _utf8(utf8) {} - userstring(const userstring& s, bool utf8, size_type pos = 0, - size_type n = npos) : std::string(s, pos, n), _utf8(utf8) {} - userstring(const charT *s, bool utf8) : std::string(s), _utf8(utf8) {} - userstring(const charT* s, size_type n, bool utf8) : std::string(s, n), - _utf8(utf8) {} - userstring(size_type n, charT c, bool utf8) : std::string(n, c), - _utf8(utf8) {} + userstring(const userstring& s, size_type pos = 0, + size_type n = npos) : std::string(s, pos, n), _utf8(s._utf8) {} + userstring(const char *s, bool utf8) : std::string(s), _utf8(utf8) {} + userstring(const char *s, size_type n, bool utf8) : std::string(s, n), + _utf8(utf8) {} + userstring(size_type n, char c, bool utf8) : std::string(n, c), + _utf8(utf8) {} + userstring(const_iterator first, const_iterator last, bool utf8) : + std::string(first, last), _utf8(utf8) {} //! Returns if the string is encoded in UTF-8 or not inline bool utf8() const { return _utf8; } + + inline void setUtf8(bool u) { _utf8 = u; } + + inline userstring& insert(size_type pos, const userstring& s) { + assert(s._utf8 == _utf8); + std::string::insert(pos, s); + return *this; + } + + inline userstring& insert(size_type pos, + const userstring& s, + size_type pos1, size_type n) { + assert(s._utf8 == _utf8); + std::string::insert(pos, s, pos1, n); + return *this; + } + + inline userstring& append(const userstring& s) { + assert(s._utf8 == _utf8); + std::string::append(s); + return *this; + } + + inline userstring& append(const userstring& s, + size_type pos, size_type n) { + assert(s._utf8 == _utf8); + std::string::append(s, pos, n); + return *this; + } + + inline userstring& assign(const userstring& s) { + assert(s._utf8 == _utf8); + std::string::assign(s); + return *this; + } + + inline userstring& assign(const userstring& s, + size_type pos, size_type n) { + assert(s._utf8 == _utf8); + std::string::assign(s, pos, n); + return *this; + } + + inline userstring& replace(size_type pos, size_type n, + const userstring& s) { + assert(s._utf8 == _utf8); + std::string::replace(pos, n, s); + return *this; + } + + inline userstring& replace(size_type pos, size_type n, + const userstring& s, + size_type pos1, size_type n1) { + assert(s._utf8 == _utf8); + std::string::replace(pos, n, s, pos1, n1); + return *this; + } + + inline userstring& operator=(const userstring& s) { + return assign(s); + } + + inline userstring& operator+=(const userstring& s) { + return append(s); + } }; #endif // __userstring_hh -- 2.39.2