]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Added wxTreeCtrl::GetItemParent to deprecate GetParent.
[wxWidgets.git] / src / gtk / textctrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11#pragma implementation "textctrl.h"
12#endif
13
14#include "wx/textctrl.h"
15#include "wx/utils.h"
16#include "wx/intl.h"
17#include "wx/log.h"
18#include "wx/settings.h"
19#include "wx/panel.h"
20#include "wx/strconv.h"
21
22#include <sys/types.h>
23#include <sys/stat.h>
24#include <ctype.h>
25#include <math.h> // for fabs
26
27#include "wx/gtk/private.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;
43extern wxWindowGTK *g_delayedFocus;
44
45// ----------------------------------------------------------------------------
46// helpers
47// ----------------------------------------------------------------------------
48
49#ifndef __WXGTK20__
50static void wxGtkTextInsert(GtkWidget *text,
51 const wxTextAttr& attr,
52 const char *txt,
53 size_t len)
54{
55 GdkFont *font = attr.HasFont() ? attr.GetFont().GetInternalFont()
56 : NULL;
57
58 GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
59 : NULL;
60
61 GdkColor *colBg = attr.HasBackgroundColour()
62 ? attr.GetBackgroundColour().GetColor()
63 : NULL;
64
65 gtk_text_insert( GTK_TEXT(text), font, colFg, colBg, txt, len );
66}
67#endif // GTK 1.x
68
69// ----------------------------------------------------------------------------
70// "insert_text" for GtkEntry
71// ----------------------------------------------------------------------------
72
73static void
74gtk_insert_text_callback(GtkEditable *editable,
75 const gchar *new_text,
76 gint new_text_length,
77 gint *position,
78 wxTextCtrl *win)
79{
80 if (g_isIdle)
81 wxapp_install_idle_handler();
82
83 // we should only be called if we have a max len limit at all
84 GtkEntry *entry = GTK_ENTRY (editable);
85
86 wxCHECK_RET( entry->text_max_length, _T("shouldn't be called") );
87
88 // check that we don't overflow the max length limit
89 //
90 // FIXME: this doesn't work when we paste a string which is going to be
91 // truncated
92 if ( entry->text_length == entry->text_max_length )
93 {
94 // we don't need to run the base class version at all
95 gtk_signal_emit_stop_by_name(GTK_OBJECT(editable), "insert_text");
96
97 // remember that the next changed signal is to be ignored to avoid
98 // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
99 win->IgnoreNextTextUpdate();
100
101 // and generate the correct one ourselves
102 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId());
103 event.SetEventObject(win);
104 event.SetString(win->GetValue());
105 win->GetEventHandler()->ProcessEvent( event );
106 }
107}
108
109//-----------------------------------------------------------------------------
110// "changed"
111//-----------------------------------------------------------------------------
112
113static void
114gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win )
115{
116 if ( win->IgnoreTextUpdate() )
117 return;
118
119 if (!win->m_hasVMT) return;
120
121 if (g_isIdle)
122 wxapp_install_idle_handler();
123
124 win->SetModified();
125 win->UpdateFontIfNeeded();
126
127 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
128 event.SetEventObject( win );
129 event.SetString( win->GetValue() );
130 win->GetEventHandler()->ProcessEvent( event );
131}
132
133//-----------------------------------------------------------------------------
134// "changed" from vertical scrollbar
135//-----------------------------------------------------------------------------
136
137#ifndef __WXGTK20__
138static void
139gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
140{
141 if (!win->m_hasVMT) return;
142
143 if (g_isIdle)
144 wxapp_install_idle_handler();
145
146 win->CalculateScrollbar();
147}
148#endif
149
150// ----------------------------------------------------------------------------
151// redraw callback for multiline text
152// ----------------------------------------------------------------------------
153
154#ifndef __WXGTK20__
155
156// redrawing a GtkText from inside a wxYield() call results in crashes (the
157// text sample shows it in its "Add lines" command which shows wxProgressDialog
158// which implicitly calls wxYield()) so we override GtkText::draw() and simply
159// don't do anything if we're inside wxYield()
160
161extern bool wxIsInsideYield;
162
163extern "C" {
164 typedef void (*GtkDrawCallback)(GtkWidget *widget, GdkRectangle *rect);
165}
166
167static GtkDrawCallback gs_gtk_text_draw = NULL;
168
169extern "C"
170void wxgtk_text_draw( GtkWidget *widget, GdkRectangle *rect)
171{
172 if ( !wxIsInsideYield )
173 {
174 wxCHECK_RET( gs_gtk_text_draw != wxgtk_text_draw,
175 _T("infinite recursion in wxgtk_text_draw aborted") );
176
177 gs_gtk_text_draw(widget, rect);
178 }
179}
180
181#endif // __WXGTK20__
182
183//-----------------------------------------------------------------------------
184// wxTextCtrl
185//-----------------------------------------------------------------------------
186
187IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
188
189BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
190 EVT_CHAR(wxTextCtrl::OnChar)
191
192 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
193 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
194 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
195 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
196 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
197
198 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
199 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
200 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
201 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
202 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
203END_EVENT_TABLE()
204
205void wxTextCtrl::Init()
206{
207 m_ignoreNextUpdate =
208 m_modified = FALSE;
209 m_updateFont = FALSE;
210 m_text =
211 m_vScrollbar = (GtkWidget *)NULL;
212}
213
214wxTextCtrl::wxTextCtrl( wxWindow *parent,
215 wxWindowID id,
216 const wxString &value,
217 const wxPoint &pos,
218 const wxSize &size,
219 long style,
220 const wxValidator& validator,
221 const wxString &name )
222{
223 Init();
224
225 Create( parent, id, value, pos, size, style, validator, name );
226}
227
228bool wxTextCtrl::Create( wxWindow *parent,
229 wxWindowID id,
230 const wxString &value,
231 const wxPoint &pos,
232 const wxSize &size,
233 long style,
234 const wxValidator& validator,
235 const wxString &name )
236{
237 m_needParent = TRUE;
238 m_acceptsFocus = TRUE;
239
240 if (!PreCreation( parent, pos, size ) ||
241 !CreateBase( parent, id, pos, size, style, validator, name ))
242 {
243 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
244 return FALSE;
245 }
246
247
248 m_vScrollbarVisible = FALSE;
249
250 bool multi_line = (style & wxTE_MULTILINE) != 0;
251
252#ifdef __WXGTK20__
253 GtkTextBuffer *buffer = NULL;
254#endif
255
256 if (multi_line)
257 {
258#ifdef __WXGTK20__
259 // Create view
260 m_text = gtk_text_view_new();
261
262 buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
263
264 // create scrolled window
265 m_widget = gtk_scrolled_window_new( NULL, NULL );
266 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget ),
267 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
268
269 // Insert view into scrolled window
270 gtk_container_add( GTK_CONTAINER(m_widget), m_text );
271
272 // Global settings which can be overridden by tags, I guess.
273 if (HasFlag( wxHSCROLL ))
274 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_NONE );
275 else
276 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_WORD );
277
278 if (!HasFlag(wxNO_BORDER))
279 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN );
280#else
281 // create our control ...
282 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
283
284 // ... and put into the upper left hand corner of the table
285 bool bHasHScrollbar = FALSE;
286 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
287 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
288 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
289 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
290 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
291 0, 0);
292
293 // always wrap words
294 gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
295
296 // finally, put the vertical scrollbar in the upper right corner
297 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
298 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
299 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
300 GTK_FILL,
301 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
302 0, 0);
303#endif
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 m_focusWidget = m_text;
315
316 PostCreation();
317
318 SetFont( parent->GetFont() );
319
320 wxSize size_best( DoGetBestSize() );
321 wxSize new_size( size );
322 if (new_size.x == -1)
323 new_size.x = size_best.x;
324 if (new_size.y == -1)
325 new_size.y = size_best.y;
326 if ((new_size.x != size.x) || (new_size.y != size.y))
327 SetSize( new_size.x, new_size.y );
328
329 if (multi_line)
330 gtk_widget_show(m_text);
331
332#ifndef __WXGTK20__
333 if (multi_line)
334 {
335 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
336 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
337
338 // only initialize gs_gtk_text_draw once, starting from the next the
339 // klass::draw will already be wxgtk_text_draw
340 if ( !gs_gtk_text_draw )
341 {
342 GtkDrawCallback&
343 draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw;
344
345 gs_gtk_text_draw = draw;
346
347 draw = wxgtk_text_draw;
348 }
349 }
350#endif // GTK+ 1.x
351
352 if (!value.IsEmpty())
353 {
354#ifdef __WXGTK20__
355 SetValue( value );
356#else
357
358#if !GTK_CHECK_VERSION(1, 2, 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 gint tmp = 0;
365#if wxUSE_UNICODE
366 wxWX2MBbuf val = value.mbc_str();
367 gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
368#else
369 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
370#endif
371
372 if (multi_line)
373 {
374 // Bring editable's cursor uptodate. Bug in GTK.
375 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
376 }
377
378#endif
379 }
380
381 if (style & wxTE_PASSWORD)
382 {
383 if (!multi_line)
384 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
385 }
386
387 if (style & wxTE_READONLY)
388 {
389 if (!multi_line)
390 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
391#ifdef __WXGTK20__
392 else
393 gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text), FALSE);
394 }
395#else
396 }
397 else
398 {
399 if (multi_line)
400 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
401 }
402#endif
403
404 // We want to be notified about text changes.
405#ifdef __WXGTK20__
406 if (multi_line)
407 {
408 g_signal_connect( G_OBJECT(buffer), "changed",
409 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
410 }
411 else
412#endif
413 {
414 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
415 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
416 }
417
418 // we don't set a valid background colour, because the window
419 // manager should use a default one
420 m_backgroundColour = wxColour();
421
422 wxColour colFg = parent->GetForegroundColour();
423 SetForegroundColour( colFg );
424
425 m_cursor = wxCursor( wxCURSOR_IBEAM );
426
427#ifndef __WXGTK20__
428 wxTextAttr attrDef( colFg, m_backgroundColour, parent->GetFont() );
429 SetDefaultStyle( attrDef );
430#endif
431
432 Show( TRUE );
433
434 return TRUE;
435}
436
437void wxTextCtrl::CalculateScrollbar()
438{
439#ifndef __WXGTK20__
440 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
441
442 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
443
444 if (adj->upper - adj->page_size < 0.8)
445 {
446 if (m_vScrollbarVisible)
447 {
448 gtk_widget_hide( m_vScrollbar );
449 m_vScrollbarVisible = FALSE;
450 }
451 }
452 else
453 {
454 if (!m_vScrollbarVisible)
455 {
456 gtk_widget_show( m_vScrollbar );
457 m_vScrollbarVisible = TRUE;
458 }
459 }
460#endif
461}
462
463wxString wxTextCtrl::GetValue() const
464{
465 wxCHECK_MSG( m_text != NULL, wxT(""), wxT("invalid text ctrl") );
466
467 wxString tmp;
468 if (m_windowStyle & wxTE_MULTILINE)
469 {
470#ifdef __WXGTK20__
471 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
472
473 GtkTextIter start;
474 gtk_text_buffer_get_start_iter( text_buffer, &start );
475 GtkTextIter end;
476 gtk_text_buffer_get_end_iter( text_buffer, &end );
477 gchar *text = gtk_text_buffer_get_text( text_buffer, &start, &end, TRUE );
478
479#if wxUSE_UNICODE
480 wxWCharBuffer buffer( wxConvUTF8.cMB2WX( text ) );
481#else
482 wxCharBuffer buffer( wxConvLocal.cWC2WX( wxConvUTF8.cMB2WC( text ) ) );
483#endif
484 tmp = buffer;
485
486 g_free( text );
487#else
488 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
489 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
490 tmp = text;
491 g_free( text );
492#endif
493 }
494 else
495 {
496 tmp = wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text) ) );
497 }
498
499 return tmp;
500}
501
502void wxTextCtrl::SetValue( const wxString &value )
503{
504 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
505
506 if (m_windowStyle & wxTE_MULTILINE)
507 {
508#ifdef __WXGTK20__
509
510#if wxUSE_UNICODE
511 wxCharBuffer buffer( wxConvUTF8.cWX2MB( value) );
512#else
513 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( value ) ) );
514#endif
515 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
516 gtk_text_buffer_set_text( text_buffer, buffer, strlen(buffer) );
517
518#else
519 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
520 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
521 len = 0;
522 gtk_editable_insert_text( GTK_EDITABLE(m_text), value.mbc_str(), value.Length(), &len );
523#endif
524 }
525 else
526 {
527 gtk_entry_set_text( GTK_ENTRY(m_text), wxGTK_CONV( value ) );
528 }
529
530 // GRG, Jun/2000: Changed this after a lot of discussion in
531 // the lists. wxWindows 2.2 will have a set of flags to
532 // customize this behaviour.
533 SetInsertionPoint(0);
534
535 m_modified = FALSE;
536}
537
538void wxTextCtrl::WriteText( const wxString &text )
539{
540 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
541
542 if ( text.empty() )
543 return;
544
545 if ( m_windowStyle & wxTE_MULTILINE )
546 {
547#ifdef __WXGTK20__
548
549#if wxUSE_UNICODE
550 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
551#else
552 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
553#endif
554 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
555 // TODO: call wahtever is needed to delete the selection
556 gtk_text_buffer_insert_at_cursor( text_buffer, buffer, strlen(buffer) );
557
558#else // GTK 1.x
559 // After cursor movements, gtk_text_get_point() is wrong by one.
560 gtk_text_set_point( GTK_TEXT(m_text), GET_EDITABLE_POS(m_text) );
561
562 // always use m_defaultStyle, even if it is empty as otherwise
563 // resetting the style and appending some more text wouldn't work: if
564 // we don't specify the style explicitly, the old style would be used
565 gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
566 wxGtkTextInsert(m_text, m_defaultStyle, text.c_str(), text.Len());
567
568 // Bring editable's cursor back uptodate.
569 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
570#endif // GTK 1.x/2.0
571 }
572 else // single line
573 {
574 // First remove the selection if there is one
575 gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
576
577 // This moves the cursor pos to behind the inserted text.
578 gint len = GET_EDITABLE_POS(m_text);
579
580#ifdef __WXGTK20__
581
582#if wxUSE_UNICODE
583 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
584#else
585 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
586#endif
587 gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
588
589#else
590 gtk_editable_insert_text( GTK_EDITABLE(m_text), text.c_str(), text.Len(), &len );
591#endif
592
593 // Bring entry's cursor uptodate.
594 gtk_entry_set_position( GTK_ENTRY(m_text), len );
595 }
596
597 m_modified = TRUE;
598}
599
600void wxTextCtrl::AppendText( const wxString &text )
601{
602 SetInsertionPointEnd();
603 WriteText( text );
604}
605
606wxString wxTextCtrl::GetLineText( long lineNo ) const
607{
608 if (m_windowStyle & wxTE_MULTILINE)
609 {
610#ifndef __WXGTK20__
611 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
612 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
613
614 if (text)
615 {
616 wxString buf(wxT(""));
617 long i;
618 int currentLine = 0;
619 for (i = 0; currentLine != lineNo && text[i]; i++ )
620 if (text[i] == '\n')
621 currentLine++;
622 // Now get the text
623 int j;
624 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
625 buf += text[i];
626
627 g_free( text );
628 return buf;
629 }
630 else
631#endif
632 {
633 return wxEmptyString;
634 }
635 }
636 else
637 {
638 if (lineNo == 0) return GetValue();
639 return wxEmptyString;
640 }
641}
642
643void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
644{
645 /* If you implement this, don't forget to update the documentation!
646 * (file docs/latex/wx/text.tex) */
647 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
648}
649
650bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
651{
652 if ( m_windowStyle & wxTE_MULTILINE )
653 {
654 wxString text = GetValue();
655
656 // cast to prevent warning. But pos really should've been unsigned.
657 if( (unsigned long)pos > text.Len() )
658 return FALSE;
659
660 *x=0; // First Col
661 *y=0; // First Line
662
663 const wxChar* stop = text.c_str() + pos;
664 for ( const wxChar *p = text.c_str(); p < stop; p++ )
665 {
666 if (*p == wxT('\n'))
667 {
668 (*y)++;
669 *x=0;
670 }
671 else
672 (*x)++;
673 }
674 }
675 else // single line control
676 {
677 if ( pos <= GTK_ENTRY(m_text)->text_length )
678 {
679 *y = 0;
680 *x = pos;
681 }
682 else
683 {
684 // index out of bounds
685 return FALSE;
686 }
687 }
688
689 return TRUE;
690}
691
692long wxTextCtrl::XYToPosition(long x, long y ) const
693{
694 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
695
696 long pos=0;
697 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
698
699 pos += x;
700 return pos;
701}
702
703int wxTextCtrl::GetLineLength(long lineNo) const
704{
705 wxString str = GetLineText (lineNo);
706 return (int) str.Length();
707}
708
709int wxTextCtrl::GetNumberOfLines() const
710{
711 if (m_windowStyle & wxTE_MULTILINE)
712 {
713#ifdef __WXGTK20__
714 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
715
716 return gtk_text_buffer_get_line_count( buffer );
717#else
718 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
719 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
720
721 if (text)
722 {
723 int currentLine = 0;
724 for (int i = 0; i < len; i++ )
725 {
726 if (text[i] == '\n')
727 currentLine++;
728 }
729 g_free( text );
730
731 // currentLine is 0 based, add 1 to get number of lines
732 return currentLine + 1;
733 }
734 else
735 {
736 return 0;
737 }
738#endif
739 }
740 else
741 {
742 return 1;
743 }
744}
745
746void wxTextCtrl::SetInsertionPoint( long pos )
747{
748 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
749
750 if (m_windowStyle & wxTE_MULTILINE)
751 {
752#ifdef __WXGTK20__
753 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
754 GtkTextIter iter;
755 gtk_text_buffer_get_iter_at_offset( text_buffer, &iter, pos );
756 gtk_text_buffer_place_cursor( text_buffer, &iter );
757#else
758 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
759 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
760
761 /* we fake a set_point by inserting and deleting. as the user
762 isn't supposed to get to know about this non-sense, we
763 disconnect so that no events are sent to the user program. */
764
765 gint tmp = (gint)pos;
766 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
767 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
768
769 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
770 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
771
772 // bring editable's cursor uptodate. Bug in GTK.
773 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
774#endif
775 }
776 else
777 {
778 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
779
780 // Bring editable's cursor uptodate. Bug in GTK.
781 SET_EDITABLE_POS(m_text, (guint32)pos);
782 }
783}
784
785void wxTextCtrl::SetInsertionPointEnd()
786{
787 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
788
789 if (m_windowStyle & wxTE_MULTILINE)
790 {
791#ifdef __WXGTK20__
792 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
793 GtkTextIter end;
794 gtk_text_buffer_get_end_iter( text_buffer, &end );
795 gtk_text_buffer_place_cursor( text_buffer, &end );
796#else
797 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
798#endif
799 }
800 else
801 {
802 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
803 }
804}
805
806void wxTextCtrl::SetEditable( bool editable )
807{
808 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
809
810 if (m_windowStyle & wxTE_MULTILINE)
811 {
812#ifdef __WXGTK20__
813 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
814#else
815 gtk_text_set_editable( GTK_TEXT(m_text), editable );
816#endif
817 }
818 else
819 {
820 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
821 }
822}
823
824bool wxTextCtrl::Enable( bool enable )
825{
826 if (!wxWindowBase::Enable(enable))
827 {
828 // nothing to do
829 return FALSE;
830 }
831
832 if (m_windowStyle & wxTE_MULTILINE)
833 {
834#ifdef __WXGTK20__
835 SetEditable( enable );
836#else
837 gtk_text_set_editable( GTK_TEXT(m_text), enable );
838 OnParentEnable(enable);
839#endif
840 }
841 else
842 {
843 gtk_widget_set_sensitive( m_text, enable );
844 }
845
846 return TRUE;
847}
848
849// wxGTK-specific: called recursively by Enable,
850// to give widgets an oppprtunity to correct their colours after they
851// have been changed by Enable
852void wxTextCtrl::OnParentEnable( bool enable )
853{
854 // If we have a custom background colour, we use this colour in both
855 // disabled and enabled mode, or we end up with a different colour under the
856 // text.
857 wxColour oldColour = GetBackgroundColour();
858 if (oldColour.Ok())
859 {
860 // Need to set twice or it'll optimize the useful stuff out
861 if (oldColour == * wxWHITE)
862 SetBackgroundColour(*wxBLACK);
863 else
864 SetBackgroundColour(*wxWHITE);
865 SetBackgroundColour(oldColour);
866 }
867}
868
869void wxTextCtrl::DiscardEdits()
870{
871 m_modified = FALSE;
872}
873
874// ----------------------------------------------------------------------------
875// max text length support
876// ----------------------------------------------------------------------------
877
878void wxTextCtrl::IgnoreNextTextUpdate()
879{
880 m_ignoreNextUpdate = TRUE;
881}
882
883bool wxTextCtrl::IgnoreTextUpdate()
884{
885 if ( m_ignoreNextUpdate )
886 {
887 m_ignoreNextUpdate = FALSE;
888
889 return TRUE;
890 }
891
892 return FALSE;
893}
894
895void wxTextCtrl::SetMaxLength(unsigned long len)
896{
897 if ( !HasFlag(wxTE_MULTILINE) )
898 {
899 gtk_entry_set_max_length(GTK_ENTRY(m_text), len);
900
901 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
902 // we had tried to enter more text than allowed by max text length and
903 // the text wasn't really changed
904 //
905 // to detect this and generate TEXT_MAXLEN event instead of
906 // TEXT_CHANGED one in this case we also catch "insert_text" signal
907 //
908 // when max len is set to 0 we disconnect our handler as it means that
909 // we shouldn't check anything any more
910 if ( len )
911 {
912 gtk_signal_connect( GTK_OBJECT(m_text),
913 "insert_text",
914 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
915 (gpointer)this);
916 }
917 else // no checking
918 {
919 gtk_signal_disconnect_by_func
920 (
921 GTK_OBJECT(m_text),
922 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
923 (gpointer)this
924 );
925 }
926 }
927}
928
929void wxTextCtrl::SetSelection( long from, long to )
930{
931 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
932
933 if (from == -1 && to == -1)
934 {
935 from = 0;
936 to = GetValue().Length();
937 }
938
939#ifndef __WXGTK20__
940 if ( (m_windowStyle & wxTE_MULTILINE) &&
941 !GTK_TEXT(m_text)->line_start_cache )
942 {
943 // tell the programmer that it didn't work
944 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
945 return;
946 }
947#endif
948
949 if (m_windowStyle & wxTE_MULTILINE)
950 {
951#ifdef __WXGTK20__
952 // ????
953#else
954 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
955#endif
956 }
957 else
958 {
959 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
960 }
961}
962
963void wxTextCtrl::ShowPosition( long pos )
964{
965#ifndef __WXGTK20__
966 if (m_windowStyle & wxTE_MULTILINE)
967 {
968 GtkAdjustment *vp = GTK_TEXT(m_text)->vadj;
969 float totalLines = (float) GetNumberOfLines();
970 long posX;
971 long posY;
972 PositionToXY(pos, &posX, &posY);
973 float posLine = (float) posY;
974 float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower;
975 gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p);
976 }
977#endif
978}
979
980long wxTextCtrl::GetInsertionPoint() const
981{
982 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
983
984#ifdef __WXGTK20__
985 if (m_windowStyle & wxTE_MULTILINE)
986 {
987 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
988
989 // There is no direct accessor for the cursor, but
990 // internally, the cursor is the "mark" called
991 // "insert" in the text view's btree structure.
992
993 GtkTextMark *mark = gtk_text_buffer_get_insert( text_buffer );
994 GtkTextIter cursor;
995 gtk_text_buffer_get_iter_at_mark( text_buffer, &cursor, mark );
996
997 return gtk_text_iter_get_offset( &cursor );
998 }
999 else
1000#endif
1001 {
1002 return (long) GET_EDITABLE_POS(m_text);
1003 }
1004}
1005
1006long wxTextCtrl::GetLastPosition() const
1007{
1008 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1009
1010 int pos = 0;
1011
1012 if (m_windowStyle & wxTE_MULTILINE)
1013 {
1014#ifdef __WXGTK20__
1015 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1016 GtkTextIter end;
1017 gtk_text_buffer_get_end_iter( text_buffer, &end );
1018
1019 pos = gtk_text_iter_get_offset( &end );
1020#else
1021 pos = gtk_text_get_length( GTK_TEXT(m_text) );
1022#endif
1023 }
1024 else
1025 {
1026 pos = GTK_ENTRY(m_text)->text_length;
1027 }
1028
1029 return (long)pos;
1030}
1031
1032void wxTextCtrl::Remove( long from, long to )
1033{
1034 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1035
1036#ifndef __WXGTK20__
1037 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1038#endif
1039}
1040
1041void wxTextCtrl::Replace( long from, long to, const wxString &value )
1042{
1043 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1044
1045#ifndef __WXGTK20__
1046 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1047
1048 if (!value.IsEmpty())
1049 {
1050 gint pos = (gint)from;
1051#if wxUSE_UNICODE
1052 wxWX2MBbuf buf = value.mbc_str();
1053 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
1054#else
1055 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
1056#endif
1057 }
1058#endif
1059}
1060
1061void wxTextCtrl::Cut()
1062{
1063 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1064
1065#ifndef __WXGTK20__
1066 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1067#endif
1068}
1069
1070void wxTextCtrl::Copy()
1071{
1072 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1073
1074#ifndef __WXGTK20__
1075 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1076#endif
1077}
1078
1079void wxTextCtrl::Paste()
1080{
1081 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1082
1083#ifndef __WXGTK20__
1084 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1085#endif
1086}
1087
1088// Undo/redo
1089void wxTextCtrl::Undo()
1090{
1091 // TODO
1092 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1093}
1094
1095void wxTextCtrl::Redo()
1096{
1097 // TODO
1098 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1099}
1100
1101bool wxTextCtrl::CanUndo() const
1102{
1103 // TODO
1104 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1105 return FALSE;
1106}
1107
1108bool wxTextCtrl::CanRedo() const
1109{
1110 // TODO
1111 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1112 return FALSE;
1113}
1114
1115// If the return values from and to are the same, there is no
1116// selection.
1117void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1118{
1119 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1120
1121 gint from, to;
1122#ifdef __WXGTK20__
1123 if ( !gtk_editable_get_selection_bounds(GTK_EDITABLE(m_text), &from, &to) )
1124#else
1125 if ( !(GTK_EDITABLE(m_text)->has_selection) )
1126#endif
1127 {
1128 from =
1129 to = GetInsertionPoint();
1130 }
1131 else // got selection
1132 {
1133#ifndef __WXGTK20__
1134 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1135 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1136#endif
1137
1138 if ( from > to )
1139 {
1140 // exchange them to be compatible with wxMSW
1141 gint tmp = from;
1142 from = to;
1143 to = tmp;
1144 }
1145 }
1146
1147 if ( fromOut )
1148 *fromOut = from;
1149 if ( toOut )
1150 *toOut = to;
1151}
1152
1153bool wxTextCtrl::IsEditable() const
1154{
1155 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1156
1157#ifdef __WXGTK20__
1158 return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1159#else
1160 return GTK_EDITABLE(m_text)->editable;
1161#endif
1162}
1163
1164bool wxTextCtrl::IsModified() const
1165{
1166 return m_modified;
1167}
1168
1169void wxTextCtrl::Clear()
1170{
1171 SetValue( wxT("") );
1172}
1173
1174void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1175{
1176 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1177
1178 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1179 {
1180 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1181 event.SetEventObject(this);
1182 event.SetString(GetValue());
1183 if (GetEventHandler()->ProcessEvent(event)) return;
1184 }
1185
1186 if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1187 {
1188 // This will invoke the dialog default action, such
1189 // as the clicking the default button.
1190
1191 wxWindow *top_frame = m_parent;
1192 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1193 top_frame = top_frame->GetParent();
1194
1195 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1196 {
1197 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1198
1199 if (window->default_widget)
1200 {
1201 gtk_widget_activate (window->default_widget);
1202 return;
1203 }
1204 }
1205 }
1206
1207 key_event.Skip();
1208}
1209
1210GtkWidget* wxTextCtrl::GetConnectWidget()
1211{
1212 return GTK_WIDGET(m_text);
1213}
1214
1215bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1216{
1217 if (m_windowStyle & wxTE_MULTILINE)
1218 {
1219#ifdef __WXGTK20__
1220 return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT ); // pure guesswork
1221#else
1222 return (window == GTK_TEXT(m_text)->text_area);
1223#endif
1224 }
1225 else
1226 {
1227 return (window == GTK_ENTRY(m_text)->text_area);
1228 }
1229}
1230
1231// the font will change for subsequent text insertiongs
1232bool wxTextCtrl::SetFont( const wxFont &font )
1233{
1234 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1235
1236 if ( !wxTextCtrlBase::SetFont(font) )
1237 {
1238 // font didn't change, nothing to do
1239 return FALSE;
1240 }
1241
1242 if ( m_windowStyle & wxTE_MULTILINE )
1243 {
1244 m_updateFont = TRUE;
1245
1246 m_defaultStyle.SetFont(font);
1247
1248 ChangeFontGlobally();
1249 }
1250
1251 return TRUE;
1252}
1253
1254void wxTextCtrl::ChangeFontGlobally()
1255{
1256 // this method is very inefficient and hence should be called as rarely as
1257 // possible!
1258 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1259 _T("shouldn't be called for single line controls") );
1260
1261 wxString value = GetValue();
1262 if ( !value.IsEmpty() )
1263 {
1264 m_updateFont = FALSE;
1265
1266 Clear();
1267 AppendText(value);
1268 }
1269}
1270
1271void wxTextCtrl::UpdateFontIfNeeded()
1272{
1273 if ( m_updateFont )
1274 ChangeFontGlobally();
1275}
1276
1277bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1278{
1279 if ( !wxControl::SetForegroundColour(colour) )
1280 return FALSE;
1281
1282 // update default fg colour too
1283 m_defaultStyle.SetTextColour(colour);
1284
1285 return TRUE;
1286}
1287
1288bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1289{
1290 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1291
1292 if ( !wxControl::SetBackgroundColour( colour ) )
1293 return FALSE;
1294
1295 if (!m_widget->window)
1296 return FALSE;
1297
1298 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1299 if (sysbg.Red() == colour.Red() &&
1300 sysbg.Green() == colour.Green() &&
1301 sysbg.Blue() == colour.Blue())
1302 {
1303 return FALSE; // FIXME or TRUE?
1304 }
1305
1306 if (!m_backgroundColour.Ok())
1307 return FALSE;
1308
1309 if (m_windowStyle & wxTE_MULTILINE)
1310 {
1311#ifndef __WXGTK20__
1312 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1313 if (!window)
1314 return FALSE;
1315 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1316 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1317 gdk_window_clear( window );
1318#endif
1319 }
1320
1321 // change active background color too
1322 m_defaultStyle.SetBackgroundColour( colour );
1323
1324 return TRUE;
1325}
1326
1327bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1328{
1329 /* VERY dirty way to do that - removes the required text and re-adds it
1330 with styling (FIXME) */
1331 if ( m_windowStyle & wxTE_MULTILINE )
1332 {
1333#ifndef __WXGTK20__
1334 if ( style.IsDefault() )
1335 {
1336 // nothing to do
1337 return TRUE;
1338 }
1339
1340 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1341
1342 wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1343 _T("invalid range in wxTextCtrl::SetStyle") );
1344
1345 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1346 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1347 wxString tmp(text,*wxConvCurrent);
1348 g_free( text );
1349
1350 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1351 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1352
1353#if wxUSE_UNICODE
1354 wxWX2MBbuf buf = tmp.mbc_str();
1355 const char *txt = buf;
1356 size_t txtlen = strlen(buf);
1357#else
1358 const char *txt = tmp;
1359 size_t txtlen = tmp.length();
1360#endif
1361
1362 // use the attributes from style which are set in it and fall back
1363 // first to the default style and then to the text control default
1364 // colours for the others
1365 wxGtkTextInsert(m_text,
1366 wxTextAttr::Combine(style, m_defaultStyle, this),
1367 txt,
1368 txtlen);
1369
1370 /* does not seem to help under GTK+ 1.2 !!!
1371 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1372 SetInsertionPoint( old_pos );
1373#endif
1374 return TRUE;
1375 }
1376 else // singe line
1377 {
1378 // cannot do this for GTK+'s Entry widget
1379 return FALSE;
1380 }
1381}
1382
1383void wxTextCtrl::ApplyWidgetStyle()
1384{
1385 if (m_windowStyle & wxTE_MULTILINE)
1386 {
1387 // how ?
1388 }
1389 else
1390 {
1391 SetWidgetStyle();
1392 gtk_widget_set_style( m_text, m_widgetStyle );
1393 }
1394}
1395
1396void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1397{
1398 Cut();
1399}
1400
1401void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1402{
1403 Copy();
1404}
1405
1406void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1407{
1408 Paste();
1409}
1410
1411void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1412{
1413 Undo();
1414}
1415
1416void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1417{
1418 Redo();
1419}
1420
1421void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1422{
1423 event.Enable( CanCut() );
1424}
1425
1426void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1427{
1428 event.Enable( CanCopy() );
1429}
1430
1431void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1432{
1433 event.Enable( CanPaste() );
1434}
1435
1436void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1437{
1438 event.Enable( CanUndo() );
1439}
1440
1441void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1442{
1443 event.Enable( CanRedo() );
1444}
1445
1446void wxTextCtrl::OnInternalIdle()
1447{
1448 wxCursor cursor = m_cursor;
1449 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1450
1451 if (cursor.Ok())
1452 {
1453#ifndef __WXGTK20__
1454 GdkWindow *window = (GdkWindow*) NULL;
1455 if (HasFlag(wxTE_MULTILINE))
1456 window = GTK_TEXT(m_text)->text_area;
1457 else
1458 window = GTK_ENTRY(m_text)->text_area;
1459
1460 if (window)
1461 gdk_window_set_cursor( window, cursor.GetCursor() );
1462
1463 if (!g_globalCursor.Ok())
1464 cursor = *wxSTANDARD_CURSOR;
1465
1466 window = m_widget->window;
1467 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1468 gdk_window_set_cursor( window, cursor.GetCursor() );
1469#endif
1470 }
1471
1472 if (g_delayedFocus == this)
1473 {
1474 if (GTK_WIDGET_REALIZED(m_widget))
1475 {
1476 gtk_widget_grab_focus( m_widget );
1477 g_delayedFocus = NULL;
1478 }
1479 }
1480
1481 UpdateWindowUI();
1482}
1483
1484wxSize wxTextCtrl::DoGetBestSize() const
1485{
1486 // FIXME should be different for multi-line controls...
1487 wxSize ret( wxControl::DoGetBestSize() );
1488 return wxSize(80, ret.y);
1489}
1490
1491// ----------------------------------------------------------------------------
1492// freeze/thaw
1493// ----------------------------------------------------------------------------
1494
1495void wxTextCtrl::Freeze()
1496{
1497#ifndef __WXGTK20__
1498 if ( HasFlag(wxTE_MULTILINE) )
1499 {
1500 gtk_text_freeze(GTK_TEXT(m_text));
1501 }
1502#endif
1503}
1504
1505void wxTextCtrl::Thaw()
1506{
1507#ifndef __WXGTK20__
1508 if ( HasFlag(wxTE_MULTILINE) )
1509 {
1510 GTK_TEXT(m_text)->vadj->value = 0.0;
1511
1512 gtk_text_thaw(GTK_TEXT(m_text));
1513 }
1514#endif
1515}
1516
1517// ----------------------------------------------------------------------------
1518// scrolling
1519// ----------------------------------------------------------------------------
1520
1521GtkAdjustment *wxTextCtrl::GetVAdj() const
1522{
1523#ifdef __WXGTK20__
1524 return NULL;
1525#else
1526 return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1527#endif
1528}
1529
1530bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1531{
1532#ifndef __WXGTK20__
1533 float value = adj->value + diff;
1534
1535 if ( value < 0 )
1536 value = 0;
1537
1538 float upper = adj->upper - adj->page_size;
1539 if ( value > upper )
1540 value = upper;
1541
1542 // did we noticeably change the scroll position?
1543 if ( fabs(adj->value - value) < 0.2 )
1544 {
1545 // well, this is what Robert does in wxScrollBar, so it must be good...
1546 return FALSE;
1547 }
1548
1549 adj->value = value;
1550
1551 gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1552
1553#endif
1554 return TRUE;
1555}
1556
1557bool wxTextCtrl::ScrollLines(int lines)
1558{
1559#ifdef __WXGTK20__
1560 return FALSE;
1561#else
1562 GtkAdjustment *adj = GetVAdj();
1563 if ( !adj )
1564 return FALSE;
1565
1566 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1567 static const int KEY_SCROLL_PIXELS = 10;
1568
1569 return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1570#endif
1571}
1572
1573bool wxTextCtrl::ScrollPages(int pages)
1574{
1575#ifdef __WXGTK20__
1576 return FALSE;
1577#else
1578 GtkAdjustment *adj = GetVAdj();
1579 if ( !adj )
1580 return FALSE;
1581
1582 return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1583#endif
1584}
1585
wxWidgets (Impactor)