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

Cosmetic fixes in waves-anim.scm and app/app_procs.c. 

First set of changes to integrate GAP (Gimp Animation Plugin written
by Michael Hofer)
New functions:  gimp_layer_[get|set]_linked
		gimp_image_raise_layer_to_top
		gimp_image_lower_layer_to_bottom


--Sven
This commit is contained in:
Sven Neumann 1998-11-15 17:02:59 +00:00
parent ee6c165b98
commit 63e3d52df8
27 changed files with 1671 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@ -1,6 +1,22 @@
Sun Nov 15 17:54:18 MET 1998 Sven Neumann <sven@gimp.org>
* plugins/script-fu/scripts/waves-anim.scm: cosmetic fix
* app/app_procs.c: cosmetic fix
* app/gimage.h
* app/gimage_cmds.[ch]
* app/gimpimage.[ch]
* layer_cmds.[ch]
* layers_dialog.c: first set of changes to integrate GAP
(Gimp Animation Plugin written by Michael Hofer)
new functions: gimp_layer_[get|set]_linked
gimp_image_raise_layer_to_top
gimp_image_lower_layer_to_bottom
Sun Nov 15 15:05:22 MET 1998 Sven Neumann <sven@gimp.org>
* app/gdsiplay.h
* app/gdisplay.h
* app/interface.c: fixed my latest changes
1998-11-15 Tuomas Kuosmanen <tigert@gimp.org>

2
app/app_procs.c
View File

@ -288,7 +288,7 @@ splash_text_draw (GtkWidget *widget)
* This is a hack: we try to compute a good guess for the maximum number
* of charcters that will fit into the splash-screen using the given font
*/
max_label_length = (float)strlen (AUTHORS) *
max_label_length = 0.92 * (float)strlen (AUTHORS) *
( (float)logo_area_width / (float)gdk_string_width (font, AUTHORS) );
}

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

159
app/core/gimpimage.c
View File

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

2
app/core/gimpimage.h
View File

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

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

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

2
app/gimage.h
View File

@ -85,6 +85,8 @@ gimage_foreach (GFunc func, gpointer user_data);
#define gimage_pick_correlate_layer gimp_image_pick_correlate_layer
#define gimage_raise_layer gimp_image_raise_layer
#define gimage_lower_layer gimp_image_lower_layer
#define gimage_raise_layer_to_top gimp_image_raise_layer_to_top
#define gimage_lower_layer_to_bottom gimp_image_lower_layer_to_bottom
#define gimage_merge_visible_layers gimp_image_merge_visible_layers
#define gimage_flatten gimp_image_flatten
#define gimage_merge_layers gimp_image_merge_layers

129
app/gimage_cmds.c
View File

