]> git.saurik.com Git - wxWidgets.git/blob - src/common/txtstrm.cpp
remove sizing controls when being in fullscreen mode
[wxWidgets.git] / src / common / txtstrm.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: txtstrm.cpp
3 // Purpose: Text stream classes
4 // Author: Guilhem Lavaux
5 // Modified by:
6 // Created: 28/06/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Guilhem Lavaux
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_STREAMS
20
21 #include "wx/txtstrm.h"
22 #include <ctype.h>
23
24
25 // ----------------------------------------------------------------------------
26 // constants
27 // ----------------------------------------------------------------------------
28
29 // Unix: "\n"
30 // Dos: "\r\n"
31 // Mac: "\r"
32
33 // ----------------------------------------------------------------------------
34 // wxTextInputStream
35 // ----------------------------------------------------------------------------
36
37 #if wxUSE_UNICODE
38 wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep, wxMBConv& conv)
39 : m_input(s), m_separators(sep), m_conv(conv)
40 {
41 memset((void*)m_lastBytes, 0, 10);
42 }
43 #else
44 wxTextInputStream::wxTextInputStream(wxInputStream &s, const wxString &sep)
45 : m_input(s), m_separators(sep)
46 {
47 memset((void*)m_lastBytes, 0, 10);
48 }
49 #endif
50
51 wxTextInputStream::~wxTextInputStream()
52 {
53 }
54
55 void wxTextInputStream::UngetLast()
56 {
57 size_t byteCount = 0;
58 while(m_lastBytes[byteCount]) // pseudo ANSI strlen (even for Unicode!)
59 byteCount++;
60 m_input.Ungetch(m_lastBytes, byteCount);
61 memset((void*)m_lastBytes, 0, 10);
62 }
63
64 wxChar wxTextInputStream::NextChar()
65 {
66 #if wxUSE_UNICODE
67 wxChar wbuf[2];
68 memset((void*)m_lastBytes, 0, 10);
69 for(size_t inlen = 0; inlen < 9; inlen++)
70 {
71 // actually read the next character
72 m_lastBytes[inlen] = m_input.GetC();
73
74 if(m_input.LastRead() <= 0)
75 return wxEOT;
76
77 int retlen = (int) m_conv.MB2WC(wbuf, m_lastBytes, 2); // returns -1 for failure
78 if(retlen >= 0) // res == 0 could happen for '\0' char
79 return wbuf[0];
80 }
81 // there should be no encoding which requires more than nine bytes for one character...
82 return wxEOT;
83 #else
84 m_lastBytes[0] = m_input.GetC();
85
86 if(m_input.LastRead() <= 0)
87 return wxEOT;
88
89 return m_lastBytes[0];
90 #endif
91
92 }
93
94 wxChar wxTextInputStream::NextNonSeparators()
95 {
96 for (;;)
97 {
98 wxChar c = NextChar();
99 if (c == wxEOT) return (wxChar) 0;
100
101 if (c != wxT('\n') &&
102 c != wxT('\r') &&
103 !m_separators.Contains(c))
104 return c;
105 }
106
107 }
108
109 bool wxTextInputStream::EatEOL(const wxChar &c)
110 {
111 if (c == wxT('\n')) return true; // eat on UNIX
112
113 if (c == wxT('\r')) // eat on both Mac and DOS
114 {
115 wxChar c2 = NextChar();
116 if(c2 == wxEOT) return true; // end of stream reached, had enough :-)
117
118 if (c2 != wxT('\n')) UngetLast(); // Don't eat on Mac
119 return true;
120 }
121
122 return false;
123 }
124
125 wxUint32 wxTextInputStream::Read32(int base)
126 {
127 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
128 if(!m_input) return 0;
129
130 wxString word = ReadWord();
131 if(word.empty())
132 return 0;
133 return wxStrtoul(word.c_str(), 0, base);
134 }
135
136 wxUint16 wxTextInputStream::Read16(int base)
137 {
138 return (wxUint16)Read32(base);
139 }
140
141 wxUint8 wxTextInputStream::Read8(int base)
142 {
143 return (wxUint8)Read32(base);
144 }
145
146 wxInt32 wxTextInputStream::Read32S(int base)
147 {
148 wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
149 if(!m_input) return 0;
150
151 wxString word = ReadWord();
152 if(word.empty())
153 return 0;
154 return wxStrtol(word.c_str(), 0, base);
155 }
156
157 wxInt16 wxTextInputStream::Read16S(int base)
158 {
159 return (wxInt16)Read32S(base);
160 }
161
162 wxInt8 wxTextInputStream::Read8S(int base)
163 {
164 return (wxInt8)Read32S(base);
165 }
166
167 double wxTextInputStream::ReadDouble()
168 {
169 if(!m_input) return 0;
170 wxString word = ReadWord();
171 if(word.empty())
172 return 0;
173 return wxStrtod(word.c_str(), 0);
174 }
175
176 wxString wxTextInputStream::ReadString()
177 {
178 return ReadLine();
179 }
180
181 wxString wxTextInputStream::ReadLine()
182 {
183 wxString line;
184
185 while ( !m_input.Eof() )
186 {
187 wxChar c = NextChar();
188 if(c == wxEOT)
189 break;
190
191 if ( !m_input )
192 break;
193
194 if (EatEOL(c))
195 break;
196
197 line += c;
198 }
199
200 return line;
201 }
202
203 wxString wxTextInputStream::ReadWord()
204 {
205 wxString word;
206
207 if ( !m_input )
208 return word;
209
210 wxChar c = NextNonSeparators();
211 if ( !c )
212 return word;
213
214 word += c;
215
216 while ( !m_input.Eof() )
217 {
218 c = NextChar();
219 if(c == wxEOT)
220 break;
221
222 if (m_separators.Contains(c))
223 break;
224
225 if (EatEOL(c))
226 break;
227
228 word += c;
229 }
230
231 return word;
232 }
233
234 wxTextInputStream& wxTextInputStream::operator>>(wxString& word)
235 {
236 word = ReadWord();
237 return *this;
238 }
239
240 wxTextInputStream& wxTextInputStream::operator>>(char& c)
241 {
242 c = m_input.GetC();
243 if(m_input.LastRead() <= 0) c = 0;
244
245 if (EatEOL(c))
246 c = '\n';
247
248 return *this;
249 }
250
251 #if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
252
253 wxTextInputStream& wxTextInputStream::operator>>(wchar_t& wc)
254 {
255 wc = GetChar();
256
257 return *this;
258 }
259
260 #endif // wxUSE_UNICODE
261
262 wxTextInputStream& wxTextInputStream::operator>>(wxInt16& i)
263 {
264 i = (wxInt16)Read16();
265 return *this;
266 }
267
268 wxTextInputStream& wxTextInputStream::operator>>(wxInt32& i)
269 {
270 i = (wxInt32)Read32();
271 return *this;
272 }
273
274 wxTextInputStream& wxTextInputStream::operator>>(wxUint16& i)
275 {
276 i = Read16();
277 return *this;
278 }
279
280 wxTextInputStream& wxTextInputStream::operator>>(wxUint32& i)
281 {
282 i = Read32();
283 return *this;
284 }
285
286 wxTextInputStream& wxTextInputStream::operator>>(double& i)
287 {
288 i = ReadDouble();
289 return *this;
290 }
291
292 wxTextInputStream& wxTextInputStream::operator>>(float& f)
293 {
294 f = (float)ReadDouble();
295 return *this;
296 }
297
298
299
300 #if wxUSE_UNICODE
301 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode, wxMBConv& conv)
302 : m_output(s), m_conv(conv)
303 #else
304 wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
305 : m_output(s)
306 #endif
307 {
308 m_mode = mode;
309 if (m_mode == wxEOL_NATIVE)
310 {
311 #if defined(__WXMSW__) || defined(__WXPM__)
312 m_mode = wxEOL_DOS;
313 #elif defined(__WXMAC__) && !defined(__DARWIN__)
314 m_mode = wxEOL_MAC;
315 #else
316 m_mode = wxEOL_UNIX;
317 #endif
318 }
319 }
320
321 wxTextOutputStream::~wxTextOutputStream()
322 {
323 }
324
325 void wxTextOutputStream::SetMode(wxEOL mode)
326 {
327 m_mode = mode;
328 if (m_mode == wxEOL_NATIVE)
329 {
330 #if defined(__WXMSW__) || defined(__WXPM__)
331 m_mode = wxEOL_DOS;
332 #elif defined(__WXMAC__) && !defined(__DARWIN__)
333 m_mode = wxEOL_MAC;
334 #else
335 m_mode = wxEOL_UNIX;
336 #endif
337 }
338 }
339
340 void wxTextOutputStream::Write32(wxUint32 i)
341 {
342 wxString str;
343 str.Printf(wxT("%u"), i);
344
345 WriteString(str);
346 }
347
348 void wxTextOutputStream::Write16(wxUint16 i)
349 {
350 wxString str;
351 str.Printf(wxT("%u"), (unsigned)i);
352
353 WriteString(str);
354 }
355
356 void wxTextOutputStream::Write8(wxUint8 i)
357 {
358 wxString str;
359 str.Printf(wxT("%u"), (unsigned)i);
360
361 WriteString(str);
362 }
363
364 void wxTextOutputStream::WriteDouble(double d)
365 {
366 wxString str;
367
368 str.Printf(wxT("%f"), d);
369 WriteString(str);
370 }
371
372 void wxTextOutputStream::WriteString(const wxString& string)
373 {
374 size_t len = string.length();
375
376 wxString out;
377 out.reserve(len);
378
379 for ( size_t i = 0; i < len; i++ )
380 {
381 const wxChar c = string[i];
382 if ( c == wxT('\n') )
383 {
384 switch ( m_mode )
385 {
386 case wxEOL_DOS:
387 out << _T("\r\n");
388 continue;
389
390 case wxEOL_MAC:
391 out << _T('\r');
392 continue;
393
394 default:
395 wxFAIL_MSG( _T("unknown EOL mode in wxTextOutputStream") );
396 // fall through
397
398 case wxEOL_UNIX:
399 // don't treat '\n' specially
400 ;
401 }
402 }
403
404 out << c;
405 }
406
407 // We must not write the trailing NULL here
408 #if wxUSE_UNICODE
409 wxCharBuffer buffer = m_conv.cWC2MB( out );
410 m_output.Write( (const char*) buffer, strlen( (const char*) buffer ) );
411 #else
412 m_output.Write(out.c_str(), out.length() );
413 #endif
414 }
415
416 wxTextOutputStream& wxTextOutputStream::PutChar(wxChar c)
417 {
418 #if wxUSE_UNICODE
419 WriteString( wxString(&c, m_conv, 1) );
420 #else
421 WriteString( wxString(&c, wxConvLocal, 1) );
422 #endif
423 return *this;
424 }
425
426 wxTextOutputStream& wxTextOutputStream::operator<<(const wxChar *string)
427 {
428 WriteString( wxString(string) );
429 return *this;
430 }
431
432 wxTextOutputStream& wxTextOutputStream::operator<<(const wxString& string)
433 {
434 WriteString( string );
435 return *this;
436 }
437
438 wxTextOutputStream& wxTextOutputStream::operator<<(char c)
439 {
440 WriteString( wxString::FromAscii(c) );
441
442 return *this;
443 }
444
445 #if wxUSE_UNICODE && wxWCHAR_T_IS_REAL_TYPE
446
447 wxTextOutputStream& wxTextOutputStream::operator<<(wchar_t wc)
448 {
449 WriteString( wxString(&wc, m_conv, 1) );
450
451 return *this;
452 }
453
454 #endif // wxUSE_UNICODE
455
456 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt16 c)
457 {
458 wxString str;
459 str.Printf(wxT("%d"), (signed int)c);
460 WriteString(str);
461
462 return *this;
463 }
464
465 wxTextOutputStream& wxTextOutputStream::operator<<(wxInt32 c)
466 {
467 wxString str;
468 str.Printf(wxT("%ld"), (signed long)c);
469 WriteString(str);
470
471 return *this;
472 }
473
474 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint16 c)
475 {
476 wxString str;
477 str.Printf(wxT("%u"), (unsigned int)c);
478 WriteString(str);
479
480 return *this;
481 }
482
483 wxTextOutputStream& wxTextOutputStream::operator<<(wxUint32 c)
484 {
485 wxString str;
486 str.Printf(wxT("%lu"), (unsigned long)c);
487 WriteString(str);
488
489 return *this;
490 }
491
492 wxTextOutputStream &wxTextOutputStream::operator<<(double f)
493 {
494 WriteDouble(f);
495 return *this;
496 }
497
498 wxTextOutputStream& wxTextOutputStream::operator<<(float f)
499 {
500 WriteDouble((double)f);
501 return *this;
502 }
503
504 wxTextOutputStream &endl( wxTextOutputStream &stream )
505 {
506 return stream.PutChar(wxT('\n'));
507 }
508
509 #endif
510 // wxUSE_STREAMS