]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
conditional compilation for Universal Interfaces (3.4 or later)
[wxWidgets.git] / src / gtk1 / textctrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11#pragma implementation "textctrl.h"
12#endif
13
14#include "wx/textctrl.h"
15#include "wx/utils.h"
16#include "wx/intl.h"
17#include "wx/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 SetBackgroundColour( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) );
397 SetForegroundColour( parent->GetForegroundColour() );
398
399 m_cursor = wxCursor( wxCURSOR_IBEAM );
400
401 Show( TRUE );
402
403 return TRUE;
404}
405
406void wxTextCtrl::CalculateScrollbar()
407{
408 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
409
410 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
411
412 if (adj->upper - adj->page_size < 0.8)
413 {
414 if (m_vScrollbarVisible)
415 {
416 gtk_widget_hide( m_vScrollbar );
417 m_vScrollbarVisible = FALSE;
418 }
419 }
420 else
421 {
422 if (!m_vScrollbarVisible)
423 {
424 gtk_widget_show( m_vScrollbar );
425 m_vScrollbarVisible = TRUE;
426 }
427 }
428}
429
430wxString wxTextCtrl::GetValue() const
431{
432 wxCHECK_MSG( m_text != NULL, wxT(""), wxT("invalid text ctrl") );
433
434 wxString tmp;
435 if (m_windowStyle & wxTE_MULTILINE)
436 {
437 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
438 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
439 tmp = wxString(text,*wxConvCurrent);
440 g_free( text );
441 }
442 else
443 {
444 tmp = wxString(gtk_entry_get_text( GTK_ENTRY(m_text) ),*wxConvCurrent);
445 }
446 return tmp;
447}
448
449void wxTextCtrl::SetValue( const wxString &value )
450{
451 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
452
453 if (m_windowStyle & wxTE_MULTILINE)
454 {
455 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
456 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
457 len = 0;
458#if wxUSE_UNICODE
459 wxWX2MBbuf tmpbuf = value.mbc_str();
460 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmpbuf, strlen(tmpbuf), &len );
461#else
462 gtk_editable_insert_text( GTK_EDITABLE(m_text), value.mbc_str(), value.Length(), &len );
463#endif
464 }
465 else
466 {
467 gtk_entry_set_text( GTK_ENTRY(m_text), value.mbc_str() );
468 }
469
470 // GRG, Jun/2000: Changed this after a lot of discussion in
471 // the lists. wxWindows 2.2 will have a set of flags to
472 // customize this behaviour.
473 SetInsertionPoint(0);
474
475 m_modified = FALSE;
476}
477
478void wxTextCtrl::WriteText( const wxString &text )
479{
480 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
481
482 if (text.IsEmpty()) return;
483
484 if (m_windowStyle & wxTE_MULTILINE)
485 {
486 /* this moves the cursor pos to behind the inserted text */
487 gint len = GTK_EDITABLE(m_text)->current_pos;
488
489#if wxUSE_UNICODE
490 wxWX2MBbuf buf = text.mbc_str();
491 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
492#else
493 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
494#endif
495
496 /* bring editable's cursor uptodate. bug in GTK. */
497 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
498 }
499 else
500 {
501 /* this moves the cursor pos to behind the inserted text */
502 gint len = GTK_EDITABLE(m_text)->current_pos;
503#if wxUSE_UNICODE
504 wxWX2MBbuf buf = text.mbc_str();
505 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
506#else
507 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
508#endif
509
510 /* bring editable's cursor uptodate. bug in GTK. */
511 GTK_EDITABLE(m_text)->current_pos += text.Len();
512
513 /* bring entry's cursor uptodate. bug in GTK. */
514 gtk_entry_set_position( GTK_ENTRY(m_text), GTK_EDITABLE(m_text)->current_pos );
515 }
516}
517
518void wxTextCtrl::AppendText( const wxString &text )
519{
520 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
521
522 if (text.IsEmpty()) return;
523
524 if (m_windowStyle & wxTE_MULTILINE)
525 {
526 bool hasSpecialAttributes = m_font.Ok() ||
527 m_foregroundColour.Ok() ||
528 m_backgroundColour.Ok();
529 if ( hasSpecialAttributes )
530 {
531 gtk_text_insert( GTK_TEXT(m_text),
532 m_font.GetInternalFont(),
533 m_foregroundColour.GetColor(),
534 m_backgroundColour.GetColor(),
535 text.mbc_str(), text.length());
536
537 }
538 else
539 {
540 /* we'll insert at the last position */
541 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
542#if wxUSE_UNICODE
543 wxWX2MBbuf buf = text.mbc_str();
544 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &len );
545#else
546 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
547#endif
548 }
549
550 /* bring editable's cursor uptodate. bug in GTK. */
551 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
552 }
553 else
554 {
555 gtk_entry_append_text( GTK_ENTRY(m_text), text.mbc_str() );
556 }
557}
558
559wxString wxTextCtrl::GetLineText( long lineNo ) const
560{
561 if (m_windowStyle & wxTE_MULTILINE)
562 {
563 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
564 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
565
566 if (text)
567 {
568 wxString buf(wxT(""));
569 long i;
570 int currentLine = 0;
571 for (i = 0; currentLine != lineNo && text[i]; i++ )
572 if (text[i] == '\n')
573 currentLine++;
574 // Now get the text
575 int j;
576 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
577 buf += text[i];
578
579 g_free( text );
580 return buf;
581 }
582 else
583 return wxEmptyString;
584 }
585 else
586 {
587 if (lineNo == 0) return GetValue();
588 return wxEmptyString;
589 }
590}
591
592void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
593{
594 /* If you implement this, don't forget to update the documentation!
595 * (file docs/latex/wx/text.tex) */
596 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
597}
598
599bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
600{
601 if ( m_windowStyle & wxTE_MULTILINE )
602 {
603 wxString text = GetValue();
604
605 // cast to prevent warning. But pos really should've been unsigned.
606 if( (unsigned long)pos > text.Len() )
607 return FALSE;
608
609 *x=0; // First Col
610 *y=0; // First Line
611
612 const wxChar* stop = text.c_str() + pos;
613 for ( const wxChar *p = text.c_str(); p < stop; p++ )
614 {
615 if (*p == wxT('\n'))
616 {
617 (*y)++;
618 *x=0;
619 }
620 else
621 (*x)++;
622 }
623 }
624 else // single line control
625 {
626 if ( pos <= GTK_ENTRY(m_text)->text_length )
627 {
628 *y = 0;
629 *x = pos;
630 }
631 else
632 {
633 // index out of bounds
634 return FALSE;
635 }
636 }
637
638 return TRUE;
639}
640
641long wxTextCtrl::XYToPosition(long x, long y ) const
642{
643 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
644
645 long pos=0;
646 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
647
648 pos += x;
649 return pos;
650}
651
652int wxTextCtrl::GetLineLength(long lineNo) const
653{
654 wxString str = GetLineText (lineNo);
655 return (int) str.Length();
656}
657
658int wxTextCtrl::GetNumberOfLines() const
659{
660 if (m_windowStyle & wxTE_MULTILINE)
661 {
662 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
663 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
664
665 if (text)
666 {
667 int currentLine = 0;
668 for (int i = 0; i < len; i++ )
669 {
670 if (text[i] == '\n')
671 currentLine++;
672 }
673 g_free( text );
674
675 // currentLine is 0 based, add 1 to get number of lines
676 return currentLine + 1;
677 }
678 else
679 {
680 return 0;
681 }
682 }
683 else
684 {
685 return 1;
686 }
687}
688
689void wxTextCtrl::SetInsertionPoint( long pos )
690{
691 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
692
693 if (m_windowStyle & wxTE_MULTILINE)
694 {
695 /* seems to be broken in GTK 1.0.X:
696 gtk_text_set_point( GTK_TEXT(m_text), (int)pos ); */
697
698 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
699 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
700
701 /* we fake a set_point by inserting and deleting. as the user
702 isn't supposed to get to know about thos non-sense, we
703 disconnect so that no events are sent to the user program. */
704
705 gint tmp = (gint)pos;
706 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
707 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
708
709 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
710 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
711
712 /* bring editable's cursor uptodate. another bug in GTK. */
713
714 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
715 }
716 else
717 {
718 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
719
720 /* bring editable's cursor uptodate. bug in GTK. */
721
722 GTK_EDITABLE(m_text)->current_pos = (guint32)pos;
723 }
724}
725
726void wxTextCtrl::SetInsertionPointEnd()
727{
728 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
729
730 if (m_windowStyle & wxTE_MULTILINE)
731 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
732 else
733 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
734}
735
736void wxTextCtrl::SetEditable( bool editable )
737{
738 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
739
740 if (m_windowStyle & wxTE_MULTILINE)
741 gtk_text_set_editable( GTK_TEXT(m_text), editable );
742 else
743 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
744}
745
746bool wxTextCtrl::Enable( bool enable )
747{
748 if (!wxWindowBase::Enable(enable))
749 {
750 // nothing to do
751 return FALSE;
752 }
753
754 if (m_windowStyle & wxTE_MULTILINE)
755 {
756 gtk_text_set_editable( GTK_TEXT(m_text), enable );
757 }
758 else
759 {
760 gtk_widget_set_sensitive( m_text, enable );
761 }
762
763 return TRUE;
764}
765
766void wxTextCtrl::DiscardEdits()
767{
768 m_modified = FALSE;
769}
770
771void wxTextCtrl::SetSelection( long from, long to )
772{
773 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
774
775 if ( (m_windowStyle & wxTE_MULTILINE) &&
776 !GTK_TEXT(m_text)->line_start_cache )
777 {
778 // tell the programmer that it didn't work
779 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
780 return;
781 }
782
783 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
784}
785
786void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
787{
788// SetInsertionPoint( pos );
789}
790
791long wxTextCtrl::GetInsertionPoint() const
792{
793 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
794
795 return (long) GTK_EDITABLE(m_text)->current_pos;
796}
797
798long wxTextCtrl::GetLastPosition() const
799{
800 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
801
802 int pos = 0;
803 if (m_windowStyle & wxTE_MULTILINE)
804 pos = gtk_text_get_length( GTK_TEXT(m_text) );
805 else
806 pos = GTK_ENTRY(m_text)->text_length;
807
808 return (long)pos;
809}
810
811void wxTextCtrl::Remove( long from, long to )
812{
813 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
814
815 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
816}
817
818void wxTextCtrl::Replace( long from, long to, const wxString &value )
819{
820 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
821
822 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
823
824 if (!value.IsEmpty())
825 {
826 gint pos = (gint)from;
827#if wxUSE_UNICODE
828 wxWX2MBbuf buf = value.mbc_str();
829 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
830#else
831 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
832#endif
833 }
834}
835
836void wxTextCtrl::Cut()
837{
838 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
839
840#if (GTK_MINOR_VERSION > 0)
841 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
842#else
843 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
844#endif
845}
846
847void wxTextCtrl::Copy()
848{
849 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
850
851#if (GTK_MINOR_VERSION > 0)
852 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
853#else
854 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
855#endif
856}
857
858void wxTextCtrl::Paste()
859{
860 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
861
862#if (GTK_MINOR_VERSION > 0)
863 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
864#else
865 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
866#endif
867}
868
869bool wxTextCtrl::CanCopy() const
870{
871 // Can copy if there's a selection
872 long from, to;
873 GetSelection(& from, & to);
874 return (from != to) ;
875}
876
877bool wxTextCtrl::CanCut() const
878{
879 // Can cut if there's a selection
880 long from, to;
881 GetSelection(& from, & to);
882 return (from != to) && (IsEditable());
883}
884
885bool wxTextCtrl::CanPaste() const
886{
887 return IsEditable() ;
888}
889
890// Undo/redo
891void wxTextCtrl::Undo()
892{
893 // TODO
894 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
895}
896
897void wxTextCtrl::Redo()
898{
899 // TODO
900 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
901}
902
903bool wxTextCtrl::CanUndo() const
904{
905 // TODO
906 wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
907 return FALSE;
908}
909
910bool wxTextCtrl::CanRedo() const
911{
912 // TODO
913 wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
914 return FALSE;
915}
916
917// If the return values from and to are the same, there is no
918// selection.
919void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
920{
921 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
922
923 long from, to;
924 if ( !(GTK_EDITABLE(m_text)->has_selection) )
925 {
926 from =
927 to = GetInsertionPoint();
928 }
929 else // got selection
930 {
931 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
932 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
933
934 if ( from > to )
935 {
936 // exchange them to be compatible with wxMSW
937 long tmp = from;
938 from = to;
939 to = tmp;
940 }
941 }
942
943 if ( fromOut )
944 *fromOut = from;
945 if ( toOut )
946 *toOut = to;
947}
948
949bool wxTextCtrl::IsEditable() const
950{
951 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
952
953 return GTK_EDITABLE(m_text)->editable;
954}
955
956bool wxTextCtrl::IsModified() const
957{
958 return m_modified;
959}
960
961void wxTextCtrl::Clear()
962{
963 SetValue( wxT("") );
964}
965
966void wxTextCtrl::OnChar( wxKeyEvent &key_event )
967{
968 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
969
970 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
971 {
972 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
973 event.SetEventObject(this);
974 event.SetString(GetValue());
975 if (GetEventHandler()->ProcessEvent(event)) return;
976 }
977
978 if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
979 {
980 wxWindow *top_frame = m_parent;
981 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
982 top_frame = top_frame->GetParent();
983 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
984
985 if (window->default_widget)
986 {
987 gtk_widget_activate (window->default_widget);
988 return;
989 }
990 }
991
992 key_event.Skip();
993}
994
995GtkWidget* wxTextCtrl::GetConnectWidget()
996{
997 return GTK_WIDGET(m_text);
998}
999
1000bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1001{
1002 if (m_windowStyle & wxTE_MULTILINE)
1003 return (window == GTK_TEXT(m_text)->text_area);
1004 else
1005 return (window == GTK_ENTRY(m_text)->text_area);
1006}
1007
1008// the font will change for subsequent text insertiongs
1009bool wxTextCtrl::SetFont( const wxFont &font )
1010{
1011 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1012
1013 if ( !wxWindowBase::SetFont(font) )
1014 {
1015 // font didn't change, nothing to do
1016 return FALSE;
1017 }
1018
1019 if ( m_windowStyle & wxTE_MULTILINE )
1020 {
1021 m_updateFont = TRUE;
1022
1023 ChangeFontGlobally();
1024 }
1025
1026 return TRUE;
1027}
1028
1029void wxTextCtrl::ChangeFontGlobally()
1030{
1031 // this method is very inefficient and hence should be called as rarely as
1032 // possible!
1033 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1034 _T("shouldn't be called for single line controls") );
1035
1036 wxString value = GetValue();
1037 if ( !value.IsEmpty() )
1038 {
1039 Clear();
1040 AppendText(value);
1041
1042 m_updateFont = FALSE;
1043 }
1044}
1045
1046void wxTextCtrl::UpdateFontIfNeeded()
1047{
1048 if ( m_updateFont )
1049 ChangeFontGlobally();
1050}
1051
1052bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
1053{
1054 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1055
1056 // doesn't work
1057 return FALSE;
1058}
1059
1060bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1061{
1062 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1063
1064 wxControl::SetBackgroundColour( colour );
1065
1066 if (!m_widget->window)
1067 return FALSE;
1068
1069 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1070 if (sysbg.Red() == colour.Red() &&
1071 sysbg.Green() == colour.Green() &&
1072 sysbg.Blue() == colour.Blue())
1073 {
1074 return FALSE; // FIXME or TRUE?
1075 }
1076
1077 if (!m_backgroundColour.Ok())
1078 return FALSE;
1079
1080 if (m_windowStyle & wxTE_MULTILINE)
1081 {
1082 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1083 if (!window)
1084 return FALSE;
1085 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1086 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1087 gdk_window_clear( window );
1088 }
1089
1090 return TRUE;
1091}
1092
1093void wxTextCtrl::ApplyWidgetStyle()
1094{
1095 if (m_windowStyle & wxTE_MULTILINE)
1096 {
1097 // how ?
1098 }
1099 else
1100 {
1101 SetWidgetStyle();
1102 gtk_widget_set_style( m_text, m_widgetStyle );
1103 }
1104}
1105
1106void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1107{
1108 Cut();
1109}
1110
1111void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1112{
1113 Copy();
1114}
1115
1116void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1117{
1118 Paste();
1119}
1120
1121void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1122{
1123 Undo();
1124}
1125
1126void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1127{
1128 Redo();
1129}
1130
1131void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1132{
1133 event.Enable( CanCut() );
1134}
1135
1136void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1137{
1138 event.Enable( CanCopy() );
1139}
1140
1141void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1142{
1143 event.Enable( CanPaste() );
1144}
1145
1146void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1147{
1148 event.Enable( CanUndo() );
1149}
1150
1151void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1152{
1153 event.Enable( CanRedo() );
1154}
1155
1156void wxTextCtrl::OnInternalIdle()
1157{
1158 wxCursor cursor = m_cursor;
1159 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1160
1161 if (cursor.Ok())
1162 {
1163 GdkWindow *window = (GdkWindow*) NULL;
1164 if (HasFlag(wxTE_MULTILINE))
1165 window = GTK_TEXT(m_text)->text_area;
1166 else
1167 window = GTK_ENTRY(m_text)->text_area;
1168
1169 if (window)
1170 gdk_window_set_cursor( window, cursor.GetCursor() );
1171
1172 if (!g_globalCursor.Ok())
1173 cursor = *wxSTANDARD_CURSOR;
1174
1175 window = m_widget->window;
1176 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1177 gdk_window_set_cursor( window, cursor.GetCursor() );
1178 }
1179
1180 UpdateWindowUI();
1181}
1182
1183wxSize wxTextCtrl::DoGetBestSize() const
1184{
1185 // FIXME should be different for multi-line controls...
1186 wxSize ret( wxControl::DoGetBestSize() );
1187 return wxSize(80, ret.y);
1188}
wxWidgets (Impactor)