]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Solaris compilation patches
[wxWidgets.git] / src / gtk1 / textctrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11#pragma implementation "textctrl.h"
12#endif
13
14#include "wx/textctrl.h"
15#include "wx/utils.h"
16#include "wx/intl.h"
17#include "wx/settings.h"
18
19#include <sys/types.h>
20#include <sys/stat.h>
21#include <ctype.h>
22
23#include "gdk/gdk.h"
24#include "gtk/gtk.h"
25#include "gdk/gdkkeysyms.h"
26
27//-----------------------------------------------------------------------------
28// data
29//-----------------------------------------------------------------------------
30
31extern bool g_blockEventsOnDrag;
32
33//-----------------------------------------------------------------------------
34// "changed"
35//-----------------------------------------------------------------------------
36
37static void
38gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
39{
40 win->SetModified();
41
42 win->CalculateScrollbar();
43
44 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
45 event.SetString( copystring(win->GetValue()) );
46 event.SetEventObject( win );
47 win->GetEventHandler()->ProcessEvent( event );
48 delete[] event.GetString();
49}
50
51//-----------------------------------------------------------------------------
52// "size_allocate"
53//-----------------------------------------------------------------------------
54
55static void
56gtk_text_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* WXUNUSED(alloc), wxTextCtrl *win )
57{
58 win->CalculateScrollbar();
59}
60
61//-----------------------------------------------------------------------------
62// wxTextCtrl
63//-----------------------------------------------------------------------------
64
65IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
66
67BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
68 EVT_CHAR(wxTextCtrl::OnChar)
69END_EVENT_TABLE()
70
71#ifndef NO_TEXT_WINDOW_STREAM
72wxTextCtrl::wxTextCtrl() : streambuf()
73{
74 if (allocate()) setp(base(),ebuf());
75
76 m_modified = FALSE;
77}
78#else
79wxTextCtrl::wxTextCtrl()
80{
81 m_modified = FALSE;
82}
83#endif
84
85#ifndef NO_TEXT_WINDOW_STREAM
86wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
87 const wxPoint &pos, const wxSize &size,
88 int style, const wxValidator& validator, const wxString &name ) : streambuf()
89{
90 if (allocate()) setp(base(),ebuf());
91
92 m_modified = FALSE;
93 Create( parent, id, value, pos, size, style, validator, name );
94}
95#else
96wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
97 const wxPoint &pos, const wxSize &size,
98 int style, const wxValidator& validator, const wxString &name )
99{
100 m_modified = FALSE;
101 Create( parent, id, value, pos, size, style, validator, name );
102}
103#endif
104
105bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
106 const wxPoint &pos, const wxSize &size,
107 int style, const wxValidator& validator, const wxString &name )
108{
109 m_needParent = TRUE;
110 m_acceptsFocus = TRUE;
111
112 PreCreation( parent, id, pos, size, style, name );
113
114 SetValidator( validator );
115
116 m_vScrollbarVisible = TRUE;
117
118 bool multi_line = (style & wxTE_MULTILINE) != 0;
119 if ( multi_line )
120 {
121 // a multi-line edit control: create a vertical scrollbar by default and
122 // horizontal if requested
123 bool bHasHScrollbar = (style & wxHSCROLL) != 0;
124
125 // create our control...
126 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
127
128 // ... and put into the upper left hand corner of the table
129 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
130 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
131 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
132 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
133 0, 0);
134
135 // put the horizontal scrollbar in the lower left hand corner
136 if (bHasHScrollbar)
137 {
138 GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
139 gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
140 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
141 GTK_FILL,
142 0, 0);
143 gtk_widget_show(hscrollbar);
144 }
145
146 // finally, put the vertical scrollbar in the upper right corner
147 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
148 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
149 GTK_FILL,
150 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
151 0, 0);
152 gtk_widget_show( m_vScrollbar );
153
154 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
155 GTK_SIGNAL_FUNC(gtk_text_size_callback), (gpointer)this );
156 }
157 else
158 {
159 // a single-line text control: no need for scrollbars
160 m_widget =
161 m_text = gtk_entry_new();
162 }
163
164 wxSize newSize = size;
165 if (newSize.x == -1) newSize.x = 80;
166 if (newSize.y == -1) newSize.y = 26;
167 SetSize( newSize.x, newSize.y );
168
169 m_parent->AddChild( this );
170
171 (m_parent->m_insertCallback)( m_parent, this );
172
173 PostCreation();
174
175 if (multi_line)
176 {
177 gtk_widget_realize(m_text);
178 gtk_widget_show(m_text);
179 }
180
181 // we want to be notified about text changes
182 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
183 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
184
185 if (!value.IsEmpty())
186 {
187 gint tmp = 0;
188 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
189
190 if (multi_line)
191 {
192 /* bring editable's cursor uptodate. bug in GTK. */
193
194 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
195 }
196 }
197
198 if (style & wxTE_PASSWORD)
199 {
200 if (!multi_line)
201 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
202 }
203
204 if (style & wxTE_READONLY)
205 {
206 if (!multi_line)
207 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
208 }
209 else
210 {
211 if (multi_line)
212 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
213 }
214
215 Show( TRUE );
216
217 SetBackgroundColour( parent->GetBackgroundColour() );
218 SetForegroundColour( parent->GetForegroundColour() );
219
220 return TRUE;
221}
222
223void wxTextCtrl::CalculateScrollbar()
224{
225 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
226
227 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
228
229 if (adj->upper - adj->page_size < 0.8)
230 {
231 if (m_vScrollbarVisible)
232 {
233 gtk_widget_hide( m_vScrollbar );
234
235 m_vScrollbarVisible = FALSE;
236 }
237 }
238 else
239 {
240 if (!m_vScrollbarVisible)
241 {
242 gtk_widget_show( m_vScrollbar );
243
244 m_vScrollbarVisible = TRUE;
245 }
246 }
247}
248
249wxString wxTextCtrl::GetValue() const
250{
251 wxCHECK_MSG( m_text != NULL, "", "invalid text ctrl" );
252
253 wxString tmp;
254 if (m_windowStyle & wxTE_MULTILINE)
255 {
256 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
257 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
258 tmp = text;
259 g_free( text );
260 }
261 else
262 {
263 tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
264 }
265 return tmp;
266}
267
268void wxTextCtrl::SetValue( const wxString &value )
269{
270 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
271
272 wxString tmp = "";
273 if (!value.IsNull()) tmp = value;
274 if (m_windowStyle & wxTE_MULTILINE)
275 {
276 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
277 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
278 len = 0;
279 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
280 }
281 else
282 {
283 gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
284 }
285}
286
287void wxTextCtrl::WriteText( const wxString &text )
288{
289 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
290
291 if (text.IsNull()) return;
292
293 if (m_windowStyle & wxTE_MULTILINE)
294 {
295 /* this moves the cursor pos to behind the inserted text */
296 gint len = GTK_EDITABLE(m_text)->current_pos;
297 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
298
299 /* bring editable's cursor uptodate. bug in GTK. */
300 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
301 }
302 else
303 {
304 /* this moves the cursor pos to behind the inserted text */
305 gint len = GTK_EDITABLE(m_text)->current_pos;
306 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
307
308 /* bring editable's cursor uptodate. bug in GTK. */
309 GTK_EDITABLE(m_text)->current_pos += text.Len();
310
311 /* bring entry's cursor uptodate. bug in GTK. */
312 gtk_entry_set_position( GTK_ENTRY(m_text), GTK_EDITABLE(m_text)->current_pos );
313 }
314}
315
316void wxTextCtrl::AppendText( const wxString &text )
317{
318 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
319
320 if (m_windowStyle & wxTE_MULTILINE)
321 {
322 /* we'll insert at the last position */
323 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
324 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
325
326 /* bring editable's cursor uptodate. bug in GTK. */
327 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
328 }
329 else
330 {
331 gtk_entry_append_text( GTK_ENTRY(m_text), text );
332 }
333}
334
335bool wxTextCtrl::LoadFile( const wxString &file )
336{
337 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
338
339 if (!wxFileExists(file)) return FALSE;
340
341 Clear();
342
343 FILE *fp = (FILE*) NULL;
344 struct stat statb;
345
346 if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
347 !(fp = fopen ((char*) (const char*) file, "r")))
348 {
349 return FALSE;
350 }
351 else
352 {
353 gint len = statb.st_size;
354 char *text;
355 if (!(text = (char*)malloc ((unsigned) (len + 1))))
356 {
357 fclose (fp);
358 return FALSE;
359 }
360 if (fread (text, sizeof (char), len, fp) != (size_t) len)
361 {
362 }
363 fclose (fp);
364
365 text[len] = 0;
366
367 if (m_windowStyle & wxTE_MULTILINE)
368 {
369 gint pos = 0;
370 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, len, &pos );
371 }
372 else
373 {
374 gtk_entry_set_text( GTK_ENTRY(m_text), text );
375 }
376
377 free (text);
378 m_modified = FALSE;
379 return TRUE;
380 }
381 return FALSE;
382}
383
384bool wxTextCtrl::SaveFile( const wxString &file )
385{
386 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
387
388 if (file == "") return FALSE;
389
390 FILE *fp;
391
392 if (!(fp = fopen ((char*) (const char*) file, "w")))
393 {
394 return FALSE;
395 }
396 else
397 {
398 char *text = (char*) NULL;
399 gint len = 0;
400
401 if (m_windowStyle & wxTE_MULTILINE)
402 {
403 len = gtk_text_get_length( GTK_TEXT(m_text) );
404 text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
405 }
406 else
407 {
408 text = gtk_entry_get_text( GTK_ENTRY(m_text) );
409 }
410
411 if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
412 {
413 // Did not write whole file
414 }
415
416 // Make sure newline terminates the file
417 if (text[len - 1] != '\n')
418 fputc ('\n', fp);
419
420 fclose (fp);
421
422 if (m_windowStyle & wxTE_MULTILINE) g_free( text );
423
424 m_modified = FALSE;
425 return TRUE;
426 }
427
428 return TRUE;
429}
430
431wxString wxTextCtrl::GetLineText( long lineNo ) const
432{
433 if (m_windowStyle & wxTE_MULTILINE)
434 {
435 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
436 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
437
438 if (text)
439 {
440 wxString buf("");
441 long i;
442 int currentLine = 0;
443 for (i = 0; currentLine != lineNo && text[i]; i++ )
444 if (text[i] == '\n')
445 currentLine++;
446 // Now get the text
447 int j;
448 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
449 buf += text[i];
450
451 g_free( text );
452 return buf;
453 }
454 else
455 return wxEmptyString;
456 }
457 else
458 {
459 if (lineNo == 0) return GetValue();
460 return wxEmptyString;
461 }
462}
463
464void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
465{
466 /* If you implement this, don't forget to update the documentation!
467 * (file docs/latex/wx/text.tex) */
468 wxFAIL_MSG( "wxTextCtrl::OnDropFiles not implemented" );
469}
470
471long wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
472{
473 if ( m_windowStyle & wxTE_MULTILINE )
474 {
475 wxString text = GetValue();
476
477 // cast to prevent warning. But pos really should've been unsigned.
478 if( (unsigned long)pos > text.Len() )
479 return FALSE;
480
481 *x=0; // First Col
482 *y=0; // First Line
483
484 const char* stop = text.c_str() + pos;
485 for ( const char *p = text.c_str(); p < stop; p++ )
486 {
487 if (*p == '\n')
488 {
489 (*y)++;
490 *x=0;
491 }
492 else
493 (*x)++;
494 }
495 }
496 else // single line control
497 {
498 if ( pos <= GTK_ENTRY(m_text)->text_length )
499 {
500 *y = 0;
501 *x = pos;
502 }
503 else
504 {
505 // index out of bounds
506 return FALSE;
507 }
508 }
509
510 return TRUE;
511}
512
513long wxTextCtrl::XYToPosition(long x, long y ) const
514{
515 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
516
517 long pos=0;
518 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
519
520 pos += x;
521 return pos;
522}
523
524int wxTextCtrl::GetLineLength(long lineNo) const
525{
526 wxString str = GetLineText (lineNo);
527 return (int) str.Length();
528}
529
530int wxTextCtrl::GetNumberOfLines() const
531{
532 if (m_windowStyle & wxTE_MULTILINE)
533 {
534 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
535 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
536
537 if (text)
538 {
539 int currentLine = 0;
540 for (int i = 0; i < len; i++ )
541 {
542 if (text[i] == '\n')
543 currentLine++;
544 }
545 g_free( text );
546
547 // currentLine is 0 based, add 1 to get number of lines
548 return currentLine + 1;
549 }
550 else
551 {
552 return 0;
553 }
554 }
555 else
556 {
557 return 1;
558 }
559}
560
561void wxTextCtrl::SetInsertionPoint( long pos )
562{
563 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
564
565 if (m_windowStyle & wxTE_MULTILINE)
566 {
567 /* seems to be broken in GTK 1.0.X:
568 gtk_text_set_point( GTK_TEXT(m_text), (int)pos ); */
569
570 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
571 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
572
573 /* we fake a set_point by inserting and deleting. as the user
574 isn't supposed to get to know about thos non-sense, we
575 disconnect so that no events are sent to the user program. */
576
577 gint tmp = (gint)pos;
578 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
579 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
580
581 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
582 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
583
584 /* bring editable's cursor uptodate. another bug in GTK. */
585
586 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
587 }
588 else
589 {
590 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
591
592 /* bring editable's cursor uptodate. bug in GTK. */
593
594 GTK_EDITABLE(m_text)->current_pos = pos;
595 }
596}
597
598void wxTextCtrl::SetInsertionPointEnd()
599{
600 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
601
602 if (m_windowStyle & wxTE_MULTILINE)
603 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
604 else
605 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
606}
607
608void wxTextCtrl::SetEditable( bool editable )
609{
610 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
611
612 if (m_windowStyle & wxTE_MULTILINE)
613 gtk_text_set_editable( GTK_TEXT(m_text), editable );
614 else
615 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
616}
617
618void wxTextCtrl::SetSelection( long from, long to )
619{
620 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
621
622 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
623}
624
625void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
626{
627 wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
628}
629
630long wxTextCtrl::GetInsertionPoint() const
631{
632 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
633
634 return (long) GTK_EDITABLE(m_text)->current_pos;
635}
636
637long wxTextCtrl::GetLastPosition() const
638{
639 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
640
641 int pos = 0;
642 if (m_windowStyle & wxTE_MULTILINE)
643 pos = gtk_text_get_length( GTK_TEXT(m_text) );
644 else
645 pos = GTK_ENTRY(m_text)->text_length;
646
647 return (long)pos;
648}
649
650void wxTextCtrl::Remove( long from, long to )
651{
652 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
653
654 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
655}
656
657void wxTextCtrl::Replace( long from, long to, const wxString &value )
658{
659 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
660
661 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
662 if (value.IsNull()) return;
663 gint pos = (gint)from;
664 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
665}
666
667void wxTextCtrl::Cut()
668{
669 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
670
671#if (GTK_MINOR_VERSION == 1)
672 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
673#else
674 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
675#endif
676}
677
678void wxTextCtrl::Copy()
679{
680 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
681
682#if (GTK_MINOR_VERSION == 1)
683 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
684#else
685 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
686#endif
687}
688
689void wxTextCtrl::Paste()
690{
691 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
692
693#if (GTK_MINOR_VERSION == 1)
694 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
695#else
696 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
697#endif
698}
699
700void wxTextCtrl::Clear()
701{
702 SetValue( "" );
703}
704
705void wxTextCtrl::OnChar( wxKeyEvent &key_event )
706{
707 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
708
709 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
710 {
711 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
712 event.SetEventObject(this);
713 if (GetEventHandler()->ProcessEvent(event)) return;
714 }
715
716 key_event.Skip();
717}
718
719#ifndef NO_TEXT_WINDOW_STREAM
720int wxTextCtrl::overflow( int WXUNUSED(c) )
721{
722 int len = pptr() - pbase();
723 char *txt = new char[len+1];
724 strncpy(txt, pbase(), len);
725 txt[len] = '\0';
726 (*this) << txt;
727 setp(pbase(), epptr());
728 delete[] txt;
729 return EOF;
730}
731
732int wxTextCtrl::sync()
733{
734 int len = pptr() - pbase();
735 char *txt = new char[len+1];
736 strncpy(txt, pbase(), len);
737 txt[len] = '\0';
738 (*this) << txt;
739 setp(pbase(), epptr());
740 delete[] txt;
741 return 0;
742}
743
744int wxTextCtrl::underflow()
745{
746 return EOF;
747}
748
749wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
750{
751 AppendText(s);
752 return *this;
753}
754
755wxTextCtrl& wxTextCtrl::operator<<(float f)
756{
757 static char buf[100];
758 sprintf(buf, "%.2f", f);
759 AppendText(buf);
760 return *this;
761}
762
763wxTextCtrl& wxTextCtrl::operator<<(double d)
764{
765 static char buf[100];
766 sprintf(buf, "%.2f", d);
767 AppendText(buf);
768 return *this;
769}
770
771wxTextCtrl& wxTextCtrl::operator<<(int i)
772{
773 static char buf[100];
774 sprintf(buf, "%i", i);
775 AppendText(buf);
776 return *this;
777}
778
779wxTextCtrl& wxTextCtrl::operator<<(long i)
780{
781 static char buf[100];
782 sprintf(buf, "%ld", i);
783 AppendText(buf);
784 return *this;
785}
786
787wxTextCtrl& wxTextCtrl::operator<<(const char c)
788{
789 char buf[2];
790
791 buf[0] = c;
792 buf[1] = 0;
793 AppendText(buf);
794 return *this;
795}
796#endif
797
798GtkWidget* wxTextCtrl::GetConnectWidget()
799{
800 return GTK_WIDGET(m_text);
801}
802
803bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
804{
805 if (m_windowStyle & wxTE_MULTILINE)
806 return (window == GTK_TEXT(m_text)->text_area);
807 else
808 return (window == GTK_ENTRY(m_text)->text_area);
809}
810
811void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
812{
813 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
814
815 // doesn't work
816}
817
818void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
819{
820 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
821
822 // doesn't work
823}
824
825void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
826{
827 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
828
829 wxControl::SetBackgroundColour( colour );
830
831 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
832 if (sysbg.Red() == colour.Red() &&
833 sysbg.Green() == colour.Green() &&
834 sysbg.Blue() == colour.Blue())
835 {
836 return;
837 }
838
839 if (!m_backgroundColour.Ok()) return;
840
841 if (m_windowStyle & wxTE_MULTILINE)
842 {
843 GdkWindow *window = GTK_TEXT(m_text)->text_area;
844 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
845 gdk_window_set_background( window, m_backgroundColour.GetColor() );
846 gdk_window_clear( window );
847 }
848}
849
850void wxTextCtrl::ApplyWidgetStyle()
851{
852 if (m_windowStyle & wxTE_MULTILINE)
853 {
854 // how ?
855 }
856 else
857 {
858 SetWidgetStyle();
859 gtk_widget_set_style( m_text, m_widgetStyle );
860 }
861}
862
wxWidgets (Impactor)