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

removed "linked" API... ...and added it here. 

2003-12-04  Michael Natterer  <mitch@gimp.org>

	* tools/pdbgen/pdb/layer.pdb: removed "linked" API...
	* tools/pdbgen/pdb/drawable.pdb: ...and added it here.

	* app/pdb/drawable_cmds.c
	* app/pdb/internal_procs.c
	* app/pdb/layer_cmds.c
	* libgimp/gimpdrawable_pdb.[ch]
	* libgimp/gimplayer_pdb.[ch]: regenerated.

	* libgimp/gimpcompat.h: added gimp_layer_*_linked compat #defines.

	* plug-ins/xjt/xjt.c: changed accordingly.

2003-12-04  Michael Natterer  <mitch@gimp.org>

	* libgimp/libgimp-sections.txt
	* libgimp/tmpl/gimpdrawable.sgml
	* libgimp/tmpl/gimplayer.sgml: "linked" moved from layer to drawable.
This commit is contained in:
Michael Natterer 2003-12-04 11:10:20 +00:00 committed by Michael Natterer
parent 79fadead25
commit 8589ff4de8
14 changed files with 243 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,3 +1,18 @@
2003-12-04 Michael Natterer <mitch@gimp.org>
* tools/pdbgen/pdb/layer.pdb: removed "linked" API...
* tools/pdbgen/pdb/drawable.pdb: ...and added it here.
* app/pdb/drawable_cmds.c
* app/pdb/internal_procs.c
* app/pdb/layer_cmds.c
* libgimp/gimpdrawable_pdb.[ch]
* libgimp/gimplayer_pdb.[ch]: regenerated.
* libgimp/gimpcompat.h: added gimp_layer_*_linked compat #defines.
* plug-ins/xjt/xjt.c: changed accordingly.
2003-12-03 Manish Singh <yosh@gimp.org>
* plug-ins/pygimp/gimpmodule.c

108
app/pdb/drawable_cmds.c
View File

@ -63,6 +63,8 @@ static ProcRecord drawable_get_name_proc;
static ProcRecord drawable_set_name_proc;
static ProcRecord drawable_get_visible_proc;
static ProcRecord drawable_set_visible_proc;
static ProcRecord drawable_get_linked_proc;
static ProcRecord drawable_set_linked_proc;
static ProcRecord drawable_get_tattoo_proc;
static ProcRecord drawable_set_tattoo_proc;
static ProcRecord drawable_get_pixel_proc;
@ -97,6 +99,8 @@ register_drawable_procs (Gimp *gimp)
procedural_db_register (gimp, &drawable_set_name_proc);
procedural_db_register (gimp, &drawable_get_visible_proc);
procedural_db_register (gimp, &drawable_set_visible_proc);
procedural_db_register (gimp, &drawable_get_linked_proc);
procedural_db_register (gimp, &drawable_set_linked_proc);
procedural_db_register (gimp, &drawable_get_tattoo_proc);
procedural_db_register (gimp, &drawable_set_tattoo_proc);
procedural_db_register (gimp, &drawable_get_pixel_proc);
@ -1365,6 +1369,110 @@ static ProcRecord drawable_set_visible_proc =
{ { drawable_set_visible_invoker } }
};
static Argument *
drawable_get_linked_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpDrawable *drawable;
drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_DRAWABLE (drawable))
success = FALSE;
return_args = procedural_db_return_args (&drawable_get_linked_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_linked (GIMP_ITEM (drawable));
return return_args;
}
static ProcArg drawable_get_linked_inargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The drawable"
}
};
static ProcArg drawable_get_linked_outargs[] =
{
{
GIMP_PDB_INT32,
"linked",
"The drawable linked state (for moves)"
}
};
static ProcRecord drawable_get_linked_proc =
{
"gimp_drawable_get_linked",
"Get the linked state of the specified drawable.",
"This procedure returns the specified drawable's linked state.",
"Wolfgang Hofer",
"Wolfgang Hofer",
"1998",
GIMP_INTERNAL,
1,
drawable_get_linked_inargs,
1,
drawable_get_linked_outargs,
{ { drawable_get_linked_invoker } }
};
static Argument *
drawable_set_linked_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
GimpDrawable *drawable;
gboolean linked;
drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_DRAWABLE (drawable))
success = FALSE;
linked = args[1].value.pdb_int ? TRUE : FALSE;
if (success)
gimp_item_set_linked (GIMP_ITEM (drawable), linked, TRUE);
return procedural_db_return_args (&drawable_set_linked_proc, success);
}
static ProcArg drawable_set_linked_inargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The drawable"
},
{
GIMP_PDB_INT32,
"linked",
"The new drawable linked state"
}
};
static ProcRecord drawable_set_linked_proc =
{
"gimp_drawable_set_linked",
"Set the linked state of the specified drawable.",
"This procedure sets the specified drawable's linked state.",
"Wolfgang Hofer",
"Wolfgang Hofer",
"1998",
GIMP_INTERNAL,
2,
drawable_set_linked_inargs,
0,
NULL,
{ { drawable_set_linked_invoker } }
};
static Argument *
drawable_get_tattoo_invoker (Gimp *gimp,
Argument *args)

