callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app: remove gimp_paint_mode_menu_new() and use GimpLayerModeBox

Browse Source 
I know this looks absolutely horrible, please spare me comments about
that. This commit has the purpose to let everybody experiment with the
new modes, and suggest improvements of the GimpLayerModeBox widget; we
need *some* way of controlling the new layer mode madness.
This commit is contained in:
Michael Natterer
2017-01-30 13:24:35 +01:00
parent 6e522d735f
commit c58d471af7
10 changed files with 70 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/dialogs/fade-dialog.c
View File

@ -151,8 +151,8 @@ fade_dialog_new (GimpImage *image,
gtk_widget_show (table); gtk_widget_show (table);
/* the paint mode menu */ /* the paint mode menu */
menu = gimp_prop_paint_mode_menu_new (G_OBJECT (private->context), menu = gimp_prop_layer_mode_box_new (G_OBJECT (private->context),
"paint-mode", TRUE, TRUE); "paint-mode", TRUE, TRUE);
gimp_table_attach_aligned (GTK_TABLE (table), 0, table_row++, gimp_table_attach_aligned (GTK_TABLE (table), 0, table_row++,
_("_Mode:"), 0.0, 0.5, _("_Mode:"), 0.0, 0.5,
menu, 2, FALSE); menu, 2, FALSE);

16
app/dialogs/layer-options-dialog.c
View File

@ -35,9 +35,9 @@
#include "text/gimptextlayer.h" #include "text/gimptextlayer.h"
#include "widgets/gimpcontainertreeview.h" #include "widgets/gimpcontainertreeview.h"
#include "widgets/gimplayermodebox.h"
#include "widgets/gimpspinscale.h" #include "widgets/gimpspinscale.h"
#include "widgets/gimpviewabledialog.h" #include "widgets/gimpviewabledialog.h"
#include "widgets/gimpwidgets-constructors.h"
#include "item-options-dialog.h" #include "item-options-dialog.h"
#include "layer-options-dialog.h" #include "layer-options-dialog.h"
@ -58,6 +58,7 @@ struct _LayerOptionsDialog
GimpLayerOptionsCallback callback; GimpLayerOptionsCallback callback;
gpointer user_data; gpointer user_data;
GtkWidget *mode_box;
GtkWidget *size_se; GtkWidget *size_se;
GtkWidget *offset_se; GtkWidget *offset_se;
}; };
@ -157,12 +158,10 @@ layer_options_dialog_new (GimpImage *image,
g_object_weak_ref (G_OBJECT (dialog), g_object_weak_ref (G_OBJECT (dialog),
(GWeakNotify) layer_options_dialog_free, private); (GWeakNotify) layer_options_dialog_free, private);
combo = gimp_paint_mode_menu_new (FALSE, FALSE); private->mode_box = gimp_layer_mode_box_new (FALSE, FALSE);
item_options_dialog_add_widget (dialog, _("_Mode:"), combo); item_options_dialog_add_widget (dialog, _("_Mode:"), private->mode_box);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), gimp_layer_mode_box_set_mode (GIMP_LAYER_MODE_BOX (private->mode_box),
private->mode, private->mode);
G_CALLBACK (gimp_int_combo_box_get_active),
&private->mode);
adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (private->opacity, 0.0, 100.0, adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (private->opacity, 0.0, 100.0,
1.0, 10.0, 0.0)); 1.0, 10.0, 0.0));
@ -421,6 +420,9 @@ layer_options_dialog_callback (GtkWidget *dialog,
gint offset_x; gint offset_x;
gint offset_y; gint offset_y;
private->mode =
gimp_layer_mode_box_get_mode (GIMP_LAYER_MODE_BOX (private->mode_box));
if (private->size_se) if (private->size_se)
{ {
width = width =

8
app/tools/gimppaintoptions-gui.c
View File

@ -28,6 +28,7 @@
#include "paint/gimppaintoptions.h" #include "paint/gimppaintoptions.h"
#include "widgets/gimplayermodebox.h"
#include "widgets/gimppropwidgets.h" #include "widgets/gimppropwidgets.h"
#include "widgets/gimpspinscale.h" #include "widgets/gimpspinscale.h"
#include "widgets/gimpviewablebox.h" #include "widgets/gimpviewablebox.h"
@ -113,9 +114,10 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
tool_type = tool_options->tool_info->tool_type; tool_type = tool_options->tool_info->tool_type;
/* the paint mode menu */ /* the paint mode menu */
menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE); menu = gimp_prop_layer_mode_box_new (config, "paint-mode", TRUE, FALSE);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (menu), _("Mode")); gimp_layer_mode_box_set_label (GIMP_LAYER_MODE_BOX (menu), _("Mode"));
g_object_set (menu, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gimp_layer_mode_box_set_ellipsize (GIMP_LAYER_MODE_BOX (menu),
PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu); gtk_widget_show (menu);

43
app/widgets/gimpbrushselect.c
View File

@ -39,8 +39,8 @@
#include "gimpbrushfactoryview.h" #include "gimpbrushfactoryview.h"
#include "gimpbrushselect.h" #include "gimpbrushselect.h"
#include "gimpcontainerbox.h" #include "gimpcontainerbox.h"
#include "gimplayermodebox.h"
#include "gimpspinscale.h" #include "gimpspinscale.h"
#include "gimpwidgets-constructors.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -74,8 +74,6 @@ static void gimp_brush_select_mode_changed (GimpContext *context
static void gimp_brush_select_opacity_update (GtkAdjustment *adj, static void gimp_brush_select_opacity_update (GtkAdjustment *adj,
GimpBrushSelect *select); GimpBrushSelect *select);
static void gimp_brush_select_mode_update (GtkWidget *widget,
GimpBrushSelect *select);
static void gimp_brush_select_spacing_update (GtkAdjustment *adj, static void gimp_brush_select_spacing_update (GtkAdjustment *adj,
GimpBrushSelect *select); GimpBrushSelect *select);
@ -191,14 +189,14 @@ gimp_brush_select_constructed (GObject *object)
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label); gtk_widget_show (label);
select->paint_mode_menu = gimp_paint_mode_menu_new (TRUE, FALSE); select->layer_mode_box = gimp_layer_mode_box_new (TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), select->paint_mode_menu, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), select->layer_mode_box, TRUE, TRUE, 0);
gtk_widget_show (select->paint_mode_menu); gtk_widget_show (select->layer_mode_box);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (select->paint_mode_menu), g_object_bind_property (G_OBJECT (dialog->context), "paint-mode",
gimp_context_get_paint_mode (dialog->context), G_OBJECT (select->layer_mode_box), "layer-mode",
G_CALLBACK (gimp_brush_select_mode_update), G_BINDING_BIDIRECTIONAL |
select); G_BINDING_SYNC_CREATE);
spacing_adj = GIMP_BRUSH_FACTORY_VIEW (dialog->view)->spacing_adjustment; spacing_adj = GIMP_BRUSH_FACTORY_VIEW (dialog->view)->spacing_adjustment;
@ -311,17 +309,6 @@ gimp_brush_select_mode_changed (GimpContext *context,
GimpLayerMode paint_mode, GimpLayerMode paint_mode,
GimpBrushSelect *select) GimpBrushSelect *select)
{ {
g_signal_handlers_block_by_func (select->paint_mode_menu,
gimp_brush_select_mode_update,
select);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (select->paint_mode_menu),
paint_mode);
g_signal_handlers_unblock_by_func (select->paint_mode_menu,
gimp_brush_select_mode_update,
select);
gimp_pdb_dialog_run_callback (GIMP_PDB_DIALOG (select), FALSE); gimp_pdb_dialog_run_callback (GIMP_PDB_DIALOG (select), FALSE);
} }
@ -333,20 +320,6 @@ gimp_brush_select_opacity_update (GtkAdjustment *adjustment,
gtk_adjustment_get_value (adjustment) / 100.0); gtk_adjustment_get_value (adjustment) / 100.0);
} }
static void
gimp_brush_select_mode_update (GtkWidget *widget,
GimpBrushSelect *select)
{
gint paint_mode;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget),
&paint_mode))
{
gimp_context_set_paint_mode (GIMP_PDB_DIALOG (select)->context,
(GimpLayerMode) paint_mode);
}
}
static void static void
gimp_brush_select_spacing_update (GtkAdjustment *adjustment, gimp_brush_select_spacing_update (GtkAdjustment *adjustment,
GimpBrushSelect *select) GimpBrushSelect *select)

