]> 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 RPM spec file
[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
49static void wxGtkTextInsert(GtkWidget *text,
50 const wxTextAttr& attr,
51 const char *txt,
52 size_t len)
53{
54#ifndef __WXGTK__
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#endif
67}
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 gtk_text_buffer_insert_at_cursor( text_buffer, buffer, strlen(buffer) );
556
557#else
558 // After cursor movements, gtk_text_get_point() is wrong by one.
559 gtk_text_set_point( GTK_TEXT(m_text), GET_EDITABLE_POS(m_text) );
560
561 // always use m_defaultStyle, even if it is empty as otherwise
562 // resetting the style and appending some more text wouldn't work: if
563 // we don't specify the style explicitly, the old style would be used
564 wxGtkTextInsert(m_text, m_defaultStyle, text.c_str(), text.Len());
565
566 // Bring editable's cursor back uptodate.
567 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
568#endif
569 }
570 else // single line
571 {
572 // This moves the cursor pos to behind the inserted text.
573 gint len = GET_EDITABLE_POS(m_text);
574
575#ifdef __WXGTK20__
576
577#if wxUSE_UNICODE
578 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
579#else
580 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
581#endif
582 gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
583
584#else
585 gtk_editable_insert_text( GTK_EDITABLE(m_text), text.c_str(), text.Len(), &len );
586#endif
587
588 // Bring editable's cursor uptodate.
589 len += text.Len();
590
591 // Bring entry's cursor uptodate.
592 gtk_entry_set_position( GTK_ENTRY(m_text), len );
593 }
594
595 m_modified = TRUE;
596}
597
598void wxTextCtrl::AppendText( const wxString &text )
599{
600 SetInsertionPointEnd();
601 WriteText( text );
602}
603
604wxString wxTextCtrl::GetLineText( long lineNo ) const
605{
606 if (m_windowStyle & wxTE_MULTILINE)
607 {
608#ifndef __WXGTK20__
609 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
610 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
611
612 if (text)
613 {
614 wxString buf(wxT(""));
615 long i;
616 int currentLine = 0;
617 for (i = 0; currentLine != lineNo && text[i]; i++ )
618 if (text[i] == '\n')
619 currentLine++;
620 // Now get the text
621 int j;
622 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
623 buf += text[i];
624
625 g_free( text );
626 return buf;
627 }
628 else
629#endif
630 {
631 return wxEmptyString;
632 }
633 }
634 else
635 {
636 if (lineNo == 0) return GetValue();
637 return wxEmptyString;
638 }
639}
640
641void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
642{
643 /* If you implement this, don't forget to update the documentation!
644 * (file docs/latex/wx/text.tex) */
645 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
646}
647
648bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
649{
650 if ( m_windowStyle & wxTE_MULTILINE )
651 {
652 wxString text = GetValue();
653
654 // cast to prevent warning. But pos really should've been unsigned.
655 if( (unsigned long)pos > text.Len() )
656 return FALSE;
657
658 *x=0; // First Col
659 *y=0; // First Line
660
661 const wxChar* stop = text.c_str() + pos;
662 for ( const wxChar *p = text.c_str(); p < stop; p++ )
663 {
664 if (*p == wxT('\n'))
665 {
666 (*y)++;
667 *x=0;
668 }
669 else
670 (*x)++;
671 }
672 }
673 else // single line control
674 {
675 if ( pos <= GTK_ENTRY(m_text)->text_length )
676 {
677 *y = 0;
678 *x = pos;
679 }
680 else
681 {
682 // index out of bounds
683 return FALSE;
684 }
685 }
686
687 return TRUE;
688}
689
690long wxTextCtrl::XYToPosition(long x, long y ) const
691{
692 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
693
694 long pos=0;
695 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
696
697 pos += x;
698 return pos;
699}
700
701int wxTextCtrl::GetLineLength(long lineNo) const
702{
703 wxString str = GetLineText (lineNo);
704 return (int) str.Length();
705}
706
707int wxTextCtrl::GetNumberOfLines() const
708{
709 if (m_windowStyle & wxTE_MULTILINE)
710 {
711#ifdef __WXGTK20__
712 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
713
714 return gtk_text_buffer_get_line_count( buffer );
715#else
716 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
717 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
718
719 if (text)
720 {
721 int currentLine = 0;
722 for (int i = 0; i < len; i++ )
723 {
724 if (text[i] == '\n')
725 currentLine++;
726 }
727 g_free( text );
728
729 // currentLine is 0 based, add 1 to get number of lines
730 return currentLine + 1;
731 }
732 else
733 {
734 return 0;
735 }
736#endif
737 }
738 else
739 {
740 return 1;
741 }
742}
743
744void wxTextCtrl::SetInsertionPoint( long pos )
745{
746 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
747
748 if (m_windowStyle & wxTE_MULTILINE)
749 {
750#ifdef __WXGTK20__
751 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
752 GtkTextIter iter;
753 gtk_text_buffer_get_iter_at_offset( text_buffer, &iter, pos );
754 gtk_text_buffer_place_cursor( text_buffer, &iter );
755#else
756 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
757 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
758
759 /* we fake a set_point by inserting and deleting. as the user
760 isn't supposed to get to know about this non-sense, we
761 disconnect so that no events are sent to the user program. */
762
763 gint tmp = (gint)pos;
764 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
765 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
766
767 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
768 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
769
770 // bring editable's cursor uptodate. Bug in GTK.
771 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
772#endif
773 }
774 else
775 {
776 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
777
778 // Bring editable's cursor uptodate. Bug in GTK.
779 SET_EDITABLE_POS(m_text, (guint32)pos);
780 }
781}
782
783void wxTextCtrl::SetInsertionPointEnd()
784{
785 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
786
787 if (m_windowStyle & wxTE_MULTILINE)
788 {
789#ifdef __WXGTK20__
790 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
791 GtkTextIter end;
792 gtk_text_buffer_get_end_iter( text_buffer, &end );
793 gtk_text_buffer_place_cursor( text_buffer, &end );
794#else
795 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
796#endif
797 }
798 else
799 {
800 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
801 }
802}
803
804void wxTextCtrl::SetEditable( bool editable )
805{
806 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
807
808 if (m_windowStyle & wxTE_MULTILINE)
809 {
810#ifdef __WXGTK20__
811 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
812#else
813 gtk_text_set_editable( GTK_TEXT(m_text), editable );
814#endif
815 }
816 else
817 {
818 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
819 }
820}
821
822bool wxTextCtrl::Enable( bool enable )
823{
824 if (!wxWindowBase::Enable(enable))
825 {
826 // nothing to do
827 return FALSE;
828 }
829
830 if (m_windowStyle & wxTE_MULTILINE)
831 {
832#ifdef __WXGTK20__
833 SetEditable( enable );
834#else
835 gtk_text_set_editable( GTK_TEXT(m_text), enable );
836 OnParentEnable(enable);
837#endif
838 }
839 else
840 {
841 gtk_widget_set_sensitive( m_text, enable );
842 }
843
844 return TRUE;
845}
846
847// wxGTK-specific: called recursively by Enable,
848// to give widgets an oppprtunity to correct their colours after they
849// have been changed by Enable
850void wxTextCtrl::OnParentEnable( bool enable )
851{
852 // If we have a custom background colour, we use this colour in both
853 // disabled and enabled mode, or we end up with a different colour under the
854 // text.
855 wxColour oldColour = GetBackgroundColour();
856 if (oldColour.Ok())
857 {
858 // Need to set twice or it'll optimize the useful stuff out
859 if (oldColour == * wxWHITE)
860 SetBackgroundColour(*wxBLACK);
861 else
862 SetBackgroundColour(*wxWHITE);
863 SetBackgroundColour(oldColour);
864 }
865}
866
867void wxTextCtrl::DiscardEdits()
868{
869 m_modified = FALSE;
870}
871
872// ----------------------------------------------------------------------------
873// max text length support
874// ----------------------------------------------------------------------------
875
876void wxTextCtrl::IgnoreNextTextUpdate()
877{
878 m_ignoreNextUpdate = TRUE;
879}
880
881bool wxTextCtrl::IgnoreTextUpdate()
882{
883 if ( m_ignoreNextUpdate )
884 {
885 m_ignoreNextUpdate = FALSE;
886
887 return TRUE;
888 }
889
890 return FALSE;
891}
892
893void wxTextCtrl::SetMaxLength(unsigned long len)
894{
895 if ( !HasFlag(wxTE_MULTILINE) )
896 {
897 gtk_entry_set_max_length(GTK_ENTRY(m_text), len);
898
899 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
900 // we had tried to enter more text than allowed by max text length and
901 // the text wasn't really changed
902 //
903 // to detect this and generate TEXT_MAXLEN event instead of
904 // TEXT_CHANGED one in this case we also catch "insert_text" signal
905 //
906 // when max len is set to 0 we disconnect our handler as it means that
907 // we shouldn't check anything any more
908 if ( len )
909 {
910 gtk_signal_connect( GTK_OBJECT(m_text),
911 "insert_text",
912 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
913 (gpointer)this);
914 }
915 else // no checking
916 {
917 gtk_signal_disconnect_by_func
918 (
919 GTK_OBJECT(m_text),
920 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
921 (gpointer)this
922 );
923 }
924 }
925}
926
927void wxTextCtrl::SetSelection( long from, long to )
928{
929 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
930
931#ifndef __WXGTK20__
932 if ( (m_windowStyle & wxTE_MULTILINE) &&
933 !GTK_TEXT(m_text)->line_start_cache )
934 {
935 // tell the programmer that it didn't work
936 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
937 return;
938 }
939#endif
940
941 if (m_windowStyle & wxTE_MULTILINE)
942 {
943#ifdef __WXGTK20__
944 // ????
945#else
946 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
947#endif
948 }
949 else
950 {
951 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
952 }
953}
954
955void wxTextCtrl::ShowPosition( long pos )
956{
957#ifndef __WXGTK20__
958 if (m_windowStyle & wxTE_MULTILINE)
959 {
960 GtkAdjustment *vp = GTK_TEXT(m_text)->vadj;
961 float totalLines = (float) GetNumberOfLines();
962 long posX;
963 long posY;
964 PositionToXY(pos, &posX, &posY);
965 float posLine = (float) posY;
966 float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower;
967 gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p);
968 }
969#endif
970}
971
972long wxTextCtrl::GetInsertionPoint() const
973{
974 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
975
976#ifdef __WXGTK20__
977 if (m_windowStyle & wxTE_MULTILINE)
978 {
979 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
980
981 // There is no direct accessor for the cursor, but
982 // internally, the cursor is the "mark" called
983 // "insert" in the text view's btree structure.
984
985 GtkTextMark *mark = gtk_text_buffer_get_insert( text_buffer );
986 GtkTextIter cursor;
987 gtk_text_buffer_get_iter_at_mark( text_buffer, &cursor, mark );
988
989 return gtk_text_iter_get_offset( &cursor );
990 }
991 else
992#endif
993 {
994 return (long) GET_EDITABLE_POS(m_text);
995 }
996}
997
998long wxTextCtrl::GetLastPosition() const
999{
1000 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1001
1002 int pos = 0;
1003
1004 if (m_windowStyle & wxTE_MULTILINE)
1005 {
1006#ifdef __WXGTK20__
1007 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1008 GtkTextIter end;
1009 gtk_text_buffer_get_end_iter( text_buffer, &end );
1010
1011 pos = gtk_text_iter_get_offset( &end );
1012#else
1013 pos = gtk_text_get_length( GTK_TEXT(m_text) );
1014#endif
1015 }
1016 else
1017 {
1018 pos = GTK_ENTRY(m_text)->text_length;
1019 }
1020
1021 return (long)pos;
1022}
1023
1024void wxTextCtrl::Remove( long from, long to )
1025{
1026 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1027
1028#ifndef __WXGTK20__
1029 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1030#endif
1031}
1032
1033void wxTextCtrl::Replace( long from, long to, const wxString &value )
1034{
1035 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1036
1037#ifndef __WXGTK20__
1038 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1039
1040 if (!value.IsEmpty())
1041 {
1042 gint pos = (gint)from;
1043#if wxUSE_UNICODE
1044 wxWX2MBbuf buf = value.mbc_str();
1045 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
1046#else
1047 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
1048#endif
1049 }
1050#endif
1051}
1052
1053void wxTextCtrl::Cut()
1054{
1055 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1056
1057#ifndef __WXGTK20__
1058 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1059#endif
1060}
1061
1062void wxTextCtrl::Copy()
1063{
1064 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1065
1066#ifndef __WXGTK20__
1067 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1068#endif
1069}
1070
1071void wxTextCtrl::Paste()
1072{
1073 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1074
1075#ifndef __WXGTK20__
1076 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1077#endif
1078}
1079
1080// Undo/redo
1081void wxTextCtrl::Undo()
1082{
1083 // TODO
1084 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1085}
1086
1087void wxTextCtrl::Redo()
1088{
1089 // TODO
1090 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1091}
1092
1093bool wxTextCtrl::CanUndo() const
1094{
1095 // TODO
1096 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1097 return FALSE;
1098}
1099
1100bool wxTextCtrl::CanRedo() const
1101{
1102 // TODO
1103 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1104 return FALSE;
1105}
1106
1107// If the return values from and to are the same, there is no
1108// selection.
1109void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1110{
1111 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1112
1113 gint from, to;
1114#ifdef __WXGTK20__
1115 if ( !gtk_editable_get_selection_bounds(GTK_EDITABLE(m_text), &from, &to) )
1116#else
1117 if ( !(GTK_EDITABLE(m_text)->has_selection) )
1118#endif
1119 {
1120 from =
1121 to = GetInsertionPoint();
1122 }
1123 else // got selection
1124 {
1125#ifndef __WXGTK20__
1126 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1127 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1128#endif
1129
1130 if ( from > to )
1131 {
1132 // exchange them to be compatible with wxMSW
1133 gint tmp = from;
1134 from = to;
1135 to = tmp;
1136 }
1137 }
1138
1139 if ( fromOut )
1140 *fromOut = from;
1141 if ( toOut )
1142 *toOut = to;
1143}
1144
1145bool wxTextCtrl::IsEditable() const
1146{
1147 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1148
1149#ifdef __WXGTK20__
1150 return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1151#else
1152 return GTK_EDITABLE(m_text)->editable;
1153#endif
1154}
1155
1156bool wxTextCtrl::IsModified() const
1157{
1158 return m_modified;
1159}
1160
1161void wxTextCtrl::Clear()
1162{
1163 SetValue( wxT("") );
1164}
1165
1166void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1167{
1168 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1169
1170 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1171 {
1172 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1173 event.SetEventObject(this);
1174 event.SetString(GetValue());
1175 if (GetEventHandler()->ProcessEvent(event)) return;
1176 }
1177
1178 if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1179 {
1180 // This will invoke the dialog default action, such
1181 // as the clicking the default button.
1182
1183 wxWindow *top_frame = m_parent;
1184 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1185 top_frame = top_frame->GetParent();
1186
1187 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1188 {
1189 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1190
1191 if (window->default_widget)
1192 {
1193 gtk_widget_activate (window->default_widget);
1194 return;
1195 }
1196 }
1197 }
1198
1199 key_event.Skip();
1200}
1201
1202GtkWidget* wxTextCtrl::GetConnectWidget()
1203{
1204 return GTK_WIDGET(m_text);
1205}
1206
1207bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1208{
1209 if (m_windowStyle & wxTE_MULTILINE)
1210 {
1211#ifdef __WXGTK20__
1212 return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT ); // pure guesswork
1213#else
1214 return (window == GTK_TEXT(m_text)->text_area);
1215#endif
1216 }
1217 else
1218 {
1219 return (window == GTK_ENTRY(m_text)->text_area);
1220 }
1221}
1222
1223// the font will change for subsequent text insertiongs
1224bool wxTextCtrl::SetFont( const wxFont &font )
1225{
1226 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1227
1228 if ( !wxTextCtrlBase::SetFont(font) )
1229 {
1230 // font didn't change, nothing to do
1231 return FALSE;
1232 }
1233
1234 if ( m_windowStyle & wxTE_MULTILINE )
1235 {
1236 m_updateFont = TRUE;
1237
1238 m_defaultStyle.SetFont(font);
1239
1240 ChangeFontGlobally();
1241 }
1242
1243 return TRUE;
1244}
1245
1246void wxTextCtrl::ChangeFontGlobally()
1247{
1248 // this method is very inefficient and hence should be called as rarely as
1249 // possible!
1250 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1251 _T("shouldn't be called for single line controls") );
1252
1253 wxString value = GetValue();
1254 if ( !value.IsEmpty() )
1255 {
1256 m_updateFont = FALSE;
1257
1258 Clear();
1259 AppendText(value);
1260 }
1261}
1262
1263void wxTextCtrl::UpdateFontIfNeeded()
1264{
1265 if ( m_updateFont )
1266 ChangeFontGlobally();
1267}
1268
1269bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1270{
1271 if ( !wxControl::SetForegroundColour(colour) )
1272 return FALSE;
1273
1274 // update default fg colour too
1275 m_defaultStyle.SetTextColour(colour);
1276
1277 return TRUE;
1278}
1279
1280bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1281{
1282 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1283
1284 if ( !wxControl::SetBackgroundColour( colour ) )
1285 return FALSE;
1286
1287 if (!m_widget->window)
1288 return FALSE;
1289
1290 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1291 if (sysbg.Red() == colour.Red() &&
1292 sysbg.Green() == colour.Green() &&
1293 sysbg.Blue() == colour.Blue())
1294 {
1295 return FALSE; // FIXME or TRUE?
1296 }
1297
1298 if (!m_backgroundColour.Ok())
1299 return FALSE;
1300
1301 if (m_windowStyle & wxTE_MULTILINE)
1302 {
1303#ifndef __WXGTK__
1304 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1305 if (!window)
1306 return FALSE;
1307 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1308 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1309 gdk_window_clear( window );
1310#endif
1311 }
1312
1313 // change active background color too
1314 m_defaultStyle.SetBackgroundColour( colour );
1315
1316 return TRUE;
1317}
1318
1319bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1320{
1321 /* VERY dirty way to do that - removes the required text and re-adds it
1322 with styling (FIXME) */
1323 if ( m_windowStyle & wxTE_MULTILINE )
1324 {
1325#ifndef __WXGTK20__
1326 if ( style.IsDefault() )
1327 {
1328 // nothing to do
1329 return TRUE;
1330 }
1331
1332 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1333
1334 wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1335 _T("invalid range in wxTextCtrl::SetStyle") );
1336
1337 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1338 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1339 wxString tmp(text,*wxConvCurrent);
1340 g_free( text );
1341
1342 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1343 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1344
1345#if wxUSE_UNICODE
1346 wxWX2MBbuf buf = tmp.mbc_str();
1347 const char *txt = buf;
1348 size_t txtlen = strlen(buf);
1349#else
1350 const char *txt = tmp;
1351 size_t txtlen = tmp.length();
1352#endif
1353
1354 // use the attributes from style which are set in it and fall back
1355 // first to the default style and then to the text control default
1356 // colours for the others
1357 wxGtkTextInsert(m_text,
1358 wxTextAttr::Combine(style, m_defaultStyle, this),
1359 txt,
1360 txtlen);
1361
1362 /* does not seem to help under GTK+ 1.2 !!!
1363 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1364 SetInsertionPoint( old_pos );
1365#endif
1366 return TRUE;
1367 }
1368 else // singe line
1369 {
1370 // cannot do this for GTK+'s Entry widget
1371 return FALSE;
1372 }
1373}
1374
1375void wxTextCtrl::ApplyWidgetStyle()
1376{
1377 if (m_windowStyle & wxTE_MULTILINE)
1378 {
1379 // how ?
1380 }
1381 else
1382 {
1383 SetWidgetStyle();
1384 gtk_widget_set_style( m_text, m_widgetStyle );
1385 }
1386}
1387
1388void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1389{
1390 Cut();
1391}
1392
1393void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1394{
1395 Copy();
1396}
1397
1398void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1399{
1400 Paste();
1401}
1402
1403void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1404{
1405 Undo();
1406}
1407
1408void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1409{
1410 Redo();
1411}
1412
1413void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1414{
1415 event.Enable( CanCut() );
1416}
1417
1418void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1419{
1420 event.Enable( CanCopy() );
1421}
1422
1423void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1424{
1425 event.Enable( CanPaste() );
1426}
1427
1428void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1429{
1430 event.Enable( CanUndo() );
1431}
1432
1433void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1434{
1435 event.Enable( CanRedo() );
1436}
1437
1438void wxTextCtrl::OnInternalIdle()
1439{
1440 wxCursor cursor = m_cursor;
1441 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1442
1443 if (cursor.Ok())
1444 {
1445#ifndef __WXGTK20__
1446 GdkWindow *window = (GdkWindow*) NULL;
1447 if (HasFlag(wxTE_MULTILINE))
1448 window = GTK_TEXT(m_text)->text_area;
1449 else
1450 window = GTK_ENTRY(m_text)->text_area;
1451
1452 if (window)
1453 gdk_window_set_cursor( window, cursor.GetCursor() );
1454
1455 if (!g_globalCursor.Ok())
1456 cursor = *wxSTANDARD_CURSOR;
1457
1458 window = m_widget->window;
1459 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1460 gdk_window_set_cursor( window, cursor.GetCursor() );
1461#endif
1462 }
1463
1464 if (g_delayedFocus == this)
1465 {
1466 if (GTK_WIDGET_REALIZED(m_widget))
1467 {
1468 gtk_widget_grab_focus( m_widget );
1469 g_delayedFocus = NULL;
1470 }
1471 }
1472
1473 UpdateWindowUI();
1474}
1475
1476wxSize wxTextCtrl::DoGetBestSize() const
1477{
1478 // FIXME should be different for multi-line controls...
1479 wxSize ret( wxControl::DoGetBestSize() );
1480 return wxSize(80, ret.y);
1481}
1482
1483// ----------------------------------------------------------------------------
1484// freeze/thaw
1485// ----------------------------------------------------------------------------
1486
1487void wxTextCtrl::Freeze()
1488{
1489#ifndef __WXGTK20__
1490 if ( HasFlag(wxTE_MULTILINE) )
1491 {
1492 gtk_text_freeze(GTK_TEXT(m_text));
1493 }
1494#endif
1495}
1496
1497void wxTextCtrl::Thaw()
1498{
1499#ifndef __WXGTK20__
1500 if ( HasFlag(wxTE_MULTILINE) )
1501 {
1502 GTK_TEXT(m_text)->vadj->value = 0.0;
1503
1504 gtk_text_thaw(GTK_TEXT(m_text));
1505 }
1506#endif
1507}
1508
1509// ----------------------------------------------------------------------------
1510// scrolling
1511// ----------------------------------------------------------------------------
1512
1513GtkAdjustment *wxTextCtrl::GetVAdj() const
1514{
1515#ifdef __WXGTK20__
1516 return NULL;
1517#else
1518 return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1519#endif
1520}
1521
1522bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1523{
1524#ifndef __WXGTK20__
1525 float value = adj->value + diff;
1526
1527 if ( value < 0 )
1528 value = 0;
1529
1530 float upper = adj->upper - adj->page_size;
1531 if ( value > upper )
1532 value = upper;
1533
1534 // did we noticeably change the scroll position?
1535 if ( fabs(adj->value - value) < 0.2 )
1536 {
1537 // well, this is what Robert does in wxScrollBar, so it must be good...
1538 return FALSE;
1539 }
1540
1541 adj->value = value;
1542
1543 gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1544
1545#endif
1546 return TRUE;
1547}
1548
1549bool wxTextCtrl::ScrollLines(int lines)
1550{
1551#ifdef __WXGTK20__
1552 return FALSE;
1553#else
1554 GtkAdjustment *adj = GetVAdj();
1555 if ( !adj )
1556 return FALSE;
1557
1558 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1559 static const int KEY_SCROLL_PIXELS = 10;
1560
1561 return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1562#endif
1563}
1564
1565bool wxTextCtrl::ScrollPages(int pages)
1566{
1567#ifdef __WXGTK20__
1568 return FALSE;
1569#else
1570 GtkAdjustment *adj = GetVAdj();
1571 if ( !adj )
1572 return FALSE;
1573
1574 return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1575#endif
1576}
1577
wxWidgets (Impactor)