@ -1666,6 +1666,135 @@ ProcRecord gimage_lower_layer_proc =
{ { gimage_lower_layer_invoker } },
};
/*******************************/
/* GIMAGE_RAISE_LAYER_TO_TOP */
static Argument *
gimage_raise_layer_to_top_invoker (Argument *args)
{
GImage *gimage;
Layer *layer;
success = TRUE;
if (success)
{
int_value = args[0].value.pdb_int;
if ((gimage = gimage_get_ID (int_value)) == NULL)
success = FALSE;
}
if (success)
{
int_value = args[1].value.pdb_int;
if ((layer = layer_get_ID (int_value)) == NULL)
success = FALSE;
}
if (success)
success = ((gimage_raise_layer_to_top (gimage, layer)) != NULL);
return procedural_db_return_args (&gimage_raise_layer_to_top_proc, success);
}
/* The procedure definition */
ProcArg gimage_raise_layer_to_top_args[] =
{
{ PDB_IMAGE,
"image",
"The image"
},
{ PDB_LAYER,
"layer",
"The layer to raise to top"
}
};
ProcRecord gimage_raise_layer_to_top_proc =
{
"gimp_image_raise_layer_to_top",
"Raise the specified layer in the image's layer stack to top of stack",
"This procedure raises the specified layer to top of the existing layer stack. It will not move the layer if there is no layer above it, or the layer has no alpha channel.",
"Wolfgang Hofer, Sven Neumann",
"Wolfgang Hofer",
"1998",
PDB_INTERNAL,
/* Input arguments */
2,
gimage_raise_layer_to_top_args,
/* Output arguments */
0,
NULL,
/* Exec method */
{ { gimage_raise_layer_to_top_invoker } },
};
/**********************************/
/* GIMAGE_LOWER_LAYER_TO_BOTTOM */
static Argument *
gimage_lower_layer_to_bottom_invoker (Argument *args)
{
GImage *gimage;
Layer *layer;
success = TRUE;
if (success)
{
int_value = args[0].value.pdb_int;
if ((gimage = gimage_get_ID (int_value)) == NULL)
success = FALSE;
}
if (success)
{
int_value = args[1].value.pdb_int;
if ((layer = layer_get_ID (int_value)) == NULL)
success = FALSE;
}
if (success)
success = ((gimage_lower_layer_to_bottom (gimage, layer)) != NULL);
return procedural_db_return_args (&gimage_lower_layer_to_bottom_proc, success);
}
/* The procedure definition */
ProcArg gimage_lower_layer_to_bottom_args[] =
{
{ PDB_IMAGE,
"image",
"The image"
},
{ PDB_LAYER,
"layer",
"The layer to lower to bottom"
}
};
ProcRecord gimage_lower_layer_to_bottom_proc =
{
"gimp_image_lower_layer_to_bottom",
"Lower the specified layer to bottom of the image's layer stack",
"This procedure lowers the specified layer to bottom of the existing layer stack. It will not move the layer if there is no layer below it, or the layer has no alpha channel.",
"Wolfgang Hofer, Sven Neumann",
"Wolfgang Hofer",
"1998",
PDB_INTERNAL,
/* Input arguments */
2,
gimage_lower_layer_to_bottom_args,
/* Output arguments */
0,
NULL,
/* Exec method */
{ { gimage_lower_layer_to_bottom_invoker } },
};
/*********************************/
/* GIMAGE_MERGE_VISIBLE_LAYERS */

2
app/gimage_cmds.h
View File

@ -43,6 +43,8 @@ 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;

159
app/gimpimage.c
View File

@ -1792,6 +1792,165 @@ gimp_image_lower_layer (GimpImage *gimage, Layer *layer_arg)
return NULL;
}
Layer *
gimp_image_raise_layer_to_top (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
list = gimage->layers;
if (list == NULL)
{
/* the layers list is empty */
return NULL;
}
layer = (Layer *) list->data;
if (layer == layer_arg)
{
/* layer_arg is already the top_layer */
g_message ("Layer is already on top");
return NULL;
}
if (! layer_has_alpha (layer_arg))
{
g_message ("cant raise Layer without alpha");
return NULL;
}
list = g_slist_next (list);
/* search for layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_prepend (list, layer_arg);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer;
}
Layer *
gimp_image_lower_layer_to_bottom (GimpImage *gimage, Layer *layer_arg)
{
Layer *layer;
GSList *list;
GSList *next;
GSList *pos;
int x_min, y_min, x_max, y_max;
int off_x, off_y;
int index;
int ex_flag;
list = gimage->layers;
next = NULL; layer = NULL;
ex_flag = 0;
index = 0;
/* 1. loop find layer_arg */
while (list)
{
layer = (Layer *) list->data;
if (layer == layer_arg)
{
break;
}
list = g_slist_next (list);
index++;
}
if (layer != layer_arg)
{
/* The requested layer was not found in the layerstack
* Return without changing anything
*/
return NULL;
}
pos = list;
/* 2. loop: search for the bottom layer and check for alpha */
while (list)
{
next = g_slist_next (list);
if (next == NULL)
{
if (layer == layer_arg)
{
/* there is no next layer below layer_arg */
g_message ("Layer is already on bottom");
}
/* bottom is reached, we can stop now */
break;
}
layer = (Layer *) next->data;
if (layer_has_alpha (layer))
{
ex_flag = 1;
}
else
{
g_message ("BG has no alpha, layer was placed above");
break;
}
list = next;
index++;
}
if (ex_flag == 0)
{
return NULL;
}
list = g_slist_remove (gimage->layers, layer_arg);
gimage->layers = g_slist_insert (list, layer_arg, index);
/* update the affected area (== area of layer_arg) */
drawable_offsets (GIMP_DRAWABLE(layer_arg), &off_x, &off_y);
x_min = off_x;
y_min = off_y;
x_max = off_x + drawable_width (GIMP_DRAWABLE(layer_arg));
y_max = off_y + drawable_height (GIMP_DRAWABLE(layer_arg));
gtk_signal_emit(GTK_OBJECT(gimage),
gimp_image_signals[REPAINT],
x_min, y_min, x_max, y_max);
/* invalidate the composite preview */
gimp_image_invalidate_preview (gimage);
return layer_arg;
}
Layer *