2
app/widgets/gimpbrushselect.h
View File

@ -45,7 +45,7 @@ struct _GimpBrushSelect
gint spacing; gint spacing;
GtkAdjustment *opacity_data; GtkAdjustment *opacity_data;
GtkWidget *paint_mode_menu; GtkWidget *layer_mode_box;
}; };
struct _GimpBrushSelectClass struct _GimpBrushSelectClass

50
app/widgets/gimplayertreeview.c
View File

@ -51,11 +51,11 @@
#include "gimpcontainerview.h" #include "gimpcontainerview.h"
#include "gimpdnd.h" #include "gimpdnd.h"
#include "gimphelp-ids.h" #include "gimphelp-ids.h"
#include "gimplayermodebox.h"
#include "gimplayertreeview.h" #include "gimplayertreeview.h"
#include "gimpspinscale.h" #include "gimpspinscale.h"
#include "gimpuimanager.h" #include "gimpuimanager.h"
#include "gimpviewrenderer.h" #include "gimpviewrenderer.h"
#include "gimpwidgets-constructors.h"
#include "gimpwidgets-utils.h" #include "gimpwidgets-utils.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -63,7 +63,7 @@
struct _GimpLayerTreeViewPriv struct _GimpLayerTreeViewPriv
{ {
GtkWidget *paint_mode_menu; GtkWidget *layer_mode_box;
GtkAdjustment *opacity_adjustment; GtkAdjustment *opacity_adjustment;
GtkWidget *lock_alpha_toggle; GtkWidget *lock_alpha_toggle;
@ -130,7 +130,8 @@ static void gimp_layer_tree_view_set_image (GimpItemTreeV
static GimpItem * gimp_layer_tree_view_item_new (GimpImage *image); static GimpItem * gimp_layer_tree_view_item_new (GimpImage *image);
static void gimp_layer_tree_view_floating_selection_changed (GimpImage *image, static void gimp_layer_tree_view_floating_selection_changed (GimpImage *image,
GimpLayerTreeView *view); GimpLayerTreeView *view);
static void gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, static void gimp_layer_tree_view_layer_mode_box_callback (GtkWidget *widget,
const GParamSpec *pspec,
GimpLayerTreeView *view); GimpLayerTreeView *view);
static void gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adj, static void gimp_layer_tree_view_opacity_scale_changed (GtkAdjustment *adj,
GimpLayerTreeView *view); GimpLayerTreeView *view);
@ -264,18 +265,17 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
/* Paint mode menu */ /* Paint mode menu */
view->priv->paint_mode_menu = gimp_paint_mode_menu_new (FALSE, FALSE); view->priv->layer_mode_box = gimp_layer_mode_box_new (FALSE, FALSE);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (view->priv->paint_mode_menu), gimp_layer_mode_box_set_label (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
_("Mode")); _("Mode"));
gimp_item_tree_view_add_options (GIMP_ITEM_TREE_VIEW (view), gimp_item_tree_view_add_options (GIMP_ITEM_TREE_VIEW (view), NULL,
NULL, view->priv->paint_mode_menu); view->priv->layer_mode_box);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (view->priv->paint_mode_menu), g_signal_connect (view->priv->layer_mode_box, "notify::layer-mode",
GIMP_LAYER_MODE_NORMAL, G_CALLBACK (gimp_layer_tree_view_layer_mode_box_callback),
G_CALLBACK (gimp_layer_tree_view_paint_mode_menu_callback), view);
view);
gimp_help_set_help_data (view->priv->paint_mode_menu, NULL, gimp_help_set_help_data (view->priv->layer_mode_box, NULL,
GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU); GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU);
/* Opacity scale */ /* Opacity scale */
@ -923,8 +923,9 @@ gimp_layer_tree_view_floating_selection_changed (GimpImage *image,
static void static void
gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget, gimp_layer_tree_view_layer_mode_box_callback (GtkWidget *widget,
GimpLayerTreeView *view) const GParamSpec *pspec,
GimpLayerTreeView *view)
{ {
GimpImage *image; GimpImage *image;
GimpLayer *layer = NULL; GimpLayer *layer = NULL;
@ -937,11 +938,10 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget,
if (layer) if (layer)
{ {
gint mode; GimpLayerMode mode =
gimp_layer_mode_box_get_mode (GIMP_LAYER_MODE_BOX (widget));
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), if (gimp_layer_get_mode (layer) != mode)
&mode) &&
gimp_layer_get_mode (layer) != (GimpLayerMode) mode)
{ {
GimpUndo *undo; GimpUndo *undo;
gboolean push_undo = TRUE; gboolean push_undo = TRUE;
@ -1073,14 +1073,14 @@ static void
gimp_layer_tree_view_update_options (GimpLayerTreeView *view, gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
GimpLayer *layer) GimpLayer *layer)
{ {
BLOCK (view->priv->paint_mode_menu, BLOCK (view->priv->layer_mode_box,
gimp_layer_tree_view_paint_mode_menu_callback); gimp_layer_tree_view_layer_mode_box_callback);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (view->priv->paint_mode_menu), gimp_layer_mode_box_set_mode (GIMP_LAYER_MODE_BOX (view->priv->layer_mode_box),
gimp_layer_get_mode (layer)); gimp_layer_get_mode (layer));
UNBLOCK (view->priv->paint_mode_menu, UNBLOCK (view->priv->layer_mode_box,
gimp_layer_tree_view_paint_mode_menu_callback); gimp_layer_tree_view_layer_mode_box_callback);
if (gimp_layer_get_lock_alpha (layer) != if (gimp_layer_get_lock_alpha (layer) !=
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view->priv->lock_alpha_toggle))) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view->priv->lock_alpha_toggle)))

