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

app/gimage_cmds.c pdbgenned files 

* app/gimage_cmds.c
* app/guides_cmds.c: pdbgenned files

* app/parasite_cmds.c: added image parasite cmds

* app/gimpimage.h: capitalized ChannelType and MergeType enums,
made HORIZONTAL_GUIDE and VERTICAL_GUIDE an enum

* app/layer.h: made APPLY and DISCARD an enum

* app/internal_procs.[ch]: finally pdbgenned

* app/channels_dialog.c
* app/fileops.c
* app/gimpimage.c
* app/layers_dialog.c: ChannelType, MergeType enum changes

* app/commands.c: remove gimage_cmds.h #include

* app/cursorutil.h: #include <gdk/gdktypes.h>

* app/paint_funcs.h: cosmetic change for PDB help

* app/brush_select_cmds.c
* app/brushes_cmds.c
* app/layer_cmds.c
* app/tools_cmds.c: pdbgen updates

* app/Makefile.am: removed gimage_cmds.h, added guides_cmds.c

* plug-ins/Lighting/lighting_main.c
* plug-ins/MapObject/mapobject_main.c
* plug-ins/rcm/rcm.c
* plug-ins/xbm/xbm.c: removed trailing ";" from MAIN ()

-Yosh
This commit is contained in:
Manish Singh 1999-04-27 04:57:59 +00:00
parent 26e21fc723
commit 80de6ea79c
49 changed files with 3829 additions and 4818 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
ChangeLog
View File

@ -1,3 +1,40 @@
Mon Apr 26 21:34:08 PDT 1999 Manish Singh <yosh@gimp.org>
* app/gimage_cmds.c
* app/guides_cmds.c: pdbgenned files
* app/parasite_cmds.c: added image parasite cmds
* app/gimpimage.h: capitalized ChannelType and MergeType enums,
made HORIZONTAL_GUIDE and VERTICAL_GUIDE an enum
* app/layer.h: made APPLY and DISCARD an enum
* app/internal_procs.[ch]: finally pdbgenned
* app/channels_dialog.c
* app/fileops.c
* app/gimpimage.c
* app/layers_dialog.c: ChannelType, MergeType enum changes
* app/commands.c: remove gimage_cmds.h #include
* app/cursorutil.h: #include <gdk/gdktypes.h>
* app/paint_funcs.h: cosmetic change for PDB help
* app/brush_select_cmds.c
* app/brushes_cmds.c
* app/layer_cmds.c
* app/tools_cmds.c: pdbgen updates
* app/Makefile.am: removed gimage_cmds.h, added guides_cmds.c
* plug-ins/Lighting/lighting_main.c
* plug-ins/MapObject/mapobject_main.c
* plug-ins/rcm/rcm.c
* plug-ins/xbm/xbm.c: removed trailing ";" from MAIN ()
Tue Apr 27 04:16:55 MEST 1999 Sven Neumann <sven@gimp.org>
* app/tools_cmds.c: small fix (and updated the pdb file)

2
app/Makefile.am
View File

@ -169,7 +169,6 @@ gimp_SOURCES = \
gimage.c \
gimage.h \
gimage_cmds.c \
gimage_cmds.h \
gimage_mask.c \
gimage_mask.h \
gimage_mask_cmds.c \
@ -209,6 +208,7 @@ gimp_SOURCES = \
gradient_select_cmds.c \
gradient.h \
gradient_cmds.c \
guides_cmds.c \
gximage.c \
gximage.h \
histogramwidget.c \

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

@ -42,7 +42,6 @@
#include "floating_sel.h"
#include "gdisplay_ops.h"
#include "general.h"
#include "gimage_cmds.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "global_edit.h"

4
app/brush_select_cmds.c
View File

@ -140,7 +140,7 @@ static ProcArg brushes_popup_inargs[] =
{
PDB_INT32,
"paint_mode",
"The initial paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The initial paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
}
};
@ -313,7 +313,7 @@ static ProcArg brushes_set_popup_inargs[] =
{
PDB_INT32,
"paint_mode",
"The initial paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The initial paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
}
};

6
app/brushes_cmds.c
View File

