diff --git a/taglib/mpeg/id3v1/id3v1tag.cpp b/taglib/mpeg/id3v1/id3v1tag.cpp
index bcb773c3..5c3f85d1 100644
--- a/taglib/mpeg/id3v1/id3v1tag.cpp
+++ b/taglib/mpeg/id3v1/id3v1tag.cpp
@@ -32,6 +32,28 @@
 using namespace TagLib;
 using namespace ID3v1;
 
+namespace
+{
+  class DefaultStringHandler : public TagLib::StringHandler
+  {
+    virtual String parse(const ByteVector &data) const
+    {
+      return String(data, String::Latin1).stripWhiteSpace();
+    }
+
+    virtual ByteVector render(const String &s) const
+    {
+      if(s.isLatin1())
+        return s.data(String::Latin1);
+      else
+        return ByteVector();
+    }
+  };
+
+  const DefaultStringHandler defaultStringHandler;
+  const TagLib::StringHandler *stringHandler = &defaultStringHandler;
+}
+
 class ID3v1::Tag::TagPrivate
 {
 public:
@@ -47,38 +69,8 @@ public:
   String comment;
   uchar track;
   uchar genre;
-
-  static const TagLib::StringHandler *stringHandler;
 };
 
-namespace
-{
-  const ID3v1::StringHandler defaultStringHandler;
-}
-
-const TagLib::StringHandler *ID3v1::Tag::TagPrivate::stringHandler = &defaultStringHandler;
-
-////////////////////////////////////////////////////////////////////////////////
-// StringHandler implementation
-////////////////////////////////////////////////////////////////////////////////
-
-ID3v1::StringHandler::StringHandler()
-{
-}
-
-String ID3v1::StringHandler::parse(const ByteVector &data) const
-{
-  return String(data, String::Latin1).stripWhiteSpace();
-}
-
-ByteVector ID3v1::StringHandler::render(const String &s) const
-{
-  if(s.isLatin1())
-    return s.data(String::Latin1);
-  else
-    return ByteVector();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
@@ -107,11 +99,11 @@ ByteVector ID3v1::Tag::render() const
   ByteVector data;
 
   data.append(fileIdentifier());
-  data.append(TagPrivate::stringHandler->render(d->title).resize(30));
-  data.append(TagPrivate::stringHandler->render(d->artist).resize(30));
-  data.append(TagPrivate::stringHandler->render(d->album).resize(30));
-  data.append(TagPrivate::stringHandler->render(d->year).resize(4));
-  data.append(TagPrivate::stringHandler->render(d->comment).resize(28));
+  data.append(stringHandler->render(d->title).resize(30));
+  data.append(stringHandler->render(d->artist).resize(30));
+  data.append(stringHandler->render(d->album).resize(30));
+  data.append(stringHandler->render(d->year).resize(4));
+  data.append(stringHandler->render(d->comment).resize(28));
   data.append(char(0));
   data.append(char(d->track));
   data.append(char(d->genre));
@@ -207,9 +199,9 @@ void ID3v1::Tag::setGenreNumber(TagLib::uint i)
 void ID3v1::Tag::setStringHandler(const TagLib::StringHandler *handler)
 {
   if(handler)
-    TagPrivate::stringHandler = handler;
+    stringHandler = handler;
   else
-    TagPrivate::stringHandler = &defaultStringHandler;
+    stringHandler = &defaultStringHandler;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -235,16 +227,16 @@ void ID3v1::Tag::parse(const ByteVector &data)
 {
   int offset = 3;
 
-  d->title = TagPrivate::stringHandler->parse(data.mid(offset, 30));
+  d->title = stringHandler->parse(data.mid(offset, 30));
   offset += 30;
 
-  d->artist = TagPrivate::stringHandler->parse(data.mid(offset, 30));
+  d->artist = stringHandler->parse(data.mid(offset, 30));
   offset += 30;
 
-  d->album = TagPrivate::stringHandler->parse(data.mid(offset, 30));
+  d->album = stringHandler->parse(data.mid(offset, 30));
   offset += 30;
 
-  d->year = TagPrivate::stringHandler->parse(data.mid(offset, 4));
+  d->year = stringHandler->parse(data.mid(offset, 4));
   offset += 4;
 
   // Check for ID3v1.1 -- Note that ID3v1 *does not* support "track zero" -- this
@@ -255,7 +247,7 @@ void ID3v1::Tag::parse(const ByteVector &data)
   if(data[offset + 28] == 0 && data[offset + 29] != 0) {
     // ID3v1.1 detected
 
-    d->comment = TagPrivate::stringHandler->parse(data.mid(offset, 28));
+    d->comment = stringHandler->parse(data.mid(offset, 28));
     d->track = uchar(data[offset + 29]);
   }
   else
diff --git a/taglib/mpeg/id3v1/id3v1tag.h b/taglib/mpeg/id3v1/id3v1tag.h
index 01dda34b..8ac83546 100644
--- a/taglib/mpeg/id3v1/id3v1tag.h
+++ b/taglib/mpeg/id3v1/id3v1tag.h
@@ -39,48 +39,6 @@ namespace TagLib {
 
   namespace ID3v1 {
 
-    //! A abstraction for the string to data encoding in ID3v1 tags.
-
-    /*!
-     * ID3v1 should in theory always contain ISO-8859-1 (Latin1) data.  In
-     * practice it does not.  TagLib by default only supports ISO-8859-1 data
-     * in ID3v1 tags.
-     *
-     * However by subclassing TagLib::StringHandler class and reimplementing 
-     * parse() and render() and setting your reimplementation as the default 
-     * with ID3v1::Tag::setStringHandler() you can define how you would like 
-     * these transformations to be done.
-     *
-     * \warning It is advisable <b>not</b> to write non-ISO-8859-1 data to ID3v1
-     * tags.  Please consider disabling the writing of ID3v1 tags in the case
-     * that the data is not ISO-8859-1.
-     *
-     * \see ID3v1::Tag::setStringHandler()
-     */
-
-    class TAGLIB_EXPORT StringHandler : public TagLib::StringHandler
-    {
-    public:
-      StringHandler();
-
-      /*!
-       * Decode a string from \a data.  The default implementation assumes that
-       * \a data is an ISO-8859-1 (Latin1) character array.
-       */
-      virtual String parse(const ByteVector &data) const;
-
-      /*!
-       * Encode a ByteVector with the data from \a s.  The default implementation
-       * assumes that \a s is an ISO-8859-1 (Latin1) string.  If the string is
-       * does not conform to ISO-8859-1, no value is written.
-       *
-       * \warning It is recommended that you <b>not</b> override this method, but
-       * instead do not write an ID3v1 tag in the case that the data is not
-       * ISO-8859-1.
-       */
-      virtual ByteVector render(const String &s) const;
-    };
-
     //! The main class in the ID3v1 implementation
 
     /*!
@@ -173,8 +131,6 @@ namespace TagLib {
        *
        * \note The caller is responsible for deleting the previous handler
        * as needed after it is released.
-       *
-       * \see StringHandler
        */
       static void setStringHandler(const TagLib::StringHandler *handler);
 
diff --git a/taglib/mpeg/id3v2/id3v2tag.cpp b/taglib/mpeg/id3v2/id3v2tag.cpp
index b4a4bcf9..b7b183a4 100644
--- a/taglib/mpeg/id3v2/id3v2tag.cpp
+++ b/taglib/mpeg/id3v2/id3v2tag.cpp
@@ -51,6 +51,29 @@
 using namespace TagLib;
 using namespace ID3v2;
 
+namespace
+{
+  class DefaultStringHandler : public TagLib::StringHandler
+  {
+    virtual String parse(const ByteVector &data) const
+    {
+      return String(data, String::Latin1);
+    }
+
+    virtual ByteVector render(const String &s) const
+    {
+      // Not implemented on purpose. This function is never used.
+      return ByteVector();
+    }
+  };
+
+  const DefaultStringHandler defaultStringHandler;
+  const TagLib::StringHandler *stringHandler = &defaultStringHandler;
+
+  const offset_t MinPaddingSize = 1024;
+  const offset_t MaxPaddingSize = 1024 * 1024;
+}
+
 class ID3v2::Tag::TagPrivate
 {
 public:
@@ -79,41 +102,8 @@ public:
 
   FrameListMap frameListMap;
   FrameList frameList;
-
-  static const TagLib::StringHandler *stringHandler;
 };
 
-namespace
-{
-  const ID3v2::Latin1StringHandler defaultStringHandler;
-}
-
-const TagLib::StringHandler *ID3v2::Tag::TagPrivate::stringHandler = &defaultStringHandler;
-
-namespace
-{
-  const offset_t MinPaddingSize = 1024;
-  const offset_t MaxPaddingSize = 1024 * 1024;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Latin1StringHandler implementation
-////////////////////////////////////////////////////////////////////////////////
-
-ID3v2::Latin1StringHandler::Latin1StringHandler()
-{
-}
-
-String ID3v2::Latin1StringHandler::parse(const ByteVector &data) const
-{
-  return String(data, String::Latin1);
-}
-
-ByteVector ID3v2::Latin1StringHandler::render(const String &) const
-{
-  return ByteVector();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -141,7 +131,6 @@ ID3v2::Tag::~Tag()
   delete d;
 }
 
-
 String ID3v2::Tag::title() const
 {
   if(!d->frameListMap["TIT2"].isEmpty())
@@ -654,15 +643,15 @@ ByteVector ID3v2::Tag::render(int version) const
 
 TagLib::StringHandler const *ID3v2::Tag::latin1StringHandler()
 {
-  return TagPrivate::stringHandler;
+  return stringHandler;
 }
 
 void ID3v2::Tag::setLatin1StringHandler(const TagLib::StringHandler *handler)
 {
   if(handler)
-    TagPrivate::stringHandler = handler;
+    stringHandler = handler;
   else
-    TagPrivate::stringHandler = &defaultStringHandler;
+    stringHandler = &defaultStringHandler;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/taglib/mpeg/id3v2/id3v2tag.h b/taglib/mpeg/id3v2/id3v2tag.h
index cd742c5c..2a84bed2 100644
--- a/taglib/mpeg/id3v2/id3v2tag.h
+++ b/taglib/mpeg/id3v2/id3v2tag.h
@@ -58,42 +58,6 @@ namespace TagLib {
     typedef List<Frame *> FrameList;
     typedef Map<ByteVector, FrameList> FrameListMap;
 
-    //! An abstraction for the ISO-8859-1 string to data encoding in ID3v2 tags.
-
-    /*!
-     * ID3v2 tag can store strings in ISO-8859-1 (Latin1), and TagLib only
-     * supports genuine ISO-8859-1 by default.  However, in practice, non
-     * ISO-8859-1 encodings are often used instead of ISO-8859-1, such as
-     * Windows-1252 for western languages, Shift_JIS for Japanese and so on.
-     *
-     * Here is an option to read such tags by subclassing this class,
-     * reimplementing parse() and setting your reimplementation as the default
-     * with ID3v2::Tag::setStringHandler().
-     *
-     * \note Writing non-ISO-8859-1 tags is not implemented intentionally.
-     * Use UTF-16 or UTF-8 instead.
-     *
-     * \see ID3v2::Tag::setStringHandler()
-     */
-    class TAGLIB_EXPORT Latin1StringHandler : public TagLib::StringHandler
-    {
-    public:
-      Latin1StringHandler();
-
-      /*!
-       * Decode a string from \a data.  The default implementation assumes that
-       * \a data is an ISO-8859-1 (Latin1) character array.
-       */
-      virtual String parse(const ByteVector &data) const;
-
-      /*!
-       * Encode a ByteVector with the data from \a s.
-       *
-       * \note Not implemented intentionally.  Always returns empty \s ByteVector.
-       */
-      virtual ByteVector render(const String &s) const;
-    };
-
     //! The main class in the ID3v2 implementation
 
     /*!
@@ -364,8 +328,6 @@ namespace TagLib {
       /*!
        * Gets the current string handler that decides how the "Latin-1" data
        * will be converted to and from binary data.
-       *
-       * \see Latin1StringHandler
        */
       static TagLib::StringHandler const *latin1StringHandler();
 
@@ -378,7 +340,10 @@ namespace TagLib {
        * \note The caller is responsible for deleting the previous handler
        * as needed after it is released.
        *
-       * \see Latin1StringHandler
+       * \note User defined string handers are not used for rendering tags.
+       * TagLib doesn't support writing non-standard tags.
+       *
+       * \see latin1StringHandler
        */
       static void setLatin1StringHandler(const TagLib::StringHandler *handler);
 
diff --git a/taglib/riff/wav/infotag.cpp b/taglib/riff/wav/infotag.cpp
index 24e0304a..b9431ab9 100644
--- a/taglib/riff/wav/infotag.cpp
+++ b/taglib/riff/wav/infotag.cpp
@@ -32,42 +32,31 @@
 using namespace TagLib;
 using namespace RIFF::Info;
 
+namespace
+{
+  class DefaultStringHandler : public TagLib::StringHandler
+  {
+    virtual String parse(const ByteVector &data) const
+    {
+      return String(data, String::UTF8);
+    }
+
+    virtual ByteVector render(const String &s) const
+    {
+      return s.data(String::UTF8);
+    }
+  };
+
+  const DefaultStringHandler defaultStringHandler;
+  const TagLib::StringHandler *stringHandler = &defaultStringHandler;
+}
+
 class RIFF::Info::Tag::TagPrivate
 {
 public:
-  TagPrivate()
-  {}
-
   FieldMap fieldMap;
-
-  static const TagLib::StringHandler *stringHandler;
 };
 
-namespace
-{
-  const RIFF::Info::StringHandler defaultStringHandler;
-}
-
-const TagLib::StringHandler *RIFF::Info::Tag::TagPrivate::stringHandler = &defaultStringHandler;
-
-////////////////////////////////////////////////////////////////////////////////
-// StringHandler implementation
-////////////////////////////////////////////////////////////////////////////////
-
-RIFF::Info::StringHandler::StringHandler()
-{
-}
-
-String RIFF::Info::StringHandler::parse(const ByteVector &data) const
-{
-  return String(data, String::UTF8);
-}
-
-ByteVector RIFF::Info::StringHandler::render(const String &s) const
-{
-  return s.data(String::UTF8);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -208,7 +197,7 @@ ByteVector RIFF::Info::Tag::render() const
 
   FieldMap::ConstIterator it = d->fieldMap.begin();
   for(; it != d->fieldMap.end(); ++it) {
-    ByteVector text = TagPrivate::stringHandler->render(it->second);
+    ByteVector text = stringHandler->render(it->second);
     if(text.isEmpty())
       continue;
 
@@ -230,9 +219,9 @@ ByteVector RIFF::Info::Tag::render() const
 void RIFF::Info::Tag::setStringHandler(const TagLib::StringHandler *handler)
 {
   if(handler)
-    TagPrivate::stringHandler = handler;
+    stringHandler = handler;
   else
-    TagPrivate::stringHandler = &defaultStringHandler;
+    stringHandler = &defaultStringHandler;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -249,7 +238,7 @@ void RIFF::Info::Tag::parse(const ByteVector &data)
 
     const ByteVector id = data.mid(p, 4);
     if(RIFF::File::isValidChunkName(id)) {
-      const String text = TagPrivate::stringHandler->parse(data.mid(p + 8, size));
+      const String text = stringHandler->parse(data.mid(p + 8, size));
       d->fieldMap[id] = text;
     }
 
diff --git a/taglib/riff/wav/infotag.h b/taglib/riff/wav/infotag.h
index 0812d264..8960ebc5 100644
--- a/taglib/riff/wav/infotag.h
+++ b/taglib/riff/wav/infotag.h
@@ -45,38 +45,6 @@ namespace TagLib {
 
     typedef Map<ByteVector, String> FieldMap;
 
-    //! A abstraction for the string to data encoding in Info tags.
-
-    /*!
-     * RIFF INFO tag has no clear definitions about character encodings.
-     * In practice, local encoding of each system is largely used and UTF-8 is
-     * popular too.
-     *
-     * Here is an option to read and write tags in your preferred encoding
-     * by subclassing this class, reimplementing parse() and render() and setting
-     * your reimplementation as the default with Info::Tag::setStringHandler().
-     *
-     * \see ID3v1::Tag::setStringHandler()
-     */
-
-    class TAGLIB_EXPORT StringHandler : public TagLib::StringHandler
-    {
-    public:
-      StringHandler();
-
-      /*!
-       * Decode a string from \a data.  The default implementation assumes that
-       * \a data is an UTF-8 character array.
-       */
-      virtual String parse(const ByteVector &data) const;
-
-      /*!
-       * Encode a ByteVector with the data from \a s.  The default implementation
-       * assumes that \a s is an UTF-8 string.
-       */
-      virtual ByteVector render(const String &s) const;
-    };
-
     //! The main class in the RIFF INFO tag implementation
 
     /*!
@@ -169,8 +137,6 @@ namespace TagLib {
        *
        * \note The caller is responsible for deleting the previous handler
        * as needed after it is released.
-       *
-       * \see StringHandler
        */
       static void setStringHandler(const TagLib::StringHandler *handler);