97
app/widgets/gimppropwidgets.c
View File

@ -45,12 +45,12 @@
#include "gimpiconpicker.h" #include "gimpiconpicker.h"
#include "gimplanguagecombobox.h" #include "gimplanguagecombobox.h"
#include "gimplanguageentry.h" #include "gimplanguageentry.h"
#include "gimplayermodebox.h"
#include "gimpscalebutton.h" #include "gimpscalebutton.h"
#include "gimpspinscale.h" #include "gimpspinscale.h"
#include "gimpview.h" #include "gimpview.h"
#include "gimppolar.h" #include "gimppolar.h"
#include "gimppropwidgets.h" #include "gimppropwidgets.h"
#include "gimpwidgets-constructors.h"
#include "gimpwidgets-utils.h" #include "gimpwidgets-utils.h"
#include "gimp-intl.h" #include "gimp-intl.h"
@ -142,106 +142,47 @@ gimp_prop_expanding_frame_new (GObject *config,
} }
/*********************/ /********************/
/* paint mode menu */ /* layer mode box */
/*********************/ /********************/
static void gimp_prop_paint_menu_callback (GtkWidget *widget,
GObject *config);
static void gimp_prop_paint_menu_notify (GObject *config,
GParamSpec *param_spec,
GtkWidget *menu);
/** /**
* gimp_prop_paint_mode_menu_new: * gimp_prop_layer_mode_box_new:
* @config: #GimpConfig object to which property is attached. * @config: #GimpConfig object to which property is attached.
* @property_name: Name of Enum property. * @property_name: Name of Enum property.
* @with_behind_mode: Whether to include "Behind" mode in the menu. * @with_behind_mode: Whether to include "Behind" mode in the menu.
* @with_replace_modes: Whether to include the "Replace", "Erase" and * @with_replace_modes: Whether to include the "Replace", "Erase" and
* "Anti Erase" modes in the menu. * "Anti Erase" modes in the menu.
* *
* Creates a #GimpPaintModeMenu widget to display and set the specified * Creates a #GimpLayerModeBox widget to display and set the specified
* Enum property, for which the enum must be #GimpLayerModeEffects. * Enum property, for which the enum must be #GimpLayerMode.
* *
* Return value: The newly created #GimpPaintModeMenu widget. * Return value: The newly created #GimpLayerModeBox widget.
* *
* Since GIMP 2.4 * Since GIMP 2.4
*/ */
GtkWidget * GtkWidget *
gimp_prop_paint_mode_menu_new (GObject *config, gimp_prop_layer_mode_box_new (GObject *config,
const gchar *property_name, const gchar *property_name,
gboolean with_behind_mode, gboolean with_behind_mode,
gboolean with_replace_modes) gboolean with_replace_modes)
{ {
GParamSpec *param_spec; GParamSpec *param_spec;
GtkWidget *menu; GtkWidget *box;
gint value;
param_spec = check_param_spec_w (config, property_name, param_spec = check_param_spec_w (config, property_name,
G_TYPE_PARAM_ENUM, G_STRFUNC); G_TYPE_PARAM_ENUM, G_STRFUNC);
if (! param_spec) if (! param_spec)
return NULL; return NULL;
g_object_get (config, box = gimp_layer_mode_box_new (with_behind_mode, with_replace_modes);
property_name, &value,
NULL);
menu = gimp_paint_mode_menu_new (with_behind_mode, with_replace_modes); g_object_bind_property (config, property_name,
G_OBJECT (box), "layer-mode",
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (menu), G_BINDING_BIDIRECTIONAL |
value, G_BINDING_SYNC_CREATE);
G_CALLBACK (gimp_prop_paint_menu_callback),
config);
set_param_spec (G_OBJECT (menu), menu, param_spec);
connect_notify (config, property_name,
G_CALLBACK (gimp_prop_paint_menu_notify),
menu);
return menu;
}
static void
gimp_prop_paint_menu_callback (GtkWidget *widget,
GObject *config)
{
GParamSpec *param_spec;
gint value;
param_spec = get_param_spec (G_OBJECT (widget));
if (! param_spec)
return;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
{
g_object_set (config,
param_spec->name, value,
NULL);
}
}
static void
gimp_prop_paint_menu_notify (GObject *config,
GParamSpec *param_spec,
GtkWidget *menu)
{
gint value;
g_object_get (config,
param_spec->name, &value,
NULL);
g_signal_handlers_block_by_func (menu,
gimp_prop_paint_menu_callback,
config);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (menu), value);
g_signal_handlers_unblock_by_func (menu,
gimp_prop_paint_menu_callback,
config);
return box;
} }

