static void
gimp_move_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpMoveTool *move = GIMP_MOVE_TOOL (tool);
GimpMoveOptions *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool);
if (key == GDK_SHIFT_MASK)
{
g_object_set (options, "move-current", ! options->move_current, NULL);
}
else if (key == GDK_MOD1_MASK ||
key == gimp_get_toggle_behavior_mask ())
{
GimpTransformType button_type;
button_type = options->move_type;
if (press)
{
if (key == (state & (GDK_MOD1_MASK |
gimp_get_toggle_behavior_mask ())))
{
/* first modifier pressed */
move->saved_type = options->move_type;
}
}
else
{
if (! (state & (GDK_MOD1_MASK |
gimp_get_toggle_behavior_mask ())))
{
/* last modifier released */
button_type = move->saved_type;
}
}
if (state & GDK_MOD1_MASK)
{
button_type = GIMP_TRANSFORM_TYPE_SELECTION;
}
else if (state & gimp_get_toggle_behavior_mask ())
{
button_type = GIMP_TRANSFORM_TYPE_PATH;
}
if (button_type != options->move_type)
{
g_object_set (options, "move-type", button_type, NULL);
}
}
}
static void
gimp_color_picker_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpColorPickerOptions *options = GIMP_COLOR_PICKER_TOOL_GET_OPTIONS (tool);
if (key == GDK_SHIFT_MASK)
{
g_object_set (options, "use-info-window", ! options->use_info_window,
NULL);
}
else if (key == gimp_get_toggle_behavior_mask ())
{
switch (options->pick_mode)
{
case GIMP_COLOR_PICK_MODE_FOREGROUND:
g_object_set (options, "pick-mode", GIMP_COLOR_PICK_MODE_BACKGROUND,
NULL);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
g_object_set (options, "pick-mode", GIMP_COLOR_PICK_MODE_FOREGROUND,
NULL);
break;
default:
break;
}
}
}
static void
gimp_bucket_fill_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpBucketFillOptions *options = GIMP_BUCKET_FILL_TOOL_GET_OPTIONS (tool);
if (key == gimp_get_toggle_behavior_mask ())
{
switch (options->fill_mode)
{
case GIMP_FG_BUCKET_FILL:
g_object_set (options, "fill-mode", GIMP_BG_BUCKET_FILL, NULL);
break;
case GIMP_BG_BUCKET_FILL:
g_object_set (options, "fill-mode", GIMP_FG_BUCKET_FILL, NULL);
break;
default:
break;
}
}
else if (key == GDK_SHIFT_MASK)
{
g_object_set (options, "fill-selection", ! options->fill_selection, NULL);
}
}
static void
gimp_flip_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpFlipOptions *options = GIMP_FLIP_TOOL_GET_OPTIONS (tool);
if (key == gimp_get_toggle_behavior_mask ())
{
switch (options->flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
g_object_set (options,
"flip-type", GIMP_ORIENTATION_VERTICAL,
NULL);
break;
case GIMP_ORIENTATION_VERTICAL:
g_object_set (options,
"flip-type", GIMP_ORIENTATION_HORIZONTAL,
NULL);
break;
default:
break;
}
}
}
GtkWidget *
gimp_magnify_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *button;
gchar *str;
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
/* the auto_resize toggle button */
button = gimp_prop_check_button_new (config, "auto-resize",
_("Auto-resize window"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* tool toggle */
str = g_strdup_printf (_("Direction (%s)"),
gimp_get_mod_string (toggle_mask));
frame = gimp_prop_enum_radio_frame_new (config, "zoom-type",
str, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
g_free (str);
return vbox;
}
static GtkWidget *
gimp_convolve_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_paint_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *scale;
gchar *str;
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
/* the type radio box */
str = g_strdup_printf (_("Convolve Type (%s)"),
gimp_get_mod_string (toggle_mask));
frame = gimp_prop_enum_radio_frame_new (config, "type",
str, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
g_free (str);
/* the rate scale */
scale = gimp_prop_spin_scale_new (config, "rate",
_("Rate"),
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
return vbox;
}
static void
gimp_source_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpSourceCore *source = GIMP_SOURCE_CORE (paint_tool->core);
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask)
{
source->set_source = TRUE;
gimp_source_tool_set_src_display (source_tool, display);
}
else
{
source->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
source_tool->src_x = source->src_x;
source_tool->src_y = source->src_y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_source_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
GimpCursorType cursor = GIMP_CURSOR_MOUSE;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (gimp_source_core_use_source (GIMP_SOURCE_CORE (paint_tool->core),
options))
{
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if ((state & (toggle_mask | GDK_SHIFT_MASK)) == toggle_mask)
{
cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
}
else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable)
{
modifier = GIMP_CURSOR_MODIFIER_BAD;
}
}
gimp_tool_control_set_cursor (tool->control, cursor);
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_perspective_clone_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_PAINT &&
key == gimp_get_toggle_behavior_mask ())
{
if (press)
{
clone_tool->saved_precision =
gimp_tool_control_get_precision (tool->control);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_PIXEL_CENTER);
}
else
{
gimp_tool_control_set_precision (tool->control,
clone_tool->saved_precision);
}
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_palette_editor_constructed (GObject *object)
{
GimpPaletteEditor *editor = GIMP_PALETTE_EDITOR (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-edit-color", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-new-color-fg",
"palette-editor-new-color-bg",
gimp_get_toggle_behavior_mask (),
NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-delete-color", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-out", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-in", NULL);
gimp_editor_add_action_button (GIMP_EDITOR (editor), "palette-editor",
"palette-editor-zoom-all", NULL);
}
static void
gimp_thumb_box_thumbnail_clicked (GtkWidget *widget,
GdkModifierType state,
GimpThumbBox *box)
{
gimp_thumb_box_create_thumbnails (box,
(state & gimp_get_toggle_behavior_mask ()) ?
TRUE : FALSE);
}
static void
gimp_curves_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpCurvesConfig *config = GIMP_CURVES_CONFIG (im_tool->config);
if (state & gimp_get_extend_selection_mask ())
{
GimpCurve *curve = config->curve[config->channel];
gdouble value = c_tool->picked_color[config->channel];
gint closest;
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
else if (state & gimp_get_toggle_behavior_mask ())
{
GimpHistogramChannel channel;
for (channel = GIMP_HISTOGRAM_VALUE;
channel <= GIMP_HISTOGRAM_ALPHA;
channel++)
{
GimpCurve *curve = config->curve[channel];
gdouble value = c_tool->picked_color[channel];
gint closest;
if (value != -1)
{
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
}
}
/* chain up to halt the tool */
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
}
static void
gimp_curves_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
if (gimp_image_map_tool_on_guide (GIMP_IMAGE_MAP_TOOL (tool),
coords, display))
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
else
{
GimpColorPickMode mode;
gchar *status = NULL;
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gimp_tool_pop_status (tool, display);
if (state & extend_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add a control point"));
}
else if (state & toggle_mask)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = g_strdup (_("Click to add control points to all channels"));
}
else
{
mode = GIMP_COLOR_PICK_MODE_NONE;
status = gimp_suggest_modifiers (_("Click to locate on curve"),
(extend_mask | toggle_mask) & ~state,
_("%s: add control point"),
_("%s: add control points to all channels"),
NULL);
}
GIMP_COLOR_TOOL (tool)->pick_mode = mode;
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
static void
gimp_curves_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool);
GimpCurvesConfig *config = c_tool->config;
if (state & GDK_SHIFT_MASK)
{
GimpCurve *curve = config->curve[config->channel];
gdouble value = c_tool->picked_color[config->channel];
gint closest;
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
else if (state & gimp_get_toggle_behavior_mask ())
{
gint i;
for (i = 0; i < 5; i++)
{
GimpCurve *curve = config->curve[i];
gdouble value = c_tool->picked_color[i];
gint closest;
closest = gimp_curve_get_closest_point (curve, value);
gimp_curve_view_set_selected (GIMP_CURVE_VIEW (c_tool->graph),
closest);
gimp_curve_set_point (curve, closest,
value, gimp_curve_map_value (curve, value));
}
}
/* chain up to halt the tool */
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display);
}
static void
palette_editor_entry_clicked (GimpPaletteView *view,
GimpPaletteEntry *entry,
GdkModifierType state,
GimpPaletteEditor *editor)
{
if (entry)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
if (state & gimp_get_toggle_behavior_mask ())
gimp_context_set_background (data_editor->context, &entry->color);
else
gimp_context_set_foreground (data_editor->context, &entry->color);
}
}
static void
gimp_image_map_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
gimp_tool_pop_status (tool, display);
if (! gimp_image_map_tool_on_guide (im_tool, coords, display))
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
}
else
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gchar *status = NULL;
if (state & extend_mask)
{
status = g_strdup (_("Click to switch the original and filtered sides"));
}
else if (state & toggle_mask)
{
status = g_strdup (_("Click to switch between vertical and horizontal"));
}
else
{
status = gimp_suggest_modifiers (_("Click to move the split guide"),
(extend_mask | toggle_mask) & ~state,
_("%s: switch original and filtered"),
_("%s: switch horizontal and vertical"),
NULL);
}
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
g_free (status);
}
}
static void
gimp_foreground_select_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
if (key == gimp_get_toggle_behavior_mask ())
{
GimpForegroundSelectOptions *options;
options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool);
g_object_set (options,
"background", ! options->background,
NULL);
}
}
static void
gimp_dodge_burn_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpDodgeBurnTool *dodgeburn = GIMP_DODGE_BURN_TOOL (tool);
GimpDodgeBurnOptions *options = GIMP_DODGE_BURN_TOOL_GET_OPTIONS (tool);
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
if ((key == toggle_mask &&
! (state & GDK_SHIFT_MASK) && /* leave stuff untouched in line draw mode */
press != dodgeburn->toggled)
||
(key == GDK_SHIFT_MASK && /* toggle back after keypresses CTRL(hold)-> */
! press && /* SHIFT(hold)->CTRL(release)->SHIFT(release) */
dodgeburn->toggled &&
! (state & toggle_mask)))
{
dodgeburn->toggled = press;
switch (options->type)
{
case GIMP_DODGE:
g_object_set (options, "type", GIMP_BURN, NULL);
break;
case GIMP_BURN:
g_object_set (options, "type", GIMP_DODGE, NULL);
break;
default:
break;
}
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_convolve_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpConvolveTool *convolve = GIMP_CONVOLVE_TOOL (tool);
GimpConvolveOptions *options = GIMP_CONVOLVE_TOOL_GET_OPTIONS (tool);
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
if (((key == toggle_mask) &&
! (state & GDK_SHIFT_MASK) && /* leave stuff untouched in line draw mode */
press != convolve->toggled)
||
(key == GDK_SHIFT_MASK && /* toggle back after keypresses CTRL(hold)-> */
! press && /* SHIFT(hold)->CTRL(release)->SHIFT(release) */
convolve->toggled &&
! (state & toggle_mask)))
{
convolve->toggled = press;
switch (options->type)
{
case GIMP_BLUR_CONVOLVE:
g_object_set (options, "type", GIMP_SHARPEN_CONVOLVE, NULL);
break;
case GIMP_SHARPEN_CONVOLVE:
g_object_set (options, "type", GIMP_BLUR_CONVOLVE, NULL);
break;
default:
break;
}
}
}
GtkWidget *
gimp_flip_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *hbox;
GtkWidget *box;
GtkWidget *label;
GtkWidget *frame;
gchar *str;
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
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 (_("Affect:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
box = gimp_prop_enum_icon_box_new (config, "type", "gimp", 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), box, FALSE, FALSE, 0);
gtk_widget_show (box);
/* tool toggle */
str = g_strdup_printf (_("Flip Type (%s)"),
gimp_get_mod_string (toggle_mask));
frame = gimp_prop_enum_radio_frame_new (config, "flip-type",
str,
GIMP_ORIENTATION_HORIZONTAL,
GIMP_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
g_free (str);
return vbox;
}
static GtkWidget *
gimp_dodge_burn_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_paint_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *scale;
gchar *str;
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
/* the type (dodge or burn) */
str = g_strdup_printf (_("Type (%s)"),
gimp_get_mod_string (toggle_mask));
frame = gimp_prop_enum_radio_frame_new (config, "type",
str, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
g_free (str);
/* mode (highlights, midtones, or shadows) */
frame = gimp_prop_enum_radio_frame_new (config, "mode", _("Range"), 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* the exposure scale */
scale = gimp_prop_spin_scale_new (config, "exposure",
_("Exposure"),
1.0, 10.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
return vbox;
}
static void
gimp_source_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
if (gimp_source_core_use_source (GIMP_SOURCE_CORE (paint_tool->core),
options) &&
key == gimp_get_toggle_behavior_mask ())
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (press)
{
paint_tool->status = source_tool->status_set_source;
source_tool->show_source_outline = FALSE;
}
else
{
paint_tool->status = source_tool->status_paint;
source_tool->show_source_outline = TRUE;
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_curves_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorPickMode mode;
const gchar *status;
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
gimp_tool_pop_status (tool, display);
if (state & GDK_SHIFT_MASK)
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = _("Click to add a control point");
}
else if (state & gimp_get_toggle_behavior_mask ())
{
mode = GIMP_COLOR_PICK_MODE_PALETTE;
status = _("Click to add control points to all channels");
}
else
{
mode = GIMP_COLOR_PICK_MODE_NONE;
status = _("Click to locate on curve (try Shift, Ctrl)");
}
GIMP_COLOR_TOOL (tool)->pick_mode = mode;
if (proximity)
gimp_tool_push_status (tool, display, "%s", status);
}
GtkWidget *
gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_paint_options_gui (tool_options);
GtkWidget *vbox2;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *scale;
GtkWidget *combo;
gchar *str;
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
/* fill type */
str = g_strdup_printf (_("Fill Type (%s)"),
gimp_get_mod_string (toggle_mask)),
frame = gimp_prop_enum_radio_frame_new (config, "fill-mode", str, 0, 0);
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
hbox = gimp_prop_pattern_box_new (NULL, GIMP_CONTEXT (tool_options),
NULL, 2,
"pattern-view-type", "pattern-view-size");
gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox,
GIMP_PATTERN_BUCKET_FILL, TRUE);
/* fill selection */
str = g_strdup_printf (_("Affected Area (%s)"),
gimp_get_mod_string (GDK_SHIFT_MASK));
frame = gimp_prop_boolean_radio_frame_new (config, "fill-selection",
str,
_("Fill whole selection"),
_("Fill similar colors"));
g_free (str);
gtk_box_reorder_child (GTK_BOX (gtk_bin_get_child (GTK_BIN (frame))),
g_object_get_data (G_OBJECT (frame), "radio-button"),
1);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = gimp_frame_new (_("Finding Similar Colors"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
g_object_bind_property (config, "fill-selection",
frame, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
gtk_widget_show (vbox2);
/* the fill transparent areas toggle */
button = gimp_prop_check_button_new (config, "fill-transparent",
_("Fill transparent areas"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the sample merged toggle */
button = gimp_prop_check_button_new (config, "sample-merged",
_("Sample merged"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* the threshold scale */
scale = gimp_prop_spin_scale_new (config, "threshold",
_("Threshold"),
1.0, 16.0, 1);
gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* the fill criterion combo */
combo = gimp_prop_enum_combo_box_new (config, "fill-criterion", 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Fill by"));
gtk_box_pack_start (GTK_BOX (vbox2), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
return vbox;
}
static void
gimp_source_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpSourceTool *source_tool = GIMP_SOURCE_TOOL (tool);
GimpSourceOptions *options = GIMP_SOURCE_TOOL_GET_OPTIONS (tool);
GimpSourceCore *source;
source = GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core);
if (proximity)
{
if (gimp_source_core_use_source (source, options))
paint_tool->status_ctrl = source_tool->status_set_source_ctrl;
else
paint_tool->status_ctrl = NULL;
}
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
if (gimp_source_core_use_source (source, options))
{
if (source->src_drawable == NULL)
{
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if (state & toggle_mask)
{
gimp_tool_replace_status (tool, display, "%s",
source_tool->status_set_source);
}
else
{
gimp_tool_replace_status (tool, display, "%s-%s",
gimp_get_mod_string (toggle_mask),
source_tool->status_set_source);
}
}
else
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
source_tool->src_x = source->src_x;
source_tool->src_y = source->src_y;
if (! source->first_stroke)
{
switch (options->align_mode)
{
case GIMP_SOURCE_ALIGN_YES:
source_tool->src_x = coords->x + source->offset_x;
source_tool->src_y = coords->y + source->offset_y;
break;
case GIMP_SOURCE_ALIGN_REGISTERED:
source_tool->src_x = coords->x;
source_tool->src_y = coords->y;
break;
default:
break;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
}
static void
gimp_image_map_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
if (! gimp_image_map_tool_on_guide (im_tool, coords, display))
{
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
}
else
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
if (state & gimp_get_extend_selection_mask ())
{
GimpAlignmentType alignment;
/* switch side */
switch (options->preview_alignment)
{
case GIMP_ALIGN_LEFT: alignment = GIMP_ALIGN_RIGHT; break;
case GIMP_ALIGN_RIGHT: alignment = GIMP_ALIGN_LEFT; break;
case GIMP_ALIGN_TOP: alignment = GIMP_ALIGN_BOTTOM; break;
case GIMP_ALIGN_BOTTOM: alignment = GIMP_ALIGN_TOP; break;
default:
g_return_if_reached ();
}
g_object_set (options, "preview-alignment", alignment, NULL);
}
else if (state & gimp_get_toggle_behavior_mask ())
{
GimpItem *item = GIMP_ITEM (im_tool->drawable);
GimpAlignmentType alignment;
gdouble position;
/* switch orientation */
switch (options->preview_alignment)
{
case GIMP_ALIGN_LEFT: alignment = GIMP_ALIGN_TOP; break;
case GIMP_ALIGN_RIGHT: alignment = GIMP_ALIGN_BOTTOM; break;
case GIMP_ALIGN_TOP: alignment = GIMP_ALIGN_LEFT; break;
case GIMP_ALIGN_BOTTOM: alignment = GIMP_ALIGN_RIGHT; break;
default:
g_return_if_reached ();
}
if (alignment == GIMP_ALIGN_LEFT ||
alignment == GIMP_ALIGN_RIGHT)
{
position = ((coords->x - gimp_item_get_offset_x (item)) /
gimp_item_get_width (item));
}
else
{
position = ((coords->y - gimp_item_get_offset_y (item)) /
gimp_item_get_height (item));
}
g_object_set (options,
"preview-alignment", alignment,
"preview-position", CLAMP (position, 0.0, 1.0),
NULL);
}
else
{
gimp_guide_tool_start_edit (tool, display,
im_tool->percent_guide);
}
}
}
static void
gimp_perspective_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_tool->core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (clone);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
switch (options->clone_mode)
{
case GIMP_PERSPECTIVE_CLONE_MODE_ADJUST:
if (clone_tool->function == TRANSFORM_CREATING)
gimp_perspective_clone_tool_oper_update (tool,
coords, state, TRUE, display);
clone_tool->lastx = coords->x;
clone_tool->lasty = coords->y;
gimp_tool_control_activate (tool->control);
break;
case GIMP_PERSPECTIVE_CLONE_MODE_PAINT:
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
gdouble nnx, nny;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if ((state & (toggle_mask | extend_mask)) == toggle_mask)
{
source_core->set_source = TRUE;
clone_tool->src_display = display;
}
else
{
source_core->set_source = FALSE;
}
GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
press_type, display);
/* Set the coordinates for the reference cross */
gimp_perspective_clone_get_source_point (clone,
coords->x, coords->y,
&nnx, &nny);
clone_tool->src_x = nnx;
clone_tool->src_y = nny;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
break;
}
}
static void
gimp_perspective_clone_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveCloneOptions *options;
GimpImage *image;
GimpToolClass *tool_class;
GimpCursorType cursor = GIMP_CURSOR_MOUSE;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
image = gimp_display_get_image (display);
if (gimp_image_coords_in_active_pickable (image, coords,
FALSE, TRUE))
{
cursor = GIMP_CURSOR_MOUSE;
}
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
{
/* perspective cursors */
cursor = gimp_tool_control_get_cursor (tool->control);
switch (clone_tool->function)
{
case TRANSFORM_HANDLE_NW:
cursor = GIMP_CURSOR_CORNER_TOP_LEFT;
break;
case TRANSFORM_HANDLE_NE:
cursor = GIMP_CURSOR_CORNER_TOP_RIGHT;
break;
case TRANSFORM_HANDLE_SW:
cursor = GIMP_CURSOR_CORNER_BOTTOM_LEFT;
break;
case TRANSFORM_HANDLE_SE:
cursor = GIMP_CURSOR_CORNER_BOTTOM_RIGHT;
break;
default:
cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
break;
}
}
else
{
GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
if ((state & (toggle_mask | extend_mask)) == toggle_mask)
{
cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
}
else if (! GIMP_SOURCE_CORE (GIMP_PAINT_TOOL (tool)->core)->src_drawable)
{
modifier = GIMP_CURSOR_MODIFIER_BAD;
}
}
gimp_tool_control_set_cursor (tool->control, cursor);
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
/* If we are in adjust mode, skip the GimpBrushClass when chaining up.
* This ensures that the cursor will be set regardless of
* GimpBrushTool::show_cursor (see bug #354933).
*/
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
tool_class = GIMP_TOOL_CLASS (g_type_class_peek_parent (parent_class));
else
tool_class = GIMP_TOOL_CLASS (parent_class);
tool_class->cursor_update (tool, coords, state, display);
}
GtkWidget *
gimp_document_view_new (GimpViewType view_type,
GimpContainer *container,
GimpContext *context,
gint view_size,
gint view_border_width,
GimpMenuFactory *menu_factory)
{
GimpDocumentView *document_view;
GimpContainerEditor *editor;
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (view_size > 0 &&
view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, FALSE);
g_return_val_if_fail (view_border_width >= 0 &&
view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,
FALSE);
g_return_val_if_fail (menu_factory == NULL ||
GIMP_IS_MENU_FACTORY (menu_factory), NULL);
document_view = g_object_new (GIMP_TYPE_DOCUMENT_VIEW,
"view-type", view_type,
"container", container,
"context", context,
"view-size", view_size,
"view-border-width", view_border_width,
"menu-factory", menu_factory,
"menu-identifier", "<Documents>",
"ui-path", "/documents-popup",
NULL);
editor = GIMP_CONTAINER_EDITOR (document_view);
document_view->open_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
"documents-open",
"documents-raise-or-open",
GDK_SHIFT_MASK,
"documents-file-open-dialog",
gimp_get_toggle_behavior_mask (),
NULL);
gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (document_view->open_button),
GIMP_TYPE_IMAGEFILE);
document_view->remove_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
"documents-remove", NULL);
gimp_container_view_enable_dnd (editor->view,
GTK_BUTTON (document_view->remove_button),
GIMP_TYPE_IMAGEFILE);
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
"documents-clear", NULL);
document_view->refresh_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
"documents-recreate-preview",
"documents-reload-previews",
GDK_SHIFT_MASK,
"documents-remove-dangling",
gimp_get_toggle_behavior_mask (),
NULL);
if (view_type == GIMP_VIEW_TYPE_LIST)
{
GtkWidget *dnd_widget;
dnd_widget = gimp_container_view_get_dnd_widget (editor->view);
gimp_dnd_uri_list_source_add (dnd_widget,
gimp_document_view_drag_uri_list,
editor);
}
gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor->view)),
editor);
return GTK_WIDGET (document_view);
}
static void
gimp_color_picker_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpColorPickerTool *picker_tool = GIMP_COLOR_PICKER_TOOL (tool);
GimpColorPickerOptions *options = GIMP_COLOR_PICKER_TOOL_GET_OPTIONS (tool);
GdkModifierType toggle_mask;
toggle_mask = gimp_get_toggle_behavior_mask ();
GIMP_COLOR_TOOL (tool)->pick_mode = options->pick_mode;
gimp_tool_pop_status (tool, display);
if (proximity)
{
gchar *status_help = NULL;
GdkModifierType shift_mod = 0;
if (! picker_tool->gui)
shift_mod = GDK_SHIFT_MASK;
switch (options->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
status_help = gimp_suggest_modifiers (_("Click in any image to view"
" its color"),
shift_mod & ~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
status_help = gimp_suggest_modifiers (_("Click in any image to pick"
" the foreground color"),
(shift_mod | toggle_mask) &
~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
status_help = gimp_suggest_modifiers (_("Click in any image to pick"
" the background color"),
(shift_mod | toggle_mask) &
~state,
NULL, NULL, NULL);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
status_help = gimp_suggest_modifiers (_("Click in any image to add"
" the color to the palette"),
shift_mod & ~state,
NULL, NULL, NULL);
break;
}
if (status_help != NULL)
{
gimp_tool_push_status (tool, display, "%s", status_help);
g_free (status_help);
}
}
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity,
display);
}
