]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Oh well, I'll just stuff in the rest of the Unicode changes I have made
[wxWidgets.git] / src / gtk / textctrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10#ifdef __GNUG__
11#pragma implementation "textctrl.h"
12#endif
13
14#include "wx/textctrl.h"
15#include "wx/utils.h"
16#include "wx/intl.h"
17#include "wx/settings.h"
18
19#include <sys/types.h>
20#include <sys/stat.h>
21#include <ctype.h>
22
23#include "gdk/gdk.h"
24#include "gtk/gtk.h"
25#include "gdk/gdkkeysyms.h"
26
27//-----------------------------------------------------------------------------
28// data
29//-----------------------------------------------------------------------------
30
31extern bool g_blockEventsOnDrag;
32
33//-----------------------------------------------------------------------------
34// "changed"
35//-----------------------------------------------------------------------------
36
37static void
38gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
39{
40 if (!win->m_hasVMT) return;
41
42 win->SetModified();
43
44 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
45 event.SetString( win->GetValue() );
46 event.SetEventObject( win );
47 win->GetEventHandler()->ProcessEvent( event );
48}
49
50//-----------------------------------------------------------------------------
51// "changed" from vertical scrollbar
52//-----------------------------------------------------------------------------
53
54static void
55gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
56{
57 if (!win->m_hasVMT) return;
58
59 win->CalculateScrollbar();
60}
61
62//-----------------------------------------------------------------------------
63// wxTextCtrl
64//-----------------------------------------------------------------------------
65
66IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
67
68BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
69 EVT_CHAR(wxTextCtrl::OnChar)
70
71 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
72 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
73 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
74 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
75 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
76
77 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
78 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
79 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
80 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
81 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
82END_EVENT_TABLE()
83
84#ifndef NO_TEXT_WINDOW_STREAM
85wxTextCtrl::wxTextCtrl() : streambuf()
86{
87 if (allocate()) setp(base(),ebuf());
88
89 m_modified = FALSE;
90}
91#else
92wxTextCtrl::wxTextCtrl()
93{
94 m_modified = FALSE;
95}
96#endif
97
98#ifndef NO_TEXT_WINDOW_STREAM
99wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
100 const wxPoint &pos, const wxSize &size,
101 int style, const wxValidator& validator, const wxString &name ) : streambuf()
102{
103 if (allocate()) setp(base(),ebuf());
104
105 m_modified = FALSE;
106 Create( parent, id, value, pos, size, style, validator, name );
107}
108#else
109wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
110 const wxPoint &pos, const wxSize &size,
111 int style, const wxValidator& validator, const wxString &name )
112{
113 m_modified = FALSE;
114 Create( parent, id, value, pos, size, style, validator, name );
115}
116#endif
117
118bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
119 const wxPoint &pos, const wxSize &size,
120 int style, const wxValidator& validator, const wxString &name )
121{
122 m_needParent = TRUE;
123 m_acceptsFocus = TRUE;
124
125 PreCreation( parent, id, pos, size, style, name );
126
127 SetValidator( validator );
128
129 m_vScrollbarVisible = FALSE;
130
131 bool multi_line = (style & wxTE_MULTILINE) != 0;
132 if ( multi_line )
133 {
134 /* a multi-line edit control: create a vertical scrollbar by default and
135 horizontal if requested */
136 bool bHasHScrollbar = (style & wxHSCROLL) != 0;
137
138 /* create our control ... */
139 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
140
141 /* ... and put into the upper left hand corner of the table */
142 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
143 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
144
145 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
146 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
147 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
148 0, 0);
149
150 /* put the horizontal scrollbar in the lower left hand corner */
151 if (bHasHScrollbar)
152 {
153 GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
154 GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
155
156 gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
157 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
158 GTK_FILL,
159 0, 0);
160 gtk_widget_show(hscrollbar);
161 }
162
163 /* we create the vertical scrollbar on demand */
164 m_vScrollbar = (GtkWidget*) NULL;
165
166 }
167 else
168 {
169 /* a single-line text control: no need for scrollbars */
170 m_widget =
171 m_text = gtk_entry_new();
172 }
173
174 wxSize newSize = size;
175 if (newSize.x == -1) newSize.x = 80;
176 if (newSize.y == -1) newSize.y = 26;
177 SetSize( newSize.x, newSize.y );
178
179 m_parent->AddChild( this );
180
181 (m_parent->m_insertCallback)( m_parent, this );
182
183 PostCreation();
184
185 if (multi_line)
186 {
187 gtk_widget_realize(m_text);
188 gtk_widget_show(m_text);
189 }
190
191 /* we want to be notified about text changes */
192 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
193 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
194
195 if (!value.IsEmpty())
196 {
197 gint tmp = 0;
198 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
199
200 if (multi_line)
201 {
202 /* bring editable's cursor uptodate. bug in GTK. */
203
204 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
205 }
206 }
207
208 if (style & wxTE_PASSWORD)
209 {
210 if (!multi_line)
211 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
212 }
213
214 if (style & wxTE_READONLY)
215 {
216 if (!multi_line)
217 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
218 }
219 else
220 {
221 if (multi_line)
222 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
223 }
224
225 SetBackgroundColour( parent->GetBackgroundColour() );
226 SetForegroundColour( parent->GetForegroundColour() );
227
228 Show( TRUE );
229
230 if (multi_line)
231 {
232 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
233 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
234 }
235
236 return TRUE;
237}
238
239void wxTextCtrl::CalculateScrollbar()
240{
241 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
242
243 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
244
245 if (adj->upper - adj->page_size < 0.8)
246 {
247 if (m_vScrollbarVisible)
248 {
249 gtk_widget_hide( m_vScrollbar );
250
251 m_vScrollbarVisible = FALSE;
252 }
253 }
254 else
255 {
256 if (!m_vScrollbarVisible)
257 {
258 if (!m_vScrollbar)
259 {
260 /* finally, put the vertical scrollbar in the upper right corner */
261 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
262 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
263
264 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
265 GTK_FILL,
266 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
267 0, 0);
268 }
269
270 gtk_widget_show( m_vScrollbar );
271
272 m_vScrollbarVisible = TRUE;
273 }
274 }
275}
276
277wxString wxTextCtrl::GetValue() const
278{
279 wxCHECK_MSG( m_text != NULL, "", "invalid text ctrl" );
280
281 wxString tmp;
282 if (m_windowStyle & wxTE_MULTILINE)
283 {
284 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
285 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
286 tmp = text;
287 g_free( text );
288 }
289 else
290 {
291 tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
292 }
293 return tmp;
294}
295
296void wxTextCtrl::SetValue( const wxString &value )
297{
298 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
299
300 wxString tmp = "";
301 if (!value.IsNull()) tmp = value;
302 if (m_windowStyle & wxTE_MULTILINE)
303 {
304 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
305 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
306 len = 0;
307 gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
308 }
309 else
310 {
311 gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
312 }
313}
314
315void wxTextCtrl::WriteText( const wxString &text )
316{
317 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
318
319 if (text.IsNull()) return;
320
321 if (m_windowStyle & wxTE_MULTILINE)
322 {
323 /* this moves the cursor pos to behind the inserted text */
324 gint len = GTK_EDITABLE(m_text)->current_pos;
325
326 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
327
328 /* bring editable's cursor uptodate. bug in GTK. */
329 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
330 }
331 else
332 {
333 /* this moves the cursor pos to behind the inserted text */
334 gint len = GTK_EDITABLE(m_text)->current_pos;
335 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
336
337 /* bring editable's cursor uptodate. bug in GTK. */
338 GTK_EDITABLE(m_text)->current_pos += text.Len();
339
340 /* bring entry's cursor uptodate. bug in GTK. */
341 gtk_entry_set_position( GTK_ENTRY(m_text), GTK_EDITABLE(m_text)->current_pos );
342 }
343}
344
345void wxTextCtrl::AppendText( const wxString &text )
346{
347 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
348
349 if (m_windowStyle & wxTE_MULTILINE)
350 {
351 /* we'll insert at the last position */
352 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
353 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
354
355 /* bring editable's cursor uptodate. bug in GTK. */
356 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
357 }
358 else
359 {
360 gtk_entry_append_text( GTK_ENTRY(m_text), text );
361 }
362}
363
364bool wxTextCtrl::LoadFile( const wxString &file )
365{
366 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
367
368 if (!wxFileExists(file)) return FALSE;
369
370 Clear();
371
372 FILE *fp = (FILE*) NULL;
373 struct stat statb;
374
375 if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
376 !(fp = fopen ((char*) (const char*) file, "r")))
377 {
378 return FALSE;
379 }
380 else
381 {
382 gint len = statb.st_size;
383 char *text;
384 if (!(text = (char*)malloc ((unsigned) (len + 1))))
385 {
386 fclose (fp);
387 return FALSE;
388 }
389 if (fread (text, sizeof (char), len, fp) != (size_t) len)
390 {
391 }
392 fclose (fp);
393
394 text[len] = 0;
395
396 if (m_windowStyle & wxTE_MULTILINE)
397 {
398 gint pos = 0;
399 gtk_editable_insert_text( GTK_EDITABLE(m_text), text, len, &pos );
400 }
401 else
402 {
403 gtk_entry_set_text( GTK_ENTRY(m_text), text );
404 }
405
406 free (text);
407 m_modified = FALSE;
408 return TRUE;
409 }
410 return FALSE;
411}
412
413bool wxTextCtrl::SaveFile( const wxString &file )
414{
415 wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
416
417 if (file == "") return FALSE;
418
419 FILE *fp;
420
421 if (!(fp = fopen ((char*) (const char*) file, "w")))
422 {
423 return FALSE;
424 }
425 else
426 {
427 char *text = (char*) NULL;
428 gint len = 0;
429
430 if (m_windowStyle & wxTE_MULTILINE)
431 {
432 len = gtk_text_get_length( GTK_TEXT(m_text) );
433 text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
434 }
435 else
436 {
437 text = gtk_entry_get_text( GTK_ENTRY(m_text) );
438 }
439
440 if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
441 {
442 // Did not write whole file
443 }
444
445 // Make sure newline terminates the file
446 if (text[len - 1] != '\n')
447 fputc ('\n', fp);
448
449 fclose (fp);
450
451 if (m_windowStyle & wxTE_MULTILINE) g_free( text );
452
453 m_modified = FALSE;
454 return TRUE;
455 }
456
457 return TRUE;
458}
459
460wxString wxTextCtrl::GetLineText( long lineNo ) const
461{
462 if (m_windowStyle & wxTE_MULTILINE)
463 {
464 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
465 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
466
467 if (text)
468 {
469 wxString buf("");
470 long i;
471 int currentLine = 0;
472 for (i = 0; currentLine != lineNo && text[i]; i++ )
473 if (text[i] == '\n')
474 currentLine++;
475 // Now get the text
476 int j;
477 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
478 buf += text[i];
479
480 g_free( text );
481 return buf;
482 }
483 else
484 return wxEmptyString;
485 }
486 else
487 {
488 if (lineNo == 0) return GetValue();
489 return wxEmptyString;
490 }
491}
492
493void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
494{
495 /* If you implement this, don't forget to update the documentation!
496 * (file docs/latex/wx/text.tex) */
497 wxFAIL_MSG( "wxTextCtrl::OnDropFiles not implemented" );
498}
499
500long wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
501{
502 if ( m_windowStyle & wxTE_MULTILINE )
503 {
504 wxString text = GetValue();
505
506 // cast to prevent warning. But pos really should've been unsigned.
507 if( (unsigned long)pos > text.Len() )
508 return FALSE;
509
510 *x=0; // First Col
511 *y=0; // First Line
512
513 const char* stop = text.c_str() + pos;
514 for ( const char *p = text.c_str(); p < stop; p++ )
515 {
516 if (*p == '\n')
517 {
518 (*y)++;
519 *x=0;
520 }
521 else
522 (*x)++;
523 }
524 }
525 else // single line control
526 {
527 if ( pos <= GTK_ENTRY(m_text)->text_length )
528 {
529 *y = 0;
530 *x = pos;
531 }
532 else
533 {
534 // index out of bounds
535 return FALSE;
536 }
537 }
538
539 return TRUE;
540}
541
542long wxTextCtrl::XYToPosition(long x, long y ) const
543{
544 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
545
546 long pos=0;
547 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
548
549 pos += x;
550 return pos;
551}
552
553int wxTextCtrl::GetLineLength(long lineNo) const
554{
555 wxString str = GetLineText (lineNo);
556 return (int) str.Length();
557}
558
559int wxTextCtrl::GetNumberOfLines() const
560{
561 if (m_windowStyle & wxTE_MULTILINE)
562 {
563 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
564 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
565
566 if (text)
567 {
568 int currentLine = 0;
569 for (int i = 0; i < len; i++ )
570 {
571 if (text[i] == '\n')
572 currentLine++;
573 }
574 g_free( text );
575
576 // currentLine is 0 based, add 1 to get number of lines
577 return currentLine + 1;
578 }
579 else
580 {
581 return 0;
582 }
583 }
584 else
585 {
586 return 1;
587 }
588}
589
590void wxTextCtrl::SetInsertionPoint( long pos )
591{
592 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
593
594 if (m_windowStyle & wxTE_MULTILINE)
595 {
596 /* seems to be broken in GTK 1.0.X:
597 gtk_text_set_point( GTK_TEXT(m_text), (int)pos ); */
598
599 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
600 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
601
602 /* we fake a set_point by inserting and deleting. as the user
603 isn't supposed to get to know about thos non-sense, we
604 disconnect so that no events are sent to the user program. */
605
606 gint tmp = (gint)pos;
607 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
608 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
609
610 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
611 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
612
613 /* bring editable's cursor uptodate. another bug in GTK. */
614
615 GTK_EDITABLE(m_text)->current_pos = gtk_text_get_point( GTK_TEXT(m_text) );
616 }
617 else
618 {
619 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
620
621 /* bring editable's cursor uptodate. bug in GTK. */
622
623 GTK_EDITABLE(m_text)->current_pos = pos;
624 }
625}
626
627void wxTextCtrl::SetInsertionPointEnd()
628{
629 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
630
631 if (m_windowStyle & wxTE_MULTILINE)
632 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
633 else
634 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
635}
636
637void wxTextCtrl::SetEditable( bool editable )
638{
639 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
640
641 if (m_windowStyle & wxTE_MULTILINE)
642 gtk_text_set_editable( GTK_TEXT(m_text), editable );
643 else
644 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
645}
646
647void wxTextCtrl::SetSelection( long from, long to )
648{
649 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
650
651 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
652}
653
654void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
655{
656 wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
657}
658
659long wxTextCtrl::GetInsertionPoint() const
660{
661 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
662
663 return (long) GTK_EDITABLE(m_text)->current_pos;
664}
665
666long wxTextCtrl::GetLastPosition() const
667{
668 wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
669
670 int pos = 0;
671 if (m_windowStyle & wxTE_MULTILINE)
672 pos = gtk_text_get_length( GTK_TEXT(m_text) );
673 else
674 pos = GTK_ENTRY(m_text)->text_length;
675
676 return (long)pos;
677}
678
679void wxTextCtrl::Remove( long from, long to )
680{
681 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
682
683 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
684}
685
686void wxTextCtrl::Replace( long from, long to, const wxString &value )
687{
688 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
689
690 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
691 if (value.IsNull()) return;
692 gint pos = (gint)from;
693 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
694}
695
696void wxTextCtrl::Cut()
697{
698 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
699
700#if (GTK_MINOR_VERSION > 0)
701 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
702#else
703 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
704#endif
705}
706
707void wxTextCtrl::Copy()
708{
709 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
710
711#if (GTK_MINOR_VERSION > 0)
712 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
713#else
714 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
715#endif
716}
717
718void wxTextCtrl::Paste()
719{
720 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
721
722#if (GTK_MINOR_VERSION > 0)
723 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
724#else
725 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
726#endif
727}
728
729bool wxTextCtrl::CanCopy() const
730{
731 // Can copy if there's a selection
732 long from, to;
733 GetSelection(& from, & to);
734 return (from != to) ;
735}
736
737bool wxTextCtrl::CanCut() const
738{
739 // Can cut if there's a selection
740 long from, to;
741 GetSelection(& from, & to);
742 return (from != to) ;
743}
744
745bool wxTextCtrl::CanPaste() const
746{
747 return IsEditable() ;
748}
749
750// Undo/redo
751void wxTextCtrl::Undo()
752{
753 // TODO
754 wxFAIL_MSG( "wxTextCtrl::Undo not implemented" );
755}
756
757void wxTextCtrl::Redo()
758{
759 // TODO
760 wxFAIL_MSG( "wxTextCtrl::Redo not implemented" );
761}
762
763bool wxTextCtrl::CanUndo() const
764{
765 // TODO
766 wxFAIL_MSG( "wxTextCtrl::CanUndo not implemented" );
767 return FALSE;
768}
769
770bool wxTextCtrl::CanRedo() const
771{
772 // TODO
773 wxFAIL_MSG( "wxTextCtrl::CanRedo not implemented" );
774 return FALSE;
775}
776
777// If the return values from and to are the same, there is no
778// selection.
779void wxTextCtrl::GetSelection(long* from, long* to) const
780{
781 // TODO
782 *from = 0;
783 *to = 0;
784 wxFAIL_MSG( "wxTextCtrl::GetSelection not implemented" );
785}
786
787bool wxTextCtrl::IsEditable() const
788{
789 // TODO
790 wxFAIL_MSG( "wxTextCtrl::IsEditable not implemented" );
791 return FALSE;
792}
793
794void wxTextCtrl::Clear()
795{
796 SetValue( "" );
797}
798
799void wxTextCtrl::OnChar( wxKeyEvent &key_event )
800{
801 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
802
803 if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
804 {
805 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
806 event.SetEventObject(this);
807 if (GetEventHandler()->ProcessEvent(event)) return;
808 }
809
810 key_event.Skip();
811}
812
813#ifndef NO_TEXT_WINDOW_STREAM
814int wxTextCtrl::overflow( int WXUNUSED(c) )
815{
816 int len = pptr() - pbase();
817 char *txt = new char[len+1];
818 strncpy(txt, pbase(), len);
819 txt[len] = '\0';
820 (*this) << txt;
821 setp(pbase(), epptr());
822 delete[] txt;
823 return EOF;
824}
825
826int wxTextCtrl::sync()
827{
828 int len = pptr() - pbase();
829 char *txt = new char[len+1];
830 strncpy(txt, pbase(), len);
831 txt[len] = '\0';
832 (*this) << txt;
833 setp(pbase(), epptr());
834 delete[] txt;
835 return 0;
836}
837
838int wxTextCtrl::underflow()
839{
840 return EOF;
841}
842
843wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
844{
845 AppendText(s);
846 return *this;
847}
848
849wxTextCtrl& wxTextCtrl::operator<<(float f)
850{
851 static char buf[100];
852 sprintf(buf, "%.2f", f);
853 AppendText(buf);
854 return *this;
855}
856
857wxTextCtrl& wxTextCtrl::operator<<(double d)
858{
859 static char buf[100];
860 sprintf(buf, "%.2f", d);
861 AppendText(buf);
862 return *this;
863}
864
865wxTextCtrl& wxTextCtrl::operator<<(int i)
866{
867 static char buf[100];
868 sprintf(buf, "%i", i);
869 AppendText(buf);
870 return *this;
871}
872
873wxTextCtrl& wxTextCtrl::operator<<(long i)
874{
875 static char buf[100];
876 sprintf(buf, "%ld", i);
877 AppendText(buf);
878 return *this;
879}
880
881wxTextCtrl& wxTextCtrl::operator<<(const char c)
882{
883 char buf[2];
884
885 buf[0] = c;
886 buf[1] = 0;
887 AppendText(buf);
888 return *this;
889}
890#endif
891
892GtkWidget* wxTextCtrl::GetConnectWidget()
893{
894 return GTK_WIDGET(m_text);
895}
896
897bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
898{
899 if (m_windowStyle & wxTE_MULTILINE)
900 return (window == GTK_TEXT(m_text)->text_area);
901 else
902 return (window == GTK_ENTRY(m_text)->text_area);
903}
904
905void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
906{
907 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
908
909 // doesn't work
910}
911
912void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
913{
914 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
915
916 // doesn't work
917}
918
919void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
920{
921 wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
922
923 wxControl::SetBackgroundColour( colour );
924
925 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
926 if (sysbg.Red() == colour.Red() &&
927 sysbg.Green() == colour.Green() &&
928 sysbg.Blue() == colour.Blue())
929 {
930 return;
931 }
932
933 if (!m_backgroundColour.Ok()) return;
934
935 if (m_windowStyle & wxTE_MULTILINE)
936 {
937 GdkWindow *window = GTK_TEXT(m_text)->text_area;
938 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
939 gdk_window_set_background( window, m_backgroundColour.GetColor() );
940 gdk_window_clear( window );
941 }
942}
943
944void wxTextCtrl::ApplyWidgetStyle()
945{
946 if (m_windowStyle & wxTE_MULTILINE)
947 {
948 // how ?
949 }
950 else
951 {
952 SetWidgetStyle();
953 gtk_widget_set_style( m_text, m_widgetStyle );
954 }
955}
956
957void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
958{
959 Cut();
960}
961
962void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
963{
964 Copy();
965}
966
967void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
968{
969 Paste();
970}
971
972void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
973{
974 Undo();
975}
976
977void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
978{
979 Redo();
980}
981
982void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
983{
984 event.Enable( CanCut() );
985}
986
987void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
988{
989 event.Enable( CanCopy() );
990}
991
992void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
993{
994 event.Enable( CanPaste() );
995}
996
997void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
998{
999 event.Enable( CanUndo() );
1000}
1001
1002void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1003{
1004 event.Enable( CanRedo() );
1005}
wxWidgets (Impactor)