src/gtk1/textctrl.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        textctrl.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "textctrl.h"
#endif

#include "wx/textctrl.h"
#include "wx/utils.h"
#include <wx/intl.h>

//-----------------------------------------------------------------------------
//  "changed"
//-----------------------------------------------------------------------------

static void gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
{
  win->SetModified();

  wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
  wxString val( win->GetValue() );
  if (!val.IsNull()) event.m_commandString = WXSTRINGCAST val;
  event.SetEventObject( win );
  win->GetEventHandler()->ProcessEvent( event );
}

//-----------------------------------------------------------------------------
//  wxTextCtrl
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)

BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  EVT_CHAR(wxTextCtrl::OnChar)
END_EVENT_TABLE()

wxTextCtrl::wxTextCtrl() : streambuf()
{
  if (allocate()) setp(base(),ebuf());

  m_modified = FALSE;
}

wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
      const wxPoint &pos, const wxSize &size,
      int style, const wxValidator& validator, const wxString &name ) : streambuf()
{
  if (allocate()) setp(base(),ebuf());

  m_modified = FALSE;
  Create( parent, id, value, pos, size, style, validator, name );
}

bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
      const wxPoint &pos, const wxSize &size,
      int style, const wxValidator& validator, const wxString &name )
{
  m_needParent = TRUE;

  PreCreation( parent, id, pos, size, style, name );

  SetValidator( validator );

  bool bMultiLine = (style & wxTE_MULTILINE) != 0;
  if ( bMultiLine )
  {
    // a multi-line edit control: create a vertical scrollbar by default and
    // horizontal if requested
    bool bHasHScrollbar = (style & wxHSCROLL) != 0;

    // create our control...
    m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );

    // ... and put into the upper left hand corner of the table
    m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
    gtk_table_attach(GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
                     GTK_FILL | GTK_EXPAND,
                     GTK_FILL | GTK_EXPAND | GTK_SHRINK,
                     0, 0);

    // put the horizontal scrollbar in the lower left hand corner
    if (bHasHScrollbar)
    {
      GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
      gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
                       GTK_EXPAND | GTK_FILL,
                       GTK_FILL,
                       0, 0);
      gtk_widget_show(hscrollbar);
    }

    // finally, put the vertical scrollbar in the upper right corner
    GtkWidget *vscrollbar = gtk_vscrollbar_new(GTK_TEXT(m_text)->vadj);
    gtk_table_attach(GTK_TABLE(m_widget), vscrollbar, 1, 2, 0, 1,
                     GTK_FILL,
                     GTK_EXPAND | GTK_FILL | GTK_SHRINK,
                     0, 0);
    gtk_widget_show( vscrollbar );
  }
  else
  {
    // a single-line text control: no need for scrollbars
    m_widget =
    m_text = gtk_entry_new();
  }

  wxSize newSize = size;
  if (newSize.x == -1) newSize.x = 80;
  if (newSize.y == -1) newSize.y = 26;
  SetSize( newSize.x, newSize.y );

  PostCreation();

  if (bMultiLine)
  {
    gtk_widget_realize(m_text);
    gtk_widget_show(m_text);
  }

  // we want to be notified about text changes
  gtk_signal_connect(GTK_OBJECT(m_text), "changed",
                     GTK_SIGNAL_FUNC(gtk_text_changed_callback),
                     (gpointer)this);

  if (!value.IsNull())
  {
    gint tmp = 0;
    gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
  }

  if (style & wxTE_READONLY)
  {
  }
  else
  {
    if (bMultiLine)
      gtk_text_set_editable( GTK_TEXT(m_text), 1 );
  }

  Show( TRUE );

  SetBackgroundColour( parent->GetBackgroundColour() );

  return TRUE;
}

wxString wxTextCtrl::GetValue() const
{
  wxString tmp;
  if (m_windowStyle & wxTE_MULTILINE)
  {
    gint len = gtk_text_get_length( GTK_TEXT(m_text) );
    tmp = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
  }
  else
  {
    tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
  }
  return tmp;
}

void wxTextCtrl::SetValue( const wxString &value )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  wxString tmp = "";
  if (!value.IsNull()) tmp = value;
  if (m_windowStyle & wxTE_MULTILINE)
  {
    gint len = gtk_text_get_length( GTK_TEXT(m_text) );
    gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
    len = 0;
    gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
  }
  else
  {
    gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
  }
}

