]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/textctrl.cpp
Added distribution script
[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.IsNull())
186 {
187 gint tmp = 0;
188 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
189 SetInsertionPointEnd();
190 }
191
192 if (style & wxTE_PASSWORD)
193 {
194 if (!multi_line)
195 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
196 }
197
198 if (style & wxTE_READONLY)
199 {
200 if (!multi_line)
201 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
202 }
203 else
204 {
205 if (multi_line)
206 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
207 }
208
209 Show( TRUE );
210
211 SetBackgroundColour( parent->GetBackgroundColour() );
212 SetForegroundColour( parent->GetForegroundColour() );
213
214 return TRUE;
215}
216
217void wxTextCtrl::CalculateScrollbar()
218{
219 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
220
221 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
222
223 if (adj->upper - adj->page_size < 0.8)
224 {
225 if (m_vScrollbarVisible)
226 {
227 gtk_widget_hide( m_vScrollbar );
228
229 m_vScrollbarVisible = FALSE;
230 }
231 }
232 else
233 {
234 if (!m_vScrollbarVisible)
235 {
236 gtk_widget_show( m_vScrollbar );
237
238 m_vScrollbarVisible = TRUE;
239 }
240 }
241}
242
243wxString wxTextCtrl::GetValue() const
244{
245 wxCHECK_MSG( m_text != NULL, "", "invalid text ctrl" );
246
247 wxString tmp;
248 if (m_windowStyle & wxTE_MULTILINE)
249 {
250 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
251 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
252 tmp = text;
253 g_free( text );
254 }
255 else
256 {
257 tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
258 }
259 return tmp;
260}
261
262void wxTextCtrl::SetValue( const wxString &value )
263{
264 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
265
266 wxString tmp = "";
267 if (!value.IsNull()) tmp = value;
268 if (m_windowStyle & wxTE_MULTILINE)
269 {
270 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
271 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
272 len = 0;
273 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
274 }
275 else
276 {
277 gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
278 }
279}
280
281void wxTextCtrl::WriteText( const wxString &text )
282{
283 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
284
285 if (text.IsNull()) return;
286
287 if (m_windowStyle & wxTE_MULTILINE)
288 {
289 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
290 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
291 }
292 else
293 {
294 gtk_entry_append_text( GTK_ENTRY(m_text), text );
295 }
296}
297
298bool wxTextCtrl::LoadFile( const wxString &file )
299{
300 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
301
302 if (!wxFileExists(file)) return FALSE;
303
304 Clear();
305
306 FILE *fp = (FILE*) NULL;
307 struct stat statb;
308
309 if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
310 !(fp = fopen ((char*) (const char*) file, "r")))
311 {
312 return FALSE;
313 }
314 else
315 {
316 gint len = statb.st_size;
317 char *text;
318 if (!(text = (char*)malloc ((unsigned) (len + 1))))
319 {
320 fclose (fp);
321 return FALSE;
322 }
323 if (fread (text, sizeof (char), len, fp) != (size_t) len)
324 {
325 }
326 fclose (fp);
327
328 text[len] = 0;
329
330 if (m_windowStyle & wxTE_MULTILINE)
331 {
332 gint pos = 0;
333 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, len, &pos );
334 }
335 else
336 {
337 gtk_entry_set_text( GTK_ENTRY(m_text), text );
338 }
339
340 free (text);
341 m_modified = FALSE;
342 return TRUE;
343 }
344 return FALSE;
345}
346
347bool wxTextCtrl::SaveFile( const wxString &file )
348{
349 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
350
351 if (file == "") return FALSE;
352
353 FILE *fp;
354
355 if (!(fp = fopen ((char*) (const char*) file, "w")))
356 {
357 return FALSE;
358 }
359 else
360 {
361 char *text = (char*) NULL;
362 gint len = 0;
363
364 if (m_windowStyle & wxTE_MULTILINE)
365 {
366 len = gtk_text_get_length( GTK_TEXT(m_text) );
367 text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
368 }
369 else
370 {
371 text = gtk_entry_get_text( GTK_ENTRY(m_text) );
372 }
373
374 if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
375 {
376 // Did not write whole file
377 }
378
379 // Make sure newline terminates the file
380 if (text[len - 1] != '\n')
381 fputc ('\n', fp);
382
383 fclose (fp);
384
385 if (m_windowStyle & wxTE_MULTILINE) g_free( text );
386
387 m_modified = FALSE;
388 return TRUE;
389 }
390
391 return TRUE;
392}
393
394wxString wxTextCtrl::GetLineText( long lineNo ) const
395{
396 if (m_windowStyle & wxTE_MULTILINE)
397 {
398 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
399 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
400
401 if (text)
402 {
403 wxString buf("");
404 long i;
405 int currentLine = 0;
406 for (i = 0; currentLine != lineNo && text[i]; i++ )
407 if (text[i] == '\n')
408 currentLine++;
409 // Now get the text
410 int j;
411 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
412 buf += text[i];
413
414 g_free( text );
415 return buf;
416 }
417 else
418 return wxEmptyString;
419 }
420 else
421 {
422 if (lineNo == 0) return GetValue();
423 return wxEmptyString;
424 }
425}
426
427void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
428{
429 wxFAIL_MSG( "wxTextCtrl::OnDropFiles not implemented" );
430}
431
432long wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
433{
434 if ( m_windowStyle & wxTE_MULTILINE )
435 {
436 wxString text = GetValue();
437
438 // cast to prevent warning. But pos really should've been unsigned.
439 if( (unsigned long)pos > text.Len() )
440 return FALSE;
441
442 *x=1; // Col 1
443 *y=1; // Line 1
444
445 if (pos == 0)
446 return TRUE;
447
448 const char* stop = text.c_str() + pos;
449 for ( const char *p = text.c_str(); p < stop; p++ )
450 {
451 if (*p == '\n')
452 {
453 (*y)++;
454 *x=1;
455 }
456 else
457 (*x)++;
458 }
459 }
460 else // single line control
461 {
462 if ( pos <= GTK_ENTRY(m_text)->text_length )
463 {
464 *y = 1;
465 *x = pos;
466 }
467 else
468 {
469 // index out of bounds
470 return FALSE;
471 }
472 }
473
474 return TRUE;
475}
476
477long wxTextCtrl::XYToPosition(long x, long y ) const
478{
479 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
480
481 long pos=0;
482 /* This is a kludge; our XY values are 1-based, but GetLineLength()
483 * and --Text() start counting at 0. (and so say the docs) */
484 for( int i=1; i<y; i++ ) pos += GetLineLength(i-1) + 1; // one for '\n'
485
486 pos += x-1; // Pos start with 0
487 return pos;
488}
489
490int wxTextCtrl::GetLineLength(long lineNo) const
491{
492 wxString str = GetLineText (lineNo);
493 return (int) str.Length();
494}
495
496int wxTextCtrl::GetNumberOfLines() const
497{
498 if (m_windowStyle & wxTE_MULTILINE)
499 {
500 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
501 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
502
503 if (text)
504 {
505 int currentLine = 0;
506 for (int i = 0; i < len; i++ )
507 {
508 if (text[i] == '\n')
509 currentLine++;
510 }
511 g_free( text );
512
513 // currentLine is 0 based, add 1 to get number of lines
514 return currentLine + 1;
515 }
516 else
517 {
518 return 0;
519 }
520 }
521 else
522 {
523 return 1;
524 }
525}
526
527void wxTextCtrl::SetInsertionPoint( long pos )
528{
529 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
530
531 if (m_windowStyle & wxTE_MULTILINE)
532 gtk_text_set_point( GTK_TEXT(m_text), (int)pos );
533 else
534 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
535}
536
537void wxTextCtrl::SetInsertionPointEnd()
538{
539 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
540
541 if (m_windowStyle & wxTE_MULTILINE)
542 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
543 else
544 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
545}
546
547void wxTextCtrl::SetEditable( bool editable )
548{
549 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
550
551 if (m_windowStyle & wxTE_MULTILINE)
552 gtk_text_set_editable( GTK_TEXT(m_text), editable );
553 else
554 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
555}
556
557void wxTextCtrl::SetSelection( long from, long to )
558{
559 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
560
561 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
562}
563
564void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
565{
566 wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
567}
568
569long wxTextCtrl::GetInsertionPoint() const
570{
571 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
572
573 return (long) GTK_EDITABLE(m_text)->current_pos;
574}
575
576long wxTextCtrl::GetLastPosition() const
577{
578 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
579
580 int pos = 0;
581 if (m_windowStyle & wxTE_MULTILINE)
582 pos = gtk_text_get_length( GTK_TEXT(m_text) );
583 else
584 pos = GTK_ENTRY(m_text)->text_length;
585
586 return (long)pos-1;
587}
588
589void wxTextCtrl::Remove( long from, long to )
590{
591 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
592
593 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
594}
595
596void wxTextCtrl::Replace( long from, long to, const wxString &value )
597{
598 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
599
600 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
601 if (value.IsNull()) return;
602 gint pos = (gint)from;
603 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
604}
605
606void wxTextCtrl::Cut()
607{
608 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
609
610#if (GTK_MINOR_VERSION == 1)
611 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
612#else
613 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
614#endif
615}
616
617void wxTextCtrl::Copy()
618{
619 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
620
621#if (GTK_MINOR_VERSION == 1)
622 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
623#else
624 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
625#endif
626}
627
628void wxTextCtrl::Paste()
629{
630 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
631
632#if (GTK_MINOR_VERSION == 1)
633 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
634#else
635 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
636#endif
637}
638
639void wxTextCtrl::Clear()
640{
641 SetValue( "" );
642}
643
644void wxTextCtrl::OnChar( wxKeyEvent &key_event )
645{
646 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
647
648 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
649 {
650 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
651 event.SetEventObject(this);
652 if (GetEventHandler()->ProcessEvent(event)) return;
653 }
654
655 key_event.Skip();
656}
657
658#ifndef NO_TEXT_WINDOW_STREAM
659int wxTextCtrl::overflow( int WXUNUSED(c) )
660{
661 int len = pptr() - pbase();
662 char *txt = new char[len+1];
663 strncpy(txt, pbase(), len);
664 txt[len] = '\0';
665 (*this) << txt;
666 setp(pbase(), epptr());
667 delete[] txt;
668 return EOF;
669}
670
671int wxTextCtrl::sync()
672{
673 int len = pptr() - pbase();
674 char *txt = new char[len+1];
675 strncpy(txt, pbase(), len);
676 txt[len] = '\0';
677 (*this) << txt;
678 setp(pbase(), epptr());
679 delete[] txt;
680 return 0;
681}
682
683int wxTextCtrl::underflow()
684{
685 return EOF;
686}
687
688wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
689{
690 WriteText(s);
691 return *this;
692}
693
694wxTextCtrl& wxTextCtrl::operator<<(float f)
695{
696 static char buf[100];
697 sprintf(buf, "%.2f", f);
698 WriteText(buf);
699 return *this;
700}
701
702wxTextCtrl& wxTextCtrl::operator<<(double d)
703{
704 static char buf[100];
705 sprintf(buf, "%.2f", d);
706 WriteText(buf);
707 return *this;
708}
709
710wxTextCtrl& wxTextCtrl::operator<<(int i)
711{
712 static char buf[100];
713 sprintf(buf, "%i", i);
714 WriteText(buf);
715 return *this;
716}
717
718wxTextCtrl& wxTextCtrl::operator<<(long i)
719{
720 static char buf[100];
721 sprintf(buf, "%ld", i);
722 WriteText(buf);
723 return *this;
724}
725
726wxTextCtrl& wxTextCtrl::operator<<(const char c)
727{
728 char buf[2];
729
730 buf[0] = c;
731 buf[1] = 0;
732 WriteText(buf);
733 return *this;
734}
735#endif
736
737GtkWidget* wxTextCtrl::GetConnectWidget()
738{
739 return GTK_WIDGET(m_text);
740}
741
742bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
743{
744 if (m_windowStyle & wxTE_MULTILINE)
745 return (window == GTK_TEXT(m_text)->text_area);
746 else
747 return (window == GTK_ENTRY(m_text)->text_area);
748}
749
750void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
751{
752 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
753
754 // doesn't work
755}
756
757void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
758{
759 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
760
761 // doesn't work
762}
763
764void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
765{
766 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
767
768 wxControl::SetBackgroundColour( colour );
769
770 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
771 if (sysbg.Red() == colour.Red() &&
772 sysbg.Green() == colour.Green() &&
773 sysbg.Blue() == colour.Blue())
774 {
775 return;
776 }
777
778 if (!m_backgroundColour.Ok()) return;
779
780 if (m_windowStyle & wxTE_MULTILINE)
781 {
782 GdkWindow *window = GTK_TEXT(m_text)->text_area;
783 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
784 gdk_window_set_background( window, m_backgroundColour.GetColor() );
785 gdk_window_clear( window );
786 }
787}
788
789void wxTextCtrl::ApplyWidgetStyle()
790{
791 if (m_windowStyle & wxTE_MULTILINE)
792 {
793 // how ?
794 }
795 else
796 {
797 SetWidgetStyle();
798 gtk_widget_set_style( m_text, m_widgetStyle );
799 }
800}
801