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 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 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_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 gboolean gimp_ruler_motion_notify (GtkWidget *widget, GdkEventMotion *event) { GimpRuler *ruler = GIMP_RULER (widget); gimp_ruler_update_position (ruler, event->x, event->y); return FALSE; }
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 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 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; } }
static gboolean gimp_ruler_draw (GtkWidget *widget, cairo_t *cr) { GimpRuler *ruler = GIMP_RULER (widget); GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler); GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkAllocation allocation; gtk_widget_get_allocation (widget, &allocation); gtk_render_background (context, cr, 0, 0, allocation.width, allocation.height); gtk_render_frame (context, cr, 0, 0, allocation.width, allocation.height); if (! priv->backing_store_valid) gimp_ruler_draw_ticks (ruler); cairo_set_source_surface (cr, priv->backing_store, 0, 0); cairo_paint (cr); gimp_ruler_draw_pos (ruler, cr); return FALSE; }
/** * gimp_display_shell_scale_update_rulers: * @shell: * **/ void gimp_display_shell_scale_update_rulers (GimpDisplayShell *shell) { GimpImage *image; gint image_width; gint image_height; gdouble resolution_x = 1.0; gdouble resolution_y = 1.0; gdouble horizontal_lower; gdouble horizontal_upper; gdouble horizontal_max_size; gdouble vertical_lower; gdouble vertical_upper; gdouble vertical_max_size; if (! shell->display) return; image = gimp_display_get_image (shell->display); if (image) { image_width = gimp_image_get_width (image); image_height = gimp_image_get_height (image); gimp_image_get_resolution (image, &resolution_x, &resolution_y); } else { image_width = shell->disp_width; image_height = shell->disp_height; } /* Initialize values */ horizontal_lower = 0; vertical_lower = 0; if (image) { horizontal_upper = gimp_pixels_to_units (FUNSCALEX (shell, shell->disp_width), shell->unit, resolution_x); horizontal_max_size = gimp_pixels_to_units (MAX (image_width, image_height), shell->unit, resolution_x); vertical_upper = gimp_pixels_to_units (FUNSCALEY (shell, shell->disp_height), shell->unit, resolution_y); vertical_max_size = gimp_pixels_to_units (MAX (image_width, image_height), shell->unit, resolution_y); } else { horizontal_upper = image_width; horizontal_max_size = MAX (image_width, image_height); vertical_upper = image_height; vertical_max_size = MAX (image_width, image_height); } /* Adjust due to scrolling */ if (image) { gdouble offset_x; gdouble offset_y; offset_x = gimp_pixels_to_units (FUNSCALEX (shell, (gdouble) shell->offset_x), shell->unit, resolution_x); offset_y = gimp_pixels_to_units (FUNSCALEX (shell, (gdouble) shell->offset_y), shell->unit, resolution_y); horizontal_lower += offset_x; horizontal_upper += offset_x; vertical_lower += offset_y; vertical_upper += offset_y; } /* Finally setup the actual rulers */ gimp_ruler_set_range (GIMP_RULER (shell->hrule), horizontal_lower, horizontal_upper, horizontal_max_size); gimp_ruler_set_unit (GIMP_RULER (shell->hrule), shell->unit); gimp_ruler_set_range (GIMP_RULER (shell->vrule), vertical_lower, vertical_upper, vertical_max_size); gimp_ruler_set_unit (GIMP_RULER (shell->vrule), shell->unit); }
/** * resolution_calibrate_dialog: * @resolution_entry: a #GimpSizeEntry to connect the dialog to * @pixbuf: an optional #GdkPixbuf for the upper left corner * * Displays a dialog that allows the user to interactively determine * her monitor resolution. This dialog runs it's own GTK main loop and * is connected to a #GimpSizeEntry handling the resolution to be set. **/ void resolution_calibrate_dialog (GtkWidget *resolution_entry, GdkPixbuf *pixbuf) { GtkWidget *dialog; GtkWidget *table; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *ruler; GtkWidget *label; GdkScreen *screen; GdkRectangle rect; gint monitor; g_return_if_fail (GIMP_IS_SIZE_ENTRY (resolution_entry)); g_return_if_fail (GTK_WIDGET_REALIZED (resolution_entry)); g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf)); /* this dialog can only exist once */ if (calibrate_entry) return; dialog = gimp_dialog_new (_("Calibrate Monitor Resolution"), "gimp-resolution-calibration", gtk_widget_get_toplevel (resolution_entry), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); screen = gtk_widget_get_screen (dialog); monitor = gdk_screen_get_monitor_at_window (screen, resolution_entry->window); gdk_screen_get_monitor_geometry (screen, monitor, &rect); ruler_width = rect.width - 300 - (rect.width % 100); ruler_height = rect.height - 300 - (rect.height % 100); table = gtk_table_new (4, 4, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), table); gtk_widget_show (table); if (pixbuf) { GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, GTK_SHRINK, GTK_SHRINK, 4, 4); gtk_widget_show (image); } ruler = gimp_ruler_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_size_request (ruler, ruler_width, 32); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_width, ruler_width); gtk_table_attach (GTK_TABLE (table), ruler, 1, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); ruler = gimp_ruler_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_size_request (ruler, 32, ruler_height); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_height, ruler_height); gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); vbox = gtk_vbox_new (FALSE, 12); gtk_table_attach (GTK_TABLE (table), vbox, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Measure the rulers and enter their lengths:")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); calibrate_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 0); calibrate_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 1); calibrate_entry = gimp_coordinates_new (GIMP_UNIT_INCH, "%p", FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, FALSE, _("_Horizontal:"), ruler_width, calibrate_xres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0, _("_Vertical:"), ruler_height, calibrate_yres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0); gtk_widget_hide (GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (calibrate_entry))); g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &calibrate_entry); gtk_box_pack_end (GTK_BOX (hbox), calibrate_entry, FALSE, FALSE, 0); gtk_widget_show (calibrate_entry); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: { GtkWidget *chain_button; gdouble x, y; x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 0); y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 1); calibrate_xres = (gdouble) ruler_width * calibrate_xres / x; calibrate_yres = (gdouble) ruler_height * calibrate_yres / y; chain_button = GIMP_COORDINATES_CHAINBUTTON (resolution_entry); if (ABS (x - y) > GIMP_MIN_RESOLUTION) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), FALSE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 0, calibrate_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 1, calibrate_yres); } default: break; } gtk_widget_destroy (dialog); }