void wxTextCtrl::WriteText( const wxString &text )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  if (text.IsNull()) return;

  if (m_windowStyle & wxTE_MULTILINE)
  {
    gint len = gtk_text_get_length( GTK_TEXT(m_text) );
    gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
  }
  else
  {
    gtk_entry_append_text( GTK_ENTRY(m_text), text );
  }
}

bool wxTextCtrl::LoadFile( const wxString &WXUNUSED(file) )
{
  wxFAIL_MSG( "wxTextCtrl::LoadFile not implemented" );

  return FALSE;
}

bool wxTextCtrl::SaveFile( const wxString &WXUNUSED(file) )
{
  wxFAIL_MSG( "wxTextCtrl::SaveFile not implemented" );

  return FALSE;
}

/*
wxString wxTextCtrl::GetLineText( long lineNo ) const
{
}


void wxTextCtrl::OnDropFiles( wxDropFilesEvent &event )
{
}

long wxTextCtrl::PositionToXY( long pos, long *x, long *y ) const
{
}

long wxTextCtrl::XYToPosition( long x, long y )
{
}

int wxTextCtrl::GetNumberOfLines()
{
}

*/
void wxTextCtrl::SetInsertionPoint( long pos )
{
  int tmp = (int) pos;
  if (m_windowStyle & wxTE_MULTILINE)
    gtk_text_set_point( GTK_TEXT(m_text), tmp );
  else
    gtk_entry_set_position( GTK_ENTRY(m_text), tmp );
}

void wxTextCtrl::SetInsertionPointEnd()
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  int pos = 0;
  if (m_windowStyle & wxTE_MULTILINE)
    pos = gtk_text_get_length( GTK_TEXT(m_text) );
  else
    pos = GTK_ENTRY(m_text)->text_length;
  SetInsertionPoint( pos-1 );
}

void wxTextCtrl::SetEditable( bool editable )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  if (m_windowStyle & wxTE_MULTILINE)
    gtk_text_set_editable( GTK_TEXT(m_text), editable );
  else
    gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
}

void wxTextCtrl::SetSelection( long from, long to )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
}

void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
{
  wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
}

long wxTextCtrl::GetInsertionPoint() const
{
  wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );

  return (long) GTK_EDITABLE(m_text)->current_pos;
}

long wxTextCtrl::GetLastPosition() const
{
  wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );

  int pos = 0;
  if (m_windowStyle & wxTE_MULTILINE)
    pos = gtk_text_get_length( GTK_TEXT(m_text) );
  else
    pos = GTK_ENTRY(m_text)->text_length;
  return (long)pos-1;
}

void wxTextCtrl::Remove( long from, long to )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
}

void wxTextCtrl::Replace( long from, long to, const wxString &value )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
  if (value.IsNull()) return;
  gint pos = (gint)to;
  gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
}

void wxTextCtrl::Cut()
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

#if (GTK_MINOR_VERSION == 1)
  gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
#else
  gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
#endif
}

void wxTextCtrl::Copy()
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

#if (GTK_MINOR_VERSION == 1)
  gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
#else
  gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
#endif
}

void wxTextCtrl::Paste()
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

#if (GTK_MINOR_VERSION == 1)
  gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
#else
  gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
#endif
}

void wxTextCtrl::Clear()
{
  SetValue( "" );
}

void wxTextCtrl::OnChar( wxKeyEvent &key_event )
{
  if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
  {
    wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
    event.SetEventObject(this);
    if (GetEventHandler()->ProcessEvent(event)) return;
  }
  else if (key_event.KeyCode() == WXK_TAB)
  {
    wxNavigationKeyEvent event;
    event.SetDirection( key_event.m_shiftDown );
    event.SetWindowChange(FALSE);
    event.SetEventObject(this);

    if (GetEventHandler()->ProcessEvent(event)) return;
  }
  key_event.Skip();
}

int wxTextCtrl::overflow( int WXUNUSED(c) )
{
  int len = pptr() - pbase();
  char *txt = new char[len+1];
  strncpy(txt, pbase(), len);
  txt[len] = '\0';
  (*this) << txt;
  setp(pbase(), epptr());
  delete[] txt;
  return EOF;
}

int wxTextCtrl::sync()
{
  int len = pptr() - pbase();
  char *txt = new char[len+1];
  strncpy(txt, pbase(), len);
  txt[len] = '\0';
  (*this) << txt;
  setp(pbase(), epptr());
  delete[] txt;
  return 0;
}

