mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-22 20:41:43 +00:00
9b7d21dab5
Wed Jun 23 23:52:54 BST 1999 Andy Thomas <alt@gimp.org> * gimp/app/gimppreviewcache.c * gimp/app/gimppreviewcache.h * gimp/app/drawable_cmds.c * gimp/app/gdisplay.c * gimp/app/gimpdrawableP.h * gimp/app/gimage_cmds.c * gimp/app/Makefile.am * gimp/app/layers_dialog.c * gimp/app/channel.c * gimp/app/lc_dialog.c * gimp/app/lc_dialog.h * gimp/app/lc_dialogP.h * gimp/app/layer.c * gimp/app/gimpdrawable.c * gimp/app/internal_procs.c * gimp/libgimp/gimp.h * gimp/libgimp/gimpimage.c * gimp/libgimp/gimpdrawable.c * gimp/libgimp/gimpmenu.c * gimp/tools/pdbgen/pdb/drawable.pdb * gimp/tools/pdbgen/pdb/gimage.pdb Added thumbnail image preview functions. Previews are visible on the L&C&P dialogs as well as in the drawables/channels/ menus generated for plugins (see the bumpmap & Mapobject plugins). PDB interface exists to simply extract a thumbnail preview of a given size. This is much quicker & more efficient than getting the image data tile-by-tile if you only need a small image since a "preview cache" has been implemented. This cache also reduces the number of times the tiles cached is scanned since smaller previews are always generated from large ones if they exists and are valid. Some possible usages (I don't intend to implement these ideas. Just suggestions). More plugins using the thumbnail preview (ie any that use multiple images). Indication of "active image" somewhere..... Actually almost anywhere a drawable/image name appears.
1167 lines
25 KiB
C
1167 lines
25 KiB
C
/* LIBGIMP - The GIMP Library
|
|
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
#include <string.h>
|
|
#include "gimp.h"
|
|
|
|
|
|
gint32
|
|
gimp_image_add_hguide (gint32 image_id,
|
|
gint32 yposition)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 guide_id;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_add_hguide",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, yposition,
|
|
PARAM_END);
|
|
|
|
guide_id = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
guide_id = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return guide_id;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_add_vguide (gint32 image_id,
|
|
gint32 xposition)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 guide_id;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_add_vguide",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, xposition,
|
|
PARAM_END);
|
|
|
|
guide_id = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
guide_id = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return guide_id;
|
|
}
|
|
|
|
void
|
|
gimp_image_delete_guide (gint32 image_id,
|
|
gint32 guide_id)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_delete_guide",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, guide_id,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
gint32
|
|
gimp_image_find_next_guide (gint32 image_id,
|
|
gint32 guide_id)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 rtn_guide_id;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_find_next_guide",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, guide_id,
|
|
PARAM_END);
|
|
|
|
rtn_guide_id = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
rtn_guide_id = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return rtn_guide_id;
|
|
}
|
|
|
|
GOrientation
|
|
gimp_image_get_guide_orientation (gint32 image_id,
|
|
gint32 guide_id)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
GOrientation rtn_guide_orientation;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_guide_orientation",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, guide_id,
|
|
PARAM_END);
|
|
|
|
rtn_guide_orientation = ORIENTATION_UNKNOWN;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
rtn_guide_orientation = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return rtn_guide_orientation;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_guide_position (gint32 image_id,
|
|
gint32 guide_id)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 rtn_guide_position;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_guide_position",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_id,
|
|
PARAM_INT32, guide_id,
|
|
PARAM_END);
|
|
|
|
rtn_guide_position = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
rtn_guide_position = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return rtn_guide_position;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
gint32
|
|
gimp_image_new (guint width,
|
|
guint height,
|
|
GImageType type)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 image_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_new",
|
|
&nreturn_vals,
|
|
PARAM_INT32, width,
|
|
PARAM_INT32, height,
|
|
PARAM_INT32, type,
|
|
PARAM_END);
|
|
|
|
image_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
image_ID = return_vals[1].data.d_image;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return image_ID;
|
|
}
|
|
|
|
void
|
|
gimp_image_delete (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_delete",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
guint
|
|
gimp_image_width (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
int result;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_width",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
result = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
result = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return result;
|
|
}
|
|
|
|
guint
|
|
gimp_image_height (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
int result;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_height",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
result = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
result = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return result;
|
|
}
|
|
|
|
GImageType
|
|
gimp_image_base_type (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
int result;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_base_type",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
result = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
result = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return result;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_floating_selection (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_floating_selection",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
layer_ID = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer_ID = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer_ID;
|
|
}
|
|
|
|
void
|
|
gimp_image_add_channel (gint32 image_ID,
|
|
gint32 channel_ID,
|
|
int position)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_add_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_CHANNEL, channel_ID,
|
|
PARAM_INT32, position,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_add_layer (gint32 image_ID,
|
|
gint32 layer_ID,
|
|
int position)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_add_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_INT32, position,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_add_layer_mask (gint32 image_ID,
|
|
gint32 layer_ID,
|
|
gint32 mask_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_add_layer_mask",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_CHANNEL, mask_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_disable_undo (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_disable_undo",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_enable_undo (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_enable_undo",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_undo_push_group_start (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_undo_push_group_start",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_undo_push_group_end (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_undo_push_group_end",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_clean_all (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_clean_all",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
gint32
|
|
gimp_image_flatten (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_flatten",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
layer_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer_ID = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer_ID;
|
|
}
|
|
|
|
void
|
|
gimp_image_lower_channel (gint32 image_ID,
|
|
gint32 channel_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_lower_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_CHANNEL, channel_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_lower_layer (gint32 image_ID,
|
|
gint32 layer_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_lower_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
gint32
|
|
gimp_image_merge_visible_layers (gint32 image_ID,
|
|
gint merge_type)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_merge_visible_layers",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, merge_type,
|
|
PARAM_END);
|
|
|
|
layer_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer_ID = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer_ID;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_pick_correlate_layer (gint32 image_ID,
|
|
gint x,
|
|
gint y)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_pick_correlate_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, x,
|
|
PARAM_INT32, y,
|
|
PARAM_END);
|
|
|
|
layer_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer_ID = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer_ID;
|
|
}
|
|
|
|
void
|
|
gimp_image_raise_channel (gint32 image_ID,
|
|
gint32 channel_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_raise_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_CHANNEL, channel_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_raise_layer (gint32 image_ID,
|
|
gint32 layer_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_raise_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_remove_channel (gint32 image_ID,
|
|
gint32 channel_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_remove_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_CHANNEL, channel_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_remove_layer (gint32 image_ID,
|
|
gint32 layer_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_remove_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_remove_layer_mask (gint32 image_ID,
|
|
gint32 layer_ID,
|
|
gint mode)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_remove_layer_mask",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_INT32, mode,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_resize (gint32 image_ID,
|
|
guint new_width,
|
|
guint new_height,
|
|
gint offset_x,
|
|
gint offset_y)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_resize",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, new_width,
|
|
PARAM_INT32, new_height,
|
|
PARAM_INT32, offset_x,
|
|
PARAM_INT32, offset_y,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_active_channel (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 channel_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_active_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
channel_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
channel_ID = return_vals[1].data.d_channel;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return channel_ID;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_active_layer (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_active_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
layer_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer_ID = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer_ID;
|
|
}
|
|
|
|
gint32*
|
|
gimp_image_get_channels (gint32 image_ID,
|
|
gint *nchannels)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 *channels;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_channels",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
channels = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
*nchannels = return_vals[1].data.d_int32;
|
|
channels = g_new (gint32, *nchannels);
|
|
memcpy (channels, return_vals[2].data.d_int32array, *nchannels * 4);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return channels;
|
|
}
|
|
|
|
guchar*
|
|
gimp_image_get_cmap (gint32 image_ID,
|
|
gint *ncolors)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
guchar *cmap;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_cmap",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
cmap = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
*ncolors = return_vals[1].data.d_int32 / 3;
|
|
cmap = g_new (guchar, *ncolors * 3);
|
|
memcpy (cmap, return_vals[2].data.d_int8array, *ncolors * 3);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return cmap;
|
|
}
|
|
|
|
gint
|
|
gimp_image_get_component_active (gint32 image_ID,
|
|
gint component)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
int result;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_component_active",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
result = FALSE;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
result = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return result;
|
|
}
|
|
|
|
gint
|
|
gimp_image_get_component_visible (gint32 image_ID,
|
|
gint component)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
int result;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_component_visible",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
result = FALSE;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
result = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return result;
|
|
}
|
|
|
|
char*
|
|
gimp_image_get_filename (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
char *filename;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_filename",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
filename = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
filename = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return filename;
|
|
}
|
|
|
|
gint32*
|
|
gimp_image_get_layers (gint32 image_ID,
|
|
gint *nlayers)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 *layers;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_layers",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
layers = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
*nlayers = return_vals[1].data.d_int32;
|
|
layers = g_new (gint32, *nlayers);
|
|
memcpy (layers, return_vals[2].data.d_int32array, *nlayers * 4);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layers;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_selection (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 selection_ID;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_selection",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
selection_ID = -1;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
selection_ID = return_vals[1].data.d_selection;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return selection_ID;
|
|
}
|
|
|
|
void
|
|
gimp_image_set_active_channel (gint32 image_ID,
|
|
gint32 channel_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
if (channel_ID == -1)
|
|
{
|
|
return_vals = gimp_run_procedure ("gimp_image_unset_active_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
}
|
|
else
|
|
{
|
|
return_vals = gimp_run_procedure ("gimp_image_set_active_channel",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_CHANNEL, channel_ID,
|
|
PARAM_END);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_set_active_layer (gint32 image_ID,
|
|
gint32 layer_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_active_layer",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_LAYER, layer_ID,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_set_cmap (gint32 image_ID,
|
|
guchar *cmap,
|
|
gint ncolors)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_cmap",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, ncolors * 3,
|
|
PARAM_INT8ARRAY, cmap,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_set_component_active (gint32 image_ID,
|
|
gint component,
|
|
gint active)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_component_active",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, component,
|
|
PARAM_INT32, active,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_set_component_visible (gint32 image_ID,
|
|
gint component,
|
|
gint visible)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_component_visible",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, component,
|
|
PARAM_INT32, visible,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_set_filename (gint32 image_ID,
|
|
char *name)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_filename",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_STRING, name,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
Parasite *
|
|
gimp_image_find_parasite (gint32 image_ID, const char *name)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
Parasite *parasite;
|
|
return_vals = gimp_run_procedure ("gimp_image_find_parasite",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_STRING, name,
|
|
PARAM_END);
|
|
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
parasite = parasite_copy(&return_vals[1].data.d_parasite);
|
|
}
|
|
else
|
|
parasite = NULL;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return parasite;
|
|
}
|
|
|
|
void
|
|
gimp_image_attach_parasite (gint32 image_ID, const Parasite *p)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_PARASITE, p,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_attach_new_parasite (gint32 image_ID, const char *name, int flags,
|
|
int size, const void *data)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
Parasite *p = parasite_new(name, flags, size, data);
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_attach_parasite",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_PARASITE, p,
|
|
PARAM_END);
|
|
|
|
parasite_free(p);
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_detach_parasite (gint32 image_ID, const char *name)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_detach_parasite",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_STRING, name,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
void
|
|
gimp_image_get_resolution (gint32 image_ID,
|
|
double *xresolution,
|
|
double *yresolution)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
double xres;
|
|
double yres;
|
|
|
|
g_return_if_fail (xresolution && yresolution);
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_resolution",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
/* error return values */
|
|
xres = 0.0;
|
|
yres = 0.0;
|
|
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
xres = return_vals[1].data.d_float;
|
|
yres = return_vals[2].data.d_float;
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
*xresolution = xres;
|
|
*yresolution = yres;
|
|
}
|
|
|
|
void
|
|
gimp_image_set_resolution (gint32 image_ID,
|
|
double xresolution,
|
|
double yresolution)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_resolution",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_FLOAT, xresolution,
|
|
PARAM_FLOAT, yresolution,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
GUnit
|
|
gimp_image_get_unit (gint32 image_ID)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
GUnit unit;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_unit",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_END);
|
|
|
|
/* error return value */
|
|
unit = UNIT_INCH;
|
|
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
unit = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return unit;
|
|
}
|
|
|
|
void
|
|
gimp_image_set_unit (gint32 image_ID,
|
|
GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_set_unit",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_layer_by_tattoo (gint32 image_ID, gint32 tattoo)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 layer = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_layer_by_tattoo",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, tattoo,
|
|
PARAM_END);
|
|
|
|
layer = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
layer = return_vals[1].data.d_layer;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return layer;
|
|
}
|
|
|
|
gint32
|
|
gimp_image_get_channel_by_tattoo (gint32 image_ID, gint32 tattoo)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gint32 channel = 0;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_get_channel_by_tattoo",
|
|
&nreturn_vals,
|
|
PARAM_IMAGE, image_ID,
|
|
PARAM_INT32, tattoo,
|
|
PARAM_END);
|
|
|
|
channel = 0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
channel = return_vals[1].data.d_channel;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return channel;
|
|
}
|
|
|
|
guchar *
|
|
gimp_image_get_thumbnail_data (gint32 image_ID,
|
|
gint *width,
|
|
gint *height,
|
|
gint *bytes)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
gchar *image_data = NULL;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_image_thumbnail",
|
|
&nreturn_vals,
|
|
PARAM_DRAWABLE, image_ID,
|
|
PARAM_INT32, *width,
|
|
PARAM_INT32, *height,
|
|
PARAM_END);
|
|
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
{
|
|
*width = return_vals[1].data.d_int32;
|
|
*height = return_vals[2].data.d_int32;
|
|
*bytes = return_vals[3].data.d_int32;
|
|
image_data = g_new (gchar,return_vals[4].data.d_int32);
|
|
g_memmove (image_data, return_vals[5].data.d_int32array,return_vals[4].data.d_int32);
|
|
}
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return image_data;
|
|
|
|
}
|
|
|