base/i18n/rtl.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/i18n/rtl.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/logging.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/sys_string_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "third_party/icu/source/common/unicode/locid.h"
  13 #include "third_party/icu/source/common/unicode/uchar.h"
  14 #include "third_party/icu/source/common/unicode/uscript.h"
  15 #include "third_party/icu/source/i18n/unicode/coll.h"
  16
  17 namespace {
  18
  19 // Extract language, country and variant, but ignore keywords.  For example,
  20 // en-US, ca@valencia, ca-ES@valencia.
  21 std::string GetLocaleString(const icu::Locale& locale) {
  22   const char* language = locale.getLanguage();
  23   const char* country = locale.getCountry();
  24   const char* variant = locale.getVariant();
  25
  26   std::string result =
  27       (language != NULL && *language != '\0') ? language : "und";
  28
  29   if (country != NULL && *country != '\0') {
  30     result += '-';
  31     result += country;
  32   }
  33
  34   if (variant != NULL && *variant != '\0') {
  35     std::string variant_str(variant);
  36     base::StringToLowerASCII(&variant_str);
  37     result += '@' + variant_str;
  38   }
  39
  40   return result;
  41 }
  42
  43 // Returns LEFT_TO_RIGHT or RIGHT_TO_LEFT if |character| has strong
  44 // directionality, returns UNKNOWN_DIRECTION if it doesn't. Please refer to
  45 // http://unicode.org/reports/tr9/ for more information.
  46 base::i18n::TextDirection GetCharacterDirection(UChar32 character) {
  47   // Now that we have the character, we use ICU in order to query for the
  48   // appropriate Unicode BiDi character type.
  49   int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
  50   if ((property == U_RIGHT_TO_LEFT) ||
  51       (property == U_RIGHT_TO_LEFT_ARABIC) ||
  52       (property == U_RIGHT_TO_LEFT_EMBEDDING) ||
  53       (property == U_RIGHT_TO_LEFT_OVERRIDE)) {
  54     return base::i18n::RIGHT_TO_LEFT;
  55   } else if ((property == U_LEFT_TO_RIGHT) ||
  56              (property == U_LEFT_TO_RIGHT_EMBEDDING) ||
  57              (property == U_LEFT_TO_RIGHT_OVERRIDE)) {
  58     return base::i18n::LEFT_TO_RIGHT;
  59   }
  60   return base::i18n::UNKNOWN_DIRECTION;
  61 }
  62
  63 }  // namespace
  64
  65 namespace base {
  66 namespace i18n {
  67
  68 // Represents the locale-specific ICU text direction.
  69 static TextDirection g_icu_text_direction = UNKNOWN_DIRECTION;
  70
  71 // Convert the ICU default locale to a string.
  72 std::string GetConfiguredLocale() {
  73   return GetLocaleString(icu::Locale::getDefault());
  74 }
  75
  76 // Convert the ICU canonicalized locale to a string.
  77 std::string GetCanonicalLocale(const std::string& locale) {
  78   return GetLocaleString(icu::Locale::createCanonical(locale.c_str()));
  79 }
  80
  81 // Convert Chrome locale name to ICU locale name
  82 std::string ICULocaleName(const std::string& locale_string) {
  83   // If not Spanish, just return it.
  84   if (locale_string.substr(0, 2) != "es")
  85     return locale_string;
  86   // Expand es to es-ES.
  87   if (LowerCaseEqualsASCII(locale_string, "es"))
  88     return "es-ES";
  89   // Map es-419 (Latin American Spanish) to es-FOO depending on the system
  90   // locale.  If it's es-RR other than es-ES, map to es-RR. Otherwise, map
  91   // to es-MX (the most populous in Spanish-speaking Latin America).
  92   if (LowerCaseEqualsASCII(locale_string, "es-419")) {
  93     const icu::Locale& locale = icu::Locale::getDefault();
  94     std::string language = locale.getLanguage();
  95     const char* country = locale.getCountry();
  96     if (LowerCaseEqualsASCII(language, "es") &&
  97       !LowerCaseEqualsASCII(country, "es")) {
  98         language += '-';
  99         language += country;
 100         return language;
 101     }
 102     return "es-MX";
 103   }
 104   // Currently, Chrome has only "es" and "es-419", but later we may have
 105   // more specific "es-RR".
 106   return locale_string;
 107 }
 108
 109 void SetICUDefaultLocale(const std::string& locale_string) {
 110   icu::Locale locale(ICULocaleName(locale_string).c_str());
 111   UErrorCode error_code = U_ZERO_ERROR;
 112   icu::Locale::setDefault(locale, error_code);
 113   // This return value is actually bogus because Locale object is
 114   // an ID and setDefault seems to always succeed (regardless of the
 115   // presence of actual locale data). However,
 116   // it does not hurt to have it as a sanity check.
 117   DCHECK(U_SUCCESS(error_code));
 118   g_icu_text_direction = UNKNOWN_DIRECTION;
 119 }
 120
 121 bool IsRTL() {
 122   return ICUIsRTL();
 123 }
 124
 125 bool ICUIsRTL() {
 126   if (g_icu_text_direction == UNKNOWN_DIRECTION) {
 127     const icu::Locale& locale = icu::Locale::getDefault();
 128     g_icu_text_direction = GetTextDirectionForLocale(locale.getName());
 129   }
 130   return g_icu_text_direction == RIGHT_TO_LEFT;
 131 }
 132
 133 TextDirection GetTextDirectionForLocale(const char* locale_name) {
 134   UErrorCode status = U_ZERO_ERROR;
 135   ULayoutType layout_dir = uloc_getCharacterOrientation(locale_name, &status);
 136   DCHECK(U_SUCCESS(status));
 137   // Treat anything other than RTL as LTR.
 138   return (layout_dir != ULOC_LAYOUT_RTL) ? LEFT_TO_RIGHT : RIGHT_TO_LEFT;
 139 }
 140
 141 TextDirection GetFirstStrongCharacterDirection(const string16& text) {
 142   const UChar* string = text.c_str();
 143   size_t length = text.length();
 144   size_t position = 0;
 145   while (position < length) {
 146     UChar32 character;
 147     size_t next_position = position;
 148     U16_NEXT(string, next_position, length, character);
 149     TextDirection direction = GetCharacterDirection(character);
 150     if (direction != UNKNOWN_DIRECTION)
 151       return direction;
 152     position = next_position;
 153   }
 154   return LEFT_TO_RIGHT;
 155 }
 156
 157 TextDirection GetLastStrongCharacterDirection(const string16& text) {
 158   const UChar* string = text.c_str();
 159   size_t position = text.length();
 160   while (position > 0) {
 161     UChar32 character;
 162     size_t prev_position = position;
 163     U16_PREV(string, 0, prev_position, character);
 164     TextDirection direction = GetCharacterDirection(character);
 165     if (direction != UNKNOWN_DIRECTION)
 166       return direction;
 167     position = prev_position;
 168   }
 169   return LEFT_TO_RIGHT;
 170 }
 171
 172 TextDirection GetStringDirection(const string16& text) {
 173   const UChar* string = text.c_str();
 174   size_t length = text.length();
 175   size_t position = 0;
 176
 177   TextDirection result(UNKNOWN_DIRECTION);
 178   while (position < length) {
 179     UChar32 character;
 180     size_t next_position = position;
 181     U16_NEXT(string, next_position, length, character);
 182     TextDirection direction = GetCharacterDirection(character);
 183     if (direction != UNKNOWN_DIRECTION) {
 184       if (result != UNKNOWN_DIRECTION && result != direction)
 185         return UNKNOWN_DIRECTION;
 186       result = direction;
 187     }
 188     position = next_position;
 189   }
 190
 191   // Handle the case of a string not containing any strong directionality
 192   // characters defaulting to LEFT_TO_RIGHT.
 193   if (result == UNKNOWN_DIRECTION)
 194     return LEFT_TO_RIGHT;
 195
 196   return result;
 197 }
 198
 199 #if defined(OS_WIN)
 200 bool AdjustStringForLocaleDirection(string16* text) {
 201   if (!IsRTL() || text->empty())
 202     return false;
 203
 204   // Marking the string as LTR if the locale is RTL and the string does not
 205   // contain strong RTL characters. Otherwise, mark the string as RTL.
 206   bool has_rtl_chars = StringContainsStrongRTLChars(*text);
 207   if (!has_rtl_chars)
 208     WrapStringWithLTRFormatting(text);
 209   else
 210     WrapStringWithRTLFormatting(text);
 211
 212   return true;
 213 }
 214
 215 bool UnadjustStringForLocaleDirection(string16* text) {
 216   if (!IsRTL() || text->empty())
 217     return false;
 218
 219   *text = StripWrappingBidiControlCharacters(*text);
 220   return true;
 221 }
 222 #else
 223 bool AdjustStringForLocaleDirection(string16* text) {
 224   // On OS X & GTK the directionality of a label is determined by the first
 225   // strongly directional character.
 226   // However, we want to make sure that in an LTR-language-UI all strings are
 227   // left aligned and vice versa.
 228   // A problem can arise if we display a string which starts with user input.
 229   // User input may be of the opposite directionality to the UI. So the whole
 230   // string will be displayed in the opposite directionality, e.g. if we want to
 231   // display in an LTR UI [such as US English]:
 232   //
 233   // EMAN_NOISNETXE is now installed.
 234   //
 235   // Since EXTENSION_NAME begins with a strong RTL char, the label's
 236   // directionality will be set to RTL and the string will be displayed visually
 237   // as:
 238   //
 239   // .is now installed EMAN_NOISNETXE
 240   //
 241   // In order to solve this issue, we prepend an LRM to the string. An LRM is a
 242   // strongly directional LTR char.
 243   // We also append an LRM at the end, which ensures that we're in an LTR
 244   // context.
 245
 246   // Unlike Windows, Linux and OS X can correctly display RTL glyphs out of the
 247   // box so there is no issue with displaying zero-width bidi control characters
 248   // on any system.  Thus no need for the !IsRTL() check here.
 249   if (text->empty())
 250     return false;
 251
 252   bool ui_direction_is_rtl = IsRTL();
 253
 254   bool has_rtl_chars = StringContainsStrongRTLChars(*text);
 255   if (!ui_direction_is_rtl && has_rtl_chars) {
 256     WrapStringWithRTLFormatting(text);
 257     text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
 258                  kLeftToRightMark);
 259     text->push_back(kLeftToRightMark);
 260   } else if (ui_direction_is_rtl && has_rtl_chars) {
 261     WrapStringWithRTLFormatting(text);
 262     text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
 263                  kRightToLeftMark);
 264     text->push_back(kRightToLeftMark);
 265   } else if (ui_direction_is_rtl) {
 266     WrapStringWithLTRFormatting(text);
 267     text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
 268                  kRightToLeftMark);
 269     text->push_back(kRightToLeftMark);
 270   } else {
 271     return false;
 272   }
 273
 274   return true;
 275 }
 276
 277 bool UnadjustStringForLocaleDirection(string16* text) {
 278   if (text->empty())
 279     return false;
 280
 281   size_t begin_index = 0;
 282   char16 begin = text->at(begin_index);
 283   if (begin == kLeftToRightMark ||
 284       begin == kRightToLeftMark) {
 285     ++begin_index;
 286   }
 287
 288   size_t end_index = text->length() - 1;
 289   char16 end = text->at(end_index);
 290   if (end == kLeftToRightMark ||
 291       end == kRightToLeftMark) {
 292     --end_index;
 293   }
 294
 295   string16 unmarked_text =
 296       text->substr(begin_index, end_index - begin_index + 1);
 297   *text = StripWrappingBidiControlCharacters(unmarked_text);
 298   return true;
 299 }
 300
 301 #endif  // !OS_WIN
 302
 303 bool StringContainsStrongRTLChars(const string16& text) {
 304   const UChar* string = text.c_str();
 305   size_t length = text.length();
 306   size_t position = 0;
 307   while (position < length) {
 308     UChar32 character;
 309     size_t next_position = position;
 310     U16_NEXT(string, next_position, length, character);
 311
 312     // Now that we have the character, we use ICU in order to query for the
 313     // appropriate Unicode BiDi character type.
 314     int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
 315     if ((property == U_RIGHT_TO_LEFT) || (property == U_RIGHT_TO_LEFT_ARABIC))
 316       return true;
 317
 318     position = next_position;
 319   }
 320
 321   return false;
 322 }
 323
 324 void WrapStringWithLTRFormatting(string16* text) {
 325   if (text->empty())
 326     return;
 327
 328   // Inserting an LRE (Left-To-Right Embedding) mark as the first character.
 329   text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
 330                kLeftToRightEmbeddingMark);
 331
 332   // Inserting a PDF (Pop Directional Formatting) mark as the last character.
 333   text->push_back(kPopDirectionalFormatting);
 334 }
 335
 336 void WrapStringWithRTLFormatting(string16* text) {
 337   if (text->empty())
 338     return;
 339
 340   // Inserting an RLE (Right-To-Left Embedding) mark as the first character.
 341   text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
 342                kRightToLeftEmbeddingMark);
 343
 344   // Inserting a PDF (Pop Directional Formatting) mark as the last character.
 345   text->push_back(kPopDirectionalFormatting);
 346 }
 347
 348 void WrapPathWithLTRFormatting(const FilePath& path,
 349                                string16* rtl_safe_path) {
 350   // Wrap the overall path with LRE-PDF pair which essentialy marks the
 351   // string as a Left-To-Right string.
 352   // Inserting an LRE (Left-To-Right Embedding) mark as the first character.
 353   rtl_safe_path->push_back(kLeftToRightEmbeddingMark);
 354 #if defined(OS_MACOSX)
 355     rtl_safe_path->append(UTF8ToUTF16(path.value()));
 356 #elif defined(OS_WIN)
 357     rtl_safe_path->append(path.value());
 358 #else  // defined(OS_POSIX) && !defined(OS_MACOSX)
 359     std::wstring wide_path = base::SysNativeMBToWide(path.value());
 360     rtl_safe_path->append(WideToUTF16(wide_path));
 361 #endif
 362   // Inserting a PDF (Pop Directional Formatting) mark as the last character.
 363   rtl_safe_path->push_back(kPopDirectionalFormatting);
 364 }
 365
 366 string16 GetDisplayStringInLTRDirectionality(const string16& text) {
 367   // Always wrap the string in RTL UI (it may be appended to RTL string).
 368   // Also wrap strings with an RTL first strong character direction in LTR UI.
 369   if (IsRTL() || GetFirstStrongCharacterDirection(text) == RIGHT_TO_LEFT) {
 370     string16 text_mutable(text);
 371     WrapStringWithLTRFormatting(&text_mutable);
 372     return text_mutable;
 373   }
 374   return text;
 375 }
 376
 377 string16 StripWrappingBidiControlCharacters(const string16& text) {
 378   if (text.empty())
 379     return text;
 380   size_t begin_index = 0;
 381   char16 begin = text[begin_index];
 382   if (begin == kLeftToRightEmbeddingMark ||
 383       begin == kRightToLeftEmbeddingMark ||
 384       begin == kLeftToRightOverride ||
 385       begin == kRightToLeftOverride)
 386     ++begin_index;
 387   size_t end_index = text.length() - 1;
 388   if (text[end_index] == kPopDirectionalFormatting)
 389     --end_index;
 390   return text.substr(begin_index, end_index - begin_index + 1);
 391 }
 392
 393 }  // namespace i18n
 394 }  // namespace base