int wxTextCtrl::underflow()
{
  return EOF;
}

wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
{
  WriteText(s);
  return *this;
}

wxTextCtrl& wxTextCtrl::operator<<(float f)
{
  static char buf[100];
  sprintf(buf, "%.2f", f);
  WriteText(buf);
  return *this;
}

wxTextCtrl& wxTextCtrl::operator<<(double d)
{
  static char buf[100];
  sprintf(buf, "%.2f", d);
  WriteText(buf);
  return *this;
}

wxTextCtrl& wxTextCtrl::operator<<(int i)
{
  static char buf[100];
  sprintf(buf, "%i", i);
  WriteText(buf);
  return *this;
}

wxTextCtrl& wxTextCtrl::operator<<(long i)
{
  static char buf[100];
  sprintf(buf, "%ld", i);
  WriteText(buf);
  return *this;
}

wxTextCtrl& wxTextCtrl::operator<<(const char c)
{
  char buf[2];

  buf[0] = c;
  buf[1] = 0;
  WriteText(buf);
  return *this;
}

GtkWidget* wxTextCtrl::GetConnectWidget()
{
  return GTK_WIDGET(m_text);
}

bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
{
  if (m_windowStyle & wxTE_MULTILINE)
    return (window == GTK_TEXT(m_text)->text_area);
  else
    return (window == GTK_ENTRY(m_text)->text_area);
}

void wxTextCtrl::SetFont( const wxFont &font )
{
  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  if (((wxFont*)&font)->Ok())
    m_font = font;
  else
    m_font = *wxSWISS_FONT;

  GtkStyle *style = gtk_widget_get_style( m_text );
  if (!m_hasOwnStyle)
  {
    m_hasOwnStyle = TRUE;
    style = gtk_style_copy( gtk_widget_get_style( m_text ) );
  }

  gdk_font_unref( style->font );
  style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );

  gtk_widget_set_style( m_text, style );
}

