/** * gimp_ruler_get_unit: * @ruler: a #GimpRuler * * Return value: the unit currently used in the @ruler widget. * * Since: GIMP 2.8 **/ GimpUnit gimp_ruler_get_unit (GimpRuler *ruler) { g_return_val_if_fail (GIMP_IS_RULER (ruler), 0); return GIMP_RULER_GET_PRIVATE (ruler)->unit; }
/** * gimp_ruler_set_range: * @ruler: a #GimpRuler * @lower: the lower limit of the ruler * @upper: the upper limit of the ruler * @max_size: the maximum size of the ruler used when calculating the space to * leave for the text * * This sets the range of the ruler. * * Since: GIMP 2.8 */ void gimp_ruler_set_range (GimpRuler *ruler, gdouble lower, gdouble upper, gdouble max_size) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); g_object_freeze_notify (G_OBJECT (ruler)); if (priv->lower != lower) { priv->lower = lower; g_object_notify (G_OBJECT (ruler), "lower"); } if (priv->upper != upper) { priv->upper = upper; g_object_notify (G_OBJECT (ruler), "upper"); } if (priv->max_size != max_size) { priv->max_size = max_size; g_object_notify (G_OBJECT (ruler), "max-size"); } g_object_thaw_notify (G_OBJECT (ruler)); gtk_widget_queue_draw (GTK_WIDGET (ruler)); }
/** * gimp_ruler_get_position: * @ruler: a #GimpRuler * * Return value: the current position of the @ruler widget. * * Since: GIMP 2.8 **/ gdouble gimp_ruler_get_position (GimpRuler *ruler) { g_return_val_if_fail (GIMP_IS_RULER (ruler), 0.0); return GIMP_RULER_GET_PRIVATE (ruler)->position; }
static void gimp_ruler_queue_pos_redraw (GimpRuler *ruler) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); const GdkRectangle rect = gimp_ruler_get_pos_rect (ruler, priv->position); gtk_widget_queue_draw_area (GTK_WIDGET(ruler), rect.x, rect.y, rect.width, rect.height); if (priv->last_pos_rect.width != 0 || priv->last_pos_rect.height != 0) { gtk_widget_queue_draw_area (GTK_WIDGET(ruler), priv->last_pos_rect.x, priv->last_pos_rect.y, priv->last_pos_rect.width, priv->last_pos_rect.height); priv->last_pos_rect.x = 0; priv->last_pos_rect.y = 0; priv->last_pos_rect.width = 0; priv->last_pos_rect.height = 0; } }
static void gimp_ruler_init (GimpRuler *ruler) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE); priv->orientation = GTK_ORIENTATION_HORIZONTAL; priv->unit = GIMP_UNIT_PIXEL; priv->lower = 0; priv->upper = 0; priv->position = 0; priv->max_size = 0; priv->backing_store = NULL; priv->backing_store_valid = FALSE; priv->last_pos_rect.x = 0; priv->last_pos_rect.y = 0; priv->last_pos_rect.width = 0; priv->last_pos_rect.height = 0; priv->pos_redraw_idle_id = 0; priv->font_scale = DEFAULT_RULER_FONT_SCALE; }
static void gimp_ruler_unrealize (GtkWidget *widget) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); if (priv->backing_store) { cairo_surface_destroy (priv->backing_store); priv->backing_store = NULL; } if (priv->layout) { g_object_unref (priv->layout); priv->layout = NULL; } if (priv->input_window) { gdk_window_destroy (priv->input_window); priv->input_window = NULL; } GTK_WIDGET_CLASS (gimp_ruler_parent_class)->unrealize (widget); }
static void gimp_ruler_realize (GtkWidget *widget) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; GdkWindowAttr attributes; gint attributes_mask; GTK_WIDGET_CLASS (gimp_ruler_parent_class)->realize (widget); gtk_widget_get_allocation (widget, &allocation); attributes.window_type = GDK_WINDOW_CHILD; attributes.x = allocation.x; attributes.y = allocation.y; attributes.width = allocation.width; attributes.height = allocation.height; attributes.wclass = GDK_INPUT_ONLY; attributes.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK); attributes_mask = GDK_WA_X | GDK_WA_Y; priv->input_window = gdk_window_new (gtk_widget_get_window (widget), &attributes, attributes_mask); gdk_window_set_user_data (priv->input_window, ruler); gimp_ruler_make_pixmap (ruler); }
static void gimp_ruler_size_request (GtkWidget *widget, GtkRequisition *requisition) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget); GtkStyle *style = gtk_widget_get_style (widget); PangoLayout *layout; PangoRectangle ink_rect; gint size; layout = gimp_ruler_get_layout (widget, "0123456789"); pango_layout_get_pixel_extents (layout, &ink_rect, NULL); size = 2 + ink_rect.height * 1.7; if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { requisition->width = style->xthickness * 2 + 1; requisition->height = style->ythickness * 2 + size; } else { requisition->width = style->xthickness * 2 + size; requisition->height = style->ythickness * 2 + 1; } }
static void gimp_ruler_size_request (GtkWidget *widget, GtkRequisition *requisition) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget); GtkStyleContext *context = gtk_widget_get_style_context (widget); PangoLayout *layout; PangoRectangle ink_rect; GtkBorder border; gint size; layout = gimp_ruler_get_layout (widget, "0123456789"); pango_layout_get_pixel_extents (layout, &ink_rect, NULL); size = 2 + ink_rect.height * 1.7; gtk_style_context_get_border (context, 0, &border); requisition->width = border.left + border.right; requisition->height = border.top + border.bottom; if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { requisition->width += 1; requisition->height += size; } else { requisition->width += size; requisition->height += 1; } }
static void gimp_ruler_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation widget_allocation; gboolean resized; gtk_widget_get_allocation (widget, &widget_allocation); resized = (widget_allocation.width != allocation->width || widget_allocation.height != allocation->height); gtk_widget_set_allocation (widget, allocation); if (gtk_widget_get_realized (widget)) { gdk_window_move_resize (priv->input_window, allocation->x, allocation->y, allocation->width, allocation->height); if (resized) gimp_ruler_make_pixmap (ruler); } }
static void gimp_ruler_update_position (GimpRuler *ruler, gdouble x, gdouble y) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; gdouble lower; gdouble upper; gtk_widget_get_allocation (GTK_WIDGET (ruler), &allocation); gimp_ruler_get_range (ruler, &lower, &upper, NULL); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { gimp_ruler_set_position (ruler, lower + (upper - lower) * x / allocation.width); } else { gimp_ruler_set_position (ruler, lower + (upper - lower) * y / allocation.height); } }
static gboolean gimp_ruler_expose (GtkWidget *widget, GdkEventExpose *event) { if (gtk_widget_is_drawable (widget)) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; cairo_t *cr; gimp_ruler_draw_ticks (ruler); cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, event->region); cairo_clip (cr); gtk_widget_get_allocation (widget, &allocation); cairo_translate (cr, allocation.x, allocation.y); cairo_set_source_surface (cr, priv->backing_store, 0, 0); cairo_paint (cr); gimp_ruler_draw_pos (ruler); cairo_destroy (cr); } return FALSE; }
static GdkRectangle gimp_ruler_get_pos_rect (GimpRuler *ruler, gdouble position) { GtkWidget *widget = GTK_WIDGET (ruler); GtkStyleContext *context = gtk_widget_get_style_context (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; GtkBorder border; gint width, height; gdouble upper, lower; gdouble increment; GdkRectangle rect = { 0, }; if (! gtk_widget_is_drawable (widget)) return rect; gtk_widget_get_allocation (widget, &allocation); gtk_style_context_get_border (context, 0, &border); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { width = allocation.width; height = allocation.height - (border.top + border.bottom); rect.width = height / 2 + 2; rect.width |= 1; /* make sure it's odd */ rect.height = rect.width / 2 + 1; } else { width = allocation.width - (border.left + border.right); height = allocation.height; rect.height = width / 2 + 2; rect.height |= 1; /* make sure it's odd */ rect.width = rect.height / 2 + 1; } gimp_ruler_get_range (ruler, &lower, &upper, NULL); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { increment = (gdouble) width / (upper - lower); rect.x = ROUND ((position - lower) * increment) + (border.left + border.right - rect.width) / 2 - 1; rect.y = (height + rect.height) / 2 + border.top; } else { increment = (gdouble) height / (upper - lower); rect.x = (width + rect.width) / 2 + border.left; rect.y = ROUND ((position - lower) * increment) + (border.top + border.bottom - rect.height) / 2 - 1; } return rect; }
static void gimp_ruler_unmap (GtkWidget *widget) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget); if (priv->input_window) gdk_window_hide (priv->input_window); GTK_WIDGET_CLASS (parent_class)->unmap (widget); }
static void gimp_ruler_dispose (GObject *object) { GimpRuler *ruler = GIMP_RULER (object); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); while (priv->track_widgets) gimp_ruler_remove_track_widget (ruler, priv->track_widgets->data); G_OBJECT_CLASS (parent_class)->dispose (object); }
static gboolean gimp_ruler_idle_queue_pos_redraw (gpointer data) { GimpRuler *ruler = data; GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); gimp_ruler_queue_pos_redraw (ruler); priv->pos_redraw_idle_id = 0; return G_SOURCE_REMOVE; }
static void gimp_ruler_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GimpRuler *ruler = GIMP_RULER (object); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); switch (prop_id) { case PROP_ORIENTATION: priv->orientation = g_value_get_enum (value); gtk_widget_queue_resize (GTK_WIDGET (ruler)); break; case PROP_UNIT: gimp_ruler_set_unit (ruler, g_value_get_int (value)); break; case PROP_LOWER: gimp_ruler_set_range (ruler, g_value_get_double (value), priv->upper, priv->max_size); break; case PROP_UPPER: gimp_ruler_set_range (ruler, priv->lower, g_value_get_double (value), priv->max_size); break; case PROP_POSITION: gimp_ruler_set_position (ruler, g_value_get_double (value)); break; case PROP_MAX_SIZE: gimp_ruler_set_range (ruler, priv->lower, priv->upper, g_value_get_double (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static PangoLayout * gimp_ruler_get_layout (GtkWidget *widget, const gchar *text) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget); if (priv->layout) { pango_layout_set_text (priv->layout, text, -1); return priv->layout; } priv->layout = gimp_ruler_create_layout (widget, text); return priv->layout; }
static void gimp_ruler_init (GimpRuler *ruler) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE); priv->orientation = GTK_ORIENTATION_HORIZONTAL; priv->unit = GIMP_PIXELS; priv->lower = 0; priv->upper = 0; priv->position = 0; priv->max_size = 0; priv->backing_store = NULL; priv->font_scale = DEFAULT_RULER_FONT_SCALE; }
/** * gimp_ruler_set_position: * @ruler: a #GimpRuler * @position: the position to set the ruler to * * This sets the position of the ruler. * * Since: 2.8 */ void gimp_ruler_set_position (GimpRuler *ruler, gdouble position) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); if (priv->position != position) { GdkRectangle rect; gint xdiff, ydiff; priv->position = position; g_object_notify (G_OBJECT (ruler), "position"); rect = gimp_ruler_get_pos_rect (ruler, priv->position); xdiff = rect.x - priv->last_pos_rect.x; ydiff = rect.y - priv->last_pos_rect.y; /* * If the position has changed far enough, queue a redraw immediately. * Otherwise, we only queue a redraw in a low priority idle handler, to * allow for other things (like updating the canvas) to run. * * TODO: This might not be necessary any more in GTK3 with the frame * clock. Investigate this more after the port to GTK3. */ if (priv->last_pos_rect.width != 0 && priv->last_pos_rect.height != 0 && (ABS (xdiff) > IMMEDIATE_REDRAW_THRESHOLD || ABS (ydiff) > IMMEDIATE_REDRAW_THRESHOLD)) { gimp_ruler_queue_pos_redraw (ruler); } else if (! priv->pos_redraw_idle_id) { priv->pos_redraw_idle_id = g_idle_add_full (G_PRIORITY_LOW, gimp_ruler_idle_queue_pos_redraw, ruler, NULL); } } }
static void gimp_ruler_style_updated (GtkWidget *widget) { GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget); GTK_WIDGET_CLASS (gimp_ruler_parent_class)->style_updated (widget); gtk_widget_style_get (widget, "font-scale", &priv->font_scale, NULL); if (priv->layout) { g_object_unref (priv->layout); priv->layout = NULL; } }
static void gimp_ruler_make_pixmap (GimpRuler *ruler) { GtkWidget *widget = GTK_WIDGET (ruler); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkAllocation allocation; gtk_widget_get_allocation (widget, &allocation); if (priv->backing_store) cairo_surface_destroy (priv->backing_store); priv->backing_store = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, allocation.width, allocation.height); }
/** * gimp_ruler_set_unit: * @ruler: a #GimpRuler * @unit: the #GimpUnit to set the ruler to * * This sets the unit of the ruler. * * Since: GIMP 2.8 */ void gimp_ruler_set_unit (GimpRuler *ruler, GimpUnit unit) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); if (priv->unit != unit) { priv->unit = unit; g_object_notify (G_OBJECT (ruler), "unit"); gtk_widget_queue_draw (GTK_WIDGET (ruler)); } }
/** * gimp_ruler_set_position: * @ruler: a #GimpRuler * @position: the position to set the ruler to * * This sets the position of the ruler. * * Since: GIMP 2.8 */ void gimp_ruler_set_position (GimpRuler *ruler, gdouble position) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); if (priv->position != position) { priv->position = position; g_object_notify (G_OBJECT (ruler), "position"); gimp_ruler_draw_pos (ruler); } }
static void gimp_ruler_draw_pos (GimpRuler *ruler, cairo_t *cr) { GtkWidget *widget = GTK_WIDGET (ruler); GtkStyleContext *context = gtk_widget_get_style_context (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GdkRectangle pos_rect; if (! gtk_widget_is_drawable (widget)) return; pos_rect = gimp_ruler_get_pos_rect (ruler, gimp_ruler_get_position (ruler)); if ((pos_rect.width > 0) && (pos_rect.height > 0)) { GdkRGBA color; gtk_style_context_get_color (context, gtk_widget_get_state_flags (widget), &color); gdk_cairo_set_source_rgba (cr, &color); cairo_move_to (cr, pos_rect.x, pos_rect.y); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { cairo_line_to (cr, pos_rect.x + pos_rect.width / 2.0, pos_rect.y + pos_rect.height); cairo_line_to (cr, pos_rect.x + pos_rect.width, pos_rect.y); } else { cairo_line_to (cr, pos_rect.x + pos_rect.width, pos_rect.y + pos_rect.height / 2.0); cairo_line_to (cr, pos_rect.x, pos_rect.y + pos_rect.height); } cairo_fill (cr); } priv->last_pos_rect = pos_rect; }
/** * gimp_ruler_get_range: * @ruler: a #GimpRuler * @lower: location to store lower limit of the ruler, or %NULL * @upper: location to store upper limit of the ruler, or %NULL * @max_size: location to store the maximum size of the ruler used when * calculating the space to leave for the text, or %NULL. * * Retrieves values indicating the range and current position of a #GimpRuler. * See gimp_ruler_set_range(). * * Since: GIMP 2.8 **/ void gimp_ruler_get_range (GimpRuler *ruler, gdouble *lower, gdouble *upper, gdouble *max_size) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); if (lower) *lower = priv->lower; if (upper) *upper = priv->upper; if (max_size) *max_size = priv->max_size; }
static void gimp_ruler_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GimpRuler *ruler = GIMP_RULER (object); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); switch (prop_id) { case PROP_ORIENTATION: g_value_set_enum (value, priv->orientation); break; case PROP_UNIT: g_value_set_int (value, priv->unit); break; case PROP_LOWER: g_value_set_double (value, priv->lower); break; case PROP_UPPER: g_value_set_double (value, priv->upper); break; case PROP_POSITION: g_value_set_double (value, priv->position); break; case PROP_MAX_SIZE: g_value_set_double (value, priv->max_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * gimp_ruler_add_track_widget: * @ruler: a #GimpRuler * @widget: the track widget to add * * Adds a "track widget" to the ruler. The ruler will connect to * GtkWidget:motion-notify-event: on the track widget and update its * position marker accordingly. The marker is correctly updated also * for the track widget's children, regardless of whether they are * ordinary children of off-screen children. * * Since: GIMP 2.8 */ void gimp_ruler_add_track_widget (GimpRuler *ruler, GtkWidget *widget) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); g_return_if_fail (GTK_IS_WIDGET (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); g_return_if_fail (g_list_find (priv->track_widgets, widget) == NULL); priv->track_widgets = g_list_prepend (priv->track_widgets, widget); g_signal_connect (widget, "motion-notify-event", G_CALLBACK (gimp_ruler_track_widget_motion_notify), ruler); g_signal_connect_swapped (widget, "destroy", G_CALLBACK (gimp_ruler_remove_track_widget), ruler); }
/** * gimp_ruler_remove_track_widget: * @ruler: a #GimpRuler * @widget: the track widget to remove * * Removes a previously added track widget from the ruler. See * gimp_ruler_add_track_widget(). * * Since: GIMP 2.8 */ void gimp_ruler_remove_track_widget (GimpRuler *ruler, GtkWidget *widget) { GimpRulerPrivate *priv; g_return_if_fail (GIMP_IS_RULER (ruler)); g_return_if_fail (GTK_IS_WIDGET (ruler)); priv = GIMP_RULER_GET_PRIVATE (ruler); g_return_if_fail (g_list_find (priv->track_widgets, widget) != NULL); priv->track_widgets = g_list_remove (priv->track_widgets, widget); g_signal_handlers_disconnect_by_func (widget, gimp_ruler_track_widget_motion_notify, ruler); g_signal_handlers_disconnect_by_func (widget, gimp_ruler_remove_track_widget, ruler); }
static void gimp_ruler_draw_pos (GimpRuler *ruler, cairo_t *cr) { GtkWidget *widget = GTK_WIDGET (ruler); GtkStyle *style = gtk_widget_get_style (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkStateType state = gtk_widget_get_state (widget); GdkRectangle pos_rect; if (! gtk_widget_is_drawable (widget)) return; pos_rect = gimp_ruler_get_pos_rect (ruler, gimp_ruler_get_position (ruler)); if ((pos_rect.width > 0) && (pos_rect.height > 0)) { gdk_cairo_set_source_color (cr, &style->fg[state]); cairo_move_to (cr, pos_rect.x, pos_rect.y); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { cairo_line_to (cr, pos_rect.x + pos_rect.width / 2.0, pos_rect.y + pos_rect.height); cairo_line_to (cr, pos_rect.x + pos_rect.width, pos_rect.y); } else { cairo_line_to (cr, pos_rect.x + pos_rect.width, pos_rect.y + pos_rect.height / 2.0); cairo_line_to (cr, pos_rect.x, pos_rect.y + pos_rect.height); } cairo_fill (cr); } }