← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/i18n/rtl.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

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