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