static GObject * gimp_align_tool_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GimpTool *tool; GimpAlignTool *align_tool; GtkContainer *container; GObject *options; object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); tool = GIMP_TOOL (object); align_tool = GIMP_ALIGN_TOOL (object); options = G_OBJECT (gimp_tool_get_options (tool)); container = GTK_CONTAINER (g_object_get_data (options, "controls-container")); align_tool->controls = gimp_align_tool_controls (align_tool); gtk_container_add (container, align_tool->controls); gtk_widget_show (align_tool->controls); return object; }
static gboolean gimp_cage_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: if (! ct->cage_complete && ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_tool_remove_last_handle (ct); } else if (ct->cage_complete && ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_config_remove_selected_points(ct->config); /* if the cage have less than 3 handles, we reopen it */ if (gimp_cage_config_get_n_points(ct->config) <= 2) ct->cage_complete = FALSE; } return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: if (ct->cage_complete == FALSE && gimp_cage_config_get_n_points (ct->config) > 2) { g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_DEFORM, NULL); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_commit (ct->image_map); g_object_unref (ct->image_map); ct->image_map = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (display)); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } break; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static void gimp_cage_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); switch (action) { case GIMP_TOOL_ACTION_PAUSE: case GIMP_TOOL_ACTION_RESUME: break; case GIMP_TOOL_ACTION_HALT: if (ct->config) { g_object_unref (ct->config); ct->config = NULL; } if (ct->coef) { g_object_unref (ct->coef); ct->coef = NULL; } if (ct->render_node) { g_object_unref (ct->render_node); ct->render_node = NULL; ct->coef_node = NULL; ct->cage_node = NULL; } if (ct->image_map) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_abort (ct->image_map); g_object_unref (ct->image_map); ct->image_map = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (tool->display)); } tool->display = NULL; g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_CAGE_CHANGE, NULL); break; } GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); }
static gboolean gimp_cage_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpCageTool *ct = GIMP_CAGE_TOOL (tool); switch (kevent->keyval) { case GDK_KEY_BackSpace: if (ct->tool_state == CAGE_STATE_WAIT) { gimp_cage_tool_remove_last_handle (ct); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_cage_config_remove_selected_points(ct->config); /* if the cage have less than 3 handles, we reopen it */ if (gimp_cage_config_get_n_points(ct->config) <= 2) { ct->tool_state = CAGE_STATE_WAIT; } gimp_cage_tool_compute_coef (ct); gimp_cage_tool_render_node_update (ct); } return TRUE; case GDK_KEY_Return: case GDK_KEY_KP_Enter: case GDK_KEY_ISO_Enter: if (! gimp_cage_tool_is_complete (ct) && gimp_cage_config_get_n_points (ct->config) > 2) { g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_DEFORM, NULL); } else if (ct->tool_state == DEFORM_STATE_WAIT) { gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); } return TRUE; case GDK_KEY_Escape: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); return TRUE; default: break; } return FALSE; }
static void gimp_tool_constructed (GObject *object) { GimpTool *tool = GIMP_TOOL (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_TOOL_INFO (tool->tool_info)); g_signal_connect_object (gimp_tool_get_options (tool), "notify", G_CALLBACK (gimp_tool_options_notify), tool, 0); }
static void gimp_brush_tool_constructed (GObject *object) { GimpTool *tool = GIMP_TOOL (object); GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_BRUSH_CORE (paint_tool->core)); g_signal_connect_object (gimp_tool_get_options (tool), "brush-changed", G_CALLBACK (gimp_brush_tool_brush_changed), paint_tool, 0); g_signal_connect_object (paint_tool->core, "set-brush", G_CALLBACK (gimp_brush_tool_set_brush), paint_tool, 0); }
static void gimp_cage_tool_halt (GimpCageTool *ct) { GimpTool *tool = GIMP_TOOL (ct); if (ct->config) { g_object_unref (ct->config); ct->config = NULL; } if (ct->coef) { g_object_unref (ct->coef); ct->coef = NULL; } if (ct->render_node) { g_object_unref (ct->render_node); ct->render_node = NULL; ct->coef_node = NULL; ct->cage_node = NULL; } if (ct->image_map) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_abort (ct->image_map); g_object_unref (ct->image_map); ct->image_map = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (tool->display)); } tool->display = NULL; g_object_set (gimp_tool_get_options (tool), "cage-mode", GIMP_CAGE_MODE_CAGE_CHANGE, NULL); }
static void gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, gdouble x, gdouble y, const Babl *sample_format, const GimpRGB *color, gint color_index) { GimpTool *tool = GIMP_TOOL (color_tool); GimpContext *context; /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GtkWidget *widget; if (babl_format_is_palette (sample_format)) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-indexed-palette"); if (widget) { GimpColormapEditor *editor; editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); gimp_colormap_editor_set_index (editor, color_index, NULL); } } if (TRUE) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-palette-editor"); if (widget) { GimpPaletteEditor *editor; gint index; editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); index = gimp_palette_editor_get_index (editor, color); if (index != -1) gimp_palette_editor_set_index (editor, index, NULL); } } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell)); GtkWidget *dockable; dockable = gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)), tool->display->gimp, gimp_dialog_factory_get_singleton (), screen, "gimp-palette-editor"); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
static void gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, GimpImageType sample_type, GimpRGB *color, gint color_index) { GimpTool *tool = GIMP_TOOL (color_tool); GimpContext *context; GimpDialogFactory *dialog_factory; /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); dialog_factory = gimp_dialog_factory_from_name ("dock"); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GimpSessionInfo *info; if (GIMP_IMAGE_TYPE_IS_INDEXED (sample_type)) { info = gimp_dialog_factory_find_session_info (dialog_factory, "gimp-indexed-palette"); if (info && info->widget) { GimpColormapEditor *editor; editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget))); gimp_colormap_editor_set_index (editor, color_index, NULL); } } if (TRUE) { info = gimp_dialog_factory_find_session_info (dialog_factory, "gimp-palette-editor"); if (info && info->widget) { GimpPaletteEditor *editor; gint index; editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (info->widget))); index = gimp_palette_editor_get_index (editor, color); if (index != -1) gimp_palette_editor_set_index (editor, index, NULL); } } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GdkScreen *screen; GtkWidget *dockable; screen = gtk_widget_get_screen (tool->display->shell); dockable = gimp_dialog_factory_dialog_raise (dialog_factory, screen, "gimp-palette-editor", -1); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
static void gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool) { GimpTool *tool = GIMP_TOOL (picker_tool); GtkWidget *content_area; GtkWidget *hbox; GtkWidget *frame; GimpRGB color; g_return_if_fail (tool->drawable != NULL); picker_tool->dialog = gimp_tool_dialog_new (tool->tool_info, gimp_display_get_shell (tool->display), _("Color Picker Information"), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_focus_on_map (GTK_WINDOW (picker_tool->dialog), FALSE); gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (picker_tool->dialog), GIMP_VIEWABLE (tool->drawable), GIMP_CONTEXT (gimp_tool_get_options (tool))); g_signal_connect (picker_tool->dialog, "response", G_CALLBACK (gimp_color_picker_tool_info_response), picker_tool); content_area = gtk_dialog_get_content_area (GTK_DIALOG (picker_tool->dialog)); hbox = gtk_hbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); picker_tool->color_frame1 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1), GIMP_COLOR_FRAME_MODE_PIXEL); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame1); picker_tool->color_frame2 = gimp_color_frame_new (); gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2), GIMP_COLOR_FRAME_MODE_RGB); gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2, FALSE, FALSE, 0); gtk_widget_show (picker_tool->color_frame2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0); picker_tool->color_area = gimp_color_area_new (&color, gimp_drawable_has_alpha (tool->drawable) ? GIMP_COLOR_AREA_LARGE_CHECKS : GIMP_COLOR_AREA_FLAT, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); gtk_widget_set_size_request (picker_tool->color_area, 48, -1); gtk_drag_dest_unset (picker_tool->color_area); gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area); gtk_widget_show (picker_tool->color_area); }