Commit 63d3ff38 authored by Michael Natterer's avatar Michael Natterer 😴 Committed by Michael Natterer
Browse files

app/Makefile.am removed

2001-04-18  Michael Natterer  <mitch@gimp.org>

	* app/Makefile.am
	* app/channel_ops.[ch]: removed

	* app/gimpdrawable-offset.[ch]
	* app/gimpimage-duplicate.[ch]: new files without GUI.

	* app/gui/Makefile.am
	* app/gui/offset-dialog.[ch]: new files.

	* app/gui/commands.c
	* app/pdb/channel_ops_cmds.c
	* po/POTFILES.in
	* tools/pdbgen/Makefile.am
	* tools/pdbgen/enums.pl
	* tools/pdbgen/pdb/channel_ops.pdb: changed accordingly.
parent addaad45
2001-04-18 Michael Natterer <mitch@gimp.org>
* app/Makefile.am
* app/channel_ops.[ch]: removed
* app/gimpdrawable-offset.[ch]
* app/gimpimage-duplicate.[ch]: new files without GUI.
* app/gui/Makefile.am
* app/gui/offset-dialog.[ch]: new files.
* app/gui/commands.c
* app/pdb/channel_ops_cmds.c
* po/POTFILES.in
* tools/pdbgen/Makefile.am
* tools/pdbgen/enums.pl
* tools/pdbgen/pdb/channel_ops.pdb: changed accordingly.
2001-04-18 Michael Natterer <mitch@gimp.org>
* app/Makefile.am
......
......@@ -81,8 +81,6 @@ gimp_SOURCES = \
##
## stuff that needs to be split up in core / ui files
##
channel_ops.c \
channel_ops.h \
gdisplay.c \
gdisplay.h \
gdisplay_ops.c \
......@@ -162,6 +160,8 @@ gimp_SOURCES = \
gimpdatalist.h \
gimpdrawable.c \
gimpdrawable.h \
gimpdrawable-offset.c \
gimpdrawable-offset.h \
gimpdrawable-preview.c \
gimpdrawable-preview.h \
gimpgradient.c \
......@@ -174,6 +174,8 @@ gimp_SOURCES = \
gimpimage.h \
gimpimage-convert.c \
gimpimage-convert.h \
gimpimage-duplicate.c \
gimpimage-duplicate.h \
gimpimage-undo.c \
gimpimage-undo.h \
gimplayer.c \
......
......@@ -33,17 +33,17 @@
#include "tools/gimptoolinfo.h"
#include "tools/tool_manager.h"
#include "commands.h"
#include "convert-dialog.h"
#include "errorconsole.h"
#include "info-dialog.h"
#include "info-window.h"
#include "layer-select.h"
#include "offset-dialog.h"
#include "app_procs.h"
#include "commands.h"
#include "context_manager.h"
#include "desaturate.h"
#include "channel_ops.h"
#include "equalize.h"
#include "file-open.h"
#include "file-save.h"
......@@ -55,6 +55,7 @@
#include "gimpdrawable.h"
#include "gimphelp.h"
#include "gimpimage.h"
#include "gimpimage-duplicate.h"
#include "gimplayer.h"
#include "gimprc.h"
#include "gimpui.h"
......@@ -813,7 +814,7 @@ image_offset_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
channel_ops_offset (gdisp->gimage);
offset_dialog_create (gdisp->gimage);
}
void
......@@ -897,7 +898,7 @@ image_duplicate_cmd_callback (GtkWidget *widget,
GDisplay *gdisp;
return_if_no_display (gdisp);
channel_ops_duplicate (gdisp->gimage);
gdisplay_new (gimp_image_duplicate (gdisp->gimage), 0x0101);
}
/***** Layers *****/
......
This diff is collapsed.
......@@ -24,207 +24,23 @@
#include "libgimpcolor/gimpcolor.h"
#include "libgimpmath/gimpmath.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "apptypes.h"
#include "paint-funcs/paint-funcs.h"
#include "apptypes.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"
#include "floating_sel.h"
#include "gdisplay.h"
#include "gimage.h"
#include "gimpchannel.h"
#include "gimpcontext.h"
#include "gimplayer.h"
#include "gimplist.h"
#include "parasitelist.h"
#include "path.h"
#include "gimpdrawable-offset.h"
#include "gimpimage.h"
#include "pixel_region.h"
#include "tile_manager.h"
#include "libgimp/gimpintl.h"
#define ENTRY_WIDTH 60
typedef struct _OffsetDialog OffsetDialog;
struct _OffsetDialog
{
GtkWidget *dlg;
GtkWidget *off_se;
gboolean wrap_around;
ChannelOffsetType fill_type;
GimpImage *gimage;
};
/* Forward declarations */
static void offset_ok_callback (GtkWidget *widget,
gpointer data);
static void offset_cancel_callback (GtkWidget *widget,
gpointer data);
static void offset_halfheight_callback (GtkWidget *widget,
gpointer data);
void
channel_ops_offset (GimpImage* gimage)
{
OffsetDialog *off_d;
GtkWidget *label;
GtkWidget *check;
GtkWidget *push;
GtkWidget *vbox;
GtkWidget *table;
GtkObject *adjustment;
GtkWidget *spinbutton;
GtkWidget *frame;
GtkWidget *radio_button;
GimpDrawable *drawable;
drawable = gimp_image_active_drawable (gimage);
off_d = g_new (OffsetDialog, 1);
off_d->wrap_around = TRUE;
off_d->fill_type = gimp_drawable_has_alpha (drawable);
off_d->gimage = gimage;
off_d->dlg = gimp_dialog_new (_("Offset"), "offset",
gimp_standard_help_func,
"dialogs/offset.html",
GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
_("OK"), offset_ok_callback,
off_d, NULL, NULL, TRUE, FALSE,
_("Cancel"), offset_cancel_callback,
off_d, NULL, NULL, FALSE, TRUE,
NULL);
/* The vbox for first column of options */
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (off_d->dlg)->vbox), vbox);
/* The table for the offsets */
table = gtk_table_new (3, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
/* The offset labels */
label = gtk_label_new (_("Offset X:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (_("Y:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_widget_show (label);
/* The offset sizeentry */
adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2);
gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton),
GTK_SHADOW_NONE);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_widget_set_usize (spinbutton, 75, 0);
off_d->off_se = gimp_size_entry_new (1, gimage->unit, "%a",
TRUE, TRUE, FALSE, 75,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (off_d->off_se),
GTK_SPIN_BUTTON (spinbutton), NULL);
gtk_table_attach_defaults (GTK_TABLE (off_d->off_se), spinbutton,
1, 2, 0, 1);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), off_d->off_se, 1, 2, 0, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (off_d->off_se);
gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (off_d->off_se), GIMP_UNIT_PIXEL);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (off_d->off_se), 0,
gimage->xresolution, FALSE);
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (off_d->off_se), 1,
gimage->yresolution, FALSE);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (off_d->off_se), 0,
-gimage->width, gimage->width);
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (off_d->off_se), 1,
-gimage->height, gimage->height);
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (off_d->off_se), 0,
0, gimage->width);
gimp_size_entry_set_size (GIMP_SIZE_ENTRY (off_d->off_se), 1,
0, gimage->height);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (off_d->off_se), 0, 0);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (off_d->off_se), 1, 0);
gtk_widget_show (table);
/* The wrap around option */
check = gtk_check_button_new_with_label (_("Wrap Around"));
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0);
gtk_widget_show (check);
/* The fill options */
frame =
gimp_radio_group_new2 (TRUE, _("Fill Type"),
gimp_radio_button_update,
&off_d->fill_type, (gpointer) off_d->fill_type,
_("Background"), (gpointer) OFFSET_BACKGROUND, NULL,
_("Transparent"), (gpointer) OFFSET_TRANSPARENT,
&radio_button,
NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
if (! gimp_drawable_has_alpha (drawable))
gtk_widget_set_sensitive (radio_button, FALSE);
/* The by half height and half width option */
push = gtk_button_new_with_label (_("Offset by (x/2),(y/2)"));
gtk_container_set_border_width (GTK_CONTAINER (push), 2);
gtk_box_pack_start (GTK_BOX (vbox), push, FALSE, FALSE, 0);
gtk_widget_show (push);
/* Hook up the wrap around */
gtk_signal_connect (GTK_OBJECT (check), "toggled",
GTK_SIGNAL_FUNC (gimp_toggle_button_update),
&off_d->wrap_around);
gtk_object_set_data (GTK_OBJECT (check), "inverse_sensitive", frame);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), off_d->wrap_around);
/* Hook up the by half */
gtk_signal_connect (GTK_OBJECT (push), "clicked",
(GtkSignalFunc) offset_halfheight_callback,
off_d);
gtk_widget_show (vbox);
gtk_widget_show (off_d->dlg);
}
void
offset (GimpImage *gimage,
GimpDrawable *drawable,
gimp_drawable_offset (GimpDrawable *drawable,
gboolean wrap_around,
ChannelOffsetType fill_type,
gint offset_x,
......@@ -505,365 +321,3 @@ offset (GimpImage *gimage,
gimp_drawable_width (drawable),
gimp_drawable_height (drawable));
}
/*
* Interface callbacks
*/
static void
offset_ok_callback (GtkWidget *widget,
gpointer data)
{
OffsetDialog *off_d;
GimpImage *gimage;
GimpDrawable *drawable;
gint offset_x;
gint offset_y;
off_d = (OffsetDialog *) data;
if ((gimage = off_d->gimage) != NULL)
{
drawable = gimp_image_active_drawable (gimage);
offset_x = (gint)
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (off_d->off_se), 0));
offset_y = (gint)
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (off_d->off_se), 1));
offset (gimage, drawable, off_d->wrap_around, off_d->fill_type,
offset_x, offset_y);
gdisplays_flush ();
}
gtk_widget_destroy (off_d->dlg);
g_free (off_d);
}
static void
offset_cancel_callback (GtkWidget *widget,
gpointer data)
{
OffsetDialog *off_d;
off_d = (OffsetDialog *) data;
gtk_widget_destroy (off_d->dlg);
g_free (off_d);
}
static void
offset_halfheight_callback (GtkWidget *widget,
gpointer data)
{
OffsetDialog *off_d;
GimpImage *gimage;
off_d = (OffsetDialog *) data;
gimage = off_d->gimage;
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (off_d->off_se),
0, gimage->width / 2);
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (off_d->off_se),
1, gimage->height / 2);
}
GimpImage *
duplicate (GimpImage *gimage)
{
PixelRegion srcPR, destPR;
GimpImage *new_gimage;
GimpLayer *layer, *new_layer;
GimpLayer *floating_layer;
GimpChannel *channel, *new_channel;
GList *list;
Guide *guide = NULL;
GimpLayer *active_layer = NULL;
GimpChannel *active_channel = NULL;
GimpDrawable *new_floating_sel_drawable = NULL;
GimpDrawable *floating_sel_drawable = NULL;
ParasiteList *parasites;
PathList *paths;
gint count;
gimp_add_busy_cursors_until_idle ();
/* Create a new image */
new_gimage = gimage_new (gimage->width, gimage->height, gimage->base_type);
gimp_image_undo_disable (new_gimage);
/* Copy resolution and unit information */
new_gimage->xresolution = gimage->xresolution;
new_gimage->yresolution = gimage->yresolution;
new_gimage->unit = gimage->unit;
/* Copy floating layer */
floating_layer = gimp_image_floating_sel (gimage);
if (floating_layer)
{
floating_sel_relax (floating_layer, FALSE);
floating_sel_drawable = floating_layer->fs.drawable;
floating_layer = NULL;
}
/* Copy the layers */
for (list = GIMP_LIST (gimage->layers)->list, count = 0;
list;
list = g_list_next (list), count++)
{
layer = (GimpLayer *) list->data;
new_layer = gimp_layer_copy (layer, FALSE);
gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage);
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (GIMP_OBJECT (layer)));
/* Make sure if the layer has a layer mask, it's name isn't screwed up */
if (new_layer->mask)
{
gimp_object_set_name (GIMP_OBJECT (new_layer->mask),
gimp_object_get_name (GIMP_OBJECT (layer->mask)));
}
if (gimp_image_get_active_layer (gimage) == layer)
active_layer = new_layer;
if (gimage->floating_sel == layer)
floating_layer = new_layer;
if (floating_sel_drawable == GIMP_DRAWABLE (layer))
new_floating_sel_drawable = GIMP_DRAWABLE (new_layer);
/* Add the layer */
if (floating_layer != new_layer)
gimp_image_add_layer (new_gimage, new_layer, count);
}
/* Copy the channels */
for (list = GIMP_LIST (gimage->channels)->list, count = 0;
list;
list = g_list_next (list), count++)
{
channel = (GimpChannel *) list->data;
new_channel = gimp_channel_copy (channel, TRUE);
gimp_drawable_set_gimage (GIMP_DRAWABLE (new_channel), new_gimage);
/* Make sure the copied channel doesn't say: "<old channel> copy" */
gimp_object_set_name (GIMP_OBJECT (new_channel),
gimp_object_get_name (GIMP_OBJECT (channel)));
if (gimp_image_get_active_channel (gimage) == channel)
active_channel = (new_channel);
if (floating_sel_drawable == GIMP_DRAWABLE (channel))
new_floating_sel_drawable = GIMP_DRAWABLE (new_channel);
/* Add the channel */
gimp_image_add_channel (new_gimage, new_channel, count);
}
/* Copy the selection mask */
pixel_region_init (&srcPR,
gimp_drawable_data (GIMP_DRAWABLE (gimage->selection_mask)),
0, 0, gimage->width, gimage->height, FALSE);
pixel_region_init (&destPR,
gimp_drawable_data (GIMP_DRAWABLE (new_gimage->selection_mask)),
0, 0, gimage->width, gimage->height, TRUE);
copy_region (&srcPR, &destPR);
new_gimage->selection_mask->bounds_known = FALSE;
new_gimage->selection_mask->boundary_known = FALSE;
/* Set active layer, active channel */
if (active_layer)
gimp_image_set_active_layer (new_gimage, active_layer);
if (active_channel)
gimp_image_set_active_channel (new_gimage, active_channel);
if (floating_layer)
floating_sel_attach (floating_layer, new_floating_sel_drawable);
/* Copy the colormap if necessary */
if (new_gimage->base_type == INDEXED)
memcpy (new_gimage->cmap, gimage->cmap, gimage->num_cols * 3);
new_gimage->num_cols = gimage->num_cols;
/* copy state of all color channels */
for (count = 0; count < MAX_CHANNELS; count++)
{
new_gimage->visible[count] = gimage->visible[count];
new_gimage->active[count] = gimage->active[count];
}
/* Copy any Guides */
for (list = gimage->guides; list; list = g_list_next (list))
{
Guide* new_guide;
guide = (Guide*) list->data;
switch (guide->orientation)
{
case ORIENTATION_HORIZONTAL:
new_guide = gimp_image_add_hguide (new_gimage);
new_guide->position = guide->position;
break;
case ORIENTATION_VERTICAL:
new_guide = gimp_image_add_vguide (new_gimage);
new_guide->position = guide->position;
break;
default:
g_error ("Unknown guide orientation.\n");
}
}
/* Copy the qmask info */
new_gimage->qmask_state = gimage->qmask_state;
new_gimage->qmask_color = gimage->qmask_color;
/* Copy parasites */
parasites = gimage->parasites;
if (parasites)
new_gimage->parasites = parasite_list_copy (parasites);
/* Copy paths */
paths = gimp_image_get_paths (gimage);
if (paths)
{
GSList *plist = NULL;
GSList *new_plist = NULL;
Path *path;
PathList *new_paths;
for (plist = paths->bz_paths; plist; plist = plist->next)
{
path = plist->data;
new_plist = g_slist_append (new_plist, path_copy (new_gimage, path));
}
new_paths = path_list_new (new_gimage, paths->last_selected_row, new_plist);
gimp_image_set_paths (new_gimage, new_paths);
}
gimp_image_undo_enable (new_gimage);
return new_gimage;
}
#ifdef I_LIKE_BOGUS_CRAP
static void
duplicate_projection (GimpImage *oldgimage,
GimpImage *newgimage,
GDisplay *newgdisplay)
{
PixelRegion srcPR, destPR;
/* Copy-on-write the projection tilemanager so we don't have
* to reproject the new gimage - since if we do the duplicate
* operation correctly, the projection for the new gimage is
* identical to that of the source. (Is this true? View-only
* attributes vs. image meta-attributes? -- View-only attributes
* *should* strictly be applied post-projection.)
*/
#if 0
newgimage->construct_flag = oldgimage->construct_flag;
g_warning("CONSTR:%d %dx%dx%d",newgimage->construct_flag,
tile_manager_level_width(gimp_image_projection (newgimage)),
tile_manager_level_height(gimp_image_projection (newgimage)),
tile_manager_level_bpp(gimp_image_projection (newgimage))
);
gdisplay_expose_area(newgdisplay,
newgdisplay->disp_xoffset, newgdisplay->disp_yoffset,
newgdisplay->disp_width, newgdisplay->disp_height);
if (newgimage->construct_flag)
#endif
{
tile_manager_set_user_data(gimp_image_projection (newgimage),
(void *) newgimage);
/*
newgimage->proj_type = oldgimage->proj_type;
newgimage->proj_bytes = oldgimage->proj_bytes;
newgimage->proj_level = oldgimage->proj_level;
gimage_projection_realloc (new_gimage);*/
pixel_region_init (&srcPR, gimp_image_projection (oldgimage), 0, 0,
oldgimage->width, oldgimage->height, FALSE);
pixel_region_init (&destPR, gimp_image_projection (newgimage), 0, 0,
newgimage->width, newgimage->height, TRUE);
copy_region(&srcPR, &destPR);
/*
pixel_region_init (&srcPR, gimp_image_projection (oldgimage),
newgdisplay->disp_xoffset, newgdisplay->disp_yoffset,
newgdisplay->disp_width, newgdisplay->disp_height,