source/charconverters.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include "strrefdup.h"
  20 #include "charconverters.h"
  21 #include "shapesexceptions.h"
  22 #include "glyphlist.h"
  23 #include "characterencoding.h"
  24 #include "texttypes.h"
  25
  26
  27 #include <iconv.h>
  28 #include <string>
  29 #include <fstream>
  30 #include <sstream>
  31
  32
  33
  34 using namespace Shapes;
  35
  36 const char * Helpers::theUCS4EncodingName = "UCS-4";
  37
  38 iconv_t
  39 Helpers::requireUTF8ToMacRomanConverter( bool cleanup )
  40 {
  41         static iconv_t converter = (iconv_t)( - 1 );
  42         if( cleanup )
  43                 {
  44                         if( converter != (iconv_t)( -1 ) )
  45                                 {
  46                                         iconv_close( converter );
  47                                         converter = (iconv_t)( -1 );
  48                                 }
  49                 }
  50         else
  51                 {
  52                         if( converter == (iconv_t)( -1 ) )
  53                                 {
  54                                         const char * iconv_Encoding_name = "Macintosh"; // This is meant to be what is called MacRoman in PDF.
  55                                         converter = iconv_open( iconv_Encoding_name, "UTF-8" );
  56                                         if( converter == (iconv_t)( -1 ) )
  57                                                 {
  58                                                         std::ostringstream msg;
  59                                                         msg << "iconv_open failed to create converter from UTF-8 to " << iconv_Encoding_name << "." ;
  60                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
  61                                                 }
  62                                 }
  63                 }
  64         return converter;
  65 }
  66
  67 iconv_t
  68 Helpers::requireMacRomanToUTF8Converter( bool cleanup )
  69 {
  70         static iconv_t converter = (iconv_t)( - 1 );
  71         if( cleanup )
  72                 {
  73                         if( converter != (iconv_t)( -1 ) )
  74                                 {
  75                                         iconv_close( converter );
  76                                         converter = (iconv_t)( -1 );
  77                                 }
  78                 }
  79         else
  80                 {
  81                         if( converter == (iconv_t)( -1 ) )
  82                                 {
  83                                         const char * iconv_Encoding_name = "Macintosh"; // This is meant to be what is called MacRoman in PDF.
  84                                         converter = iconv_open( "UTF-8", iconv_Encoding_name );
  85                                         if( converter == (iconv_t)( -1 ) )
  86                                                 {
  87                                                         std::ostringstream msg;
  88                                                         msg << "iconv_open failed to create converter to UTF-8 from " << iconv_Encoding_name << "." ;
  89                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
  90                                                 }
  91                                 }
  92                 }
  93         return converter;
  94 }
  95
  96 iconv_t
  97 Helpers::requireUTF8ToASCIIConverter( bool cleanup )
  98 {
  99         static iconv_t converter = (iconv_t)( - 1 );
 100         if( cleanup )
 101                 {
 102                         if( converter != (iconv_t)( -1 ) )
 103                                 {
 104                                         iconv_close( converter );
 105                                         converter = (iconv_t)( -1 );
 106                                 }
 107                 }
 108         else
 109                 {
 110                         if( converter == (iconv_t)( -1 ) )
 111                                 {
 112                                         const char * iconv_Encoding_name = "ASCII";     // This is used for the names of glyphs in a font
 113                                         converter = iconv_open( iconv_Encoding_name, "UTF-8" );
 114                                         if( converter == (iconv_t)( -1 ) )
 115                                                 {
 116                                                         std::ostringstream msg;
 117                                                         msg << "iconv_open failed to create converter from UTF-8 to " << iconv_Encoding_name << "." ;
 118                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
 119                                                 }
 120                                 }
 121                 }
 122         return converter;
 123 }
 124
 125 iconv_t
 126 Helpers::requireUTF8ToUCS4Converter( bool cleanup )
 127 {
 128         static iconv_t converter = (iconv_t)( - 1 );
 129         if( cleanup )
 130                 {
 131                         if( converter != (iconv_t)( -1 ) )
 132                                 {
 133                                         iconv_close( converter );
 134                                         converter = (iconv_t)( -1 );
 135                                 }
 136                 }
 137         else
 138                 {
 139                         if( converter == (iconv_t)( -1 ) )
 140                                 {
 141                                         const char * iconv_Encoding_name = Helpers::theUCS4EncodingName;        // This is used for the glyph list.
 142                                         converter = iconv_open( iconv_Encoding_name, "UTF-8" );
 143                                         if( converter == (iconv_t)( -1 ) )
 144                                                 {
 145                                                         std::ostringstream msg;
 146                                                         msg << "iconv_open failed to create converter from UTF-8 to " << iconv_Encoding_name << "." ;
 147                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
 148                                                 }
 149                                 }
 150                 }
 151         return converter;
 152 }
 153
 154 iconv_t
 155 Helpers::requireUTF16BEToUCS4Converter( bool cleanup )
 156 {
 157         static iconv_t converter = (iconv_t)( - 1 );
 158         if( cleanup )
 159                 {
 160                         if( converter != (iconv_t)( -1 ) )
 161                                 {
 162                                         iconv_close( converter );
 163                                         converter = (iconv_t)( -1 );
 164                                 }
 165                 }
 166         else
 167                 {
 168                         if( converter == (iconv_t)( -1 ) )
 169                                 {
 170                                         const char * iconv_Encoding_name = Helpers::theUCS4EncodingName;        // This is used for the glyph list.
 171                                         converter = iconv_open( iconv_Encoding_name, "UTF-16BE" );
 172                                         if( converter == (iconv_t)( -1 ) )
 173                                                 {
 174                                                         std::ostringstream msg;
 175                                                         msg << "iconv_open failed to create converter from UTF-8 to " << iconv_Encoding_name << "." ;
 176                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
 177                                                 }
 178                                 }
 179                 }
 180         return converter;
 181 }
 182
 183 iconv_t
 184 Helpers::requireUTF8ToWinANSIConverter( bool cleanup )
 185 {
 186         static iconv_t converter = (iconv_t)( - 1 );
 187         if( cleanup )
 188                 {
 189                         if( converter != (iconv_t)( -1 ) )
 190                                 {
 191                                         iconv_close( converter );
 192                                         converter = (iconv_t)( -1 );
 193                                 }
 194                 }
 195         else
 196                 {
 197                         if( converter == (iconv_t)( -1 ) )
 198                                 {
 199                                         const char * iconv_Encoding_name = "LATIN1";    // This is meant to be what is called WinANSI in PDF.
 200                                         converter = iconv_open( iconv_Encoding_name, "UTF-8" );
 201                                         if( converter == (iconv_t)( -1 ) )
 202                                                 {
 203                                                         std::ostringstream msg;
 204                                                         msg << "iconv_open failed to create converter from UTF-8 to " << iconv_Encoding_name << "." ;
 205                                                         throw Exceptions::ExternalError( strrefdup( msg ) );
 206                                                 }
 207                                 }
 208                 }
 209         return converter;
 210 }
 211
 212 const FontMetrics::GlyphList &
 213 Helpers::requireGlyphList( bool cleanup )
 214 {
 215         static const FontMetrics::GlyphList * converter = 0;
 216         if( cleanup )
 217                 {
 218                         if( converter != 0 )
 219                                 {
 220                                         delete converter;
 221                                         converter = 0;
 222                                 }
 223                 }
 224         else
 225                 {
 226                         if( converter == 0 )
 227                                 {
 228                                         std::string filename = Lang::Font::searchGlyphList( );
 229                                         std::ifstream iFile( filename.c_str( ) );
 230                                         if( ! iFile.is_open( ) )
 231                                                 {
 232                                                         std::ostringstream oss;
 233                                                         oss << "Could locate, but not open the glyph list " << filename ;
 234                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 235                                                 }
 236                                         try
 237                                                 {
 238                                                         converter = new FontMetrics::GlyphList( iFile );
 239                                                 }
 240                                         catch( const char * ball )
 241                                                 {
 242                                                         std::ostringstream oss;
 243                                                         oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
 244                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 245                                                 }
 246                                         catch( const std::string ball )
 247                                                 {
 248                                                         std::ostringstream oss;
 249                                                         oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
 250                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 251                                                 }
 252                                         catch( const Shapes::Exceptions::Exception & ball )
 253                                                 {
 254                                                         std::cerr << "Parsing the glyph list " << filename << " resulted an error.      Rethrowing." << std::endl ;
 255                                                         throw;
 256                                                 }
 257                                         catch( ... )
 258                                                 {
 259                                                         throw Exceptions::InternalError( "An unrecognized exception was caught from glyph list parsing." );
 260                                                 }
 261                                 }
 262                 }
 263         return *converter;
 264 }
 265
 266 const FontMetrics::CharacterEncoding &
 267 Helpers::requireMacRomanEncoding( bool cleanup )
 268 {
 269         static const FontMetrics::CharacterEncoding * converter = 0;
 270         if( cleanup )
 271                 {
 272                         if( converter != 0 )
 273                                 {
 274                                         delete converter;
 275                                         converter = 0;
 276                                 }
 277                 }
 278         else
 279                 {
 280                         if( converter == 0 )
 281                                 {
 282                                         std::string filename = Lang::Font::searchCharacterEncoding( "MacRoman" );
 283                                         std::ifstream iFile( filename.c_str( ) );
 284                                         if( ! iFile.is_open( ) )
 285                                                 {
 286                                                         std::ostringstream oss;
 287                                                         oss << "Could locate, but not open the character encoding " << filename ;
 288                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 289                                                 }
 290                                         try
 291                                                 {
 292                                                         converter = new FontMetrics::CharacterEncoding( iFile );
 293                                                 }
 294                                         catch( const char * ball )
 295                                                 {
 296                                                         std::ostringstream oss;
 297                                                         oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
 298                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 299                                                 }
 300                                         catch( const std::string ball )
 301                                                 {
 302                                                         std::ostringstream oss;
 303                                                         oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
 304                                                         throw Exceptions::ExternalError( strrefdup( oss ) );
 305                                                 }
 306                                         catch( const Shapes::Exceptions::Exception & ball )
 307                                                 {
 308                                                         std::cerr << "Parsing the character encoding " << filename << " resulted an error.      Rethrowing." << std::endl ;
 309                                                         throw;
 310                                                 }
 311                                         catch( ... )
 312                                                 {
 313                                                         throw Exceptions::InternalError( "An unrecognized exception was caught from character encoding parsing." );
 314                                                 }
 315                                 }
 316                 }
 317         return *converter;
 318 }