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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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