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
15class FilePath;
16
17namespace base {
18namespace i18n {
19
20const char16 kRightToLeftMark = 0x200F;
21const char16 kLeftToRightMark = 0x200E;
22const char16 kLeftToRightEmbeddingMark = 0x202A;
23const char16 kRightToLeftEmbeddingMark = 0x202B;
24const char16 kPopDirectionalFormatting = 0x202C;
25const char16 kLeftToRightOverride = 0x202D;
26const char16 kRightToLeftOverride = 0x202E;
27
28enum 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.
37std::string GetConfiguredLocale();
38
39// Canonicalize a string (eg. a POSIX locale string) to a Chrome locale name.
40std::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.
49void SetICUDefaultLocale(const std::string& locale_string);
50
51// Returns true if the application text direction is right-to-left.
52bool 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.
58bool ICUIsRTL();
59
60// Returns the text direction for |locale_name|.
61TextDirection 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.
69TextDirection GetFirstStrongCharacterDirection(const string16& text);
70#if defined(WCHAR_T_IS_UTF32)
71TextDirection 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.
96bool AdjustStringForLocaleDirection(string16* text);
97#if defined(WCHAR_T_IS_UTF32)
98bool 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.
104bool StringContainsStrongRTLChars(const string16& text);
105#if defined(WCHAR_T_IS_UTF32)
106bool 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.
112void WrapStringWithLTRFormatting(string16* text);
113#if defined(WCHAR_T_IS_UTF32)
114void 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.
120void WrapStringWithRTLFormatting(string16* text);
121#if defined(WCHAR_T_IS_UTF32)
122void 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.
127void 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.
135string16 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.
143const string16 StripWrappingBidiControlCharacters(const string16& text)
144    WARN_UNUSED_RESULT;
145
146}  // namespace i18n
147}  // namespace base
148
149#endif  // BASE_I18N_RTL_H_
150