/**
* gtk_source_gutter_renderer_get_window_type:
* @renderer: a #GtkSourceGutterRenderer
*
* Get the #GtkTextWindowType associated with the gutter renderer.
*
* Returns: a #GtkTextWindowType
*
**/
GtkTextWindowType
gtk_source_gutter_renderer_get_window_type (GtkSourceGutterRenderer *renderer)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), GTK_TEXT_WINDOW_PRIVATE);
return renderer->priv->window_type;
}
/**
* gtk_source_gutter_renderer_query_tooltip:
* @renderer: a #GtkSourceGutterRenderer.
* @iter: a #GtkTextIter.
* @area: a #GdkRectangle.
* @x: The x position of the tooltip.
* @y: The y position of the tooltip.
* @tooltip: a #GtkTooltip.
*
* Emits the ::query-tooltip signal. This function is called from
* #GtkSourceGutter. Implementations can override the default signal handler
* or can connect to the signal externally.
*
* Returns: %TRUE if the tooltip has been set, %FALSE otherwise
*
**/
gboolean
gtk_source_gutter_renderer_query_tooltip (GtkSourceGutterRenderer *renderer,
GtkTextIter *iter,
GdkRectangle *area,
gint x,
gint y,
GtkTooltip *tooltip)
{
gboolean ret;
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (area != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TOOLTIP (tooltip), FALSE);
ret = FALSE;
g_signal_emit (renderer,
signals[QUERY_TOOLTIP],
0,
iter,
area,
x,
y,
tooltip,
&ret);
return ret;
}
/**
* gtk_source_gutter_renderer_get_alignment_mode:
* @renderer: a #GtkSourceGutterRenderer
*
* Get the alignment mode. The alignment mode describes the manner in which the
* renderer is aligned (see :xalign and :yalign).
*
* Returns: a #GtkSourceGutterRendererAlignmentMode
*
**/
GtkSourceGutterRendererAlignmentMode
gtk_source_gutter_renderer_get_alignment_mode (GtkSourceGutterRenderer *renderer)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), 0);
return renderer->priv->alignment_mode;
}
/**
* gtk_source_gutter_renderer_draw:
* @renderer: a #GtkSourceGutterRenderer
* @cr: the cairo render context
* @background_area: a #GdkRectangle indicating the total area to be drawn
* @cell_area: a #GdkRectangle indicating the area to draw content
* @start: a #GtkTextIter
* @end: a #GtkTextIter
* @state: a #GtkSourceGutterRendererState
*
* Main renderering method. Implementations should implement this method to
* draw onto the cairo context. The @background_area indicates total area of
* the cell (without padding or margin) to be drawn. The @cell_area indicates
* the area where content can be drawn (text, images, etc).
*
* The @state argument indicates the current state of the renderer and should
* be taken into account to properly draw the different possible states
* (cursor, prelit, selected) if appropriate.
*
**/
void
gtk_source_gutter_renderer_draw (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
g_return_if_fail (cr != NULL);
g_return_if_fail (background_area != NULL);
g_return_if_fail (cell_area != NULL);
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (G_OBJECT_GET_CLASS (renderer))->draw)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (
G_OBJECT_GET_CLASS (renderer))->draw (renderer,
cr,
background_area,
cell_area,
start,
end,
state);
}
}
/**
* gtk_source_gutter_renderer_get_view:
* @renderer: a #GtkSourceGutterRenderer
*
* Get the view associated to the gutter renderer
*
* Returns: (transfer none): a #GtkTextView
*
**/
GtkTextView *
gtk_source_gutter_renderer_get_view (GtkSourceGutterRenderer *renderer)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), NULL);
return renderer->priv->view;
}
/**
* gtk_source_gutter_renderer_queue_draw:
* @renderer: a #GtkSourceGutterRenderer
*
* Emits the ::queue-draw signal of the renderer. Call this from an
* implementation to inform that the renderer has changed such that it needs
* to redraw.
*
**/
void
gtk_source_gutter_renderer_queue_draw (GtkSourceGutterRenderer *renderer)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
g_signal_emit (renderer, signals[QUEUE_DRAW], 0);
}
/**
* gtk_source_gutter_renderer_query_activatable:
* @renderer: a #GtkSourceGutterRenderer
* @iter: a #GtkTextIter at the start of the line to be activated
* @area: a #GdkRectangle of the cell area to be activated
* @event: the event that triggered the query
*
* Get whether the renderer is activatable at the location in @event. This is
* called from #GtkSourceGutter to determine whether a renderer is activatable
* using the mouse pointer.
*
* Returns: %TRUE if the renderer can be activated, %FALSE otherwise
*
**/
gboolean
gtk_source_gutter_renderer_query_activatable (GtkSourceGutterRenderer *renderer,
GtkTextIter *iter,
GdkRectangle *area,
GdkEvent *event)
{
gboolean ret;
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (area != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
ret = FALSE;
g_signal_emit (renderer,
signals[QUERY_ACTIVATABLE],
0,
iter,
area,
event,
&ret);
return ret;
}
/**
* gtk_source_gutter_renderer_get_size:
* @renderer: a #GtkSourceGutterRenderer
*
* Get the size of the renderer.
*
* Returns: the size of the renderer.
*
**/
gint
gtk_source_gutter_renderer_get_size (GtkSourceGutterRenderer *renderer)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), 0);
return renderer->priv->size;
}
/**
* gtk_source_gutter_renderer_get_visible:
* @renderer: a #GtkSourceGutterRenderer
*
* Get whether the gutter renderer is visible.
*
* Returns: %TRUE if the renderer is visible, %FALSE otherwise
*
**/
gboolean
gtk_source_gutter_renderer_get_visible (GtkSourceGutterRenderer *renderer)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), FALSE);
return renderer->priv->visible;
}
/**
* gtk_source_gutter_renderer_set_background:
* @renderer: a #GtkSourceGutterRenderer
* @color: (allow-none): a #GdkRGBA or %NULL
*
* Set the background color of the renderer. If @color is set to %NULL, the
* renderer will not have a background color.
*
*/
void
gtk_source_gutter_renderer_set_background (GtkSourceGutterRenderer *renderer,
const GdkRGBA *color)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
set_background_color (renderer, color);
}
/**
* gtk_source_gutter_renderer_set_size:
* @renderer: a #GtkSourceGutterRenderer
* @size: the size
*
* Sets the size of the renderer. A value of -1 specifies that the size
* is to be determined dynamically.
*
**/
void
gtk_source_gutter_renderer_set_size (GtkSourceGutterRenderer *renderer,
gint size)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
set_size (renderer, size);
}
/**
* gtk_source_gutter_renderer_set_alignment_mode:
* @renderer: a #GtkSourceGutterRenderer
* @mode: a #GtkSourceGutterRendererAlignmentMode
*
* Set the alignment mode. The alignment mode describes the manner in which the
* renderer is aligned (see :xalign and :yalign).
*
**/
void
gtk_source_gutter_renderer_set_alignment_mode (GtkSourceGutterRenderer *renderer,
GtkSourceGutterRendererAlignmentMode mode)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
set_alignment_mode (renderer, mode);
}
/**
* gtk_source_gutter_renderer_end:
* @renderer: a #GtkSourceGutterRenderer
*
* Called when drawing a region of lines has ended.
*
**/
void
gtk_source_gutter_renderer_end (GtkSourceGutterRenderer *renderer)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (G_OBJECT_GET_CLASS (renderer))->end)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (G_OBJECT_GET_CLASS (renderer))->end (renderer);
}
}
/**
* gtk_source_gutter_renderer_set_padding:
* @renderer: a #GtkSourceGutterRenderer
* @xpad: the x-padding
* @ypad: the y-padding
*
* Set the padding of the gutter renderer. Both @xpad and @ypad can be
* -1, which means the values will not be changed (this allows changing only
* one of the values).
*
**/
void
gtk_source_gutter_renderer_set_padding (GtkSourceGutterRenderer *renderer,
gint xpad,
gint ypad)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
set_xpad (renderer, xpad);
set_ypad (renderer, ypad);
}
/**
* gtk_source_gutter_renderer_query_data:
* @renderer: a #GtkSourceGutterRenderer.
* @start: a #GtkTextIter.
* @end: a #GtkTextIter.
* @state: a #GtkSourceGutterRendererState.
*
* Emit the ::query-data signal. This function is called to query for data
* just before rendering a cell. This is called from the #GtkSourceGutter.
* Implementations can override the default signal handler or can connect
* a signal handler externally to the ::query-data signal.
*
**/
void
gtk_source_gutter_renderer_query_data (GtkSourceGutterRenderer *renderer,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
g_signal_emit (renderer, signals[QUERY_DATA], 0, start, end, state);
}
/**
* gtk_source_gutter_renderer_get_background:
* @renderer: a #GtkSourceGutterRenderer
* @color: (out caller-allocates) (allow-none): return value for a #GdkRGBA
*
* Get the background color of the renderer.
*
* Returns: %TRUE if the background color is set, %FALSE otherwise
*
**/
gboolean
gtk_source_gutter_renderer_get_background (GtkSourceGutterRenderer *renderer,
GdkRGBA *color)
{
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), FALSE);
if (color)
{
*color = renderer->priv->background_color;
}
return renderer->priv->background_set;
}
/**
* gtk_source_gutter_renderer_activate:
* @renderer: a #GtkSourceGutterRenderer
* @iter: a #GtkTextIter at the start of the line where the renderer is activated
* @area: a #GdkRectangle of the cell area where the renderer is activated
* @event: the event that triggered the activation
*
* Emits the ::activate signal of the renderer. This is called from
* #GtkSourceGutter and should never have to be called manually.
*
*/
void
gtk_source_gutter_renderer_activate (GtkSourceGutterRenderer *renderer,
GtkTextIter *iter,
GdkRectangle *area,
GdkEvent *event)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
g_return_if_fail (iter != NULL);
g_return_if_fail (area != NULL);
g_return_if_fail (event != NULL);
g_signal_emit (renderer, signals[ACTIVATE], 0, iter, area, event);
}
/**
* gtk_source_gutter_renderer_set_visible:
* @renderer: a #GtkSourceGutterRenderer
* @visible: the visibility
*
* Set whether the gutter renderer is visible.
*
**/
void
gtk_source_gutter_renderer_set_visible (GtkSourceGutterRenderer *renderer,
gboolean visible)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (visible != renderer->priv->visible)
{
renderer->priv->visible = visible;
g_object_notify (G_OBJECT (renderer), "visible");
gtk_source_gutter_renderer_queue_draw (renderer);
}
}
/**
* gtk_source_gutter_renderer_get_alignment:
* @renderer: a #GtkSourceGutterRenderer
* @xalign: (out caller-allocates) (allow-none): return location for the x-alignment (can be %NULL)
* @yalign: (out caller-allocates) (allow-none): return location for the y-alignment (can be %NULL)
*
* Get the x-alignment and y-alignment of the gutter renderer.
*
**/
void
gtk_source_gutter_renderer_get_alignment (GtkSourceGutterRenderer *renderer,
gfloat *xalign,
gfloat *yalign)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (xalign)
{
*xalign = renderer->priv->xalign;
}
if (yalign)
{
*yalign = renderer->priv->yalign;
}
}
/**
* gtk_source_gutter_renderer_get_padding:
* @renderer: a #GtkSourceGutterRenderer
* @xpad: (out caller-allocates) (allow-none): return location for the x-padding (can be %NULL)
* @ypad: (out caller-allocates) (allow-none): return location for the y-padding (can be %NULL)
*
* Get the x-padding and y-padding of the gutter renderer.
*
**/
void
gtk_source_gutter_renderer_get_padding (GtkSourceGutterRenderer *renderer,
gint *xpad,
gint *ypad)
{
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (xpad)
{
*xpad = renderer->priv->xpad;
}
if (ypad)
{
*ypad = renderer->priv->ypad;
}
}
/**
* gtk_source_gutter_insert:
* @gutter: a #GtkSourceGutter.
* @renderer: a gutter renderer (must inherit from #GtkSourceGutterRenderer).
* @position: the renderer position.
*
* Insert @renderer into the gutter. If @renderer is yet unowned then gutter
* claims its ownership. Otherwise just increases renderer's reference count.
* @renderer cannot be already inserted to another gutter.
*
* Returns: %TRUE if operation succeeded. Otherwise %FALSE.
*
* Since: 3.0
*
**/
gboolean
gtk_source_gutter_insert (GtkSourceGutter *gutter,
GtkSourceGutterRenderer *renderer,
gint position)
{
Renderer* internal_renderer;
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER (gutter), FALSE);
g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer), FALSE);
g_return_val_if_fail (gtk_source_gutter_renderer_get_view (renderer) == NULL, FALSE);
g_return_val_if_fail (gtk_source_gutter_renderer_get_window_type (renderer) == GTK_TEXT_WINDOW_PRIVATE, FALSE);
internal_renderer = renderer_new (gutter, renderer, position);
append_renderer (gutter, internal_renderer);
return TRUE;
}
/**
* gtk_source_gutter_renderer_set_alignment:
* @renderer: a #GtkSourceGutterRenderer
* @xalign: the x-alignment
* @yalign: the y-alignment
*
* Set the alignment of the gutter renderer. Both @xalign and @yalign can be
* -1, which means the values will not be changed (this allows changing only
* one of the values).
*
**/
void
gtk_source_gutter_renderer_set_alignment (GtkSourceGutterRenderer *renderer,
gfloat xalign,
gfloat yalign)
{
gboolean changed_x;
gboolean changed_y;
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
changed_x = set_xalign (renderer, xalign, FALSE);
changed_y = set_yalign (renderer, yalign, FALSE);
if (changed_x || changed_y)
{
gtk_source_gutter_renderer_queue_draw (renderer);
}
}
/**
* gtk_source_gutter_remove:
* @gutter: a #GtkSourceGutter.
* @renderer: a #GtkSourceGutterRenderer.
*
* Removes @renderer from @gutter.
*
* Since: 2.8
*/
void
gtk_source_gutter_remove (GtkSourceGutter *gutter,
GtkSourceGutterRenderer *renderer)
{
Renderer *ret;
GList *retlist;
g_return_if_fail (GTK_SOURCE_IS_GUTTER (gutter));
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (renderer_find (gutter, renderer, &ret, &retlist))
{
gutter->priv->renderers =
g_list_delete_link (gutter->priv->renderers,
retlist);
update_gutter_size (gutter);
renderer_free (ret);
}
}
/**
* gtk_source_gutter_reorder:
* @gutter: a #GtkSourceGutterRenderer.
* @renderer: a #GtkCellRenderer.
* @position: the new renderer position.
*
* Reorders @renderer in @gutter to new @position.
*
* Since: 2.8
*/
void
gtk_source_gutter_reorder (GtkSourceGutter *gutter,
GtkSourceGutterRenderer *renderer,
gint position)
{
Renderer *ret;
GList *retlist;
g_return_if_fail (GTK_SOURCE_IS_GUTTER (gutter));
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
if (renderer_find (gutter, renderer, &ret, &retlist))
{
gutter->priv->renderers =
g_list_delete_link (gutter->priv->renderers,
retlist);
ret->position = position;
append_renderer (gutter, ret);
}
}
void
_gtk_source_gutter_renderer_set_view (GtkSourceGutterRenderer *renderer,
GtkTextView *view,
GtkTextWindowType window_type)
{
GtkTextView *old_view;
g_return_if_fail (GTK_SOURCE_IS_GUTTER_RENDERER (renderer));
g_return_if_fail (view == NULL || GTK_IS_TEXT_VIEW (view));
old_view = renderer->priv->view;
renderer->priv->window_type = window_type;
if (view)
{
renderer->priv->view = g_object_ref (view);
}
else
{
renderer->priv->view = NULL;
}
if (GTK_SOURCE_GUTTER_RENDERER_GET_CLASS (renderer)->change_view)
{
GTK_SOURCE_GUTTER_RENDERER_GET_CLASS (renderer)->change_view (renderer,
old_view);
}
if (old_view)
{
g_object_unref (old_view);
}
g_object_notify (G_OBJECT (renderer), "view");
g_object_notify (G_OBJECT (renderer), "window_type");
}