]> git.saurik.com Git - wxWidgets.git/blob - docs/latex/wx/txtstrm.tex
Documentedm, that the print setup dialog has been
[wxWidgets.git] / docs / latex / wx / txtstrm.tex
1 % ----------------------------------------------------------------------------
2 % wxTextInputStream
3 % ----------------------------------------------------------------------------
4 \section{\class{wxTextInputStream}}\label{wxtextinputstream}
5
6 This class provides functions that read text datas using an input stream.
7 So, you can read {\it text} floats, integers.
8
9 The wxTextInputStream correctly reads text files (or streams) in DOS, Macintosh
10 and Unix formats and reports a single newline char as a line ending.
11
12 Operator >> is overloaded and you can use this class like a standard C++ iostream.
13 Note, however, that the arguments are the fixed size types wxUint32, wxInt32 etc
14 and on a typical 32-bit computer, none of these match to the "long" type (wxInt32
15 is defined as int on 32-bit architectures) so that you cannot use long. To avoid
16 problems (here and elsewhere), make use of wxInt32, wxUint32 and similar types.
17
18 If you're scanning through a file using wxTextInputStream, you should check for EOF {\bf before}
19 reading the next item (word / number), because otherwise the last item may get lost.
20 You should however be prepared to receive an empty item (empty string / zero number) at the
21 end of file, especially on Windows systems. This is unavoidable because most (but not all) files end
22 with whitespace (i.e. usually a newline).
23
24 For example:
25
26 \begin{verbatim}
27 wxFileInputStream input( "mytext.txt" );
28 wxTextInputStream text( input );
29 wxUint8 i1;
30 float f2;
31 wxString line;
32
33 text >> i1; // read a 8 bit integer.
34 text >> i1 >> f2; // read a 8 bit integer followed by float.
35 text >> line; // read a text line
36 \end{verbatim}
37
38 \wxheading{Include files}
39
40 <wx/txtstrm.h>
41
42 \latexignore{\rtfignore{\wxheading{Members}}}
43
44 \membersection{wxTextInputStream::wxTextInputStream}\label{wxtextinputstreamctor}
45
46 \func{}{wxTextInputStream}{\param{wxInputStream\&}{ stream}, \param{const wxString\&}{ sep=" $\backslash$t"},
47 \param{wxMBConv\&}{ conv = wxConvUTF8} }
48
49 Constructs a text stream associated to the given input stream.
50
51 \wxheading{Parameters}
52
53 \docparam{stream}{The underlying input stream.}
54
55 \docparam{sep}{The initial string separator characters.}
56
57 \docparam{conv}{{\it In Unicode build only:} The encoding converter used to convert the bytes in the
58 underlying input stream to characters.}
59
60 \membersection{wxTextInputStream::\destruct{wxTextInputStream}}\label{wxtextinputstreamdtor}
61
62 \func{}{\destruct{wxTextInputStream}}{\void}
63
64 Destroys the wxTextInputStream object.
65
66 \membersection{wxTextInputStream::Read8}\label{wxtextinputstreamread8}
67
68 \func{wxUint8}{Read8}{\param{int}{ base = 10}}
69
70 Reads a single unsigned byte from the stream, given in base {\it base}.
71
72 The value of {\it base} must be comprised between $2$ and $36$, inclusive, or
73 be a special value $0$ which means that the usual rules of {\tt C} numbers are
74 applied: if the number starts with {\tt 0x} it is considered to be in base
75 $16$, if it starts with {\tt 0} - in base $8$ and in base $10$ otherwise. Note
76 that you may not want to specify the base $0$ if you are parsing the numbers
77 which may have leading zeroes as they can yield unexpected (to the user not
78 familiar with C) results.
79
80 \membersection{wxTextInputStream::Read8S}\label{wxtextinputstreamread8s}
81
82 \func{wxInt8}{Read8S}{\param{int}{ base = 10}}
83
84 Reads a single signed byte from the stream.
85
86 See \helpref{wxTextInputStream::Read8}{wxtextinputstreamread8} for the
87 description of the {\it base} parameter.
88
89 \membersection{wxTextInputStream::Read16}\label{wxtextinputstreamread16}
90
91 \func{wxUint16}{Read16}{\param{int}{ base = 10}}
92
93 Reads a unsigned 16 bit integer from the stream.
94
95 See \helpref{wxTextInputStream::Read8}{wxtextinputstreamread8} for the
96 description of the {\it base} parameter.
97
98 \membersection{wxTextInputStream::Read16S}\label{wxtextinputstreamread16s}
99
100 \func{wxInt16}{Read16S}{\param{int}{ base = 10}}
101
102 Reads a signed 16 bit integer from the stream.
103
104 See \helpref{wxTextInputStream::Read8}{wxtextinputstreamread8} for the
105 description of the {\it base} parameter.
106
107 \membersection{wxTextInputStream::Read32}\label{wxtextinputstreamread32}
108
109 \func{wxUint32}{Read32}{\param{int}{ base = 10}}
110
111 Reads a 32 bit unsigned integer from the stream.
112
113 See \helpref{wxTextInputStream::Read8}{wxtextinputstreamread8} for the
114 description of the {\it base} parameter.
115
116 \membersection{wxTextInputStream::Read32S}\label{wxtextinputstreamread32s}
117
118 \func{wxInt32}{Read32S}{\param{int}{ base = 10}}
119
120 Reads a 32 bit signed integer from the stream.
121
122 See \helpref{wxTextInputStream::Read8}{wxtextinputstreamread8} for the
123 description of the {\it base} parameter.
124
125 \membersection{wxTextInputStream::GetChar}\label{wxtextinputstreamgetchar}
126
127 \func{wxChar}{wxTextInputStream::GetChar}{\void}
128
129 Reads a character, returns $0$ if there are no more characters in the stream.
130
131 \membersection{wxTextInputStream::ReadDouble}\label{wxtextinputstreamreaddouble}
132
133 \func{double}{ReadDouble}{\void}
134
135 Reads a double (IEEE encoded) from the stream.
136
137 \membersection{wxTextInputStream::ReadLine}\label{wxtextinputstreamreadline}
138
139 \func{wxString}{wxTextInputStream::ReadLine}{\void}
140
141 Reads a line from the input stream and returns it (without the end of line
142 character).
143
144 \membersection{wxTextInputStream::ReadString}\label{wxtextinputstreamreadstring}
145
146 \func{wxString}{wxTextInputStream::ReadString}{\void}
147
148 {\bf NB:} This method is deprecated, use \helpref{ReadLine}{wxtextinputstreamreadline}
149 or \helpref{ReadWord}{wxtextinputstreamreadword} instead.
150
151 Same as \helpref{ReadLine}{wxtextinputstreamreadline}.
152
153 \membersection{wxTextInputStream::ReadWord}\label{wxtextinputstreamreadword}
154
155 \func{wxString}{wxTextInputStream::ReadWord}{\void}
156
157 Reads a word (a sequence of characters until the next separator) from the
158 input stream.
159
160 \wxheading{See also}
161
162 \helpref{SetStringSeparators}{wxtextinputstreamsetstringseparators}
163
164 \membersection{wxTextInputStream::SetStringSeparators}\label{wxtextinputstreamsetstringseparators}
165
166 \func{void}{SetStringSeparators}{\param{const wxString\& }{sep}}
167
168 Sets the characters which are used to define the word boundaries in
169 \helpref{ReadWord}{wxtextinputstreamreadword}.
170
171 The default separators are the space and {\tt TAB} characters.
172
173 % ----------------------------------------------------------------------------
174 % wxTextOutputStream
175 % ----------------------------------------------------------------------------
176
177 \section{\class{wxTextOutputStream}}\label{wxtextoutputstream}
178
179 This class provides functions that write text datas using an output stream.
180 So, you can write {\it text} floats, integers.
181
182 You can also simulate the C++ cout class:
183
184 \begin{verbatim}
185 wxFFileOutputStream output( stderr );
186 wxTextOutputStream cout( output );
187
188 cout << "This is a text line" << endl;
189 cout << 1234;
190 cout << 1.23456;
191 \end{verbatim}
192
193 The wxTextOutputStream writes text files (or streams) on DOS, Macintosh
194 and Unix in their native formats (concerning the line ending).
195
196 \latexignore{\rtfignore{\wxheading{Members}}}
197
198 \membersection{wxTextOutputStream::wxTextOutputStream}\label{wxtextoutputstreamctor}
199
200 \func{}{wxTextOutputStream}{\param{wxOutputStream\&}{ stream}, \param{wxEOL}{ mode = wxEOL\_NATIVE}, \param{wxMBConv\&}{ conv = wxConvUTF8}}
201
202 Constructs a text stream object associated to the given output stream.
203
204 \wxheading{Parameters}
205
206 \docparam{stream}{The output stream.}
207
208 \docparam{mode}{The end-of-line mode. One of {\bf wxEOL\_NATIVE}, {\bf wxEOL\_DOS}, {\bf wxEOL\_MAC} and {\bf wxEOL\_UNIX}.}
209
210 \docparam{conv}{{\it In Unicode build only:} The object used to convert
211 Unicode text into ASCII characters written to the output stream.}
212
213 \membersection{wxTextOutputStream::\destruct{wxTextOutputStream}}\label{wxtextoutputstreamdtor}
214
215 \func{}{\destruct{wxTextOutputStream}}{\void}
216
217 Destroys the wxTextOutputStream object.
218
219 \membersection{wxTextOutputStream::GetMode}\label{wxtextoutputstreamgetmode}
220
221 \func{wxEOL}{wxTextOutputStream::GetMode}{\void}
222
223 Returns the end-of-line mode. One of {\bf wxEOL\_DOS}, {\bf wxEOL\_MAC} and {\bf wxEOL\_UNIX}.
224
225 \membersection{wxTextOutputStream::SetMode}\label{wxtextoutputstreamsetmode}
226
227 \func{void}{wxTextOutputStream::SetMode}{{\param wxEOL}{ mode = wxEOL\_NATIVE}}
228
229 Set the end-of-line mode. One of {\bf wxEOL\_NATIVE}, {\bf wxEOL\_DOS}, {\bf wxEOL\_MAC} and {\bf wxEOL\_UNIX}.
230
231 \membersection{wxTextOutputStream::Write8}\label{wxtextoutputstreamwrite8}
232
233 \func{void}{wxTextOutputStream::Write8}{{\param wxUint8 }{i8}}
234
235 Writes the single byte {\it i8} to the stream.
236
237 \membersection{wxTextOutputStream::PutChar}\label{wxtextoutputstreamputchar}
238
239 \func{void}{wxTextOutputStream::PutChar}{{\param wxChar }{c}}
240
241 Writes a character to the stream.
242
243 \membersection{wxTextOutputStream::Write16}\label{wxtextoutputstreamwrite16}
244
245 \func{void}{wxTextOutputStream::Write16}{{\param wxUint16 }{i16}}
246
247 Writes the 16 bit integer {\it i16} to the stream.
248
249 \membersection{wxTextOutputStream::Write32}\label{wxtextoutputstreamwrite32}
250
251 \func{void}{wxTextOutputStream::Write32}{{\param wxUint32 }{i32}}
252
253 Writes the 32 bit integer {\it i32} to the stream.
254
255 \membersection{wxTextOutputStream::WriteDouble}\label{wxtextoutputstreamwritedouble}
256
257 \func{virtual void}{wxTextOutputStream::WriteDouble}{{\param double }{f}}
258
259 Writes the double {\it f} to the stream using the IEEE format.
260
261 \membersection{wxTextOutputStream::WriteString}\label{wxtextoutputstreamwritestring}
262
263 \func{virtual void}{wxTextOutputStream::WriteString}{{\param const wxString\& }{string}}
264
265 Writes {\it string} as a line. Depending on the end-of-line mode the end of
266 line ('$\backslash$n') characters in the string are converted to the correct
267 line ending terminator.
268