rpms/gtk3
7
0
Fork 0
Code Issues Pull Requests Releases Activity
8543d20fc1
gtk3/0001-Revert-text-view-add-padding-and-margin.patch

1070 lines
38 KiB
Diff
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

From 3477cf7d5443a5027246b987bb3729f7f6bb5879 Mon Sep 17 00:00:00 2001
From: Adam Williamson <awilliam@redhat.com>
Date: Wed, 26 Aug 2015 12:22:42 -0700
Subject: [PATCH] Revert "text view: add padding and margin"
This reverts commit d1381569fdf2abde1535db1fcff07b3c767d396d.
---
docs/reference/gtk/gtk3-sections.txt | 4 -
gtk/gtktextlayout.c | 17 +-
gtk/gtktextlayout.h | 3 -
gtk/gtktextview.c | 660 +++++++++--------------------------
gtk/gtktextview.h | 10 -
5 files changed, 160 insertions(+), 534 deletions(-)
diff --git a/docs/reference/gtk/gtk3-sections.txt b/docs/reference/gtk/gtk3-sections.txt
index 55e4d49..383840f 100644
--- a/docs/reference/gtk/gtk3-sections.txt
+++ b/docs/reference/gtk/gtk3-sections.txt
@@ -3917,10 +3917,6 @@ gtk_text_view_set_left_margin
gtk_text_view_get_left_margin
gtk_text_view_set_right_margin
gtk_text_view_get_right_margin
-gtk_text_view_set_top_margin
-gtk_text_view_get_top_margin
-gtk_text_view_set_bottom_margin
-gtk_text_view_get_bottom_margin
gtk_text_view_set_indent
gtk_text_view_get_indent
gtk_text_view_set_tabs
diff --git a/gtk/gtktextlayout.c b/gtk/gtktextlayout.c
index ffba509..041f062 100644
--- a/gtk/gtktextlayout.c
+++ b/gtk/gtktextlayout.c
@@ -1310,8 +1310,6 @@ set_para_values (GtkTextLayout *layout,
{
PangoAlignment pango_align = PANGO_ALIGN_LEFT;
PangoWrapMode pango_wrap = PANGO_WRAP_WORD;
- gint h_margin;
- gint h_padding;
switch (base_dir)
{
@@ -1394,16 +1392,14 @@ set_para_values (GtkTextLayout *layout,
break;
}
- h_margin = display->left_margin + display->right_margin;
- h_padding = layout->left_padding + layout->right_padding;
-
if (style->wrap_mode != GTK_WRAP_NONE)
{
- int layout_width = (layout->screen_width - h_margin - h_padding);
+ int layout_width = (layout->screen_width - display->left_margin - display->right_margin);
pango_layout_set_width (display->layout, layout_width * PANGO_SCALE);
pango_layout_set_wrap (display->layout, pango_wrap);
}
- display->total_width = MAX (layout->screen_width, layout->width) - h_margin - h_padding;
+
+ display->total_width = MAX (layout->screen_width, layout->width) - display->left_margin - display->right_margin;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (style->pg_bg_color)
@@ -2245,8 +2241,6 @@ gtk_text_layout_get_line_display (GtkTextLayout *layout,
PangoDirection base_dir;
GPtrArray *tags;
gboolean initial_toggle_segments;
- gint h_margin;
- gint h_padding;
g_return_val_if_fail (line != NULL, NULL);
@@ -2556,11 +2550,6 @@ gtk_text_layout_get_line_display (GtkTextLayout *layout,
text_pixel_width = PIXEL_BOUND (extents.width);
display->width = text_pixel_width + display->left_margin + display->right_margin;
-
- h_margin = display->left_margin + display->right_margin;
- h_padding = layout->left_padding + layout->right_padding;
-
- display->width = text_pixel_width + h_margin + h_padding;
display->height += PANGO_PIXELS (extents.height);
/* If we aren't wrapping, we need to do the alignment of each
diff --git a/gtk/gtktextlayout.h b/gtk/gtktextlayout.h
index 2565b64..d113f88 100644
--- a/gtk/gtktextlayout.h
+++ b/gtk/gtktextlayout.h
@@ -132,9 +132,6 @@ struct _GtkTextLayout
GtkTextBuffer *buffer;
- gint left_padding;
- gint right_padding;
-
/* Default style used if no tags override it */
GtkTextAttributes *default_style;
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 3e59314..a1cca95 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -156,18 +156,9 @@ struct _GtkTextViewPrivate
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
- /* X offset between widget coordinates and buffer coordinates
- * taking left_padding in account
- */
- gint xoffset;
-
- /* Y offset between widget coordinates and buffer coordinates
- * taking top_padding and top_margin in account
- */
+ gint xoffset; /* Offsets between widget coordinates and buffer coordinates */
gint yoffset;
-
- /* Width and height of the buffer */
- gint width;
+ gint width; /* Width and height of the buffer */
gint height;
/* This is used to monitor the overall size request
@@ -223,20 +214,8 @@ struct _GtkTextViewPrivate
gint pixels_inside_wrap;
GtkWrapMode wrap_mode;
GtkJustification justify;
-
gint left_margin;
gint right_margin;
- gint top_margin;
- gint bottom_margin;
- gint left_padding;
- gint right_padding;
- gint top_padding;
- gint bottom_padding;
- gint top_border;
- gint bottom_border;
- gint left_border;
- gint right_border;
-
gint indent;
gint64 handle_place_time;
PangoTabArray *tabs;
@@ -320,8 +299,6 @@ enum
PROP_JUSTIFICATION,
PROP_LEFT_MARGIN,
PROP_RIGHT_MARGIN,
- PROP_TOP_MARGIN,
- PROP_BOTTOM_MARGIN,
PROP_INDENT,
PROP_TABS,
PROP_CURSOR_VISIBLE,
@@ -810,19 +787,7 @@ gtk_text_view_class_init (GtkTextViewClass *klass)
GTK_TYPE_JUSTIFICATION,
GTK_JUSTIFY_LEFT,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
-
- /**
- * GtkTextView:left-margin:
- *
- * The default left margin for text in the text view.
- * Tags in the buffer may override the default.
- *
- * Note that this property is confusingly named. In CSS terms,
- * the value set here is padding, and it is applied in addition
- * to the padding from the theme.
- *
- * Don't confuse this property with #GtkWidget:margin-left.
- */
+
g_object_class_install_property (gobject_class,
PROP_LEFT_MARGIN,
g_param_spec_int ("left-margin",
@@ -831,18 +796,6 @@ gtk_text_view_class_init (GtkTextViewClass *klass)
0, G_MAXINT, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
- /**
- * GtkTextView:right-margin:
- *
- * The default right margin for text in the text view.
- * Tags in the buffer may override the default.
- *
- * Note that this property is confusingly named. In CSS terms,
- * the value set here is padding, and it is applied in addition
- * to the padding from the theme.
- *
- * Don't confuse this property with #GtkWidget:margin-right.
- */
g_object_class_install_property (gobject_class,
PROP_RIGHT_MARGIN,
g_param_spec_int ("right-margin",
@@ -851,48 +804,6 @@ gtk_text_view_class_init (GtkTextViewClass *klass)
0, G_MAXINT, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
- /**
- * GtkTextView:top-margin:
- *
- * The top margin for text in the text view.
- *
- * Note that this property is confusingly named. In CSS terms,
- * the value set here is padding, and it is applied in addition
- * to the padding from the theme.
- *
- * Don't confuse this property with #GtkWidget:margin-top.
- *
- * Since: 3.18
- */
- g_object_class_install_property (gobject_class,
- PROP_TOP_MARGIN,
- g_param_spec_int ("top-margin",
- P_("Top Margin"),
- P_("Height of the top margin in pixels"),
- 0, G_MAXINT, 0,
- GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
-
- /**
- * GtkTextView:bottom-margin:
- *
- * The bottom margin for text in the text view.
- *
- * Note that this property is confusingly named. In CSS terms,
- * the value set here is padding, and it is applied in addition
- * to the padding from the theme.
- *
- * Don't confuse this property with #GtkWidget:margin-bottom.
- *
- * Since: 3.18
- */
- g_object_class_install_property (gobject_class,
- PROP_BOTTOM_MARGIN,
- g_param_spec_int ("bottom-margin",
- P_("Bottom Margin"),
- P_("Height of the bottom margin in pixels"),
- 0, G_MAXINT, 0,
- GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
-
g_object_class_install_property (gobject_class,
PROP_INDENT,
g_param_spec_int ("indent",
@@ -1657,6 +1568,8 @@ gtk_text_view_init (GtkTextView *text_view)
priv->pixels_below_lines = 0;
priv->pixels_inside_wrap = 0;
priv->justify = GTK_JUSTIFY_LEFT;
+ priv->left_margin = 0;
+ priv->right_margin = 0;
priv->indent = 0;
priv->tabs = NULL;
priv->editable = TRUE;
@@ -2173,46 +2086,51 @@ gtk_text_view_get_line_at_y (GtkTextView *text_view,
line_top);
}
-/* Same as gtk_text_view_scroll_to_iter but deal with
- * (top_margin / top_padding) and (bottom_margin / bottom_padding).
- * When with_border == TRUE and you scroll on the edges,
- * all borders are shown for the corresponding edge.
- * When with_border == FALSE, only left margin and right_margin
- * can be seen because they can be can be overwritten by tags.
- */
-static gboolean
-_gtk_text_view_scroll_to_iter (GtkTextView *text_view,
- GtkTextIter *iter,
- gdouble within_margin,
- gboolean use_align,
- gdouble xalign,
- gdouble yalign,
- gboolean with_border)
+/**
+ * gtk_text_view_scroll_to_iter:
+ * @text_view: a #GtkTextView
+ * @iter: a #GtkTextIter
+ * @within_margin: margin as a [0.0,0.5) fraction of screen size
+ * @use_align: whether to use alignment arguments (if %FALSE,
+ * just get the mark onscreen)
+ * @xalign: horizontal alignment of mark within visible area
+ * @yalign: vertical alignment of mark within visible area
+ *
+ * Scrolls @text_view so that @iter is on the screen in the position
+ * indicated by @xalign and @yalign. An alignment of 0.0 indicates
+ * left or top, 1.0 indicates right or bottom, 0.5 means center.
+ * If @use_align is %FALSE, the text scrolls the minimal distance to
+ * get the mark onscreen, possibly not scrolling at all. The effective
+ * screen for purposes of this function is reduced by a margin of size
+ * @within_margin.
+ *
+ * Note that this function uses the currently-computed height of the
+ * lines in the text buffer. Line heights are computed in an idle
+ * handler; so this function may not have the desired effect if it’s
+ * called before the height computations. To avoid oddness, consider
+ * using gtk_text_view_scroll_to_mark() which saves a point to be
+ * scrolled to after line validation.
+ *
+ * Returns: %TRUE if scrolling occurred
+ **/
+gboolean
+gtk_text_view_scroll_to_iter (GtkTextView *text_view,
+ GtkTextIter *iter,
+ gdouble within_margin,
+ gboolean use_align,
+ gdouble xalign,
+ gdouble yalign)
{
- GtkTextViewPrivate *priv = text_view->priv;
- GtkWidget *widget;
-
- GdkRectangle cursor;
- gint cursor_bottom;
- gint cursor_right;
-
+ GdkRectangle rect;
GdkRectangle screen;
- GdkRectangle screen_dest;
-
- gint screen_inner_left;
- gint screen_inner_right;
- gint screen_inner_top;
- gint screen_inner_bottom;
-
- gint border_xoffset = 0;
- gint border_yoffset = 0;
- gint within_margin_xoffset;
- gint within_margin_yoffset;
-
- gint buffer_bottom;
- gint buffer_right;
-
+ gint screen_bottom;
+ gint screen_right;
+ gint scroll_dest;
+ GtkWidget *widget;
gboolean retval = FALSE;
+ gint scroll_inc;
+ gint screen_xoffset, screen_yoffset;
+ gint current_x_scroll, current_y_scroll;
/* FIXME why don't we do the validate-at-scroll-destination thing
* from flush_scroll in this function? I think it wasn't done before
@@ -2229,211 +2147,130 @@ _gtk_text_view_scroll_to_iter (GtkTextView *text_view,
DV(g_print(G_STRLOC"\n"));
- gtk_text_layout_get_iter_location (priv->layout,
+ gtk_text_layout_get_iter_location (text_view->priv->layout,
iter,
- &cursor);
-
- DV (g_print (" target cursor %d,%d %d x %d\n", cursor.x, cursor.y, cursor.width, cursor.height));
-
- /* In each direction, *_border are the addition of *_padding and *_margin
- *
- * Vadjustment value:
- * (-priv->top_border) [top padding][top margin] (0) [text][bottom margin][bottom padding]
- *
- * Hadjustment value:
- * (-priv->left_padding) [left padding] (0) [left margin][text][right margin][right padding]
- *
- * Buffer coordinates:
- * on x: (0) [left margin][text][right margin]
- * on y: (0) [text]
- *
- * left margin and right margin are part of the x buffer coordinate
- * because they are part of the pango layout so that they can be
- * overwritten by tags.
- *
- * Canvas coordinates:
- * (the canvas is the virtual window where the content of the buffer is drawn )
- *
- * on x: (-priv->left_padding) [left padding] (0) [left margin][text][right margin][right padding]
- * on y: (-priv->top_border) [top margin][top padding] (0) [text][bottom margin][bottom padding]
- *
- * (priv->xoffset, priv->yoffset) is the origin of the view (visible part of the canvas)
- * in canvas coordinates.
- * As you can see, canvas coordinates and buffer coordinates are compatible but the canvas
- * can be larger than the buffer depending of the border size.
- */
+ &rect);
- cursor_bottom = cursor.y + cursor.height;
- cursor_right = cursor.x + cursor.width;
+ DV (g_print (" target rect %d,%d %d x %d\n", rect.x, rect.y, rect.width, rect.height));
+
+ current_x_scroll = text_view->priv->xoffset;
+ current_y_scroll = text_view->priv->yoffset;
- /* Current position of the view in canvas coordinates */
- screen.x = priv->xoffset;
- screen.y = priv->yoffset;
+ screen.x = current_x_scroll;
+ screen.y = current_y_scroll;
screen.width = SCREEN_WIDTH (widget);
screen.height = SCREEN_HEIGHT (widget);
-
- within_margin_xoffset = screen.width * within_margin;
- within_margin_yoffset = screen.height * within_margin;
-
- screen_inner_left = screen.x + within_margin_xoffset;
- screen_inner_top = screen.y + within_margin_yoffset;
- screen_inner_right = screen.x + screen.width - within_margin_xoffset;
- screen_inner_bottom = screen.y + screen.width - within_margin_yoffset;
-
- buffer_bottom = priv->height - priv->bottom_border;
- buffer_right = priv->width - priv->right_margin;
-
- screen_dest.x = screen.x;
- screen_dest.y = screen.y;
- screen_dest.width = screen.width - within_margin_xoffset * 2;
- screen_dest.height = screen.height - within_margin_yoffset * 2;
-
- /* Minimum authorised size check */
- if (screen_dest.width < 1)
- screen_dest.width = 1;
- if (screen_dest.height < 1)
- screen_dest.height = 1;
-
+
+ screen_xoffset = screen.width * within_margin;
+ screen_yoffset = screen.height * within_margin;
+
+ screen.x += screen_xoffset;
+ screen.y += screen_yoffset;
+ screen.width -= screen_xoffset * 2;
+ screen.height -= screen_yoffset * 2;
+
+ /* paranoia check */
+ if (screen.width < 1)
+ screen.width = 1;
+ if (screen.height < 1)
+ screen.height = 1;
+
+ /* The -1 here ensures that we leave enough space to draw the cursor
+ * when this function is used for horizontal scrolling.
+ */
+ screen_right = screen.x + screen.width - 1;
+ screen_bottom = screen.y + screen.height;
+
/* The alignment affects the point in the target character that we
* choose to align. If we're doing right/bottom alignment, we align
* the right/bottom edge of the character the mark is at; if we're
* doing left/top we align the left/top edge of the character; if
* we're doing center alignment we align the center of the
* character.
- *
- * The differents cases handle on each direction:
- * 1. cursor outside of the inner area define by within_margin
- * 2. if use_align == TRUE, alignment with xalign and yalign
- * 3. scrolling on the edges dependent of with_border
*/
-
+
/* Vertical scroll */
- if (use_align)
- {
- gint cursor_y_alignment_offset;
- cursor_y_alignment_offset = (cursor.height * yalign) - (screen_dest.height * yalign);
- screen_dest.y = cursor.y + cursor_y_alignment_offset - within_margin_yoffset;
+ scroll_inc = 0;
+ scroll_dest = current_y_scroll;
+
+ if (use_align)
+ {
+ scroll_dest = rect.y + (rect.height * yalign) - (screen.height * yalign);
+
+ /* if scroll_dest < screen.y, we move a negative increment (up),
+ * else a positive increment (down)
+ */
+ scroll_inc = scroll_dest - screen.y + screen_yoffset;
}
else
{
- /* move minimum to get onscreen, showing the
- * top_border or bottom_border when necessary
- */
- if (cursor.y < screen_inner_top)
+ /* move minimum to get onscreen */
+ if (rect.y < screen.y)
{
- if (cursor.y == 0)
- border_yoffset = (with_border) ? priv->top_padding : 0;
-
- screen_dest.y = cursor.y - MAX (within_margin_yoffset, border_yoffset);
+ scroll_dest = rect.y;
+ scroll_inc = scroll_dest - screen.y - screen_yoffset;
}
- else if (cursor_bottom > screen_inner_bottom)
+ else if ((rect.y + rect.height) > screen_bottom)
{
- if (cursor_bottom == buffer_bottom)
- border_yoffset = (with_border) ? priv->bottom_padding : 0;
-
- screen_dest.y = cursor_bottom - screen_dest.height +
- MAX (within_margin_yoffset, border_yoffset);
+ scroll_dest = rect.y + rect.height;
+ scroll_inc = scroll_dest - screen_bottom + screen_yoffset;
}
- }
-
- if (screen_dest.y != screen.y)
+ }
+
+ if (scroll_inc != 0)
{
- gtk_adjustment_animate_to_value (priv->vadjustment, screen_dest.y);
+ gtk_adjustment_animate_to_value (text_view->priv->vadjustment,
+ current_y_scroll + scroll_inc);
- DV (g_print (" vert increment %d\n", screen_dest.y - screen.y));
+ DV (g_print (" vert increment %d\n", scroll_inc));
}
/* Horizontal scroll */
-
+
+ scroll_inc = 0;
+ scroll_dest = current_x_scroll;
+
if (use_align)
- {
- gint cursor_x_alignment_offset;
+ {
+ scroll_dest = rect.x + (rect.width * xalign) - (screen.width * xalign);
- cursor_x_alignment_offset = (cursor.width * xalign) - (screen_dest.width * xalign);
- screen_dest.x = cursor.x + cursor_x_alignment_offset - within_margin_xoffset;
+ /* if scroll_dest < screen.y, we move a negative increment (left),
+ * else a positive increment (right)
+ */
+ scroll_inc = scroll_dest - screen.x + screen_xoffset;
}
else
{
- /* move minimum to get onscreen, showing the
- * left_border or right_border when necessary
- */
- if (cursor.x < screen_inner_left)
+ /* move minimum to get onscreen */
+ if (rect.x < screen.x)
{
- if (cursor.x == priv->left_margin)
- border_xoffset = (with_border) ? 0 : priv->left_padding;
-
- screen_dest.x = cursor.x - MAX (within_margin_xoffset, border_xoffset);
+ scroll_dest = rect.x;
+ scroll_inc = scroll_dest - screen.x - screen_xoffset;
}
- else if (cursor_right > screen_inner_right)
+ else if ((rect.x + rect.width) > screen_right)
{
- if (cursor.x == buffer_right)
- border_xoffset = (with_border) ? priv->left_border : priv->left_padding;
-
- screen_dest.x = cursor_right - screen_dest.width +
- MAX (within_margin_xoffset, border_xoffset);
+ scroll_dest = rect.x + rect.width;
+ scroll_inc = scroll_dest - screen_right + screen_xoffset;
}
}
-
- if (screen_dest.x != screen.x)
+
+ if (scroll_inc != 0)
{
- gtk_adjustment_animate_to_value (priv->hadjustment, screen_dest.x);
+ gtk_adjustment_animate_to_value (text_view->priv->hadjustment,
+ current_x_scroll + scroll_inc);
- DV (g_print (" horiz increment %d\n", screen_dest.x - screen.x));
+ DV (g_print (" horiz increment %d\n", scroll_inc));
}
-
- retval = (screen.y != gtk_adjustment_get_value (priv->vadjustment))
- || (screen.x != gtk_adjustment_get_value (priv->hadjustment));
+
+ retval = (current_y_scroll != gtk_adjustment_get_value (text_view->priv->vadjustment))
+ || (current_x_scroll != gtk_adjustment_get_value (text_view->priv->hadjustment));
DV(g_print (">%s ("G_STRLOC")\n", retval ? "Actually scrolled" : "Didn't end up scrolling"));
return retval;
}
-/**
- * gtk_text_view_scroll_to_iter:
- * @text_view: a #GtkTextView
- * @iter: a #GtkTextIter
- * @within_margin: margin as a [0.0,0.5) fraction of screen size
- * @use_align: whether to use alignment arguments (if %FALSE,
- * just get the mark onscreen)
- * @xalign: horizontal alignment of mark within visible area
- * @yalign: vertical alignment of mark within visible area
- *
- * Scrolls @text_view so that @iter is on the screen in the position
- * indicated by @xalign and @yalign. An alignment of 0.0 indicates
- * left or top, 1.0 indicates right or bottom, 0.5 means center.
- * If @use_align is %FALSE, the text scrolls the minimal distance to
- * get the mark onscreen, possibly not scrolling at all. The effective
- * screen for purposes of this function is reduced by a margin of size
- * @within_margin.
- *
- * Note that this function uses the currently-computed height of the
- * lines in the text buffer. Line heights are computed in an idle
- * handler; so this function may not have the desired effect if it’s
- * called before the height computations. To avoid oddness, consider
- * using gtk_text_view_scroll_to_mark() which saves a point to be
- * scrolled to after line validation.
- *
- * Returns: %TRUE if scrolling occurred
- **/
-gboolean
-gtk_text_view_scroll_to_iter (GtkTextView *text_view,
- GtkTextIter *iter,
- gdouble within_margin,
- gboolean use_align,
- gdouble xalign,
- gdouble yalign)
-{
- return _gtk_text_view_scroll_to_iter (text_view,
- iter,
- within_margin,
- use_align,
- xalign,
- yalign,
- FALSE);
-}
-
static void
free_pending_scroll (GtkTextPendingScroll *scroll)
{
@@ -2532,13 +2369,12 @@ gtk_text_view_flush_scroll (GtkTextView *text_view)
/* Ensure we have updated width/height */
gtk_text_view_update_adjustments (text_view);
- retval = _gtk_text_view_scroll_to_iter (text_view,
- &iter,
- scroll->within_margin,
- scroll->use_align,
- scroll->xalign,
- scroll->yalign,
- TRUE);
+ retval = gtk_text_view_scroll_to_iter (text_view,
+ &iter,
+ scroll->within_margin,
+ scroll->use_align,
+ scroll->xalign,
+ scroll->yalign);
if (text_view->priv->text_handle)
gtk_text_view_update_handles (text_view,
@@ -2564,7 +2400,6 @@ gtk_text_view_update_adjustments (GtkTextView *text_view)
/* Make room for the cursor after the last character in the widest line */
width += SPACE_FOR_CURSOR;
- height += priv->top_border + priv->bottom_border;
if (priv->width != width || priv->height != height)
{
@@ -3115,25 +2950,23 @@ gtk_text_view_get_justification (GtkTextView *text_view)
* gtk_text_view_set_left_margin:
* @text_view: a #GtkTextView
* @left_margin: left margin in pixels
- *
+ *
* Sets the default left margin for text in @text_view.
* Tags in the buffer may override the default.
- *
- * Note that this function is confusingly named.
- * In CSS terms, the value set here is padding.
- */
+ **/
void
gtk_text_view_set_left_margin (GtkTextView *text_view,
gint left_margin)
{
- GtkTextViewPrivate *priv = text_view->priv;
+ GtkTextViewPrivate *priv;
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
+ priv = text_view->priv;
+
if (priv->left_margin != left_margin)
{
priv->left_margin = left_margin;
- priv->left_border = left_margin + priv->left_padding;
if (priv->layout && priv->layout->default_style)
{
@@ -3148,12 +2981,12 @@ gtk_text_view_set_left_margin (GtkTextView *text_view,
/**
* gtk_text_view_get_left_margin:
* @text_view: a #GtkTextView
- *
+ *
* Gets the default left margin size of paragraphs in the @text_view.
* Tags in the buffer may override the default.
- *
+ *
* Returns: left margin in pixels
- */
+ **/
gint
gtk_text_view_get_left_margin (GtkTextView *text_view)
{
@@ -3169,10 +3002,7 @@ gtk_text_view_get_left_margin (GtkTextView *text_view)
*
* Sets the default right margin for text in the text view.
* Tags in the buffer may override the default.
- *
- * Note that this function is confusingly named.
- * In CSS terms, the value set here is padding.
- */
+ **/
void
gtk_text_view_set_right_margin (GtkTextView *text_view,
gint right_margin)
@@ -3184,7 +3014,6 @@ gtk_text_view_set_right_margin (GtkTextView *text_view,
if (priv->right_margin != right_margin)
{
priv->right_margin = right_margin;
- priv->right_border = right_margin + priv->right_padding;
if (priv->layout && priv->layout->default_style)
{
@@ -3199,12 +3028,12 @@ gtk_text_view_set_right_margin (GtkTextView *text_view,
/**
* gtk_text_view_get_right_margin:
* @text_view: a #GtkTextView
- *
+ *
* Gets the default right margin for text in @text_view. Tags
* in the buffer may override the default.
- *
+ *
* Returns: right margin in pixels
- */
+ **/
gint
gtk_text_view_get_right_margin (GtkTextView *text_view)
{
@@ -3214,110 +3043,6 @@ gtk_text_view_get_right_margin (GtkTextView *text_view)
}
/**
- * gtk_text_view_set_top_margin:
- * @text_view: a #GtkTextView
- * @top_margin: top margin in pixels
- *
- * Sets the top margin for text in @text_view.
- *
- * Note that this function is confusingly named.
- * In CSS terms, the value set here is padding.
- *
- * Since: 3.18
- */
-void
-gtk_text_view_set_top_margin (GtkTextView *text_view,
- gint top_margin)
-{
- GtkTextViewPrivate *priv = text_view->priv;
-
- g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
-
- if (priv->top_margin != top_margin)
- {
- priv->yoffset += priv->top_margin - top_margin;
-
- priv->top_margin = top_margin;
- priv->top_border = top_margin + priv->top_padding;
-
- if (priv->layout && priv->layout->default_style)
- gtk_text_layout_default_style_changed (priv->layout);
-
- gtk_text_view_invalidate (text_view);
-
- g_object_notify (G_OBJECT (text_view), "top-margin");
- }
-}
-
-/**
- * gtk_text_view_get_top_margin:
- * @text_view: a #GtkTextView
- *
- * Gets the top margin for text in the @text_view.
- *
- * Returns: top margin in pixels
- *
- * Since: 3.18
- **/
-gint
-gtk_text_view_get_top_margin (GtkTextView *text_view)
-{
- g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
-
- return text_view->priv->top_margin;
-}
-
-/**
- * gtk_text_view_set_bottom_margin:
- * @text_view: a #GtkTextView
- * @bottom_margin: bottom margin in pixels
- *
- * Sets the bottom margin for text in @text_view.
- *
- * Note that this function is confusingly named.
- * In CSS terms, the value set here is padding.
- *
- * Since: 3.18
- */
-void
-gtk_text_view_set_bottom_margin (GtkTextView *text_view,
- gint bottom_margin)
-{
- GtkTextViewPrivate *priv = text_view->priv;
-
- g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
-
- if (priv->bottom_margin != bottom_margin)
- {
- priv->bottom_margin = bottom_margin;
- priv->bottom_border = bottom_margin + priv->bottom_padding;
-
- if (priv->layout && priv->layout->default_style)
- gtk_text_layout_default_style_changed (priv->layout);
-
- g_object_notify (G_OBJECT (text_view), "bottom-margin");
- }
-}
-
-/**
- * gtk_text_view_get_bottom_margin:
- * @text_view: a #GtkTextView
- *
- * Gets the bottom margin for text in the @text_view.
- *
- * Returns: bottom margin in pixels
- *
- * Since: 3.18
- */
-gint
-gtk_text_view_get_bottom_margin (GtkTextView *text_view)
-{
- g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
-
- return text_view->priv->bottom_margin;
-}
-
-/**
* gtk_text_view_set_indent:
* @text_view: a #GtkTextView
* @indent: indentation in pixels
@@ -3671,14 +3396,6 @@ gtk_text_view_set_property (GObject *object,
gtk_text_view_set_right_margin (text_view, g_value_get_int (value));
break;
- case PROP_TOP_MARGIN:
- gtk_text_view_set_top_margin (text_view, g_value_get_int (value));
- break;
-
- case PROP_BOTTOM_MARGIN:
- gtk_text_view_set_bottom_margin (text_view, g_value_get_int (value));
- break;
-
case PROP_INDENT:
gtk_text_view_set_indent (text_view, g_value_get_int (value));
break;
@@ -3807,14 +3524,6 @@ gtk_text_view_get_property (GObject *object,
g_value_set_int (value, priv->right_margin);
break;
- case PROP_TOP_MARGIN:
- g_value_set_int (value, priv->top_margin);
- break;
-
- case PROP_BOTTOM_MARGIN:
- g_value_set_int (value, priv->bottom_margin);
- break;
-
case PROP_INDENT:
g_value_set_int (value, priv->indent);
break;
@@ -4150,7 +3859,7 @@ gtk_text_view_size_allocate (GtkWidget *widget,
DV(g_print(G_STRLOC"\n"));
_gtk_pixel_cache_set_extra_size (priv->pixel_cache, 64,
- allocation->height / 2 + priv->top_border);
+ allocation->height / 2);
gtk_widget_get_allocation (widget, &widget_allocation);
size_changed =
@@ -4532,7 +4241,7 @@ changed_handler (GtkTextLayout *layout,
gtk_text_layout_get_line_yrange (layout, &first, &new_first_para_top, NULL);
- old_first_para_top = priv->yoffset - priv->first_para_pixels + priv->top_border;
+ old_first_para_top = priv->yoffset - priv->first_para_pixels;
if (new_first_para_top != old_first_para_top)
{
@@ -4715,52 +4424,6 @@ gtk_text_view_unmap (GtkWidget *widget)
}
static void
-text_window_set_padding (GtkTextView *text_view,
- GtkStyleContext *style_context)
-{
- GtkTextViewPrivate *priv;
- GtkStateFlags state;
- GtkBorder padding;
-
- priv = text_view->priv;
-
- gtk_style_context_save (style_context);
- gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_VIEW);
-
- state = gtk_widget_get_state_flags (GTK_WIDGET (text_view));
- gtk_style_context_get_padding (style_context, state, &padding);
-
- gtk_style_context_restore (style_context);
-
- if (padding.left != priv->left_padding ||
- padding.right != priv->right_padding ||
- padding.top != priv->top_padding ||
- padding.bottom != priv->bottom_padding)
- {
- priv->xoffset += priv->left_padding - padding.left;
- priv->yoffset += priv->top_padding - padding.top;
-
- priv->left_padding = padding.left;
- priv->right_padding = padding.right;
- priv->top_padding = padding.top;
- priv->bottom_padding = padding.bottom;
-
- priv->top_border = padding.top + priv->top_margin;
- priv->bottom_border = padding.bottom + priv->bottom_margin;
- priv->left_border = padding.left + priv->left_margin;
- priv->right_border = padding.right + priv->right_margin;
-
- if (priv->layout && priv->layout->default_style)
- {
- priv->layout->right_padding = priv->right_padding;
- priv->layout->left_padding = priv->left_padding;
-
- gtk_text_layout_default_style_changed (priv->layout);
- }
- }
-}
-
-static void
gtk_text_view_style_updated (GtkWidget *widget)
{
static GtkBitmask *affects_font = NULL;
@@ -5731,8 +5394,8 @@ gtk_text_view_paint (GtkWidget *widget,
priv = text_view->priv;
g_return_if_fail (priv->layout != NULL);
- g_return_if_fail (priv->xoffset >= - priv->left_padding);
- g_return_if_fail (priv->yoffset >= - priv->top_border);
+ g_return_if_fail (priv->xoffset >= 0);
+ g_return_if_fail (priv->yoffset >= 0);
while (priv->first_validate_idle != 0)
{
@@ -5843,8 +5506,6 @@ gtk_text_view_draw (GtkWidget *widget,
context = gtk_widget_get_style_context (widget);
- text_window_set_padding (GTK_TEXT_VIEW (widget), context);
-
if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
{
gtk_style_context_save (context);
@@ -7874,12 +7535,8 @@ gtk_text_view_ensure_layout (GtkTextView *text_view)
style->pixels_above_lines = priv->pixels_above_lines;
style->pixels_below_lines = priv->pixels_below_lines;
style->pixels_inside_wrap = priv->pixels_inside_wrap;
-
style->left_margin = priv->left_margin;
style->right_margin = priv->right_margin;
- priv->layout->right_padding = priv->right_padding;
- priv->layout->left_padding = priv->left_padding;
-
style->indent = priv->indent;
style->tabs = priv->tabs ? pango_tab_array_copy (priv->tabs) : NULL;
@@ -8713,8 +8370,8 @@ gtk_text_view_value_changed (GtkAdjustment *adjustment,
if (adjustment == priv->hadjustment)
{
- dx = priv->xoffset - gtk_adjustment_get_value (adjustment);
- priv->xoffset = gtk_adjustment_get_value (adjustment) - priv->left_padding;
+ dx = priv->xoffset - (gint)gtk_adjustment_get_value (adjustment);
+ priv->xoffset = gtk_adjustment_get_value (adjustment);
/* If the change is due to a size change we need
* to invalidate the entire text window because there might be
@@ -8730,8 +8387,8 @@ gtk_text_view_value_changed (GtkAdjustment *adjustment,
}
else if (adjustment == priv->vadjustment)
{
- dy = priv->yoffset - gtk_adjustment_get_value (adjustment);
- priv->yoffset = gtk_adjustment_get_value (adjustment) - priv->top_border;
+ dy = priv->yoffset - (gint)gtk_adjustment_get_value (adjustment);
+ priv->yoffset = gtk_adjustment_get_value (adjustment);
if (priv->layout)
{
@@ -9719,7 +9376,7 @@ gtk_text_view_get_rendered_rect (GtkTextView *text_view,
window = gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT);
rect->x = gtk_adjustment_get_value (priv->hadjustment) - extra_w;
- rect->y = gtk_adjustment_get_value (priv->vadjustment) - extra_h - priv->top_border;
+ rect->y = gtk_adjustment_get_value (priv->vadjustment) - extra_h;
rect->height = gdk_window_get_height (window) + (extra_h * 2);
rect->width = gdk_window_get_width (window) + (extra_w * 2);
@@ -9748,23 +9405,20 @@ text_window_invalidate_handler (GdkWindow *window,
{
gpointer widget;
GtkTextView *text_view;
- GtkTextViewPrivate *priv;
int x, y;
gdk_window_get_user_data (window, &widget);
text_view = GTK_TEXT_VIEW (widget);
- priv = text_view->priv;
/* Scrolling will invalidate everything in the bin window,
* but we already have it in the cache, so we can ignore that */
- if (priv->in_scroll)
+ if (text_view->priv->in_scroll)
return;
- x = priv->xoffset;
- y = priv->yoffset + priv->top_border;
-
+ x = gtk_adjustment_get_value (text_view->priv->hadjustment);
+ y = gtk_adjustment_get_value (text_view->priv->vadjustment);
cairo_region_translate (region, x, y);
- _gtk_pixel_cache_invalidate (priv->pixel_cache, region);
+ _gtk_pixel_cache_invalidate (text_view->priv->pixel_cache, region);
cairo_region_translate (region, -x, -y);
}
diff --git a/gtk/gtktextview.h b/gtk/gtktextview.h
index 41a54ba..7917044 100644
--- a/gtk/gtktextview.h
+++ b/gtk/gtktextview.h
@@ -405,16 +405,6 @@ void gtk_text_view_set_right_margin (GtkTextView *text_vi
gint right_margin);
GDK_AVAILABLE_IN_ALL
gint gtk_text_view_get_right_margin (GtkTextView *text_view);
-GDK_AVAILABLE_IN_3_18
-void gtk_text_view_set_top_margin (GtkTextView *text_view,
- gint top_margin);
-GDK_AVAILABLE_IN_3_18
-gint gtk_text_view_get_top_margin (GtkTextView *text_view);
-GDK_AVAILABLE_IN_3_18
-void gtk_text_view_set_bottom_margin (GtkTextView *text_view,
- gint bottom_margin);
-GDK_AVAILABLE_IN_3_18
-gint gtk_text_view_get_bottom_margin (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_indent (GtkTextView *text_view,
gint indent);
--
2.5.0
Reference in New Issue View Git Blame Copy Permalink