]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
1. wxTextControl::SetFont() does something (good or bad - for you to judge)
[wxWidgets.git] / src / gtk / 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// idle system
29//-----------------------------------------------------------------------------
30
31extern void wxapp_install_idle_handler();
32extern bool g_isIdle;
33
34//-----------------------------------------------------------------------------
35// data
36//-----------------------------------------------------------------------------
37
38extern bool g_blockEventsOnDrag;
39
40//-----------------------------------------------------------------------------
41// "changed"
42//-----------------------------------------------------------------------------
43
44static void
45gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
46{
47 if (!win->m_hasVMT) return;
48
49 if (g_isIdle)
50 wxapp_install_idle_handler();
51
52 win->SetModified();
53
54 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
55 event.SetString( win->GetValue() );
56 event.SetEventObject( win );
57 win->GetEventHandler()->ProcessEvent( event );
58}
59
60//-----------------------------------------------------------------------------
61// "changed" from vertical scrollbar
62//-----------------------------------------------------------------------------
63
64static void
65gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
66{
67 if (!win->m_hasVMT) return;
68
69 if (g_isIdle)
70 wxapp_install_idle_handler();
71
72 win->CalculateScrollbar();
73}
74
75//-----------------------------------------------------------------------------
76// wxTextCtrl
77//-----------------------------------------------------------------------------
78
79IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
80
81BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
82 EVT_CHAR(wxTextCtrl::OnChar)
83
84 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
85 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
86 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
87 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
88 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
89
90 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
91 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
92 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
93 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
94 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
95END_EVENT_TABLE()
96
97#if wxUSE_STD_IOSTREAM
98wxTextCtrl::wxTextCtrl() : streambuf()
99{
100 if (allocate()) setp(base(),ebuf());
101
102 m_modified = FALSE;
103}
104#else
105wxTextCtrl::wxTextCtrl()
106{
107 m_modified = FALSE;
108}
109#endif
110
111#if wxUSE_STD_IOSTREAM
112wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
113 const wxPoint &pos, const wxSize &size,
114 int style, const wxValidator& validator, const wxString &name ) : streambuf()
115{
116 if (allocate()) setp(base(),ebuf());
117
118 m_modified = FALSE;
119 Create( parent, id, value, pos, size, style, validator, name );
120}
121#else
122wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
123 const wxPoint &pos, const wxSize &size,
124 int style, const wxValidator& validator, const wxString &name )
125{
126 m_modified = FALSE;
127 Create( parent, id, value, pos, size, style, validator, name );
128}
129#endif
130
131bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
132 const wxPoint &pos, const wxSize &size,
133 int style, const wxValidator& validator, const wxString &name )
134{
135 m_needParent = TRUE;
136 m_acceptsFocus = TRUE;
137
138 PreCreation( parent, id, pos, size, style, name );
139
140#if wxUSE_VALIDATORS
141 SetValidator( validator );
142#endif // wxUSE_VALIDATORS
143
144 m_vScrollbarVisible = FALSE;
145
146 bool multi_line = (style & wxTE_MULTILINE) != 0;
147 if (multi_line)
148 {
149 /* a multi-line edit control: create a vertical scrollbar by default and
150 horizontal if requested */
151 bool bHasHScrollbar = (style & wxHSCROLL) != 0;
152
153 /* create our control ... */
154 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
155
156 /* ... and put into the upper left hand corner of the table */
157 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
158 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
159 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
160 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
161 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
162 0, 0);
163
164 /* always wrap words */
165 gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
166
167 /* put the horizontal scrollbar in the lower left hand corner */
168 if (bHasHScrollbar)
169 {
170 GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
171 GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
172 gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
173 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
174 GTK_FILL,
175 0, 0);
176 gtk_widget_show(hscrollbar);
177
178#if (GTK_MINOR_VERSION > 0)
179 /* don't wrap lines, otherwise we wouldn't need the scrollbar */
180 gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
181#endif
182 }
183
184 /* finally, put the vertical scrollbar in the upper right corner */
185 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
186 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
187 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
188 GTK_FILL,
189 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
190 0, 0);
191 }
192 else
193 {
194 /* a single-line text control: no need for scrollbars */
195 m_widget =
196 m_text = gtk_entry_new();
197 }
198
199 wxSize newSize = size;
200 if (newSize.x == -1) newSize.x = 80;
201 if (newSize.y == -1) newSize.y = 26;
202 SetSize( newSize.x, newSize.y );
203
204 m_parent->DoAddChild( this );
205
206 PostCreation();
207
208 if (multi_line)
209 gtk_widget_show(m_text);
210
211 /* we want to be notified about text changes */
212 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
213 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
214
215 if (multi_line)
216 {
217 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
218 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
219 }
220
221 if (!value.IsEmpty())
222 {
223 gint tmp = 0;
224
225#if GTK_MINOR_VERSION == 0
226 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
227 // gtk_editable_insert_text()
228 gtk_widget_realize(m_text);
229#endif // GTK 1.0
230
231#if wxUSE_UNICODE
232 wxWX2MBbuf val = value.mbc_str();
233 gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
234#else // !Unicode
235 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
236#endif // Unicode/!Unicode
237
238 if (multi_line)
239 {
240 /* bring editable's cursor uptodate. bug in GTK. */
241
242 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
243 }
244 }
245
246 if (style & wxTE_PASSWORD)
247 {
248 if (!multi_line)
249 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
250 }
251
252 if (style & wxTE_READONLY)
253 {
254 if (!multi_line)
255 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
256 }
257 else
258 {
259 if (multi_line)
260 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
261 }
262
263 SetBackgroundColour( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) );
264 SetForegroundColour( parent->GetForegroundColour() );
265
266 Show( TRUE );
267
268 return TRUE;
269}
270
271void wxTextCtrl::CalculateScrollbar()
272{
273 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
274
275 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
276
277 if (adj->upper - adj->page_size < 0.8)
278 {
279 if (m_vScrollbarVisible)
280 {
281 gtk_widget_hide( m_vScrollbar );
282 m_vScrollbarVisible = FALSE;
283 }
284 }
285 else
286 {
287 if (!m_vScrollbarVisible)
288 {
289 gtk_widget_show( m_vScrollbar );
290 m_vScrollbarVisible = TRUE;
291 }
292 }
293}
294
295wxString wxTextCtrl::GetValue() const
296{
297 wxCHECK_MSG( m_text != NULL, _T(""), _T("invalid text ctrl") );
298
299 wxString tmp;
300 if (m_windowStyle & wxTE_MULTILINE)
301 {
302 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
303 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
304 tmp = wxString(text,*wxConvCurrent);
305 g_free( text );
306 }
307 else
308 {
309 tmp = wxString(gtk_entry_get_text( GTK_ENTRY(m_text) ),*wxConvCurrent);
310 }
311 return tmp;
312}
313
314void wxTextCtrl::SetValue( const wxString &value )
315{
316 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
317
318 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
319 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
320
321 wxString tmp = _T("");
322 if (!value.IsNull()) tmp = value;
323 if (m_windowStyle & wxTE_MULTILINE)
324 {
325 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
326 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
327 len = 0;
328#if wxUSE_UNICODE
329 wxWX2MBbuf tmpbuf = tmp.mbc_str();
330 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmpbuf, strlen(tmpbuf), &len );
331#else
332 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp.mbc_str(), tmp.Length(), &len );
333#endif
334 }
335 else
336 {
337 gtk_entry_set_text( GTK_ENTRY(m_text), tmp.mbc_str() );
338 }
339
340 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
341 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
342}
343
344void wxTextCtrl::WriteText( const wxString &text )
345{
346 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
347
348 if (text.IsEmpty()) return;
349
350 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
351 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
352
353 if (m_windowStyle & wxTE_MULTILINE)
354 {
355 /* this moves the cursor pos to behind the inserted text */
356 gint len = GTK_EDITABLE(m_text)->current_pos;
357
358#if wxUSE_UNICODE
359 wxWX2MBbuf buf = text.mbc_str();
360 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
361#else
362 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
363#endif
364
365 /* bring editable's cursor uptodate. bug in GTK. */
366 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
367 }
368 else
369 {
370 /* this moves the cursor pos to behind the inserted text */
371 gint len = GTK_EDITABLE(m_text)->current_pos;
372#if wxUSE_UNICODE
373 wxWX2MBbuf buf = text.mbc_str();
374 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
375#else
376 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
377#endif
378
379 /* bring editable's cursor uptodate. bug in GTK. */
380 GTK_EDITABLE(m_text)->current_pos += text.Len();
381
382 /* bring entry's cursor uptodate. bug in GTK. */
383 gtk_entry_set_position( GTK_ENTRY(m_text), GTK_EDITABLE(m_text)->current_pos );
384 }
385
386 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
387 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
388}
389
390void wxTextCtrl::AppendText( const wxString &text )
391{
392 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
393
394 if (text.IsEmpty()) return;
395
396 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
397 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
398
399 if (m_windowStyle & wxTE_MULTILINE)
400 {
401 bool hasSpecialAttributes = m_font.Ok() ||
402 m_foregroundColour.Ok() ||
403 m_backgroundColour.Ok();
404 if ( hasSpecialAttributes )
405 {
406 gtk_text_insert( GTK_TEXT(m_text),
407 m_font.GetInternalFont(),
408 m_foregroundColour.GetColor(),
409 m_backgroundColour.GetColor(),
410 text, text.length());
411
412 }
413 else
414 {
415 /* we'll insert at the last position */
416 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
417#if wxUSE_UNICODE
418 wxWX2MBbuf buf = text.mbc_str();
419 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
420#else
421 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
422#endif
423 }
424
425 /* bring editable's cursor uptodate. bug in GTK. */
426 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
427 }
428 else
429 {
430 gtk_entry_append_text( GTK_ENTRY(m_text), text.mbc_str() );
431 }
432
433 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
434 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
435}
436
437bool wxTextCtrl::LoadFile( const wxString &file )
438{
439 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
440
441 if (!wxFileExists(file)) return FALSE;
442
443 Clear();
444
445 FILE *fp = (FILE*) NULL;
446 struct stat statb;
447
448 if ((stat (FNSTRINGCAST file.fn_str(), &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
449 !(fp = fopen (FNSTRINGCAST file.fn_str(), "r")))
450 {
451 return FALSE;
452 }
453 else
454 {
455 gint len = statb.st_size;
456 char *text;
457 if (!(text = (char*)malloc ((unsigned) (len + 1))))
458 {
459 fclose (fp);
460 return FALSE;
461 }
462 if (fread (text, sizeof (char), len, fp) != (size_t) len)
463 {
464 }
465 fclose (fp);
466
467 text[len] = 0;
468
469 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
470 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
471
472 if (m_windowStyle & wxTE_MULTILINE)
473 {
474 gint pos = 0;
475 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, len, &pos );
476 }
477 else
478 {
479 gtk_entry_set_text( GTK_ENTRY(m_text), text );
480 }
481
482 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
483 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
484
485 free (text);
486 m_modified = FALSE;
487 return TRUE;
488 }
489 return FALSE;
490}
491
492bool wxTextCtrl::SaveFile( const wxString &file )
493{
494 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
495
496 if (file == _T("")) return FALSE;
497
498 FILE *fp;
499
500 if (!(fp = fopen (FNSTRINGCAST file.fn_str(), "w")))
501 {
502 return FALSE;
503 }
504 else
505 {
506 char *text = (char*) NULL;
507 gint len = 0;
508
509 if (m_windowStyle & wxTE_MULTILINE)
510 {
511 len = gtk_text_get_length( GTK_TEXT(m_text) );
512 text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
513 }
514 else
515 {
516 text = gtk_entry_get_text( GTK_ENTRY(m_text) );
517 }
518
519 if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
520 {
521 // Did not write whole file
522 }
523
524 // Make sure newline terminates the file
525 if (text[len - 1] != '\n')
526 fputc ('\n', fp);
527
528 fclose (fp);
529
530 if (m_windowStyle & wxTE_MULTILINE) g_free( text );
531
532 m_modified = FALSE;
533 return TRUE;
534 }
535
536 return TRUE;
537}
538
539wxString wxTextCtrl::GetLineText( long lineNo ) const
540{
541 if (m_windowStyle & wxTE_MULTILINE)
542 {
543 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
544 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
545
546 if (text)
547 {
548 wxString buf(_T(""));
549 long i;
550 int currentLine = 0;
551 for (i = 0; currentLine != lineNo && text[i]; i++ )
552 if (text[i] == '\n')
553 currentLine++;
554 // Now get the text
555 int j;
556 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
557 buf += text[i];
558
559 g_free( text );
560 return buf;
561 }
562 else
563 return wxEmptyString;
564 }
565 else
566 {
567 if (lineNo == 0) return GetValue();
568 return wxEmptyString;
569 }
570}
571
572void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
573{
574 /* If you implement this, don't forget to update the documentation!
575 * (file docs/latex/wx/text.tex) */
576 wxFAIL_MSG( _T("wxTextCtrl::OnDropFiles not implemented") );
577}
578
579long wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
580{
581 if ( m_windowStyle & wxTE_MULTILINE )
582 {
583 wxString text = GetValue();
584
585 // cast to prevent warning. But pos really should've been unsigned.
586 if( (unsigned long)pos > text.Len() )
587 return FALSE;
588
589 *x=0; // First Col
590 *y=0; // First Line
591
592 const wxChar* stop = text.c_str() + pos;
593 for ( const wxChar *p = text.c_str(); p < stop; p++ )
594 {
595 if (*p == _T('\n'))
596 {
597 (*y)++;
598 *x=0;
599 }
600 else
601 (*x)++;
602 }
603 }
604 else // single line control
605 {
606 if ( pos <= GTK_ENTRY(m_text)->text_length )
607 {
608 *y = 0;
609 *x = pos;
610 }
611 else
612 {
613 // index out of bounds
614 return FALSE;
615 }
616 }
617
618 return TRUE;
619}
620
621long wxTextCtrl::XYToPosition(long x, long y ) const
622{
623 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
624
625 long pos=0;
626 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
627
628 pos += x;
629 return pos;
630}
631
632int wxTextCtrl::GetLineLength(long lineNo) const
633{
634 wxString str = GetLineText (lineNo);
635 return (int) str.Length();
636}
637
638int wxTextCtrl::GetNumberOfLines() const
639{
640 if (m_windowStyle & wxTE_MULTILINE)
641 {
642 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
643 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
644
645 if (text)
646 {
647 int currentLine = 0;
648 for (int i = 0; i < len; i++ )
649 {
650 if (text[i] == '\n')
651 currentLine++;
652 }
653 g_free( text );
654
655 // currentLine is 0 based, add 1 to get number of lines
656 return currentLine + 1;
657 }
658 else
659 {
660 return 0;
661 }
662 }
663 else
664 {
665 return 1;
666 }
667}
668
669void wxTextCtrl::SetInsertionPoint( long pos )
670{
671 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
672
673 if (m_windowStyle & wxTE_MULTILINE)
674 {
675 /* seems to be broken in GTK 1.0.X:
676 gtk_text_set_point( GTK_TEXT(m_text), (int)pos ); */
677
678 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
679 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
680
681 /* we fake a set_point by inserting and deleting. as the user
682 isn't supposed to get to know about thos non-sense, we
683 disconnect so that no events are sent to the user program. */
684
685 gint tmp = (gint)pos;
686 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
687 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
688
689 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
690 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
691
692 /* bring editable's cursor uptodate. another bug in GTK. */
693
694 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
695 }
696 else
697 {
698 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
699
700 /* bring editable's cursor uptodate. bug in GTK. */
701
702 GTK_EDITABLE(m_text)->current_pos = pos;
703 }
704}
705
706void wxTextCtrl::SetInsertionPointEnd()
707{
708 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
709
710 if (m_windowStyle & wxTE_MULTILINE)
711 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
712 else
713 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
714}
715
716void wxTextCtrl::SetEditable( bool editable )
717{
718 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
719
720 if (m_windowStyle & wxTE_MULTILINE)
721 gtk_text_set_editable( GTK_TEXT(m_text), editable );
722 else
723 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
724}
725
726void wxTextCtrl::SetSelection( long from, long to )
727{
728 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
729
730 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
731}
732
733void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
734{
735// SetInsertionPoint( pos );
736}
737
738long wxTextCtrl::GetInsertionPoint() const
739{
740 wxCHECK_MSG( m_text != NULL, 0, _T("invalid text ctrl") );
741
742 return (long) GTK_EDITABLE(m_text)->current_pos;
743}
744
745long wxTextCtrl::GetLastPosition() const
746{
747 wxCHECK_MSG( m_text != NULL, 0, _T("invalid text ctrl") );
748
749 int pos = 0;
750 if (m_windowStyle & wxTE_MULTILINE)
751 pos = gtk_text_get_length( GTK_TEXT(m_text) );
752 else
753 pos = GTK_ENTRY(m_text)->text_length;
754
755 return (long)pos;
756}
757
758void wxTextCtrl::Remove( long from, long to )
759{
760 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
761
762 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
763 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
764
765 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
766
767 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
768 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
769}
770
771void wxTextCtrl::Replace( long from, long to, const wxString &value )
772{
773 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
774
775 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
776 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
777
778 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
779
780 if (!value.IsEmpty())
781 {
782 gint pos = (gint)from;
783#if wxUSE_UNICODE
784 wxWX2MBbuf buf = value.mbc_str();
785 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
786#else
787 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
788#endif
789 }
790
791 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
792 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
793}
794
795void wxTextCtrl::Cut()
796{
797 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
798
799 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
800 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
801
802#if (GTK_MINOR_VERSION > 0)
803 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
804#else
805 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
806#endif
807
808 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
809 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
810}
811
812void wxTextCtrl::Copy()
813{
814 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
815
816#if (GTK_MINOR_VERSION > 0)
817 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
818#else
819 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
820#endif
821}
822
823void wxTextCtrl::Paste()
824{
825 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
826
827 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
828 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
829
830#if (GTK_MINOR_VERSION > 0)
831 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
832#else
833 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
834#endif
835
836 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
837 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
838}
839
840bool wxTextCtrl::CanCopy() const
841{
842 // Can copy if there's a selection
843 long from, to;
844 GetSelection(& from, & to);
845 return (from != to) ;
846}
847
848bool wxTextCtrl::CanCut() const
849{
850 // Can cut if there's a selection
851 long from, to;
852 GetSelection(& from, & to);
853 return (from != to) ;
854}
855
856bool wxTextCtrl::CanPaste() const
857{
858 return IsEditable() ;
859}
860
861// Undo/redo
862void wxTextCtrl::Undo()
863{
864 // TODO
865 wxFAIL_MSG( _T("wxTextCtrl::Undo not implemented") );
866}
867
868void wxTextCtrl::Redo()
869{
870 // TODO
871 wxFAIL_MSG( _T("wxTextCtrl::Redo not implemented") );
872}
873
874bool wxTextCtrl::CanUndo() const
875{
876 // TODO
877 wxFAIL_MSG( _T("wxTextCtrl::CanUndo not implemented") );
878 return FALSE;
879}
880
881bool wxTextCtrl::CanRedo() const
882{
883 // TODO
884 wxFAIL_MSG( _T("wxTextCtrl::CanRedo not implemented") );
885 return FALSE;
886}
887
888// If the return values from and to are the same, there is no
889// selection.
890void wxTextCtrl::GetSelection(long* from, long* to) const
891{
892 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
893
894 if (!(GTK_EDITABLE(m_text)->has_selection))
895 {
896 if (from) *from = 0;
897 if (to) *to = 0;
898 return;
899 }
900
901 if (from) *from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
902 if (to) *to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
903}
904
905bool wxTextCtrl::IsEditable() const
906{
907 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
908
909 return GTK_EDITABLE(m_text)->editable;
910}
911
912void wxTextCtrl::Clear()
913{
914 SetValue( _T("") );
915}
916
917void wxTextCtrl::OnChar( wxKeyEvent &key_event )
918{
919 wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
920
921 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
922 {
923 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
924 event.SetEventObject(this);
925 if (GetEventHandler()->ProcessEvent(event)) return;
926 }
927
928 key_event.Skip();
929}
930
931#if wxUSE_STD_IOSTREAM
932int wxTextCtrl::overflow( int WXUNUSED(c) )
933{
934 int len = pptr() - pbase();
935 char *txt = new char[len+1];
936 strncpy(txt, pbase(), len);
937 txt[len] = '\0';
938 (*this) << txt;
939 setp(pbase(), epptr());
940 delete[] txt;
941 return EOF;
942}
943
944int wxTextCtrl::sync()
945{
946 int len = pptr() - pbase();
947 char *txt = new char[len+1];
948 strncpy(txt, pbase(), len);
949 txt[len] = '\0';
950 (*this) << txt;
951 setp(pbase(), epptr());
952 delete[] txt;
953 return 0;
954}
955
956int wxTextCtrl::underflow()
957{
958 return EOF;
959}
960#endif
961
962wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
963{
964 AppendText(s);
965 return *this;
966}
967
968wxTextCtrl& wxTextCtrl::operator<<(float f)
969{
970 static char buf[100];
971 sprintf(buf, "%.2f", f);
972 AppendText(buf);
973 return *this;
974}
975
976wxTextCtrl& wxTextCtrl::operator<<(double d)
977{
978 static char buf[100];
979 sprintf(buf, "%.2f", d);
980 AppendText(buf);
981 return *this;
982}
983
984wxTextCtrl& wxTextCtrl::operator<<(int i)
985{
986 static char buf[100];
987 sprintf(buf, "%i", i);
988 AppendText(buf);
989 return *this;
990}
991
992wxTextCtrl& wxTextCtrl::operator<<(long i)
993{
994 static char buf[100];
995 sprintf(buf, "%ld", i);
996 AppendText(buf);
997 return *this;
998}
999
1000wxTextCtrl& wxTextCtrl::operator<<(const char c)
1001{
1002 char buf[2];
1003
1004 buf[0] = c;
1005 buf[1] = 0;
1006 AppendText(buf);
1007 return *this;
1008}
1009
1010GtkWidget* wxTextCtrl::GetConnectWidget()
1011{
1012 return GTK_WIDGET(m_text);
1013}
1014
1015bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1016{
1017 if (m_windowStyle & wxTE_MULTILINE)
1018 return (window == GTK_TEXT(m_text)->text_area);
1019 else
1020 return (window == GTK_ENTRY(m_text)->text_area);
1021}
1022
1023// the font will change for subsequent text insertiongs
1024bool wxTextCtrl::SetFont( const wxFont &font )
1025{
1026 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
1027
1028 if ( !wxWindowBase::SetFont(font) )
1029 {
1030 // font didn't change, nothing to do
1031 return FALSE;
1032 }
1033
1034 if ( m_windowStyle & wxTE_MULTILINE )
1035 {
1036 // for compatibility with other ports: the font is a global controls
1037 // characteristic, so change the font globally
1038 wxString value = GetValue();
1039 if ( !value.IsEmpty() )
1040 {
1041 Clear();
1042
1043 AppendText(value);
1044 }
1045 }
1046
1047 return TRUE;
1048}
1049
1050bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
1051{
1052 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
1053
1054 // doesn't work
1055 return FALSE;
1056}
1057
1058bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1059{
1060 wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
1061
1062 wxControl::SetBackgroundColour( colour );
1063
1064 if (!m_widget->window)
1065 return FALSE;
1066
1067 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1068 if (sysbg.Red() == colour.Red() &&
1069 sysbg.Green() == colour.Green() &&
1070 sysbg.Blue() == colour.Blue())
1071 {
1072 return FALSE; // FIXME or TRUE?
1073 }
1074
1075 if (!m_backgroundColour.Ok())
1076 return FALSE;
1077
1078 if (m_windowStyle & wxTE_MULTILINE)
1079 {
1080 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1081 if (!window)
1082 return FALSE;
1083 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1084 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1085 gdk_window_clear( window );
1086 }
1087
1088 return TRUE;
1089}
1090
1091void wxTextCtrl::ApplyWidgetStyle()
1092{
1093 if (m_windowStyle & wxTE_MULTILINE)
1094 {
1095 // how ?
1096 }
1097 else
1098 {
1099 SetWidgetStyle();
1100 gtk_widget_set_style( m_text, m_widgetStyle );
1101 }
1102}
1103
1104void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1105{
1106 Cut();
1107}
1108
1109void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1110{
1111 Copy();
1112}
1113
1114void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1115{
1116 Paste();
1117}
1118
1119void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1120{
1121 Undo();
1122}
1123
1124void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1125{
1126 Redo();
1127}
1128
1129void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1130{
1131 event.Enable( CanCut() );
1132}
1133
1134void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1135{
1136 event.Enable( CanCopy() );
1137}
1138
1139void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1140{
1141 event.Enable( CanPaste() );
1142}
1143
1144void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1145{
1146 event.Enable( CanUndo() );
1147}
1148
1149void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1150{
1151 event.Enable( CanRedo() );
1152}
wxWidgets (Impactor)