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