dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app/Makefile.am app/apptypes.h new subclass of GimpDrawableListView (the 

2001-03-11  Michael Natterer  <mitch@gimp.org>

	* 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__
This commit is contained in:
Michael Natterer 2001-03-11 17:24:47 +00:00 committed by Michael Natterer
parent f7cfaa825a
commit b51d761fcc
86 changed files with 3343 additions and 721 deletions

67
ChangeLog
View File

@ -1,3 +1,70 @@
2001-03-11 Michael Natterer <mitch@gimp.org>
* 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 <egger@suse.de>
* plug-ins/common/sobel.c: Applied patch from

2
app/Makefile.am
View File

@ -317,6 +317,8 @@ gimp_SOURCES = \
gimpimagepreview.c \
gimplayerlistitem.h \
gimplayerlistitem.c \
gimplayerlistview.h \
gimplayerlistview.c \
gimplistitem.h \
gimplistitem.c \
gimppalettepreview.h \

4
app/actions/help-commands.c
View File

@ -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;

1
app/apptypes.h
View File

@ -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;

2
app/brush_select.c
View File

@ -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,

4
app/commands.c
View File

@ -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;

4
app/core/gimpimage-guides.c
View File

@ -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);

4
app/core/gimpimage-merge.c
View File

@ -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);

4
app/core/gimpimage-projection.c
View File

@ -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);

4
app/core/gimpimage-resize.c
View File

@ -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);

4
app/core/gimpimage-scale.c
View File

@ -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);

8
app/core/gimpimage-undo-push.c
View File

@ -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,

4
app/core/gimpimage.c
View File

@ -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);

12
app/core/gimplayer-floating-sel.c
View File

@ -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++)

124
app/core/gimplayer.c
View File

@ -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;
}

33
app/core/gimplayer.h
View File

@ -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__ */

4
app/core/gimpprojection-construct.c
View File

@ -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);

4
app/core/gimpprojection.c
View File

@ -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

5
app/core/gimptoolinfo.c
View File

@ -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",

16
app/disp_callbacks.c
View File

@ -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)

16
app/display/gimpdisplay-callbacks.c
View File

@ -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)

4
app/display/gimpdisplay.c
View File

@ -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

16
app/display/gimpdisplayshell-callbacks.c
View File

@ -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)

12
app/floating_sel.c
View File

@ -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++)

4
app/gdisplay.c
View File

@ -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

26
app/gimpcontainergridview.c
View File

@ -22,6 +22,8 @@
#include <gtk/gtk.h>
#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);

9
app/gimpcontainerlistview.c
View File

@ -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,

23
app/gimpcontainerview.c
View File

@ -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);

2
app/gimpcontainerview.h
View File

@ -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);

28
app/gimpdrawablelistitem.c
View File

@ -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 ();
}
}

76
app/gimpdrawablelistview.c
View File

@ -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)

4
app/gimpimage.c
View File

@ -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);

124
app/gimplayer.c
View File

@ -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;
}

33
app/gimplayer.h
View File

@ -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__ */

87
app/gimplayerlistitem.c
View File

@ -23,6 +23,7 @@
#include <gtk/gtk.h>
#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);
}

511
app/gimplayerlistview.c Normal file
View File

@ -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 <gtk/gtk.h>
#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);
}
}

62
app/gimplayerlistview.h Normal file
View File

@ -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__ */

20
app/gimplistitem.c
View File

@ -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

115
app/gimppreview.c
View File

@ -25,6 +25,7 @@
#include <gtk/gtk.h>
#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++)

13
app/gimppreview.h
View File

@ -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,

2
app/gui/brush-select.c
View File

@ -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,

4
app/gui/commands.c
View File

@ -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;

4
app/gui/help-commands.c
View File

@ -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;

61
app/gui/layers-dialog.c
View File

@ -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,

4
app/gui/menus.c
View File

@ -1791,7 +1791,9 @@ menus_init (void)
menus_tools_create (GIMP_TOOL_INFO (list->data));
}
/* reorder <Image>/Image/Colors */
/*#warning FIXME (reorder <Image>/Image/Colors) */
#ifdef __GNUC__
#warning FIXME (reorder <Image>/Image/Colors)
#endif
#if 0
menu_item = gtk_item_factory_get_widget (image_factory,
tool_info[POSTERIZE].menu_path);

61
app/layers_dialog.c
View File

@ -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,

4
app/menus.c
View File

