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