24
app/pdb/internal_procs.c
View File

@ -99,40 +99,40 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Drawable procedures"), 0.125);
register_drawable_procs (gimp);
(* status_callback) (NULL, _("Edit procedures"), 0.212);
(* status_callback) (NULL, _("Edit procedures"), 0.218);
register_edit_procs (gimp);
(* status_callback) (NULL, _("File Operations"), 0.23);
(* status_callback) (NULL, _("File Operations"), 0.235);
register_fileops_procs (gimp);
(* status_callback) (NULL, _("Floating selections"), 0.253);
(* status_callback) (NULL, _("Floating selections"), 0.259);
register_floating_sel_procs (gimp);
(* status_callback) (NULL, _("Font UI"), 0.27);
(* status_callback) (NULL, _("Font UI"), 0.276);
register_font_select_procs (gimp);
(* status_callback) (NULL, _("Fonts"), 0.279);
(* status_callback) (NULL, _("Fonts"), 0.285);
register_fonts_procs (gimp);
(* status_callback) (NULL, _("Gimprc procedures"), 0.285);
(* status_callback) (NULL, _("Gimprc procedures"), 0.291);
register_gimprc_procs (gimp);
(* status_callback) (NULL, _("Gradient UI"), 0.302);
(* status_callback) (NULL, _("Gradient UI"), 0.308);
register_gradient_select_procs (gimp);
(* status_callback) (NULL, _("Gradients"), 0.311);
(* status_callback) (NULL, _("Gradients"), 0.317);
register_gradients_procs (gimp);
(* status_callback) (NULL, _("Guide procedures"), 0.331);
(* status_callback) (NULL, _("Guide procedures"), 0.337);
register_guides_procs (gimp);
(* status_callback) (NULL, _("Help procedures"), 0.349);
(* status_callback) (NULL, _("Help procedures"), 0.355);
register_help_procs (gimp);
(* status_callback) (NULL, _("Image"), 0.352);
(* status_callback) (NULL, _("Image"), 0.358);
register_image_procs (gimp);
(* status_callback) (NULL, _("Layer"), 0.538);
(* status_callback) (NULL, _("Layer"), 0.544);
register_layer_procs (gimp);
(* status_callback) (NULL, _("Message procedures"), 0.613);

108
app/pdb/layer_cmds.c
View File