2
app/widgets/gimppropwidgets.h
View File

@ -33,7 +33,7 @@ GtkWidget * gimp_prop_expanding_frame_new (GObject *config,
/* GParamEnum */ /* GParamEnum */
GtkWidget * gimp_prop_paint_mode_menu_new (GObject *config, GtkWidget * gimp_prop_layer_mode_box_new (GObject *config,
const gchar *property_name, const gchar *property_name,
gboolean with_behind_mode, gboolean with_behind_mode,
gboolean with_replace_modes); gboolean with_replace_modes);

195
app/widgets/gimpwidgets-constructors.c
View File

@ -31,188 +31,8 @@
#include "gimp-intl.h" #include "gimp-intl.h"
/* local function prototypes */
static gboolean gimp_paint_mode_menu_separator_func (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data);
/* public functions */ /* public functions */
static void
gimp_enum_store_insert_value_after (GimpEnumStore *store,
gint after,
gint insert_value)
{
GtkTreeIter iter;
g_return_if_fail (GIMP_IS_ENUM_STORE (store));
if (gimp_int_store_lookup_by_value (GTK_TREE_MODEL (store),
after, &iter))
{
GEnumValue *enum_value;
enum_value = g_enum_get_value (store->enum_class, insert_value);
if (enum_value)
{
GtkTreeIter value_iter;
const gchar *desc;
gtk_list_store_insert_after (GTK_LIST_STORE (store),
&value_iter, &iter);
desc = gimp_enum_value_get_desc (store->enum_class, enum_value);
gtk_list_store_set (GTK_LIST_STORE (store), &value_iter,
GIMP_INT_STORE_VALUE, enum_value->value,
GIMP_INT_STORE_LABEL, desc,
-1);
}
}
}
static void
gimp_int_store_insert_separator_after (GimpIntStore *store,
gint after,
gint separator_value)
{
GtkTreeIter iter;
g_return_if_fail (GIMP_IS_INT_STORE (store));
if (gimp_int_store_lookup_by_value (GTK_TREE_MODEL (store),
after, &iter))
{
GtkTreeIter sep_iter;
gtk_list_store_insert_after (GTK_LIST_STORE (store),
&sep_iter, &iter);
gtk_list_store_set (GTK_LIST_STORE (store), &sep_iter,
GIMP_INT_STORE_VALUE, separator_value,
-1);
}
}
GtkWidget *
gimp_paint_mode_menu_new (gboolean with_behind_mode,
gboolean with_replace_modes)
{
GtkListStore *store;
GtkWidget *combo;
store = gimp_enum_store_new_with_values (GIMP_TYPE_LAYER_MODE,
47,
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_NORMAL_LINEAR,
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_LIGHTEN_ONLY,
GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY,
GIMP_LAYER_MODE_LUMINANCE_LIGHTEN_ONLY,
GIMP_LAYER_MODE_SCREEN,
GIMP_LAYER_MODE_SCREEN_LEGACY,
GIMP_LAYER_MODE_DODGE,
GIMP_LAYER_MODE_DODGE_LEGACY,
GIMP_LAYER_MODE_ADDITION,
GIMP_LAYER_MODE_ADDITION_LEGACY,
GIMP_LAYER_MODE_DARKEN_ONLY,
GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY,
GIMP_LAYER_MODE_LUMINANCE_DARKEN_ONLY,
GIMP_LAYER_MODE_MULTIPLY,
GIMP_LAYER_MODE_MULTIPLY_LINEAR,
GIMP_LAYER_MODE_MULTIPLY_LEGACY,
GIMP_LAYER_MODE_BURN,
GIMP_LAYER_MODE_BURN_LEGACY,
GIMP_LAYER_MODE_LINEAR_BURN,
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_SOFTLIGHT,
GIMP_LAYER_MODE_SOFTLIGHT_LEGACY,
GIMP_LAYER_MODE_HARDLIGHT,
GIMP_LAYER_MODE_HARDLIGHT_LEGACY,
GIMP_LAYER_MODE_VIVID_LIGHT,
GIMP_LAYER_MODE_PIN_LIGHT,
GIMP_LAYER_MODE_LINEAR_LIGHT,
GIMP_LAYER_MODE_DIFFERENCE,
GIMP_LAYER_MODE_DIFFERENCE_LEGACY,
GIMP_LAYER_MODE_SUBTRACT,
GIMP_LAYER_MODE_SUBTRACT_LEGACY,
GIMP_LAYER_MODE_EXCLUSION,
GIMP_LAYER_MODE_GRAIN_EXTRACT,
GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY,
GIMP_LAYER_MODE_GRAIN_MERGE,
GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY,
GIMP_LAYER_MODE_DIVIDE,
GIMP_LAYER_MODE_DIVIDE_LEGACY,
GIMP_LAYER_MODE_HSV_HUE,
GIMP_LAYER_MODE_HSV_SATURATION,
GIMP_LAYER_MODE_HSV_COLOR,
GIMP_LAYER_MODE_HSV_VALUE,
GIMP_LAYER_MODE_HSV_HUE_LEGACY,
GIMP_LAYER_MODE_HSV_SATURATION_LEGACY,
GIMP_LAYER_MODE_HSV_COLOR_LEGACY,
GIMP_LAYER_MODE_HSV_VALUE_LEGACY,
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_DISSOLVE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_ADDITION_LEGACY, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_LINEAR_BURN, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_LINEAR_LIGHT, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_DIVIDE_LEGACY, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_LAYER_MODE_HSV_VALUE_LEGACY, -1);
if (with_behind_mode)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_BEHIND);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_BEHIND,
GIMP_LAYER_MODE_BEHIND_LINEAR);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_BEHIND_LINEAR,
GIMP_LAYER_MODE_COLOR_ERASE);
}
if (with_replace_modes)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_NORMAL_LINEAR,
GIMP_LAYER_MODE_REPLACE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_COLOR_ERASE,
GIMP_LAYER_MODE_ERASE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_LAYER_MODE_ERASE,
GIMP_LAYER_MODE_ANTI_ERASE);
}
combo = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store));
g_object_unref (store);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
gimp_paint_mode_menu_separator_func,
GINT_TO_POINTER (-1),
NULL);
return combo;
}
GtkWidget * GtkWidget *
gimp_icon_button_new (const gchar *icon_name, gimp_icon_button_new (const gchar *icon_name,
const gchar *label) const gchar *label)
@ -281,18 +101,3 @@ gimp_color_profile_label_new (GimpColorProfile *profile)
return expander; return expander;
} }
/* private functions */
static gboolean
gimp_paint_mode_menu_separator_func (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
gint value;
gtk_tree_model_get (model, iter, GIMP_INT_STORE_VALUE, &value, -1);
return value == GPOINTER_TO_INT (data);
}

3
app/widgets/gimpwidgets-constructors.h
View File

@ -19,9 +19,6 @@
#define __GIMP_WIDGETS_CONSTRUCTORS_H__ #define __GIMP_WIDGETS_CONSTRUCTORS_H__
GtkWidget * gimp_paint_mode_menu_new (gboolean with_behind_mode,
gboolean with_replace_modes);
GtkWidget * gimp_icon_button_new (const gchar *icon_name, GtkWidget * gimp_icon_button_new (const gchar *icon_name,
const gchar *label); const gchar *label);