2
app/gimpimage.h
View File

@ -170,6 +170,8 @@ void gimp_image_set_layer_mask_edit (GimpImage *, Layer *, int);
void gimp_image_set_layer_mask_show (GimpImage *, int);
Layer * gimp_image_raise_layer (GimpImage *, Layer *);
Layer * gimp_image_lower_layer (GimpImage *, Layer *);
Layer * gimp_image_raise_layer_to_top (GimpImage *, Layer *);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *, Layer *);
Layer * gimp_image_merge_visible_layers (GimpImage *, MergeType);
Layer * gimp_image_merge_down (GimpImage *, Layer *, MergeType);
Layer * gimp_image_flatten (GimpImage *);

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

@ -155,6 +155,8 @@ static void layers_dialog_unmap_callback (GtkWidget *, gpointer);
static void layers_dialog_new_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_raise_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_lower_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_raise_layer_to_top_callback (GtkWidget *, gpointer);
static void layers_dialog_lower_layer_to_bottom_callback (GtkWidget *, gpointer);
static void layers_dialog_duplicate_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_delete_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_scale_layer_callback (GtkWidget *, gpointer);
@ -253,7 +255,11 @@ static MenuItem layers_ops[] =
layers_dialog_mask_select_callback, NULL, NULL, NULL },
{ "Add Alpha Channel", 0, 0,
layers_dialog_add_alpha_channel_callback, NULL, NULL, NULL },
{ NULL, 0, 0, NULL, NULL, NULL, NULL },
{ "Layer to Top", 'T', GDK_CONTROL_MASK,
layers_dialog_raise_layer_to_top_callback, NULL, NULL, NULL },
{ "Layer to Bottom", 'U', GDK_CONTROL_MASK,
layers_dialog_lower_layer_to_bottom_callback, NULL, NULL, NULL },
{ NULL, 0, 0, NULL, NULL, NULL, NULL },
};
/* the option menu items -- the paint modes */
@ -1233,6 +1239,10 @@ layers_dialog_set_menu_sensitivity ()
gtk_widget_set_sensitive (layers_ops[14].widget, fs && ac && gimage && lm && lp);
/* add alpha */
gtk_widget_set_sensitive (layers_ops[15].widget, !alpha);
/* raise layer to top */
gtk_widget_set_sensitive (layers_ops[16].widget, fs && ac && gimage && lp && alpha);
/* lower layer to bottom */
gtk_widget_set_sensitive (layers_ops[17].widget, fs && ac && gimage && lp);
/* set mode, preserve transparency and opacity to insensitive if there are no layers */
gtk_widget_set_sensitive (layersD->preserve_trans, lp);
@ -1650,6 +1660,42 @@ layers_dialog_lower_layer_callback (GtkWidget *w,
gdisplays_flush ();
}
static void
layers_dialog_raise_layer_to_top_callback (GtkWidget *w,
gpointer client_data)
{
GImage *gimage;
if (!layersD)
return;
if (! (gimage = layersD->gimage))
return;
if (NULL != gimage_raise_layer_to_top (gimage, gimage->active_layer))
{
/* update, only needed if raise was performed */
gdisplays_flush ();
}
}
static void
layers_dialog_lower_layer_to_bottom_callback (GtkWidget *w,
gpointer client_data)
{
GImage *gimage;
if (!layersD)
return;
if (! (gimage = layersD->gimage))
return;
if (NULL != gimage_lower_layer_to_bottom (gimage, gimage->active_layer))
{
/* update, only needed if lower was performed */
gdisplays_flush ();
}
}
static void
layers_dialog_duplicate_layer_callback (GtkWidget *w,

6
app/internal_procs.c
View File

@ -80,7 +80,7 @@ internal_procs_init ()
{
gfloat pcount = 0;
/* grep -c procedural_db_register internal_procs.c */
gfloat total_pcount = 249;
gfloat total_pcount = 253;
app_init_update_status("Internal Procedures", "Tool procedures",
pcount/total_pcount);
@ -159,6 +159,8 @@ internal_procs_init ()
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++;
@ -250,6 +252,8 @@ internal_procs_init ()
procedural_db_register (&layer_mask_proc); pcount++;
procedural_db_register (&layer_is_floating_sel_proc); pcount++;
procedural_db_register (&layer_get_tattoo_proc); pcount++;
procedural_db_register (&layer_get_linked_proc); pcount++;
procedural_db_register (&layer_set_linked_proc); pcount++;
app_init_update_status(NULL, "Channel procedures",
pcount/total_pcount);

130
app/layer_cmds.c
View File

@ -2092,3 +2092,133 @@ ProcRecord layer_get_tattoo_proc =
/* Exec method */
{ { layer_get_tattoo_invoker } },
};
/***********************/
/* LAYER_GET_LINKED */
static Argument *
layer_get_linked_invoker (Argument *args)
{
Layer *layer;
int linked;
Argument *return_args;
linked = FALSE;
success = TRUE;
if (success)
{
int_value = args[0].value.pdb_int;
if ((layer = layer_get_ID (int_value)))
linked = layer_linked(GIMP_LAYER(layer));
else
success = FALSE;
}
return_args = procedural_db_return_args (&layer_get_linked_proc, success);
if (success)
return_args[1].value.pdb_int = linked;
return return_args;
}
/* The procedure definition */
ProcArg layer_get_linked_args[] =
{
{ PDB_LAYER,
"layer",
"the layer"
}
};
ProcArg layer_get_linked_out_args[] =
{
{ PDB_INT32,
"linked",
"the layers linked state (for moves)"
}
};
ProcRecord layer_get_linked_proc =
{
"gimp_layer_get_linked",
"Get the linked state of the specified layer.",
"This procedure returns the specified layer's linked state.",
"Wolfgang Hofer",
"Wolfgang Hofer",
"1998",
PDB_INTERNAL,
/* Input arguments */
1,
layer_get_linked_args,
/* Output arguments */
1,
layer_get_linked_out_args,
/* Exec method */
{ { layer_get_linked_invoker } },
};
/***********************/
/* LAYER_SET_LINKED */
static Argument *
layer_set_linked_invoker (Argument *args)
{
Layer *layer;
int linked;
success = TRUE;
if (success)
{
int_value = args[0].value.pdb_int;
if ((layer = layer_get_ID (int_value)) == NULL)
success = FALSE;
}
if (success)
{
linked = args[1].value.pdb_int;
GIMP_LAYER(layer)->linked = (linked) ? TRUE : FALSE;
}
return procedural_db_return_args (&layer_set_linked_proc, success);
}
/* The procedure definition */
ProcArg layer_set_linked_args[] =
{
{ PDB_LAYER,
"layer",
"the layer"
},
{ PDB_INT32,
"linked",
"the new layer linked state"
}
};
ProcRecord layer_set_linked_proc =
{
"gimp_layer_set_linked",
"Set the linked state of the specified layer.",
"This procedure sets the specified layer's link state.",
"Wolfgang Hofer",
"Wolfgang Hofer",
"1998",
PDB_INTERNAL,
/* Input arguments */
2,
layer_set_linked_args,
/* Output arguments */
0,
NULL,
/* Exec method */
{ { layer_set_linked_invoker } },
};

2
app/layer_cmds.h
View File

@ -48,5 +48,7 @@ extern ProcRecord layer_set_offsets_proc;
extern ProcRecord layer_mask_proc;
extern ProcRecord layer_is_floating_sel_proc;
extern ProcRecord layer_get_tattoo_proc;
extern ProcRecord layer_get_linked_proc;
extern ProcRecord layer_set_linked_proc;
#endif /* __LAYER_CMDS_H__ */

48
app/layers_dialog.c
View File

@ -155,6 +155,8 @@ static void layers_dialog_unmap_callback (GtkWidget *, gpointer);
static void layers_dialog_new_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_raise_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_lower_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_raise_layer_to_top_callback (GtkWidget *, gpointer);
static void layers_dialog_lower_layer_to_bottom_callback (GtkWidget *, gpointer);
static void layers_dialog_duplicate_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_delete_layer_callback (GtkWidget *, gpointer);
static void layers_dialog_scale_layer_callback (GtkWidget *, gpointer);
@ -253,7 +255,11 @@ static MenuItem layers_ops[] =
layers_dialog_mask_select_callback, NULL, NULL, NULL },
{ "Add Alpha Channel", 0, 0,
layers_dialog_add_alpha_channel_callback, NULL, NULL, NULL },
{ NULL, 0, 0, NULL, NULL, NULL, NULL },
{ "Layer to Top", 'T', GDK_CONTROL_MASK,
layers_dialog_raise_layer_to_top_callback, NULL, NULL, NULL },
{ "Layer to Bottom", 'U', GDK_CONTROL_MASK,
layers_dialog_lower_layer_to_bottom_callback, NULL, NULL, NULL },
{ NULL, 0, 0, NULL, NULL, NULL, NULL },
};
/* the option menu items -- the paint modes */
@ -1233,6 +1239,10 @@ layers_dialog_set_menu_sensitivity ()
gtk_widget_set_sensitive (layers_ops[14].widget, fs && ac && gimage && lm && lp);
/* add alpha */
gtk_widget_set_sensitive (layers_ops[15].widget, !alpha);
/* raise layer to top */
gtk_widget_set_sensitive (layers_ops[16].widget, fs && ac && gimage && lp && alpha);
/* lower layer to bottom */
gtk_widget_set_sensitive (layers_ops[17].widget, fs && ac && gimage && lp);
/* set mode, preserve transparency and opacity to insensitive if there are no layers */
gtk_widget_set_sensitive (layersD->preserve_trans, lp);
@ -1650,6 +1660,42 @@ layers_dialog_lower_layer_callback (GtkWidget *w,
gdisplays_flush ();
}
static void
layers_dialog_raise_layer_to_top_callback (GtkWidget *w,
gpointer client_data)
{
GImage *gimage;
if (!layersD)
return;
if (! (gimage = layersD->gimage))
return;
if (NULL != gimage_raise_layer_to_top (gimage, gimage->active_layer))
{
/* update, only needed if raise was performed */
gdisplays_flush ();
}
}
static void
layers_dialog_lower_layer_to_bottom_callback (GtkWidget *w,
gpointer client_data)
{
GImage *gimage;
if (!layersD)
return;
if (! (gimage = layersD->gimage))
return;
if (NULL != gimage_lower_layer_to_bottom (gimage, gimage->active_layer))
{
/* update, only needed if lower was performed */
gdisplays_flush ();
}
}
static void
layers_dialog_duplicate_layer_callback (GtkWidget *w,

2
plug-ins/script-fu/scripts/waves-anim.scm
View File

@ -95,5 +95,5 @@
SF-DRAWABLE "Drawable" 0
SF-ADJUSTMENT "Amplitude" '(10 1 101 1 10 1 0)
SF-ADJUSTMENT "Wavelength" '(10 .10 100 1 10 1 0)
SF-ADJUSTMENT "Number of Frames" '(6 1 512 1 10 1 1)
SF-ADJUSTMENT "Number of Frames" '(6 1 512 1 10 0 1)
SF-TOGGLE "Invert direction?" FALSE)