@ -64,8 +64,6 @@ static ProcRecord layer_get_opacity_proc;
static ProcRecord layer_set_opacity_proc;
static ProcRecord layer_get_mode_proc;
static ProcRecord layer_set_mode_proc;
static ProcRecord layer_get_linked_proc;
static ProcRecord layer_set_linked_proc;
void
register_layer_procs (Gimp *gimp)
@ -94,8 +92,6 @@ register_layer_procs (Gimp *gimp)
procedural_db_register (gimp, &layer_set_opacity_proc);
procedural_db_register (gimp, &layer_get_mode_proc);
procedural_db_register (gimp, &layer_set_mode_proc);
procedural_db_register (gimp, &layer_get_linked_proc);
procedural_db_register (gimp, &layer_set_linked_proc);
}
static Argument *
@ -1637,107 +1633,3 @@ static ProcRecord layer_set_mode_proc =
NULL,
{ { layer_set_mode_invoker } }
};
static Argument *
layer_get_linked_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpLayer *layer;
layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_LAYER (layer))
success = FALSE;
return_args = procedural_db_return_args (&layer_get_linked_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_linked (GIMP_ITEM (layer));
return return_args;
}
static ProcArg layer_get_linked_inargs[] =
{
{
GIMP_PDB_LAYER,
"layer",
"The layer"
}
};
static ProcArg layer_get_linked_outargs[] =
{
{
GIMP_PDB_INT32,
"linked",
"The layer linked state (for moves)"
}
};
static 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",
GIMP_INTERNAL,
1,
layer_get_linked_inargs,
1,
layer_get_linked_outargs,
{ { layer_get_linked_invoker } }
};
static Argument *
layer_set_linked_invoker (Gimp *gimp,
Argument *args)
{
gboolean success = TRUE;
GimpLayer *layer;
gboolean linked;
layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! GIMP_IS_LAYER (layer))
success = FALSE;
linked = args[1].value.pdb_int ? TRUE : FALSE;
if (success)
gimp_item_set_linked (GIMP_ITEM (layer), linked, TRUE);
return procedural_db_return_args (&layer_set_linked_proc, success);
}
static ProcArg layer_set_linked_inargs[] =
{
{
GIMP_PDB_LAYER,
"layer",
"The layer"
},
{
GIMP_PDB_INT32,
"linked",
"The new layer linked state"
}
};
static ProcRecord layer_set_linked_proc =
{
"gimp_layer_set_linked",
"Set the linked state of the specified layer.",
"This procedure sets the specified layer's linked state.",
"Wolfgang Hofer",
"Wolfgang Hofer",
"1998",
GIMP_INTERNAL,
2,
layer_set_linked_inargs,
0,
NULL,
{ { layer_set_linked_invoker } }
};

6
devel-docs/ChangeLog
View File

@ -1,3 +1,9 @@
2003-12-04 Michael Natterer <mitch@gimp.org>
* libgimp/libgimp-sections.txt
* libgimp/tmpl/gimpdrawable.sgml
* libgimp/tmpl/gimplayer.sgml: "linked" moved from layer to drawable.
2003-12-03 Michael Natterer <mitch@gimp.org>
* libgimp/libgimp-sections.txt

4
devel-docs/libgimp/libgimp-sections.txt
View File

@ -178,6 +178,8 @@ gimp_drawable_get_name
gimp_drawable_set_name
gimp_drawable_get_visible
gimp_drawable_set_visible
gimp_drawable_get_linked
gimp_drawable_set_linked
gimp_drawable_get_tattoo
gimp_drawable_set_tattoo
gimp_drawable_get_pixel
@ -407,8 +409,6 @@ gimp_layer_get_opacity
gimp_layer_set_opacity
gimp_layer_get_mode
gimp_layer_set_mode
gimp_layer_get_linked
gimp_layer_set_linked
gimp_layer_get_mask_id
gimp_layer_get_image_id
gimp_layer_is_floating_sel

19
devel-docs/libgimp/tmpl/gimpdrawable.sgml
View File

@ -103,6 +103,25 @@ Functions to manipulate drawables.
@Returns:
<!-- ##### FUNCTION gimp_drawable_get_linked ##### -->
<para>
</para>
@drawable_ID:
@Returns:
<!-- ##### FUNCTION gimp_drawable_set_linked ##### -->
<para>
</para>
@drawable_ID:
@linked:
@Returns:
<!-- ##### FUNCTION gimp_drawable_get_tattoo ##### -->
<para>

19
devel-docs/libgimp/tmpl/gimplayer.sgml
View File

