// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "textctrl.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
// data
//-----------------------------------------------------------------------------
-extern bool g_blockEventsOnDrag;
extern wxCursor g_globalCursor;
extern wxWindowGTK *g_delayedFocus;
// ----------------------------------------------------------------------------
#ifdef __WXGTK20__
+extern "C" {
+static void wxGtkOnRemoveTag(GtkTextBuffer *buffer,
+ GtkTextTag *tag,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ char *prefix)
+{
+ gchar *name;
+ g_object_get (tag, "name", &name, NULL);
+
+ if (!name || strncmp(name, prefix, strlen(prefix)))
+ // anonymous tag or not starting with prefix - don't remove
+ g_signal_stop_emission_by_name(buffer, "remove_tag");
+
+ g_free(name);
+}
+}
+
+extern "C" {
static void wxGtkTextApplyTagsFromAttr(GtkTextBuffer *text_buffer,
const wxTextAttr& attr,
GtkTextIter *start,
static gchar buf[1024];
GtkTextTag *tag;
+ gulong remove_handler_id = g_signal_connect( text_buffer, "remove_tag",
+ G_CALLBACK(wxGtkOnRemoveTag), gpointer("WX"));
+ gtk_text_buffer_remove_all_tags(text_buffer, start, end);
+ g_signal_handler_disconnect( text_buffer, remove_handler_id );
+
if (attr.HasFont())
{
char *font_string;
"background-gdk", colBg, NULL );
gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
}
+
+ if (attr.HasAlignment())
+ {
+ GtkTextIter para_start, para_end = *end;
+ gtk_text_buffer_get_iter_at_line( text_buffer,
+ ¶_start,
+ gtk_text_iter_get_line(start) );
+ gtk_text_iter_forward_line(¶_end);
+
+ remove_handler_id = g_signal_connect( text_buffer, "remove_tag",
+ G_CALLBACK(wxGtkOnRemoveTag),
+ gpointer("WXALIGNMENT"));
+ gtk_text_buffer_remove_all_tags( text_buffer, ¶_start, ¶_end );
+ g_signal_handler_disconnect( text_buffer, remove_handler_id );
+
+ GtkJustification align;
+ switch (attr.GetAlignment())
+ {
+ default:
+ align = GTK_JUSTIFY_LEFT;
+ break;
+ case wxTEXT_ALIGNMENT_RIGHT:
+ align = GTK_JUSTIFY_RIGHT;
+ break;
+ case wxTEXT_ALIGNMENT_CENTER:
+ align = GTK_JUSTIFY_CENTER;
+ break;
+ // gtk+ doesn't support justify as of gtk+-2.7.4
+ }
+
+ g_snprintf(buf, sizeof(buf), "WXALIGNMENT %d", align);
+ tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
+ buf );
+ if (!tag)
+ tag = gtk_text_buffer_create_tag( text_buffer, buf,
+ "justification", align, NULL );
+ gtk_text_buffer_apply_tag( text_buffer, tag, ¶_start, ¶_end );
+ }
+}
}
+extern "C" {
static void wxGtkTextInsert(GtkWidget *text,
GtkTextBuffer *text_buffer,
const wxTextAttr& attr,
- wxCharBuffer buffer)
+ const wxCharBuffer& buffer)
{
gint start_offset;
wxGtkTextApplyTagsFromAttr(text_buffer, attr, &start, &iter);
}
+}
#else
+extern "C" {
static void wxGtkTextInsert(GtkWidget *text,
const wxTextAttr& attr,
const char *txt,
gtk_text_insert( GTK_TEXT(text), font, colFg, colBg, txt, len );
}
+}
#endif // GTK 1.x
// ----------------------------------------------------------------------------
// "insert_text" for GtkEntry
// ----------------------------------------------------------------------------
+extern "C" {
static void
gtk_insert_text_callback(GtkEditable *editable,
const gchar *new_text,
win->GetEventHandler()->ProcessEvent( event );
}
}
+}
#ifdef __WXGTK20__
// Implementation of wxTE_AUTO_URL for wxGTK2 by Mart Raudsepp,
+extern "C" {
static void
au_apply_tag_callback(GtkTextBuffer *buffer,
GtkTextTag *tag,
if(tag == gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl"))
g_signal_stop_emission_by_name(buffer, "apply_tag");
}
+}
//-----------------------------------------------------------------------------
// GtkTextCharPredicates for gtk_text_iter_*_find_char
//-----------------------------------------------------------------------------
+extern "C" {
static gboolean
pred_whitespace (gunichar ch, gpointer user_data)
{
return g_unichar_isspace(ch);
}
+}
+extern "C" {
static gboolean
pred_non_whitespace (gunichar ch, gpointer user_data)
{
return !g_unichar_isspace(ch);
}
+}
+extern "C" {
static gboolean
pred_nonpunct (gunichar ch, gpointer user_data)
{
return !g_unichar_ispunct(ch);
}
+}
+extern "C" {
static gboolean
pred_nonpunct_or_slash (gunichar ch, gpointer user_data)
{
return !g_unichar_ispunct(ch) || ch == '/';
}
+}
//-----------------------------------------------------------------------------
// Check for links between s and e and correct tags as necessary
// This function should be made match better while being efficient at one point.
// Most probably with a row of regular expressions.
+extern "C" {
static void
au_check_word( GtkTextIter *s, GtkTextIter *e )
{
GtkTextIter start = *s, end = *e;
GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
-
+
// Get our special link tag
GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
g_signal_handler_unblock(buffer, signal_id);
}
}
+}
+extern "C" {
static void
au_check_range(GtkTextIter *s,
GtkTextIter *range_end)
gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
}
}
+}
//-----------------------------------------------------------------------------
// "insert-text" for GtkTextBuffer
//-----------------------------------------------------------------------------
+extern "C" {
static void
au_insert_text_callback(GtkTextBuffer *buffer,
GtkTextIter *end,
au_check_range(&words_start, &words_end);
}
+}
//-----------------------------------------------------------------------------
// "delete-range" for GtkTextBuffer
//-----------------------------------------------------------------------------
+extern "C" {
static void
au_delete_range_callback(GtkTextBuffer *buffer,
GtkTextIter *start,
au_check_range(start, end);
}
+}
#endif
// "changed"
//-----------------------------------------------------------------------------
+extern "C" {
static void
gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win )
{
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
}
+}
//-----------------------------------------------------------------------------
// "expose_event" from scrolled window and textview
//-----------------------------------------------------------------------------
#ifdef __WXGTK20__
+extern "C" {
static gboolean
gtk_text_exposed_callback( GtkWidget *widget, GdkEventExpose *event, wxTextCtrl *win )
{
return TRUE;
}
+}
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __WXGTK20__
+extern "C" {
static void
gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
{
win->CalculateScrollbar();
}
+}
#endif
// ----------------------------------------------------------------------------
static GtkDrawCallback gs_gtk_text_draw = NULL;
-extern "C"
-void wxgtk_text_draw( GtkWidget *widget, GdkRectangle *rect)
+extern "C" {
+static void wxgtk_text_draw( GtkWidget *widget, GdkRectangle *rect)
{
if ( !wxIsInsideYield )
{
gs_gtk_text_draw(widget, rect);
}
}
+}
#endif // __WXGTK20__
// Insert view into scrolled window
gtk_container_add( GTK_CONTAINER(m_widget), m_text );
- // Global settings which can be overridden by tags, I guess.
- if (HasFlag( wxHSCROLL ) || HasFlag( wxTE_DONTWRAP ))
- gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_NONE );
- else
- gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_WORD );
+ // translate wx wrapping style to GTK+
+ GtkWrapMode wrap;
+ if ( HasFlag( wxTE_DONTWRAP ) )
+ wrap = GTK_WRAP_NONE;
+ else if ( HasFlag( wxTE_CHARWRAP ) )
+ wrap = GTK_WRAP_CHAR;
+ else if ( HasFlag( wxTE_WORDWRAP ) )
+ wrap = GTK_WRAP_WORD;
+ else // HasFlag(wxTE_BESTWRAP) always true as wxTE_BESTWRAP == 0
+ {
+ // GTK_WRAP_WORD_CHAR seems to be new in GTK+ 2.4
+#ifdef __WXGTK24__
+ if ( !gtk_check_version(2,4,0) )
+ {
+ wrap = GTK_WRAP_WORD_CHAR;
+ }
+ else
+#endif
+ wrap = GTK_WRAP_WORD;
+ }
+
+ gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), wrap );
if (!HasFlag(wxNO_BORDER))
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN );
+ gtk_widget_add_events( GTK_WIDGET(m_text), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
+
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-#else
+#else // GTK+ 1
// create our control ...
m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GTK_FILL,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
0, 0);
-#endif
+#endif // GTK+ 2/1
}
else
{
wxString wxTextCtrl::GetValue() const
{
- wxCHECK_MSG( m_text != NULL, wxT(""), wxT("invalid text ctrl") );
+ wxCHECK_MSG( m_text != NULL, wxEmptyString, wxT("invalid text ctrl") );
wxString tmp;
if (m_windowStyle & wxTE_MULTILINE)
if (gtk_text_buffer_get_char_count(m_buffer) != 0)
IgnoreNextTextUpdate();
+ if ( !buffer )
+ {
+ // what else can we do? at least don't crash...
+ return;
+ }
+
gtk_text_buffer_set_text( m_buffer, buffer, strlen(buffer) );
#else
#else
wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
#endif
+ if ( !buffer )
+ {
+ // what else can we do? at least don't crash...
+ return;
+ }
+
gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
#else
if (text)
{
- wxString buf(wxT(""));
+ wxString buf;
long i;
int currentLine = 0;
for (i = 0; currentLine != lineNo && text[i]; i++ )
#else
GtkTextIter line;
gtk_text_buffer_get_iter_at_line(m_buffer,&line,lineNo);
- GtkTextIter end;
- gtk_text_buffer_get_end_iter(m_buffer,&end );
+ GtkTextIter end = line;
+ gtk_text_iter_forward_to_line_end(&end);
gchar *text = gtk_text_buffer_get_text(m_buffer,&line,&end,TRUE);
wxString result(wxGTK_CONV_BACK(text));
g_free(text);
- return result.BeforeFirst(wxT('\n'));
+ return result;
#endif
}
else
{
if ( m_windowStyle & wxTE_MULTILINE )
{
+#ifdef __WXGTK20__
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_offset(m_buffer, &iter, pos);
+ if (gtk_text_iter_is_end(&iter))
+ return false;
+
+ *y = gtk_text_iter_get_line(&iter);
+ *x = gtk_text_iter_get_line_offset(&iter);
+#else
wxString text = GetValue();
// cast to prevent warning. But pos really should've been unsigned.
else
(*x)++;
}
+#endif
}
else // single line control
{
{
if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
+#ifdef __WXGTK20__
+ GtkTextIter iter;
+ if (y >= gtk_text_buffer_get_line_count (m_buffer))
+ return -1;
+
+ gtk_text_buffer_get_iter_at_line(m_buffer, &iter, y);
+ if (x >= gtk_text_iter_get_chars_in_line (&iter))
+ return -1;
+
+ return gtk_text_iter_get_offset(&iter) + x;
+#else
long pos=0;
for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
pos += x;
return pos;
+#endif
}
int wxTextCtrl::GetLineLength(long lineNo) const
{
- wxString str = GetLineText (lineNo);
- return (int) str.Length();
+#ifdef __WXGTK20__
+ if (m_windowStyle & wxTE_MULTILINE)
+ {
+ int last_line = gtk_text_buffer_get_line_count( m_buffer ) - 1;
+ if (lineNo > last_line)
+ return -1;
+
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_line(m_buffer, &iter, lineNo);
+ // get_chars_in_line return includes paragraph delimiters, so need to subtract 1 IF it is not the last line
+ return gtk_text_iter_get_chars_in_line(&iter) - ((lineNo == last_line) ? 0 : 1);
+ }
+ else
+#endif
+ {
+ wxString str = GetLineText (lineNo);
+ return (int) str.Length();
+ }
}
int wxTextCtrl::GetNumberOfLines() const
else
#endif
{
- return (long) GET_EDITABLE_POS(m_text);
+ return (long) GET_EDITABLE_POS(m_text);
}
}
void wxTextCtrl::Clear()
{
- SetValue( wxT("") );
+ SetValue( wxEmptyString );
}
void wxTextCtrl::OnChar( wxKeyEvent &key_event )
// nothing to do
return true;
}
+
#ifdef __WXGTK20__
gint l = gtk_text_buffer_get_char_count( m_buffer );
wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
wxGtkTextApplyTagsFromAttr( m_buffer, attr, &starti, &endi );
-
- return true;
#else
// VERY dirty way to do that - removes the required text and re-adds it
// with styling (FIXME)
gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
gtk_editable_set_position( GTK_EDITABLE(m_text), start );
-#if wxUSE_UNICODE
+ #if wxUSE_UNICODE
wxWX2MBbuf buf = tmp.mbc_str();
const char *txt = buf;
size_t txtlen = strlen(buf);
-#else
+ #else
const char *txt = tmp;
size_t txtlen = tmp.length();
-#endif
+ #endif
// use the attributes from style which are set in it and fall back
// first to the default style and then to the text control default
gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
SetInsertionPoint( old_pos );
#endif
+
return true;
}
- else // singe line
- {
- // cannot do this for GTK+'s Entry widget
- return false;
- }
+
+ // else single line
+ // cannot do this for GTK+'s Entry widget
+ return false;
}
void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
gtk_widget_set_sensitive(m_widget, false);
g_object_ref(m_buffer);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), gtk_text_buffer_new(NULL));
- }
+ }
#else
gtk_text_freeze(GTK_TEXT(m_text));
#endif
projects / wxWidgets.git / blobdiff