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