@ -247,25 +247,6 @@ Operations on single layers.
@Returns:
<!-- ##### FUNCTION gimp_layer_get_linked ##### -->
<para>
</para>
@layer_ID:
@Returns:
<!-- ##### FUNCTION gimp_layer_set_linked ##### -->
<para>
</para>
@layer_ID:
@linked:
@Returns:
<!-- ##### MACRO gimp_layer_get_mask_id ##### -->
<para>

2
libgimp/gimpcompat.h
View File

@ -57,6 +57,8 @@ G_BEGIN_DECLS
#define gimp_layer_set_name gimp_drawable_set_name
#define gimp_layer_get_visible gimp_drawable_get_visible
#define gimp_layer_set_visible gimp_drawable_set_visible
#define gimp_layer_get_linked gimp_drawable_get_linked
#define gimp_layer_set_linked gimp_drawable_set_linked
#define gimp_layer_get_tattoo gimp_drawable_get_tattoo
#define gimp_layer_set_tattoo gimp_drawable_set_tattoo

62
libgimp/gimpdrawable_pdb.c
View File

@ -768,6 +768,68 @@ gimp_drawable_set_visible (gint32 drawable_ID,
return success;
}
/**
* gimp_drawable_get_linked:
* @drawable_ID: The drawable.
*
* Get the linked state of the specified drawable.
*
* This procedure returns the specified drawable's linked state.
*
* Returns: The drawable linked state (for moves).
*/
gboolean
gimp_drawable_get_linked (gint32 drawable_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean linked = FALSE;
return_vals = gimp_run_procedure ("gimp_drawable_get_linked",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
linked = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
return linked;
}
/**
* gimp_drawable_set_linked:
* @drawable_ID: The drawable.
* @linked: The new drawable linked state.
*
* Set the linked state of the specified drawable.
*
* This procedure sets the specified drawable's linked state.
*
* Returns: TRUE on success.
*/
gboolean
gimp_drawable_set_linked (gint32 drawable_ID,
gboolean linked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp_drawable_set_linked",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
return success;
}
/**
* gimp_drawable_get_tattoo:
* @drawable_ID: The drawable.

3
libgimp/gimpdrawable_pdb.h
View File

@ -65,6 +65,9 @@ gboolean gimp_drawable_set_name (gint32 drawable_ID,
gboolean gimp_drawable_get_visible (gint32 drawable_ID);
gboolean gimp_drawable_set_visible (gint32 drawable_ID,
gboolean visible);
gboolean gimp_drawable_get_linked (gint32 drawable_ID);
gboolean gimp_drawable_set_linked (gint32 drawable_ID,
gboolean linked);
gint gimp_drawable_get_tattoo (gint32 drawable_ID);
gboolean gimp_drawable_set_tattoo (gint32 drawable_ID,
gint tattoo);

62
libgimp/gimplayer_pdb.c
View File

@ -872,65 +872,3 @@ gimp_layer_set_mode (gint32 layer_ID,
return success;
}
/**
* gimp_layer_get_linked:
* @layer_ID: The layer.
*
* Get the linked state of the specified layer.
*
* This procedure returns the specified layer's linked state.
*
* Returns: The layer linked state (for moves).
*/
gboolean
gimp_layer_get_linked (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean linked = FALSE;
return_vals = gimp_run_procedure ("gimp_layer_get_linked",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
linked = return_vals[1].data.d_int32;
gimp_destroy_params (return_vals, nreturn_vals);
return linked;
}
/**
* gimp_layer_set_linked:
* @layer_ID: The layer.
* @linked: The new layer linked state.
*
* Set the linked state of the specified layer.
*
* This procedure sets the specified layer's linked state.
*
* Returns: TRUE on success.
*/
gboolean
gimp_layer_set_linked (gint32 layer_ID,
gboolean linked)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp_layer_set_linked",
&nreturn_vals,
GIMP_PDB_LAYER, layer_ID,
GIMP_PDB_INT32, linked,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
return success;
}

3
libgimp/gimplayer_pdb.h
View File

@ -79,9 +79,6 @@ gboolean gimp_layer_set_opacity (gint32 laye
GimpLayerModeEffects gimp_layer_get_mode (gint32 layer_ID);
gboolean gimp_layer_set_mode (gint32 layer_ID,
GimpLayerModeEffects mode);
gboolean gimp_layer_get_linked (gint32 layer_ID);
gboolean gimp_layer_set_linked (gint32 layer_ID,
gboolean linked);
G_END_DECLS

28
plug-ins/xjt/xjt.c
View File

@ -1440,7 +1440,7 @@ p_write_layer_prp(const gchar *dirname,
l_param.int_val1 = p_invert(gimp_drawable_get_visible(layer_id));
p_write_prop (fp, PROP_VISIBLE, &l_param, wr_all_prp);
l_param.int_val1 = gimp_layer_get_linked (layer_id);
l_param.int_val1 = gimp_drawable_get_linked (layer_id);
p_write_prop (fp, PROP_LINKED, &l_param, wr_all_prp);
l_param.int_val1 = gimp_layer_get_preserve_transparency(layer_id);
@ -3467,11 +3467,11 @@ load_xjt_image (const gchar *filename)
/* adjust offsets and other layerproperties */
gimp_layer_set_offsets(l_layer_id, l_layer_prp_ptr->offx, l_layer_prp_ptr->offy);
gimp_drawable_set_visible (l_layer_id, l_layer_prp_ptr->visible);
gimp_layer_set_linked (l_layer_id, l_layer_prp_ptr->linked);
gimp_drawable_set_linked (l_layer_id, l_layer_prp_ptr->linked);
gimp_layer_set_preserve_transparency (l_layer_id, l_layer_prp_ptr->preserve_transparency);
if (l_layer_prp_ptr->tattoo >= 0)
{
gimp_drawable_set_tattoo(l_layer_id, l_layer_prp_ptr->tattoo);
gimp_drawable_set_tattoo (l_layer_id, l_layer_prp_ptr->tattoo);
}
if (l_layer_prp_ptr->active_layer)
@ -3480,25 +3480,25 @@ load_xjt_image (const gchar *filename)
}
/* Handle layer parasites */
p_check_and_add_parasite(l_layer_id,
l_dirname,
l_image_prp_ptr->parasite_props,
l_layer_prp_ptr->layer_pos,
XJT_LAYER_PARASITE);
p_check_and_add_parasite (l_layer_id,
l_dirname,
l_image_prp_ptr->parasite_props,
l_layer_prp_ptr->layer_pos,
XJT_LAYER_PARASITE);
/* search for the properties of the layermask */
for(l_channel_prp_ptr = l_image_prp_ptr->mask_props;
l_channel_prp_ptr != NULL;
l_channel_prp_ptr = (t_channel_props *)l_channel_prp_ptr->next)
for (l_channel_prp_ptr = l_image_prp_ptr->mask_props;
l_channel_prp_ptr != NULL;
l_channel_prp_ptr = (t_channel_props *) l_channel_prp_ptr->next)
{
if(l_channel_prp_ptr->channel_pos == l_layer_prp_ptr->layer_pos)
if (l_channel_prp_ptr->channel_pos == l_layer_prp_ptr->layer_pos)
{
/* layermask properties found: load the layermask */
l_jpg_file = g_strdup_printf("%s%clm%d.jpg", l_dirname, G_DIR_SEPARATOR, (int)l_layer_prp_ptr->layer_pos);
l_jpg_file = g_strdup_printf ("%s%clm%d.jpg", l_dirname, G_DIR_SEPARATOR, (int)l_layer_prp_ptr->layer_pos);
if(xjt_debug) printf("XJT-DEBUG: loading layer-mask from file %s\n", l_jpg_file);
l_channel_id = gimp_layer_create_mask(l_layer_id, 0 /* mask_type 0 = WHITE_MASK */ );
l_channel_id = gimp_layer_create_mask (l_layer_id, 0 /* mask_type 0 = WHITE_MASK */ );
/* load should overwrite the layer_mask with data from jpeg file */