static void
gimp_image_map_tool_gegl_notify (GObject *config,
const GParamSpec *pspec,
GimpImageMapTool *im_tool)
{
if (im_tool->image_map)
{
gimp_tool_control_set_preserve (GIMP_TOOL (im_tool)->control, TRUE);
gimp_image_map_tool_create_map (im_tool);
gimp_tool_control_set_preserve (GIMP_TOOL (im_tool)->control, FALSE);
gimp_image_map_tool_preview (im_tool);
}
}
static gboolean
gimp_image_map_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpImageMapTool *image_map_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpToolInfo *tool_info = tool->tool_info;
GimpDrawable *drawable;
/* set display so the dialog can be hidden on display destruction */
tool->display = display;
if (! image_map_tool->shell)
{
GimpImageMapToolClass *klass;
GtkWidget *shell;
GtkWidget *vbox;
GtkWidget *toggle;
const gchar *stock_id;
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (image_map_tool);
stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool_info));
image_map_tool->shell = shell =
gimp_tool_dialog_new (tool_info,
display->shell,
klass->shell_desc,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect_object (shell, "response",
G_CALLBACK (gimp_image_map_tool_response),
G_OBJECT (image_map_tool), 0);
image_map_tool->main_vbox = vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (shell)->vbox), vbox);
if (klass->settings_name)
gimp_image_map_tool_add_settings_gui (image_map_tool);
/* The preview toggle */
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview",
_("_Preview"));
gtk_box_pack_end (GTK_BOX (image_map_tool->main_vbox), toggle,
FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect_object (tool_info->tool_options, "notify::preview",
G_CALLBACK (gimp_image_map_tool_notify_preview),
image_map_tool, 0);
/* Fill in subclass widgets */
gimp_image_map_tool_dialog (image_map_tool);
gtk_widget_show (vbox);
if (image_map_tool->operation)
g_signal_connect_object (tool_info->gimp->config, "notify::use-gegl",
G_CALLBACK (gimp_image_map_tool_gegl_notify),
image_map_tool, 0);
}
drawable = gimp_image_get_active_drawable (display->image);
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (image_map_tool->shell),
GIMP_VIEWABLE (drawable),
GIMP_CONTEXT (tool_info->tool_options));
gtk_widget_show (image_map_tool->shell);
image_map_tool->drawable = drawable;
gimp_image_map_tool_create_map (image_map_tool);
return TRUE;
}
static void
gimp_gegl_tool_operation_changed (GtkWidget *widget,
GimpGeglTool *tool)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter))
return;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
if (tool->operation)
{
g_free (tool->operation);
tool->operation = NULL;
}
if (tool->config)
{
g_object_unref (tool->config);
tool->config = NULL;
}
gtk_tree_model_get (model, &iter,
COLUMN_NAME, &tool->operation,
-1);
if (! tool->operation)
return;
if (GIMP_IMAGE_MAP_TOOL (tool)->image_map)
{
gimp_image_map_clear (GIMP_IMAGE_MAP_TOOL (tool)->image_map);
g_object_unref (GIMP_IMAGE_MAP_TOOL (tool)->image_map);
GIMP_IMAGE_MAP_TOOL (tool)->image_map = NULL;
}
gegl_node_set (GIMP_IMAGE_MAP_TOOL (tool)->operation,
"operation", tool->operation,
NULL);
gimp_image_map_tool_create_map (GIMP_IMAGE_MAP_TOOL (tool));
tool->config = gimp_gegl_tool_get_config (tool);
if (tool->options_table)
{
gtk_container_remove (GTK_CONTAINER (tool->options_frame),
tool->options_table);
tool->options_table = NULL;
}
if (tool->config)
{
g_signal_connect_object (tool->config, "notify",
G_CALLBACK (gimp_gegl_tool_config_notify),
G_OBJECT (tool), 0);
tool->options_table =
gimp_prop_table_new (G_OBJECT (tool->config),
G_TYPE_FROM_INSTANCE (tool->config),
GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (tool)));
gtk_container_add (GTK_CONTAINER (tool->options_frame),
tool->options_table);
gtk_widget_show (tool->options_table);
}
gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool));
}
static gboolean
gimp_image_map_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool);
GimpToolInfo *tool_info = tool->tool_info;
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpDisplayShell *shell = gimp_display_get_shell (display);
if (! drawable)
return FALSE;
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Cannot modify the pixels of layer groups."));
return FALSE;
}
if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer's pixels are locked."));
return FALSE;
}
if (! gimp_item_is_visible (GIMP_ITEM (drawable)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("The active layer is not visible."));
return FALSE;
}
if (im_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker),
FALSE);
/* set display so the dialog can be hidden on display destruction */
tool->display = display;
if (im_tool->config)
gimp_config_reset (GIMP_CONFIG (im_tool->config));
if (! im_tool->gui)
{
GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *toggle;
gchar *operation_name;
/* disabled for at least GIMP 2.8 */
im_tool->overlay = FALSE;
im_tool->gui =
gimp_tool_gui_new (tool_info,
im_tool->title,
im_tool->description,
im_tool->icon_name,
im_tool->help_id,
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
im_tool->overlay,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK);
gimp_tool_gui_set_alternative_button_order (im_tool->gui,
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gimp_tool_gui_get_vbox (im_tool->gui);
g_signal_connect_object (im_tool->gui, "response",
G_CALLBACK (gimp_image_map_tool_response),
G_OBJECT (im_tool), 0);
if (im_tool->config && klass->settings_name)
{
GType type = G_TYPE_FROM_INSTANCE (im_tool->config);
GimpContainer *settings;
GFile *settings_file;
GFile *default_folder;
GtkWidget *settings_ui;
settings = gimp_gegl_config_get_container (type);
if (! gimp_list_get_sort_func (GIMP_LIST (settings)))
gimp_list_set_sort_func (GIMP_LIST (settings),
(GCompareFunc) gimp_settings_compare);
settings_file = gimp_tool_info_get_options_file (tool_info,
".settings");
default_folder = gimp_directory_file (klass->settings_name, NULL);
settings_ui = klass->get_settings_ui (im_tool,
settings,
settings_file,
klass->import_dialog_title,
klass->export_dialog_title,
im_tool->help_id,
default_folder,
&im_tool->settings_box);
g_object_unref (default_folder);
g_object_unref (settings_file);
gtk_box_pack_start (GTK_BOX (vbox), settings_ui, FALSE, FALSE, 0);
gtk_widget_show (settings_ui);
}
/* The gamma hack toggle */
toggle = gtk_check_button_new_with_label ("Gamma hack (temp hack, please ignore)");
gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gamma_hack),
im_tool);
/* The preview and split view toggles */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview", NULL);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0);
gtk_widget_show (toggle);
toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options),
"preview-split", NULL);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_object_bind_property (G_OBJECT (tool_info->tool_options), "preview",
toggle, "sensitive",
G_BINDING_SYNC_CREATE);
/* The area combo */
gegl_node_get (im_tool->operation,
"operation", &operation_name,
NULL);
im_tool->region_combo =
gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options),
"region",
0, 0);
gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo,
FALSE, FALSE, 0);
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
gtk_widget_show (im_tool->region_combo);
}
g_free (operation_name);
/* Fill in subclass widgets */
gimp_image_map_tool_dialog (im_tool);
}
else
{
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
}
gimp_tool_gui_set_shell (im_tool->gui, shell);
gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable));
gimp_tool_gui_show (im_tool->gui);
im_tool->drawable = drawable;
gimp_image_map_tool_create_map (im_tool);
gimp_image_map_tool_preview (im_tool);
return TRUE;
}
void
gimp_image_map_tool_get_operation (GimpImageMapTool *im_tool)
{
GimpImageMapToolClass *klass;
GimpToolInfo *tool_info;
gchar *operation_name;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool));
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool);
tool_info = GIMP_TOOL (im_tool)->tool_info;
if (im_tool->image_map)
{
gimp_image_map_abort (im_tool->image_map);
g_object_unref (im_tool->image_map);
im_tool->image_map = NULL;
}
if (im_tool->operation)
{
g_object_unref (im_tool->operation);
im_tool->operation = NULL;
}
if (im_tool->config)
{
g_signal_handlers_disconnect_by_func (im_tool->config,
gimp_image_map_tool_config_notify,
im_tool);
g_object_unref (im_tool->config);
im_tool->config = NULL;
}
if (im_tool->default_config)
{
g_object_unref (im_tool->default_config);
im_tool->default_config = NULL;
}
if (im_tool->title)
{
g_free (im_tool->title);
im_tool->title = NULL;
}
if (im_tool->description)
{
g_free (im_tool->description);
im_tool->description = NULL;
}
if (im_tool->undo_desc)
{
g_free (im_tool->undo_desc);
im_tool->undo_desc = NULL;
}
if (im_tool->icon_name)
{
g_free (im_tool->icon_name);
im_tool->icon_name = NULL;
}
if (im_tool->help_id)
{
g_free (im_tool->help_id);
im_tool->help_id = NULL;
}
operation_name = klass->get_operation (im_tool,
&im_tool->title,
&im_tool->description,
&im_tool->undo_desc,
&im_tool->icon_name,
&im_tool->help_id);
if (! operation_name)
operation_name = g_strdup ("gegl:nop");
if (! im_tool->title)
im_tool->title = g_strdup (tool_info->blurb);
if (! im_tool->description)
im_tool->description = g_strdup (im_tool->title);
if (! im_tool->undo_desc)
im_tool->undo_desc = g_strdup (tool_info->blurb);
if (! im_tool->icon_name)
im_tool->icon_name =
g_strdup (gimp_viewable_get_icon_name (GIMP_VIEWABLE (tool_info)));
if (! im_tool->help_id)
im_tool->help_id = g_strdup (tool_info->help_id);
im_tool->operation = gegl_node_new_child (NULL,
"operation", operation_name,
NULL);
im_tool->config = G_OBJECT (gimp_gegl_config_new (operation_name,
im_tool->icon_name,
GIMP_TYPE_SETTINGS));
gimp_gegl_config_sync_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
gimp_gegl_config_connect_node (GIMP_OBJECT (im_tool->config),
im_tool->operation);
if (im_tool->gui)
{
gimp_tool_gui_set_title (im_tool->gui, im_tool->title);
gimp_tool_gui_set_description (im_tool->gui, im_tool->description);
gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name);
gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id);
}
if (gegl_operation_get_key (operation_name, "position-dependent"))
{
if (im_tool->gui)
gtk_widget_show (im_tool->region_combo);
}
else
{
if (im_tool->gui)
gtk_widget_hide (im_tool->region_combo);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool),
"region", GIMP_IMAGE_MAP_REGION_SELECTION,
NULL);
}
g_free (operation_name);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (im_tool),
"preview-split", FALSE,
"preview-position", 0.5,
NULL);
if (im_tool->config)
g_signal_connect_object (im_tool->config, "notify",
G_CALLBACK (gimp_image_map_tool_config_notify),
G_OBJECT (im_tool), 0);
if (GIMP_TOOL (im_tool)->drawable)
gimp_image_map_tool_create_map (im_tool);
}
void
gimp_image_map_tool_get_operation (GimpImageMapTool *image_map_tool)
{
GimpImageMapToolClass *klass;
gchar *operation_name;
g_return_if_fail (GIMP_IS_IMAGE_MAP_TOOL (image_map_tool));
klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (image_map_tool);
if (image_map_tool->image_map)
{
gimp_image_map_abort (image_map_tool->image_map);
g_object_unref (image_map_tool->image_map);
image_map_tool->image_map = NULL;
}
if (image_map_tool->operation)
{
g_object_unref (image_map_tool->operation);
image_map_tool->operation = NULL;
}
if (image_map_tool->config)
{
g_signal_handlers_disconnect_by_func (image_map_tool->config,
gimp_image_map_tool_config_notify,
image_map_tool);
g_object_unref (image_map_tool->config);
image_map_tool->config = NULL;
}
if (image_map_tool->undo_desc)
{
g_free (image_map_tool->undo_desc);
image_map_tool->undo_desc = NULL;
}
image_map_tool->operation = klass->get_operation (image_map_tool,
&image_map_tool->config,
&image_map_tool->undo_desc);
if (! image_map_tool->undo_desc)
image_map_tool->undo_desc =
g_strdup (GIMP_TOOL (image_map_tool)->tool_info->blurb);
gegl_node_get (image_map_tool->operation,
"operation", &operation_name,
NULL);
if (operation_name &&
gegl_operation_get_key (operation_name, "position-dependent"))
{
if (image_map_tool->region_combo)
gtk_widget_show (image_map_tool->region_combo);
}
else
{
if (image_map_tool->region_combo)
gtk_widget_show (image_map_tool->region_combo);
g_object_set (GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (image_map_tool),
"region", GIMP_IMAGE_MAP_REGION_SELECTION,
NULL);
}
g_free (operation_name);
if (image_map_tool->config)
g_signal_connect_object (image_map_tool->config, "notify",
G_CALLBACK (gimp_image_map_tool_config_notify),
G_OBJECT (image_map_tool), 0);
if (GIMP_TOOL (image_map_tool)->drawable)
gimp_image_map_tool_create_map (image_map_tool);
}