@ -367,7 +367,7 @@ static ProcArg brushes_get_paint_mode_outargs[] =
{
PDB_INT32,
"paint_mode",
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
}
};
@ -408,7 +408,7 @@ static ProcArg brushes_set_paint_mode_inargs[] =
{
PDB_INT32,
"paint_mode",
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
}
};
@ -580,7 +580,7 @@ static ProcArg brushes_get_brush_data_outargs[] =
{
PDB_INT32,
"paint_mode",
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The paint mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
},
{
PDB_INT32,

127
app/channels_dialog.c
View File

@ -325,7 +325,7 @@ channels_dialog_flush ()
cw = (ChannelWidget *) list->data;
list = g_slist_next (list);
if (cw->visited == FALSE && cw->type == Auxillary)
if (cw->visited == FALSE && cw->type == AUXILLARY_CHANNEL)
/* will only be true for auxillary channels */
channels_dialog_remove_channel (cw);
}
@ -338,7 +338,7 @@ channels_dialog_flush ()
cw = (ChannelWidget *) list->data;
list = g_slist_next (list);
if (cw->type == Auxillary)
if (cw->type == AUXILLARY_CHANNEL)
if ((gimage_pos = gimage_get_channel_index (gimage, cw->channel)) != pos)
channels_dialog_position_channel (cw, gimage_pos);
@ -404,38 +404,38 @@ channels_dialog_update (GimpImage* gimage)
switch ((channelsD->base_type = gimage_base_type (gimage)))
{
case RGB:
cw = create_channel_widget (gimage, NULL, Red);
cw = create_channel_widget (gimage, NULL, RED_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Red;
channelsD->components[0] = RED_CHANNEL;
cw = create_channel_widget (gimage, NULL, Green);
cw = create_channel_widget (gimage, NULL, GREEN_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[1] = Green;
channelsD->components[1] = GREEN_CHANNEL;
cw = create_channel_widget (gimage, NULL, Blue);
cw = create_channel_widget (gimage, NULL, BLUE_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[2] = Blue;
channelsD->components[2] = BLUE_CHANNEL;
channelsD->num_components = 3;
break;
case GRAY:
cw = create_channel_widget (gimage, NULL, Gray);
cw = create_channel_widget (gimage, NULL, GRAY_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Gray;
channelsD->components[0] = GRAY_CHANNEL;
channelsD->num_components = 1;
break;
case INDEXED:
cw = create_channel_widget (gimage, NULL, Indexed);
cw = create_channel_widget (gimage, NULL, INDEXED_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Indexed;
channelsD->components[0] = INDEXED_CHANNEL;
channelsD->num_components = 1;
break;
@ -447,7 +447,7 @@ channels_dialog_update (GimpImage* gimage)
{
/* create a channel list item */
channel = (Channel *) list->data;
cw = create_channel_widget (gimage, channel, Auxillary);
cw = create_channel_widget (gimage, channel, AUXILLARY_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
@ -549,7 +549,7 @@ channels_dialog_set_menu_sensitivity ()
fs_sensitive = (channelsD->floating_sel != NULL);
if (cw)
aux_sensitive = (cw->type == Auxillary);
aux_sensitive = (cw->type == AUXILLARY_CHANNEL);
else
aux_sensitive = FALSE;
@ -593,7 +593,7 @@ channels_dialog_set_channel (ChannelWidget *channel_widget)
/* get the list item data */
state = channel_widget->list_item->state;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* turn on the specified auxillary channel */
index = gimage_get_channel_index (channel_widget->gimage, channel_widget->channel);
@ -611,16 +611,16 @@ channels_dialog_set_channel (ChannelWidget *channel_widget)
gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item), NULL);
switch (channel_widget->type)
{
case Red: case Gray: case Indexed:
case RED_CHANNEL: case GRAY_CHANNEL: case INDEXED_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 0);
break;
case Green:
case GREEN_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 1);
break;
case Blue:
case BLUE_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 2);
break;
case Auxillary:
case AUXILLARY_CHANNEL:
g_error (_("error in %s at %d: this shouldn't happen."),
__FILE__, __LINE__);
break;
@ -647,7 +647,7 @@ channels_dialog_unset_channel (ChannelWidget * channel_widget)
/* get the list item data */
state = channel_widget->list_item->state;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* turn off the specified auxillary channel */
index = gimage_get_channel_index (channel_widget->gimage, channel_widget->channel);
@ -665,16 +665,16 @@ channels_dialog_unset_channel (ChannelWidget * channel_widget)
gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item), NULL);
switch (channel_widget->type)
{
case Red: case Gray: case Indexed:
case RED_CHANNEL: case GRAY_CHANNEL: case INDEXED_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 0);
break;
case Green:
case GREEN_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 1);
break;
case Blue:
case BLUE_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 2);
break;
case Auxillary:
case AUXILLARY_CHANNEL:
g_error (_("error in %s at %d: this shouldn't happen."),
__FILE__, __LINE__);
break;
@ -727,7 +727,7 @@ channels_dialog_add_channel (Channel *channel)
item_list = NULL;
channel_widget = create_channel_widget (gimage, channel, Auxillary);
channel_widget = create_channel_widget (gimage, channel, AUXILLARY_CHANNEL);
item_list = g_list_append (item_list, channel_widget->list_item);
position = gimage_get_channel_index (gimage, channel);
@ -788,7 +788,7 @@ channel_list_events (GtkWidget *widget,
break;
case GDK_2BUTTON_PRESS:
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
channels_dialog_edit_channel_query (channel_widget);
return TRUE;
break;
@ -1070,7 +1070,7 @@ create_channel_widget (GImage *gimage,
channel_widget->channel_preview = NULL;
channel_widget->channel_pixmap = NULL;
channel_widget->type = type;
channel_widget->ID = (type == Auxillary) ? GIMP_DRAWABLE(channel)->ID : (COMPONENT_BASE_ID + type);
channel_widget->ID = (type == AUXILLARY_CHANNEL) ? GIMP_DRAWABLE(channel)->ID : (COMPONENT_BASE_ID + type);
channel_widget->list_item = list_item;
channel_widget->width = -1;
channel_widget->height = -1;
@ -1126,12 +1126,29 @@ create_channel_widget (GImage *gimage,
/* the channel name label */
switch (channel_widget->type)
{
case Red: channel_widget->label = gtk_label_new (_("Red")); break;
case Green: channel_widget->label = gtk_label_new (_("Green")); break;
case Blue: channel_widget->label = gtk_label_new (_("Blue")); break;
case Gray: channel_widget->label = gtk_label_new (_("Gray")); break;
case Indexed: channel_widget->label = gtk_label_new (_("Indexed")); break;
case Auxillary: channel_widget->label = gtk_label_new (channel_get_name(channel)); break;
case RED_CHANNEL:
channel_widget->label = gtk_label_new (_("Red"));
break;
case GREEN_CHANNEL:
channel_widget->label = gtk_label_new (_("Green"));
break;
case BLUE_CHANNEL:
channel_widget->label = gtk_label_new (_("Blue"));
break;
case GRAY_CHANNEL:
channel_widget->label = gtk_label_new (_("Gray"));
break;
case INDEXED_CHANNEL:
channel_widget->label = gtk_label_new (_("Indexed"));
break;
case AUXILLARY_CHANNEL:
channel_widget->label = gtk_label_new (channel_get_name(channel));
break;
}
gtk_box_pack_start (GTK_BOX (hbox), channel_widget->label, FALSE, FALSE, 2);
@ -1173,7 +1190,7 @@ channel_widget_select_update (GtkWidget *w,
if (suspend_gimage_notify == 0)
{
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
if (w->state == GTK_STATE_SELECTED)
/* set the gimage's active channel to be this channel */
@ -1184,7 +1201,7 @@ channel_widget_select_update (GtkWidget *w,
gdisplays_flush ();
}
else if (channel_widget->type != Auxillary)
else if (channel_widget->type != AUXILLARY_CHANNEL)
{
if (w->state == GTK_STATE_SELECTED)
gimage_set_component_active (channel_widget->gimage, channel_widget->type, TRUE);
@ -1213,7 +1230,7 @@ channel_widget_button_events (GtkWidget *widget,
channel_widget = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible = GIMP_DRAWABLE(channel_widget->channel)->visible;
width = GIMP_DRAWABLE(channel_widget->channel)->width;
height = GIMP_DRAWABLE(channel_widget->channel)->height;
@ -1261,7 +1278,7 @@ channel_widget_button_events (GtkWidget *widget,
else
{
exclusive = FALSE;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
GIMP_DRAWABLE(channel_widget->channel)->visible = !visible;
else
gimage_set_component_visible (channel_widget->gimage, channel_widget->type, !visible);
@ -1305,7 +1322,7 @@ channel_widget_button_events (GtkWidget *widget,
}
else
{
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
GIMP_DRAWABLE(channel_widget->channel)->visible = !visible;
else
gimage_set_component_visible (channel_widget->gimage, channel_widget->type, !visible);
@ -1353,7 +1370,7 @@ channel_widget_preview_events (GtkWidget *widget,
{
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
valid = GIMP_DRAWABLE(channel_widget->channel)->preview_valid;
break;
default:
@ -1411,7 +1428,7 @@ channel_widget_preview_redraw (ChannelWidget *channel_widget)
/* determine width and height */
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
width = GIMP_DRAWABLE(channel_widget->channel)->width;
height = GIMP_DRAWABLE(channel_widget->channel)->height;
channel_widget->width = (int) (channelsD->ratio * width);
@ -1434,13 +1451,13 @@ channel_widget_preview_redraw (ChannelWidget *channel_widget)
switch (channel_widget->type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case Auxillary: channel = -1; break;
default: channel = -1; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
case AUXILLARY_CHANNEL: channel = -1; break;
default: channel = -1; break;
}
render_preview (preview_buf,
@ -1555,7 +1572,7 @@ channel_widget_eye_redraw (ChannelWidget *channel_widget)
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible = GIMP_DRAWABLE(channel_widget->channel)->visible;
break;
default:
@ -1624,7 +1641,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
{
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible |= GIMP_DRAWABLE(cw->channel)->visible;
break;
default:
@ -1644,7 +1661,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
if (cw != channel_widget)
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
GIMP_DRAWABLE(cw->channel)->visible = !visible;
break;
default:
@ -1654,7 +1671,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
else
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
GIMP_DRAWABLE(cw->channel)->visible = TRUE;
break;
default:
@ -1684,7 +1701,7 @@ channel_widget_channel_flush (GtkWidget *widget,
if (channelsD->floating_sel != NULL)
{
/* to insensitive if this is an auxillary channel */
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
@ -1699,7 +1716,7 @@ channel_widget_channel_flush (GtkWidget *widget,
else
{
/* to insensitive if there is an active channel, and this is a component channel */
if (channel_widget->type != Auxillary && channelsD->active_channel != NULL)
if (channel_widget->type != AUXILLARY_CHANNEL && channelsD->active_channel != NULL)
{
if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
@ -1715,7 +1732,7 @@ channel_widget_channel_flush (GtkWidget *widget,
/*** Selection ***/
/* If this is an auxillary channel */
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* select if this is the active channel */
if (channelsD->active_channel == (channel_widget->channel))
@ -1735,7 +1752,7 @@ channel_widget_channel_flush (GtkWidget *widget,
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
update_preview = !GIMP_DRAWABLE(channel_widget->channel)->preview_valid;
break;
default:

1
app/commands.c
View File

@ -42,7 +42,6 @@
#include "floating_sel.h"
#include "gdisplay_ops.h"
#include "general.h"
#include "gimage_cmds.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "global_edit.h"

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage-guides.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage-merge.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage-projection.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage-resize.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage-scale.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

90
app/core/gimpimage.c
View File

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpimage.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

6
app/core/gimplayer.h
View File

@ -25,8 +25,10 @@
#include "temp_buf.h"
#include "tile_manager.h"
#define APPLY 0
#define DISCARD 1
typedef enum {
APPLY,
DISCARD
} MaskApplyMode;
#include "layerF.h"

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

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/core/gimpprojection-construct.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

2
app/cursorutil.h
View File

@ -18,6 +18,8 @@
#ifndef __CURSORUTIL_H__
#define __CURSORUTIL_H__
#include <gdk/gdktypes.h>
void change_win_cursor (GdkWindow *, GdkCursorType);
void unset_win_cursor (GdkWindow *);

4
app/fileops.c
View File

@ -996,7 +996,7 @@ file_save_thumbnail (GimpImage* gimage,
return FALSE;
}
if (gimp_image_preview_valid (gimage, Gray))
if (gimp_image_preview_valid (gimage, GRAY_CHANNEL))
{
/* just for debugging */
printf("(incidentally, gimage already has a valid preview - %dx%d)\n",
@ -1040,7 +1040,7 @@ file_save_thumbnail (GimpImage* gimage,
/*printf("tn: %d x %d -> ", w, h);fflush(stdout);*/
tempbuf = gimp_image_composite_preview (gimage, Gray, w, h);
tempbuf = gimp_image_composite_preview (gimage, GRAY_CHANNEL, w, h);
tbd = temp_buf_data(tempbuf);
w = tempbuf->width;

6121
app/gimage_cmds.c
View File

File diff suppressed because it is too large Load Diff

90
app/gimage_cmds.h
View File

@ -1,90 +0,0 @@
/* 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 __GIMAGE_CMDS_H__
#define __GIMAGE_CMDS_H__
#include "procedural_db.h"
extern ProcRecord gimage_list_images_proc;
extern ProcRecord gimage_new_proc;
extern ProcRecord gimage_resize_proc;
extern ProcRecord gimage_scale_proc;
extern ProcRecord gimage_delete_proc;
extern ProcRecord gimage_free_shadow_proc;
extern ProcRecord gimage_get_layers_proc;
extern ProcRecord gimage_get_channels_proc;
extern ProcRecord gimage_get_active_layer_proc;
extern ProcRecord gimage_get_active_channel_proc;
extern ProcRecord gimage_get_selection_proc;
extern ProcRecord gimage_get_component_active_proc;
extern ProcRecord gimage_get_component_visible_proc;
extern ProcRecord gimage_set_active_layer_proc;
extern ProcRecord gimage_set_active_channel_proc;
extern ProcRecord gimage_unset_active_channel_proc;
extern ProcRecord gimage_set_component_active_proc;
extern ProcRecord gimage_set_component_visible_proc;
extern ProcRecord gimage_pick_correlate_layer_proc;
extern ProcRecord gimage_raise_layer_proc;
extern ProcRecord gimage_lower_layer_proc;
extern ProcRecord gimage_raise_layer_to_top_proc;
extern ProcRecord gimage_lower_layer_to_bottom_proc;
extern ProcRecord gimage_merge_visible_layers_proc;
extern ProcRecord gimage_merge_down_proc;
extern ProcRecord gimage_flatten_proc;
extern ProcRecord gimage_add_layer_proc;
extern ProcRecord gimage_remove_layer_proc;
extern ProcRecord gimage_add_layer_mask_proc;
extern ProcRecord gimage_remove_layer_mask_proc;
extern ProcRecord gimage_raise_channel_proc;
extern ProcRecord gimage_lower_channel_proc;
extern ProcRecord gimage_add_channel_proc;
extern ProcRecord gimage_remove_channel_proc;
extern ProcRecord gimage_active_drawable_proc;
extern ProcRecord gimage_base_type_proc;
extern ProcRecord gimage_get_filename_proc;
extern ProcRecord gimage_set_filename_proc;
extern ProcRecord gimage_get_resolution_proc;
extern ProcRecord gimage_set_resolution_proc;
extern ProcRecord gimage_get_unit_proc;
extern ProcRecord gimage_set_unit_proc;
extern ProcRecord gimage_width_proc;
extern ProcRecord gimage_height_proc;
extern ProcRecord gimage_get_cmap_proc;
extern ProcRecord gimage_set_cmap_proc;
extern ProcRecord gimage_enable_undo_proc;
extern ProcRecord gimage_disable_undo_proc;
extern ProcRecord gimage_clean_all_proc;
extern ProcRecord gimage_floating_sel_proc;
extern ProcRecord gimage_floating_sel_attached_to_proc;
extern ProcRecord gimp_image_add_hguide_proc;
extern ProcRecord gimp_image_add_vguide_proc;
extern ProcRecord gimp_image_delete_guide_proc;
extern ProcRecord gimp_image_findnext_guide_proc;
extern ProcRecord gimp_image_get_guide_orientation_proc;
extern ProcRecord gimp_image_get_guide_position_proc;
extern ProcRecord gimp_image_find_parasite_proc;
extern ProcRecord gimp_image_parasite_list_proc;
extern ProcRecord gimp_image_attach_parasite_proc;
extern ProcRecord gimp_image_detach_parasite_proc;
extern ProcRecord gimp_image_get_layer_by_tattoo_proc;
extern ProcRecord gimp_image_get_channel_by_tattoo_proc;
#endif /* __GIMAGE_CMDS_H__ */

90
app/gimpimage.c
View File

@ -1207,17 +1207,17 @@ gimp_image_construct_layers (GimpImage *gimage, int x, int y, int w, int h)
switch (gimp_image_base_type (gimage))
{
case RGB:
if (! gimp_image_get_component_visible (gimage, Red) &&
! gimp_image_get_component_visible (gimage, Green) &&
! gimp_image_get_component_visible (gimage, Blue))
if (! gimp_image_get_component_visible (gimage, RED_CHANNEL) &&
! gimp_image_get_component_visible (gimage, GREEN_CHANNEL) &&
! gimp_image_get_component_visible (gimage, BLUE_CHANNEL))
return;
break;
case GRAY:
if (! gimp_image_get_component_visible (gimage, Gray))
if (! gimp_image_get_component_visible (gimage, GRAY_CHANNEL))
return;
break;
case INDEXED:
if (! gimp_image_get_component_visible (gimage, Indexed))
if (! gimp_image_get_component_visible (gimage, INDEXED_CHANNEL))
return;
break;
}
@ -1717,11 +1717,11 @@ gimp_image_get_component_active (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->active[RED_PIX]; break;
case Green: return gimage->active[GREEN_PIX]; break;
case Blue: return gimage->active[BLUE_PIX]; break;
case Gray: return gimage->active[GRAY_PIX]; break;
case Indexed: return gimage->active[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->active[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->active[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->active[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->active[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->active[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1733,11 +1733,11 @@ gimp_image_get_component_visible (GimpImage *gimage, ChannelType type)
/* No sanity checking here... */
switch (type)
{
case Red: return gimage->visible[RED_PIX]; break;
case Green: return gimage->visible[GREEN_PIX]; break;
case Blue: return gimage->visible[BLUE_PIX]; break;
case Gray: return gimage->visible[GRAY_PIX]; break;
case Indexed: return gimage->visible[INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->visible[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->visible[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->visible[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->visible[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->visible[INDEXED_PIX]; break;
default: return 0; break;
}
}
@ -1856,18 +1856,18 @@ gimp_image_set_component_active (GimpImage *gimage, ChannelType type, int value)
/* No sanity checking here... */
switch (type)
{
case Red: gimage->active[RED_PIX] = value; break;
case Green: gimage->active[GREEN_PIX] = value; break;
case Blue: gimage->active[BLUE_PIX] = value; break;
case Gray: gimage->active[GRAY_PIX] = value; break;
case Indexed: gimage->active[INDEXED_PIX] = value; break;
case Auxillary: break;
case RED_CHANNEL: gimage->active[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->active[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->active[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->active[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->active[INDEXED_PIX] = value; break;
case AUXILLARY_CHANNEL: break;
}
/* If there is an active channel and we mess with the components,
* the active channel gets unset...
*/
if (type != Auxillary)
if (type != AUXILLARY_CHANNEL)
gimp_image_unset_active_channel (gimage);
}
@ -1878,11 +1878,11 @@ gimp_image_set_component_visible (GimpImage *gimage, ChannelType type, int value
/* No sanity checking here... */
switch (type)
{
case Red: gimage->visible[RED_PIX] = value; break;
case Green: gimage->visible[GREEN_PIX] = value; break;
case Blue: gimage->visible[BLUE_PIX] = value; break;
case Gray: gimage->visible[GRAY_PIX] = value; break;
case Indexed: gimage->visible[INDEXED_PIX] = value; break;
case RED_CHANNEL: gimage->visible[RED_PIX] = value; break;
case GREEN_CHANNEL: gimage->visible[GREEN_PIX] = value; break;
case BLUE_CHANNEL: gimage->visible[BLUE_PIX] = value; break;
case GRAY_CHANNEL: gimage->visible[GRAY_PIX] = value; break;
case INDEXED_CHANNEL: gimage->visible[INDEXED_PIX] = value; break;
default: break;
}
}
@ -2266,7 +2266,7 @@ gimp_image_flatten (GimpImage *gimage)
layer_list = g_slist_next (layer_list);
}
layer = gimp_image_merge_layers (gimage, merge_list, FlattenImage);
layer = gimp_image_merge_layers (gimage, merge_list, FLATTEN_IMAGE);
g_slist_free (merge_list);
gimp_remove_busy_cursors(NULL);
@ -2357,8 +2357,8 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
switch (merge_type)
{
case ExpandAsNecessary:
case ClipToImage:
case EXPAND_AS_NECESSARY:
case CLIP_TO_IMAGE:
if (!count)
{
x1 = off_x;
@ -2377,7 +2377,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
if ((off_y + drawable_height (GIMP_DRAWABLE(layer))) > y2)
y2 = (off_y + drawable_height (GIMP_DRAWABLE(layer)));
}
if (merge_type == ClipToImage)
if (merge_type == CLIP_TO_IMAGE)
{
x1 = CLAMP (x1, 0, gimage->width);
y1 = CLAMP (y1, 0, gimage->height);
@ -2385,7 +2385,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = CLAMP (y2, 0, gimage->height);
}
break;
case ClipToBottomLayer:
case CLIP_TO_BOTTOM_LAYER:
if (merge_list->next == NULL)
{
x1 = off_x;
@ -2394,7 +2394,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
y2 = off_y + drawable_height (GIMP_DRAWABLE(layer));
}
break;
case FlattenImage:
case FLATTEN_IMAGE:
if (merge_list->next == NULL)
{
x1 = 0;
@ -2416,7 +2416,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
/* Start a merge undo group */
undo_push_group_start (gimage, LAYER_MERGE_UNDO);
if (merge_type == FlattenImage ||
if (merge_type == FLATTEN_IMAGE ||
drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
{
switch (gimp_image_base_type (gimage))
@ -2539,7 +2539,7 @@ gimp_image_merge_layers (GimpImage *gimage, GSList *merge_list, MergeType merge_
g_slist_free (reverse_list);
/* if the type is flatten, remove all the remaining layers */
if (merge_type == FlattenImage)
if (merge_type == FLATTEN_IMAGE)
{
merge_list = gimage->layers;
while (merge_list)
@ -3294,11 +3294,11 @@ gimp_image_composite_preview (GimpImage *gimage, ChannelType type,
switch (type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
default: return NULL;
}
@ -3331,11 +3331,11 @@ gimp_image_preview_valid (gimage, type)
{
switch (type)
{
case Red: return gimage->comp_preview_valid [RED_PIX]; break;
case Green: return gimage->comp_preview_valid [GREEN_PIX]; break;
case Blue: return gimage->comp_preview_valid [BLUE_PIX]; break;
case Gray: return gimage->comp_preview_valid [GRAY_PIX]; break;
case Indexed: return gimage->comp_preview_valid [INDEXED_PIX]; break;
case RED_CHANNEL: return gimage->comp_preview_valid[RED_PIX]; break;
case GREEN_CHANNEL: return gimage->comp_preview_valid[GREEN_PIX]; break;
case BLUE_CHANNEL: return gimage->comp_preview_valid[BLUE_PIX]; break;
case GRAY_CHANNEL: return gimage->comp_preview_valid[GRAY_PIX]; break;
case INDEXED_CHANNEL: return gimage->comp_preview_valid[INDEXED_PIX]; break;
default: return TRUE;
}
}

32
app/gimpimage.h
View File

@ -49,33 +49,35 @@ typedef enum /*< chop=_GIMAGE >*/
typedef enum
{
RGB,
GRAY,
INDEXED
RGB,
GRAY,
INDEXED
} GimpImageBaseType;
#define COLORMAP_SIZE 768
#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE 2
typedef enum { /*< chop=_GUIDE >*/
HORIZONTAL_GUIDE,
VERTICAL_GUIDE
} GuideOrientation;
typedef enum
{
Red,
Green,
Blue,
Gray,
Indexed,
Auxillary
RED_CHANNEL,
GREEN_CHANNEL,
BLUE_CHANNEL,
GRAY_CHANNEL,
INDEXED_CHANNEL,
AUXILLARY_CHANNEL
} ChannelType;
typedef enum
{
ExpandAsNecessary,
ClipToImage,
ClipToBottomLayer,
FlattenImage
EXPAND_AS_NECESSARY,
CLIP_TO_IMAGE,
CLIP_TO_BOTTOM_LAYER,
FLATTEN_IMAGE
} MergeType;

6
app/gimplayer.h
View File

@ -25,8 +25,10 @@
#include "temp_buf.h"
#include "tile_manager.h"
#define APPLY 0
#define DISCARD 1
typedef enum {
APPLY,
DISCARD
} MaskApplyMode;
#include "layerF.h"

127
app/gui/channels-dialog.c
View File

@ -325,7 +325,7 @@ channels_dialog_flush ()
cw = (ChannelWidget *) list->data;
list = g_slist_next (list);
if (cw->visited == FALSE && cw->type == Auxillary)
if (cw->visited == FALSE && cw->type == AUXILLARY_CHANNEL)
/* will only be true for auxillary channels */
channels_dialog_remove_channel (cw);
}
@ -338,7 +338,7 @@ channels_dialog_flush ()
cw = (ChannelWidget *) list->data;
list = g_slist_next (list);
if (cw->type == Auxillary)
if (cw->type == AUXILLARY_CHANNEL)
if ((gimage_pos = gimage_get_channel_index (gimage, cw->channel)) != pos)
channels_dialog_position_channel (cw, gimage_pos);
@ -404,38 +404,38 @@ channels_dialog_update (GimpImage* gimage)
switch ((channelsD->base_type = gimage_base_type (gimage)))
{
case RGB:
cw = create_channel_widget (gimage, NULL, Red);
cw = create_channel_widget (gimage, NULL, RED_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Red;
channelsD->components[0] = RED_CHANNEL;
cw = create_channel_widget (gimage, NULL, Green);
cw = create_channel_widget (gimage, NULL, GREEN_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[1] = Green;
channelsD->components[1] = GREEN_CHANNEL;
cw = create_channel_widget (gimage, NULL, Blue);
cw = create_channel_widget (gimage, NULL, BLUE_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[2] = Blue;
channelsD->components[2] = BLUE_CHANNEL;
channelsD->num_components = 3;
break;
case GRAY:
cw = create_channel_widget (gimage, NULL, Gray);
cw = create_channel_widget (gimage, NULL, GRAY_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Gray;
channelsD->components[0] = GRAY_CHANNEL;
channelsD->num_components = 1;
break;
case INDEXED:
cw = create_channel_widget (gimage, NULL, Indexed);
cw = create_channel_widget (gimage, NULL, INDEXED_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
channelsD->components[0] = Indexed;
channelsD->components[0] = INDEXED_CHANNEL;
channelsD->num_components = 1;
break;
@ -447,7 +447,7 @@ channels_dialog_update (GimpImage* gimage)
{
/* create a channel list item */
channel = (Channel *) list->data;
cw = create_channel_widget (gimage, channel, Auxillary);
cw = create_channel_widget (gimage, channel, AUXILLARY_CHANNEL);
channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
item_list = g_list_append (item_list, cw->list_item);
@ -549,7 +549,7 @@ channels_dialog_set_menu_sensitivity ()
fs_sensitive = (channelsD->floating_sel != NULL);
if (cw)
aux_sensitive = (cw->type == Auxillary);
aux_sensitive = (cw->type == AUXILLARY_CHANNEL);
else
aux_sensitive = FALSE;
@ -593,7 +593,7 @@ channels_dialog_set_channel (ChannelWidget *channel_widget)
/* get the list item data */
state = channel_widget->list_item->state;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* turn on the specified auxillary channel */
index = gimage_get_channel_index (channel_widget->gimage, channel_widget->channel);
@ -611,16 +611,16 @@ channels_dialog_set_channel (ChannelWidget *channel_widget)
gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item), NULL);
switch (channel_widget->type)
{
case Red: case Gray: case Indexed:
case RED_CHANNEL: case GRAY_CHANNEL: case INDEXED_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 0);
break;
case Green:
case GREEN_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 1);
break;
case Blue:
case BLUE_CHANNEL:
gtk_list_select_item (GTK_LIST (channelsD->channel_list), 2);
break;
case Auxillary:
case AUXILLARY_CHANNEL:
g_error (_("error in %s at %d: this shouldn't happen."),
__FILE__, __LINE__);
break;
@ -647,7 +647,7 @@ channels_dialog_unset_channel (ChannelWidget * channel_widget)
/* get the list item data */
state = channel_widget->list_item->state;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* turn off the specified auxillary channel */
index = gimage_get_channel_index (channel_widget->gimage, channel_widget->channel);
@ -665,16 +665,16 @@ channels_dialog_unset_channel (ChannelWidget * channel_widget)
gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item), NULL);
switch (channel_widget->type)
{
case Red: case Gray: case Indexed:
case RED_CHANNEL: case GRAY_CHANNEL: case INDEXED_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 0);
break;
case Green:
case GREEN_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 1);
break;
case Blue:
case BLUE_CHANNEL:
gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 2);
break;
case Auxillary:
case AUXILLARY_CHANNEL:
g_error (_("error in %s at %d: this shouldn't happen."),
__FILE__, __LINE__);
break;
@ -727,7 +727,7 @@ channels_dialog_add_channel (Channel *channel)
item_list = NULL;
channel_widget = create_channel_widget (gimage, channel, Auxillary);
channel_widget = create_channel_widget (gimage, channel, AUXILLARY_CHANNEL);
item_list = g_list_append (item_list, channel_widget->list_item);
position = gimage_get_channel_index (gimage, channel);
@ -788,7 +788,7 @@ channel_list_events (GtkWidget *widget,
break;
case GDK_2BUTTON_PRESS:
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
channels_dialog_edit_channel_query (channel_widget);
return TRUE;
break;
@ -1070,7 +1070,7 @@ create_channel_widget (GImage *gimage,
channel_widget->channel_preview = NULL;
channel_widget->channel_pixmap = NULL;
channel_widget->type = type;
channel_widget->ID = (type == Auxillary) ? GIMP_DRAWABLE(channel)->ID : (COMPONENT_BASE_ID + type);
channel_widget->ID = (type == AUXILLARY_CHANNEL) ? GIMP_DRAWABLE(channel)->ID : (COMPONENT_BASE_ID + type);
channel_widget->list_item = list_item;
channel_widget->width = -1;
channel_widget->height = -1;
@ -1126,12 +1126,29 @@ create_channel_widget (GImage *gimage,
/* the channel name label */
switch (channel_widget->type)
{
case Red: channel_widget->label = gtk_label_new (_("Red")); break;
case Green: channel_widget->label = gtk_label_new (_("Green")); break;
case Blue: channel_widget->label = gtk_label_new (_("Blue")); break;
case Gray: channel_widget->label = gtk_label_new (_("Gray")); break;
case Indexed: channel_widget->label = gtk_label_new (_("Indexed")); break;
case Auxillary: channel_widget->label = gtk_label_new (channel_get_name(channel)); break;
case RED_CHANNEL:
channel_widget->label = gtk_label_new (_("Red"));
break;
case GREEN_CHANNEL:
channel_widget->label = gtk_label_new (_("Green"));
break;
case BLUE_CHANNEL:
channel_widget->label = gtk_label_new (_("Blue"));
break;
case GRAY_CHANNEL:
channel_widget->label = gtk_label_new (_("Gray"));
break;
case INDEXED_CHANNEL:
channel_widget->label = gtk_label_new (_("Indexed"));
break;
case AUXILLARY_CHANNEL:
channel_widget->label = gtk_label_new (channel_get_name(channel));
break;
}
gtk_box_pack_start (GTK_BOX (hbox), channel_widget->label, FALSE, FALSE, 2);
@ -1173,7 +1190,7 @@ channel_widget_select_update (GtkWidget *w,
if (suspend_gimage_notify == 0)
{
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
if (w->state == GTK_STATE_SELECTED)
/* set the gimage's active channel to be this channel */
@ -1184,7 +1201,7 @@ channel_widget_select_update (GtkWidget *w,
gdisplays_flush ();
}
else if (channel_widget->type != Auxillary)
else if (channel_widget->type != AUXILLARY_CHANNEL)
{
if (w->state == GTK_STATE_SELECTED)
gimage_set_component_active (channel_widget->gimage, channel_widget->type, TRUE);
@ -1213,7 +1230,7 @@ channel_widget_button_events (GtkWidget *widget,
channel_widget = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible = GIMP_DRAWABLE(channel_widget->channel)->visible;
width = GIMP_DRAWABLE(channel_widget->channel)->width;
height = GIMP_DRAWABLE(channel_widget->channel)->height;
@ -1261,7 +1278,7 @@ channel_widget_button_events (GtkWidget *widget,
else
{
exclusive = FALSE;
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
GIMP_DRAWABLE(channel_widget->channel)->visible = !visible;
else
gimage_set_component_visible (channel_widget->gimage, channel_widget->type, !visible);
@ -1305,7 +1322,7 @@ channel_widget_button_events (GtkWidget *widget,
}
else
{
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
GIMP_DRAWABLE(channel_widget->channel)->visible = !visible;
else
gimage_set_component_visible (channel_widget->gimage, channel_widget->type, !visible);
@ -1353,7 +1370,7 @@ channel_widget_preview_events (GtkWidget *widget,
{
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
valid = GIMP_DRAWABLE(channel_widget->channel)->preview_valid;
break;
default:
@ -1411,7 +1428,7 @@ channel_widget_preview_redraw (ChannelWidget *channel_widget)
/* determine width and height */
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
width = GIMP_DRAWABLE(channel_widget->channel)->width;
height = GIMP_DRAWABLE(channel_widget->channel)->height;
channel_widget->width = (int) (channelsD->ratio * width);
@ -1434,13 +1451,13 @@ channel_widget_preview_redraw (ChannelWidget *channel_widget)
switch (channel_widget->type)
{
case Red: channel = RED_PIX; break;
case Green: channel = GREEN_PIX; break;
case Blue: channel = BLUE_PIX; break;
case Gray: channel = GRAY_PIX; break;
case Indexed: channel = INDEXED_PIX; break;
case Auxillary: channel = -1; break;
default: channel = -1; break;
case RED_CHANNEL: channel = RED_PIX; break;
case GREEN_CHANNEL: channel = GREEN_PIX; break;
case BLUE_CHANNEL: channel = BLUE_PIX; break;
case GRAY_CHANNEL: channel = GRAY_PIX; break;
case INDEXED_CHANNEL: channel = INDEXED_PIX; break;
case AUXILLARY_CHANNEL: channel = -1; break;
default: channel = -1; break;
}
render_preview (preview_buf,
@ -1555,7 +1572,7 @@ channel_widget_eye_redraw (ChannelWidget *channel_widget)
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible = GIMP_DRAWABLE(channel_widget->channel)->visible;
break;
default:
@ -1624,7 +1641,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
{
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
visible |= GIMP_DRAWABLE(cw->channel)->visible;
break;
default:
@ -1644,7 +1661,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
if (cw != channel_widget)
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
GIMP_DRAWABLE(cw->channel)->visible = !visible;
break;
default:
@ -1654,7 +1671,7 @@ channel_widget_exclusive_visible (ChannelWidget *channel_widget)
else
switch (cw->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
GIMP_DRAWABLE(cw->channel)->visible = TRUE;
break;
default:
@ -1684,7 +1701,7 @@ channel_widget_channel_flush (GtkWidget *widget,
if (channelsD->floating_sel != NULL)
{
/* to insensitive if this is an auxillary channel */
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
@ -1699,7 +1716,7 @@ channel_widget_channel_flush (GtkWidget *widget,
else
{
/* to insensitive if there is an active channel, and this is a component channel */
if (channel_widget->type != Auxillary && channelsD->active_channel != NULL)
if (channel_widget->type != AUXILLARY_CHANNEL && channelsD->active_channel != NULL)
{
if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
@ -1715,7 +1732,7 @@ channel_widget_channel_flush (GtkWidget *widget,
/*** Selection ***/
/* If this is an auxillary channel */
if (channel_widget->type == Auxillary)
if (channel_widget->type == AUXILLARY_CHANNEL)
{
/* select if this is the active channel */
if (channelsD->active_channel == (channel_widget->channel))
@ -1735,7 +1752,7 @@ channel_widget_channel_flush (GtkWidget *widget,
switch (channel_widget->type)
{
case Auxillary:
case AUXILLARY_CHANNEL:
update_preview = !GIMP_DRAWABLE(channel_widget->channel)->preview_valid;
break;
default:

1
app/gui/commands.c
View File

@ -42,7 +42,6 @@
#include "floating_sel.h"
#include "gdisplay_ops.h"
#include "general.h"
#include "gimage_cmds.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "global_edit.h"

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

@ -42,7 +42,6 @@
#include "floating_sel.h"
#include "gdisplay_ops.h"
#include "general.h"
#include "gimage_cmds.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "global_edit.h"

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

@ -1901,7 +1901,7 @@ layers_dialog_merge_down_callback (GtkWidget *w, gpointer client_data)
if (! (gimage = layersD->gimage))
return;
gimp_image_merge_down (gimage, gimage->active_layer, ExpandAsNecessary);
gimp_image_merge_down (gimage, gimage->active_layer, EXPAND_AS_NECESSARY);
gdisplays_flush ();
}
@ -3937,7 +3937,7 @@ expand_as_necessary_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ExpandAsNecessary;
options->merge_type = EXPAND_AS_NECESSARY;
}
static void
@ -3947,7 +3947,7 @@ clip_to_image_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ClipToImage;
options->merge_type = CLIP_TO_IMAGE;
}
static void
@ -3957,7 +3957,7 @@ clip_to_bottom_layer_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ClipToBottomLayer;
options->merge_type = CLIP_TO_BOTTOM_LAYER;
}
void
@ -3994,7 +3994,7 @@ layers_dialog_layer_merge_query (GImage *gimage,
options = (LayerMergeOptions *) g_malloc (sizeof (LayerMergeOptions));
options->gimage = gimage;
options->merge_visible = merge_visible;
options->merge_type = ExpandAsNecessary;
options->merge_type = EXPAND_AS_NECESSARY;
/* the dialog */
options->query_box = gtk_dialog_new ();

546
app/guides_cmds.c Normal file
View File

@ -0,0 +1,546 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995-1999 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.
*/
/* NOTE: This file is autogenerated by pdbgen.pl. */
#include "procedural_db.h"
#include "gimage.h"
#include "gimpimage.h"
#include "undo.h"
static ProcRecord image_add_hguide_proc;
static ProcRecord image_add_vguide_proc;
static ProcRecord image_delete_guide_proc;
static ProcRecord image_find_next_guide_proc;
static ProcRecord image_get_guide_orientation_proc;
static ProcRecord image_get_guide_position_proc;
void
register_guides_procs (void)
{
procedural_db_register (&image_add_hguide_proc);
procedural_db_register (&image_add_vguide_proc);
procedural_db_register (&image_delete_guide_proc);
procedural_db_register (&image_find_next_guide_proc);
procedural_db_register (&image_get_guide_orientation_proc);
procedural_db_register (&image_get_guide_position_proc);
}
static Argument *
image_add_hguide_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 offset;
gint32 guide_id = 0;
Guide *guide;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
offset = args[1].value.pdb_int;
if (offset <= 0)
success = FALSE;
if (success)
{
if (offset < gimage->height)
{
guide = gimp_image_add_hguide (gimage);
guide->position = offset;
guide_id = guide->guide_ID;
}
else
success = FALSE;
}
return_args = procedural_db_return_args (&image_add_hguide_proc, success);
if (success)
return_args[1].value.pdb_int = guide_id;
return return_args;
}
static ProcArg image_add_hguide_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"yposition",
"The guide's y-offset from top of image"
}
};
static ProcArg image_add_hguide_outargs[] =
{
{
PDB_INT32,
"guide_id",
"The new guide"
}
};
static ProcRecord image_add_hguide_proc =
{
"gimp_image_add_hguide",
"Add a horizontal guide to an image.",
"This procedure adds a horizontal guide to an image. It takes the input image and the y-position of the new guide as parameters. It returns the guide ID of the new guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_add_hguide_inargs,
1,
image_add_hguide_outargs,
{ { image_add_hguide_invoker } }
};
static Argument *
image_add_vguide_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 offset;
gint32 guide_id = 0;
Guide *guide;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
offset = args[1].value.pdb_int;
if (offset <= 0)
success = FALSE;
if (success)
{
if (offset < gimage->width)
{
guide = gimp_image_add_vguide (gimage);
guide->position = offset;
guide_id = guide->guide_ID;
}
else
success = FALSE;
}
return_args = procedural_db_return_args (&image_add_vguide_proc, success);
if (success)
return_args[1].value.pdb_int = guide_id;
return return_args;
}
static ProcArg image_add_vguide_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"xposition",
"The guide's x-offset from left of image"
}
};
static ProcArg image_add_vguide_outargs[] =
{
{
PDB_INT32,
"guide_id",
"The new guide"
}
};
static ProcRecord image_add_vguide_proc =
{
"gimp_image_add_vguide",
"Add a vertical guide to an image.",
"This procedure adds a vertical guide to an image. It takes the input image and the x-position of the new guide as parameters. It returns the guide ID of the new guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_add_vguide_inargs,
1,
image_add_vguide_outargs,
{ { image_add_vguide_invoker } }
};
static Argument *
image_delete_guide_invoker (Argument *args)
{
gboolean success = TRUE;
GimpImage *gimage;
gint32 guide;
GList *guides;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
guide = args[1].value.pdb_int;
if (success)
{
success = FALSE;
guides = gimage->guides;
while (guides)
{
if ((((Guide *) guides->data)->guide_ID == guide) &&
(((Guide *) guides->data)->position >= 0))
{
GList *tmp_next;
success = TRUE;
tmp_next = guides->next;
((Guide *) guides->data)->position = -1;
undo_push_guide (gimage, ((Guide *) guides->data));
/* gimp_image_remove_guide (gimage, ((Guide *) guides->data)); */
guides = tmp_next;
}
else
guides = guides->next;
}
}
return procedural_db_return_args (&image_delete_guide_proc, success);
}
static ProcArg image_delete_guide_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"guide",
"The ID of the guide to be removed"
}
};
static ProcRecord image_delete_guide_proc =
{
"gimp_image_delete_guide",
"Deletes a guide from an image.",
"This procedure takes an image and a guide ID as input and removes the specified guide from the specified image.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_delete_guide_inargs,
0,
NULL,
{ { image_delete_guide_invoker } }
};
static Argument *
image_find_next_guide_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 guide;
gint32 next_guide = 0;
GList *guides;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
guide = args[1].value.pdb_int;
if (success)
{
guides = gimage->guides;
if (guides != NULL)
{
if (guide == 0) /* init - Return first guide ID in list */
{
while (guides && (((Guide *) guides->data)->position < 0))
guides = guides->next;
if (guides) /* didn't just come to end of list */
next_guide = ((Guide *) guides->data)->guide_ID;
}
else
{
success = FALSE;
while (guides)
{
if ((((Guide *) guides->data)->guide_ID == guide) &&
(((Guide *) guides->data)->position >= 0))
{
GList* tmplist;
success = TRUE;
tmplist = guides->next;
while (tmplist && (((Guide *) tmplist->data)->position < 0))
tmplist = tmplist->next;
if (tmplist);
next_guide = ((Guide *) tmplist->data)->guide_ID;
break;
}
guides = guides->next;
}
}
}
}
return_args = procedural_db_return_args (&image_find_next_guide_proc, success);
if (success)
return_args[1].value.pdb_int = next_guide;
return return_args;
}
static ProcArg image_find_next_guide_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"guide",
"The ID of the current guide (0 if first invocation)"
}
};
static ProcArg image_find_next_guide_outargs[] =
{
{
PDB_INT32,
"next_guide",
"The next guide's ID"
}
};
static ProcRecord image_find_next_guide_proc =
{
"gimp_image_find_next_guide",
"Find next guide on an image.",
"This procedure takes an image and a guide ID as input and finds the guide ID of the successor of the given guide ID in the image's guide list. If the supplied guide ID is 0, the procedure will return the first Guide. The procedure will return 0 if given the final guide ID as an argument or the image has no guides.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_find_next_guide_inargs,
1,
image_find_next_guide_outargs,
{ { image_find_next_guide_invoker } }
};
static Argument *
image_get_guide_orientation_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 guide;
gint32 orientation = 0;
GList *guides;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
guide = args[1].value.pdb_int;
if (success)
{
guides = gimage->guides;
success = FALSE;
while (guides)
{
if ((((Guide *) guides->data)->guide_ID == guide) &&
(((Guide *) guides->data)->position >= 0))
{
orientation = ((Guide *) guides->data)->orientation;
success = TRUE;
break;
}
guides = guides->next;
}
}
return_args = procedural_db_return_args (&image_get_guide_orientation_proc, success);
if (success)
return_args[1].value.pdb_int = orientation;
return return_args;
}
static ProcArg image_get_guide_orientation_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"guide",
"The guide"
}
};
static ProcArg image_get_guide_orientation_outargs[] =
{
{
PDB_INT32,
"orientation",
"The guide's orientation: { HORIZONTAL (0), VERTICAL (1) }"
}
};
static ProcRecord image_get_guide_orientation_proc =
{
"gimp_image_get_guide_orientation",
"Get orientation of a guide on an image.",
"This procedure takes an image and a guide ID as input and returns the orientations of the guide.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_get_guide_orientation_inargs,
1,
image_get_guide_orientation_outargs,
{ { image_get_guide_orientation_invoker } }
};
static Argument *
image_get_guide_position_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 guide;
gint32 position = 0;
GList *guides;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
guide = args[1].value.pdb_int;
if (success)
{
guides = gimage->guides;
success = FALSE;
while (guides)
{
if ((((Guide *) guides->data)->guide_ID == guide) &&
(((Guide *) guides->data)->position >= 0))
{
position = ((Guide *) guides->data)->position;
success = TRUE;
break;
}
guides = guides->next;
}
}
return_args = procedural_db_return_args (&image_get_guide_position_proc, success);
if (success)
return_args[1].value.pdb_int = position;
return return_args;
}
static ProcArg image_get_guide_position_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_INT32,
"guide",
"The guide"
}
};
static ProcArg image_get_guide_position_outargs[] =
{
{
PDB_INT32,
"position",
"The guide's position relative to top or left of image"
}
};
static ProcRecord image_get_guide_position_proc =
{
"gimp_image_get_guide_position",
"Get position of a guide on an image.",
"This procedure takes an image and a guide ID as input and returns the position of the guide relative to the top or left of the image.",
"Adam D. Moss",
"Adam D. Moss",
"1998",
PDB_INTERNAL,
2,
image_get_guide_position_inargs,
1,
image_get_guide_position_outargs,
{ { image_get_guide_position_invoker } }
};

273
app/internal_procs.c
View File

@ -1,5 +1,5 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
* Copyright (C) 1995-1999 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
@ -15,249 +15,132 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "appenv.h"
/* NOTE: This file is autogenerated by pdbgen.pl. */
#include "config.h"
#include "app_procs.h"
#include "gimage_cmds.h"
#include "internal_procs.h"
#include "procedural_db.h"
#include "libgimp/gimpintl.h"
/* Forward declarations for registering PDB procs */
void register_gdisplay_procs (void);
void register_edit_procs (void);
void register_floating_sel_procs (void);
void register_undo_procs (void);
void register_convert_procs (void);
void register_paths_procs (void);
void register_palette_procs (void);
void register_gradient_procs (void);
void register_convert_procs (void);
void register_channel_ops_procs (void);
void register_gimprc_procs (void);
void register_drawable_procs (void);
void register_parasite_procs (void);
void register_paths_procs (void);
void register_gradient_select_procs (void);
void register_unit_procs (void);
void register_procedural_db_procs (void);
void register_brushes_procs (void);
void register_text_tool_procs (void);
void register_brush_select_procs (void);
void register_color_procs (void);
void register_misc_procs (void);
void register_tools_procs (void);
void register_gimprc_procs (void);
void register_channel_procs (void);
void register_channel_ops_procs (void);
void register_gradient_procs (void);
void register_gradient_select_procs (void);
void register_brushes_procs (void);
void register_brush_select_procs (void);
void register_patterns_procs (void);
void register_pattern_select_procs (void);
void register_parasite_procs (void);
void register_drawable_procs (void);
void register_procedural_db_procs (void);
void register_layer_procs (void);
void register_gimage_mask_procs (void);
void register_gimage_procs (void);
void register_guides_procs (void);
/* 281 procedures registered total */
void
internal_procs_init (void)
{
gfloat pcount = 0;
/* grep -c procedural_db_register internal_procs.c */
gfloat total_pcount = 264;
app_init_update_status(_("Internal Procedures"), _("Tool procedures"),
pcount/total_pcount);
/* Tool procedures */
register_tools_procs ();
pcount += 21;
register_text_tool_procs ();
pcount += 6;
app_init_update_status(NULL, _("GDisplay procedures"),
pcount/total_pcount);
/* GDisplay procedures */
app_init_update_status (_("Internal Procedures"), _("GDisplay procedures"), 0.0);
register_gdisplay_procs ();
pcount += 3;
app_init_update_status(NULL, _("Edit procedures"),
pcount/total_pcount);
/* Edit procedures */
app_init_update_status (NULL, _("Edit procedures"), 0.011);
register_edit_procs ();
pcount += 6;
app_init_update_status(NULL, _("GImage procedures"),
pcount/total_pcount);
/* GImage procedures */
procedural_db_register (&gimage_list_images_proc); pcount++;
procedural_db_register (&gimage_new_proc); pcount++;
procedural_db_register (&gimage_resize_proc); pcount++;
procedural_db_register (&gimage_scale_proc); pcount++;
procedural_db_register (&gimage_delete_proc); pcount++;
procedural_db_register (&gimage_free_shadow_proc); pcount++;
procedural_db_register (&gimage_get_layers_proc); pcount++;
procedural_db_register (&gimage_get_channels_proc); pcount++;
procedural_db_register (&gimage_get_active_layer_proc); pcount++;
procedural_db_register (&gimage_get_active_channel_proc); pcount++;
procedural_db_register (&gimage_get_selection_proc); pcount++;
procedural_db_register (&gimage_get_component_active_proc); pcount++;
procedural_db_register (&gimage_get_component_visible_proc); pcount++;
procedural_db_register (&gimage_set_active_layer_proc); pcount++;
procedural_db_register (&gimage_set_active_channel_proc); pcount++;
procedural_db_register (&gimage_unset_active_channel_proc); pcount++;
procedural_db_register (&gimage_set_component_active_proc); pcount++;
procedural_db_register (&gimage_set_component_visible_proc); pcount++;
procedural_db_register (&gimage_pick_correlate_layer_proc); pcount++;
procedural_db_register (&gimage_raise_layer_proc); pcount++;
procedural_db_register (&gimage_lower_layer_proc); pcount++;
procedural_db_register (&gimage_raise_layer_to_top_proc); pcount++;
procedural_db_register (&gimage_lower_layer_to_bottom_proc); pcount++;
procedural_db_register (&gimage_merge_visible_layers_proc); pcount++;
procedural_db_register (&gimage_merge_down_proc); pcount++;
procedural_db_register (&gimage_flatten_proc); pcount++;
procedural_db_register (&gimage_add_layer_proc); pcount++;
procedural_db_register (&gimage_remove_layer_proc); pcount++;
procedural_db_register (&gimage_add_layer_mask_proc); pcount++;
procedural_db_register (&gimage_remove_layer_mask_proc); pcount++;
procedural_db_register (&gimage_raise_channel_proc); pcount++;
procedural_db_register (&gimage_lower_channel_proc); pcount++;
procedural_db_register (&gimage_add_channel_proc); pcount++;
procedural_db_register (&gimage_remove_channel_proc); pcount++;
procedural_db_register (&gimage_active_drawable_proc); pcount++;
procedural_db_register (&gimage_base_type_proc); pcount++;
procedural_db_register (&gimage_get_filename_proc); pcount++;
procedural_db_register (&gimage_set_filename_proc); pcount++;
procedural_db_register (&gimage_get_resolution_proc); pcount++;
procedural_db_register (&gimage_set_resolution_proc); pcount++;
procedural_db_register (&gimage_get_unit_proc); pcount++;
procedural_db_register (&gimage_set_unit_proc); pcount++;
procedural_db_register (&gimage_width_proc); pcount++;
procedural_db_register (&gimage_height_proc); pcount++;
procedural_db_register (&gimage_get_cmap_proc); pcount++;
procedural_db_register (&gimage_set_cmap_proc); pcount++;
procedural_db_register (&gimage_enable_undo_proc); pcount++;
procedural_db_register (&gimage_disable_undo_proc); pcount++;
procedural_db_register (&gimage_clean_all_proc); pcount++;
procedural_db_register (&gimage_floating_sel_proc); pcount++;
procedural_db_register (&gimage_floating_sel_attached_to_proc); pcount++;
procedural_db_register (&gimp_image_add_hguide_proc); pcount++;
procedural_db_register (&gimp_image_add_vguide_proc); pcount++;
procedural_db_register (&gimp_image_delete_guide_proc); pcount++;
procedural_db_register (&gimp_image_findnext_guide_proc); pcount++;
procedural_db_register (&gimp_image_get_guide_orientation_proc); pcount++;
procedural_db_register (&gimp_image_get_guide_position_proc); pcount++;
procedural_db_register (&gimp_image_find_parasite_proc); pcount++;
procedural_db_register (&gimp_image_parasite_list_proc); pcount++;
procedural_db_register (&gimp_image_attach_parasite_proc); pcount++;
procedural_db_register (&gimp_image_detach_parasite_proc); pcount++;
procedural_db_register (&gimp_image_get_layer_by_tattoo_proc); pcount++;
procedural_db_register (&gimp_image_get_channel_by_tattoo_proc); pcount++;
app_init_update_status(NULL, _("GImage mask procedures"),
pcount/total_pcount);
/* GImage mask procedures */
register_gimage_mask_procs ();
pcount += 19;
app_init_update_status(NULL, _("Layer procedures"),
pcount/total_pcount);
/* Layer procedures */
register_layer_procs ();
pcount += 30;
app_init_update_status(NULL, _("Channel procedures"),
pcount/total_pcount);
/* Channel procedures */
register_channel_procs ();
pcount += 14;
app_init_update_status(NULL, _("Drawable procedures"),
pcount/total_pcount);
/* Drawable procedures */
register_drawable_procs ();
pcount += 25;
app_init_update_status(NULL, _("Floating selections"),
pcount/total_pcount);
/* Floating Selections */
app_init_update_status (NULL, _("Floating selections"), 0.032);
register_floating_sel_procs ();
pcount += 6;
app_init_update_status(NULL, _("Undo"),
pcount/total_pcount);
/* Undo */
app_init_update_status (NULL, _("Undo"), 0.053);
register_undo_procs ();
pcount += 2;
app_init_update_status(NULL, _("Palette"),
pcount/total_pcount);
/* Palette */
app_init_update_status (NULL, _("Palette"), 0.06);
register_palette_procs ();
pcount += 7;
app_init_update_status(NULL, _("Interface procedures"),
pcount/total_pcount);
/* Interface procs */
register_brushes_procs ();
register_brush_select_procs ();
register_patterns_procs ();
register_pattern_select_procs ();
pcount += 20;
app_init_update_status (NULL, _("Gradients"), 0.085);
register_gradient_procs ();
register_gradient_select_procs ();
pcount += 9;
app_init_update_status(NULL, _("Image procedures"),
pcount/total_pcount);
register_color_procs ();
pcount += 12;
app_init_update_status (NULL, _("Convert"), 0.103);
register_convert_procs ();
pcount += 4;
app_init_update_status(NULL, _("Channel ops"),
pcount/total_pcount);
/* Channel Ops procedures */
app_init_update_status (NULL, _("Channel Ops"), 0.117);
register_channel_ops_procs ();
pcount += 2;
app_init_update_status(NULL, _("gimprc ops"),
pcount/total_pcount);
/* Gimprc procedures */
app_init_update_status (NULL, _("Gimprc procedures"), 0.125);
register_gimprc_procs ();
pcount += 2;
app_init_update_status(NULL, _("parasites"),
pcount/total_pcount);
/* parasite procedures */
app_init_update_status (NULL, _("Drawable procedures"), 0.132);
register_drawable_procs ();
app_init_update_status (NULL, _("Parasite procedures"), 0.206);
register_parasite_procs ();
pcount += 5;
/* paths procedures */
app_init_update_status (NULL, _("Paths"), 0.253);
register_paths_procs ();
pcount += 6;
app_init_update_status(NULL, _("Procedural database"),
pcount/total_pcount);
app_init_update_status (NULL, _("Gradient UI"), 0.285);
register_gradient_select_procs ();
/* Unit Procedures */
app_init_update_status (NULL, _("Units"), 0.299);
register_unit_procs ();
pcount += 11;
/* Procedural Database */
app_init_update_status (NULL, _("Procedural database"), 0.338);
register_procedural_db_procs ();
pcount += 8;
app_init_update_status (NULL, _("Brushes"), 0.367);
register_brushes_procs ();
app_init_update_status (NULL, _("Text procedures"), 0.406);
register_text_tool_procs ();
app_init_update_status (NULL, _("Brush UI"), 0.42);
register_brush_select_procs ();
app_init_update_status (NULL, _("Color"), 0.431);
register_color_procs ();
app_init_update_status (NULL, _("Miscellaneous"), 0.473);
register_misc_procs ();
app_init_update_status (NULL, _("Tool procedures"), 0.477);
register_tools_procs ();
app_init_update_status (NULL, _("Channel"), 0.548);
register_channel_procs ();
app_init_update_status (NULL, _("Patterns"), 0.598);
register_patterns_procs ();
app_init_update_status (NULL, _("Pattern UI"), 0.612);
register_pattern_select_procs ();
app_init_update_status (NULL, _("Layer"), 0.623);
register_layer_procs ();
app_init_update_status (NULL, _("Image mask"), 0.73);
register_gimage_mask_procs ();
app_init_update_status (NULL, _("Image"), 0.79);
register_gimage_procs ();
app_init_update_status (NULL, _("Guide procedures"), 0.979);
register_guides_procs ();
}

10
app/internal_procs.h
View File

@ -1,5 +1,5 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
* Copyright (C) 1995-1999 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
@ -15,10 +15,12 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* NOTE: This file is autogenerated by pdbgen.pl. */
#ifndef __INTERNAL_PROCS_H__
#define __INTERNAL_PROCS_H__
/* Functions */
void internal_procs_init (void);
void internal_procs_init (void);
#endif /* __INTERNAL_PROCS_H__ */
#endif /* __INTERNAL_PROCS_H__ */

6
app/layer.h
View File

@ -25,8 +25,10 @@
#include "temp_buf.h"
#include "tile_manager.h"
#define APPLY 0
#define DISCARD 1
typedef enum {
APPLY,
DISCARD
} MaskApplyMode;
#include "layerF.h"

9
app/layer_cmds.c
View File

@ -189,7 +189,7 @@ static ProcArg layer_new_inargs[] =
{
PDB_INT32,
"mode",
"The layer combination mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The layer combination mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
}
};
@ -807,13 +807,10 @@ layer_mask_invoker (Argument *args)
if (layer == NULL)
success = FALSE;
if (success)
success = layer->mask ? TRUE : FALSE;
return_args = procedural_db_return_args (&layer_mask_proc, success);
if (success)
return_args[1].value.pdb_int = drawable_ID (GIMP_DRAWABLE (layer->mask));
return_args[1].value.pdb_int = layer->mask ? drawable_ID (GIMP_DRAWABLE (layer->mask)) : -1;
return return_args;
}
@ -840,7 +837,7 @@ static ProcRecord layer_mask_proc =
{
"gimp_layer_mask",
"Get the specified layer's mask if it exists.",
"This procedure returns the specified layer's mask. If there is no layer mask, the procedure fails.",
"This procedure returns the specified layer's mask, or -1 if none exists.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",

10
app/layers_dialog.c
View File

@ -1901,7 +1901,7 @@ layers_dialog_merge_down_callback (GtkWidget *w, gpointer client_data)
if (! (gimage = layersD->gimage))
return;
gimp_image_merge_down (gimage, gimage->active_layer, ExpandAsNecessary);
gimp_image_merge_down (gimage, gimage->active_layer, EXPAND_AS_NECESSARY);
gdisplays_flush ();
}
@ -3937,7 +3937,7 @@ expand_as_necessary_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ExpandAsNecessary;
options->merge_type = EXPAND_AS_NECESSARY;
}
static void
@ -3947,7 +3947,7 @@ clip_to_image_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ClipToImage;
options->merge_type = CLIP_TO_IMAGE;
}
static void
@ -3957,7 +3957,7 @@ clip_to_bottom_layer_callback (GtkWidget *w,
LayerMergeOptions *options;
options = (LayerMergeOptions *) client_data;
options->merge_type = ClipToBottomLayer;
options->merge_type = CLIP_TO_BOTTOM_LAYER;
}
void
@ -3994,7 +3994,7 @@ layers_dialog_layer_merge_query (GImage *gimage,
options = (LayerMergeOptions *) g_malloc (sizeof (LayerMergeOptions));
options->gimage = gimage;
options->merge_visible = merge_visible;
options->merge_type = ExpandAsNecessary;
options->merge_type = EXPAND_AS_NECESSARY;
/* the dialog */
options->query_box = gtk_dialog_new ();

4
app/paint-funcs/paint-funcs.h
View File

@ -591,8 +591,8 @@ typedef enum { /*< chop=_MODE >*/
DIFFERENCE_MODE,
ADDITION_MODE,
SUBTRACT_MODE,
DARKEN_ONLY_MODE, /*< nick=DARKEN-ONLY >*/
LIGHTEN_ONLY_MODE, /*< nick=LIGHTEN-ONLY >*/
DARKEN_ONLY_MODE,
LIGHTEN_ONLY_MODE,
HUE_MODE,
SATURATION_MODE,
COLOR_MODE,

4
app/paint_funcs.h
View File

@ -591,8 +591,8 @@ typedef enum { /*< chop=_MODE >*/
DIFFERENCE_MODE,
ADDITION_MODE,
SUBTRACT_MODE,
DARKEN_ONLY_MODE, /*< nick=DARKEN-ONLY >*/
LIGHTEN_ONLY_MODE, /*< nick=LIGHTEN-ONLY >*/
DARKEN_ONLY_MODE,
LIGHTEN_ONLY_MODE,
HUE_MODE,
SATURATION_MODE,
COLOR_MODE,

247
app/parasite_cmds.c
View File

@ -22,6 +22,7 @@
#include "drawable.h"
#include "gimpdrawable.h"
#include "gimpimage.h"
#include "gimpparasite.h"
#include "libgimp/parasite.h"
@ -34,6 +35,10 @@ static ProcRecord drawable_find_parasite_proc;
static ProcRecord drawable_attach_parasite_proc;
static ProcRecord drawable_detach_parasite_proc;
static ProcRecord drawable_parasite_list_proc;
static ProcRecord image_find_parasite_proc;
static ProcRecord image_attach_parasite_proc;
static ProcRecord image_detach_parasite_proc;
static ProcRecord image_parasite_list_proc;
void
register_parasite_procs (void)
@ -47,6 +52,10 @@ register_parasite_procs (void)
procedural_db_register (&drawable_attach_parasite_proc);
procedural_db_register (&drawable_detach_parasite_proc);
procedural_db_register (&drawable_parasite_list_proc);
procedural_db_register (&image_find_parasite_proc);
procedural_db_register (&image_attach_parasite_proc);
procedural_db_register (&image_detach_parasite_proc);
procedural_db_register (&image_parasite_list_proc);
}
static Argument *
@ -374,7 +383,7 @@ static ProcArg drawable_find_parasite_outargs[] =
static ProcRecord drawable_find_parasite_proc =
{
"gimp_drawable_find_parasite",
"Finds the named parasitein a drawable.",
"Finds the named parasite in a drawable",
"Finds and returns the named parasite that was previously attached to a drawable.",
"Jay Cox",
"Jay Cox",
@ -554,3 +563,239 @@ static ProcRecord drawable_parasite_list_proc =
drawable_parasite_list_outargs,
{ { drawable_parasite_list_invoker } }
};
static Argument *
image_find_parasite_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gchar *name;
Parasite *parasite = NULL;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
name = (gchar *) args[1].value.pdb_pointer;
if (success)
{
parasite = parasite_copy (gimp_image_find_parasite (gimage, name));
success = parasite != NULL;
}
return_args = procedural_db_return_args (&image_find_parasite_proc, success);
if (success)
return_args[1].value.pdb_pointer = parasite;
return return_args;
}
static ProcArg image_find_parasite_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_STRING,
"name",
"The name of the parasite to find"
}
};
static ProcArg image_find_parasite_outargs[] =
{
{
PDB_PARASITE,
"parasite",
"The found parasite"
}
};
static ProcRecord image_find_parasite_proc =
{
"gimp_image_find_parasite",
"Finds the named parasite in an image",
"Finds and returns the named parasite that was previously attached to an image.",
"Jay Cox",
"Jay Cox",
"1998",
PDB_INTERNAL,
2,
image_find_parasite_inargs,
1,
image_find_parasite_outargs,
{ { image_find_parasite_invoker } }
};
static Argument *
image_attach_parasite_invoker (Argument *args)
{
gboolean success = TRUE;
GimpImage *gimage;
Parasite *parasite;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
parasite = (Parasite *) args[1].value.pdb_pointer;
if (parasite == NULL)
success = FALSE;
if (success)
gimp_image_attach_parasite (gimage, parasite);
return procedural_db_return_args (&image_attach_parasite_proc, success);
}
static ProcArg image_attach_parasite_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_PARASITE,
"parasite",
"The parasite to attach to an image"
}
};
static ProcRecord image_attach_parasite_proc =
{
"gimp_image_attach_parasite",
"Add a parasite to an image.",
"This procedure attaches a parasite to an image. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
PDB_INTERNAL,
2,
image_attach_parasite_inargs,
0,
NULL,
{ { image_attach_parasite_invoker } }
};
static Argument *
image_detach_parasite_invoker (Argument *args)
{
gboolean success = TRUE;
GimpImage *gimage;
gchar *name;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
name = (gchar *) args[1].value.pdb_pointer;
if (name == NULL)
success = FALSE;
if (success)
gimp_image_detach_parasite (gimage, name);
return procedural_db_return_args (&image_detach_parasite_proc, success);
}
static ProcArg image_detach_parasite_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
},
{
PDB_STRING,
"name",
"The name of the parasite to detach from an image."
}
};
static ProcRecord image_detach_parasite_proc =
{
"gimp_image_detach_parasite",
"Removes a parasite from an image.",
"This procedure detaches a parasite from an image. It has no return values.",
"Jay Cox",
"Jay Cox",
"1998",
PDB_INTERNAL,
2,
image_detach_parasite_inargs,
0,
NULL,
{ { image_detach_parasite_invoker } }
};
static Argument *
image_parasite_list_invoker (Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpImage *gimage;
gint32 num_parasites;
gchar **parasites = NULL;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)
success = FALSE;
if (success)
parasites = gimp_image_parasite_list (gimage, &num_parasites);
return_args = procedural_db_return_args (&image_parasite_list_proc, success);
if (success)
{
return_args[1].value.pdb_int = num_parasites;
return_args[2].value.pdb_pointer = parasites;
}
return return_args;
}
static ProcArg image_parasite_list_inargs[] =
{
{
PDB_IMAGE,
"image",
"The image"
}
};
static ProcArg image_parasite_list_outargs[] =
{
{
PDB_INT32,
"num_parasites",
"The number of attached parasites"
},
{
PDB_STRINGARRAY,
"parasites",
"The names of currently attached parasites"
}
};
static ProcRecord image_parasite_list_proc =
{
"gimp_image_parasite_list",
"List all parasites.",
"Returns a list of all currently attached parasites.",
"Marc Lehmann",
"Marc Lehmann",
"1999",
PDB_INTERNAL,
1,
image_parasite_list_inargs,
2,
image_parasite_list_outargs,
{ { image_parasite_list_invoker } }
};

4
app/tools_cmds.c
View File

@ -257,7 +257,7 @@ static ProcArg blend_inargs[] =
{
PDB_INT32,
"paint_mode",
"The paint application mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The paint application mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
},
{
PDB_INT32,
@ -397,7 +397,7 @@ static ProcArg bucket_fill_inargs[] =
{
PDB_INT32,
"paint_mode",
"The paint application mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN-ONLY (9), LIGHTEN-ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
"The paint application mode: { NORMAL (0), DISSOLVE (1), BEHIND (2), MULTIPLY/BURN (3), SCREEN (4), OVERLAY (5), DIFFERENCE (6), ADDITION (7), SUBTRACT (8), DARKEN_ONLY (9), LIGHTEN_ONLY (10), HUE (11), SATURATION (12), COLOR (13), VALUE (14), DIVIDE/DODGE (15) }"
},
{
PDB_FLOAT,

2
app/widgets/gimpcursor.h
View File

@ -18,6 +18,8 @@
#ifndef __CURSORUTIL_H__
#define __CURSORUTIL_H__
#include <gdk/gdktypes.h>
void change_win_cursor (GdkWindow *, GdkCursorType);
void unset_win_cursor (GdkWindow *);

2
plug-ins/Lighting/lighting_main.c
View File

@ -337,5 +337,5 @@ void lighting_noninteractive(GDrawable *drawable)
printf("Noninteractive not yet implemented! Sorry.\n");
}
MAIN();
MAIN ()

2
plug-ins/MapObject/mapobject_main.c
View File

@ -353,5 +353,5 @@ void mapobject_interactive(GDrawable *drawable)
gdk_flush();
}
MAIN();
MAIN ()

2
plug-ins/common/xbm.c
View File

@ -119,7 +119,7 @@ GPlugInInfo PLUG_IN_INFO =
run, /* run_proc */
};
MAIN ();
MAIN ()
#ifdef VERBOSE
static int verbose = VERBOSE;

2
plug-ins/rcm/rcm.c
View File

@ -85,7 +85,7 @@ GPlugInInfo PLUG_IN_INFO =
/* Dummy function */
/*-----------------------------------------------------------------------------------*/
MAIN();
MAIN()
/*-----------------------------------------------------------------------------------*/
/* Query plug-in */

2
plug-ins/xbm/xbm.c
View File

@ -119,7 +119,7 @@ GPlugInInfo PLUG_IN_INFO =
run, /* run_proc */
};
MAIN ();
MAIN ()
#ifdef VERBOSE
static int verbose = VERBOSE;