void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
{
  return;

  wxCHECK_RET( m_text != NULL, "invalid text ctrl" );

  m_backgroundColour = colour;
  if (!m_backgroundColour.Ok()) return;

  if (m_windowStyle & wxTE_MULTILINE)
  {
    GdkWindow *window = GTK_TEXT(m_text)->text_area;
    m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
    gdk_window_set_background( window, m_backgroundColour.GetColor() );
    gdk_window_clear( window );
  }
  else
  {
    GtkStyle *style = gtk_widget_get_style( m_text );
    if (!m_hasOwnStyle)
    {
      m_hasOwnStyle = TRUE;
      style = gtk_style_copy( gtk_widget_get_style( m_text ) );
    }

    m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_text->window ) );
    style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
    style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();

    gtk_widget_set_style( m_text, style );
  }
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: textctrl.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	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
	18	//-----------------------------------------------------------------------------
	19	// "changed"
	20	//-----------------------------------------------------------------------------
	21
	22	static void gtk_text_changed_callback( GtkWidget WXUNUSED(widget), wxTextCtrl win )
	23	{
	24	win->SetModified();
	25
	26	wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
	27	wxString val( win->GetValue() );
	28	if (!val.IsNull()) event.m_commandString = WXSTRINGCAST val;
	29	event.SetEventObject( win );
	30	win->GetEventHandler()->ProcessEvent( event );
	31	}
	32
	33	//-----------------------------------------------------------------------------
	34	// wxTextCtrl
	35	//-----------------------------------------------------------------------------
	36
	37	IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
	38
	39	BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
	40	EVT_CHAR(wxTextCtrl::OnChar)
	41	END_EVENT_TABLE()
	42
	43	wxTextCtrl::wxTextCtrl() : streambuf()
	44	{
	45	if (allocate()) setp(base(),ebuf());
	46
	47	m_modified = FALSE;
	48	}
	49
	50	wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
	51	const wxPoint &pos, const wxSize &size,
	52	int style, const wxValidator& validator, const wxString &name ) : streambuf()
	53	{
	54	if (allocate()) setp(base(),ebuf());
	55
	56	m_modified = FALSE;
	57	Create( parent, id, value, pos, size, style, validator, name );
	58	}
	59
	60	bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
	61	const wxPoint &pos, const wxSize &size,
	62	int style, const wxValidator& validator, const wxString &name )
	63	{
	64	m_needParent = TRUE;
	65
	66	PreCreation( parent, id, pos, size, style, name );
	67
	68	SetValidator( validator );
	69
	70	bool bMultiLine = (style & wxTE_MULTILINE) != 0;
	71	if ( bMultiLine )
	72	{
	73	// a multi-line edit control: create a vertical scrollbar by default and
	74	// horizontal if requested
	75	bool bHasHScrollbar = (style & wxHSCROLL) != 0;
	76
	77	// create our control...
	78	m_text = gtk_text_new( (GtkAdjustment ) NULL, (GtkAdjustment ) NULL );
	79
	80	// ... and put into the upper left hand corner of the table
	81	m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
	82	gtk_table_attach(GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
	83	GTK_FILL \| GTK_EXPAND,
	84	GTK_FILL \| GTK_EXPAND \| GTK_SHRINK,
	85	0, 0);
	86
	87	// put the horizontal scrollbar in the lower left hand corner
	88	if (bHasHScrollbar)
	89	{
	90	GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
	91	gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
	92	GTK_EXPAND \| GTK_FILL,
	93	GTK_FILL,
	94	0, 0);
	95	gtk_widget_show(hscrollbar);
	96	}
	97
	98	// finally, put the vertical scrollbar in the upper right corner
	99	GtkWidget *vscrollbar = gtk_vscrollbar_new(GTK_TEXT(m_text)->vadj);
	100	gtk_table_attach(GTK_TABLE(m_widget), vscrollbar, 1, 2, 0, 1,
	101	GTK_FILL,
	102	GTK_EXPAND \| GTK_FILL \| GTK_SHRINK,
	103	0, 0);
	104	gtk_widget_show( vscrollbar );
	105	}
	106	else
	107	{
	108	// a single-line text control: no need for scrollbars
	109	m_widget =
	110	m_text = gtk_entry_new();
	111	}
	112
	113	wxSize newSize = size;
	114	if (newSize.x == -1) newSize.x = 80;
	115	if (newSize.y == -1) newSize.y = 26;
	116	SetSize( newSize.x, newSize.y );
	117
	118	PostCreation();
	119
	120	if (bMultiLine)
	121	{
	122	gtk_widget_realize(m_text);
	123	gtk_widget_show(m_text);
	124	}
	125
	126	// we want to be notified about text changes
	127	gtk_signal_connect(GTK_OBJECT(m_text), "changed",
	128	GTK_SIGNAL_FUNC(gtk_text_changed_callback),
	129	(gpointer)this);
	130
	131	if (!value.IsNull())
	132	{
	133	gint tmp = 0;
	134	gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
	135	}
	136
	137	if (style & wxTE_READONLY)
	138	{
	139	}
	140	else
	141	{
	142	if (bMultiLine)
	143	gtk_text_set_editable( GTK_TEXT(m_text), 1 );
	144	}
	145
	146	Show( TRUE );
	147
	148	SetBackgroundColour( parent->GetBackgroundColour() );
	149
	150	return TRUE;
	151	}
	152
	153	wxString wxTextCtrl::GetValue() const
	154	{
	155	wxString tmp;
	156	if (m_windowStyle & wxTE_MULTILINE)
	157	{
	158	gint len = gtk_text_get_length( GTK_TEXT(m_text) );
	159	tmp = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
	160	}
	161	else
	162	{
	163	tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
	164	}
	165	return tmp;
	166	}
	167
	168	void wxTextCtrl::SetValue( const wxString &value )
	169	{
	170	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	171
	172	wxString tmp = "";
	173	if (!value.IsNull()) tmp = value;
	174	if (m_windowStyle & wxTE_MULTILINE)
	175	{
	176	gint len = gtk_text_get_length( GTK_TEXT(m_text) );
	177	gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
	178	len = 0;
	179	gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
	180	}
	181	else
	182	{
	183	gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
	184	}
	185	}
	186
	187	void wxTextCtrl::WriteText( const wxString &text )
	188	{
	189	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	190
	191	if (text.IsNull()) return;
	192
	193	if (m_windowStyle & wxTE_MULTILINE)
	194	{
	195	gint len = gtk_text_get_length( GTK_TEXT(m_text) );
	196	gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
	197	}
	198	else
	199	{
	200	gtk_entry_append_text( GTK_ENTRY(m_text), text );
	201	}
	202	}
	203
	204	bool wxTextCtrl::LoadFile( const wxString &WXUNUSED(file) )
	205	{
	206	wxFAIL_MSG( "wxTextCtrl::LoadFile not implemented" );
	207
	208	return FALSE;
	209	}
	210
	211	bool wxTextCtrl::SaveFile( const wxString &WXUNUSED(file) )
	212	{
	213	wxFAIL_MSG( "wxTextCtrl::SaveFile not implemented" );
	214
	215	return FALSE;
	216	}
	217
	218	/*
	219	wxString wxTextCtrl::GetLineText( long lineNo ) const
	220	{
	221	}
	222
	223
	224	void wxTextCtrl::OnDropFiles( wxDropFilesEvent &event )
	225	{
	226	}
	227
	228	long wxTextCtrl::PositionToXY( long pos, long x, long y ) const
	229	{
	230	}
	231
	232	long wxTextCtrl::XYToPosition( long x, long y )
	233	{
	234	}
	235
	236	int wxTextCtrl::GetNumberOfLines()
	237	{
	238	}
	239
	240	*/
	241	void wxTextCtrl::SetInsertionPoint( long pos )
	242	{
	243	int tmp = (int) pos;
	244	if (m_windowStyle & wxTE_MULTILINE)
	245	gtk_text_set_point( GTK_TEXT(m_text), tmp );
	246	else
	247	gtk_entry_set_position( GTK_ENTRY(m_text), tmp );
	248	}
	249
	250	void wxTextCtrl::SetInsertionPointEnd()
	251	{
	252	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	253
	254	int pos = 0;
	255	if (m_windowStyle & wxTE_MULTILINE)
	256	pos = gtk_text_get_length( GTK_TEXT(m_text) );
	257	else
	258	pos = GTK_ENTRY(m_text)->text_length;
	259	SetInsertionPoint( pos-1 );
	260	}
	261
	262	void wxTextCtrl::SetEditable( bool editable )
	263	{
	264	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	265
	266	if (m_windowStyle & wxTE_MULTILINE)
	267	gtk_text_set_editable( GTK_TEXT(m_text), editable );
	268	else
	269	gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
	270	}
	271
	272	void wxTextCtrl::SetSelection( long from, long to )
	273	{
	274	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	275
	276	gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
	277	}
	278
	279	void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
	280	{
	281	wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
	282	}
	283
	284	long wxTextCtrl::GetInsertionPoint() const
	285	{
	286	wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
	287
	288	return (long) GTK_EDITABLE(m_text)->current_pos;
	289	}
	290
	291	long wxTextCtrl::GetLastPosition() const
	292	{
	293	wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
	294
	295	int pos = 0;
	296	if (m_windowStyle & wxTE_MULTILINE)
	297	pos = gtk_text_get_length( GTK_TEXT(m_text) );
	298	else
	299	pos = GTK_ENTRY(m_text)->text_length;
	300	return (long)pos-1;
	301	}
	302
	303	void wxTextCtrl::Remove( long from, long to )
	304	{
	305	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	306
	307	gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
	308	}
	309
	310	void wxTextCtrl::Replace( long from, long to, const wxString &value )
	311	{
	312	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	313
	314	gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
	315	if (value.IsNull()) return;
	316	gint pos = (gint)to;
	317	gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
	318	}
	319
	320	void wxTextCtrl::Cut()
	321	{
	322	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	323
	324	#if (GTK_MINOR_VERSION == 1)
	325	gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
	326	#else
	327	gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
	328	#endif
	329	}
	330
	331	void wxTextCtrl::Copy()
	332	{
	333	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	334
	335	#if (GTK_MINOR_VERSION == 1)
	336	gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
	337	#else
	338	gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
	339	#endif
	340	}
	341
	342	void wxTextCtrl::Paste()
	343	{
	344	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	345
	346	#if (GTK_MINOR_VERSION == 1)
	347	gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
	348	#else
	349	gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
	350	#endif
	351	}
	352
	353	void wxTextCtrl::Clear()
	354	{
	355	SetValue( "" );
	356	}
	357
	358	void wxTextCtrl::OnChar( wxKeyEvent &key_event )
	359	{
	360	if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
	361	{
	362	wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
	363	event.SetEventObject(this);
	364	if (GetEventHandler()->ProcessEvent(event)) return;
	365	}
	366	else if (key_event.KeyCode() == WXK_TAB)
	367	{
	368	wxNavigationKeyEvent event;
	369	event.SetDirection( key_event.m_shiftDown );
	370	event.SetWindowChange(FALSE);
	371	event.SetEventObject(this);
	372
	373	if (GetEventHandler()->ProcessEvent(event)) return;
	374	}
	375	key_event.Skip();
	376	}
	377
	378	int wxTextCtrl::overflow( int WXUNUSED(c) )
	379	{
	380	int len = pptr() - pbase();
	381	char *txt = new char[len+1];
	382	strncpy(txt, pbase(), len);
	383	txt[len] = '\0';
	384	(*this) << txt;
	385	setp(pbase(), epptr());
	386	delete[] txt;
	387	return EOF;
	388	}
	389
	390	int wxTextCtrl::sync()
	391	{
	392	int len = pptr() - pbase();
	393	char *txt = new char[len+1];
	394	strncpy(txt, pbase(), len);
	395	txt[len] = '\0';
	396	(*this) << txt;
	397	setp(pbase(), epptr());
	398	delete[] txt;
	399	return 0;
	400	}
	401
	402	int wxTextCtrl::underflow()
	403	{
	404	return EOF;
	405	}
	406
	407	wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
	408	{
	409	WriteText(s);
	410	return *this;
	411	}
	412
	413	wxTextCtrl& wxTextCtrl::operator<<(float f)
	414	{
	415	static char buf[100];
	416	sprintf(buf, "%.2f", f);
	417	WriteText(buf);
	418	return *this;
	419	}
	420
	421	wxTextCtrl& wxTextCtrl::operator<<(double d)
	422	{
	423	static char buf[100];
	424	sprintf(buf, "%.2f", d);
	425	WriteText(buf);
	426	return *this;
	427	}
	428
	429	wxTextCtrl& wxTextCtrl::operator<<(int i)
	430	{
	431	static char buf[100];
	432	sprintf(buf, "%i", i);
	433	WriteText(buf);
	434	return *this;
	435	}
	436
	437	wxTextCtrl& wxTextCtrl::operator<<(long i)
	438	{
	439	static char buf[100];
	440	sprintf(buf, "%ld", i);
	441	WriteText(buf);
	442	return *this;
	443	}
	444
	445	wxTextCtrl& wxTextCtrl::operator<<(const char c)
	446	{
	447	char buf[2];
	448
	449	buf[0] = c;
	450	buf[1] = 0;
	451	WriteText(buf);
	452	return *this;
	453	}
	454
	455	GtkWidget* wxTextCtrl::GetConnectWidget()
	456	{
	457	return GTK_WIDGET(m_text);
	458	}
	459
	460	bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
	461	{
	462	if (m_windowStyle & wxTE_MULTILINE)
	463	return (window == GTK_TEXT(m_text)->text_area);
	464	else
	465	return (window == GTK_ENTRY(m_text)->text_area);
	466	}
	467
	468	void wxTextCtrl::SetFont( const wxFont &font )
	469	{
	470	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	471
	472	if (((wxFont*)&font)->Ok())
	473	m_font = font;
	474	else
	475	m_font = *wxSWISS_FONT;
	476
	477	GtkStyle *style = gtk_widget_get_style( m_text );
	478	if (!m_hasOwnStyle)
	479	{
	480	m_hasOwnStyle = TRUE;
	481	style = gtk_style_copy( gtk_widget_get_style( m_text ) );
	482	}
	483
	484	gdk_font_unref( style->font );
	485	style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
	486
	487	gtk_widget_set_style( m_text, style );
	488	}
	489
	490	void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
	491	{
	492	return;
	493
	494	wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
	495
	496	m_backgroundColour = colour;
	497	if (!m_backgroundColour.Ok()) return;
	498
	499	if (m_windowStyle & wxTE_MULTILINE)
	500	{
	501	GdkWindow *window = GTK_TEXT(m_text)->text_area;
	502	m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
	503	gdk_window_set_background( window, m_backgroundColour.GetColor() );
	504	gdk_window_clear( window );
	505	}
	506	else
	507	{
	508	GtkStyle *style = gtk_widget_get_style( m_text );
	509	if (!m_hasOwnStyle)
	510	{
	511	m_hasOwnStyle = TRUE;
	512	style = gtk_style_copy( gtk_widget_get_style( m_text ) );
	513	}
	514
	515	m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_text->window ) );
	516	style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
	517	style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
	518
	519	gtk_widget_set_style( m_text, style );
	520	}
	521	}
	522