@ -1791,7 +1791,9 @@ menus_init (void)
menus_tools_create (GIMP_TOOL_INFO (list->data));
}
/* reorder <Image>/Image/Colors */
/*#warning FIXME (reorder <Image>/Image/Colors) */
#ifdef __GNUC__
#warning FIXME (reorder <Image>/Image/Colors)
#endif
#if 0
menu_item = gtk_item_factory_get_widget (image_factory,
tool_info[POSTERIZE].menu_path);

4
app/menus/menus.c
View File

@ -1791,7 +1791,9 @@ menus_init (void)
menus_tools_create (GIMP_TOOL_INFO (list->data));
}
/* reorder <Image>/Image/Colors */
/*#warning FIXME (reorder <Image>/Image/Colors) */
#ifdef __GNUC__
#warning FIXME (reorder <Image>/Image/Colors)
#endif
#if 0
menu_item = gtk_item_factory_get_widget (image_factory,
tool_info[POSTERIZE].menu_path);

8
app/paint/gimppaintcore.c
View File

@ -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)

20
app/pdb/layer_cmds.c
View File

@ -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);
}

8
app/tools/gimpbrushtool.c
View File

@ -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)

6
app/tools/gimpeditselectiontool.c
View File

@ -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);
}

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

@ -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);

1
app/tools/gimppaintoptions-gui.h
View File

@ -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);

8
app/tools/gimppainttool.c
View File

@ -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)

16
app/tools/gimptool.c
View File

@ -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[] =
{

5
app/tools/gimptoolinfo.c
View File

@ -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",

80
app/tools/paint_options.c
View File

@ -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);

1
app/tools/paint_options.h
View File

@ -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);

9
app/tools/tool_manager.c
View File

@ -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,

8
app/undo.c
View File

@ -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,

26
app/widgets/gimpcontainergridview.c
View File

@ -22,6 +22,8 @@
#include <gtk/gtk.h>
#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);

9
app/widgets/gimpcontainerlistview.c
View File

@ -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,

23
app/widgets/gimpcontainerview.c
View File

@ -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);

2
app/widgets/gimpcontainerview.h
View File

@ -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);

28
app/widgets/gimpdrawablelistitem.c
View File

@ -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 ();
}
}

76
app/widgets/gimpdrawablelistview.c
View File

@ -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)

76
app/widgets/gimpdrawabletreeview.c
View File

@ -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)

4
app/widgets/gimpitemfactory.c
View File

@ -1791,7 +1791,9 @@ menus_init (void)
menus_tools_create (GIMP_TOOL_INFO (list->data));
}
/* reorder <Image>/Image/Colors */
/*#warning FIXME (reorder <Image>/Image/Colors) */
#ifdef __GNUC__
#warning FIXME (reorder <Image>/Image/Colors)
#endif
#if 0
menu_item = gtk_item_factory_get_widget (image_factory,
tool_info[POSTERIZE].menu_path);

76
app/widgets/gimpitemlistview.c
View File

@ -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)

76
app/widgets/gimpitemtreeview.c
View File

@ -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)

87
app/widgets/gimplayerlistitem.c
View File

@ -23,6 +23,7 @@
#include <gtk/gtk.h>
#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);
}

511
app/widgets/gimplayerlistview.c Normal file
View File

@ -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 <gtk/gtk.h>
#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);
}
}

62
app/widgets/gimplayerlistview.h Normal file
View File

@ -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__ */

511
app/widgets/gimplayertreeview.c Normal file
View File

@ -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 <gtk/gtk.h>
#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);
}
}

62
app/widgets/gimplayertreeview.h Normal file
View File

@ -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__ */

20
app/widgets/gimplistitem.c
View File

@ -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

115
app/widgets/gimppreview.c
View File

@ -25,6 +25,7 @@
#include <gtk/gtk.h>
#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++)

13
app/widgets/gimppreview.h
View File

@ -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,

115
app/widgets/gimppreviewrenderer.c
View File

@ -25,6 +25,7 @@
#include <gtk/gtk.h>
#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++)

13
app/widgets/gimppreviewrenderer.h
View File

@ -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,

115
app/widgets/gimpview.c
View File

@ -25,6 +25,7 @@
#include <gtk/gtk.h>
#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++)

13
app/widgets/gimpview.h
View File

@ -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,

115
app/widgets/gimpviewrenderer.c
View File

@ -25,6 +25,7 @@
#include <gtk/gtk.h>
#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++)

13
app/widgets/gimpviewrenderer.h
View File

@ -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,

14
tools/pdbgen/pdb/layer.pdb
View File

@ -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';