]> 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
implemented wxMask::Create(bitmap, paletteEntry) for wxGTK
[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 /* we want to be notified about text changes */
331 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
332 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
333
334 if (multi_line)
335 {
336 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
337 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
338
339 gtk_signal_connect( GTK_OBJECT(GTK_TEXT(m_text)), "focus_in_event",
340 GTK_SIGNAL_FUNC(gtk_text_focus_in_callback), (gpointer)this );
341
342 gtk_signal_connect( GTK_OBJECT(GTK_TEXT(m_text)), "focus_out_event",
343 GTK_SIGNAL_FUNC(gtk_text_focus_out_callback), (gpointer)this );
344 }
345 else
346 {
347 gtk_signal_connect( GTK_OBJECT(m_text), "focus_in_event",
348 GTK_SIGNAL_FUNC(gtk_text_focus_in_callback), (gpointer)this );
349
350 gtk_signal_connect( GTK_OBJECT(m_text), "focus_out_event",
351 GTK_SIGNAL_FUNC(gtk_text_focus_out_callback), (gpointer)this );
352 }
353
354 if (!value.IsEmpty())
355 {
356 gint tmp = 0;
357
358#if GTK_MINOR_VERSION == 0
359 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
360 // gtk_editable_insert_text()
361 gtk_widget_realize(m_text);
362#endif // GTK 1.0
363
364#if wxUSE_UNICODE
365 wxWX2MBbuf val = value.mbc_str();
366 gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
367#else // !Unicode
368 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
369#endif // Unicode/!Unicode
370
371 if (multi_line)
372 {
373 /* bring editable's cursor uptodate. bug in GTK. */
374
375 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
376 }
377 }
378
379 if (style & wxTE_PASSWORD)
380 {
381 if (!multi_line)
382 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
383 }
384
385 if (style & wxTE_READONLY)
386 {
387 if (!multi_line)
388 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
389 }
390 else
391 {
392 if (multi_line)
393 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
394 }
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* from, long* to) const
920{
921 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
922
923 if (!(GTK_EDITABLE(m_text)->has_selection))
924 {
925 long i = GetInsertionPoint();
926 if (from) *from = i;
927 if (to) *to = i;
928 return;
929 }
930
931 if (from) *from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
932 if (to) *to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
933}
934
935bool wxTextCtrl::IsEditable() const
936{
937 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
938
939 return GTK_EDITABLE(m_text)->editable;
940}
941
942bool wxTextCtrl::IsModified() const
943{
944 return m_modified;
945}
946
947void wxTextCtrl::Clear()
948{
949 SetValue( wxT("") );
950}
951
952void wxTextCtrl::OnChar( wxKeyEvent &key_event )
953{
954 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
955
956 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
957 {
958 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
959 event.SetEventObject(this);
960 event.SetString(GetValue());
961 if (GetEventHandler()->ProcessEvent(event)) return;
962 }
963
964 if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
965 {
966 wxWindow *top_frame = m_parent;
967 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
968 top_frame = top_frame->GetParent();
969 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
970
971 if (window->default_widget)
972 {
973 gtk_widget_activate (window->default_widget);
974 return;
975 }
976 }
977
978 key_event.Skip();
979}
980
981GtkWidget* wxTextCtrl::GetConnectWidget()
982{
983 return GTK_WIDGET(m_text);
984}
985
986bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
987{
988 if (m_windowStyle & wxTE_MULTILINE)
989 return (window == GTK_TEXT(m_text)->text_area);
990 else
991 return (window == GTK_ENTRY(m_text)->text_area);
992}
993
994// the font will change for subsequent text insertiongs
995bool wxTextCtrl::SetFont( const wxFont &font )
996{
997 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
998
999 if ( !wxWindowBase::SetFont(font) )
1000 {
1001 // font didn't change, nothing to do
1002 return FALSE;
1003 }
1004
1005 if ( m_windowStyle & wxTE_MULTILINE )
1006 {
1007 m_updateFont = TRUE;
1008
1009 ChangeFontGlobally();
1010 }
1011
1012 return TRUE;
1013}
1014
1015void wxTextCtrl::ChangeFontGlobally()
1016{
1017 // this method is very inefficient and hence should be called as rarely as
1018 // possible!
1019 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1020 _T("shouldn't be called for single line controls") );
1021
1022 wxString value = GetValue();
1023 if ( !value.IsEmpty() )
1024 {
1025 Clear();
1026 AppendText(value);
1027
1028 m_updateFont = FALSE;
1029 }
1030}
1031
1032void wxTextCtrl::UpdateFontIfNeeded()
1033{
1034 if ( m_updateFont )
1035 ChangeFontGlobally();
1036}
1037
1038bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
1039{
1040 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1041
1042 // doesn't work
1043 return FALSE;
1044}
1045
1046bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1047{
1048 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1049
1050 wxControl::SetBackgroundColour( colour );
1051
1052 if (!m_widget->window)
1053 return FALSE;
1054
1055 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1056 if (sysbg.Red() == colour.Red() &&
1057 sysbg.Green() == colour.Green() &&
1058 sysbg.Blue() == colour.Blue())
1059 {
1060 return FALSE; // FIXME or TRUE?
1061 }
1062
1063 if (!m_backgroundColour.Ok())
1064 return FALSE;
1065
1066 if (m_windowStyle & wxTE_MULTILINE)
1067 {
1068 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1069 if (!window)
1070 return FALSE;
1071 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1072 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1073 gdk_window_clear( window );
1074 }
1075
1076 return TRUE;
1077}
1078
1079void wxTextCtrl::ApplyWidgetStyle()
1080{
1081 if (m_windowStyle & wxTE_MULTILINE)
1082 {
1083 // how ?
1084 }
1085 else
1086 {
1087 SetWidgetStyle();
1088 gtk_widget_set_style( m_text, m_widgetStyle );
1089 }
1090}
1091
1092void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1093{
1094 Cut();
1095}
1096
1097void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1098{
1099 Copy();
1100}
1101
1102void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1103{
1104 Paste();
1105}
1106
1107void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1108{
1109 Undo();
1110}
1111
1112void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1113{
1114 Redo();
1115}
1116
1117void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1118{
1119 event.Enable( CanCut() );
1120}
1121
1122void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1123{
1124 event.Enable( CanCopy() );
1125}
1126
1127void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1128{
1129 event.Enable( CanPaste() );
1130}
1131
1132void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1133{
1134 event.Enable( CanUndo() );
1135}
1136
1137void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1138{
1139 event.Enable( CanRedo() );
1140}
1141
1142void wxTextCtrl::OnInternalIdle()
1143{
1144 wxCursor cursor = m_cursor;
1145 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1146
1147 if (cursor.Ok())
1148 {
1149 GdkWindow *window = (GdkWindow*) NULL;
1150 if (HasFlag(wxTE_MULTILINE))
1151 window = GTK_TEXT(m_text)->text_area;
1152 else
1153 window = GTK_ENTRY(m_text)->text_area;
1154
1155 if (window)
1156 gdk_window_set_cursor( window, cursor.GetCursor() );
1157
1158 if (!g_globalCursor.Ok())
1159 cursor = *wxSTANDARD_CURSOR;
1160
1161 window = m_widget->window;
1162 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1163 gdk_window_set_cursor( window, cursor.GetCursor() );
1164 }
1165
1166 UpdateWindowUI();
1167}
1168
1169wxSize wxTextCtrl::DoGetBestSize() const
1170{
1171 // FIXME should be different for multi-line controls...
1172 wxSize ret( wxControl::DoGetBestSize() );
1173 return wxSize(80, ret.y);
1174}
wxWidgets (Impactor)