From b51d761fccde1d9274081a0493e9b391f88726f8 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Sun, 11 Mar 2001 17:24:47 +0000 Subject: [PATCH] app/Makefile.am app/apptypes.h new subclass of GimpDrawableListView (the 2001-03-11 Michael Natterer * app/Makefile.am * app/apptypes.h * app/gimplayerlistview.[ch]: new subclass of GimpDrawableListView (the upcoming replacement of the layers dialog). Connects to the new GimpLayer signals using the layer container as signal proxy (see below). * app/gimpcontainerview.[ch]: made "set_container" a virtual function. This is needed by the GimpLayerListView to connect/disconnect signals. Subclasses implementing this method MUST obey the following order of instructions: 1. disconnect from signals related to GimpContainerView->container 2. chain up (!!!) 3. connect to signals related to GimpContainerView->container And yes, I will add DocBook files for all those new objects :) * app/gimppreview.[ch]: made "border_color" a GimpRGB instead of guchar[3]. Added gimp_preview_set_border_color(). * app/gimpcontainergridview.c * app/gimplayerlistitem.c: use gimp_preview_set_border_color(). * app/gimpcontainerlistview.c * app/gimpdrawablelistview.c: cleanup. * app/gimpdrawablelistitem.c: we can safely asume that our parent widget is a GimpDrawableListView and use it's "reorder_drawable" function pointer (after checking that it's there). * app/gimplistitem.c: connect the correct DND type when changing the container of a list item with "reorderable" enabled. * app/gimplayer.[ch]: added accessors and "*_changed" signals for layer->mode, layer->opacity and layer->preserve_trans. * app/disp_callbacks.c: fixed a FIXME: use the correct bucket fill tool context again. * app/tools/paint_options.[ch]: paint_mode_menu_new(): added a boolean which toggles the "Behind" item on/off to the same constructor can be used for all paint mode menus. * app/tools/gimptoolinfo.c: rect. select is the standard tool again. * app/brush_select.c * app/floating_sel.c * app/gimpimage.c * app/layers_dialog.c * app/pdb/layer_cmds.c * app/tools/gimpeditselectiontool.c * tools/pdbgen/pdb/layer.pdb: use the new layer accessors and the paint_mode_menu constructor. * app/commands.c * app/gdisplay.c * app/menus.c * app/undo.c * app/tools/gimppainttool.c * app/tools/gimptool.c * app/tools/paint_options.c * app/tools/tool_manager.c: put the #warning's back inside #ifdef __GNUC__ --- ChangeLog | 67 +++ app/Makefile.am | 2 + app/actions/help-commands.c | 4 +- app/apptypes.h | 1 + app/brush_select.c | 2 +- app/commands.c | 4 +- app/core/gimpimage-guides.c | 4 +- app/core/gimpimage-merge.c | 4 +- app/core/gimpimage-projection.c | 4 +- app/core/gimpimage-resize.c | 4 +- app/core/gimpimage-scale.c | 4 +- app/core/gimpimage-undo-push.c | 8 +- app/core/gimpimage.c | 4 +- app/core/gimplayer-floating-sel.c | 12 +- app/core/gimplayer.c | 124 +++++- app/core/gimplayer.h | 33 +- app/core/gimpprojection-construct.c | 4 +- app/core/gimpprojection.c | 4 +- app/core/gimptoolinfo.c | 5 +- app/disp_callbacks.c | 16 +- app/display/gimpdisplay-callbacks.c | 16 +- app/display/gimpdisplay.c | 4 +- app/display/gimpdisplayshell-callbacks.c | 16 +- app/floating_sel.c | 12 +- app/gdisplay.c | 4 +- app/gimpcontainergridview.c | 26 +- app/gimpcontainerlistview.c | 9 + app/gimpcontainerview.c | 23 + app/gimpcontainerview.h | 2 + app/gimpdrawablelistitem.c | 28 +- app/gimpdrawablelistview.c | 76 +++- app/gimpimage.c | 4 +- app/gimplayer.c | 124 +++++- app/gimplayer.h | 33 +- app/gimplayerlistitem.c | 87 ++-- app/gimplayerlistview.c | 511 +++++++++++++++++++++++ app/gimplayerlistview.h | 62 +++ app/gimplistitem.c | 20 +- app/gimppreview.c | 115 ++--- app/gimppreview.h | 13 +- app/gui/brush-select.c | 2 +- app/gui/commands.c | 4 +- app/gui/help-commands.c | 4 +- app/gui/layers-dialog.c | 61 ++- app/gui/menus.c | 4 +- app/layers_dialog.c | 61 ++- app/menus.c | 4 +- app/menus/menus.c | 4 +- app/paint/gimppaintcore.c | 8 +- app/pdb/layer_cmds.c | 20 +- app/tools/gimpbrushtool.c | 8 +- app/tools/gimpeditselectiontool.c | 6 +- app/tools/gimppaintoptions-gui.c | 80 ++-- app/tools/gimppaintoptions-gui.h | 1 + app/tools/gimppainttool.c | 8 +- app/tools/gimptool.c | 16 +- app/tools/gimptoolinfo.c | 5 +- app/tools/paint_options.c | 80 ++-- app/tools/paint_options.h | 1 + app/tools/tool_manager.c | 9 +- app/undo.c | 8 +- app/widgets/gimpcontainergridview.c | 26 +- app/widgets/gimpcontainerlistview.c | 9 + app/widgets/gimpcontainerview.c | 23 + app/widgets/gimpcontainerview.h | 2 + app/widgets/gimpdrawablelistitem.c | 28 +- app/widgets/gimpdrawablelistview.c | 76 +++- app/widgets/gimpdrawabletreeview.c | 76 +++- app/widgets/gimpitemfactory.c | 4 +- app/widgets/gimpitemlistview.c | 76 +++- app/widgets/gimpitemtreeview.c | 76 +++- app/widgets/gimplayerlistitem.c | 87 ++-- app/widgets/gimplayerlistview.c | 511 +++++++++++++++++++++++ app/widgets/gimplayerlistview.h | 62 +++ app/widgets/gimplayertreeview.c | 511 +++++++++++++++++++++++ app/widgets/gimplayertreeview.h | 62 +++ app/widgets/gimplistitem.c | 20 +- app/widgets/gimppreview.c | 115 ++--- app/widgets/gimppreview.h | 13 +- app/widgets/gimppreviewrenderer.c | 115 ++--- app/widgets/gimppreviewrenderer.h | 13 +- app/widgets/gimpview.c | 115 ++--- app/widgets/gimpview.h | 13 +- app/widgets/gimpviewrenderer.c | 115 ++--- app/widgets/gimpviewrenderer.h | 13 +- tools/pdbgen/pdb/layer.pdb | 14 +- 86 files changed, 3343 insertions(+), 721 deletions(-) create mode 100644 app/gimplayerlistview.c create mode 100644 app/gimplayerlistview.h create mode 100644 app/widgets/gimplayerlistview.c create mode 100644 app/widgets/gimplayerlistview.h create mode 100644 app/widgets/gimplayertreeview.c create mode 100644 app/widgets/gimplayertreeview.h diff --git a/ChangeLog b/ChangeLog index 51fff34c7d..12390ba82a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,70 @@ +2001-03-11 Michael Natterer + + * app/Makefile.am + * app/apptypes.h + * app/gimplayerlistview.[ch]: new subclass of GimpDrawableListView + (the upcoming replacement of the layers dialog). Connects to the + new GimpLayer signals using the layer container as signal proxy + (see below). + + * app/gimpcontainerview.[ch]: made "set_container" a virtual + function. This is needed by the GimpLayerListView to + connect/disconnect signals. Subclasses implementing this method + MUST obey the following order of instructions: + + 1. disconnect from signals related to GimpContainerView->container + 2. chain up (!!!) + 3. connect to signals related to GimpContainerView->container + + And yes, I will add DocBook files for all those new objects :) + + * app/gimppreview.[ch]: made "border_color" a GimpRGB instead of + guchar[3]. Added gimp_preview_set_border_color(). + + * app/gimpcontainergridview.c + * app/gimplayerlistitem.c: use gimp_preview_set_border_color(). + + * app/gimpcontainerlistview.c + * app/gimpdrawablelistview.c: cleanup. + + * app/gimpdrawablelistitem.c: we can safely asume that our parent + widget is a GimpDrawableListView and use it's "reorder_drawable" + function pointer (after checking that it's there). + + * app/gimplistitem.c: connect the correct DND type when changing + the container of a list item with "reorderable" enabled. + + * app/gimplayer.[ch]: added accessors and "*_changed" signals for + layer->mode, layer->opacity and layer->preserve_trans. + + * app/disp_callbacks.c: fixed a FIXME: use the correct bucket fill + tool context again. + + * app/tools/paint_options.[ch]: paint_mode_menu_new(): added a + boolean which toggles the "Behind" item on/off to the same + constructor can be used for all paint mode menus. + + * app/tools/gimptoolinfo.c: rect. select is the standard tool again. + + * app/brush_select.c + * app/floating_sel.c + * app/gimpimage.c + * app/layers_dialog.c + * app/pdb/layer_cmds.c + * app/tools/gimpeditselectiontool.c + * tools/pdbgen/pdb/layer.pdb: use the new layer accessors and the + paint_mode_menu constructor. + + * app/commands.c + * app/gdisplay.c + * app/menus.c + * app/undo.c + * app/tools/gimppainttool.c + * app/tools/gimptool.c + * app/tools/paint_options.c + * app/tools/tool_manager.c: put the #warning's back inside + #ifdef __GNUC__ + 2001-03-10 Daniel Egger * plug-ins/common/sobel.c: Applied patch from diff --git a/app/Makefile.am b/app/Makefile.am index 1020d7dac8..139de8ed66 100644 --- a/app/Makefile.am +++ b/app/Makefile.am @@ -317,6 +317,8 @@ gimp_SOURCES = \ gimpimagepreview.c \ gimplayerlistitem.h \ gimplayerlistitem.c \ + gimplayerlistview.h \ + gimplayerlistview.c \ gimplistitem.h \ gimplistitem.c \ gimppalettepreview.h \ diff --git a/app/actions/help-commands.c b/app/actions/help-commands.c index a1b105d452..adb85f0a30 100644 --- a/app/actions/help-commands.c +++ b/app/actions/help-commands.c @@ -1161,7 +1161,9 @@ tools_select_cmd_callback (GtkWidget *widget, gimp_context_set_tool (gimp_context_get_user (), tool_info); - /* #warning FIXME (let the tool manager to this stuff) */ +#ifdef __GNUC__ +#warning FIXME (let the tool manager to this stuff) +#endif /* Paranoia */ active_tool->drawable = NULL; diff --git a/app/apptypes.h b/app/apptypes.h index 554c55b6f9..a01671ce89 100644 --- a/app/apptypes.h +++ b/app/apptypes.h @@ -104,6 +104,7 @@ typedef struct _GimpContainerListView GimpContainerListView; typedef struct _GimpContainerGridView GimpContainerGridView; typedef struct _GimpDataFactoryView GimpDataFactoryView; typedef struct _GimpDrawableListView GimpDrawableListView; +typedef struct _GimpLayerListView GimpLayerListView; typedef struct _GimpListItem GimpListItem; typedef struct _GimpDrawableListItem GimpDrawableListItem; diff --git a/app/brush_select.c b/app/brush_select.c index 946d207512..c3ff253581 100644 --- a/app/brush_select.c +++ b/app/brush_select.c @@ -270,7 +270,7 @@ brush_select_new (gchar *title, /* Create the paint mode option menu */ bsp->option_menu = - paint_mode_menu_new (paint_mode_menu_callback, (gpointer) bsp, + paint_mode_menu_new (paint_mode_menu_callback, (gpointer) bsp, TRUE, gimp_context_get_paint_mode (bsp->context)); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Mode:"), 1.0, 0.5, diff --git a/app/commands.c b/app/commands.c index a1b105d452..adb85f0a30 100644 --- a/app/commands.c +++ b/app/commands.c @@ -1161,7 +1161,9 @@ tools_select_cmd_callback (GtkWidget *widget, gimp_context_set_tool (gimp_context_get_user (), tool_info); - /* #warning FIXME (let the tool manager to this stuff) */ +#ifdef __GNUC__ +#warning FIXME (let the tool manager to this stuff) +#endif /* Paranoia */ active_tool->drawable = NULL; diff --git a/app/core/gimpimage-guides.c b/app/core/gimpimage-guides.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage-guides.c +++ b/app/core/gimpimage-guides.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpimage-merge.c b/app/core/gimpimage-merge.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage-merge.c +++ b/app/core/gimpimage-merge.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpimage-projection.c b/app/core/gimpimage-projection.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage-projection.c +++ b/app/core/gimpimage-projection.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpimage-resize.c b/app/core/gimpimage-resize.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage-resize.c +++ b/app/core/gimpimage-resize.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpimage-scale.c b/app/core/gimpimage-scale.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage-scale.c +++ b/app/core/gimpimage-scale.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c index 965c81a293..458283d580 100644 --- a/app/core/gimpimage-undo-push.c +++ b/app/core/gimpimage-undo-push.c @@ -1263,7 +1263,9 @@ undo_pop_transform (GimpImage *gimage, UndoType type, gpointer tu_ptr) { - /* #warning very bogus */ +#ifdef __GNUC__ +#warning very bogus +#endif #if 0 TransformCore *tc; TransformUndo *tu; @@ -1350,7 +1352,9 @@ undo_push_paint (GimpImage *gimage, } } - /* #warning super bogosity error */ +#ifdef __GNUC__ +#warning super bogosity error +#endif static gboolean undo_pop_paint (GimpImage *gimage, UndoState state, diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimplayer-floating-sel.c b/app/core/gimplayer-floating-sel.c index ce0ddca97c..47d4c2ed42 100644 --- a/app/core/gimplayer-floating-sel.c +++ b/app/core/gimplayer-floating-sel.c @@ -63,7 +63,7 @@ floating_sel_attach (GimpLayer *layer, } /* set the drawable and allocate a backing store */ - layer->preserve_trans = TRUE; + gimp_layer_set_preserve_trans (layer, TRUE); layer->fs.drawable = drawable; layer->fs.backing_store = tile_manager_new (GIMP_DRAWABLE (layer)->width, @@ -450,8 +450,8 @@ floating_sel_composite (GimpLayer *layer, if (GIMP_IS_LAYER (layer->fs.drawable)) { d_layer = GIMP_LAYER (layer->fs.drawable); - if ((preserve_trans = d_layer->preserve_trans)) - d_layer->preserve_trans = FALSE; + if ((preserve_trans = gimp_layer_get_preserve_trans (d_layer))) + gimp_layer_set_preserve_trans (d_layer, FALSE); } else preserve_trans = FALSE; @@ -471,13 +471,15 @@ floating_sel_composite (GimpLayer *layer, * passed to this function */ gimp_image_apply_image (gimage, layer->fs.drawable, &fsPR, - undo, layer->opacity, layer->mode, + undo, + gimp_layer_get_opacity (layer), + gimp_layer_get_mode (layer), NULL, (x1 - offx), (y1 - offy)); /* restore preserve transparency */ if (preserve_trans) - d_layer->preserve_trans = TRUE; + gimp_layer_set_preserve_trans (d_layer, TRUE); /* restore gimage active channels */ for (i = 0; i < MAX_CHANNELS; i++) diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c index eeef360789..7cc616b392 100644 --- a/app/core/gimplayer.c +++ b/app/core/gimplayer.c @@ -53,6 +53,9 @@ enum { + OPACITY_CHANGED, + MODE_CHANGED, + PRESERVE_TRANS_CHANGED, MASK_CHANGED, LAST_SIGNAL }; @@ -113,6 +116,33 @@ gimp_layer_class_init (GimpLayerClass *klass) parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE); + layer_signals[OPACITY_CHANGED] = + gtk_signal_new ("opacity_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + opacity_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + + layer_signals[MODE_CHANGED] = + gtk_signal_new ("mode_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + mode_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + + layer_signals[PRESERVE_TRANS_CHANGED] = + gtk_signal_new ("preserve_trans_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + preserve_trans_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + layer_signals[MASK_CHANGED] = gtk_signal_new ("mask_changed", GTK_RUN_FIRST, @@ -1365,8 +1395,98 @@ gimp_layer_is_floating_sel (GimpLayer *layer) return (layer->fs.drawable != NULL); } -gboolean -gimp_layer_linked (GimpLayer *layer) +void +gimp_layer_set_opacity (GimpLayer *layer, + gdouble opacity) { + gint layer_opacity; + + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + layer_opacity = (gint) (opacity * 255.999); + + if (layer->opacity != layer_opacity) + { + layer->opacity = layer_opacity; + + gtk_signal_emit (GTK_OBJECT (layer), layer_signals[OPACITY_CHANGED]); + } +} + +gdouble +gimp_layer_get_opacity (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, 1.0); + g_return_val_if_fail (GIMP_IS_LAYER (layer), 1.0); + + return (gdouble) layer->opacity / 255.0; +} + +void +gimp_layer_set_mode (GimpLayer *layer, + LayerModeEffects mode) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + if (layer->mode != mode) + { + layer->mode = mode; + + gtk_signal_emit (GTK_OBJECT (layer), layer_signals[MODE_CHANGED]); + } +} + +LayerModeEffects +gimp_layer_get_mode (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, NORMAL_MODE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), NORMAL_MODE); + + return layer->mode; +} + +void +gimp_layer_set_preserve_trans (GimpLayer *layer, + gboolean preserve) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + if (layer->preserve_trans != preserve) + { + layer->preserve_trans = preserve ? TRUE : FALSE; + + gtk_signal_emit (GTK_OBJECT (layer), + layer_signals[PRESERVE_TRANS_CHANGED]); + } +} + +gboolean +gimp_layer_get_preserve_trans (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, FALSE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); + + return layer->preserve_trans; +} + +void +gimp_layer_set_linked (GimpLayer *layer, + gboolean linked) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + layer->linked = linked ? TRUE : FALSE; +} + +gboolean +gimp_layer_get_linked (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, FALSE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); + return layer->linked; } diff --git a/app/core/gimplayer.h b/app/core/gimplayer.h index 1a73efc131..cbe5282ac5 100644 --- a/app/core/gimplayer.h +++ b/app/core/gimplayer.h @@ -36,13 +36,13 @@ struct _GimpLayer { GimpDrawable parent_instance; - gboolean linked; /* control linkage */ - gboolean preserve_trans; /* preserve transparency */ - - GimpLayerMask *mask; /* possible layer mask */ - gint opacity; /* layer opacity */ LayerModeEffects mode; /* layer combination mode */ + gboolean preserve_trans; /* preserve transparency */ + + gboolean linked; /* control linkage */ + + GimpLayerMask *mask; /* possible layer mask */ /* Floating selections */ struct @@ -61,7 +61,10 @@ struct _GimpLayerClass { GimpDrawableClass parent_class; - void (* mask_changed) (GimpLayer *layer); + void (* opacity_changed) (GimpLayer *layer); + void (* mode_changed) (GimpLayer *layer); + void (* preserve_trans_changed) (GimpLayer *layer); + void (* mask_changed) (GimpLayer *layer); }; @@ -137,9 +140,25 @@ gint gimp_layer_pick_correlate (GimpLayer *layer, gint y); GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer); + gboolean gimp_layer_has_alpha (GimpLayer *layer); gboolean gimp_layer_is_floating_sel (GimpLayer *layer); -gboolean gimp_layer_linked (GimpLayer *layer); + +void gimp_layer_set_opacity (GimpLayer *layer, + gdouble opacity); +gdouble gimp_layer_get_opacity (GimpLayer *layer); + +void gimp_layer_set_mode (GimpLayer *layer, + LayerModeEffects mode); +LayerModeEffects gimp_layer_get_mode (GimpLayer *layer); + +void gimp_layer_set_preserve_trans (GimpLayer *layer, + gboolean preserve); +gboolean gimp_layer_get_preserve_trans (GimpLayer *layer); + +void gimp_layer_set_linked (GimpLayer *layer, + gboolean linked); +gboolean gimp_layer_get_linked (GimpLayer *layer); #endif /* __GIMP_LAYER_H__ */ diff --git a/app/core/gimpprojection-construct.c b/app/core/gimpprojection-construct.c index 436c8bcff2..124fe36aba 100644 --- a/app/core/gimpprojection-construct.c +++ b/app/core/gimpprojection-construct.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/core/gimpprojection.c b/app/core/gimpprojection.c index 883049b465..1075ab8239 100644 --- a/app/core/gimpprojection.c +++ b/app/core/gimpprojection.c @@ -2040,7 +2040,9 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp) SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB)); SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY)); SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED)); - /* #warning FIXME (set_menu_sensitivity) */ +#ifdef __GNUC__ +#warning FIXME (set_menu_sensitivity) +#endif #if 0 SET_SENSITIVE ("Image/Histogram...", lp); #endif diff --git a/app/core/gimptoolinfo.c b/app/core/gimptoolinfo.c index 5b04e8b673..12184b26b3 100644 --- a/app/core/gimptoolinfo.c +++ b/app/core/gimptoolinfo.c @@ -27,8 +27,7 @@ #include "gimptoolinfo.h" #include "temp_buf.h" -/* FIXME: include rect_select.h here */ -#include "gimpcolorpickertool.h" +#include "gimprectselecttool.h" static void gimp_tool_info_class_init (GimpToolInfoClass *klass); @@ -245,7 +244,7 @@ gimp_tool_info_get_standard (void) if (! standard_tool_info) { standard_tool_info = - gimp_tool_info_new (GIMP_TYPE_COLOR_PICKER_TOOL, + gimp_tool_info_new (GIMP_TYPE_RECT_SELECT_TOOL, FALSE, "gimp:standard_tool", "Standard Tool", diff --git a/app/disp_callbacks.c b/app/disp_callbacks.c index ef7497ef65..ec3977167b 100644 --- a/app/disp_callbacks.c +++ b/app/disp_callbacks.c @@ -30,6 +30,7 @@ #include "tools/gimpbucketfilltool.h" #include "tools/gimpfuzzyselecttool.h" #include "tools/gimpmovetool.h" +#include "tools/gimptoolinfo.h" #include "tools/tool_manager.h" #include "appenv.h" @@ -926,6 +927,7 @@ gdisplay_bucket_fill (GtkWidget *widget, GimpDrawable *drawable; TileManager *buf_tiles; PixelRegion bufPR; + GimpToolInfo *tool_info; GimpContext *context; gint x1, x2, y1, y2; gint bytes; @@ -946,12 +948,16 @@ gdisplay_bucket_fill (GtkWidget *widget, gimp_add_busy_cursors (); /* Get the bucket fill context */ -#if 0 -if (! global_paint_options) -#warning FIXME context = tool_info[BUCKET_FILL].tool_context; + tool_info = tool_manager_get_info_by_type (GIMP_TYPE_BUCKET_FILL_TOOL); + + if (tool_info && tool_info->context) + { + context = tool_info->context; + } else -#endif - context = gimp_context_get_user (); + { + context = gimp_context_get_user (); + } /* Transform the passed data for the dest image */ if (fill_mode == FG_BUCKET_FILL) diff --git a/app/display/gimpdisplay-callbacks.c b/app/display/gimpdisplay-callbacks.c index ef7497ef65..ec3977167b 100644 --- a/app/display/gimpdisplay-callbacks.c +++ b/app/display/gimpdisplay-callbacks.c @@ -30,6 +30,7 @@ #include "tools/gimpbucketfilltool.h" #include "tools/gimpfuzzyselecttool.h" #include "tools/gimpmovetool.h" +#include "tools/gimptoolinfo.h" #include "tools/tool_manager.h" #include "appenv.h" @@ -926,6 +927,7 @@ gdisplay_bucket_fill (GtkWidget *widget, GimpDrawable *drawable; TileManager *buf_tiles; PixelRegion bufPR; + GimpToolInfo *tool_info; GimpContext *context; gint x1, x2, y1, y2; gint bytes; @@ -946,12 +948,16 @@ gdisplay_bucket_fill (GtkWidget *widget, gimp_add_busy_cursors (); /* Get the bucket fill context */ -#if 0 -if (! global_paint_options) -#warning FIXME context = tool_info[BUCKET_FILL].tool_context; + tool_info = tool_manager_get_info_by_type (GIMP_TYPE_BUCKET_FILL_TOOL); + + if (tool_info && tool_info->context) + { + context = tool_info->context; + } else -#endif - context = gimp_context_get_user (); + { + context = gimp_context_get_user (); + } /* Transform the passed data for the dest image */ if (fill_mode == FG_BUCKET_FILL) diff --git a/app/display/gimpdisplay.c b/app/display/gimpdisplay.c index 883049b465..1075ab8239 100644 --- a/app/display/gimpdisplay.c +++ b/app/display/gimpdisplay.c @@ -2040,7 +2040,9 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp) SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB)); SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY)); SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED)); - /* #warning FIXME (set_menu_sensitivity) */ +#ifdef __GNUC__ +#warning FIXME (set_menu_sensitivity) +#endif #if 0 SET_SENSITIVE ("Image/Histogram...", lp); #endif diff --git a/app/display/gimpdisplayshell-callbacks.c b/app/display/gimpdisplayshell-callbacks.c index ef7497ef65..ec3977167b 100644 --- a/app/display/gimpdisplayshell-callbacks.c +++ b/app/display/gimpdisplayshell-callbacks.c @@ -30,6 +30,7 @@ #include "tools/gimpbucketfilltool.h" #include "tools/gimpfuzzyselecttool.h" #include "tools/gimpmovetool.h" +#include "tools/gimptoolinfo.h" #include "tools/tool_manager.h" #include "appenv.h" @@ -926,6 +927,7 @@ gdisplay_bucket_fill (GtkWidget *widget, GimpDrawable *drawable; TileManager *buf_tiles; PixelRegion bufPR; + GimpToolInfo *tool_info; GimpContext *context; gint x1, x2, y1, y2; gint bytes; @@ -946,12 +948,16 @@ gdisplay_bucket_fill (GtkWidget *widget, gimp_add_busy_cursors (); /* Get the bucket fill context */ -#if 0 -if (! global_paint_options) -#warning FIXME context = tool_info[BUCKET_FILL].tool_context; + tool_info = tool_manager_get_info_by_type (GIMP_TYPE_BUCKET_FILL_TOOL); + + if (tool_info && tool_info->context) + { + context = tool_info->context; + } else -#endif - context = gimp_context_get_user (); + { + context = gimp_context_get_user (); + } /* Transform the passed data for the dest image */ if (fill_mode == FG_BUCKET_FILL) diff --git a/app/floating_sel.c b/app/floating_sel.c index ce0ddca97c..47d4c2ed42 100644 --- a/app/floating_sel.c +++ b/app/floating_sel.c @@ -63,7 +63,7 @@ floating_sel_attach (GimpLayer *layer, } /* set the drawable and allocate a backing store */ - layer->preserve_trans = TRUE; + gimp_layer_set_preserve_trans (layer, TRUE); layer->fs.drawable = drawable; layer->fs.backing_store = tile_manager_new (GIMP_DRAWABLE (layer)->width, @@ -450,8 +450,8 @@ floating_sel_composite (GimpLayer *layer, if (GIMP_IS_LAYER (layer->fs.drawable)) { d_layer = GIMP_LAYER (layer->fs.drawable); - if ((preserve_trans = d_layer->preserve_trans)) - d_layer->preserve_trans = FALSE; + if ((preserve_trans = gimp_layer_get_preserve_trans (d_layer))) + gimp_layer_set_preserve_trans (d_layer, FALSE); } else preserve_trans = FALSE; @@ -471,13 +471,15 @@ floating_sel_composite (GimpLayer *layer, * passed to this function */ gimp_image_apply_image (gimage, layer->fs.drawable, &fsPR, - undo, layer->opacity, layer->mode, + undo, + gimp_layer_get_opacity (layer), + gimp_layer_get_mode (layer), NULL, (x1 - offx), (y1 - offy)); /* restore preserve transparency */ if (preserve_trans) - d_layer->preserve_trans = TRUE; + gimp_layer_set_preserve_trans (d_layer, TRUE); /* restore gimage active channels */ for (i = 0; i < MAX_CHANNELS; i++) diff --git a/app/gdisplay.c b/app/gdisplay.c index 883049b465..1075ab8239 100644 --- a/app/gdisplay.c +++ b/app/gdisplay.c @@ -2040,7 +2040,9 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp) SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB)); SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY)); SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED)); - /* #warning FIXME (set_menu_sensitivity) */ +#ifdef __GNUC__ +#warning FIXME (set_menu_sensitivity) +#endif #if 0 SET_SENSITIVE ("Image/Histogram...", lp); #endif diff --git a/app/gimpcontainergridview.c b/app/gimpcontainergridview.c index d16d89d05d..b31b013f63 100644 --- a/app/gimpcontainergridview.c +++ b/app/gimpcontainergridview.c @@ -22,6 +22,8 @@ #include +#include "libgimpcolor/gimpcolor.h" + #include "apptypes.h" #include "appenv.h" @@ -63,6 +65,9 @@ static void gimp_container_grid_view_highlight_item (GimpContainerView *v static GimpContainerViewClass *parent_class = NULL; +static GimpRGB white_color; +static GimpRGB black_color; + GtkType gimp_container_grid_view_get_type (void) @@ -115,6 +120,9 @@ gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass) klass->white_style->bg[GTK_STATE_NORMAL].green = 0xffff; klass->white_style->bg[GTK_STATE_NORMAL].blue = 0xffff; klass->white_style->bg[GTK_STATE_NORMAL].pixel = g_white_pixel; + + gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0); + gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0); } static void @@ -222,9 +230,7 @@ gimp_container_grid_view_insert_item (GimpContainerView *view, 1, FALSE, TRUE, TRUE); - GIMP_PREVIEW (preview)->border_color[0] = 255; - GIMP_PREVIEW (preview)->border_color[1] = 255; - GIMP_PREVIEW (preview)->border_color[2] = 255; + GIMP_PREVIEW (preview)->border_color = white_color; gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview, FALSE, FALSE, FALSE, FALSE); @@ -361,13 +367,7 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, preview = gtk_object_get_data (GTK_OBJECT (view), "last_selected_item"); if (preview) - { - preview->border_color[0] = 255; - preview->border_color[1] = 255; - preview->border_color[2] = 255; - - gtk_signal_emit_by_name (GTK_OBJECT (preview), "render"); - } + gimp_preview_set_border_color (preview, &white_color); if (insert_data) preview = GIMP_PREVIEW (insert_data); @@ -401,11 +401,7 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, (row + 1) * item_height - adj->page_size); } - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; - - gtk_signal_emit_by_name (GTK_OBJECT (preview), "render"); + gimp_preview_set_border_color (preview, &black_color); } gtk_object_set_data (GTK_OBJECT (view), "last_selected_item", preview); diff --git a/app/gimpcontainerlistview.c b/app/gimpcontainerlistview.c index 7f6367516a..64b0e3d1f2 100644 --- a/app/gimpcontainerlistview.c +++ b/app/gimpcontainerlistview.c @@ -200,6 +200,9 @@ gimp_container_list_view_new (GimpContainer *container, return GTK_WIDGET (list_view); } + +/* GimpContainerView methods */ + static gpointer gimp_container_list_view_insert_item (GimpContainerView *view, GimpViewable *viewable, @@ -385,6 +388,9 @@ gimp_container_list_view_set_preview_size (GimpContainerView *view) gtk_widget_queue_resize (list_view->gtk_list); } + +/* GtkClist callbacks */ + static void gimp_container_list_view_item_selected (GtkWidget *widget, GtkWidget *child, @@ -397,6 +403,9 @@ gimp_container_list_view_item_selected (GtkWidget *widget, gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data), viewable); } + +/* GtkListItem callbacks */ + static gint gimp_container_list_view_item_activated (GtkWidget *widget, GdkEventButton *bevent, diff --git a/app/gimpcontainerview.c b/app/gimpcontainerview.c index ad68902fe0..ca10051e9c 100644 --- a/app/gimpcontainerview.c +++ b/app/gimpcontainerview.c @@ -32,6 +32,7 @@ enum { + SET_CONTAINER, INSERT_ITEM, REMOVE_ITEM, REORDER_ITEM, @@ -47,6 +48,9 @@ static void gimp_container_view_class_init (GimpContainerViewClass *klass); static void gimp_container_view_init (GimpContainerView *panel); static void gimp_container_view_destroy (GtkObject *object); +static void gimp_container_view_real_set_container (GimpContainerView *view, + GimpContainer *container); + static void gimp_container_view_clear_items (GimpContainerView *view); static void gimp_container_view_real_clear_items (GimpContainerView *view); @@ -110,6 +114,16 @@ gimp_container_view_class_init (GimpContainerViewClass *klass) parent_class = gtk_type_class (GTK_TYPE_VBOX); + view_signals[SET_CONTAINER] = + gtk_signal_new ("set_container", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpContainerViewClass, + set_container), + gtk_marshal_NONE__OBJECT, + GTK_TYPE_NONE, 1, + GIMP_TYPE_OBJECT); + view_signals[INSERT_ITEM] = gtk_signal_new ("insert_item", GTK_RUN_LAST, @@ -188,6 +202,7 @@ gimp_container_view_class_init (GimpContainerViewClass *klass) object_class->destroy = gimp_container_view_destroy; + klass->set_container = gimp_container_view_real_set_container; klass->insert_item = NULL; klass->remove_item = NULL; klass->reorder_item = NULL; @@ -238,6 +253,14 @@ gimp_container_view_set_container (GimpContainerView *view, if (container == view->container) return; + gtk_signal_emit (GTK_OBJECT (view), view_signals[SET_CONTAINER], + container); +} + +static void +gimp_container_view_real_set_container (GimpContainerView *view, + GimpContainer *container) +{ if (view->container) { gimp_container_view_select_item (view, NULL); diff --git a/app/gimpcontainerview.h b/app/gimpcontainerview.h index 48d3cb2113..b28dea62fc 100644 --- a/app/gimpcontainerview.h +++ b/app/gimpcontainerview.h @@ -48,6 +48,8 @@ struct _GimpContainerViewClass { GtkVBoxClass parent_class; + void (* set_container) (GimpContainerView *view, + GimpContainer *container); gpointer (* insert_item) (GimpContainerView *view, GimpViewable *object, gint index); diff --git a/app/gimpdrawablelistitem.c b/app/gimpdrawablelistitem.c index 19a756fb6c..d10da6be36 100644 --- a/app/gimpdrawablelistitem.c +++ b/app/gimpdrawablelistitem.c @@ -29,12 +29,11 @@ #include "drawable.h" #include "gdisplay.h" -#include "gimpchannel.h" #include "gimpcontainer.h" #include "gimpdnd.h" #include "gimpdrawablelistitem.h" +#include "gimpdrawablelistview.h" #include "gimpimage.h" -#include "gimplayer.h" #include "gimppreview.h" #include "gimpviewable.h" @@ -246,21 +245,23 @@ gimp_drawable_list_item_drag_drop (GtkWidget *widget, if (return_val) { - if (GIMP_IS_LAYER (src_viewable)) + if (widget->parent && GIMP_IS_DRAWABLE_LIST_VIEW (widget->parent)) { - gimp_image_position_layer (gimp_drawable_gimage (GIMP_DRAWABLE (src_viewable)), - GIMP_LAYER (src_viewable), - dest_index, - TRUE); + GimpDrawableListView *list_view; + + list_view = GIMP_DRAWABLE_LIST_VIEW (widget->parent); + + list_view->reorder_drawable_func (list_view->gimage, + GIMP_DRAWABLE (src_viewable), + dest_index, + TRUE); + gdisplays_flush (); } - else if (GIMP_IS_CHANNEL (src_viewable)) + else { - gimp_image_position_channel (gimp_drawable_gimage (GIMP_DRAWABLE (src_viewable)), - GIMP_CHANNEL (src_viewable), - dest_index, - TRUE); - gdisplays_flush (); + g_warning ("%s(): GimpDrawableListItem is not " + "part of a GimpDrawableListView", G_GNUC_FUNCTION); } } @@ -307,6 +308,7 @@ gimp_drawable_list_item_eye_toggled (GtkWidget *widget, drawable_update (drawable, 0, 0, drawable->width, drawable->height); + gdisplays_flush (); } } diff --git a/app/gimpdrawablelistview.c b/app/gimpdrawablelistview.c index 1a4c6ab849..ae2851c8eb 100644 --- a/app/gimpdrawablelistview.c +++ b/app/gimpdrawablelistview.c @@ -31,6 +31,8 @@ #include "gimpdrawablelistview.h" #include "gimpdnd.h" #include "gimpimage.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" #include "gimplistitem.h" #include "gimpmarshal.h" #include "gimprc.h" @@ -67,10 +69,12 @@ static void gimp_drawable_list_view_new_clicked (GtkWidget *w static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer data); + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view); static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, GimpDrawableListView *view); + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, @@ -78,6 +82,7 @@ static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *w static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, @@ -85,6 +90,7 @@ static void gimp_drawable_list_view_edit_clicked (GtkWidget *w static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, @@ -281,25 +287,6 @@ gimp_drawable_list_view_destroy (GtkObject *object) GTK_OBJECT_CLASS (parent_class)->destroy (object); } -static gpointer -gimp_drawable_list_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) -{ - gpointer list_item = NULL; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) - list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, - viewable, - index); - - if (list_item) - gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), - TRUE, view->container); - - return (gpointer) list_item; -} - GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage, GtkType drawable_type, @@ -325,7 +312,14 @@ gimp_drawable_list_view_new (GimpImage *gimage, g_return_val_if_fail (remove_drawable_func != NULL, NULL); g_return_val_if_fail (copy_drawable_func != NULL, NULL); - list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + if (drawable_type == GIMP_TYPE_LAYER) + { + list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW); + } + else + { + list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + } view = GIMP_CONTAINER_VIEW (list_view); @@ -420,11 +414,35 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name, GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed), view); + + gimp_drawable_list_view_drawable_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); } + +/* GimpContainerView methods */ + +static gpointer +gimp_drawable_list_view_insert_item (GimpContainerView *view, + GimpViewable *viewable, + gint index) +{ + gpointer list_item = NULL; + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) + list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, + viewable, + index); + + if (list_item) + gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), + TRUE, view->container); + + return list_item; +} + static void gimp_drawable_list_view_select_item (GimpContainerView *view, GimpViewable *item, @@ -497,6 +515,9 @@ gimp_drawable_list_view_activate_item (GimpContainerView *view, GIMP_DRAWABLE (item)); } + +/* "New" functions */ + static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -530,6 +551,9 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, } } + +/* "Duplicate" functions */ + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -570,6 +594,9 @@ gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, } } + +/* "Raise/Lower" functions */ + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view) @@ -612,6 +639,9 @@ gimp_drawable_list_view_lower_clicked (GtkWidget *widget, } } + +/* "Edit" functions */ + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -646,6 +676,9 @@ gimp_drawable_list_view_edit_dropped (GtkWidget *widget, } } + +/* "Delete" functions */ + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -682,6 +715,9 @@ gimp_drawable_list_view_delete_dropped (GtkWidget *widget, } } + +/* GimpImage callbacks */ + static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, GimpDrawableListView *view) diff --git a/app/gimpimage.c b/app/gimpimage.c index 436c8bcff2..124fe36aba 100644 --- a/app/gimpimage.c +++ b/app/gimpimage.c @@ -3049,7 +3049,7 @@ gimp_image_merge_layers (GimpImage *gimage, * the layers alpha channel. */ if (bottom->mode != DISSOLVE_MODE) - bottom->mode = NORMAL_MODE; + gimp_layer_set_mode (bottom, NORMAL_MODE); } /* Copy the tattoo and parasites of the bottom layer to the new layer */ @@ -3114,7 +3114,7 @@ gimp_image_merge_layers (GimpImage *gimage, /* Save old mode in undo */ if (bottom) - bottom->mode = bottom_mode; + gimp_layer_set_mode (bottom, bottom_mode); g_slist_free (reverse_list); diff --git a/app/gimplayer.c b/app/gimplayer.c index eeef360789..7cc616b392 100644 --- a/app/gimplayer.c +++ b/app/gimplayer.c @@ -53,6 +53,9 @@ enum { + OPACITY_CHANGED, + MODE_CHANGED, + PRESERVE_TRANS_CHANGED, MASK_CHANGED, LAST_SIGNAL }; @@ -113,6 +116,33 @@ gimp_layer_class_init (GimpLayerClass *klass) parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE); + layer_signals[OPACITY_CHANGED] = + gtk_signal_new ("opacity_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + opacity_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + + layer_signals[MODE_CHANGED] = + gtk_signal_new ("mode_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + mode_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + + layer_signals[PRESERVE_TRANS_CHANGED] = + gtk_signal_new ("preserve_trans_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpLayerClass, + preserve_trans_changed), + gtk_signal_default_marshaller, + GTK_TYPE_NONE, 0); + layer_signals[MASK_CHANGED] = gtk_signal_new ("mask_changed", GTK_RUN_FIRST, @@ -1365,8 +1395,98 @@ gimp_layer_is_floating_sel (GimpLayer *layer) return (layer->fs.drawable != NULL); } -gboolean -gimp_layer_linked (GimpLayer *layer) +void +gimp_layer_set_opacity (GimpLayer *layer, + gdouble opacity) { + gint layer_opacity; + + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + layer_opacity = (gint) (opacity * 255.999); + + if (layer->opacity != layer_opacity) + { + layer->opacity = layer_opacity; + + gtk_signal_emit (GTK_OBJECT (layer), layer_signals[OPACITY_CHANGED]); + } +} + +gdouble +gimp_layer_get_opacity (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, 1.0); + g_return_val_if_fail (GIMP_IS_LAYER (layer), 1.0); + + return (gdouble) layer->opacity / 255.0; +} + +void +gimp_layer_set_mode (GimpLayer *layer, + LayerModeEffects mode) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + if (layer->mode != mode) + { + layer->mode = mode; + + gtk_signal_emit (GTK_OBJECT (layer), layer_signals[MODE_CHANGED]); + } +} + +LayerModeEffects +gimp_layer_get_mode (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, NORMAL_MODE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), NORMAL_MODE); + + return layer->mode; +} + +void +gimp_layer_set_preserve_trans (GimpLayer *layer, + gboolean preserve) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + if (layer->preserve_trans != preserve) + { + layer->preserve_trans = preserve ? TRUE : FALSE; + + gtk_signal_emit (GTK_OBJECT (layer), + layer_signals[PRESERVE_TRANS_CHANGED]); + } +} + +gboolean +gimp_layer_get_preserve_trans (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, FALSE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); + + return layer->preserve_trans; +} + +void +gimp_layer_set_linked (GimpLayer *layer, + gboolean linked) +{ + g_return_if_fail (layer != NULL); + g_return_if_fail (GIMP_IS_LAYER (layer)); + + layer->linked = linked ? TRUE : FALSE; +} + +gboolean +gimp_layer_get_linked (GimpLayer *layer) +{ + g_return_val_if_fail (layer != NULL, FALSE); + g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); + return layer->linked; } diff --git a/app/gimplayer.h b/app/gimplayer.h index 1a73efc131..cbe5282ac5 100644 --- a/app/gimplayer.h +++ b/app/gimplayer.h @@ -36,13 +36,13 @@ struct _GimpLayer { GimpDrawable parent_instance; - gboolean linked; /* control linkage */ - gboolean preserve_trans; /* preserve transparency */ - - GimpLayerMask *mask; /* possible layer mask */ - gint opacity; /* layer opacity */ LayerModeEffects mode; /* layer combination mode */ + gboolean preserve_trans; /* preserve transparency */ + + gboolean linked; /* control linkage */ + + GimpLayerMask *mask; /* possible layer mask */ /* Floating selections */ struct @@ -61,7 +61,10 @@ struct _GimpLayerClass { GimpDrawableClass parent_class; - void (* mask_changed) (GimpLayer *layer); + void (* opacity_changed) (GimpLayer *layer); + void (* mode_changed) (GimpLayer *layer); + void (* preserve_trans_changed) (GimpLayer *layer); + void (* mask_changed) (GimpLayer *layer); }; @@ -137,9 +140,25 @@ gint gimp_layer_pick_correlate (GimpLayer *layer, gint y); GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer); + gboolean gimp_layer_has_alpha (GimpLayer *layer); gboolean gimp_layer_is_floating_sel (GimpLayer *layer); -gboolean gimp_layer_linked (GimpLayer *layer); + +void gimp_layer_set_opacity (GimpLayer *layer, + gdouble opacity); +gdouble gimp_layer_get_opacity (GimpLayer *layer); + +void gimp_layer_set_mode (GimpLayer *layer, + LayerModeEffects mode); +LayerModeEffects gimp_layer_get_mode (GimpLayer *layer); + +void gimp_layer_set_preserve_trans (GimpLayer *layer, + gboolean preserve); +gboolean gimp_layer_get_preserve_trans (GimpLayer *layer); + +void gimp_layer_set_linked (GimpLayer *layer, + gboolean linked); +gboolean gimp_layer_get_linked (GimpLayer *layer); #endif /* __GIMP_LAYER_H__ */ diff --git a/app/gimplayerlistitem.c b/app/gimplayerlistitem.c index d011f500a7..6ba688a9f9 100644 --- a/app/gimplayerlistitem.c +++ b/app/gimplayerlistitem.c @@ -23,6 +23,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -63,9 +64,19 @@ static void gimp_layer_list_item_mask_changed (GimpLayer *layer, GimpLayerListItem *layer_item); static void gimp_layer_list_item_update_state (GtkWidget *widget); +static void gimp_layer_list_item_layer_clicked (GtkWidget *widget, + GimpLayer *layer); +static void gimp_layer_list_item_mask_clicked (GtkWidget *widget, + GimpLayerMask *mask); + static GimpDrawableListItemClass *parent_class = NULL; +static GimpRGB black_color; +static GimpRGB white_color; +static GimpRGB green_color; +static GimpRGB red_color; + GtkType gimp_layer_list_item_get_type (void) @@ -111,6 +122,11 @@ gimp_layer_list_item_class_init (GimpLayerListItemClass *klass) widget_class->state_changed = gimp_layer_list_item_state_changed; list_item_class->set_viewable = gimp_layer_list_item_set_viewable; + + gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0); + gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0); + gimp_rgba_set (&green_color, 0.0, 1.0, 0.0, 1.0); + gimp_rgba_set (&red_color, 1.0, 0.0, 0.0, 1.0); } static void @@ -135,6 +151,10 @@ gimp_layer_list_item_set_viewable (GimpListItem *list_item, layer_item = GIMP_LAYER_LIST_ITEM (list_item); layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable); + gtk_signal_connect (GTK_OBJECT (list_item->preview), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_item_layer_clicked), + layer); + if (gimp_layer_get_mask (layer)) { gimp_layer_list_item_mask_changed (layer, layer_item); @@ -259,13 +279,19 @@ gimp_layer_list_item_mask_changed (GimpLayer *layer, layer_item->mask_preview = gimp_preview_new (GIMP_VIEWABLE (mask), list_item->preview_size, 2, FALSE); + GIMP_PREVIEW (layer_item->mask_preview)->clickable = TRUE; + gtk_box_pack_start (GTK_BOX (list_item->hbox), layer_item->mask_preview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (list_item->hbox), layer_item->mask_preview, 2); gtk_widget_show (layer_item->mask_preview); + gtk_signal_connect (GTK_OBJECT (layer_item->mask_preview), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_item_mask_clicked), + mask); + gtk_signal_connect_object (GTK_OBJECT (mask), "apply_changed", GTK_SIGNAL_FUNC (gimp_layer_list_item_update_state), @@ -298,8 +324,8 @@ gimp_layer_list_item_update_state (GtkWidget *widget) GimpLayer *layer; GimpLayerMask *mask; GimpPreview *preview; - guchar layer_color[3] = { 0, 0, 0 }; - guchar mask_color[3] = { 0, 0, 0 }; + GimpRGB *layer_color = &black_color; + GimpRGB *mask_color = &black_color; layer_item = GIMP_LAYER_LIST_ITEM (widget); list_item = GIMP_LIST_ITEM (widget); @@ -314,15 +340,11 @@ gimp_layer_list_item_update_state (GtkWidget *widget) case GTK_STATE_SELECTED: if (! mask || (mask && ! gimp_layer_mask_get_edit (mask))) { - layer_color[0] = 255; - layer_color[1] = 255; - layer_color[2] = 255; + layer_color = &white_color; } else { - mask_color[0] = 255; - mask_color[1] = 255; - mask_color[2] = 255; + mask_color = &white_color; } break; @@ -332,30 +354,39 @@ gimp_layer_list_item_update_state (GtkWidget *widget) preview = GIMP_PREVIEW (list_item->preview); - if (preview->border_color[0] != layer_color[0] || - preview->border_color[1] != layer_color[1] || - preview->border_color[2] != layer_color[2]) - { - preview->border_color[0] = layer_color[0]; - preview->border_color[1] = layer_color[1]; - preview->border_color[2] = layer_color[2]; - - gimp_preview_render (preview); - } + gimp_preview_set_border_color (preview, layer_color); if (mask) { preview = GIMP_PREVIEW (layer_item->mask_preview); - if (preview->border_color[0] != mask_color[0] || - preview->border_color[1] != mask_color[1] || - preview->border_color[2] != mask_color[2]) - { - preview->border_color[0] = mask_color[0]; - preview->border_color[1] = mask_color[1]; - preview->border_color[2] = mask_color[2]; - - gimp_preview_render (preview); - } + gimp_preview_set_border_color (preview, mask_color); } } + +static void +gimp_layer_list_item_layer_clicked (GtkWidget *widget, + GimpLayer *layer) +{ + GimpLayerMask *mask; + + g_print ("layer clicked\n"); + + mask = gimp_layer_get_mask (layer); + + if (mask) + { + if (gimp_layer_mask_get_edit (mask)) + gimp_layer_mask_set_edit (mask, FALSE); + } +} + +static void +gimp_layer_list_item_mask_clicked (GtkWidget *widget, + GimpLayerMask *mask) +{ + g_print ("mask clicked\n"); + + if (! gimp_layer_mask_get_edit (mask)) + gimp_layer_mask_set_edit (mask, TRUE); +} diff --git a/app/gimplayerlistview.c b/app/gimplayerlistview.c new file mode 100644 index 0000000000..cbdb69feb3 --- /dev/null +++ b/app/gimplayerlistview.c @@ -0,0 +1,511 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpmath/gimpmath.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "apptypes.h" + +#include "drawable.h" +#include "gdisplay.h" +#include "gimpcontainer.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" +#include "gimpdnd.h" +#include "gimpimage.h" +#include "gimplistitem.h" +#include "gimpmarshal.h" +#include "gimprc.h" +#include "gimpviewable.h" + +#include "tools/paint_options.h" + +#include "libgimp/gimpintl.h" + +#include "pixmaps/anchor.xpm" + + +static void gimp_layer_list_view_class_init (GimpLayerListViewClass *klass); +static void gimp_layer_list_view_init (GimpLayerListView *view); + +static void gimp_layer_list_view_destroy (GtkObject *object); + +static void gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container); +static void gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); + +static void gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer); +static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data); + +static void gimp_layer_list_view_paint_mode_menu_callback + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_preserve_button_toggled + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_opacity_scale_changed + (GtkAdjustment *adjustment, + GimpLayerListView *view); + +static void gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view); +static void gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer); + + +static GimpDrawableListViewClass *parent_class = NULL; + + +GtkType +gimp_layer_list_view_get_type (void) +{ + static guint view_type = 0; + + if (! view_type) + { + GtkTypeInfo view_info = + { + "GimpLayerListView", + sizeof (GimpLayerListView), + sizeof (GimpLayerListViewClass), + (GtkClassInitFunc) gimp_layer_list_view_class_init, + (GtkObjectInitFunc) gimp_layer_list_view_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL + }; + + view_type = gtk_type_unique (GIMP_TYPE_DRAWABLE_LIST_VIEW, &view_info); + } + + return view_type; +} + +static void +gimp_layer_list_view_class_init (GimpLayerListViewClass *klass) +{ + GtkObjectClass *object_class; + GimpContainerViewClass *container_view_class; + + object_class = (GtkObjectClass *) klass; + container_view_class = (GimpContainerViewClass *) klass; + + parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE_LIST_VIEW); + + object_class->destroy = gimp_layer_list_view_destroy; + + container_view_class->set_container = gimp_layer_list_view_set_container; + container_view_class->select_item = gimp_layer_list_view_select_item; +} + +static void +gimp_layer_list_view_init (GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *slider; + GtkWidget *pixmap; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + view->options_box = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0); + gtk_widget_show (view->options_box); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Paint mode menu */ + + label = gtk_label_new (_("Mode:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->paint_mode_menu = + paint_mode_menu_new (gimp_layer_list_view_paint_mode_menu_callback, view, + FALSE, NORMAL_MODE); + gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, FALSE, FALSE, 2); + gtk_widget_show (view->paint_mode_menu); + + /* Preserve transparency toggle */ + + view->preserve_trans_toggle = + gtk_check_button_new_with_label (_("Keep Trans.")); + gtk_box_pack_start (GTK_BOX (hbox), view->preserve_trans_toggle, + FALSE, FALSE, 2); + gtk_widget_show (view->preserve_trans_toggle); + + gtk_signal_connect (GTK_OBJECT (view->preserve_trans_toggle), "toggled", + GTK_SIGNAL_FUNC (gimp_layer_list_view_preserve_button_toggled), + view); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Opacity scale */ + + label = gtk_label_new (_("Opacity:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->opacity_adjustment = + GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0, 1.0, 1.0, 0.0)); + + gtk_signal_connect (GTK_OBJECT (view->opacity_adjustment), "value_changed", + GTK_SIGNAL_FUNC (gimp_layer_list_view_opacity_scale_changed), + view); + + slider = gtk_hscale_new (view->opacity_adjustment); + gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_RIGHT); + gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0); + gtk_widget_show (slider); + + /* Anchor button */ + + view->anchor_button = gtk_button_new (); + gtk_box_pack_start (GTK_BOX (drawable_view->button_box), view->anchor_button, + TRUE, TRUE, 0); + gtk_box_reorder_child (GTK_BOX (drawable_view->button_box), + view->anchor_button, 5); + gtk_widget_show (view->anchor_button); + + gimp_help_set_help_data (view->anchor_button, _("Anchor"), NULL); + + gtk_signal_connect (GTK_OBJECT (view->anchor_button), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_view_anchor_clicked), + view); + + pixmap = gimp_pixmap_new (anchor_xpm); + gtk_container_add (GTK_CONTAINER (view->anchor_button), pixmap); + gtk_widget_show (pixmap); + + gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->anchor_button), + GTK_DEST_DEFAULT_ALL, + GIMP_TYPE_LAYER, + GDK_ACTION_COPY); + gimp_dnd_viewable_dest_set (GTK_WIDGET (view->anchor_button), + GIMP_TYPE_LAYER, + gimp_layer_list_view_anchor_dropped, + view); + + gtk_widget_set_sensitive (view->options_box, FALSE); + gtk_widget_set_sensitive (view->anchor_button, FALSE); + + view->mode_changed_handler_id = 0; + view->opacity_changed_handler_id = 0; + view->preserve_trans_changed_handler_id = 0; +} + +static void +gimp_layer_list_view_destroy (GtkObject *object) +{ + GimpLayerListView *view; + + view = GIMP_LAYER_LIST_VIEW (object); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + GTK_OBJECT_CLASS (parent_class)->destroy (object); +} + + +/* GimpContainerView methods */ + +static void +gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container) +{ + GimpLayerListView *layer_view; + + layer_view = GIMP_LAYER_LIST_VIEW (view); + + if (view->container) + { + gimp_container_remove_handler (view->container, + layer_view->mode_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->opacity_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->preserve_trans_changed_handler_id); + } + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container); + + if (view->container) + { + layer_view->mode_changed_handler_id = + gimp_container_add_handler (view->container, "mode_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->opacity_changed_handler_id = + gimp_container_add_handler (view->container, "opacity_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->preserve_trans_changed_handler_id = + gimp_container_add_handler (view->container, "preserve_trans_changed", + gimp_layer_list_view_layer_signal_handler, + view); + } +} + +static void +gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) +{ + GimpLayerListView *list_view; + gboolean options_sensitive = FALSE; + gboolean anchor_sensitive = FALSE; + + list_view = GIMP_LAYER_LIST_VIEW (view); + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, + item, + insert_data); + + if (item) + { + gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item)); + + options_sensitive = TRUE; + + if (gimp_layer_is_floating_sel (GIMP_LAYER (item))) + { + anchor_sensitive = TRUE; + } + } + + gtk_widget_set_sensitive (list_view->options_box, options_sensitive); + gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive); +} + + +/* "Anchor" functions */ + +static void +gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer) +{ + if (layer) + g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name); +} + +static void +gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpDrawable *drawable; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + drawable = drawable_view->get_drawable_func (drawable_view->gimage); + + if (drawable) + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (drawable)); +} + +static void +gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data) +{ + GimpLayerListView *view; + + view = (GimpLayerListView *) data; + + if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, + GIMP_OBJECT (viewable))) + { + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (viewable)); + } +} + + +/* Paint Mode, Opacity and Preservce trans. callbacks */ + +#define BLOCK() \ + gtk_signal_handler_block_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + +#define UNBLOCK() \ + gtk_signal_handler_unblock_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + + +static void +gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + LayerModeEffects mode; + + mode = (LayerModeEffects) + GPOINTER_TO_INT (gtk_object_get_user_data (GTK_OBJECT (widget))); + + if (gimp_layer_get_mode (layer) != mode) + { + BLOCK(); + gimp_layer_set_mode (layer, mode); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +static void +gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gboolean preserve_trans; + + preserve_trans = GTK_TOGGLE_BUTTON (widget)->active; + + if (gimp_layer_get_preserve_trans (layer) != preserve_trans) + { + BLOCK(); + gimp_layer_set_preserve_trans (layer, preserve_trans); + UNBLOCK(); + } + } +} + +static void +gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gdouble opacity; + + opacity = adjustment->value / 100.0; + + if (gimp_layer_get_opacity (layer) != opacity) + { + BLOCK(); + gimp_layer_set_opacity (layer, opacity); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +#undef BLOCK +#undef UNBLOCK + + +static void +gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + if (drawable_view->get_drawable_func (drawable_view->gimage) == + (GimpDrawable *) layer) + { + gimp_layer_list_view_update_options (view, layer); + } +} + +static void +gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer) +{ + gimp_option_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu), + GINT_TO_POINTER (layer->mode)); + + if (layer->preserve_trans != + GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle), + layer->preserve_trans); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + } + + if ((gdouble) layer->opacity / 2.55 != view->opacity_adjustment->value) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + + gtk_adjustment_set_value (view->opacity_adjustment, layer->opacity / 2.55); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + } +} diff --git a/app/gimplayerlistview.h b/app/gimplayerlistview.h new file mode 100644 index 0000000000..e52fbbf313 --- /dev/null +++ b/app/gimplayerlistview.h @@ -0,0 +1,62 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_LAYER_LIST_VIEW_H__ +#define __GIMP_LAYER_LIST_VIEW_H__ + + +#include "gimpdrawablelistview.h" + + +#define GIMP_TYPE_LAYER_LIST_VIEW (gimp_layer_list_view_get_type ()) +#define GIMP_LAYER_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListView)) +#define GIMP_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListViewClass)) +#define GIMP_IS_LAYER_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_LIST_VIEW)) +#define GIMP_IS_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_LIST_VIEW)) + + +typedef struct _GimpLayerListViewClass GimpLayerListViewClass; + +struct _GimpLayerListView +{ + GimpDrawableListView parent_instance; + + GtkWidget *options_box; + + GtkWidget *paint_mode_menu; + GtkWidget *preserve_trans_toggle; + GtkAdjustment *opacity_adjustment; + + GtkWidget *anchor_button; + + /*< private >*/ + GQuark mode_changed_handler_id; + GQuark opacity_changed_handler_id; + GQuark preserve_trans_changed_handler_id; +}; + +struct _GimpLayerListViewClass +{ + GimpDrawableListViewClass parent_class; +}; + + +GtkType gimp_layer_list_view_get_type (void); + + +#endif /* __GIMP_LAYER_LIST_VIEW_H__ */ diff --git a/app/gimplistitem.c b/app/gimplistitem.c index a7b4beb8d8..7eccbe2e64 100644 --- a/app/gimplistitem.c +++ b/app/gimplistitem.c @@ -327,11 +327,6 @@ gimp_list_item_real_set_viewable (GimpListItem *list_item, GTK_OBJECT (viewable)->klass->type, gimp_list_item_drag_viewable, NULL); - - gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_item), - GTK_DEST_DEFAULT_ALL, - GTK_OBJECT (viewable)->klass->type, - GDK_ACTION_MOVE | GDK_ACTION_COPY); } void @@ -348,9 +343,20 @@ gimp_list_item_set_reorderable (GimpListItem *list_item, list_item->reorderable = reorderable; if (reorderable) - list_item->container = container; + { + list_item->container = container; + + gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_item), + GTK_DEST_DEFAULT_ALL, + container->children_type, + GDK_ACTION_MOVE | GDK_ACTION_COPY); + } else - list_item->container = NULL; + { + list_item->container = NULL; + + gtk_drag_dest_unset (GTK_WIDGET (list_item)); + } } gboolean diff --git a/app/gimppreview.c b/app/gimppreview.c index 93bf640eaf..011ba7071e 100644 --- a/app/gimppreview.c +++ b/app/gimppreview.c @@ -25,6 +25,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -236,9 +237,7 @@ gimp_preview_init (GimpPreview *preview) preview->height = 8; preview->border_width = 0; - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; + gimp_rgba_set (&preview->border_color, 0.0, 0.0, 0.0, 1.0); preview->is_popup = FALSE; preview->clickable = FALSE; @@ -409,47 +408,6 @@ gimp_preview_new_full (GimpViewable *viewable, return GTK_WIDGET (preview); } -void -gimp_preview_set_size (GimpPreview *preview, - gint preview_size, - gint border_width) -{ - gint width, height; - - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (preview_size > 0 && preview_size <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - gimp_preview_get_size (preview, preview_size, &width, &height); - - gimp_preview_set_size_full (preview, - width, - height, - border_width); -} - -void -gimp_preview_set_size_full (GimpPreview *preview, - gint width, - gint height, - gint border_width) -{ - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (width > 0 && width <= 256); - g_return_if_fail (height > 0 && height <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - preview->width = width; - preview->height = height; - preview->border_width = border_width; - - gtk_preview_size (GTK_PREVIEW (preview), - width + 2 * preview->border_width, - height + 2 * preview->border_width); -} - void gimp_preview_set_viewable (GimpPreview *preview, GimpViewable *viewable) @@ -512,6 +470,63 @@ gimp_preview_set_viewable (GimpPreview *preview, } } +void +gimp_preview_set_size (GimpPreview *preview, + gint preview_size, + gint border_width) +{ + gint width, height; + + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (preview_size > 0 && preview_size <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + gimp_preview_get_size (preview, preview_size, &width, &height); + + gimp_preview_set_size_full (preview, + width, + height, + border_width); +} + +void +gimp_preview_set_size_full (GimpPreview *preview, + gint width, + gint height, + gint border_width) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (width > 0 && width <= 256); + g_return_if_fail (height > 0 && height <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + preview->width = width; + preview->height = height; + preview->border_width = border_width; + + gtk_preview_size (GTK_PREVIEW (preview), + width + 2 * preview->border_width, + height + 2 * preview->border_width); +} + +void +gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *color) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (color != NULL); + + if (gimp_rgb_distance (&preview->border_color, color)) + { + preview->border_color = *color; + + gimp_preview_render (preview); + } +} + void gimp_preview_render (GimpPreview *preview) { @@ -864,11 +879,17 @@ gimp_preview_render_and_flush (GimpPreview *preview, gint image_bytes; gint offset; gint border; + guchar border_color[3]; width = preview->width; height = preview->height; border = preview->border_width; + gimp_rgb_get_uchar (&preview->border_color, + &border_color[0], + &border_color[1], + &border_color[2]); + alpha = ALPHA_PIX; /* Here are the different cases this functions handles correctly: @@ -923,9 +944,9 @@ gimp_preview_render_and_flush (GimpPreview *preview, /* Set the border color once before rendering */ for (j = 0; j < width + border * 2; j++) { - render_temp_buf[j * 3 + 0] = preview->border_color[0]; - render_temp_buf[j * 3 + 1] = preview->border_color[1]; - render_temp_buf[j * 3 + 2] = preview->border_color[2]; + render_temp_buf[j * 3 + 0] = border_color[0]; + render_temp_buf[j * 3 + 1] = border_color[1]; + render_temp_buf[j * 3 + 2] = border_color[2]; } for (i = 0; i < border; i++) diff --git a/app/gimppreview.h b/app/gimppreview.h index 2409b8346d..6e5a8b00a2 100644 --- a/app/gimppreview.h +++ b/app/gimppreview.h @@ -50,13 +50,13 @@ struct _GimpPreview gint height; gint border_width; - /* TEMP HACK: */ - guchar border_color[3]; + GimpRGB border_color; gboolean is_popup; gboolean clickable; gboolean show_popup; + /*< private >*/ gboolean in_button; guint idle_id; guint popup_id; @@ -94,6 +94,9 @@ GtkWidget * gimp_preview_new_full (GimpViewable *viewable, gboolean clickable, gboolean show_popup); +void gimp_preview_set_viewable (GimpPreview *preview, + GimpViewable *viewable); + void gimp_preview_set_size (GimpPreview *preview, gint size, gint border_width); @@ -102,13 +105,13 @@ void gimp_preview_set_size_full (GimpPreview *preview, gint height, gint border_width); -void gimp_preview_set_viewable (GimpPreview *preview, - GimpViewable *viewable); +void gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *border_color); void gimp_preview_render (GimpPreview *preview); -/* private */ +/* protected */ void gimp_preview_render_and_flush (GimpPreview *preview, TempBuf *temp_buf, diff --git a/app/gui/brush-select.c b/app/gui/brush-select.c index 946d207512..c3ff253581 100644 --- a/app/gui/brush-select.c +++ b/app/gui/brush-select.c @@ -270,7 +270,7 @@ brush_select_new (gchar *title, /* Create the paint mode option menu */ bsp->option_menu = - paint_mode_menu_new (paint_mode_menu_callback, (gpointer) bsp, + paint_mode_menu_new (paint_mode_menu_callback, (gpointer) bsp, TRUE, gimp_context_get_paint_mode (bsp->context)); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Mode:"), 1.0, 0.5, diff --git a/app/gui/commands.c b/app/gui/commands.c index a1b105d452..adb85f0a30 100644 --- a/app/gui/commands.c +++ b/app/gui/commands.c @@ -1161,7 +1161,9 @@ tools_select_cmd_callback (GtkWidget *widget, gimp_context_set_tool (gimp_context_get_user (), tool_info); - /* #warning FIXME (let the tool manager to this stuff) */ +#ifdef __GNUC__ +#warning FIXME (let the tool manager to this stuff) +#endif /* Paranoia */ active_tool->drawable = NULL; diff --git a/app/gui/help-commands.c b/app/gui/help-commands.c index a1b105d452..adb85f0a30 100644 --- a/app/gui/help-commands.c +++ b/app/gui/help-commands.c @@ -1161,7 +1161,9 @@ tools_select_cmd_callback (GtkWidget *widget, gimp_context_set_tool (gimp_context_get_user (), tool_info); - /* #warning FIXME (let the tool manager to this stuff) */ +#ifdef __GNUC__ +#warning FIXME (let the tool manager to this stuff) +#endif /* Paranoia */ active_tool->drawable = NULL; diff --git a/app/gui/layers-dialog.c b/app/gui/layers-dialog.c index 82bde84b1e..57baf98841 100644 --- a/app/gui/layers-dialog.c +++ b/app/gui/layers-dialog.c @@ -52,6 +52,8 @@ #include "temp_buf.h" #include "undo.h" +#include "tools/paint_options.h" + #include "libgimp/gimplimits.h" #include "libgimp/gimpintl.h" @@ -378,29 +380,10 @@ layers_dialog_create (void) gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2); gtk_widget_show (label); - layersD->mode_option_menu = - gimp_option_menu_new2 (FALSE, paint_mode_menu_callback, - NULL, (gpointer) NORMAL_MODE, - _("Normal"), (gpointer) NORMAL_MODE, NULL, - _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, - _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, - _("Divide"), (gpointer) DIVIDE_MODE, NULL, - _("Screen"), (gpointer) SCREEN_MODE, NULL, - _("Overlay"), (gpointer) OVERLAY_MODE, NULL, - _("Dodge"), (gpointer) DODGE_MODE, NULL, - _("Burn"), (gpointer) BURN_MODE, NULL, - _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, - _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, - _("Addition"), (gpointer) ADDITION_MODE, NULL, - _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, - _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, - _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, - _("Hue"), (gpointer) HUE_MODE, NULL, - _("Saturation"), (gpointer) SATURATION_MODE, NULL, - _("Color"), (gpointer) COLOR_MODE, NULL, - _("Value"), (gpointer) VALUE_MODE, NULL, - NULL); - + layersD->mode_option_menu = paint_mode_menu_new (paint_mode_menu_callback, + NULL, + FALSE, NORMAL_MODE); + gtk_box_pack_start (GTK_BOX (util_box), layersD->mode_option_menu, FALSE, FALSE, 2); gtk_widget_show (layersD->mode_option_menu); @@ -1403,7 +1386,7 @@ paint_mode_menu_callback (GtkWidget *widget, if (layer->mode != mode) { - layer->mode = mode; + gimp_layer_set_mode (layer, mode); drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_DRAWABLE (layer)->width, @@ -1419,18 +1402,17 @@ opacity_scale_update (GtkAdjustment *adjustment, { GimpImage *gimage; GimpLayer *layer; - gint opacity; + gdouble opacity; if (! (gimage = layersD->gimage) || ! (layer = gimp_image_get_active_layer (gimage))) return; - /* add the 0.001 to insure there are no subtle rounding errors */ - opacity = (gint) (adjustment->value * 2.55 + 0.001); + opacity = adjustment->value / 100.0; - if (layer->opacity != opacity) + if (gimp_layer_get_opacity (layer) != opacity) { - layer->opacity = opacity; + gimp_layer_set_opacity (layer, opacity); drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_DRAWABLE (layer)->width, @@ -1450,10 +1432,7 @@ preserve_trans_update (GtkWidget *widget, ! (layer = gimp_image_get_active_layer (gimage))) return; - if (GTK_TOGGLE_BUTTON (widget)->active) - layer->preserve_trans = TRUE; - else - layer->preserve_trans = FALSE; + gimp_layer_set_preserve_trans (layer, GTK_TOGGLE_BUTTON (widget)->active); } @@ -3430,8 +3409,17 @@ layer_widget_layer_flush (GtkWidget *widget, * 2) The paint mode menu * 3) The preserve trans button */ + gtk_signal_handler_block_by_func (GTK_OBJECT (layersD->opacity_data), + opacity_scale_update, + layersD); + gtk_adjustment_set_value (GTK_ADJUSTMENT (layersD->opacity_data), - (gfloat) layer_widget->layer->opacity / 2.55); + gimp_layer_get_opacity (layer_widget->layer) * 100.0); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (layersD->opacity_data), + opacity_scale_update, + layersD); + gimp_option_menu_set_history (GTK_OPTION_MENU (layersD->mode_option_menu), (gpointer) layer_widget->layer->mode); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (layersD->preserve_trans), @@ -3895,14 +3883,15 @@ layers_dialog_add_mask_query (GimpLayer *layer) if (gimage->selection_mask) { options->add_mask_type = ADD_SELECTION_MASK; + frame = gimp_radio_group_new2 (TRUE, _("Initialize Layer Mask to:"), gimp_radio_button_update, &options->add_mask_type, (gpointer) options->add_mask_type, - _("Show Selection"), + _("Selection"), (gpointer) ADD_SELECTION_MASK, NULL, - _("Hide Selection"), + _("Inverse Selection"), (gpointer) ADD_INV_SELECTION_MASK, NULL, _("White (Full Opacity)"), (gpointer) ADD_WHITE_MASK, NULL, diff --git a/app/gui/menus.c b/app/gui/menus.c index 8a86068f56..3736d02fd3 100644 --- a/app/gui/menus.c +++ b/app/gui/menus.c @@ -1791,7 +1791,9 @@ menus_init (void) menus_tools_create (GIMP_TOOL_INFO (list->data)); } /* reorder /Image/Colors */ - /*#warning FIXME (reorder /Image/Colors) */ +#ifdef __GNUC__ +#warning FIXME (reorder /Image/Colors) +#endif #if 0 menu_item = gtk_item_factory_get_widget (image_factory, tool_info[POSTERIZE].menu_path); diff --git a/app/layers_dialog.c b/app/layers_dialog.c index 82bde84b1e..57baf98841 100644 --- a/app/layers_dialog.c +++ b/app/layers_dialog.c @@ -52,6 +52,8 @@ #include "temp_buf.h" #include "undo.h" +#include "tools/paint_options.h" + #include "libgimp/gimplimits.h" #include "libgimp/gimpintl.h" @@ -378,29 +380,10 @@ layers_dialog_create (void) gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2); gtk_widget_show (label); - layersD->mode_option_menu = - gimp_option_menu_new2 (FALSE, paint_mode_menu_callback, - NULL, (gpointer) NORMAL_MODE, - _("Normal"), (gpointer) NORMAL_MODE, NULL, - _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, - _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, - _("Divide"), (gpointer) DIVIDE_MODE, NULL, - _("Screen"), (gpointer) SCREEN_MODE, NULL, - _("Overlay"), (gpointer) OVERLAY_MODE, NULL, - _("Dodge"), (gpointer) DODGE_MODE, NULL, - _("Burn"), (gpointer) BURN_MODE, NULL, - _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, - _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, - _("Addition"), (gpointer) ADDITION_MODE, NULL, - _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, - _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, - _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, - _("Hue"), (gpointer) HUE_MODE, NULL, - _("Saturation"), (gpointer) SATURATION_MODE, NULL, - _("Color"), (gpointer) COLOR_MODE, NULL, - _("Value"), (gpointer) VALUE_MODE, NULL, - NULL); - + layersD->mode_option_menu = paint_mode_menu_new (paint_mode_menu_callback, + NULL, + FALSE, NORMAL_MODE); + gtk_box_pack_start (GTK_BOX (util_box), layersD->mode_option_menu, FALSE, FALSE, 2); gtk_widget_show (layersD->mode_option_menu); @@ -1403,7 +1386,7 @@ paint_mode_menu_callback (GtkWidget *widget, if (layer->mode != mode) { - layer->mode = mode; + gimp_layer_set_mode (layer, mode); drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_DRAWABLE (layer)->width, @@ -1419,18 +1402,17 @@ opacity_scale_update (GtkAdjustment *adjustment, { GimpImage *gimage; GimpLayer *layer; - gint opacity; + gdouble opacity; if (! (gimage = layersD->gimage) || ! (layer = gimp_image_get_active_layer (gimage))) return; - /* add the 0.001 to insure there are no subtle rounding errors */ - opacity = (gint) (adjustment->value * 2.55 + 0.001); + opacity = adjustment->value / 100.0; - if (layer->opacity != opacity) + if (gimp_layer_get_opacity (layer) != opacity) { - layer->opacity = opacity; + gimp_layer_set_opacity (layer, opacity); drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_DRAWABLE (layer)->width, @@ -1450,10 +1432,7 @@ preserve_trans_update (GtkWidget *widget, ! (layer = gimp_image_get_active_layer (gimage))) return; - if (GTK_TOGGLE_BUTTON (widget)->active) - layer->preserve_trans = TRUE; - else - layer->preserve_trans = FALSE; + gimp_layer_set_preserve_trans (layer, GTK_TOGGLE_BUTTON (widget)->active); } @@ -3430,8 +3409,17 @@ layer_widget_layer_flush (GtkWidget *widget, * 2) The paint mode menu * 3) The preserve trans button */ + gtk_signal_handler_block_by_func (GTK_OBJECT (layersD->opacity_data), + opacity_scale_update, + layersD); + gtk_adjustment_set_value (GTK_ADJUSTMENT (layersD->opacity_data), - (gfloat) layer_widget->layer->opacity / 2.55); + gimp_layer_get_opacity (layer_widget->layer) * 100.0); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (layersD->opacity_data), + opacity_scale_update, + layersD); + gimp_option_menu_set_history (GTK_OPTION_MENU (layersD->mode_option_menu), (gpointer) layer_widget->layer->mode); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (layersD->preserve_trans), @@ -3895,14 +3883,15 @@ layers_dialog_add_mask_query (GimpLayer *layer) if (gimage->selection_mask) { options->add_mask_type = ADD_SELECTION_MASK; + frame = gimp_radio_group_new2 (TRUE, _("Initialize Layer Mask to:"), gimp_radio_button_update, &options->add_mask_type, (gpointer) options->add_mask_type, - _("Show Selection"), + _("Selection"), (gpointer) ADD_SELECTION_MASK, NULL, - _("Hide Selection"), + _("Inverse Selection"), (gpointer) ADD_INV_SELECTION_MASK, NULL, _("White (Full Opacity)"), (gpointer) ADD_WHITE_MASK, NULL, diff --git a/app/menus.c b/app/menus.c index 8a86068f56..3736d02fd3 100644 --- a/app/menus.c +++ b/app/menus.c @@ -1791,7 +1791,9 @@ menus_init (void) menus_tools_create (GIMP_TOOL_INFO (list->data)); } /* reorder /Image/Colors */ - /*#warning FIXME (reorder /Image/Colors) */ +#ifdef __GNUC__ +#warning FIXME (reorder /Image/Colors) +#endif #if 0 menu_item = gtk_item_factory_get_widget (image_factory, tool_info[POSTERIZE].menu_path); diff --git a/app/menus/menus.c b/app/menus/menus.c index 8a86068f56..3736d02fd3 100644 --- a/app/menus/menus.c +++ b/app/menus/menus.c @@ -1791,7 +1791,9 @@ menus_init (void) menus_tools_create (GIMP_TOOL_INFO (list->data)); } /* reorder /Image/Colors */ - /*#warning FIXME (reorder /Image/Colors) */ +#ifdef __GNUC__ +#warning FIXME (reorder /Image/Colors) +#endif #if 0 menu_item = gtk_item_factory_get_widget (image_factory, tool_info[POSTERIZE].menu_path); diff --git a/app/paint/gimppaintcore.c b/app/paint/gimppaintcore.c index 3fa003196f..cc48e5d501 100644 --- a/app/paint/gimppaintcore.c +++ b/app/paint/gimppaintcore.c @@ -622,7 +622,9 @@ gimp_paint_tool_cursor_update (GimpTool *tool, if (paint_tool->context_id) gtk_statusbar_pop (GTK_STATUSBAR (gdisp->statusbar), paint_tool->context_id); - /* #warning this doesnt belong here */ +#ifdef __GNUC__ +#warning this doesnt belong here +#endif /* Set toggle cursors for various paint tools */ if (tool->toggled) { @@ -883,7 +885,9 @@ gimp_paint_tool_start (GimpPaintTool *paint_tool, paint_tool->curx = x; paint_tool->cury = y; - /* #warning (FIX non-gui paint tools) */ +#ifdef __GNUC__ +#warning (FIX non-gui paint tools) +#endif #if 0 /* Set up some defaults for non-gui use */ if (paint_tool == &non_gui_paint_tool) diff --git a/app/pdb/layer_cmds.c b/app/pdb/layer_cmds.c index 08cfb55956..d327f03719 100644 --- a/app/pdb/layer_cmds.c +++ b/app/pdb/layer_cmds.c @@ -611,7 +611,7 @@ layer_translate_invoker (Argument *args) { tmp_layer = (GimpLayer *) layer_list->data; - if ((tmp_layer == layer) || tmp_layer->linked) + if ((tmp_layer == layer) || gimp_layer_get_linked (tmp_layer)) gimp_layer_translate (tmp_layer, offx, offy); } @@ -740,7 +740,7 @@ layer_set_offsets_invoker (Argument *args) { tmp_layer = (GimpLayer *) layer_list->data; - if ((tmp_layer == layer) || tmp_layer->linked) + if ((tmp_layer == layer) || gimp_layer_get_linked (tmp_layer)) gimp_layer_translate (tmp_layer, (offx - GIMP_DRAWABLE (layer)->offset_x), (offy - GIMP_DRAWABLE (layer)->offset_y)); @@ -1119,7 +1119,7 @@ layer_get_preserve_trans_invoker (Argument *args) return_args = procedural_db_return_args (&layer_get_preserve_trans_proc, success); if (success) - return_args[1].value.pdb_int = layer->preserve_trans; + return_args[1].value.pdb_int = gimp_layer_get_preserve_trans (layer); return return_args; } @@ -1172,7 +1172,7 @@ layer_set_preserve_trans_invoker (Argument *args) preserve_trans = args[1].value.pdb_int ? TRUE : FALSE; if (success) - layer->preserve_trans = preserve_trans; + gimp_layer_set_preserve_trans (layer, preserve_trans); return procedural_db_return_args (&layer_set_preserve_trans_proc, success); } @@ -1221,7 +1221,7 @@ layer_get_opacity_invoker (Argument *args) return_args = procedural_db_return_args (&layer_get_opacity_proc, success); if (success) - return_args[1].value.pdb_float = (layer->opacity * 100.0) / 255.0; + return_args[1].value.pdb_float = gimp_layer_get_opacity (layer) * 100.0; return return_args; } @@ -1276,7 +1276,7 @@ layer_set_opacity_invoker (Argument *args) success = FALSE; if (success) - layer->opacity = (int) ((opacity * 255) / 100); + gimp_layer_set_opacity (layer, opacity / 100.0); return procedural_db_return_args (&layer_set_opacity_proc, success); } @@ -1325,7 +1325,7 @@ layer_get_mode_invoker (Argument *args) return_args = procedural_db_return_args (&layer_get_mode_proc, success); if (success) - return_args[1].value.pdb_int = layer->mode; + return_args[1].value.pdb_int = gimp_layer_get_mode (layer); return return_args; } @@ -1380,7 +1380,7 @@ layer_set_mode_invoker (Argument *args) success = FALSE; if (success) - layer->mode = mode; + gimp_layer_set_mode (layer, mode); return procedural_db_return_args (&layer_set_mode_proc, success); } @@ -1429,7 +1429,7 @@ layer_get_linked_invoker (Argument *args) return_args = procedural_db_return_args (&layer_get_linked_proc, success); if (success) - return_args[1].value.pdb_int = layer->linked; + return_args[1].value.pdb_int = gimp_layer_get_linked (layer); return return_args; } @@ -1482,7 +1482,7 @@ layer_set_linked_invoker (Argument *args) linked = args[1].value.pdb_int ? TRUE : FALSE; if (success) - layer->linked = linked; + gimp_layer_set_linked (layer, linked); return procedural_db_return_args (&layer_set_linked_proc, success); } diff --git a/app/tools/gimpbrushtool.c b/app/tools/gimpbrushtool.c index 3fa003196f..cc48e5d501 100644 --- a/app/tools/gimpbrushtool.c +++ b/app/tools/gimpbrushtool.c @@ -622,7 +622,9 @@ gimp_paint_tool_cursor_update (GimpTool *tool, if (paint_tool->context_id) gtk_statusbar_pop (GTK_STATUSBAR (gdisp->statusbar), paint_tool->context_id); - /* #warning this doesnt belong here */ +#ifdef __GNUC__ +#warning this doesnt belong here +#endif /* Set toggle cursors for various paint tools */ if (tool->toggled) { @@ -883,7 +885,9 @@ gimp_paint_tool_start (GimpPaintTool *paint_tool, paint_tool->curx = x; paint_tool->cury = y; - /* #warning (FIX non-gui paint tools) */ +#ifdef __GNUC__ +#warning (FIX non-gui paint tools) +#endif #if 0 /* Set up some defaults for non-gui use */ if (paint_tool == &non_gui_paint_tool) diff --git a/app/tools/gimpeditselectiontool.c b/app/tools/gimpeditselectiontool.c index 3bad077fe6..fb9635136e 100644 --- a/app/tools/gimpeditselectiontool.c +++ b/app/tools/gimpeditselectiontool.c @@ -483,7 +483,7 @@ gimp_edit_selection_tool_motion (GimpTool *tool, layer = (GimpLayer *) layer_list->data; if (layer == gdisp->gimage->active_layer || - gimp_layer_linked (layer)) + gimp_layer_get_linked (layer)) { gimp_layer_translate (layer, xoffset, yoffset); } @@ -697,7 +697,7 @@ gimp_edit_selection_tool_draw (GimpDrawTool *draw_tool) layer = (GimpLayer *) layer_list->data; if (((layer) != gdisp->gimage->active_layer) && - gimp_layer_linked (layer)) + gimp_layer_get_linked (layer)) { gimp_drawable_offsets (GIMP_DRAWABLE (layer), &off_x, &off_y); gdisplay_transform_coords (gdisp, off_x, off_y, &x3, &y3, FALSE); @@ -957,7 +957,7 @@ gimp_edit_selection_tool_arrow_key (GimpTool *tool, layer = (GimpLayer *) layer_list->data; if (((layer) == gdisp->gimage->active_layer) || - gimp_layer_linked (layer)) + gimp_layer_get_linked (layer)) { gimp_layer_translate (layer, inc_x, inc_y); } diff --git a/app/tools/gimppaintoptions-gui.c b/app/tools/gimppaintoptions-gui.c index 96c21ae662..19827b5e08 100644 --- a/app/tools/gimppaintoptions-gui.c +++ b/app/tools/gimppaintoptions-gui.c @@ -175,7 +175,7 @@ paint_options_init (PaintOptions *options, gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); options->paint_mode_w = - paint_mode_menu_new (paint_options_paint_mode_update, options, + paint_mode_menu_new (paint_options_paint_mode_update, options, TRUE, gimp_context_get_paint_mode (tool_info->context)); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Mode:"), 1.0, 0.5, @@ -322,34 +322,64 @@ paint_options_set_global (gboolean global) GtkWidget * paint_mode_menu_new (GtkSignalFunc callback, gpointer data, + gboolean with_behind_mode, LayerModeEffects initial) { GtkWidget *menu; - menu = gimp_option_menu_new2 - (FALSE, callback, data, (gpointer) initial, + if (with_behind_mode) + { + menu = gimp_option_menu_new2 + (FALSE, callback, data, (gpointer) initial, - _("Normal"), (gpointer) NORMAL_MODE, NULL, - _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, - _("Behind"), (gpointer) BEHIND_MODE, NULL, - _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, - _("Divide"), (gpointer) DIVIDE_MODE, NULL, - _("Screen"), (gpointer) SCREEN_MODE, NULL, - _("Overlay"), (gpointer) OVERLAY_MODE, NULL, - _("Dodge"), (gpointer) DODGE_MODE, NULL, - _("Burn"), (gpointer) BURN_MODE, NULL, - _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, - _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, - _("Addition"), (gpointer) ADDITION_MODE, NULL, - _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, - _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, - _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, - _("Hue"), (gpointer) HUE_MODE, NULL, - _("Saturation"), (gpointer) SATURATION_MODE, NULL, - _("Color"), (gpointer) COLOR_MODE, NULL, - _("Value"), (gpointer) VALUE_MODE, NULL, + _("Normal"), (gpointer) NORMAL_MODE, NULL, + _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, + _("Behind"), (gpointer) BEHIND_MODE, NULL, + _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, + _("Divide"), (gpointer) DIVIDE_MODE, NULL, + _("Screen"), (gpointer) SCREEN_MODE, NULL, + _("Overlay"), (gpointer) OVERLAY_MODE, NULL, + _("Dodge"), (gpointer) DODGE_MODE, NULL, + _("Burn"), (gpointer) BURN_MODE, NULL, + _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, + _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, + _("Addition"), (gpointer) ADDITION_MODE, NULL, + _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, + _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, + _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, + _("Hue"), (gpointer) HUE_MODE, NULL, + _("Saturation"), (gpointer) SATURATION_MODE, NULL, + _("Color"), (gpointer) COLOR_MODE, NULL, + _("Value"), (gpointer) VALUE_MODE, NULL, - NULL); + NULL); + } + else + { + menu = gimp_option_menu_new2 + (FALSE, callback, data, (gpointer) initial, + + _("Normal"), (gpointer) NORMAL_MODE, NULL, + _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, + _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, + _("Divide"), (gpointer) DIVIDE_MODE, NULL, + _("Screen"), (gpointer) SCREEN_MODE, NULL, + _("Overlay"), (gpointer) OVERLAY_MODE, NULL, + _("Dodge"), (gpointer) DODGE_MODE, NULL, + _("Burn"), (gpointer) BURN_MODE, NULL, + _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, + _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, + _("Addition"), (gpointer) ADDITION_MODE, NULL, + _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, + _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, + _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, + _("Hue"), (gpointer) HUE_MODE, NULL, + _("Saturation"), (gpointer) SATURATION_MODE, NULL, + _("Color"), (gpointer) COLOR_MODE, NULL, + _("Value"), (gpointer) VALUE_MODE, NULL, + + NULL); + } return menu; } @@ -806,7 +836,9 @@ static void paint_gradient_options_gradient_toggle_callback (GtkWidget *widget, PaintOptions *options) { - /* #warning (FIXME make incremental_save part of the struct) */ +#ifdef __GNUC__ +#warning (FIXME make incremental_save part of the struct) +#endif static gboolean incremental_save = FALSE; gimp_toggle_button_update (widget, &options->gradient_options->use_gradient); diff --git a/app/tools/gimppaintoptions-gui.h b/app/tools/gimppaintoptions-gui.h index bc1e305798..64fd498729 100644 --- a/app/tools/gimppaintoptions-gui.h +++ b/app/tools/gimppaintoptions-gui.h @@ -149,6 +149,7 @@ void paint_options_set_global (gboolean global); /* a utility function which returns a paint mode menu */ GtkWidget * paint_mode_menu_new (GtkSignalFunc callback, gpointer data, + gboolean with_behind_mode, LayerModeEffects initial); diff --git a/app/tools/gimppainttool.c b/app/tools/gimppainttool.c index 3fa003196f..cc48e5d501 100644 --- a/app/tools/gimppainttool.c +++ b/app/tools/gimppainttool.c @@ -622,7 +622,9 @@ gimp_paint_tool_cursor_update (GimpTool *tool, if (paint_tool->context_id) gtk_statusbar_pop (GTK_STATUSBAR (gdisp->statusbar), paint_tool->context_id); - /* #warning this doesnt belong here */ +#ifdef __GNUC__ +#warning this doesnt belong here +#endif /* Set toggle cursors for various paint tools */ if (tool->toggled) { @@ -883,7 +885,9 @@ gimp_paint_tool_start (GimpPaintTool *paint_tool, paint_tool->curx = x; paint_tool->cury = y; - /* #warning (FIX non-gui paint tools) */ +#ifdef __GNUC__ +#warning (FIX non-gui paint tools) +#endif #if 0 /* Set up some defaults for non-gui use */ if (paint_tool == &non_gui_paint_tool) diff --git a/app/tools/gimptool.c b/app/tools/gimptool.c index a2e59c7083..1530d43dc3 100644 --- a/app/tools/gimptool.c +++ b/app/tools/gimptool.c @@ -94,7 +94,9 @@ static guint gimp_tool_signals[LAST_SIGNAL] = { 0 }; static GimpObjectClass *parent_class = NULL; -/* #warning FIXME: check what global_tool_ID was used for */ +#ifdef __GNUC__ +#warning FIXME: check what global_tool_ID was used for +#endif /* static gint global_tool_ID = 0; */ @@ -417,6 +419,8 @@ gimp_tool_real_button_press (GimpTool *tool, { tool->gdisp = gdisp; tool->drawable = gimp_image_active_drawable (gdisp->gimage); + + tool->state = ACTIVE; } static void @@ -424,6 +428,7 @@ gimp_tool_real_button_release (GimpTool *tool, GdkEventButton *bevent, GDisplay *gdisp) { + tool->state = INACTIVE; } static void @@ -452,8 +457,9 @@ gimp_tool_real_cursor_update (GimpTool *tool, GdkEventMotion *mevent, GDisplay *gdisp) { - gdisplay_install_tool_cursor (gdisp, GDK_TOP_LEFT_ARROW, - GIMP_TOOL_CURSOR_NONE, + gdisplay_install_tool_cursor (gdisp, + GDK_TOP_LEFT_ARROW, + tool->tool_cursor, GIMP_CURSOR_MODIFIER_NONE); } @@ -557,7 +563,9 @@ STUB(convolve_non_gui) STUB(convolve_non_gui_default) STUB(path_transform_xy) - /* #warning obsolete crap */ +#ifdef __GNUC__ +#warning obsolete crap +#endif #ifdef STONE_AGE ToolInfo tool_info[] = { diff --git a/app/tools/gimptoolinfo.c b/app/tools/gimptoolinfo.c index 5b04e8b673..12184b26b3 100644 --- a/app/tools/gimptoolinfo.c +++ b/app/tools/gimptoolinfo.c @@ -27,8 +27,7 @@ #include "gimptoolinfo.h" #include "temp_buf.h" -/* FIXME: include rect_select.h here */ -#include "gimpcolorpickertool.h" +#include "gimprectselecttool.h" static void gimp_tool_info_class_init (GimpToolInfoClass *klass); @@ -245,7 +244,7 @@ gimp_tool_info_get_standard (void) if (! standard_tool_info) { standard_tool_info = - gimp_tool_info_new (GIMP_TYPE_COLOR_PICKER_TOOL, + gimp_tool_info_new (GIMP_TYPE_RECT_SELECT_TOOL, FALSE, "gimp:standard_tool", "Standard Tool", diff --git a/app/tools/paint_options.c b/app/tools/paint_options.c index 96c21ae662..19827b5e08 100644 --- a/app/tools/paint_options.c +++ b/app/tools/paint_options.c @@ -175,7 +175,7 @@ paint_options_init (PaintOptions *options, gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); options->paint_mode_w = - paint_mode_menu_new (paint_options_paint_mode_update, options, + paint_mode_menu_new (paint_options_paint_mode_update, options, TRUE, gimp_context_get_paint_mode (tool_info->context)); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Mode:"), 1.0, 0.5, @@ -322,34 +322,64 @@ paint_options_set_global (gboolean global) GtkWidget * paint_mode_menu_new (GtkSignalFunc callback, gpointer data, + gboolean with_behind_mode, LayerModeEffects initial) { GtkWidget *menu; - menu = gimp_option_menu_new2 - (FALSE, callback, data, (gpointer) initial, + if (with_behind_mode) + { + menu = gimp_option_menu_new2 + (FALSE, callback, data, (gpointer) initial, - _("Normal"), (gpointer) NORMAL_MODE, NULL, - _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, - _("Behind"), (gpointer) BEHIND_MODE, NULL, - _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, - _("Divide"), (gpointer) DIVIDE_MODE, NULL, - _("Screen"), (gpointer) SCREEN_MODE, NULL, - _("Overlay"), (gpointer) OVERLAY_MODE, NULL, - _("Dodge"), (gpointer) DODGE_MODE, NULL, - _("Burn"), (gpointer) BURN_MODE, NULL, - _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, - _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, - _("Addition"), (gpointer) ADDITION_MODE, NULL, - _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, - _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, - _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, - _("Hue"), (gpointer) HUE_MODE, NULL, - _("Saturation"), (gpointer) SATURATION_MODE, NULL, - _("Color"), (gpointer) COLOR_MODE, NULL, - _("Value"), (gpointer) VALUE_MODE, NULL, + _("Normal"), (gpointer) NORMAL_MODE, NULL, + _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, + _("Behind"), (gpointer) BEHIND_MODE, NULL, + _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, + _("Divide"), (gpointer) DIVIDE_MODE, NULL, + _("Screen"), (gpointer) SCREEN_MODE, NULL, + _("Overlay"), (gpointer) OVERLAY_MODE, NULL, + _("Dodge"), (gpointer) DODGE_MODE, NULL, + _("Burn"), (gpointer) BURN_MODE, NULL, + _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, + _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, + _("Addition"), (gpointer) ADDITION_MODE, NULL, + _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, + _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, + _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, + _("Hue"), (gpointer) HUE_MODE, NULL, + _("Saturation"), (gpointer) SATURATION_MODE, NULL, + _("Color"), (gpointer) COLOR_MODE, NULL, + _("Value"), (gpointer) VALUE_MODE, NULL, - NULL); + NULL); + } + else + { + menu = gimp_option_menu_new2 + (FALSE, callback, data, (gpointer) initial, + + _("Normal"), (gpointer) NORMAL_MODE, NULL, + _("Dissolve"), (gpointer) DISSOLVE_MODE, NULL, + _("Multiply"), (gpointer) MULTIPLY_MODE, NULL, + _("Divide"), (gpointer) DIVIDE_MODE, NULL, + _("Screen"), (gpointer) SCREEN_MODE, NULL, + _("Overlay"), (gpointer) OVERLAY_MODE, NULL, + _("Dodge"), (gpointer) DODGE_MODE, NULL, + _("Burn"), (gpointer) BURN_MODE, NULL, + _("Hard Light"), (gpointer) HARDLIGHT_MODE, NULL, + _("Difference"), (gpointer) DIFFERENCE_MODE, NULL, + _("Addition"), (gpointer) ADDITION_MODE, NULL, + _("Subtract"), (gpointer) SUBTRACT_MODE, NULL, + _("Darken Only"), (gpointer) DARKEN_ONLY_MODE, NULL, + _("Lighten Only"), (gpointer) LIGHTEN_ONLY_MODE, NULL, + _("Hue"), (gpointer) HUE_MODE, NULL, + _("Saturation"), (gpointer) SATURATION_MODE, NULL, + _("Color"), (gpointer) COLOR_MODE, NULL, + _("Value"), (gpointer) VALUE_MODE, NULL, + + NULL); + } return menu; } @@ -806,7 +836,9 @@ static void paint_gradient_options_gradient_toggle_callback (GtkWidget *widget, PaintOptions *options) { - /* #warning (FIXME make incremental_save part of the struct) */ +#ifdef __GNUC__ +#warning (FIXME make incremental_save part of the struct) +#endif static gboolean incremental_save = FALSE; gimp_toggle_button_update (widget, &options->gradient_options->use_gradient); diff --git a/app/tools/paint_options.h b/app/tools/paint_options.h index bc1e305798..64fd498729 100644 --- a/app/tools/paint_options.h +++ b/app/tools/paint_options.h @@ -149,6 +149,7 @@ void paint_options_set_global (gboolean global); /* a utility function which returns a paint mode menu */ GtkWidget * paint_mode_menu_new (GtkSignalFunc callback, gpointer data, + gboolean with_behind_mode, LayerModeEffects initial); diff --git a/app/tools/tool_manager.c b/app/tools/tool_manager.c index 9c0382b4f9..f808b4b113 100644 --- a/app/tools/tool_manager.c +++ b/app/tools/tool_manager.c @@ -116,7 +116,9 @@ tool_manager_initialize_tool (GimpTool *tool, /* FIXME: remove tool param */ */ if (GIMP_TOOL_CLASS (GTK_OBJECT (tool)->klass)->initialize && ! gdisp) { - /* #warning FIXME tool_type = RECT_SELECT; */ +#ifdef __GNUC__ +#warning FIXME tool_type = RECT_SELECT; +#endif } /* Force the emission of the "tool_changed" signal @@ -215,8 +217,9 @@ tool_manager_control_active (ToolAction action, } - - /* #warning bogosity alert */ +#ifdef __GNUC__ +#warning bogosity alert +#endif #if 0 void tools_register (ToolType tool_type, diff --git a/app/undo.c b/app/undo.c index 965c81a293..458283d580 100644 --- a/app/undo.c +++ b/app/undo.c @@ -1263,7 +1263,9 @@ undo_pop_transform (GimpImage *gimage, UndoType type, gpointer tu_ptr) { - /* #warning very bogus */ +#ifdef __GNUC__ +#warning very bogus +#endif #if 0 TransformCore *tc; TransformUndo *tu; @@ -1350,7 +1352,9 @@ undo_push_paint (GimpImage *gimage, } } - /* #warning super bogosity error */ +#ifdef __GNUC__ +#warning super bogosity error +#endif static gboolean undo_pop_paint (GimpImage *gimage, UndoState state, diff --git a/app/widgets/gimpcontainergridview.c b/app/widgets/gimpcontainergridview.c index d16d89d05d..b31b013f63 100644 --- a/app/widgets/gimpcontainergridview.c +++ b/app/widgets/gimpcontainergridview.c @@ -22,6 +22,8 @@ #include +#include "libgimpcolor/gimpcolor.h" + #include "apptypes.h" #include "appenv.h" @@ -63,6 +65,9 @@ static void gimp_container_grid_view_highlight_item (GimpContainerView *v static GimpContainerViewClass *parent_class = NULL; +static GimpRGB white_color; +static GimpRGB black_color; + GtkType gimp_container_grid_view_get_type (void) @@ -115,6 +120,9 @@ gimp_container_grid_view_class_init (GimpContainerGridViewClass *klass) klass->white_style->bg[GTK_STATE_NORMAL].green = 0xffff; klass->white_style->bg[GTK_STATE_NORMAL].blue = 0xffff; klass->white_style->bg[GTK_STATE_NORMAL].pixel = g_white_pixel; + + gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0); + gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0); } static void @@ -222,9 +230,7 @@ gimp_container_grid_view_insert_item (GimpContainerView *view, 1, FALSE, TRUE, TRUE); - GIMP_PREVIEW (preview)->border_color[0] = 255; - GIMP_PREVIEW (preview)->border_color[1] = 255; - GIMP_PREVIEW (preview)->border_color[2] = 255; + GIMP_PREVIEW (preview)->border_color = white_color; gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), preview, FALSE, FALSE, FALSE, FALSE); @@ -361,13 +367,7 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, preview = gtk_object_get_data (GTK_OBJECT (view), "last_selected_item"); if (preview) - { - preview->border_color[0] = 255; - preview->border_color[1] = 255; - preview->border_color[2] = 255; - - gtk_signal_emit_by_name (GTK_OBJECT (preview), "render"); - } + gimp_preview_set_border_color (preview, &white_color); if (insert_data) preview = GIMP_PREVIEW (insert_data); @@ -401,11 +401,7 @@ gimp_container_grid_view_highlight_item (GimpContainerView *view, (row + 1) * item_height - adj->page_size); } - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; - - gtk_signal_emit_by_name (GTK_OBJECT (preview), "render"); + gimp_preview_set_border_color (preview, &black_color); } gtk_object_set_data (GTK_OBJECT (view), "last_selected_item", preview); diff --git a/app/widgets/gimpcontainerlistview.c b/app/widgets/gimpcontainerlistview.c index 7f6367516a..64b0e3d1f2 100644 --- a/app/widgets/gimpcontainerlistview.c +++ b/app/widgets/gimpcontainerlistview.c @@ -200,6 +200,9 @@ gimp_container_list_view_new (GimpContainer *container, return GTK_WIDGET (list_view); } + +/* GimpContainerView methods */ + static gpointer gimp_container_list_view_insert_item (GimpContainerView *view, GimpViewable *viewable, @@ -385,6 +388,9 @@ gimp_container_list_view_set_preview_size (GimpContainerView *view) gtk_widget_queue_resize (list_view->gtk_list); } + +/* GtkClist callbacks */ + static void gimp_container_list_view_item_selected (GtkWidget *widget, GtkWidget *child, @@ -397,6 +403,9 @@ gimp_container_list_view_item_selected (GtkWidget *widget, gimp_container_view_item_selected (GIMP_CONTAINER_VIEW (data), viewable); } + +/* GtkListItem callbacks */ + static gint gimp_container_list_view_item_activated (GtkWidget *widget, GdkEventButton *bevent, diff --git a/app/widgets/gimpcontainerview.c b/app/widgets/gimpcontainerview.c index ad68902fe0..ca10051e9c 100644 --- a/app/widgets/gimpcontainerview.c +++ b/app/widgets/gimpcontainerview.c @@ -32,6 +32,7 @@ enum { + SET_CONTAINER, INSERT_ITEM, REMOVE_ITEM, REORDER_ITEM, @@ -47,6 +48,9 @@ static void gimp_container_view_class_init (GimpContainerViewClass *klass); static void gimp_container_view_init (GimpContainerView *panel); static void gimp_container_view_destroy (GtkObject *object); +static void gimp_container_view_real_set_container (GimpContainerView *view, + GimpContainer *container); + static void gimp_container_view_clear_items (GimpContainerView *view); static void gimp_container_view_real_clear_items (GimpContainerView *view); @@ -110,6 +114,16 @@ gimp_container_view_class_init (GimpContainerViewClass *klass) parent_class = gtk_type_class (GTK_TYPE_VBOX); + view_signals[SET_CONTAINER] = + gtk_signal_new ("set_container", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET (GimpContainerViewClass, + set_container), + gtk_marshal_NONE__OBJECT, + GTK_TYPE_NONE, 1, + GIMP_TYPE_OBJECT); + view_signals[INSERT_ITEM] = gtk_signal_new ("insert_item", GTK_RUN_LAST, @@ -188,6 +202,7 @@ gimp_container_view_class_init (GimpContainerViewClass *klass) object_class->destroy = gimp_container_view_destroy; + klass->set_container = gimp_container_view_real_set_container; klass->insert_item = NULL; klass->remove_item = NULL; klass->reorder_item = NULL; @@ -238,6 +253,14 @@ gimp_container_view_set_container (GimpContainerView *view, if (container == view->container) return; + gtk_signal_emit (GTK_OBJECT (view), view_signals[SET_CONTAINER], + container); +} + +static void +gimp_container_view_real_set_container (GimpContainerView *view, + GimpContainer *container) +{ if (view->container) { gimp_container_view_select_item (view, NULL); diff --git a/app/widgets/gimpcontainerview.h b/app/widgets/gimpcontainerview.h index 48d3cb2113..b28dea62fc 100644 --- a/app/widgets/gimpcontainerview.h +++ b/app/widgets/gimpcontainerview.h @@ -48,6 +48,8 @@ struct _GimpContainerViewClass { GtkVBoxClass parent_class; + void (* set_container) (GimpContainerView *view, + GimpContainer *container); gpointer (* insert_item) (GimpContainerView *view, GimpViewable *object, gint index); diff --git a/app/widgets/gimpdrawablelistitem.c b/app/widgets/gimpdrawablelistitem.c index 19a756fb6c..d10da6be36 100644 --- a/app/widgets/gimpdrawablelistitem.c +++ b/app/widgets/gimpdrawablelistitem.c @@ -29,12 +29,11 @@ #include "drawable.h" #include "gdisplay.h" -#include "gimpchannel.h" #include "gimpcontainer.h" #include "gimpdnd.h" #include "gimpdrawablelistitem.h" +#include "gimpdrawablelistview.h" #include "gimpimage.h" -#include "gimplayer.h" #include "gimppreview.h" #include "gimpviewable.h" @@ -246,21 +245,23 @@ gimp_drawable_list_item_drag_drop (GtkWidget *widget, if (return_val) { - if (GIMP_IS_LAYER (src_viewable)) + if (widget->parent && GIMP_IS_DRAWABLE_LIST_VIEW (widget->parent)) { - gimp_image_position_layer (gimp_drawable_gimage (GIMP_DRAWABLE (src_viewable)), - GIMP_LAYER (src_viewable), - dest_index, - TRUE); + GimpDrawableListView *list_view; + + list_view = GIMP_DRAWABLE_LIST_VIEW (widget->parent); + + list_view->reorder_drawable_func (list_view->gimage, + GIMP_DRAWABLE (src_viewable), + dest_index, + TRUE); + gdisplays_flush (); } - else if (GIMP_IS_CHANNEL (src_viewable)) + else { - gimp_image_position_channel (gimp_drawable_gimage (GIMP_DRAWABLE (src_viewable)), - GIMP_CHANNEL (src_viewable), - dest_index, - TRUE); - gdisplays_flush (); + g_warning ("%s(): GimpDrawableListItem is not " + "part of a GimpDrawableListView", G_GNUC_FUNCTION); } } @@ -307,6 +308,7 @@ gimp_drawable_list_item_eye_toggled (GtkWidget *widget, drawable_update (drawable, 0, 0, drawable->width, drawable->height); + gdisplays_flush (); } } diff --git a/app/widgets/gimpdrawablelistview.c b/app/widgets/gimpdrawablelistview.c index 1a4c6ab849..ae2851c8eb 100644 --- a/app/widgets/gimpdrawablelistview.c +++ b/app/widgets/gimpdrawablelistview.c @@ -31,6 +31,8 @@ #include "gimpdrawablelistview.h" #include "gimpdnd.h" #include "gimpimage.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" #include "gimplistitem.h" #include "gimpmarshal.h" #include "gimprc.h" @@ -67,10 +69,12 @@ static void gimp_drawable_list_view_new_clicked (GtkWidget *w static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer data); + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view); static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, GimpDrawableListView *view); + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, @@ -78,6 +82,7 @@ static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *w static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, @@ -85,6 +90,7 @@ static void gimp_drawable_list_view_edit_clicked (GtkWidget *w static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, @@ -281,25 +287,6 @@ gimp_drawable_list_view_destroy (GtkObject *object) GTK_OBJECT_CLASS (parent_class)->destroy (object); } -static gpointer -gimp_drawable_list_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) -{ - gpointer list_item = NULL; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) - list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, - viewable, - index); - - if (list_item) - gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), - TRUE, view->container); - - return (gpointer) list_item; -} - GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage, GtkType drawable_type, @@ -325,7 +312,14 @@ gimp_drawable_list_view_new (GimpImage *gimage, g_return_val_if_fail (remove_drawable_func != NULL, NULL); g_return_val_if_fail (copy_drawable_func != NULL, NULL); - list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + if (drawable_type == GIMP_TYPE_LAYER) + { + list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW); + } + else + { + list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + } view = GIMP_CONTAINER_VIEW (list_view); @@ -420,11 +414,35 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name, GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed), view); + + gimp_drawable_list_view_drawable_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); } + +/* GimpContainerView methods */ + +static gpointer +gimp_drawable_list_view_insert_item (GimpContainerView *view, + GimpViewable *viewable, + gint index) +{ + gpointer list_item = NULL; + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) + list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, + viewable, + index); + + if (list_item) + gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), + TRUE, view->container); + + return list_item; +} + static void gimp_drawable_list_view_select_item (GimpContainerView *view, GimpViewable *item, @@ -497,6 +515,9 @@ gimp_drawable_list_view_activate_item (GimpContainerView *view, GIMP_DRAWABLE (item)); } + +/* "New" functions */ + static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -530,6 +551,9 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, } } + +/* "Duplicate" functions */ + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -570,6 +594,9 @@ gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, } } + +/* "Raise/Lower" functions */ + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view) @@ -612,6 +639,9 @@ gimp_drawable_list_view_lower_clicked (GtkWidget *widget, } } + +/* "Edit" functions */ + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -646,6 +676,9 @@ gimp_drawable_list_view_edit_dropped (GtkWidget *widget, } } + +/* "Delete" functions */ + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -682,6 +715,9 @@ gimp_drawable_list_view_delete_dropped (GtkWidget *widget, } } + +/* GimpImage callbacks */ + static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, GimpDrawableListView *view) diff --git a/app/widgets/gimpdrawabletreeview.c b/app/widgets/gimpdrawabletreeview.c index 1a4c6ab849..ae2851c8eb 100644 --- a/app/widgets/gimpdrawabletreeview.c +++ b/app/widgets/gimpdrawabletreeview.c @@ -31,6 +31,8 @@ #include "gimpdrawablelistview.h" #include "gimpdnd.h" #include "gimpimage.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" #include "gimplistitem.h" #include "gimpmarshal.h" #include "gimprc.h" @@ -67,10 +69,12 @@ static void gimp_drawable_list_view_new_clicked (GtkWidget *w static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer data); + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view); static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, GimpDrawableListView *view); + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, @@ -78,6 +82,7 @@ static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *w static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, @@ -85,6 +90,7 @@ static void gimp_drawable_list_view_edit_clicked (GtkWidget *w static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, @@ -281,25 +287,6 @@ gimp_drawable_list_view_destroy (GtkObject *object) GTK_OBJECT_CLASS (parent_class)->destroy (object); } -static gpointer -gimp_drawable_list_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) -{ - gpointer list_item = NULL; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) - list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, - viewable, - index); - - if (list_item) - gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), - TRUE, view->container); - - return (gpointer) list_item; -} - GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage, GtkType drawable_type, @@ -325,7 +312,14 @@ gimp_drawable_list_view_new (GimpImage *gimage, g_return_val_if_fail (remove_drawable_func != NULL, NULL); g_return_val_if_fail (copy_drawable_func != NULL, NULL); - list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + if (drawable_type == GIMP_TYPE_LAYER) + { + list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW); + } + else + { + list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + } view = GIMP_CONTAINER_VIEW (list_view); @@ -420,11 +414,35 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name, GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed), view); + + gimp_drawable_list_view_drawable_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); } + +/* GimpContainerView methods */ + +static gpointer +gimp_drawable_list_view_insert_item (GimpContainerView *view, + GimpViewable *viewable, + gint index) +{ + gpointer list_item = NULL; + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) + list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, + viewable, + index); + + if (list_item) + gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), + TRUE, view->container); + + return list_item; +} + static void gimp_drawable_list_view_select_item (GimpContainerView *view, GimpViewable *item, @@ -497,6 +515,9 @@ gimp_drawable_list_view_activate_item (GimpContainerView *view, GIMP_DRAWABLE (item)); } + +/* "New" functions */ + static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -530,6 +551,9 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, } } + +/* "Duplicate" functions */ + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -570,6 +594,9 @@ gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, } } + +/* "Raise/Lower" functions */ + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view) @@ -612,6 +639,9 @@ gimp_drawable_list_view_lower_clicked (GtkWidget *widget, } } + +/* "Edit" functions */ + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -646,6 +676,9 @@ gimp_drawable_list_view_edit_dropped (GtkWidget *widget, } } + +/* "Delete" functions */ + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -682,6 +715,9 @@ gimp_drawable_list_view_delete_dropped (GtkWidget *widget, } } + +/* GimpImage callbacks */ + static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, GimpDrawableListView *view) diff --git a/app/widgets/gimpitemfactory.c b/app/widgets/gimpitemfactory.c index 8a86068f56..3736d02fd3 100644 --- a/app/widgets/gimpitemfactory.c +++ b/app/widgets/gimpitemfactory.c @@ -1791,7 +1791,9 @@ menus_init (void) menus_tools_create (GIMP_TOOL_INFO (list->data)); } /* reorder /Image/Colors */ - /*#warning FIXME (reorder /Image/Colors) */ +#ifdef __GNUC__ +#warning FIXME (reorder /Image/Colors) +#endif #if 0 menu_item = gtk_item_factory_get_widget (image_factory, tool_info[POSTERIZE].menu_path); diff --git a/app/widgets/gimpitemlistview.c b/app/widgets/gimpitemlistview.c index 1a4c6ab849..ae2851c8eb 100644 --- a/app/widgets/gimpitemlistview.c +++ b/app/widgets/gimpitemlistview.c @@ -31,6 +31,8 @@ #include "gimpdrawablelistview.h" #include "gimpdnd.h" #include "gimpimage.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" #include "gimplistitem.h" #include "gimpmarshal.h" #include "gimprc.h" @@ -67,10 +69,12 @@ static void gimp_drawable_list_view_new_clicked (GtkWidget *w static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer data); + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view); static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, GimpDrawableListView *view); + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, @@ -78,6 +82,7 @@ static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *w static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, @@ -85,6 +90,7 @@ static void gimp_drawable_list_view_edit_clicked (GtkWidget *w static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, @@ -281,25 +287,6 @@ gimp_drawable_list_view_destroy (GtkObject *object) GTK_OBJECT_CLASS (parent_class)->destroy (object); } -static gpointer -gimp_drawable_list_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) -{ - gpointer list_item = NULL; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) - list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, - viewable, - index); - - if (list_item) - gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), - TRUE, view->container); - - return (gpointer) list_item; -} - GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage, GtkType drawable_type, @@ -325,7 +312,14 @@ gimp_drawable_list_view_new (GimpImage *gimage, g_return_val_if_fail (remove_drawable_func != NULL, NULL); g_return_val_if_fail (copy_drawable_func != NULL, NULL); - list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + if (drawable_type == GIMP_TYPE_LAYER) + { + list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW); + } + else + { + list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + } view = GIMP_CONTAINER_VIEW (list_view); @@ -420,11 +414,35 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name, GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed), view); + + gimp_drawable_list_view_drawable_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); } + +/* GimpContainerView methods */ + +static gpointer +gimp_drawable_list_view_insert_item (GimpContainerView *view, + GimpViewable *viewable, + gint index) +{ + gpointer list_item = NULL; + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) + list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, + viewable, + index); + + if (list_item) + gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), + TRUE, view->container); + + return list_item; +} + static void gimp_drawable_list_view_select_item (GimpContainerView *view, GimpViewable *item, @@ -497,6 +515,9 @@ gimp_drawable_list_view_activate_item (GimpContainerView *view, GIMP_DRAWABLE (item)); } + +/* "New" functions */ + static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -530,6 +551,9 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, } } + +/* "Duplicate" functions */ + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -570,6 +594,9 @@ gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, } } + +/* "Raise/Lower" functions */ + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view) @@ -612,6 +639,9 @@ gimp_drawable_list_view_lower_clicked (GtkWidget *widget, } } + +/* "Edit" functions */ + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -646,6 +676,9 @@ gimp_drawable_list_view_edit_dropped (GtkWidget *widget, } } + +/* "Delete" functions */ + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -682,6 +715,9 @@ gimp_drawable_list_view_delete_dropped (GtkWidget *widget, } } + +/* GimpImage callbacks */ + static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, GimpDrawableListView *view) diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c index 1a4c6ab849..ae2851c8eb 100644 --- a/app/widgets/gimpitemtreeview.c +++ b/app/widgets/gimpitemtreeview.c @@ -31,6 +31,8 @@ #include "gimpdrawablelistview.h" #include "gimpdnd.h" #include "gimpimage.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" #include "gimplistitem.h" #include "gimpmarshal.h" #include "gimprc.h" @@ -67,10 +69,12 @@ static void gimp_drawable_list_view_new_clicked (GtkWidget *w static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer data); + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view); static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, GimpDrawableListView *view); + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, @@ -78,6 +82,7 @@ static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *w static void gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, @@ -85,6 +90,7 @@ static void gimp_drawable_list_view_edit_clicked (GtkWidget *w static void gimp_drawable_list_view_edit_dropped (GtkWidget *widget, GimpViewable *viewable, gpointer drawable); + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable); static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, @@ -281,25 +287,6 @@ gimp_drawable_list_view_destroy (GtkObject *object) GTK_OBJECT_CLASS (parent_class)->destroy (object); } -static gpointer -gimp_drawable_list_view_insert_item (GimpContainerView *view, - GimpViewable *viewable, - gint index) -{ - gpointer list_item = NULL; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) - list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, - viewable, - index); - - if (list_item) - gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), - TRUE, view->container); - - return (gpointer) list_item; -} - GtkWidget * gimp_drawable_list_view_new (GimpImage *gimage, GtkType drawable_type, @@ -325,7 +312,14 @@ gimp_drawable_list_view_new (GimpImage *gimage, g_return_val_if_fail (remove_drawable_func != NULL, NULL); g_return_val_if_fail (copy_drawable_func != NULL, NULL); - list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + if (drawable_type == GIMP_TYPE_LAYER) + { + list_view = gtk_type_new (GIMP_TYPE_LAYER_LIST_VIEW); + } + else + { + list_view = gtk_type_new (GIMP_TYPE_DRAWABLE_LIST_VIEW); + } view = GIMP_CONTAINER_VIEW (list_view); @@ -420,11 +414,35 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, gtk_signal_connect (GTK_OBJECT (view->gimage), view->signal_name, GTK_SIGNAL_FUNC (gimp_drawable_list_view_drawable_changed), view); + + gimp_drawable_list_view_drawable_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); } + +/* GimpContainerView methods */ + +static gpointer +gimp_drawable_list_view_insert_item (GimpContainerView *view, + GimpViewable *viewable, + gint index) +{ + gpointer list_item = NULL; + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item) + list_item = GIMP_CONTAINER_VIEW_CLASS (parent_class)->insert_item (view, + viewable, + index); + + if (list_item) + gimp_list_item_set_reorderable (GIMP_LIST_ITEM (list_item), + TRUE, view->container); + + return list_item; +} + static void gimp_drawable_list_view_select_item (GimpContainerView *view, GimpViewable *item, @@ -497,6 +515,9 @@ gimp_drawable_list_view_activate_item (GimpContainerView *view, GIMP_DRAWABLE (item)); } + +/* "New" functions */ + static void gimp_drawable_list_view_new_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -530,6 +551,9 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, } } + +/* "Duplicate" functions */ + static void gimp_drawable_list_view_duplicate_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -570,6 +594,9 @@ gimp_drawable_list_view_duplicate_dropped (GtkWidget *widget, } } + +/* "Raise/Lower" functions */ + static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, GimpDrawableListView *view) @@ -612,6 +639,9 @@ gimp_drawable_list_view_lower_clicked (GtkWidget *widget, } } + +/* "Edit" functions */ + static void gimp_drawable_list_view_edit_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -646,6 +676,9 @@ gimp_drawable_list_view_edit_dropped (GtkWidget *widget, } } + +/* "Delete" functions */ + static void gimp_drawable_list_view_delete_drawable (GimpDrawableListView *view, GimpDrawable *drawable) @@ -682,6 +715,9 @@ gimp_drawable_list_view_delete_dropped (GtkWidget *widget, } } + +/* GimpImage callbacks */ + static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, GimpDrawableListView *view) diff --git a/app/widgets/gimplayerlistitem.c b/app/widgets/gimplayerlistitem.c index d011f500a7..6ba688a9f9 100644 --- a/app/widgets/gimplayerlistitem.c +++ b/app/widgets/gimplayerlistitem.c @@ -23,6 +23,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -63,9 +64,19 @@ static void gimp_layer_list_item_mask_changed (GimpLayer *layer, GimpLayerListItem *layer_item); static void gimp_layer_list_item_update_state (GtkWidget *widget); +static void gimp_layer_list_item_layer_clicked (GtkWidget *widget, + GimpLayer *layer); +static void gimp_layer_list_item_mask_clicked (GtkWidget *widget, + GimpLayerMask *mask); + static GimpDrawableListItemClass *parent_class = NULL; +static GimpRGB black_color; +static GimpRGB white_color; +static GimpRGB green_color; +static GimpRGB red_color; + GtkType gimp_layer_list_item_get_type (void) @@ -111,6 +122,11 @@ gimp_layer_list_item_class_init (GimpLayerListItemClass *klass) widget_class->state_changed = gimp_layer_list_item_state_changed; list_item_class->set_viewable = gimp_layer_list_item_set_viewable; + + gimp_rgba_set (&black_color, 0.0, 0.0, 0.0, 1.0); + gimp_rgba_set (&white_color, 1.0, 1.0, 1.0, 1.0); + gimp_rgba_set (&green_color, 0.0, 1.0, 0.0, 1.0); + gimp_rgba_set (&red_color, 1.0, 0.0, 0.0, 1.0); } static void @@ -135,6 +151,10 @@ gimp_layer_list_item_set_viewable (GimpListItem *list_item, layer_item = GIMP_LAYER_LIST_ITEM (list_item); layer = GIMP_LAYER (GIMP_PREVIEW (list_item->preview)->viewable); + gtk_signal_connect (GTK_OBJECT (list_item->preview), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_item_layer_clicked), + layer); + if (gimp_layer_get_mask (layer)) { gimp_layer_list_item_mask_changed (layer, layer_item); @@ -259,13 +279,19 @@ gimp_layer_list_item_mask_changed (GimpLayer *layer, layer_item->mask_preview = gimp_preview_new (GIMP_VIEWABLE (mask), list_item->preview_size, 2, FALSE); + GIMP_PREVIEW (layer_item->mask_preview)->clickable = TRUE; + gtk_box_pack_start (GTK_BOX (list_item->hbox), layer_item->mask_preview, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (list_item->hbox), layer_item->mask_preview, 2); gtk_widget_show (layer_item->mask_preview); + gtk_signal_connect (GTK_OBJECT (layer_item->mask_preview), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_item_mask_clicked), + mask); + gtk_signal_connect_object (GTK_OBJECT (mask), "apply_changed", GTK_SIGNAL_FUNC (gimp_layer_list_item_update_state), @@ -298,8 +324,8 @@ gimp_layer_list_item_update_state (GtkWidget *widget) GimpLayer *layer; GimpLayerMask *mask; GimpPreview *preview; - guchar layer_color[3] = { 0, 0, 0 }; - guchar mask_color[3] = { 0, 0, 0 }; + GimpRGB *layer_color = &black_color; + GimpRGB *mask_color = &black_color; layer_item = GIMP_LAYER_LIST_ITEM (widget); list_item = GIMP_LIST_ITEM (widget); @@ -314,15 +340,11 @@ gimp_layer_list_item_update_state (GtkWidget *widget) case GTK_STATE_SELECTED: if (! mask || (mask && ! gimp_layer_mask_get_edit (mask))) { - layer_color[0] = 255; - layer_color[1] = 255; - layer_color[2] = 255; + layer_color = &white_color; } else { - mask_color[0] = 255; - mask_color[1] = 255; - mask_color[2] = 255; + mask_color = &white_color; } break; @@ -332,30 +354,39 @@ gimp_layer_list_item_update_state (GtkWidget *widget) preview = GIMP_PREVIEW (list_item->preview); - if (preview->border_color[0] != layer_color[0] || - preview->border_color[1] != layer_color[1] || - preview->border_color[2] != layer_color[2]) - { - preview->border_color[0] = layer_color[0]; - preview->border_color[1] = layer_color[1]; - preview->border_color[2] = layer_color[2]; - - gimp_preview_render (preview); - } + gimp_preview_set_border_color (preview, layer_color); if (mask) { preview = GIMP_PREVIEW (layer_item->mask_preview); - if (preview->border_color[0] != mask_color[0] || - preview->border_color[1] != mask_color[1] || - preview->border_color[2] != mask_color[2]) - { - preview->border_color[0] = mask_color[0]; - preview->border_color[1] = mask_color[1]; - preview->border_color[2] = mask_color[2]; - - gimp_preview_render (preview); - } + gimp_preview_set_border_color (preview, mask_color); } } + +static void +gimp_layer_list_item_layer_clicked (GtkWidget *widget, + GimpLayer *layer) +{ + GimpLayerMask *mask; + + g_print ("layer clicked\n"); + + mask = gimp_layer_get_mask (layer); + + if (mask) + { + if (gimp_layer_mask_get_edit (mask)) + gimp_layer_mask_set_edit (mask, FALSE); + } +} + +static void +gimp_layer_list_item_mask_clicked (GtkWidget *widget, + GimpLayerMask *mask) +{ + g_print ("mask clicked\n"); + + if (! gimp_layer_mask_get_edit (mask)) + gimp_layer_mask_set_edit (mask, TRUE); +} diff --git a/app/widgets/gimplayerlistview.c b/app/widgets/gimplayerlistview.c new file mode 100644 index 0000000000..cbdb69feb3 --- /dev/null +++ b/app/widgets/gimplayerlistview.c @@ -0,0 +1,511 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpmath/gimpmath.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "apptypes.h" + +#include "drawable.h" +#include "gdisplay.h" +#include "gimpcontainer.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" +#include "gimpdnd.h" +#include "gimpimage.h" +#include "gimplistitem.h" +#include "gimpmarshal.h" +#include "gimprc.h" +#include "gimpviewable.h" + +#include "tools/paint_options.h" + +#include "libgimp/gimpintl.h" + +#include "pixmaps/anchor.xpm" + + +static void gimp_layer_list_view_class_init (GimpLayerListViewClass *klass); +static void gimp_layer_list_view_init (GimpLayerListView *view); + +static void gimp_layer_list_view_destroy (GtkObject *object); + +static void gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container); +static void gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); + +static void gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer); +static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data); + +static void gimp_layer_list_view_paint_mode_menu_callback + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_preserve_button_toggled + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_opacity_scale_changed + (GtkAdjustment *adjustment, + GimpLayerListView *view); + +static void gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view); +static void gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer); + + +static GimpDrawableListViewClass *parent_class = NULL; + + +GtkType +gimp_layer_list_view_get_type (void) +{ + static guint view_type = 0; + + if (! view_type) + { + GtkTypeInfo view_info = + { + "GimpLayerListView", + sizeof (GimpLayerListView), + sizeof (GimpLayerListViewClass), + (GtkClassInitFunc) gimp_layer_list_view_class_init, + (GtkObjectInitFunc) gimp_layer_list_view_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL + }; + + view_type = gtk_type_unique (GIMP_TYPE_DRAWABLE_LIST_VIEW, &view_info); + } + + return view_type; +} + +static void +gimp_layer_list_view_class_init (GimpLayerListViewClass *klass) +{ + GtkObjectClass *object_class; + GimpContainerViewClass *container_view_class; + + object_class = (GtkObjectClass *) klass; + container_view_class = (GimpContainerViewClass *) klass; + + parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE_LIST_VIEW); + + object_class->destroy = gimp_layer_list_view_destroy; + + container_view_class->set_container = gimp_layer_list_view_set_container; + container_view_class->select_item = gimp_layer_list_view_select_item; +} + +static void +gimp_layer_list_view_init (GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *slider; + GtkWidget *pixmap; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + view->options_box = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0); + gtk_widget_show (view->options_box); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Paint mode menu */ + + label = gtk_label_new (_("Mode:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->paint_mode_menu = + paint_mode_menu_new (gimp_layer_list_view_paint_mode_menu_callback, view, + FALSE, NORMAL_MODE); + gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, FALSE, FALSE, 2); + gtk_widget_show (view->paint_mode_menu); + + /* Preserve transparency toggle */ + + view->preserve_trans_toggle = + gtk_check_button_new_with_label (_("Keep Trans.")); + gtk_box_pack_start (GTK_BOX (hbox), view->preserve_trans_toggle, + FALSE, FALSE, 2); + gtk_widget_show (view->preserve_trans_toggle); + + gtk_signal_connect (GTK_OBJECT (view->preserve_trans_toggle), "toggled", + GTK_SIGNAL_FUNC (gimp_layer_list_view_preserve_button_toggled), + view); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Opacity scale */ + + label = gtk_label_new (_("Opacity:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->opacity_adjustment = + GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0, 1.0, 1.0, 0.0)); + + gtk_signal_connect (GTK_OBJECT (view->opacity_adjustment), "value_changed", + GTK_SIGNAL_FUNC (gimp_layer_list_view_opacity_scale_changed), + view); + + slider = gtk_hscale_new (view->opacity_adjustment); + gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_RIGHT); + gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0); + gtk_widget_show (slider); + + /* Anchor button */ + + view->anchor_button = gtk_button_new (); + gtk_box_pack_start (GTK_BOX (drawable_view->button_box), view->anchor_button, + TRUE, TRUE, 0); + gtk_box_reorder_child (GTK_BOX (drawable_view->button_box), + view->anchor_button, 5); + gtk_widget_show (view->anchor_button); + + gimp_help_set_help_data (view->anchor_button, _("Anchor"), NULL); + + gtk_signal_connect (GTK_OBJECT (view->anchor_button), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_view_anchor_clicked), + view); + + pixmap = gimp_pixmap_new (anchor_xpm); + gtk_container_add (GTK_CONTAINER (view->anchor_button), pixmap); + gtk_widget_show (pixmap); + + gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->anchor_button), + GTK_DEST_DEFAULT_ALL, + GIMP_TYPE_LAYER, + GDK_ACTION_COPY); + gimp_dnd_viewable_dest_set (GTK_WIDGET (view->anchor_button), + GIMP_TYPE_LAYER, + gimp_layer_list_view_anchor_dropped, + view); + + gtk_widget_set_sensitive (view->options_box, FALSE); + gtk_widget_set_sensitive (view->anchor_button, FALSE); + + view->mode_changed_handler_id = 0; + view->opacity_changed_handler_id = 0; + view->preserve_trans_changed_handler_id = 0; +} + +static void +gimp_layer_list_view_destroy (GtkObject *object) +{ + GimpLayerListView *view; + + view = GIMP_LAYER_LIST_VIEW (object); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + GTK_OBJECT_CLASS (parent_class)->destroy (object); +} + + +/* GimpContainerView methods */ + +static void +gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container) +{ + GimpLayerListView *layer_view; + + layer_view = GIMP_LAYER_LIST_VIEW (view); + + if (view->container) + { + gimp_container_remove_handler (view->container, + layer_view->mode_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->opacity_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->preserve_trans_changed_handler_id); + } + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container); + + if (view->container) + { + layer_view->mode_changed_handler_id = + gimp_container_add_handler (view->container, "mode_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->opacity_changed_handler_id = + gimp_container_add_handler (view->container, "opacity_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->preserve_trans_changed_handler_id = + gimp_container_add_handler (view->container, "preserve_trans_changed", + gimp_layer_list_view_layer_signal_handler, + view); + } +} + +static void +gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) +{ + GimpLayerListView *list_view; + gboolean options_sensitive = FALSE; + gboolean anchor_sensitive = FALSE; + + list_view = GIMP_LAYER_LIST_VIEW (view); + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, + item, + insert_data); + + if (item) + { + gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item)); + + options_sensitive = TRUE; + + if (gimp_layer_is_floating_sel (GIMP_LAYER (item))) + { + anchor_sensitive = TRUE; + } + } + + gtk_widget_set_sensitive (list_view->options_box, options_sensitive); + gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive); +} + + +/* "Anchor" functions */ + +static void +gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer) +{ + if (layer) + g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name); +} + +static void +gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpDrawable *drawable; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + drawable = drawable_view->get_drawable_func (drawable_view->gimage); + + if (drawable) + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (drawable)); +} + +static void +gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data) +{ + GimpLayerListView *view; + + view = (GimpLayerListView *) data; + + if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, + GIMP_OBJECT (viewable))) + { + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (viewable)); + } +} + + +/* Paint Mode, Opacity and Preservce trans. callbacks */ + +#define BLOCK() \ + gtk_signal_handler_block_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + +#define UNBLOCK() \ + gtk_signal_handler_unblock_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + + +static void +gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + LayerModeEffects mode; + + mode = (LayerModeEffects) + GPOINTER_TO_INT (gtk_object_get_user_data (GTK_OBJECT (widget))); + + if (gimp_layer_get_mode (layer) != mode) + { + BLOCK(); + gimp_layer_set_mode (layer, mode); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +static void +gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gboolean preserve_trans; + + preserve_trans = GTK_TOGGLE_BUTTON (widget)->active; + + if (gimp_layer_get_preserve_trans (layer) != preserve_trans) + { + BLOCK(); + gimp_layer_set_preserve_trans (layer, preserve_trans); + UNBLOCK(); + } + } +} + +static void +gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gdouble opacity; + + opacity = adjustment->value / 100.0; + + if (gimp_layer_get_opacity (layer) != opacity) + { + BLOCK(); + gimp_layer_set_opacity (layer, opacity); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +#undef BLOCK +#undef UNBLOCK + + +static void +gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + if (drawable_view->get_drawable_func (drawable_view->gimage) == + (GimpDrawable *) layer) + { + gimp_layer_list_view_update_options (view, layer); + } +} + +static void +gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer) +{ + gimp_option_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu), + GINT_TO_POINTER (layer->mode)); + + if (layer->preserve_trans != + GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle), + layer->preserve_trans); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + } + + if ((gdouble) layer->opacity / 2.55 != view->opacity_adjustment->value) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + + gtk_adjustment_set_value (view->opacity_adjustment, layer->opacity / 2.55); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + } +} diff --git a/app/widgets/gimplayerlistview.h b/app/widgets/gimplayerlistview.h new file mode 100644 index 0000000000..e52fbbf313 --- /dev/null +++ b/app/widgets/gimplayerlistview.h @@ -0,0 +1,62 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_LAYER_LIST_VIEW_H__ +#define __GIMP_LAYER_LIST_VIEW_H__ + + +#include "gimpdrawablelistview.h" + + +#define GIMP_TYPE_LAYER_LIST_VIEW (gimp_layer_list_view_get_type ()) +#define GIMP_LAYER_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListView)) +#define GIMP_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListViewClass)) +#define GIMP_IS_LAYER_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_LIST_VIEW)) +#define GIMP_IS_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_LIST_VIEW)) + + +typedef struct _GimpLayerListViewClass GimpLayerListViewClass; + +struct _GimpLayerListView +{ + GimpDrawableListView parent_instance; + + GtkWidget *options_box; + + GtkWidget *paint_mode_menu; + GtkWidget *preserve_trans_toggle; + GtkAdjustment *opacity_adjustment; + + GtkWidget *anchor_button; + + /*< private >*/ + GQuark mode_changed_handler_id; + GQuark opacity_changed_handler_id; + GQuark preserve_trans_changed_handler_id; +}; + +struct _GimpLayerListViewClass +{ + GimpDrawableListViewClass parent_class; +}; + + +GtkType gimp_layer_list_view_get_type (void); + + +#endif /* __GIMP_LAYER_LIST_VIEW_H__ */ diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c new file mode 100644 index 0000000000..cbdb69feb3 --- /dev/null +++ b/app/widgets/gimplayertreeview.c @@ -0,0 +1,511 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpmath/gimpmath.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "apptypes.h" + +#include "drawable.h" +#include "gdisplay.h" +#include "gimpcontainer.h" +#include "gimplayer.h" +#include "gimplayerlistview.h" +#include "gimpdnd.h" +#include "gimpimage.h" +#include "gimplistitem.h" +#include "gimpmarshal.h" +#include "gimprc.h" +#include "gimpviewable.h" + +#include "tools/paint_options.h" + +#include "libgimp/gimpintl.h" + +#include "pixmaps/anchor.xpm" + + +static void gimp_layer_list_view_class_init (GimpLayerListViewClass *klass); +static void gimp_layer_list_view_init (GimpLayerListView *view); + +static void gimp_layer_list_view_destroy (GtkObject *object); + +static void gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container); +static void gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); + +static void gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer); +static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data); + +static void gimp_layer_list_view_paint_mode_menu_callback + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_preserve_button_toggled + (GtkWidget *widget, + GimpLayerListView *view); +static void gimp_layer_list_view_opacity_scale_changed + (GtkAdjustment *adjustment, + GimpLayerListView *view); + +static void gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view); +static void gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer); + + +static GimpDrawableListViewClass *parent_class = NULL; + + +GtkType +gimp_layer_list_view_get_type (void) +{ + static guint view_type = 0; + + if (! view_type) + { + GtkTypeInfo view_info = + { + "GimpLayerListView", + sizeof (GimpLayerListView), + sizeof (GimpLayerListViewClass), + (GtkClassInitFunc) gimp_layer_list_view_class_init, + (GtkObjectInitFunc) gimp_layer_list_view_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL + }; + + view_type = gtk_type_unique (GIMP_TYPE_DRAWABLE_LIST_VIEW, &view_info); + } + + return view_type; +} + +static void +gimp_layer_list_view_class_init (GimpLayerListViewClass *klass) +{ + GtkObjectClass *object_class; + GimpContainerViewClass *container_view_class; + + object_class = (GtkObjectClass *) klass; + container_view_class = (GimpContainerViewClass *) klass; + + parent_class = gtk_type_class (GIMP_TYPE_DRAWABLE_LIST_VIEW); + + object_class->destroy = gimp_layer_list_view_destroy; + + container_view_class->set_container = gimp_layer_list_view_set_container; + container_view_class->select_item = gimp_layer_list_view_select_item; +} + +static void +gimp_layer_list_view_init (GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *slider; + GtkWidget *pixmap; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + view->options_box = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view), view->options_box, FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (view), view->options_box, 0); + gtk_widget_show (view->options_box); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Paint mode menu */ + + label = gtk_label_new (_("Mode:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->paint_mode_menu = + paint_mode_menu_new (gimp_layer_list_view_paint_mode_menu_callback, view, + FALSE, NORMAL_MODE); + gtk_box_pack_start (GTK_BOX (hbox), view->paint_mode_menu, FALSE, FALSE, 2); + gtk_widget_show (view->paint_mode_menu); + + /* Preserve transparency toggle */ + + view->preserve_trans_toggle = + gtk_check_button_new_with_label (_("Keep Trans.")); + gtk_box_pack_start (GTK_BOX (hbox), view->preserve_trans_toggle, + FALSE, FALSE, 2); + gtk_widget_show (view->preserve_trans_toggle); + + gtk_signal_connect (GTK_OBJECT (view->preserve_trans_toggle), "toggled", + GTK_SIGNAL_FUNC (gimp_layer_list_view_preserve_button_toggled), + view); + + hbox = gtk_hbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (view->options_box), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Opacity scale */ + + label = gtk_label_new (_("Opacity:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + view->opacity_adjustment = + GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0, 1.0, 1.0, 0.0)); + + gtk_signal_connect (GTK_OBJECT (view->opacity_adjustment), "value_changed", + GTK_SIGNAL_FUNC (gimp_layer_list_view_opacity_scale_changed), + view); + + slider = gtk_hscale_new (view->opacity_adjustment); + gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_RIGHT); + gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0); + gtk_widget_show (slider); + + /* Anchor button */ + + view->anchor_button = gtk_button_new (); + gtk_box_pack_start (GTK_BOX (drawable_view->button_box), view->anchor_button, + TRUE, TRUE, 0); + gtk_box_reorder_child (GTK_BOX (drawable_view->button_box), + view->anchor_button, 5); + gtk_widget_show (view->anchor_button); + + gimp_help_set_help_data (view->anchor_button, _("Anchor"), NULL); + + gtk_signal_connect (GTK_OBJECT (view->anchor_button), "clicked", + GTK_SIGNAL_FUNC (gimp_layer_list_view_anchor_clicked), + view); + + pixmap = gimp_pixmap_new (anchor_xpm); + gtk_container_add (GTK_CONTAINER (view->anchor_button), pixmap); + gtk_widget_show (pixmap); + + gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (view->anchor_button), + GTK_DEST_DEFAULT_ALL, + GIMP_TYPE_LAYER, + GDK_ACTION_COPY); + gimp_dnd_viewable_dest_set (GTK_WIDGET (view->anchor_button), + GIMP_TYPE_LAYER, + gimp_layer_list_view_anchor_dropped, + view); + + gtk_widget_set_sensitive (view->options_box, FALSE); + gtk_widget_set_sensitive (view->anchor_button, FALSE); + + view->mode_changed_handler_id = 0; + view->opacity_changed_handler_id = 0; + view->preserve_trans_changed_handler_id = 0; +} + +static void +gimp_layer_list_view_destroy (GtkObject *object) +{ + GimpLayerListView *view; + + view = GIMP_LAYER_LIST_VIEW (object); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + GTK_OBJECT_CLASS (parent_class)->destroy (object); +} + + +/* GimpContainerView methods */ + +static void +gimp_layer_list_view_set_container (GimpContainerView *view, + GimpContainer *container) +{ + GimpLayerListView *layer_view; + + layer_view = GIMP_LAYER_LIST_VIEW (view); + + if (view->container) + { + gimp_container_remove_handler (view->container, + layer_view->mode_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->opacity_changed_handler_id); + gimp_container_remove_handler (view->container, + layer_view->preserve_trans_changed_handler_id); + } + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->set_container (view, container); + + if (view->container) + { + layer_view->mode_changed_handler_id = + gimp_container_add_handler (view->container, "mode_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->opacity_changed_handler_id = + gimp_container_add_handler (view->container, "opacity_changed", + gimp_layer_list_view_layer_signal_handler, + view); + layer_view->preserve_trans_changed_handler_id = + gimp_container_add_handler (view->container, "preserve_trans_changed", + gimp_layer_list_view_layer_signal_handler, + view); + } +} + +static void +gimp_layer_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) +{ + GimpLayerListView *list_view; + gboolean options_sensitive = FALSE; + gboolean anchor_sensitive = FALSE; + + list_view = GIMP_LAYER_LIST_VIEW (view); + + if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) + GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, + item, + insert_data); + + if (item) + { + gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item)); + + options_sensitive = TRUE; + + if (gimp_layer_is_floating_sel (GIMP_LAYER (item))) + { + anchor_sensitive = TRUE; + } + } + + gtk_widget_set_sensitive (list_view->options_box, options_sensitive); + gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive); +} + + +/* "Anchor" functions */ + +static void +gimp_layer_list_view_anchor_layer (GimpLayerListView *view, + GimpLayer *layer) +{ + if (layer) + g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name); +} + +static void +gimp_layer_list_view_anchor_clicked (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpDrawable *drawable; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + drawable = drawable_view->get_drawable_func (drawable_view->gimage); + + if (drawable) + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (drawable)); +} + +static void +gimp_layer_list_view_anchor_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data) +{ + GimpLayerListView *view; + + view = (GimpLayerListView *) data; + + if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, + GIMP_OBJECT (viewable))) + { + gimp_layer_list_view_anchor_layer (view, GIMP_LAYER (viewable)); + } +} + + +/* Paint Mode, Opacity and Preservce trans. callbacks */ + +#define BLOCK() \ + gtk_signal_handler_block_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + +#define UNBLOCK() \ + gtk_signal_handler_unblock_by_func (GTK_OBJECT (layer), \ + gimp_layer_list_view_layer_signal_handler, view) + + +static void +gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + LayerModeEffects mode; + + mode = (LayerModeEffects) + GPOINTER_TO_INT (gtk_object_get_user_data (GTK_OBJECT (widget))); + + if (gimp_layer_get_mode (layer) != mode) + { + BLOCK(); + gimp_layer_set_mode (layer, mode); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +static void +gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gboolean preserve_trans; + + preserve_trans = GTK_TOGGLE_BUTTON (widget)->active; + + if (gimp_layer_get_preserve_trans (layer) != preserve_trans) + { + BLOCK(); + gimp_layer_set_preserve_trans (layer, preserve_trans); + UNBLOCK(); + } + } +} + +static void +gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + GimpLayer *layer; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + + if (layer) + { + gdouble opacity; + + opacity = adjustment->value / 100.0; + + if (gimp_layer_get_opacity (layer) != opacity) + { + BLOCK(); + gimp_layer_set_opacity (layer, opacity); + UNBLOCK(); + + drawable_update (GIMP_DRAWABLE (layer), 0, 0, + GIMP_DRAWABLE (layer)->width, + GIMP_DRAWABLE (layer)->height); + + gdisplays_flush (); + } + } +} + +#undef BLOCK +#undef UNBLOCK + + +static void +gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, + GimpLayerListView *view) +{ + GimpDrawableListView *drawable_view; + + drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + + if (drawable_view->get_drawable_func (drawable_view->gimage) == + (GimpDrawable *) layer) + { + gimp_layer_list_view_update_options (view, layer); + } +} + +static void +gimp_layer_list_view_update_options (GimpLayerListView *view, + GimpLayer *layer) +{ + gimp_option_menu_set_history (GTK_OPTION_MENU (view->paint_mode_menu), + GINT_TO_POINTER (layer->mode)); + + if (layer->preserve_trans != + GTK_TOGGLE_BUTTON (view->preserve_trans_toggle)->active) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->preserve_trans_toggle), + layer->preserve_trans); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->preserve_trans_toggle), + gimp_layer_list_view_preserve_button_toggled, + view); + } + + if ((gdouble) layer->opacity / 2.55 != view->opacity_adjustment->value) + { + gtk_signal_handler_block_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + + gtk_adjustment_set_value (view->opacity_adjustment, layer->opacity / 2.55); + + gtk_signal_handler_unblock_by_func (GTK_OBJECT (view->opacity_adjustment), + gimp_layer_list_view_opacity_scale_changed, + view); + } +} diff --git a/app/widgets/gimplayertreeview.h b/app/widgets/gimplayertreeview.h new file mode 100644 index 0000000000..e52fbbf313 --- /dev/null +++ b/app/widgets/gimplayertreeview.h @@ -0,0 +1,62 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_LAYER_LIST_VIEW_H__ +#define __GIMP_LAYER_LIST_VIEW_H__ + + +#include "gimpdrawablelistview.h" + + +#define GIMP_TYPE_LAYER_LIST_VIEW (gimp_layer_list_view_get_type ()) +#define GIMP_LAYER_LIST_VIEW(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListView)) +#define GIMP_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_LIST_VIEW, GimpLayerListViewClass)) +#define GIMP_IS_LAYER_LIST_VIEW(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_LIST_VIEW)) +#define GIMP_IS_LAYER_LIST_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_LIST_VIEW)) + + +typedef struct _GimpLayerListViewClass GimpLayerListViewClass; + +struct _GimpLayerListView +{ + GimpDrawableListView parent_instance; + + GtkWidget *options_box; + + GtkWidget *paint_mode_menu; + GtkWidget *preserve_trans_toggle; + GtkAdjustment *opacity_adjustment; + + GtkWidget *anchor_button; + + /*< private >*/ + GQuark mode_changed_handler_id; + GQuark opacity_changed_handler_id; + GQuark preserve_trans_changed_handler_id; +}; + +struct _GimpLayerListViewClass +{ + GimpDrawableListViewClass parent_class; +}; + + +GtkType gimp_layer_list_view_get_type (void); + + +#endif /* __GIMP_LAYER_LIST_VIEW_H__ */ diff --git a/app/widgets/gimplistitem.c b/app/widgets/gimplistitem.c index a7b4beb8d8..7eccbe2e64 100644 --- a/app/widgets/gimplistitem.c +++ b/app/widgets/gimplistitem.c @@ -327,11 +327,6 @@ gimp_list_item_real_set_viewable (GimpListItem *list_item, GTK_OBJECT (viewable)->klass->type, gimp_list_item_drag_viewable, NULL); - - gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_item), - GTK_DEST_DEFAULT_ALL, - GTK_OBJECT (viewable)->klass->type, - GDK_ACTION_MOVE | GDK_ACTION_COPY); } void @@ -348,9 +343,20 @@ gimp_list_item_set_reorderable (GimpListItem *list_item, list_item->reorderable = reorderable; if (reorderable) - list_item->container = container; + { + list_item->container = container; + + gimp_gtk_drag_dest_set_by_type (GTK_WIDGET (list_item), + GTK_DEST_DEFAULT_ALL, + container->children_type, + GDK_ACTION_MOVE | GDK_ACTION_COPY); + } else - list_item->container = NULL; + { + list_item->container = NULL; + + gtk_drag_dest_unset (GTK_WIDGET (list_item)); + } } gboolean diff --git a/app/widgets/gimppreview.c b/app/widgets/gimppreview.c index 93bf640eaf..011ba7071e 100644 --- a/app/widgets/gimppreview.c +++ b/app/widgets/gimppreview.c @@ -25,6 +25,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -236,9 +237,7 @@ gimp_preview_init (GimpPreview *preview) preview->height = 8; preview->border_width = 0; - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; + gimp_rgba_set (&preview->border_color, 0.0, 0.0, 0.0, 1.0); preview->is_popup = FALSE; preview->clickable = FALSE; @@ -409,47 +408,6 @@ gimp_preview_new_full (GimpViewable *viewable, return GTK_WIDGET (preview); } -void -gimp_preview_set_size (GimpPreview *preview, - gint preview_size, - gint border_width) -{ - gint width, height; - - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (preview_size > 0 && preview_size <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - gimp_preview_get_size (preview, preview_size, &width, &height); - - gimp_preview_set_size_full (preview, - width, - height, - border_width); -} - -void -gimp_preview_set_size_full (GimpPreview *preview, - gint width, - gint height, - gint border_width) -{ - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (width > 0 && width <= 256); - g_return_if_fail (height > 0 && height <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - preview->width = width; - preview->height = height; - preview->border_width = border_width; - - gtk_preview_size (GTK_PREVIEW (preview), - width + 2 * preview->border_width, - height + 2 * preview->border_width); -} - void gimp_preview_set_viewable (GimpPreview *preview, GimpViewable *viewable) @@ -512,6 +470,63 @@ gimp_preview_set_viewable (GimpPreview *preview, } } +void +gimp_preview_set_size (GimpPreview *preview, + gint preview_size, + gint border_width) +{ + gint width, height; + + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (preview_size > 0 && preview_size <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + gimp_preview_get_size (preview, preview_size, &width, &height); + + gimp_preview_set_size_full (preview, + width, + height, + border_width); +} + +void +gimp_preview_set_size_full (GimpPreview *preview, + gint width, + gint height, + gint border_width) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (width > 0 && width <= 256); + g_return_if_fail (height > 0 && height <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + preview->width = width; + preview->height = height; + preview->border_width = border_width; + + gtk_preview_size (GTK_PREVIEW (preview), + width + 2 * preview->border_width, + height + 2 * preview->border_width); +} + +void +gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *color) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (color != NULL); + + if (gimp_rgb_distance (&preview->border_color, color)) + { + preview->border_color = *color; + + gimp_preview_render (preview); + } +} + void gimp_preview_render (GimpPreview *preview) { @@ -864,11 +879,17 @@ gimp_preview_render_and_flush (GimpPreview *preview, gint image_bytes; gint offset; gint border; + guchar border_color[3]; width = preview->width; height = preview->height; border = preview->border_width; + gimp_rgb_get_uchar (&preview->border_color, + &border_color[0], + &border_color[1], + &border_color[2]); + alpha = ALPHA_PIX; /* Here are the different cases this functions handles correctly: @@ -923,9 +944,9 @@ gimp_preview_render_and_flush (GimpPreview *preview, /* Set the border color once before rendering */ for (j = 0; j < width + border * 2; j++) { - render_temp_buf[j * 3 + 0] = preview->border_color[0]; - render_temp_buf[j * 3 + 1] = preview->border_color[1]; - render_temp_buf[j * 3 + 2] = preview->border_color[2]; + render_temp_buf[j * 3 + 0] = border_color[0]; + render_temp_buf[j * 3 + 1] = border_color[1]; + render_temp_buf[j * 3 + 2] = border_color[2]; } for (i = 0; i < border; i++) diff --git a/app/widgets/gimppreview.h b/app/widgets/gimppreview.h index 2409b8346d..6e5a8b00a2 100644 --- a/app/widgets/gimppreview.h +++ b/app/widgets/gimppreview.h @@ -50,13 +50,13 @@ struct _GimpPreview gint height; gint border_width; - /* TEMP HACK: */ - guchar border_color[3]; + GimpRGB border_color; gboolean is_popup; gboolean clickable; gboolean show_popup; + /*< private >*/ gboolean in_button; guint idle_id; guint popup_id; @@ -94,6 +94,9 @@ GtkWidget * gimp_preview_new_full (GimpViewable *viewable, gboolean clickable, gboolean show_popup); +void gimp_preview_set_viewable (GimpPreview *preview, + GimpViewable *viewable); + void gimp_preview_set_size (GimpPreview *preview, gint size, gint border_width); @@ -102,13 +105,13 @@ void gimp_preview_set_size_full (GimpPreview *preview, gint height, gint border_width); -void gimp_preview_set_viewable (GimpPreview *preview, - GimpViewable *viewable); +void gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *border_color); void gimp_preview_render (GimpPreview *preview); -/* private */ +/* protected */ void gimp_preview_render_and_flush (GimpPreview *preview, TempBuf *temp_buf, diff --git a/app/widgets/gimppreviewrenderer.c b/app/widgets/gimppreviewrenderer.c index 93bf640eaf..011ba7071e 100644 --- a/app/widgets/gimppreviewrenderer.c +++ b/app/widgets/gimppreviewrenderer.c @@ -25,6 +25,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -236,9 +237,7 @@ gimp_preview_init (GimpPreview *preview) preview->height = 8; preview->border_width = 0; - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; + gimp_rgba_set (&preview->border_color, 0.0, 0.0, 0.0, 1.0); preview->is_popup = FALSE; preview->clickable = FALSE; @@ -409,47 +408,6 @@ gimp_preview_new_full (GimpViewable *viewable, return GTK_WIDGET (preview); } -void -gimp_preview_set_size (GimpPreview *preview, - gint preview_size, - gint border_width) -{ - gint width, height; - - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (preview_size > 0 && preview_size <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - gimp_preview_get_size (preview, preview_size, &width, &height); - - gimp_preview_set_size_full (preview, - width, - height, - border_width); -} - -void -gimp_preview_set_size_full (GimpPreview *preview, - gint width, - gint height, - gint border_width) -{ - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (width > 0 && width <= 256); - g_return_if_fail (height > 0 && height <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - preview->width = width; - preview->height = height; - preview->border_width = border_width; - - gtk_preview_size (GTK_PREVIEW (preview), - width + 2 * preview->border_width, - height + 2 * preview->border_width); -} - void gimp_preview_set_viewable (GimpPreview *preview, GimpViewable *viewable) @@ -512,6 +470,63 @@ gimp_preview_set_viewable (GimpPreview *preview, } } +void +gimp_preview_set_size (GimpPreview *preview, + gint preview_size, + gint border_width) +{ + gint width, height; + + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (preview_size > 0 && preview_size <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + gimp_preview_get_size (preview, preview_size, &width, &height); + + gimp_preview_set_size_full (preview, + width, + height, + border_width); +} + +void +gimp_preview_set_size_full (GimpPreview *preview, + gint width, + gint height, + gint border_width) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (width > 0 && width <= 256); + g_return_if_fail (height > 0 && height <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + preview->width = width; + preview->height = height; + preview->border_width = border_width; + + gtk_preview_size (GTK_PREVIEW (preview), + width + 2 * preview->border_width, + height + 2 * preview->border_width); +} + +void +gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *color) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (color != NULL); + + if (gimp_rgb_distance (&preview->border_color, color)) + { + preview->border_color = *color; + + gimp_preview_render (preview); + } +} + void gimp_preview_render (GimpPreview *preview) { @@ -864,11 +879,17 @@ gimp_preview_render_and_flush (GimpPreview *preview, gint image_bytes; gint offset; gint border; + guchar border_color[3]; width = preview->width; height = preview->height; border = preview->border_width; + gimp_rgb_get_uchar (&preview->border_color, + &border_color[0], + &border_color[1], + &border_color[2]); + alpha = ALPHA_PIX; /* Here are the different cases this functions handles correctly: @@ -923,9 +944,9 @@ gimp_preview_render_and_flush (GimpPreview *preview, /* Set the border color once before rendering */ for (j = 0; j < width + border * 2; j++) { - render_temp_buf[j * 3 + 0] = preview->border_color[0]; - render_temp_buf[j * 3 + 1] = preview->border_color[1]; - render_temp_buf[j * 3 + 2] = preview->border_color[2]; + render_temp_buf[j * 3 + 0] = border_color[0]; + render_temp_buf[j * 3 + 1] = border_color[1]; + render_temp_buf[j * 3 + 2] = border_color[2]; } for (i = 0; i < border; i++) diff --git a/app/widgets/gimppreviewrenderer.h b/app/widgets/gimppreviewrenderer.h index 2409b8346d..6e5a8b00a2 100644 --- a/app/widgets/gimppreviewrenderer.h +++ b/app/widgets/gimppreviewrenderer.h @@ -50,13 +50,13 @@ struct _GimpPreview gint height; gint border_width; - /* TEMP HACK: */ - guchar border_color[3]; + GimpRGB border_color; gboolean is_popup; gboolean clickable; gboolean show_popup; + /*< private >*/ gboolean in_button; guint idle_id; guint popup_id; @@ -94,6 +94,9 @@ GtkWidget * gimp_preview_new_full (GimpViewable *viewable, gboolean clickable, gboolean show_popup); +void gimp_preview_set_viewable (GimpPreview *preview, + GimpViewable *viewable); + void gimp_preview_set_size (GimpPreview *preview, gint size, gint border_width); @@ -102,13 +105,13 @@ void gimp_preview_set_size_full (GimpPreview *preview, gint height, gint border_width); -void gimp_preview_set_viewable (GimpPreview *preview, - GimpViewable *viewable); +void gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *border_color); void gimp_preview_render (GimpPreview *preview); -/* private */ +/* protected */ void gimp_preview_render_and_flush (GimpPreview *preview, TempBuf *temp_buf, diff --git a/app/widgets/gimpview.c b/app/widgets/gimpview.c index 93bf640eaf..011ba7071e 100644 --- a/app/widgets/gimpview.c +++ b/app/widgets/gimpview.c @@ -25,6 +25,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -236,9 +237,7 @@ gimp_preview_init (GimpPreview *preview) preview->height = 8; preview->border_width = 0; - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; + gimp_rgba_set (&preview->border_color, 0.0, 0.0, 0.0, 1.0); preview->is_popup = FALSE; preview->clickable = FALSE; @@ -409,47 +408,6 @@ gimp_preview_new_full (GimpViewable *viewable, return GTK_WIDGET (preview); } -void -gimp_preview_set_size (GimpPreview *preview, - gint preview_size, - gint border_width) -{ - gint width, height; - - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (preview_size > 0 && preview_size <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - gimp_preview_get_size (preview, preview_size, &width, &height); - - gimp_preview_set_size_full (preview, - width, - height, - border_width); -} - -void -gimp_preview_set_size_full (GimpPreview *preview, - gint width, - gint height, - gint border_width) -{ - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (width > 0 && width <= 256); - g_return_if_fail (height > 0 && height <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - preview->width = width; - preview->height = height; - preview->border_width = border_width; - - gtk_preview_size (GTK_PREVIEW (preview), - width + 2 * preview->border_width, - height + 2 * preview->border_width); -} - void gimp_preview_set_viewable (GimpPreview *preview, GimpViewable *viewable) @@ -512,6 +470,63 @@ gimp_preview_set_viewable (GimpPreview *preview, } } +void +gimp_preview_set_size (GimpPreview *preview, + gint preview_size, + gint border_width) +{ + gint width, height; + + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (preview_size > 0 && preview_size <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + gimp_preview_get_size (preview, preview_size, &width, &height); + + gimp_preview_set_size_full (preview, + width, + height, + border_width); +} + +void +gimp_preview_set_size_full (GimpPreview *preview, + gint width, + gint height, + gint border_width) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (width > 0 && width <= 256); + g_return_if_fail (height > 0 && height <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + preview->width = width; + preview->height = height; + preview->border_width = border_width; + + gtk_preview_size (GTK_PREVIEW (preview), + width + 2 * preview->border_width, + height + 2 * preview->border_width); +} + +void +gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *color) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (color != NULL); + + if (gimp_rgb_distance (&preview->border_color, color)) + { + preview->border_color = *color; + + gimp_preview_render (preview); + } +} + void gimp_preview_render (GimpPreview *preview) { @@ -864,11 +879,17 @@ gimp_preview_render_and_flush (GimpPreview *preview, gint image_bytes; gint offset; gint border; + guchar border_color[3]; width = preview->width; height = preview->height; border = preview->border_width; + gimp_rgb_get_uchar (&preview->border_color, + &border_color[0], + &border_color[1], + &border_color[2]); + alpha = ALPHA_PIX; /* Here are the different cases this functions handles correctly: @@ -923,9 +944,9 @@ gimp_preview_render_and_flush (GimpPreview *preview, /* Set the border color once before rendering */ for (j = 0; j < width + border * 2; j++) { - render_temp_buf[j * 3 + 0] = preview->border_color[0]; - render_temp_buf[j * 3 + 1] = preview->border_color[1]; - render_temp_buf[j * 3 + 2] = preview->border_color[2]; + render_temp_buf[j * 3 + 0] = border_color[0]; + render_temp_buf[j * 3 + 1] = border_color[1]; + render_temp_buf[j * 3 + 2] = border_color[2]; } for (i = 0; i < border; i++) diff --git a/app/widgets/gimpview.h b/app/widgets/gimpview.h index 2409b8346d..6e5a8b00a2 100644 --- a/app/widgets/gimpview.h +++ b/app/widgets/gimpview.h @@ -50,13 +50,13 @@ struct _GimpPreview gint height; gint border_width; - /* TEMP HACK: */ - guchar border_color[3]; + GimpRGB border_color; gboolean is_popup; gboolean clickable; gboolean show_popup; + /*< private >*/ gboolean in_button; guint idle_id; guint popup_id; @@ -94,6 +94,9 @@ GtkWidget * gimp_preview_new_full (GimpViewable *viewable, gboolean clickable, gboolean show_popup); +void gimp_preview_set_viewable (GimpPreview *preview, + GimpViewable *viewable); + void gimp_preview_set_size (GimpPreview *preview, gint size, gint border_width); @@ -102,13 +105,13 @@ void gimp_preview_set_size_full (GimpPreview *preview, gint height, gint border_width); -void gimp_preview_set_viewable (GimpPreview *preview, - GimpViewable *viewable); +void gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *border_color); void gimp_preview_render (GimpPreview *preview); -/* private */ +/* protected */ void gimp_preview_render_and_flush (GimpPreview *preview, TempBuf *temp_buf, diff --git a/app/widgets/gimpviewrenderer.c b/app/widgets/gimpviewrenderer.c index 93bf640eaf..011ba7071e 100644 --- a/app/widgets/gimpviewrenderer.c +++ b/app/widgets/gimpviewrenderer.c @@ -25,6 +25,7 @@ #include +#include "libgimpcolor/gimpcolor.h" #include "libgimpwidgets/gimpwidgets.h" #include "apptypes.h" @@ -236,9 +237,7 @@ gimp_preview_init (GimpPreview *preview) preview->height = 8; preview->border_width = 0; - preview->border_color[0] = 0; - preview->border_color[1] = 0; - preview->border_color[2] = 0; + gimp_rgba_set (&preview->border_color, 0.0, 0.0, 0.0, 1.0); preview->is_popup = FALSE; preview->clickable = FALSE; @@ -409,47 +408,6 @@ gimp_preview_new_full (GimpViewable *viewable, return GTK_WIDGET (preview); } -void -gimp_preview_set_size (GimpPreview *preview, - gint preview_size, - gint border_width) -{ - gint width, height; - - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (preview_size > 0 && preview_size <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - gimp_preview_get_size (preview, preview_size, &width, &height); - - gimp_preview_set_size_full (preview, - width, - height, - border_width); -} - -void -gimp_preview_set_size_full (GimpPreview *preview, - gint width, - gint height, - gint border_width) -{ - g_return_if_fail (preview != NULL); - g_return_if_fail (GIMP_IS_PREVIEW (preview)); - g_return_if_fail (width > 0 && width <= 256); - g_return_if_fail (height > 0 && height <= 256); - g_return_if_fail (border_width >= 0 && border_width <= 16); - - preview->width = width; - preview->height = height; - preview->border_width = border_width; - - gtk_preview_size (GTK_PREVIEW (preview), - width + 2 * preview->border_width, - height + 2 * preview->border_width); -} - void gimp_preview_set_viewable (GimpPreview *preview, GimpViewable *viewable) @@ -512,6 +470,63 @@ gimp_preview_set_viewable (GimpPreview *preview, } } +void +gimp_preview_set_size (GimpPreview *preview, + gint preview_size, + gint border_width) +{ + gint width, height; + + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (preview_size > 0 && preview_size <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + gimp_preview_get_size (preview, preview_size, &width, &height); + + gimp_preview_set_size_full (preview, + width, + height, + border_width); +} + +void +gimp_preview_set_size_full (GimpPreview *preview, + gint width, + gint height, + gint border_width) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (width > 0 && width <= 256); + g_return_if_fail (height > 0 && height <= 256); + g_return_if_fail (border_width >= 0 && border_width <= 16); + + preview->width = width; + preview->height = height; + preview->border_width = border_width; + + gtk_preview_size (GTK_PREVIEW (preview), + width + 2 * preview->border_width, + height + 2 * preview->border_width); +} + +void +gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *color) +{ + g_return_if_fail (preview != NULL); + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (color != NULL); + + if (gimp_rgb_distance (&preview->border_color, color)) + { + preview->border_color = *color; + + gimp_preview_render (preview); + } +} + void gimp_preview_render (GimpPreview *preview) { @@ -864,11 +879,17 @@ gimp_preview_render_and_flush (GimpPreview *preview, gint image_bytes; gint offset; gint border; + guchar border_color[3]; width = preview->width; height = preview->height; border = preview->border_width; + gimp_rgb_get_uchar (&preview->border_color, + &border_color[0], + &border_color[1], + &border_color[2]); + alpha = ALPHA_PIX; /* Here are the different cases this functions handles correctly: @@ -923,9 +944,9 @@ gimp_preview_render_and_flush (GimpPreview *preview, /* Set the border color once before rendering */ for (j = 0; j < width + border * 2; j++) { - render_temp_buf[j * 3 + 0] = preview->border_color[0]; - render_temp_buf[j * 3 + 1] = preview->border_color[1]; - render_temp_buf[j * 3 + 2] = preview->border_color[2]; + render_temp_buf[j * 3 + 0] = border_color[0]; + render_temp_buf[j * 3 + 1] = border_color[1]; + render_temp_buf[j * 3 + 2] = border_color[2]; } for (i = 0; i < border; i++) diff --git a/app/widgets/gimpviewrenderer.h b/app/widgets/gimpviewrenderer.h index 2409b8346d..6e5a8b00a2 100644 --- a/app/widgets/gimpviewrenderer.h +++ b/app/widgets/gimpviewrenderer.h @@ -50,13 +50,13 @@ struct _GimpPreview gint height; gint border_width; - /* TEMP HACK: */ - guchar border_color[3]; + GimpRGB border_color; gboolean is_popup; gboolean clickable; gboolean show_popup; + /*< private >*/ gboolean in_button; guint idle_id; guint popup_id; @@ -94,6 +94,9 @@ GtkWidget * gimp_preview_new_full (GimpViewable *viewable, gboolean clickable, gboolean show_popup); +void gimp_preview_set_viewable (GimpPreview *preview, + GimpViewable *viewable); + void gimp_preview_set_size (GimpPreview *preview, gint size, gint border_width); @@ -102,13 +105,13 @@ void gimp_preview_set_size_full (GimpPreview *preview, gint height, gint border_width); -void gimp_preview_set_viewable (GimpPreview *preview, - GimpViewable *viewable); +void gimp_preview_set_border_color (GimpPreview *preview, + const GimpRGB *border_color); void gimp_preview_render (GimpPreview *preview); -/* private */ +/* protected */ void gimp_preview_render_and_flush (GimpPreview *preview, TempBuf *temp_buf, diff --git a/tools/pdbgen/pdb/layer.pdb b/tools/pdbgen/pdb/layer.pdb index 2a689b5bb7..f6cd19ba71 100644 --- a/tools/pdbgen/pdb/layer.pdb +++ b/tools/pdbgen/pdb/layer.pdb @@ -382,7 +382,7 @@ HELP { tmp_layer = (GimpLayer *) layer_list->data; - if ((tmp_layer == layer) || tmp_layer->linked) + if ((tmp_layer == layer) || gimp_layer_get_linked (tmp_layer)) gimp_layer_translate (tmp_layer, offx, offy); } } @@ -470,7 +470,7 @@ HELP &layer_accessors('visible', 'boolean', 'visibility', 1, 0); -&layer_accessors('preserve_trans', 'boolean', 'preserve transperancy', 0, 1); +&layer_accessors('preserve_trans', 'boolean', 'preserve transperancy', 1, 1); #&layer_accessors('apply_mask', 'boolean', 'apply mask', 0, 1, # [ <<'CODE1', <<'CODE2' ]); @@ -513,15 +513,15 @@ HELP #HELP #CODE2 -&layer_accessors('opacity', '0 <= float <= 100', 'opacity', 0, 0, +&layer_accessors('opacity', '0 <= float <= 100', 'opacity', 1, 0, [ '$outargs[0]->{alias} = - "(layer->opacity * 100.0) / 255.0"', + "gimp_layer_get_opacity (layer) * 100.0"', '$invoke{code} =~ - s%(opacity);$%(int) (($1 * 255) / 100);%' ]); + s%opacity\);%opacity / 100.0\);%' ]); -&layer_accessors('mode', 'enum LayerModeEffects', 'combination mode', 0, 0); +&layer_accessors('mode', 'enum LayerModeEffects', 'combination mode', 1, 0); -&layer_accessors('linked', 'boolean', 'linked state', 0, 0, +&layer_accessors('linked', 'boolean', 'linked state', 1, 0, <<'CODE'); $author = $copyright = 'Wolfgang Hofer'; $date = '1998';