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