Commit | Line | Data |
---|---|---|
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 | ||
33 | extern void wxapp_install_idle_handler(); | |
34 | extern bool g_isIdle; | |
35 | ||
b292e2f5 RR |
36 | //----------------------------------------------------------------------------- |
37 | // data | |
38 | //----------------------------------------------------------------------------- | |
39 | ||
65045edd RR |
40 | extern bool g_blockEventsOnDrag; |
41 | extern wxCursor g_globalCursor; | |
b292e2f5 | 42 | |
c801d85f | 43 | //----------------------------------------------------------------------------- |
2f2aa628 | 44 | // "changed" |
c801d85f KB |
45 | //----------------------------------------------------------------------------- |
46 | ||
805dd538 | 47 | static void |
2830bf19 | 48 | gtk_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 | 68 | static void |
034be888 | 69 | gtk_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 |
83 | extern wxWindow *g_focusWindow; |
84 | extern bool g_blockEventsOnDrag; | |
85 | // extern bool g_isIdle; | |
86 | ||
87 | static 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 | ||
137 | static 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 | ||
192 | IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl) | |
193 | ||
c801d85f | 194 | BEGIN_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 |
208 | END_EVENT_TABLE() |
209 | ||
01041145 | 210 | void 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 |
218 | wxTextCtrl::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 |
232 | bool 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 |
415 | void 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 | 439 | wxString 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 | |
458 | void 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 | |
487 | void 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 |
547 | void 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 | 597 | wxString 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 |
630 | void 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 | 637 | bool 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 | 679 | long 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 | 690 | int wxTextCtrl::GetLineLength(long lineNo) const |
c801d85f | 691 | { |
a81258be RR |
692 | wxString str = GetLineText (lineNo); |
693 | return (int) str.Length(); | |
6de97a3b | 694 | } |
c801d85f | 695 | |
a81258be | 696 | int 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 | 727 | void 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 | 764 | void 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 | 774 | void 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 |
784 | bool 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 | |
808 | void 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 |
825 | void wxTextCtrl::DiscardEdits() |
826 | { | |
827 | m_modified = FALSE; | |
828 | } | |
829 | ||
debe6624 | 830 | void 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 | 845 | void wxTextCtrl::ShowPosition( long WXUNUSED(pos) ) |
c801d85f | 846 | { |
910f1f8c | 847 | // SetInsertionPoint( pos ); |
6de97a3b | 848 | } |
c801d85f | 849 | |
03f38c58 | 850 | long 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 | 857 | long 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 | 870 | void 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 | 877 | void 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 | 895 | void 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 | 906 | void 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 | 917 | void 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 |
929 | void wxTextCtrl::Undo() | |
930 | { | |
931 | // TODO | |
223d09f6 | 932 | wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") ); |
ca8b28f2 JS |
933 | } |
934 | ||
935 | void wxTextCtrl::Redo() | |
936 | { | |
937 | // TODO | |
223d09f6 | 938 | wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") ); |
ca8b28f2 JS |
939 | } |
940 | ||
941 | bool wxTextCtrl::CanUndo() const | |
942 | { | |
943 | // TODO | |
223d09f6 | 944 | wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") ); |
ca8b28f2 JS |
945 | return FALSE; |
946 | } | |
947 | ||
948 | bool 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 | 957 | void 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 | ||
987 | bool 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 |
994 | bool wxTextCtrl::IsModified() const |
995 | { | |
996 | return m_modified; | |
997 | } | |
998 | ||
03f38c58 | 999 | void wxTextCtrl::Clear() |
c801d85f | 1000 | { |
223d09f6 | 1001 | SetValue( wxT("") ); |
6de97a3b | 1002 | } |
c801d85f | 1003 | |
903f689b | 1004 | void 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 | 1033 | GtkWidget* wxTextCtrl::GetConnectWidget() |
e3e65dac | 1034 | { |
ae0bdb01 | 1035 | return GTK_WIDGET(m_text); |
6de97a3b | 1036 | } |
e3e65dac | 1037 | |
903f689b RR |
1038 | bool 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 |
1047 | bool 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 |
1067 | void 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 | ||
1084 | void wxTextCtrl::UpdateFontIfNeeded() | |
1085 | { | |
1086 | if ( m_updateFont ) | |
1087 | ChangeFontGlobally(); | |
1088 | } | |
1089 | ||
17665a2b VZ |
1090 | bool 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 | 1101 | bool 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 |
1137 | bool 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 |
1197 | void 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 |
1210 | void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event)) |
1211 | { | |
1212 | Cut(); | |
1213 | } | |
1214 | ||
1215 | void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event)) | |
1216 | { | |
1217 | Copy(); | |
1218 | } | |
1219 | ||
1220 | void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event)) | |
1221 | { | |
1222 | Paste(); | |
1223 | } | |
1224 | ||
1225 | void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event)) | |
1226 | { | |
1227 | Undo(); | |
1228 | } | |
1229 | ||
1230 | void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event)) | |
1231 | { | |
1232 | Redo(); | |
1233 | } | |
1234 | ||
1235 | void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event) | |
1236 | { | |
1237 | event.Enable( CanCut() ); | |
1238 | } | |
1239 | ||
1240 | void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event) | |
1241 | { | |
1242 | event.Enable( CanCopy() ); | |
1243 | } | |
1244 | ||
1245 | void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event) | |
1246 | { | |
1247 | event.Enable( CanPaste() ); | |
1248 | } | |
1249 | ||
1250 | void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event) | |
1251 | { | |
1252 | event.Enable( CanUndo() ); | |
1253 | } | |
1254 | ||
1255 | void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event) | |
1256 | { | |
1257 | event.Enable( CanRedo() ); | |
1258 | } | |
65045edd RR |
1259 | |
1260 | void 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 | |
1287 | wxSize 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 | } |