1 // Copyright (c) 2010 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 #ifndef BASE_I18N_RTL_H_ 6 #define BASE_I18N_RTL_H_ 7 #pragma once 8 9 #include <string> 10 11 #include "base/compiler_specific.h" 12 #include "base/string16.h" 13 #include "build/build_config.h" 14 15 class FilePath; 16 17 namespace base { 18 namespace i18n { 19 20 const char16 kRightToLeftMark = 0x200F; 21 const char16 kLeftToRightMark = 0x200E; 22 const char16 kLeftToRightEmbeddingMark = 0x202A; 23 const char16 kRightToLeftEmbeddingMark = 0x202B; 24 const char16 kPopDirectionalFormatting = 0x202C; 25 const char16 kLeftToRightOverride = 0x202D; 26 const char16 kRightToLeftOverride = 0x202E; 27 28 enum TextDirection { 29 UNKNOWN_DIRECTION, 30 RIGHT_TO_LEFT, 31 LEFT_TO_RIGHT, 32 }; 33 34 // Get the locale that the currently running process has been configured to use. 35 // The return value is of the form language[-country] (e.g., en-US) where the 36 // language is the 2 or 3 letter code from ISO-639. 37 std::string GetConfiguredLocale(); 38 39 // Canonicalize a string (eg. a POSIX locale string) to a Chrome locale name. 40 std::string GetCanonicalLocale(const char* locale); 41 42 // Sets the default locale of ICU. 43 // Once the application locale of Chrome in GetApplicationLocale is determined, 44 // the default locale of ICU need to be changed to match the application locale 45 // so that ICU functions work correctly in a locale-dependent manner. 46 // This is handy in that we don't have to call GetApplicationLocale() 47 // everytime we call locale-dependent ICU APIs as long as we make sure 48 // that this is called before any locale-dependent API is called. 49 void SetICUDefaultLocale(const std::string& locale_string); 50 51 // Returns true if the application text direction is right-to-left. 52 bool IsRTL(); 53 54 // Returns whether the text direction for the default ICU locale is RTL. This 55 // assumes that SetICUDefaultLocale has been called to set the default locale to 56 // the UI locale of Chrome. 57 // NOTE: Generally, you should call IsRTL() instead of this. 58 bool ICUIsRTL(); 59 60 // Returns the text direction for |locale_name|. 61 TextDirection GetTextDirectionForLocale(const char* locale_name); 62 63 // Given the string in |text|, returns the directionality of the first 64 // character with strong directionality in the string. If no character in the 65 // text has strong directionality, LEFT_TO_RIGHT is returned. The Bidi 66 // character types L, LRE, LRO, R, AL, RLE, and RLO are considered as strong 67 // directionality characters. Please refer to http://unicode.org/reports/tr9/ 68 // for more information. 69 TextDirection GetFirstStrongCharacterDirection(const string16& text); 70 #if defined(WCHAR_T_IS_UTF32) 71 TextDirection GetFirstStrongCharacterDirection(const std::wstring& text); 72 #endif 73 74 // Given the string in |text|, this function modifies the string in place with 75 // the appropriate Unicode formatting marks that mark the string direction 76 // (either left-to-right or right-to-left). The function checks both the current 77 // locale and the contents of the string in order to determine the direction of 78 // the returned string. The function returns true if the string in |text| was 79 // properly adjusted. 80 // 81 // Certain LTR strings are not rendered correctly when the context is RTL. For 82 // example, the string "Foo!" will appear as "!Foo" if it is rendered as is in 83 // an RTL context. Calling this function will make sure the returned localized 84 // string is always treated as a right-to-left string. This is done by 85 // inserting certain Unicode formatting marks into the returned string. 86 // 87 // ** Notes about the Windows version of this function: 88 // TODO(idana) bug 6806: this function adjusts the string in question only 89 // if the current locale is right-to-left. The function does not take care of 90 // the opposite case (an RTL string displayed in an LTR context) since 91 // adjusting the string involves inserting Unicode formatting characters that 92 // Windows does not handle well unless right-to-left language support is 93 // installed. Since the English version of Windows doesn't have right-to-left 94 // language support installed by default, inserting the direction Unicode mark 95 // results in Windows displaying squares. 96 bool AdjustStringForLocaleDirection(string16* text); 97 #if defined(WCHAR_T_IS_UTF32) 98 bool AdjustStringForLocaleDirection(std::wstring* text); 99 #endif 100 101 // Returns true if the string contains at least one character with strong right 102 // to left directionality; that is, a character with either R or AL Unicode 103 // BiDi character type. 104 bool StringContainsStrongRTLChars(const string16& text); 105 #if defined(WCHAR_T_IS_UTF32) 106 bool StringContainsStrongRTLChars(const std::wstring& text); 107 #endif 108 109 // Wraps a string with an LRE-PDF pair which essentialy marks the string as a 110 // Left-To-Right string. Doing this is useful in order to make sure LTR 111 // strings are rendered properly in an RTL context. 112 void WrapStringWithLTRFormatting(string16* text); 113 #if defined(WCHAR_T_IS_UTF32) 114 void WrapStringWithLTRFormatting(std::wstring* text); 115 #endif 116 117 // Wraps a string with an RLE-PDF pair which essentialy marks the string as a 118 // Right-To-Left string. Doing this is useful in order to make sure RTL 119 // strings are rendered properly in an LTR context. 120 void WrapStringWithRTLFormatting(string16* text); 121 #if defined(WCHAR_T_IS_UTF32) 122 void WrapStringWithRTLFormatting(std::wstring* text); 123 #endif 124 125 // Wraps file path to get it to display correctly in RTL UI. All filepaths 126 // should be passed through this function before display in UI for RTL locales. 127 void WrapPathWithLTRFormatting(const FilePath& path, 128 string16* rtl_safe_path); 129 130 // Given the string in |text|, this function returns the adjusted string having 131 // LTR directionality for display purpose. Which means that in RTL locale the 132 // string is wrapped with LRE (Left-To-Right Embedding) and PDF (Pop 133 // Directional Formatting) marks and returned. In LTR locale, the string itself 134 // is returned. 135 string16 GetDisplayStringInLTRDirectionality(const string16& text) 136 WARN_UNUSED_RESULT; 137 138 // Strip the beginning (U+202A..U+202B, U+202D..U+202E) and/or ending (U+202C) 139 // explicit bidi control characters from |text|, if there are any. Otherwise, 140 // return the text itself. Explicit bidi control characters display and have 141 // semantic effect. They can be deleted so they might not always appear in a 142 // pair. 143 const string16 StripWrappingBidiControlCharacters(const string16& text) 144 WARN_UNUSED_RESULT; 145 146 } // namespace i18n 147 } // namespace base 148 149 #endif // BASE_I18N_RTL_H_ 150