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