]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/textctrl.cpp
projects / wxWidgets.git / blob
? search:


b87712e0c1d1a52f1b969da1f973d7065e69d6e4
[wxWidgets.git] / src / gtk1 / textctrl.cpp
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
35 extern void wxapp_install_idle_handler();
36 extern bool g_isIdle;
37
38 //-----------------------------------------------------------------------------
39 // data
40 //-----------------------------------------------------------------------------
41
42 extern bool g_blockEventsOnDrag;
43 extern wxCursor g_globalCursor;
44 extern wxWindowGTK *g_delayedFocus;
45
46 // ----------------------------------------------------------------------------
47 // helpers
48 // ----------------------------------------------------------------------------
49
50 #ifdef __WXGTK20__
51 static 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
92 static 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
115 static void
116 gtk_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
155 static void
156 gtk_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__
180 static void
181 gtk_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
203 extern bool wxIsInsideYield;
204
205 extern "C" {
206 typedef void (*GtkDrawCallback)(GtkWidget *widget, GdkRectangle *rect);
207 }
208
209 static GtkDrawCallback gs_gtk_text_draw = NULL;
210
211 extern "C"
212 void 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
229 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
230
231 BEGIN_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)
245 END_EVENT_TABLE()
246
247 void wxTextCtrl::Init()
248 {
249 m_ignoreNextUpdate =
250 m_modified = FALSE;
251 m_updateFont = FALSE;
252 m_text =
253 m_vScrollbar = (GtkWidget *)NULL;
254 }
255
256 wxTextCtrl::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
270 bool 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
477 void 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
503 wxString 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
542 void 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
578 void 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
645 void wxTextCtrl::AppendText( const wxString &text )
646 {
647 SetInsertionPointEnd();
648 WriteText( text );
649 }
650
651 wxString 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
688 void 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
695 bool 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
737 long 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
748 int wxTextCtrl::GetLineLength(long lineNo) const
749 {
750 wxString str = GetLineText (lineNo);
751 return (int) str.Length();
752 }
753
754 int 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
791 void 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
830 void 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
851 void 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
869 bool 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
897 void 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
914 void wxTextCtrl::DiscardEdits()
915 {
916 m_modified = FALSE;
917 }
918
919 // ----------------------------------------------------------------------------
920 // max text length support
921 // ----------------------------------------------------------------------------
922
923 void wxTextCtrl::IgnoreNextTextUpdate()
924 {
925 m_ignoreNextUpdate = TRUE;
926 }
927
928 bool wxTextCtrl::IgnoreTextUpdate()
929 {
930 if ( m_ignoreNextUpdate )
931 {
932 m_ignoreNextUpdate = FALSE;
933
934 return TRUE;
935 }
936
937 return FALSE;
938 }
939
940 void 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
974 void 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
1015 void 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
1032 long 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
1058 long 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
1084 void 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
1105 void 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
1128 void 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
1137 void 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
1146 void 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
1156 void wxTextCtrl::Undo()
1157 {
1158 // TODO
1159 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1160 }
1161
1162 void wxTextCtrl::Redo()
1163 {
1164 // TODO
1165 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1166 }
1167
1168 bool wxTextCtrl::CanUndo() const
1169 {
1170 // TODO
1171 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1172 return FALSE;
1173 }
1174
1175 bool 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.
1184 void 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 GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text));
1191 GtkTextIter ifrom, ito;
1192 if (!gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito))
1193 #else
1194 if ( !(GTK_EDITABLE(m_text)->has_selection) )
1195 #endif
1196 {
1197 from =
1198 to = GetInsertionPoint();
1199 }
1200 else // got selection
1201 {
1202 #ifdef __WXGTK20__
1203 from = gtk_text_iter_get_offset(&ifrom);
1204 to = gtk_text_iter_get_offset(&ito);
1205 #else
1206 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1207 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1208 #endif
1209
1210 if ( from > to )
1211 {
1212 // exchange them to be compatible with wxMSW
1213 gint tmp = from;
1214 from = to;
1215 to = tmp;
1216 }
1217 }
1218
1219 if ( fromOut )
1220 *fromOut = from;
1221 if ( toOut )
1222 *toOut = to;
1223 }
1224
1225 bool wxTextCtrl::IsEditable() const
1226 {
1227 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1228
1229 #ifdef __WXGTK20__
1230 if (m_windowStyle & wxTE_MULTILINE)
1231 {
1232 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1233 }
1234 else
1235 {
1236 return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1237 }
1238 #else
1239 return GTK_EDITABLE(m_text)->editable;
1240 #endif
1241 }
1242
1243 bool wxTextCtrl::IsModified() const
1244 {
1245 return m_modified;
1246 }
1247
1248 void wxTextCtrl::Clear()
1249 {
1250 SetValue( wxT("") );
1251 }
1252
1253 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1254 {
1255 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1256
1257 if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1258 {
1259 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1260 event.SetEventObject(this);
1261 event.SetString(GetValue());
1262 if (GetEventHandler()->ProcessEvent(event)) return;
1263 }
1264
1265 if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1266 {
1267 // This will invoke the dialog default action, such
1268 // as the clicking the default button.
1269
1270 wxWindow *top_frame = m_parent;
1271 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1272 top_frame = top_frame->GetParent();
1273
1274 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1275 {
1276 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1277
1278 if (window->default_widget)
1279 {
1280 gtk_widget_activate (window->default_widget);
1281 return;
1282 }
1283 }
1284 }
1285
1286 key_event.Skip();
1287 }
1288
1289 GtkWidget* wxTextCtrl::GetConnectWidget()
1290 {
1291 return GTK_WIDGET(m_text);
1292 }
1293
1294 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1295 {
1296 if (m_windowStyle & wxTE_MULTILINE)
1297 {
1298 #ifdef __WXGTK20__
1299 return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT ); // pure guesswork
1300 #else
1301 return (window == GTK_TEXT(m_text)->text_area);
1302 #endif
1303 }
1304 else
1305 {
1306 return (window == GTK_ENTRY(m_text)->text_area);
1307 }
1308 }
1309
1310 // the font will change for subsequent text insertiongs
1311 bool wxTextCtrl::SetFont( const wxFont &font )
1312 {
1313 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1314
1315 if ( !wxTextCtrlBase::SetFont(font) )
1316 {
1317 // font didn't change, nothing to do
1318 return FALSE;
1319 }
1320
1321 if ( m_windowStyle & wxTE_MULTILINE )
1322 {
1323 m_updateFont = TRUE;
1324
1325 m_defaultStyle.SetFont(font);
1326
1327 ChangeFontGlobally();
1328 }
1329
1330 return TRUE;
1331 }
1332
1333 void wxTextCtrl::ChangeFontGlobally()
1334 {
1335 // this method is very inefficient and hence should be called as rarely as
1336 // possible!
1337 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1338 _T("shouldn't be called for single line controls") );
1339
1340 wxString value = GetValue();
1341 if ( !value.IsEmpty() )
1342 {
1343 m_updateFont = FALSE;
1344
1345 Clear();
1346 AppendText(value);
1347 }
1348 }
1349
1350 void wxTextCtrl::UpdateFontIfNeeded()
1351 {
1352 if ( m_updateFont )
1353 ChangeFontGlobally();
1354 }
1355
1356 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1357 {
1358 if ( !wxControl::SetForegroundColour(colour) )
1359 return FALSE;
1360
1361 // update default fg colour too
1362 m_defaultStyle.SetTextColour(colour);
1363
1364 return TRUE;
1365 }
1366
1367 bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1368 {
1369 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1370
1371 if ( !wxControl::SetBackgroundColour( colour ) )
1372 return FALSE;
1373
1374 if (!m_widget->window)
1375 return FALSE;
1376
1377 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1378 if (sysbg.Red() == colour.Red() &&
1379 sysbg.Green() == colour.Green() &&
1380 sysbg.Blue() == colour.Blue())
1381 {
1382 return FALSE; // FIXME or TRUE?
1383 }
1384
1385 if (!m_backgroundColour.Ok())
1386 return FALSE;
1387
1388 if (m_windowStyle & wxTE_MULTILINE)
1389 {
1390 #ifndef __WXGTK20__
1391 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1392 if (!window)
1393 return FALSE;
1394 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1395 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1396 gdk_window_clear( window );
1397 #endif
1398 }
1399
1400 // change active background color too
1401 m_defaultStyle.SetBackgroundColour( colour );
1402
1403 return TRUE;
1404 }
1405
1406 bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1407 {
1408 if ( m_windowStyle & wxTE_MULTILINE )
1409 {
1410 if ( style.IsDefault() )
1411 {
1412 // nothing to do
1413 return TRUE;
1414 }
1415 #ifdef __WXGTK20__
1416 GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1417 gint l = gtk_text_buffer_get_char_count( text_buffer );
1418
1419 wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1420 _T("invalid range in wxTextCtrl::SetStyle") );
1421
1422 GtkTextIter starti, endi;
1423 gtk_text_buffer_get_iter_at_offset( text_buffer, &starti, start );
1424 gtk_text_buffer_get_iter_at_offset( text_buffer, &endi, end );
1425
1426 // use the attributes from style which are set in it and fall back
1427 // first to the default style and then to the text control default
1428 // colours for the others
1429 wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1430
1431 PangoFontDescription *font_description = attr.HasFont()
1432 ? attr.GetFont().GetNativeFontInfo()->description
1433 : NULL;
1434
1435 GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
1436 : NULL;
1437
1438 GdkColor *colBg = attr.HasBackgroundColour()
1439 ? attr.GetBackgroundColour().GetColor()
1440 : NULL;
1441
1442 GtkTextTag *tag;
1443 tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description,
1444 "foreground-gdk", colFg,
1445 "background-gdk", colBg, NULL );
1446 gtk_text_buffer_apply_tag( text_buffer, tag, &starti, &endi );
1447
1448 return TRUE;
1449 #else
1450 // VERY dirty way to do that - removes the required text and re-adds it
1451 // with styling (FIXME)
1452
1453 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1454
1455 wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1456 _T("invalid range in wxTextCtrl::SetStyle") );
1457
1458 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1459 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1460 wxString tmp(text,*wxConvCurrent);
1461 g_free( text );
1462
1463 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1464 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1465
1466 #if wxUSE_UNICODE
1467 wxWX2MBbuf buf = tmp.mbc_str();
1468 const char *txt = buf;
1469 size_t txtlen = strlen(buf);
1470 #else
1471 const char *txt = tmp;
1472 size_t txtlen = tmp.length();
1473 #endif
1474
1475 // use the attributes from style which are set in it and fall back
1476 // first to the default style and then to the text control default
1477 // colours for the others
1478 wxGtkTextInsert(m_text,
1479 wxTextAttr::Combine(style, m_defaultStyle, this),
1480 txt,
1481 txtlen);
1482
1483 /* does not seem to help under GTK+ 1.2 !!!
1484 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1485 SetInsertionPoint( old_pos );
1486 #endif
1487 return TRUE;
1488 }
1489 else // singe line
1490 {
1491 // cannot do this for GTK+'s Entry widget
1492 return FALSE;
1493 }
1494 }
1495
1496 void wxTextCtrl::ApplyWidgetStyle()
1497 {
1498 if (m_windowStyle & wxTE_MULTILINE)
1499 {
1500 // how ?
1501 }
1502 else
1503 {
1504 SetWidgetStyle();
1505 gtk_widget_set_style( m_text, m_widgetStyle );
1506 }
1507 }
1508
1509 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1510 {
1511 Cut();
1512 }
1513
1514 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1515 {
1516 Copy();
1517 }
1518
1519 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1520 {
1521 Paste();
1522 }
1523
1524 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1525 {
1526 Undo();
1527 }
1528
1529 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1530 {
1531 Redo();
1532 }
1533
1534 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1535 {
1536 event.Enable( CanCut() );
1537 }
1538
1539 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1540 {
1541 event.Enable( CanCopy() );
1542 }
1543
1544 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1545 {
1546 event.Enable( CanPaste() );
1547 }
1548
1549 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1550 {
1551 event.Enable( CanUndo() );
1552 }
1553
1554 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1555 {
1556 event.Enable( CanRedo() );
1557 }
1558
1559 void wxTextCtrl::OnInternalIdle()
1560 {
1561 wxCursor cursor = m_cursor;
1562 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1563
1564 if (cursor.Ok())
1565 {
1566 #ifndef __WXGTK20__
1567 GdkWindow *window = (GdkWindow*) NULL;
1568 if (HasFlag(wxTE_MULTILINE))
1569 window = GTK_TEXT(m_text)->text_area;
1570 else
1571 window = GTK_ENTRY(m_text)->text_area;
1572
1573 if (window)
1574 gdk_window_set_cursor( window, cursor.GetCursor() );
1575
1576 if (!g_globalCursor.Ok())
1577 cursor = *wxSTANDARD_CURSOR;
1578
1579 window = m_widget->window;
1580 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1581 gdk_window_set_cursor( window, cursor.GetCursor() );
1582 #endif
1583 }
1584
1585 if (g_delayedFocus == this)
1586 {
1587 if (GTK_WIDGET_REALIZED(m_widget))
1588 {
1589 gtk_widget_grab_focus( m_widget );
1590 g_delayedFocus = NULL;
1591 }
1592 }
1593
1594 if (wxUpdateUIEvent::CanUpdate())
1595 UpdateWindowUI();
1596 }
1597
1598 wxSize wxTextCtrl::DoGetBestSize() const
1599 {
1600 // FIXME should be different for multi-line controls...
1601 wxSize ret( wxControl::DoGetBestSize() );
1602 return wxSize(80, ret.y);
1603 }
1604
1605 // ----------------------------------------------------------------------------
1606 // freeze/thaw
1607 // ----------------------------------------------------------------------------
1608
1609 void wxTextCtrl::Freeze()
1610 {
1611 #ifndef __WXGTK20__
1612 if ( HasFlag(wxTE_MULTILINE) )
1613 {
1614 gtk_text_freeze(GTK_TEXT(m_text));
1615 }
1616 #endif
1617 }
1618
1619 void wxTextCtrl::Thaw()
1620 {
1621 #ifndef __WXGTK20__
1622 if ( HasFlag(wxTE_MULTILINE) )
1623 {
1624 GTK_TEXT(m_text)->vadj->value = 0.0;
1625
1626 gtk_text_thaw(GTK_TEXT(m_text));
1627 }
1628 #endif
1629 }
1630
1631 // ----------------------------------------------------------------------------
1632 // scrolling
1633 // ----------------------------------------------------------------------------
1634
1635 GtkAdjustment *wxTextCtrl::GetVAdj() const
1636 {
1637 #ifdef __WXGTK20__
1638 return NULL;
1639 #else
1640 return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1641 #endif
1642 }
1643
1644 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1645 {
1646 #ifndef __WXGTK20__
1647 float value = adj->value + diff;
1648
1649 if ( value < 0 )
1650 value = 0;
1651
1652 float upper = adj->upper - adj->page_size;
1653 if ( value > upper )
1654 value = upper;
1655
1656 // did we noticeably change the scroll position?
1657 if ( fabs(adj->value - value) < 0.2 )
1658 {
1659 // well, this is what Robert does in wxScrollBar, so it must be good...
1660 return FALSE;
1661 }
1662
1663 adj->value = value;
1664
1665 gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1666
1667 #endif
1668 return TRUE;
1669 }
1670
1671 bool wxTextCtrl::ScrollLines(int lines)
1672 {
1673 #ifdef __WXGTK20__
1674 return FALSE;
1675 #else
1676 GtkAdjustment *adj = GetVAdj();
1677 if ( !adj )
1678 return FALSE;
1679
1680 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1681 static const int KEY_SCROLL_PIXELS = 10;
1682
1683 return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1684 #endif
1685 }
1686
1687 bool wxTextCtrl::ScrollPages(int pages)
1688 {
1689 #ifdef __WXGTK20__
1690 return FALSE;
1691 #else
1692 GtkAdjustment *adj = GetVAdj();
1693 if ( !adj )
1694 return FALSE;
1695
1696 return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1697 #endif
1698 }
1699
wxWidgets (Impactor)