static void tool_manager_disconnect_options (GimpToolManager *tool_manager, GimpContext *user_context, GimpToolInfo *tool_info) { if (tool_info->context_props) { if (GIMP_IS_PAINT_OPTIONS (tool_info->tool_options)) { /* Storing is unconditional, because the user may turn on * brush sharing mid use */ gimp_paint_options_copy_brush_props (GIMP_PAINT_OPTIONS (tool_info->tool_options), tool_manager->shared_paint_options); gimp_paint_options_copy_dynamics_props (GIMP_PAINT_OPTIONS (tool_info->tool_options), tool_manager->shared_paint_options); gimp_paint_options_copy_gradient_props (GIMP_PAINT_OPTIONS (tool_info->tool_options), tool_manager->shared_paint_options); } gimp_context_set_parent (GIMP_CONTEXT (tool_info->tool_options), NULL); } }
static void tool_manager_preset_changed (GimpContext *user_context, GimpToolPreset *preset, GimpToolManager *tool_manager) { GimpToolInfo *preset_tool; gchar *options_name; gboolean tool_change = FALSE; if (! preset || user_context->gimp->busy) return; preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options)); if (preset_tool != gimp_context_get_tool (user_context)) tool_change = TRUE; /* save the name, we don't want to overwrite it */ options_name = g_strdup (gimp_object_get_name (preset_tool->tool_options)); gimp_config_copy (GIMP_CONFIG (preset->tool_options), GIMP_CONFIG (preset_tool->tool_options), 0); /* restore the saved name */ gimp_object_take_name (GIMP_OBJECT (preset_tool->tool_options), options_name); if (tool_change) gimp_context_set_tool (user_context, preset_tool); gimp_context_copy_properties (GIMP_CONTEXT (preset->tool_options), user_context, gimp_tool_preset_get_prop_mask (preset)); if (GIMP_IS_PAINT_OPTIONS (preset->tool_options)) { GimpToolOptions *src; GimpToolOptions *dest; GimpContextPropMask prop_mask = 0; src = preset->tool_options; dest = tool_manager->active_tool->tool_info->tool_options; /* copy various data objects' additional tool options again * manually, they might have been overwritten by e.g. the "link * brush stuff to brush defaults" logic in gimptooloptions.c */ if (preset->use_brush) prop_mask |= GIMP_CONTEXT_PROP_MASK_BRUSH; if (preset->use_dynamics) prop_mask |= GIMP_CONTEXT_PROP_MASK_DYNAMICS; if (preset->use_gradient) prop_mask |= GIMP_CONTEXT_PROP_MASK_GRADIENT; gimp_paint_options_copy_props (GIMP_PAINT_OPTIONS (src), GIMP_PAINT_OPTIONS (dest), prop_mask); } }
static void tool_manager_connect_options (GimpToolManager *tool_manager, GimpContext *user_context, GimpToolInfo *tool_info) { if (tool_info->context_props) { GimpCoreConfig *config = user_context->gimp->config; GimpContextPropMask global_props = 0; /* FG and BG are always shared between all tools */ global_props |= GIMP_CONTEXT_PROP_MASK_FOREGROUND; global_props |= GIMP_CONTEXT_PROP_MASK_BACKGROUND; if (config->global_brush) global_props |= GIMP_CONTEXT_PROP_MASK_BRUSH; if (config->global_dynamics) global_props |= GIMP_CONTEXT_PROP_MASK_DYNAMICS; if (config->global_pattern) global_props |= GIMP_CONTEXT_PROP_MASK_PATTERN; if (config->global_palette) global_props |= GIMP_CONTEXT_PROP_MASK_PALETTE; if (config->global_gradient) global_props |= GIMP_CONTEXT_PROP_MASK_GRADIENT; if (config->global_font) global_props |= GIMP_CONTEXT_PROP_MASK_FONT; gimp_context_copy_properties (GIMP_CONTEXT (tool_info->tool_options), user_context, tool_info->context_props & ~global_props); gimp_context_set_parent (GIMP_CONTEXT (tool_info->tool_options), user_context); if (GIMP_IS_PAINT_OPTIONS (tool_info->tool_options)) { if (config->global_brush) gimp_paint_options_copy_brush_props (tool_manager->shared_paint_options, GIMP_PAINT_OPTIONS (tool_info->tool_options)); if (config->global_dynamics) gimp_paint_options_copy_dynamics_props (tool_manager->shared_paint_options, GIMP_PAINT_OPTIONS (tool_info->tool_options)); if (config->global_gradient) gimp_paint_options_copy_gradient_props (tool_manager->shared_paint_options, GIMP_PAINT_OPTIONS (tool_info->tool_options)); } } }
static void gimp_paint_options_finalize (GObject *object) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); g_slice_free (GimpJitterOptions, options->jitter_options); g_slice_free (GimpFadeOptions, options->fade_options); g_slice_free (GimpGradientOptions, options->gradient_options); g_slice_free (GimpSmoothingOptions, options->smoothing_options); G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gimp_paint_options_dispose (GObject *object) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); if (options->paint_info) { g_object_unref (options->paint_info); options->paint_info = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); }
static void gimp_paint_options_finalize (GObject *object) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); if (options->paint_info) g_object_unref (options->paint_info); g_slice_free (GimpDynamicOptions, options->pressure_options); g_slice_free (GimpDynamicOptions, options->velocity_options); g_slice_free (GimpDynamicOptions, options->random_options); g_slice_free (GimpFadeOptions, options->fade_options); g_slice_free (GimpJitterOptions, options->jitter_options); g_slice_free (GimpGradientOptions, options->gradient_options); G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gimp_pencil_options_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); switch (property_id) { case PROP_HARD: g_value_set_boolean (value, options->hard); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gimp_blend_tool_commit (GimpBlendTool *blend_tool) { GimpTool *tool = GIMP_TOOL (blend_tool); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (options); GimpContext *context = GIMP_CONTEXT (options); GimpImage *image = gimp_display_get_image (tool->display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpProgress *progress; gint off_x; gint off_y; progress = gimp_progress_start (GIMP_PROGRESS (tool), FALSE, _("Blending")); gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); gimp_drawable_blend (drawable, context, gimp_context_get_gradient (context), gimp_context_get_paint_mode (context), options->gradient_type, gimp_context_get_opacity (context), options->offset, paint_options->gradient_options->gradient_repeat, paint_options->gradient_options->gradient_reverse, options->supersample, options->supersample_depth, options->supersample_threshold, options->dither, blend_tool->start_x - off_x, blend_tool->start_y - off_y, blend_tool->end_x - off_x, blend_tool->end_y - off_y, progress); if (progress) gimp_progress_end (progress); gimp_image_flush (image); }
static void gimp_blend_options_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpBlendOptions *options = GIMP_BLEND_OPTIONS (object); switch (property_id) { case PROP_OFFSET: g_value_set_double (value, options->offset); break; case PROP_GRADIENT_TYPE: g_value_set_enum (value, options->gradient_type); break; case PROP_GRADIENT_REPEAT: g_value_set_enum (value, GIMP_PAINT_OPTIONS (options)->gradient_options->gradient_repeat); break; case PROP_SUPERSAMPLE: g_value_set_boolean (value, options->supersample); break; case PROP_SUPERSAMPLE_DEPTH: g_value_set_int (value, options->supersample_depth); break; case PROP_SUPERSAMPLE_THRESHOLD: g_value_set_double (value, options->supersample_threshold); break; case PROP_DITHER: g_value_set_boolean (value, options->dither); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gimp_paint_options_notify (GObject *object, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); if (pspec->param_id == PROP_USE_GRADIENT) { if (options->gradient_options->use_gradient) { options->application_mode_save = options->application_mode; options->application_mode = GIMP_PAINT_INCREMENTAL; } else { options->application_mode = options->application_mode_save; } g_object_notify (object, "application-mode"); } if (G_OBJECT_CLASS (parent_class)->notify) G_OBJECT_CLASS (parent_class)->notify (object, pspec); }
static void gimp_paint_options_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); GimpFadeOptions *fade_options = options->fade_options; GimpJitterOptions *jitter_options = options->jitter_options; GimpGradientOptions *gradient_options = options->gradient_options; GimpSmoothingOptions *smoothing_options = options->smoothing_options; switch (property_id) { case PROP_PAINT_INFO: g_value_set_object (value, options->paint_info); break; case PROP_USE_APPLICATOR: g_value_set_boolean (value, options->use_applicator); break; case PROP_BRUSH_SIZE: g_value_set_double (value, options->brush_size); break; case PROP_BRUSH_ZOOM: g_value_set_boolean (value, options->brush_zoom); break; case PROP_BRUSH_ASPECT_RATIO: g_value_set_double (value, options->brush_aspect_ratio); break; case PROP_BRUSH_ANGLE: g_value_set_double (value, - 1.0 * options->brush_angle * 360.0); /* mathematically correct -> intuitively correct */ break; case PROP_BRUSH_SPACING: g_value_set_double (value, options->brush_spacing); break; case PROP_BRUSH_HARDNESS: g_value_set_double (value, options->brush_hardness); break; case PROP_BRUSH_FORCE: g_value_set_double (value, options->brush_force); break; case PROP_BRUSH_LINK_SIZE: g_value_set_boolean (value, options->brush_link_size); break; case PROP_BRUSH_LINK_ASPECT_RATIO: g_value_set_boolean (value, options->brush_link_aspect_ratio); break; case PROP_BRUSH_LINK_ANGLE: g_value_set_boolean (value, options->brush_link_angle); break; case PROP_BRUSH_LINK_SPACING: g_value_set_boolean (value, options->brush_link_spacing); break; case PROP_BRUSH_LINK_HARDNESS: g_value_set_boolean (value, options->brush_link_hardness); break; case PROP_APPLICATION_MODE: g_value_set_enum (value, options->application_mode); break; case PROP_HARD: g_value_set_boolean (value, options->hard); break; case PROP_USE_JITTER: g_value_set_boolean (value, jitter_options->use_jitter); break; case PROP_JITTER_AMOUNT: g_value_set_double (value, jitter_options->jitter_amount); break; case PROP_DYNAMICS_EXPANDED: g_value_set_boolean (value, options->dynamics_expanded); break; case PROP_FADE_LENGTH: g_value_set_double (value, fade_options->fade_length); break; case PROP_FADE_REVERSE: g_value_set_boolean (value, fade_options->fade_reverse); break; case PROP_FADE_REPEAT: g_value_set_enum (value, fade_options->fade_repeat); break; case PROP_FADE_UNIT: g_value_set_int (value, fade_options->fade_unit); break; case PROP_GRADIENT_REVERSE: g_value_set_boolean (value, gradient_options->gradient_reverse); break; case PROP_BRUSH_VIEW_TYPE: g_value_set_enum (value, options->brush_view_type); break; case PROP_BRUSH_VIEW_SIZE: g_value_set_int (value, options->brush_view_size); break; case PROP_DYNAMICS_VIEW_TYPE: g_value_set_enum (value, options->dynamics_view_type); break; case PROP_DYNAMICS_VIEW_SIZE: g_value_set_int (value, options->dynamics_view_size); break; case PROP_PATTERN_VIEW_TYPE: g_value_set_enum (value, options->pattern_view_type); break; case PROP_PATTERN_VIEW_SIZE: g_value_set_int (value, options->pattern_view_size); break; case PROP_GRADIENT_VIEW_TYPE: g_value_set_enum (value, options->gradient_view_type); break; case PROP_GRADIENT_VIEW_SIZE: g_value_set_int (value, options->gradient_view_size); break; case PROP_USE_SMOOTHING: g_value_set_boolean (value, smoothing_options->use_smoothing); break; case PROP_SMOOTHING_QUALITY: g_value_set_int (value, smoothing_options->smoothing_quality); break; case PROP_SMOOTHING_FACTOR: g_value_set_double (value, smoothing_options->smoothing_factor); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
GtkWidget * gimp_paint_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GimpPaintOptions *options = GIMP_PAINT_OPTIONS (tool_options); GtkWidget *vbox = gimp_tool_options_gui (tool_options); GtkWidget *hbox; GtkWidget *menu; GtkWidget *label; GtkWidget *scale; GType tool_type; tool_type = tool_options->tool_info->tool_type; /* the paint mode menu */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Mode:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE); gtk_box_pack_start (GTK_BOX (hbox), menu, TRUE, TRUE, 0); gtk_widget_show (menu); if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { gtk_widget_set_sensitive (menu, FALSE); gtk_widget_set_sensitive (label, FALSE); } /* the opacity scale */ scale = gimp_prop_opacity_spin_scale_new (config, "opacity", _("Opacity")); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_widget_show (scale); /* the brush */ if (g_type_is_a (tool_type, GIMP_TYPE_BRUSH_TOOL)) { GtkWidget *button; GtkWidget *hbox; GtkWidget *frame; button = gimp_prop_brush_box_new (NULL, GIMP_CONTEXT (tool_options), _("Brush"), 2, "brush-view-type", "brush-view-size", "gimp-brush-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-size", _("Size"), 0.01, 1.0, 2); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_size), options); gimp_help_set_help_data (button, _("Reset size to brush's native size"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-aspect-ratio", _("Aspect Ratio"), 0.01, 0.1, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio), options); gimp_help_set_help_data (button, _("Reset aspect ratio to brush's native"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-angle", _("Angle"), 1.0, 5.0, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_angle), options); gimp_help_set_help_data (button, _("Reset angle to zero"), NULL); button = gimp_prop_dynamics_box_new (NULL, GIMP_CONTEXT (tool_options), _("Dynamics"), 2, "dynamics-view-type", "dynamics-view-size", "gimp-dynamics-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); frame = dynamics_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = jitter_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "smooth stroke" options */ if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL)) { GtkWidget *frame; frame = smoothing_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "incremental" toggle */ if (tool_type == GIMP_TYPE_PENCIL_TOOL || tool_type == GIMP_TYPE_PAINTBRUSH_TOOL || tool_type == GIMP_TYPE_ERASER_TOOL) { GtkWidget *button; button = gimp_prop_enum_check_button_new (config, "application-mode", _("Incremental"), GIMP_PAINT_CONSTANT, GIMP_PAINT_INCREMENTAL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } /* the "hard edge" toggle */ if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CLONE_TOOL || tool_type == GIMP_TYPE_HEAL_TOOL || tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { GtkWidget *button; button = gimp_prop_check_button_new (config, "hard", _("Hard edge")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } return vbox; }
static void gimp_paint_options_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); GimpDynamicOptions *pressure_options = options->pressure_options; GimpDynamicOptions *velocity_options = options->velocity_options; GimpDynamicOptions *random_options = options->random_options; GimpFadeOptions *fade_options = options->fade_options; GimpJitterOptions *jitter_options = options->jitter_options; GimpGradientOptions *gradient_options = options->gradient_options; switch (property_id) { case PROP_PAINT_INFO: g_value_set_object (value, options->paint_info); break; case PROP_BRUSH_SCALE: g_value_set_double (value, options->brush_scale); break; case PROP_APPLICATION_MODE: g_value_set_enum (value, options->application_mode); break; case PROP_HARD: g_value_set_boolean (value, options->hard); break; case PROP_DYNAMICS_EXPANDED: g_value_set_boolean (value, options->dynamics_expanded); break; case PROP_PRESSURE_OPACITY: g_value_set_boolean (value, pressure_options->opacity); break; case PROP_PRESSURE_HARDNESS: g_value_set_boolean (value, pressure_options->hardness); break; case PROP_PRESSURE_RATE: g_value_set_boolean (value, pressure_options->rate); break; case PROP_PRESSURE_SIZE: g_value_set_boolean (value, pressure_options->size); break; case PROP_PRESSURE_INVERSE_SIZE: g_value_set_boolean (value, pressure_options->inverse_size); break; case PROP_PRESSURE_COLOR: g_value_set_boolean (value, pressure_options->color); break; case PROP_PRESSURE_PRESCALE: g_value_set_double (value, pressure_options->prescale); break; case PROP_VELOCITY_OPACITY: g_value_set_boolean (value, velocity_options->opacity); break; case PROP_VELOCITY_HARDNESS: g_value_set_boolean (value, velocity_options->hardness); break; case PROP_VELOCITY_RATE: g_value_set_boolean (value, velocity_options->rate); break; case PROP_VELOCITY_SIZE: g_value_set_boolean (value, velocity_options->size); break; case PROP_VELOCITY_INVERSE_SIZE: g_value_set_boolean (value, velocity_options->inverse_size); break; case PROP_VELOCITY_COLOR: g_value_set_boolean (value, velocity_options->color); break; case PROP_VELOCITY_PRESCALE: g_value_set_double (value, velocity_options->prescale); break; case PROP_RANDOM_OPACITY: g_value_set_boolean (value, random_options->opacity); break; case PROP_RANDOM_HARDNESS: g_value_set_boolean (value, random_options->hardness); break; case PROP_RANDOM_RATE: g_value_set_boolean (value, random_options->rate); break; case PROP_RANDOM_SIZE: g_value_set_boolean (value, random_options->size); break; case PROP_RANDOM_INVERSE_SIZE: g_value_set_boolean (value, random_options->inverse_size); break; case PROP_RANDOM_COLOR: g_value_set_boolean (value, random_options->color); break; case PROP_RANDOM_PRESCALE: g_value_set_double (value, random_options->prescale); break; case PROP_USE_FADE: g_value_set_boolean (value, fade_options->use_fade); break; case PROP_FADE_LENGTH: g_value_set_double (value, fade_options->fade_length); break; case PROP_FADE_UNIT: g_value_set_int (value, fade_options->fade_unit); break; case PROP_USE_JITTER: g_value_set_boolean (value, jitter_options->use_jitter); break; case PROP_JITTER_AMOUNT: g_value_set_double (value, jitter_options->jitter_amount); break; case PROP_USE_GRADIENT: g_value_set_boolean (value, gradient_options->use_gradient); break; case PROP_GRADIENT_REVERSE: g_value_set_boolean (value, gradient_options->gradient_reverse); break; case PROP_GRADIENT_REPEAT: g_value_set_enum (value, gradient_options->gradient_repeat); break; case PROP_GRADIENT_LENGTH: g_value_set_double (value, gradient_options->gradient_length); break; case PROP_GRADIENT_UNIT: g_value_set_int (value, gradient_options->gradient_unit); break; case PROP_BRUSH_VIEW_TYPE: g_value_set_enum (value, options->brush_view_type); break; case PROP_BRUSH_VIEW_SIZE: g_value_set_int (value, options->brush_view_size); break; case PROP_PATTERN_VIEW_TYPE: g_value_set_enum (value, options->pattern_view_type); break; case PROP_PATTERN_VIEW_SIZE: g_value_set_int (value, options->pattern_view_size); break; case PROP_GRADIENT_VIEW_TYPE: g_value_set_enum (value, options->gradient_view_type); break; case PROP_GRADIENT_VIEW_SIZE: g_value_set_int (value, options->gradient_view_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void tool_manager_preset_changed (GimpContext *user_context, GimpToolPreset *preset, GimpToolManager *tool_manager) { GimpToolInfo *preset_tool; gchar *options_name; gboolean tool_change = FALSE; if (! preset || user_context->gimp->busy) return; preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options)); if (preset_tool != gimp_context_get_tool (user_context)) tool_change = TRUE; if (! tool_change) tool_manager_disconnect_options (tool_manager, user_context, preset_tool); /* save the name, we don't want to overwrite it */ options_name = g_strdup (gimp_object_get_name (preset_tool->tool_options)); gimp_config_copy (GIMP_CONFIG (preset->tool_options), GIMP_CONFIG (preset_tool->tool_options), 0); /* restore the saved name */ gimp_object_take_name (GIMP_OBJECT (preset_tool->tool_options), options_name); if (tool_change) gimp_context_set_tool (user_context, preset_tool); else tool_manager_connect_options (tool_manager, user_context, preset_tool); gimp_context_copy_properties (GIMP_CONTEXT (preset->tool_options), user_context, gimp_tool_preset_get_prop_mask (preset)); if (GIMP_IS_PAINT_OPTIONS (preset->tool_options)) { GimpCoreConfig *config = user_context->gimp->config; GimpToolOptions *src = preset->tool_options; GimpToolOptions *dest = tool_manager->active_tool->tool_info->tool_options; /* if connect_options() did overwrite the brush options and the * preset contains a brush, use the brush options from the * preset */ if (config->global_brush && preset->use_brush) gimp_paint_options_copy_brush_props (GIMP_PAINT_OPTIONS (src), GIMP_PAINT_OPTIONS (dest)); if (config->global_dynamics && preset->use_dynamics) gimp_paint_options_copy_dynamics_props (GIMP_PAINT_OPTIONS (src), GIMP_PAINT_OPTIONS (dest)); if (config->global_gradient && preset->use_gradient) gimp_paint_options_copy_gradient_props (GIMP_PAINT_OPTIONS (src), GIMP_PAINT_OPTIONS (dest)); } }
static void gimp_paint_options_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); GimpFadeOptions *fade_options = options->fade_options; GimpJitterOptions *jitter_options = options->jitter_options; GimpGradientOptions *gradient_options = options->gradient_options; GimpSmoothingOptions *smoothing_options = options->smoothing_options; switch (property_id) { case PROP_PAINT_INFO: options->paint_info = g_value_dup_object (value); break; case PROP_USE_APPLICATOR: options->use_applicator = g_value_get_boolean (value); break; case PROP_BRUSH_SIZE: options->brush_size = g_value_get_double (value); break; case PROP_BRUSH_ASPECT_RATIO: options->brush_aspect_ratio = g_value_get_double (value); break; case PROP_BRUSH_ANGLE: options->brush_angle = - 1.0 * g_value_get_double (value) / 360.0; /* let's make the angle mathematically correct */ break; case PROP_APPLICATION_MODE: options->application_mode = g_value_get_enum (value); break; case PROP_HARD: options->hard = g_value_get_boolean (value); break; case PROP_USE_JITTER: jitter_options->use_jitter = g_value_get_boolean (value); break; case PROP_JITTER_AMOUNT: jitter_options->jitter_amount = g_value_get_double (value); break; case PROP_DYNAMICS_EXPANDED: options->dynamics_expanded = g_value_get_boolean (value); break; case PROP_FADE_LENGTH: fade_options->fade_length = g_value_get_double (value); break; case PROP_FADE_REVERSE: fade_options->fade_reverse = g_value_get_boolean (value); break; case PROP_FADE_REPEAT: fade_options->fade_repeat = g_value_get_enum (value); break; case PROP_FADE_UNIT: fade_options->fade_unit = g_value_get_int (value); break; case PROP_GRADIENT_REVERSE: gradient_options->gradient_reverse = g_value_get_boolean (value); break; case PROP_BRUSH_VIEW_TYPE: options->brush_view_type = g_value_get_enum (value); break; case PROP_BRUSH_VIEW_SIZE: options->brush_view_size = g_value_get_int (value); break; case PROP_DYNAMICS_VIEW_TYPE: options->dynamics_view_type = g_value_get_enum (value); break; case PROP_DYNAMICS_VIEW_SIZE: options->dynamics_view_size = g_value_get_int (value); break; case PROP_PATTERN_VIEW_TYPE: options->pattern_view_type = g_value_get_enum (value); break; case PROP_PATTERN_VIEW_SIZE: options->pattern_view_size = g_value_get_int (value); break; case PROP_GRADIENT_VIEW_TYPE: options->gradient_view_type = g_value_get_enum (value); break; case PROP_GRADIENT_VIEW_SIZE: options->gradient_view_size = g_value_get_int (value); break; case PROP_USE_SMOOTHING: smoothing_options->use_smoothing = g_value_get_boolean (value); break; case PROP_SMOOTHING_QUALITY: smoothing_options->smoothing_quality = g_value_get_int (value); break; case PROP_SMOOTHING_FACTOR: smoothing_options->smoothing_factor = g_value_get_double (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gimp_blend_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpBlendTool *blend_tool = GIMP_BLEND_TOOL (tool); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (options); GimpContext *context = GIMP_CONTEXT (options); GimpImage *image = gimp_display_get_image (display); gimp_tool_pop_status (tool, display); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); gimp_tool_control_halt (tool->control); if ((release_type != GIMP_BUTTON_RELEASE_CANCEL) && ((blend_tool->start_x != blend_tool->end_x) || (blend_tool->start_y != blend_tool->end_y))) { GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpProgress *progress; gint off_x; gint off_y; progress = gimp_progress_start (GIMP_PROGRESS (tool), _("Blending"), FALSE); gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); gimp_drawable_blend (drawable, context, GIMP_CUSTOM_MODE, gimp_context_get_paint_mode (context), options->gradient_type, gimp_context_get_opacity (context), options->offset, paint_options->gradient_options->gradient_repeat, paint_options->gradient_options->gradient_reverse, options->supersample, options->supersample_depth, options->supersample_threshold, options->dither, blend_tool->start_x - off_x, blend_tool->start_y - off_y, blend_tool->end_x - off_x, blend_tool->end_y - off_y, progress); if (progress) gimp_progress_end (progress); gimp_image_flush (image); } tool->display = NULL; tool->drawable = NULL; }