From 9c0bcdf0943f38153f13821aa6d7c51cfc5d9634 Mon Sep 17 00:00:00 2001 From: Jose Dapena Paz Date: Mon, 12 Mar 2007 09:42:50 +0000 Subject: [PATCH] * Added modest-scroll-text.[ch] * It's a refactorization from ModestRecptView. Now the feature "limit the recpt view to two lines" and "scroll line by line" is in this class. * It inherits from GtkScrolledWindow, and embeds a GtkTextView * Generalized to be able to limit the text view to an arbitrary number of lines (not only 2). * modest-recpt-view.[ch] * Updated to inherit/use the new ModestScrollText class. * modest-mail-header.[ch] * Now all headers use ModestScrollText (and then they're limited all to two lines, in special subject). pmo-trunk-r899 --- src/widgets/Makefile.am | 2 + src/widgets/modest-mail-header-view.c | 13 +- src/widgets/modest-recpt-view.c | 110 +++----------- src/widgets/modest-recpt-view.h | 6 +- src/widgets/modest-scroll-text.c | 269 +++++++++++++++++++++++++++++++++ src/widgets/modest-scroll-text.h | 73 +++++++++ 6 files changed, 372 insertions(+), 101 deletions(-) create mode 100644 src/widgets/modest-scroll-text.c create mode 100644 src/widgets/modest-scroll-text.h diff --git a/src/widgets/Makefile.am b/src/widgets/Makefile.am index a5ffb26..08d11d5 100644 --- a/src/widgets/Makefile.am +++ b/src/widgets/Makefile.am @@ -40,6 +40,8 @@ libmodest_widgets_la_SOURCES= \ modest-msg-view.h \ modest-recpt-view.c \ modest-recpt-view.h \ + modest-scroll-text.c \ + modest-scroll-text.h \ modest-tny-stream-gtkhtml.c \ modest-tny-stream-gtkhtml.h \ modest-window.c \ diff --git a/src/widgets/modest-mail-header-view.c b/src/widgets/modest-mail-header-view.c index 5d2c6d3..d3dc53b 100644 --- a/src/widgets/modest-mail-header-view.c +++ b/src/widgets/modest-mail-header-view.c @@ -77,19 +77,20 @@ add_header (ModestMailHeaderView *widget, const gchar *field, const gchar *value ModestMailHeaderViewPriv *priv = MODEST_MAIL_HEADER_VIEW_GET_PRIVATE (widget); GtkWidget *hbox; GtkWidget *label_field, *label_value; + GtkWidget *scroll_text; + GtkTextBuffer *text_buffer; hbox = gtk_hbox_new (FALSE, 12); label_field = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label_field), field); gtk_misc_set_alignment (GTK_MISC (label_field), 0.0, 0.0); - label_value = gtk_label_new (NULL); - gtk_label_set_text (GTK_LABEL (label_value), value); - gtk_label_set_selectable (GTK_LABEL (label_value), TRUE); - gtk_label_set_line_wrap (GTK_LABEL (label_value), TRUE); - gtk_misc_set_alignment (GTK_MISC (label_value), 0.0, 0.0); + scroll_text = modest_scroll_text_new (NULL, 2); + label_value = (GtkWidget *) modest_scroll_text_get_text_view (MODEST_SCROLL_TEXT (scroll_text)); + text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (label_value)); + gtk_text_buffer_set_text (text_buffer, value, -1); gtk_box_pack_start (GTK_BOX (hbox), label_field, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX (hbox), label_value, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (hbox), scroll_text, TRUE, TRUE, 0); gtk_size_group_add_widget (priv->labels_size_group, label_field); gtk_box_pack_start (GTK_BOX (priv->headers_vbox), hbox, FALSE, FALSE, 0); diff --git a/src/widgets/modest-recpt-view.c b/src/widgets/modest-recpt-view.c index 7e0f246..de48e5b 100644 --- a/src/widgets/modest-recpt-view.c +++ b/src/widgets/modest-recpt-view.c @@ -31,8 +31,7 @@ #include -#include -#include +#include #include #include @@ -49,10 +48,8 @@ typedef struct _ModestRecptViewPriv ModestRecptViewPriv; struct _ModestRecptViewPriv { - GtkWidget *text_view; gboolean button_pressed; gdouble pressed_x, pressed_y; - gint line_height; }; #define MODEST_RECPT_VIEW_GET_PRIVATE(o) \ @@ -77,12 +74,15 @@ modest_recpt_view_new (void) void modest_recpt_view_set_recipients (ModestRecptView *recpt_view, const gchar *recipients) { + const GtkWidget *text_view = NULL; GtkTextBuffer *buffer = NULL; - ModestRecptViewPriv *priv = MODEST_RECPT_VIEW_GET_PRIVATE (recpt_view); - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view)); + text_view = modest_scroll_text_get_text_view (MODEST_SCROLL_TEXT (recpt_view)); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); + gtk_text_buffer_set_text (buffer, recipients, -1); - gtk_widget_queue_resize (GTK_WIDGET (recpt_view)); + if (GTK_WIDGET_REALIZED (recpt_view)) + gtk_widget_queue_resize (GTK_WIDGET (recpt_view)); } @@ -107,6 +107,9 @@ button_release_event (GtkWidget *widget, gpointer user_data) { ModestRecptViewPriv *priv = MODEST_RECPT_VIEW_GET_PRIVATE (MODEST_RECPT_VIEW (user_data)); + const GtkWidget *text_view = NULL; + + text_view = modest_scroll_text_get_text_view (MODEST_SCROLL_TEXT (user_data)); if (event->type != GDK_BUTTON_RELEASE) return TRUE; @@ -120,9 +123,9 @@ button_release_event (GtkWidget *widget, gint buffer_x, buffer_y; int index; GtkTextIter iter; - gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (priv->text_view), GTK_TEXT_WINDOW_WIDGET, + gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view), GTK_TEXT_WINDOW_WIDGET, event->x, event->y, &buffer_x, &buffer_y); - gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (priv->text_view), &iter, buffer_x, buffer_y); + gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, buffer_x, buffer_y); index = gtk_text_iter_get_offset (&iter); if (!gtk_text_iter_is_end (&iter)) { @@ -131,7 +134,7 @@ button_release_event (GtkWidget *widget, GtkTextIter start_iter, end_iter; GtkTextBuffer *buffer; - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view)); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); if (gtk_text_buffer_get_selection_bounds (buffer, &start_iter, &end_iter) && gtk_text_iter_in_range (&iter, &start_iter, &end_iter)) { selected = TRUE; @@ -178,91 +181,14 @@ button_release_event (GtkWidget *widget, } static void -text_view_size_request (GtkWidget *widget, - GtkRequisition *requisition, - gpointer user_data) -{ - GtkTextBuffer *buffer = NULL; - GtkTextIter iter; - int line; - GdkRectangle iter_rectangle; - GtkWidget *text_view = GTK_WIDGET (user_data); - GtkAdjustment *adj = NULL; - ModestRecptViewPriv *priv = MODEST_RECPT_VIEW_GET_PRIVATE (widget); - - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); - - gtk_text_buffer_get_start_iter (buffer, &iter); - gtk_text_view_get_iter_location (GTK_TEXT_VIEW (text_view), &iter, &iter_rectangle); - - for (line = 0; line < 2; line++) { - if (!gtk_text_view_forward_display_line (GTK_TEXT_VIEW (text_view), &iter)) - break; - } - - gtk_text_buffer_get_start_iter (buffer, &iter); - gtk_text_buffer_place_cursor (buffer, &iter); - - gtk_text_view_place_cursor_onscreen (GTK_TEXT_VIEW (text_view)); - - adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (widget)); - if (adj != NULL) { - g_object_set (G_OBJECT (adj), "page-increment", (gdouble) iter_rectangle.height, "step-increment", (gdouble) iter_rectangle.height, NULL); - gtk_adjustment_changed (adj); - } - - if (line > 0) { - requisition->height = iter_rectangle.height * 2; - } else { - requisition->height = iter_rectangle.height; - } - - priv->line_height = iter_rectangle.height; - -} - -static void -view_size_allocate (GtkWidget *widget, - GtkAllocation *allocation, - gpointer user_data) -{ - GtkAdjustment *adj = NULL; - ModestRecptViewPriv *priv = MODEST_RECPT_VIEW_GET_PRIVATE (widget); - - adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (widget)); - if (adj != NULL) { - g_object_set (G_OBJECT (adj), "page-increment", (gdouble) priv->line_height, "step-increment", (gdouble) priv->line_height, NULL); - } - gtk_adjustment_changed (adj); -} - -static void modest_recpt_view_instance_init (GTypeInstance *instance, gpointer g_class) { - ModestRecptViewPriv *priv = MODEST_RECPT_VIEW_GET_PRIVATE (instance); - - gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (instance), NULL); - gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (instance), NULL); - - priv->text_view = gtk_text_view_new (); - - gtk_text_view_set_editable (GTK_TEXT_VIEW (priv->text_view), FALSE); - gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (priv->text_view), GTK_WRAP_WORD_CHAR); - gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (priv->text_view), 0); - gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (priv->text_view), 0); - gtk_text_view_set_justification (GTK_TEXT_VIEW (priv->text_view), GTK_JUSTIFY_LEFT); - gtk_text_view_set_left_margin (GTK_TEXT_VIEW (priv->text_view), 0); - gtk_text_view_set_right_margin (GTK_TEXT_VIEW (priv->text_view), 0); - gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (priv->text_view), FALSE); - - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (instance), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + const GtkTextView *text_view = NULL; - gtk_container_add (GTK_CONTAINER (instance), priv->text_view); + text_view = modest_scroll_text_get_text_view (MODEST_SCROLL_TEXT (instance)); - g_signal_connect (G_OBJECT (instance), "size-request", G_CALLBACK (text_view_size_request), priv->text_view); - g_signal_connect (G_OBJECT (instance), "size-allocate", G_CALLBACK (view_size_allocate), NULL); - g_signal_connect (G_OBJECT (priv->text_view), "button-press-event", G_CALLBACK (button_press_event), instance); - g_signal_connect (G_OBJECT (priv->text_view), "button-release-event", G_CALLBACK (button_release_event), instance); + g_signal_connect (G_OBJECT (text_view), "button-press-event", G_CALLBACK (button_press_event), instance); + g_signal_connect (G_OBJECT (text_view), "button-release-event", G_CALLBACK (button_release_event), instance); return; } @@ -323,7 +249,7 @@ modest_recpt_view_get_type (void) modest_recpt_view_instance_init /* instance_init */ }; - type = g_type_register_static (GTK_TYPE_SCROLLED_WINDOW, + type = g_type_register_static (MODEST_TYPE_SCROLL_TEXT, "ModestRecptView", &info, 0); diff --git a/src/widgets/modest-recpt-view.h b/src/widgets/modest-recpt-view.h index 3810f7a..4a86d61 100644 --- a/src/widgets/modest-recpt-view.h +++ b/src/widgets/modest-recpt-view.h @@ -29,8 +29,8 @@ #ifndef MODEST_RECPT_VIEW_H #define MODEST_RECPT_VIEW_H -#include #include +#include G_BEGIN_DECLS @@ -46,13 +46,13 @@ typedef struct _ModestRecptViewClass ModestRecptViewClass; struct _ModestRecptView { - GtkScrolledWindow parent; + ModestScrollText parent; }; struct _ModestRecptViewClass { - GtkScrolledWindowClass parent_class; + ModestScrollTextClass parent_class; void (*activate) (ModestRecptView *recpt_view, const gchar *address); }; diff --git a/src/widgets/modest-scroll-text.c b/src/widgets/modest-scroll-text.c new file mode 100644 index 0000000..59875fd --- /dev/null +++ b/src/widgets/modest-scroll-text.c @@ -0,0 +1,269 @@ +/* Copyright (c) 2007, Nokia Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the Nokia Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include + +#include + +#include + +#define MODEST_SCROLL_TEXT_DEFAULT_LINE_LIMIT 2 + +static GObjectClass *parent_class = NULL; + +typedef struct _ModestScrollTextPriv ModestScrollTextPriv; + +struct _ModestScrollTextPriv +{ + GtkWidget *text_view; + gint line_height; + guint line_limit; +}; + +#define MODEST_SCROLL_TEXT_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEST_TYPE_SCROLL_TEXT, ModestScrollTextPriv)) + + +/** + * modest_scroll_text_new: + * + * Return value: a new #ModestScrollText instance implemented for Gtk+ + **/ +GtkWidget* +modest_scroll_text_new (GtkTextView *text_view, guint line_limit) +{ + ModestScrollText *self = g_object_new (MODEST_TYPE_SCROLL_TEXT, NULL); + modest_scroll_text_set_line_limit (self, line_limit); + modest_scroll_text_set_text_view (self, text_view); + + return GTK_WIDGET (self); +} + +static void +size_request (GtkWidget *widget, + GtkRequisition *requisition, + gpointer user_data) +{ + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (widget); + const GtkWidget *text_view = NULL; + GtkTextBuffer *buffer = NULL; + GtkTextIter iter; + guint line; + guint line_limit; + GdkRectangle iter_rectangle; + GtkAdjustment *adj = NULL; + + text_view = modest_scroll_text_get_text_view (MODEST_SCROLL_TEXT (widget)); + line_limit = priv->line_limit; + + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); + + /* get the first line and the height of the line */ + gtk_text_buffer_get_start_iter (buffer, &iter); + gtk_text_view_get_iter_location (GTK_TEXT_VIEW (text_view), &iter, &iter_rectangle); + + /* Count lines in text view */ + for (line = 0; line < line_limit; line++) { + if (!gtk_text_view_forward_display_line (GTK_TEXT_VIEW (text_view), &iter)) + break; + } + + /* Put again the cursor in the first character. Also scroll to first line */ + gtk_text_buffer_get_start_iter (buffer, &iter); + gtk_text_buffer_place_cursor (buffer, &iter); + gtk_text_view_place_cursor_onscreen (GTK_TEXT_VIEW (text_view)); + + /* Change the adjustment properties for one line per step behavior */ + adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (widget)); + if (adj != NULL) { + g_object_set (G_OBJECT (adj), "page-increment", (gdouble) iter_rectangle.height, "step-increment", (gdouble) iter_rectangle.height, NULL); + gtk_adjustment_changed (adj); + } + + /* Set the requisition height to the get the limit of lines or less */ + if (line > 0) { + requisition->height = iter_rectangle.height * MAX (line, line_limit); + } else { + requisition->height = iter_rectangle.height; + } + + priv->line_height = iter_rectangle.height; + +} + +static void +size_allocate (GtkWidget *widget, + GtkAllocation *allocation, + gpointer user_data) +{ + GtkAdjustment *adj = NULL; + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (widget); + + adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (widget)); + if (adj != NULL) { + g_object_set (G_OBJECT (adj), "page-increment", (gdouble) priv->line_height, "step-increment", (gdouble) priv->line_height, NULL); + } + gtk_adjustment_changed (adj); +} + +void +modest_scroll_text_set_line_limit (ModestScrollText *scroll_text, guint line_limit) +{ + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (scroll_text); + + if (line_limit == priv->line_limit) + return; + + priv->line_limit = line_limit; + if (GTK_WIDGET_REALIZED (scroll_text)) { + gtk_widget_queue_resize (GTK_WIDGET (scroll_text)); + } +} + +const GtkWidget * +modest_scroll_text_get_text_view (ModestScrollText *scroll_text) +{ + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (scroll_text); + + if (priv->text_view == NULL) + modest_scroll_text_set_text_view (scroll_text, NULL); + + return priv->text_view; +} + +void +modest_scroll_text_set_text_view (ModestScrollText *scroll_text, + GtkTextView *text_view) +{ + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (scroll_text); + + g_return_if_fail (MODEST_IS_SCROLL_TEXT (scroll_text)); + if (text_view == NULL) { + text_view = GTK_TEXT_VIEW(gtk_text_view_new ()); + gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE); + gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE); + } + + if (priv->text_view == GTK_WIDGET(text_view)) + return; + + if (priv->text_view != NULL) { + gtk_container_remove (GTK_CONTAINER(scroll_text), priv->text_view); + priv->text_view = NULL; + } + + priv->text_view = GTK_WIDGET(text_view); + + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (priv->text_view), GTK_WRAP_WORD_CHAR); + gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (priv->text_view), 0); + gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (priv->text_view), 0); + gtk_text_view_set_justification (GTK_TEXT_VIEW (priv->text_view), GTK_JUSTIFY_LEFT); + gtk_text_view_set_left_margin (GTK_TEXT_VIEW (priv->text_view), 0); + gtk_text_view_set_right_margin (GTK_TEXT_VIEW (priv->text_view), 0); + + gtk_container_add (GTK_CONTAINER (scroll_text), priv->text_view); + + if (GTK_WIDGET_REALIZED (scroll_text)) { + gtk_widget_queue_resize (GTK_WIDGET (scroll_text)); + } +} + +static void +modest_scroll_text_instance_init (GTypeInstance *instance, gpointer g_class) +{ + ModestScrollTextPriv *priv = MODEST_SCROLL_TEXT_GET_PRIVATE (instance); + + gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (instance), NULL); + gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (instance), NULL); + + priv->line_limit = MODEST_SCROLL_TEXT_DEFAULT_LINE_LIMIT; + + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (instance), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + + g_signal_connect (G_OBJECT (instance), "size-request", G_CALLBACK (size_request), NULL); + g_signal_connect (G_OBJECT (instance), "size-allocate", G_CALLBACK (size_allocate), NULL); + + return; +} + +static void +modest_scroll_text_finalize (GObject *object) +{ + (*parent_class->finalize) (object); + + return; +} + +static void +modest_scroll_text_class_init (ModestScrollTextClass *klass) +{ + GObjectClass *object_class; + GtkWidgetClass *widget_class; + + parent_class = g_type_class_peek_parent (klass); + object_class = (GObjectClass*) klass; + widget_class = GTK_WIDGET_CLASS (klass); + + object_class->finalize = modest_scroll_text_finalize; + + g_type_class_add_private (object_class, sizeof (ModestScrollTextPriv)); + + return; +} + +GType +modest_scroll_text_get_type (void) +{ + static GType type = 0; + + if (G_UNLIKELY(type == 0)) + { + static const GTypeInfo info = + { + sizeof (ModestScrollTextClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) modest_scroll_text_class_init, /* class_init */ + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (ModestScrollText), + 0, /* n_preallocs */ + modest_scroll_text_instance_init /* instance_init */ + }; + + type = g_type_register_static (GTK_TYPE_SCROLLED_WINDOW, + "ModestScrollText", + &info, 0); + + } + + return type; +} diff --git a/src/widgets/modest-scroll-text.h b/src/widgets/modest-scroll-text.h new file mode 100644 index 0000000..988c26c --- /dev/null +++ b/src/widgets/modest-scroll-text.h @@ -0,0 +1,73 @@ +/* Copyright (c) 2007, Nokia Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the Nokia Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MODEST_SCROLL_TEXT_H +#define MODEST_SCROLL_TEXT_H +#include +#include +#include + +G_BEGIN_DECLS + +#define MODEST_TYPE_SCROLL_TEXT (modest_scroll_text_get_type ()) +#define MODEST_SCROLL_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEST_TYPE_SCROLL_TEXT, ModestScrollText)) +#define MODEST_SCROLL_TEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), MODEST_TYPE_SCROLL_TEXT, ModestScrollTextClass)) +#define MODEST_IS_SCROLL_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEST_TYPE_SCROLL_TEXT)) +#define MODEST_IS_SCROLL_TEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), MODEST_TYPE_SCROLL_TEXT)) +#define MODEST_SCROLL_TEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), MODEST_TYPE_SCROLL_TEXT, ModestScrollTextClass)) + +typedef struct _ModestScrollText ModestScrollText; +typedef struct _ModestScrollTextClass ModestScrollTextClass; + +struct _ModestScrollText +{ + GtkScrolledWindow parent; + +}; + +struct _ModestScrollTextClass +{ + GtkScrolledWindowClass parent_class; +}; + +GType modest_scroll_text_get_type (void); + +GtkWidget* modest_scroll_text_new (GtkTextView *text_view, guint line_limit); + +void modest_scroll_text_set_text_view (ModestScrollText *scroll_text, + GtkTextView *text_view); +void modest_scroll_text_set_line_limit (ModestScrollText *scroll_text, + guint line_limit); + +const GtkWidget *modest_scroll_text_get_text_view (ModestScrollText *scroll_text); +guint modest_scroll_text_get_line_limit (ModestScrollText *scroll_text); + +G_END_DECLS + +#endif -- 1.7.9.5