added virtual listctrl support
[wxWidgets.git] / src / gtk1 / textctrl.cpp
CommitLineData
c801d85f
KB
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
f96aa4d9 5// Id: $Id$
a81258be 6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
13289f04 7// Licence: wxWindows licence
c801d85f
KB
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11#pragma implementation "textctrl.h"
12#endif
13
14#include "wx/textctrl.h"
15#include "wx/utils.h"
ae0bdb01 16#include "wx/intl.h"
a1f79c1e 17#include "wx/log.h"
ae0bdb01 18#include "wx/settings.h"
fc71ef6e 19#include "wx/panel.h"
c801d85f 20
a81258be
RR
21#include <sys/types.h>
22#include <sys/stat.h>
23#include <ctype.h>
24
83624f79
RR
25#include "gdk/gdk.h"
26#include "gtk/gtk.h"
b292e2f5
RR
27#include "gdk/gdkkeysyms.h"
28
acfd422a
RR
29//-----------------------------------------------------------------------------
30// idle system
31//-----------------------------------------------------------------------------
32
33extern void wxapp_install_idle_handler();
34extern bool g_isIdle;
35
b292e2f5
RR
36//-----------------------------------------------------------------------------
37// data
38//-----------------------------------------------------------------------------
39
65045edd
RR
40extern bool g_blockEventsOnDrag;
41extern wxCursor g_globalCursor;
b292e2f5 42
c801d85f 43//-----------------------------------------------------------------------------
2f2aa628 44// "changed"
c801d85f
KB
45//-----------------------------------------------------------------------------
46
805dd538 47static void
2830bf19 48gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
484e45bf 49{
a2053b27 50 if (!win->m_hasVMT) return;
805dd538 51
bb69661b 52 if (g_isIdle)
3c679789
RR
53 wxapp_install_idle_handler();
54
034be888 55 win->SetModified();
01041145 56 win->UpdateFontIfNeeded();
8bbe427f 57
f03fc89f 58 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
8a85884a 59 event.SetString( win->GetValue() );
2830bf19
RR
60 event.SetEventObject( win );
61 win->GetEventHandler()->ProcessEvent( event );
6de97a3b 62}
112892b9 63
2830bf19 64//-----------------------------------------------------------------------------
034be888 65// "changed" from vertical scrollbar
2830bf19
RR
66//-----------------------------------------------------------------------------
67
805dd538 68static void
034be888 69gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
2830bf19 70{
3c679789 71 if (!win->m_hasVMT) return;
bb69661b
VZ
72
73 if (g_isIdle)
3c679789 74 wxapp_install_idle_handler();
acfd422a 75
2830bf19
RR
76 win->CalculateScrollbar();
77}
78
fc71ef6e
JS
79//-----------------------------------------------------------------------------
80// "focus_in_event"
81//-----------------------------------------------------------------------------
82
fc71ef6e
JS
83extern wxWindow *g_focusWindow;
84extern bool g_blockEventsOnDrag;
85// extern bool g_isIdle;
86
87static gint gtk_text_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
88{
89 // Necessary?
90#if 0
91 if (g_isIdle)
92 wxapp_install_idle_handler();
93#endif
94 if (!win->m_hasVMT) return FALSE;
95 if (g_blockEventsOnDrag) return FALSE;
96
97 g_focusWindow = win;
98
99 wxPanel *panel = wxDynamicCast(win->GetParent(), wxPanel);
100 if (panel)
101 {
102 panel->SetLastFocus(win);
103 }
104
105#ifdef HAVE_XIM
106 if (win->m_ic)
107 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
108#endif
109
110#if 0
111#ifdef wxUSE_CARET
112 // caret needs to be informed about focus change
113 wxCaret *caret = win->GetCaret();
114 if ( caret )
115 {
116 caret->OnSetFocus();
117 }
118#endif // wxUSE_CARET
119#endif
120
121 wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
122 event.SetEventObject( win );
123
124 if (win->GetEventHandler()->ProcessEvent( event ))
125 {
126 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
127 return TRUE;
128 }
129
130 return FALSE;
131}
132
133//-----------------------------------------------------------------------------
134// "focus_out_event"
135//-----------------------------------------------------------------------------
136
137static gint gtk_text_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
138{
139#if 0
140 if (g_isIdle)
141 wxapp_install_idle_handler();
142#endif
143
144 if (!win->m_hasVMT) return FALSE;
145 if (g_blockEventsOnDrag) return FALSE;
146
147#if 0
148 // if the focus goes out of our app alltogether, OnIdle() will send
149 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
150 // g_sendActivateEvent to -1
151 g_sendActivateEvent = 0;
152#endif
153
3379ed37 154 wxWindow *winFocus = wxFindFocusedChild(win);
fc71ef6e
JS
155 if ( winFocus )
156 win = winFocus;
157
158 g_focusWindow = (wxWindow *)NULL;
159
160#ifdef HAVE_XIM
161 if (win->m_ic)
162 gdk_im_end();
163#endif
164
165#if 0
166#ifdef wxUSE_CARET
167 // caret needs to be informed about focus change
168 wxCaret *caret = win->GetCaret();
169 if ( caret )
170 {
171 caret->OnKillFocus();
172 }
173#endif // wxUSE_CARET
174#endif
175
176 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
177 event.SetEventObject( win );
178
179 if (win->GetEventHandler()->ProcessEvent( event ))
180 {
181 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
182 return TRUE;
183 }
184
185 return FALSE;
186}
187
2f2aa628
RR
188//-----------------------------------------------------------------------------
189// wxTextCtrl
190//-----------------------------------------------------------------------------
191
192IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
193
c801d85f 194BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
2830bf19 195 EVT_CHAR(wxTextCtrl::OnChar)
e702ff0f
JS
196
197 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
198 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
199 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
200 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
201 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
202
203 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
204 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
205 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
206 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
207 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
c801d85f
KB
208END_EVENT_TABLE()
209
01041145 210void wxTextCtrl::Init()
f5abe911
RR
211{
212 m_modified = FALSE;
01041145 213 m_updateFont = FALSE;
3ca6a5f0
BP
214 m_text =
215 m_vScrollbar = (GtkWidget *)NULL;
f5abe911 216}
13289f04 217
13111b2a
VZ
218wxTextCtrl::wxTextCtrl( wxWindow *parent,
219 wxWindowID id,
220 const wxString &value,
221 const wxPoint &pos,
222 const wxSize &size,
223 long style,
224 const wxValidator& validator,
225 const wxString &name )
f5abe911 226{
01041145
VZ
227 Init();
228
f5abe911
RR
229 Create( parent, id, value, pos, size, style, validator, name );
230}
c801d85f 231
13111b2a
VZ
232bool wxTextCtrl::Create( wxWindow *parent,
233 wxWindowID id,
234 const wxString &value,
235 const wxPoint &pos,
236 const wxSize &size,
237 long style,
238 const wxValidator& validator,
239 const wxString &name )
c801d85f 240{
2830bf19 241 m_needParent = TRUE;
b292e2f5 242 m_acceptsFocus = TRUE;
484e45bf 243
4dcaf11a
RR
244 if (!PreCreation( parent, pos, size ) ||
245 !CreateBase( parent, id, pos, size, style, validator, name ))
246 {
223d09f6 247 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
13111b2a 248 return FALSE;
4dcaf11a 249 }
6de97a3b 250
805dd538 251
034be888 252 m_vScrollbarVisible = FALSE;
13289f04 253
2830bf19 254 bool multi_line = (style & wxTE_MULTILINE) != 0;
ab46dc18 255 if (multi_line)
2830bf19 256 {
7d6d2cd4 257#if (GTK_MINOR_VERSION > 2)
034be888
RR
258 /* a multi-line edit control: create a vertical scrollbar by default and
259 horizontal if requested */
2830bf19 260 bool bHasHScrollbar = (style & wxHSCROLL) != 0;
7d6d2cd4
RR
261#else
262 bool bHasHScrollbar = FALSE;
263#endif
805dd538 264
034be888 265 /* create our control ... */
2830bf19
RR
266 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
267
034be888 268 /* ... and put into the upper left hand corner of the table */
2830bf19 269 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
5664fc32 270 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2830bf19 271 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
41dee9d0 272 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
f5368809
RR
273 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
274 0, 0);
bb69661b 275
5c387335
RR
276 /* always wrap words */
277 gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
bb69661b 278
7d6d2cd4 279#if (GTK_MINOR_VERSION > 2)
034be888 280 /* put the horizontal scrollbar in the lower left hand corner */
2830bf19
RR
281 if (bHasHScrollbar)
282 {
283 GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
5664fc32 284 GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
2830bf19 285 gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
8ce63e9d 286 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
13289f04
VZ
287 GTK_FILL,
288 0, 0);
2830bf19 289 gtk_widget_show(hscrollbar);
13289f04 290
3358d36e
VZ
291 /* don't wrap lines, otherwise we wouldn't need the scrollbar */
292 gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
5c387335 293 }
7d6d2cd4 294#endif
bb69661b 295
ab46dc18
RR
296 /* finally, put the vertical scrollbar in the upper right corner */
297 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
298 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
ab46dc18
RR
299 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
300 GTK_FILL,
301 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
302 0, 0);
2830bf19
RR
303 }
304 else
305 {
034be888 306 /* a single-line text control: no need for scrollbars */
2830bf19
RR
307 m_widget =
308 m_text = gtk_entry_new();
309 }
484e45bf 310
db434467
RR
311 m_parent->DoAddChild( this );
312
313 PostCreation();
314
315 SetFont( parent->GetFont() );
316
317 wxSize size_best( DoGetBestSize() );
318 wxSize new_size( size );
0279e844 319 if (new_size.x == -1)
db434467 320 new_size.x = size_best.x;
0279e844 321 if (new_size.y == -1)
db434467 322 new_size.y = size_best.y;
0279e844
RR
323 if ((new_size.x != size.x) || (new_size.y != size.y))
324 SetSize( new_size.x, new_size.y );
484e45bf 325
2830bf19 326 if (multi_line)
2830bf19 327 gtk_widget_show(m_text);
13289f04 328
ab46dc18
RR
329 if (multi_line)
330 {
331 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
332 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
fc71ef6e
JS
333
334 gtk_signal_connect( GTK_OBJECT(GTK_TEXT(m_text)), "focus_in_event",
335 GTK_SIGNAL_FUNC(gtk_text_focus_in_callback), (gpointer)this );
336
337 gtk_signal_connect( GTK_OBJECT(GTK_TEXT(m_text)), "focus_out_event",
338 GTK_SIGNAL_FUNC(gtk_text_focus_out_callback), (gpointer)this );
339 }
340 else
341 {
342 gtk_signal_connect( GTK_OBJECT(m_text), "focus_in_event",
343 GTK_SIGNAL_FUNC(gtk_text_focus_in_callback), (gpointer)this );
344
345 gtk_signal_connect( GTK_OBJECT(m_text), "focus_out_event",
346 GTK_SIGNAL_FUNC(gtk_text_focus_out_callback), (gpointer)this );
ab46dc18 347 }
3358d36e 348
291a8f20 349 if (!value.IsEmpty())
2830bf19
RR
350 {
351 gint tmp = 0;
3358d36e
VZ
352
353#if GTK_MINOR_VERSION == 0
354 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
355 // gtk_editable_insert_text()
356 gtk_widget_realize(m_text);
357#endif // GTK 1.0
358
05939a81 359#if wxUSE_UNICODE
3358d36e 360 wxWX2MBbuf val = value.mbc_str();
05939a81 361 gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
3358d36e 362#else // !Unicode
2830bf19 363 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
3358d36e
VZ
364#endif // Unicode/!Unicode
365
291a8f20
RR
366 if (multi_line)
367 {
3358d36e
VZ
368 /* bring editable's cursor uptodate. bug in GTK. */
369
370 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
371 }
2830bf19 372 }
484e45bf 373
2830bf19
RR
374 if (style & wxTE_PASSWORD)
375 {
376 if (!multi_line)
377 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
378 }
8bbe427f 379
2830bf19
RR
380 if (style & wxTE_READONLY)
381 {
382 if (!multi_line)
383 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
384 }
385 else
386 {
387 if (multi_line)
388 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
389 }
3358d36e 390
ce16e5d7
RR
391 /* we want to be notified about text changes */
392 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
393 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
394
a88acabd
JS
395 /* we don't set a valid background colour, because the window
396 manager should use a default one */
397 m_backgroundColour = wxColour();
17665a2b
VZ
398
399 wxColour colFg = parent->GetForegroundColour();
400 SetForegroundColour( colFg );
805dd538 401
65045edd 402 m_cursor = wxCursor( wxCURSOR_IBEAM );
13111b2a 403
17665a2b
VZ
404 // FIXME: is the bg colour correct here?
405 wxTextAttr attrDef( colFg,
406 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW),
407 parent->GetFont() );
408 SetDefaultStyle( attrDef );
409
2830bf19 410 Show( TRUE );
805dd538 411
2830bf19
RR
412 return TRUE;
413}
484e45bf 414
2830bf19
RR
415void wxTextCtrl::CalculateScrollbar()
416{
417 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
f96aa4d9 418
2830bf19 419 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
805dd538 420
2830bf19
RR
421 if (adj->upper - adj->page_size < 0.8)
422 {
423 if (m_vScrollbarVisible)
424 {
034be888 425 gtk_widget_hide( m_vScrollbar );
034be888 426 m_vScrollbarVisible = FALSE;
2830bf19
RR
427 }
428 }
429 else
430 {
431 if (!m_vScrollbarVisible)
432 {
034be888 433 gtk_widget_show( m_vScrollbar );
034be888 434 m_vScrollbarVisible = TRUE;
2830bf19
RR
435 }
436 }
6de97a3b 437}
c801d85f 438
03f38c58 439wxString wxTextCtrl::GetValue() const
c801d85f 440{
223d09f6 441 wxCHECK_MSG( m_text != NULL, wxT(""), wxT("invalid text ctrl") );
8bbe427f 442
2830bf19
RR
443 wxString tmp;
444 if (m_windowStyle & wxTE_MULTILINE)
445 {
446 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
447 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
dcf924a3 448 tmp = wxString(text,*wxConvCurrent);
2830bf19
RR
449 g_free( text );
450 }
451 else
452 {
dcf924a3 453 tmp = wxString(gtk_entry_get_text( GTK_ENTRY(m_text) ),*wxConvCurrent);
2830bf19
RR
454 }
455 return tmp;
6de97a3b 456}
c801d85f
KB
457
458void wxTextCtrl::SetValue( const wxString &value )
459{
223d09f6 460 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 461
2830bf19
RR
462 if (m_windowStyle & wxTE_MULTILINE)
463 {
464 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
465 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
466 len = 0;
05939a81 467#if wxUSE_UNICODE
01041145 468 wxWX2MBbuf tmpbuf = value.mbc_str();
05939a81
OK
469 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmpbuf, strlen(tmpbuf), &len );
470#else
01041145 471 gtk_editable_insert_text( GTK_EDITABLE(m_text), value.mbc_str(), value.Length(), &len );
05939a81 472#endif
2830bf19
RR
473 }
474 else
475 {
01041145 476 gtk_entry_set_text( GTK_ENTRY(m_text), value.mbc_str() );
2830bf19 477 }
f6bcfd97
BP
478
479 // GRG, Jun/2000: Changed this after a lot of discussion in
480 // the lists. wxWindows 2.2 will have a set of flags to
481 // customize this behaviour.
482 SetInsertionPoint(0);
483
484 m_modified = FALSE;
6de97a3b 485}
c801d85f
KB
486
487void wxTextCtrl::WriteText( const wxString &text )
488{
223d09f6 489 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 490
17665a2b
VZ
491 if ( text.empty() )
492 return;
484e45bf 493
17665a2b
VZ
494#if wxUSE_UNICODE
495 wxWX2MBbuf buf = text.mbc_str();
496 const char *txt = buf;
497 size_t txtlen = strlen(buf);
498#else
499 const char *txt = text;
500 size_t txtlen = text.length();
501#endif
502
503 if ( m_windowStyle & wxTE_MULTILINE )
2830bf19 504 {
291a8f20 505 /* this moves the cursor pos to behind the inserted text */
3358d36e 506 gint len = GTK_EDITABLE(m_text)->current_pos;
13111b2a 507
17665a2b
VZ
508 // if we have any special style, use it
509 if ( !m_defaultStyle.IsDefault() )
510 {
511 GdkFont *font = m_defaultStyle.HasFont()
512 ? m_defaultStyle.GetFont().GetInternalFont()
513 : NULL;
514
515 GdkColor *colFg = m_defaultStyle.HasTextColour()
516 ? m_defaultStyle.GetTextColour().GetColor()
517 : NULL;
518
519 GdkColor *colBg = m_defaultStyle.HasBackgroundColour()
520 ? m_defaultStyle.GetBackgroundColour().GetColor()
521 : NULL;
522
523 gtk_text_insert( GTK_TEXT(m_text), font, colFg, colBg, txt, txtlen );
524 }
525 else // no style
526 {
527 gtk_editable_insert_text( GTK_EDITABLE(m_text), txt, txtlen, &len );
528 }
3358d36e
VZ
529
530 /* bring editable's cursor uptodate. bug in GTK. */
531 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
2830bf19 532 }
17665a2b 533 else // single line
2830bf19 534 {
c46554be 535 /* this moves the cursor pos to behind the inserted text */
3358d36e 536 gint len = GTK_EDITABLE(m_text)->current_pos;
17665a2b 537 gtk_editable_insert_text( GTK_EDITABLE(m_text), txt, txtlen, &len );
3358d36e
VZ
538
539 /* bring editable's cursor uptodate. bug in GTK. */
540 GTK_EDITABLE(m_text)->current_pos += text.Len();
541
542 /* bring entry's cursor uptodate. bug in GTK. */
543 gtk_entry_set_position( GTK_ENTRY(m_text), GTK_EDITABLE(m_text)->current_pos );
2830bf19 544 }
6de97a3b 545}
c801d85f 546
a6e21573
HH
547void wxTextCtrl::AppendText( const wxString &text )
548{
223d09f6 549 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
a6e21573 550
17665a2b
VZ
551 if ( text.empty() )
552 return;
553
554#if wxUSE_UNICODE
555 wxWX2MBbuf buf = text.mbc_str();
556 const char *txt = buf;
557 size_t txtlen = strlen(buf);
558#else
559 const char *txt = text;
560 size_t txtlen = text.length();
561#endif
2df7be7f 562
a6e21573
HH
563 if (m_windowStyle & wxTE_MULTILINE)
564 {
17665a2b 565 if ( !m_defaultStyle.IsDefault() )
bb69661b 566 {
17665a2b
VZ
567 GdkFont *font = m_defaultStyle.HasFont()
568 ? m_defaultStyle.GetFont().GetInternalFont()
569 : NULL;
570
571 GdkColor *colFg = m_defaultStyle.HasTextColour()
572 ? m_defaultStyle.GetTextColour().GetColor()
573 : NULL;
bb69661b 574
17665a2b
VZ
575 GdkColor *colBg = m_defaultStyle.HasBackgroundColour()
576 ? m_defaultStyle.GetBackgroundColour().GetColor()
577 : NULL;
578
579 gtk_text_insert( GTK_TEXT(m_text), font, colFg, colBg, txt, txtlen );
bb69661b 580 }
17665a2b 581 else // no style
bb69661b
VZ
582 {
583 /* we'll insert at the last position */
584 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
17665a2b 585 gtk_editable_insert_text( GTK_EDITABLE(m_text), txt, txtlen, &len );
bb69661b 586 }
3358d36e
VZ
587
588 /* bring editable's cursor uptodate. bug in GTK. */
589 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
a6e21573 590 }
17665a2b 591 else // single line
a6e21573 592 {
17665a2b 593 gtk_entry_append_text( GTK_ENTRY(m_text), txt );
a6e21573
HH
594 }
595}
596
debe6624 597wxString wxTextCtrl::GetLineText( long lineNo ) const
c801d85f 598{
a81258be
RR
599 if (m_windowStyle & wxTE_MULTILINE)
600 {
601 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
602 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
603
604 if (text)
605 {
223d09f6 606 wxString buf(wxT(""));
a81258be
RR
607 long i;
608 int currentLine = 0;
609 for (i = 0; currentLine != lineNo && text[i]; i++ )
610 if (text[i] == '\n')
611 currentLine++;
612 // Now get the text
613 int j;
614 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
615 buf += text[i];
8bbe427f 616
a81258be
RR
617 g_free( text );
618 return buf;
619 }
620 else
621 return wxEmptyString;
622 }
623 else
624 {
625 if (lineNo == 0) return GetValue();
626 return wxEmptyString;
627 }
6de97a3b 628}
c801d85f 629
a81258be
RR
630void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
631{
ac0d36b5
HH
632 /* If you implement this, don't forget to update the documentation!
633 * (file docs/latex/wx/text.tex) */
223d09f6 634 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
a81258be 635}
112892b9 636
0efe5ba7 637bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
c801d85f 638{
96385642 639 if ( m_windowStyle & wxTE_MULTILINE )
805dd538 640 {
96385642
VZ
641 wxString text = GetValue();
642
6085b116 643 // cast to prevent warning. But pos really should've been unsigned.
2829d9e3 644 if( (unsigned long)pos > text.Len() )
96385642
VZ
645 return FALSE;
646
ac0d36b5
HH
647 *x=0; // First Col
648 *y=0; // First Line
2829d9e3 649
05939a81
OK
650 const wxChar* stop = text.c_str() + pos;
651 for ( const wxChar *p = text.c_str(); p < stop; p++ )
96385642 652 {
223d09f6 653 if (*p == wxT('\n'))
96385642
VZ
654 {
655 (*y)++;
ac0d36b5 656 *x=0;
96385642
VZ
657 }
658 else
659 (*x)++;
660 }
805dd538 661 }
96385642
VZ
662 else // single line control
663 {
2829d9e3 664 if ( pos <= GTK_ENTRY(m_text)->text_length )
96385642 665 {
ac0d36b5 666 *y = 0;
96385642
VZ
667 *x = pos;
668 }
669 else
670 {
671 // index out of bounds
672 return FALSE;
673 }
8bbe427f 674 }
96385642
VZ
675
676 return TRUE;
6de97a3b 677}
c801d85f 678
e3ca08dd 679long wxTextCtrl::XYToPosition(long x, long y ) const
c801d85f 680{
2830bf19 681 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
805dd538 682
2830bf19 683 long pos=0;
ac0d36b5 684 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
8bbe427f 685
3358d36e 686 pos += x;
2830bf19 687 return pos;
6de97a3b 688}
c801d85f 689
a81258be 690int wxTextCtrl::GetLineLength(long lineNo) const
c801d85f 691{
a81258be
RR
692 wxString str = GetLineText (lineNo);
693 return (int) str.Length();
6de97a3b 694}
c801d85f 695
a81258be 696int wxTextCtrl::GetNumberOfLines() const
c801d85f 697{
2830bf19 698 if (m_windowStyle & wxTE_MULTILINE)
a81258be 699 {
2830bf19
RR
700 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
701 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
702
703 if (text)
704 {
705 int currentLine = 0;
706 for (int i = 0; i < len; i++ )
96385642 707 {
2830bf19 708 if (text[i] == '\n')
96385642
VZ
709 currentLine++;
710 }
2830bf19 711 g_free( text );
2829d9e3
VZ
712
713 // currentLine is 0 based, add 1 to get number of lines
714 return currentLine + 1;
2830bf19
RR
715 }
716 else
96385642 717 {
2830bf19 718 return 0;
96385642 719 }
a81258be
RR
720 }
721 else
2830bf19 722 {
96385642 723 return 1;
2830bf19 724 }
6de97a3b 725}
c801d85f 726
debe6624 727void wxTextCtrl::SetInsertionPoint( long pos )
c801d85f 728{
223d09f6 729 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
3358d36e
VZ
730
731 if (m_windowStyle & wxTE_MULTILINE)
291a8f20
RR
732 {
733 /* seems to be broken in GTK 1.0.X:
3358d36e
VZ
734 gtk_text_set_point( GTK_TEXT(m_text), (int)pos ); */
735
291a8f20
RR
736 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
737 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
3358d36e 738
291a8f20 739 /* we fake a set_point by inserting and deleting. as the user
3358d36e
VZ
740 isn't supposed to get to know about thos non-sense, we
741 disconnect so that no events are sent to the user program. */
742
291a8f20
RR
743 gint tmp = (gint)pos;
744 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
3358d36e
VZ
745 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
746
291a8f20
RR
747 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
748 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
3358d36e
VZ
749
750 /* bring editable's cursor uptodate. another bug in GTK. */
751
752 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
ac0d36b5 753 }
2830bf19 754 else
291a8f20 755 {
d59051dd 756 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
3358d36e
VZ
757
758 /* bring editable's cursor uptodate. bug in GTK. */
759
b02da6b1 760 GTK_EDITABLE(m_text)->current_pos = (guint32)pos;
291a8f20 761 }
6de97a3b 762}
c801d85f 763
03f38c58 764void wxTextCtrl::SetInsertionPointEnd()
c801d85f 765{
223d09f6 766 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 767
d59051dd
VZ
768 if (m_windowStyle & wxTE_MULTILINE)
769 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
770 else
771 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
6de97a3b 772}
c801d85f 773
debe6624 774void wxTextCtrl::SetEditable( bool editable )
c801d85f 775{
223d09f6 776 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 777
2830bf19
RR
778 if (m_windowStyle & wxTE_MULTILINE)
779 gtk_text_set_editable( GTK_TEXT(m_text), editable );
780 else
781 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
6de97a3b 782}
c801d85f 783
68df5777
RR
784bool wxTextCtrl::Enable( bool enable )
785{
786 if (!wxWindowBase::Enable(enable))
787 {
788 // nothing to do
789 return FALSE;
790 }
f6bcfd97 791
68df5777
RR
792 if (m_windowStyle & wxTE_MULTILINE)
793 {
794 gtk_text_set_editable( GTK_TEXT(m_text), enable );
5abf8c9d 795 OnParentEnable(enable);
68df5777
RR
796 }
797 else
798 {
799 gtk_widget_set_sensitive( m_text, enable );
800 }
801
802 return TRUE;
803}
804
fdca68a6
JS
805// wxGTK-specific: called recursively by Enable,
806// to give widgets an oppprtunity to correct their colours after they
807// have been changed by Enable
808void wxTextCtrl::OnParentEnable( bool enable )
809{
810 // If we have a custom background colour, we use this colour in both
811 // disabled and enabled mode, or we end up with a different colour under the
812 // text.
813 wxColour oldColour = GetBackgroundColour();
814 if (oldColour.Ok())
815 {
816 // Need to set twice or it'll optimize the useful stuff out
817 if (oldColour == * wxWHITE)
818 SetBackgroundColour(*wxBLACK);
819 else
820 SetBackgroundColour(*wxWHITE);
821 SetBackgroundColour(oldColour);
822 }
823}
824
0efe5ba7
VZ
825void wxTextCtrl::DiscardEdits()
826{
827 m_modified = FALSE;
828}
829
debe6624 830void wxTextCtrl::SetSelection( long from, long to )
c801d85f 831{
223d09f6 832 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 833
a1f79c1e
VZ
834 if ( (m_windowStyle & wxTE_MULTILINE) &&
835 !GTK_TEXT(m_text)->line_start_cache )
836 {
837 // tell the programmer that it didn't work
838 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
839 return;
840 }
841
2830bf19 842 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
6de97a3b 843}
c801d85f 844
910f1f8c 845void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
c801d85f 846{
910f1f8c 847// SetInsertionPoint( pos );
6de97a3b 848}
c801d85f 849
03f38c58 850long wxTextCtrl::GetInsertionPoint() const
c801d85f 851{
223d09f6 852 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
8bbe427f 853
2830bf19 854 return (long) GTK_EDITABLE(m_text)->current_pos;
6de97a3b 855}
c801d85f 856
03f38c58 857long wxTextCtrl::GetLastPosition() const
c801d85f 858{
223d09f6 859 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
8bbe427f 860
2830bf19
RR
861 int pos = 0;
862 if (m_windowStyle & wxTE_MULTILINE)
863 pos = gtk_text_get_length( GTK_TEXT(m_text) );
864 else
865 pos = GTK_ENTRY(m_text)->text_length;
805dd538 866
ac0d36b5 867 return (long)pos;
6de97a3b 868}
c801d85f 869
debe6624 870void wxTextCtrl::Remove( long from, long to )
c801d85f 871{
223d09f6 872 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 873
2830bf19 874 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
6de97a3b 875}
c801d85f 876
debe6624 877void wxTextCtrl::Replace( long from, long to, const wxString &value )
c801d85f 878{
223d09f6 879 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 880
2830bf19 881 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
bb69661b 882
2df7be7f
RR
883 if (!value.IsEmpty())
884 {
885 gint pos = (gint)from;
05939a81 886#if wxUSE_UNICODE
2df7be7f
RR
887 wxWX2MBbuf buf = value.mbc_str();
888 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
05939a81 889#else
2df7be7f 890 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
05939a81 891#endif
2df7be7f 892 }
6de97a3b 893}
c801d85f 894
03f38c58 895void wxTextCtrl::Cut()
c801d85f 896{
223d09f6 897 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 898
d345e841 899#if (GTK_MINOR_VERSION > 0)
2830bf19 900 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
75ed1d15 901#else
2830bf19 902 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
75ed1d15 903#endif
6de97a3b 904}
c801d85f 905
03f38c58 906void wxTextCtrl::Copy()
c801d85f 907{
223d09f6 908 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 909
d345e841 910#if (GTK_MINOR_VERSION > 0)
2830bf19 911 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
75ed1d15 912#else
2830bf19 913 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
75ed1d15 914#endif
6de97a3b 915}
c801d85f 916
03f38c58 917void wxTextCtrl::Paste()
c801d85f 918{
223d09f6 919 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 920
d345e841 921#if (GTK_MINOR_VERSION > 0)
2830bf19 922 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
75ed1d15 923#else
2830bf19 924 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
75ed1d15 925#endif
6de97a3b 926}
c801d85f 927
ca8b28f2
JS
928// Undo/redo
929void wxTextCtrl::Undo()
930{
931 // TODO
223d09f6 932 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
ca8b28f2
JS
933}
934
935void wxTextCtrl::Redo()
936{
937 // TODO
223d09f6 938 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
ca8b28f2
JS
939}
940
941bool wxTextCtrl::CanUndo() const
942{
943 // TODO
223d09f6 944 wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
ca8b28f2
JS
945 return FALSE;
946}
947
948bool wxTextCtrl::CanRedo() const
949{
950 // TODO
223d09f6 951 wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
ca8b28f2
JS
952 return FALSE;
953}
954
955// If the return values from and to are the same, there is no
956// selection.
2d4cc5b6 957void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
ca8b28f2 958{
223d09f6 959 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
bb69661b 960
2d4cc5b6
VZ
961 long from, to;
962 if ( !(GTK_EDITABLE(m_text)->has_selection) )
05060eeb 963 {
2d4cc5b6
VZ
964 from =
965 to = GetInsertionPoint();
966 }
967 else // got selection
968 {
969 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
970 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
971
972 if ( from > to )
973 {
974 // exchange them to be compatible with wxMSW
975 long tmp = from;
976 from = to;
977 to = tmp;
978 }
05060eeb 979 }
bb69661b 980
2d4cc5b6
VZ
981 if ( fromOut )
982 *fromOut = from;
983 if ( toOut )
984 *toOut = to;
ca8b28f2
JS
985}
986
987bool wxTextCtrl::IsEditable() const
988{
223d09f6 989 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
05060eeb
RR
990
991 return GTK_EDITABLE(m_text)->editable;
ca8b28f2
JS
992}
993
0efe5ba7
VZ
994bool wxTextCtrl::IsModified() const
995{
996 return m_modified;
997}
998
03f38c58 999void wxTextCtrl::Clear()
c801d85f 1000{
223d09f6 1001 SetValue( wxT("") );
6de97a3b 1002}
c801d85f 1003
903f689b 1004void wxTextCtrl::OnChar( wxKeyEvent &key_event )
c801d85f 1005{
223d09f6 1006 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
805dd538 1007
2830bf19
RR
1008 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1009 {
1010 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1011 event.SetEventObject(this);
f6bcfd97 1012 event.SetString(GetValue());
2830bf19
RR
1013 if (GetEventHandler()->ProcessEvent(event)) return;
1014 }
903f689b 1015
da048e3d
RR
1016 if ((key_event.KeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1017 {
1018 wxWindow *top_frame = m_parent;
8487f887 1019 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
da048e3d 1020 top_frame = top_frame->GetParent();
13111b2a
VZ
1021 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1022
1023 if (window->default_widget)
da048e3d
RR
1024 {
1025 gtk_widget_activate (window->default_widget);
13111b2a
VZ
1026 return;
1027 }
da048e3d
RR
1028 }
1029
2830bf19 1030 key_event.Skip();
6de97a3b 1031}
c801d85f 1032
03f38c58 1033GtkWidget* wxTextCtrl::GetConnectWidget()
e3e65dac 1034{
ae0bdb01 1035 return GTK_WIDGET(m_text);
6de97a3b 1036}
e3e65dac 1037
903f689b
RR
1038bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1039{
ae0bdb01
RR
1040 if (m_windowStyle & wxTE_MULTILINE)
1041 return (window == GTK_TEXT(m_text)->text_area);
1042 else
1043 return (window == GTK_ENTRY(m_text)->text_area);
903f689b 1044}
e3e65dac 1045
bb69661b
VZ
1046// the font will change for subsequent text insertiongs
1047bool wxTextCtrl::SetFont( const wxFont &font )
868a2826 1048{
223d09f6 1049 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
8bbe427f 1050
bb69661b
VZ
1051 if ( !wxWindowBase::SetFont(font) )
1052 {
1053 // font didn't change, nothing to do
1054 return FALSE;
1055 }
1056
1057 if ( m_windowStyle & wxTE_MULTILINE )
1058 {
01041145 1059 m_updateFont = TRUE;
bb69661b 1060
01041145 1061 ChangeFontGlobally();
bb69661b
VZ
1062 }
1063
1064 return TRUE;
58614078
RR
1065}
1066
01041145
VZ
1067void wxTextCtrl::ChangeFontGlobally()
1068{
1069 // this method is very inefficient and hence should be called as rarely as
1070 // possible!
1071 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1072 _T("shouldn't be called for single line controls") );
1073
1074 wxString value = GetValue();
1075 if ( !value.IsEmpty() )
1076 {
1077 Clear();
1078 AppendText(value);
1079
1080 m_updateFont = FALSE;
1081 }
1082}
1083
1084void wxTextCtrl::UpdateFontIfNeeded()
1085{
1086 if ( m_updateFont )
1087 ChangeFontGlobally();
1088}
1089
17665a2b
VZ
1090bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1091{
1092 if ( !wxControl::SetForegroundColour(colour) )
1093 return FALSE;
1094
1095 // update default fg colour too
1096 m_defaultStyle.SetTextColour(colour);
1097
1098 return TRUE;
1099}
1100
f03fc89f 1101bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
68dda785 1102{
223d09f6 1103 wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
a81258be 1104
ae0bdb01 1105 wxControl::SetBackgroundColour( colour );
3358d36e 1106
f03fc89f
VZ
1107 if (!m_widget->window)
1108 return FALSE;
8bbe427f 1109
ae0bdb01 1110 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
805dd538
VZ
1111 if (sysbg.Red() == colour.Red() &&
1112 sysbg.Green() == colour.Green() &&
ae0bdb01
RR
1113 sysbg.Blue() == colour.Blue())
1114 {
f03fc89f 1115 return FALSE; // FIXME or TRUE?
805dd538
VZ
1116 }
1117
f03fc89f
VZ
1118 if (!m_backgroundColour.Ok())
1119 return FALSE;
8bbe427f 1120
ae0bdb01
RR
1121 if (m_windowStyle & wxTE_MULTILINE)
1122 {
1123 GdkWindow *window = GTK_TEXT(m_text)->text_area;
f03fc89f
VZ
1124 if (!window)
1125 return FALSE;
ae0bdb01
RR
1126 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1127 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1128 gdk_window_clear( window );
1129 }
f03fc89f 1130
17665a2b
VZ
1131 // change active background color too
1132 m_defaultStyle.SetBackgroundColour( colour );
1133
f03fc89f 1134 return TRUE;
58614078
RR
1135}
1136
17665a2b
VZ
1137bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr &style )
1138{
1139 /* VERY dirty way to do that - removes the required text and re-adds it
1140 with styling (FIXME) */
1141 if ( m_windowStyle & wxTE_MULTILINE )
1142 {
1143 if ( style.IsDefault() )
1144 {
1145 // nothing to do
1146 return TRUE;
1147 }
1148
1149 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1150
1151 wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1152 _T("invalid range in wxTextCtrl::SetStyle") );
1153
1154 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1155 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1156 wxString tmp(text,*wxConvCurrent);
1157 g_free( text );
1158
1159 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1160 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1161
1162#if wxUSE_UNICODE
1163 wxWX2MBbuf buf = tmp.mbc_str();
1164 const char *txt = buf;
1165 size_t txtlen = strlen(buf);
1166#else
1167 const char *txt = tmp;
1168 size_t txtlen = tmp.length();
1169#endif
1170
1171 GdkFont *font = style.HasFont()
1172 ? style.GetFont().GetInternalFont()
1173 : NULL;
1174
1175 GdkColor *colFg = style.HasTextColour()
1176 ? style.GetTextColour().GetColor()
1177 : NULL;
1178
1179 GdkColor *colBg = style.HasBackgroundColour()
1180 ? style.GetBackgroundColour().GetColor()
1181 : NULL;
1182
1183 gtk_text_insert( GTK_TEXT(m_text), font, colFg, colBg, txt, txtlen );
1184
1185 /* does not seem to help under GTK+ 1.2 !!!
1186 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1187 SetInsertionPoint( old_pos );
1188 return TRUE;
1189 }
1190 else // singe line
1191 {
1192 // cannot do this for GTK+'s Entry widget
1193 return FALSE;
1194 }
1195}
1196
58614078
RR
1197void wxTextCtrl::ApplyWidgetStyle()
1198{
ae0bdb01
RR
1199 if (m_windowStyle & wxTE_MULTILINE)
1200 {
2830bf19 1201 // how ?
805dd538 1202 }
ae0bdb01
RR
1203 else
1204 {
1205 SetWidgetStyle();
1206 gtk_widget_set_style( m_text, m_widgetStyle );
1207 }
68dda785 1208}
f96aa4d9 1209
e702ff0f
JS
1210void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1211{
1212 Cut();
1213}
1214
1215void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1216{
1217 Copy();
1218}
1219
1220void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1221{
1222 Paste();
1223}
1224
1225void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1226{
1227 Undo();
1228}
1229
1230void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1231{
1232 Redo();
1233}
1234
1235void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1236{
1237 event.Enable( CanCut() );
1238}
1239
1240void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1241{
1242 event.Enable( CanCopy() );
1243}
1244
1245void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1246{
1247 event.Enable( CanPaste() );
1248}
1249
1250void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1251{
1252 event.Enable( CanUndo() );
1253}
1254
1255void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1256{
1257 event.Enable( CanRedo() );
1258}
65045edd
RR
1259
1260void wxTextCtrl::OnInternalIdle()
1261{
1262 wxCursor cursor = m_cursor;
1263 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1264
307f16e8 1265 if (cursor.Ok())
65045edd 1266 {
65045edd 1267 GdkWindow *window = (GdkWindow*) NULL;
13111b2a 1268 if (HasFlag(wxTE_MULTILINE))
65045edd
RR
1269 window = GTK_TEXT(m_text)->text_area;
1270 else
1271 window = GTK_ENTRY(m_text)->text_area;
13111b2a 1272
65045edd
RR
1273 if (window)
1274 gdk_window_set_cursor( window, cursor.GetCursor() );
1275
1276 if (!g_globalCursor.Ok())
1277 cursor = *wxSTANDARD_CURSOR;
1278
1279 window = m_widget->window;
247e5b16 1280 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
65045edd
RR
1281 gdk_window_set_cursor( window, cursor.GetCursor() );
1282 }
26bf1ce0
VZ
1283
1284 UpdateWindowUI();
65045edd 1285}
f68586e5
VZ
1286
1287wxSize wxTextCtrl::DoGetBestSize() const
1288{
1289 // FIXME should be different for multi-line controls...
0279e844
RR
1290 wxSize ret( wxControl::DoGetBestSize() );
1291 return wxSize(80, ret.y);
f68586e5 1292}