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