1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/numformatter.h
// Purpose: interface to wxNumberFormatter
// Author: Fulvio Senore, Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@class wxNumberFormatter
Helper class for formatting and parsing numbers with thousands separators.
This class contains only static functions, so users must not create instances
but directly call the member functions.
@since 2.9.2
@library{wxbase}
*/
class wxNumberFormatter
{
public:
/**
Bit masks used with ToString().
*/
enum Style
{
/**
This flag can be used to indicate absence of any other flags below.
*/
Style_None = 0x00,
/**
If this flag is given, thousands separators will be inserted in the
number string representation as defined by the current locale.
*/
Style_WithThousandsSep = 0x01,
/**
If this flag is given, trailing zeroes in a floating point number
string representation will be omitted.
If the number is actually integer, the decimal separator will be
omitted as well. To give an example, formatting the number @c 1.23
with precision 5 will normally yield "1.23000" but with this flag
it would return "1.23". And formatting @c 123 with this flag will
return just "123" for any precision.
This flag can't be used with ToString() overload taking the integer
value.
*/
Style_NoTrailingZeroes = 0x02
};
/**
Returns string representation of an integer number.
By default, the string will use thousands separators if appropriate for
the current locale. This can be avoided by passing Style_None as @a
flags in which case the call to the function has exactly the same
effect as <code>wxString::Format("%ld", val)</code>.
Notice that calling ToString() with a value of type @c int and
non-default flags results in ambiguity between this overload and the
one below. To resolve it, you need to cast the value to @c long.
@param val
The variable to convert to a string.
@param flags
Combination of values from the Style enumeration (except for
Style_NoTrailingZeroes which can't be used with this overload).
*/
static wxString ToString(long val, int flags = Style_WithThousandsSep);
/**
Returns string representation of a floating point number.
@param val
The variable to convert to a string.
@param precision
Number of decimals to write in formatted string.
@param flags
Combination of values from the Style enumeration.
*/
static wxString
ToString(double val, int precision, int flags = Style_WithThousandsSep);
/**
Parse a string representation of a number possibly including thousands
separators.
These functions parse number representation in the current locale. On
success they return @true and store the result at the location pointed
to by @a val (which can't be @NULL), otherwise @false is returned.
@see wxString::ToLong(), wxString::ToDouble()
*/
//@{
static bool FromString(wxString s, long *val);
static bool FromString(wxString s, double *val);
//@}
/**
Get the decimal separator for the current locale.
Decimal separators is always defined and we fall back to returning '.'
in case of an error.
*/
static wxChar GetDecimalSeparator();
/**
Get the thousands separator if grouping of the digits is used by the
current locale.
The value returned in @a sep should be only used if the function
returns @true, otherwise no thousands separator should be used at all.
@param sep
Points to the variable receiving the thousands separator character
if it is used by the current locale. May be @NULL if only the
function return value is needed.
*/
static bool GetThousandsSeparatorIfUsed(wxChar *sep);
};
|
