eUgEntOptIc44/gimp
1
1
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-10-05 21:02:42 +02:00
Code Issues Releases Activity

pdb, app, libgimp, libgimpconfig: Stroke/Fill Vector Layer PDB

Browse Source 
This patch adds additional API for setting the stroke/fill
properties of vector layers. You can now set/get color, stroke
width and stroke style via the PDB. Pattern get/set API is not
yet implemented.

This patch also updates a missing parameter check for GimpVectorLayer
in gimp_config_param_spec_duplicate (), and adds additional API
in /app to make it easier to safely retrieve GimpVectorLayerOptions.
This commit is contained in:
Alx Sa
2025-09-15 14:14:46 +00:00
parent 64e276c3b5
commit 602300ec8e
9 changed files with 4146 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1583
app/path/gimpvectorlayer.c
View File

File diff suppressed because it is too large Load Diff

136
app/path/gimpvectorlayer.h
View File

@@ -1,67 +1,69 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpvectorlayer.h
*
* Copyright 2006 Hendrik Boom
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_VECTOR_LAYER_H__
#define __GIMP_VECTOR_LAYER_H__
#include "core/gimplayer.h"
#define GIMP_TYPE_VECTOR_LAYER (gimp_vector_layer_get_type ())
#define GIMP_VECTOR_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayer))
#define GIMP_VECTOR_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayerClass))
#define GIMP_IS_VECTOR_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTOR_LAYER))
#define GIMP_IS_VECTOR_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTOR_LAYER))
#define GIMP_VECTOR_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayerClass))
typedef struct _GimpVectorLayerClass GimpVectorLayerClass;
struct _GimpVectorLayer
{
GimpLayer parent_instance;
GimpVectorLayerOptions *options;
gboolean modified;
};
struct _GimpVectorLayerClass
{
GimpLayerClass parent_class;
};
GType gimp_vector_layer_get_type (void) G_GNUC_CONST;
GimpVectorLayer * gimp_vector_layer_new (GimpImage *image,
GimpPath *path,
GimpContext *context);
GimpPath * gimp_vector_layer_get_path (GimpVectorLayer *layer);
void gimp_vector_layer_refresh (GimpVectorLayer *layer);
void gimp_vector_layer_discard (GimpVectorLayer *layer);
gboolean gimp_item_is_vector_layer (GimpItem *item);
#endif /* __GIMP_VECTOR_LAYER_H__ */
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpvectorlayer.h
*
* Copyright 2006 Hendrik Boom
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_VECTOR_LAYER_H__
#define __GIMP_VECTOR_LAYER_H__
#include "core/gimplayer.h"
#define GIMP_TYPE_VECTOR_LAYER (gimp_vector_layer_get_type ())
#define GIMP_VECTOR_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayer))
#define GIMP_VECTOR_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayerClass))
#define GIMP_IS_VECTOR_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTOR_LAYER))
#define GIMP_IS_VECTOR_LAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTOR_LAYER))
#define GIMP_VECTOR_LAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTOR_LAYER, GimpVectorLayerClass))
typedef struct _GimpVectorLayerClass GimpVectorLayerClass;
struct _GimpVectorLayer
{
GimpLayer parent_instance;
GimpVectorLayerOptions *options;
gboolean modified;
};
struct _GimpVectorLayerClass
{
GimpLayerClass parent_class;
};
GType gimp_vector_layer_get_type (void) G_GNUC_CONST;
GimpVectorLayer * gimp_vector_layer_new (GimpImage *image,
GimpPath *path,
GimpContext *context);
GimpPath * gimp_vector_layer_get_path (GimpVectorLayer *layer);
GimpVectorLayerOptions * gimp_vector_layer_get_options (GimpVectorLayer *layer);
void gimp_vector_layer_refresh (GimpVectorLayer *layer);
void gimp_vector_layer_discard (GimpVectorLayer *layer);
gboolean gimp_item_is_vector_layer (GimpItem *item);
#endif /* __GIMP_VECTOR_LAYER_H__ */

2
app/pdb/internal-procs.c
View File

@@ -30,7 +30,7 @@
#include "internal-procs.h"
/* 729 procedures registered total */
/* 752 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)

1499
app/pdb/vector-layer-cmds.c
View File

File diff suppressed because it is too large Load Diff

23
libgimp/gimp.def
View File

@@ -1075,9 +1075,32 @@ EXPORTS
gimp_user_time
gimp_vector_layer_discard
gimp_vector_layer_get_by_id
gimp_vector_layer_get_enable_fill
gimp_vector_layer_get_enable_stroke
gimp_vector_layer_get_fill_color
gimp_vector_layer_get_path
gimp_vector_layer_get_stroke_cap_style
gimp_vector_layer_get_stroke_color
gimp_vector_layer_get_stroke_dash_offset
gimp_vector_layer_get_stroke_dash_pattern
gimp_vector_layer_get_stroke_join_style
gimp_vector_layer_get_stroke_miter_limit
gimp_vector_layer_get_stroke_width
gimp_vector_layer_get_stroke_width_unit
gimp_vector_layer_get_type
gimp_vector_layer_new
gimp_vector_layer_refresh
gimp_vector_layer_set_enable_fill
gimp_vector_layer_set_enable_stroke
gimp_vector_layer_set_fill_color
gimp_vector_layer_set_stroke_cap_style
gimp_vector_layer_set_stroke_color
gimp_vector_layer_set_stroke_dash_offset
gimp_vector_layer_set_stroke_dash_pattern
gimp_vector_layer_set_stroke_join_style
gimp_vector_layer_set_stroke_miter_limit
gimp_vector_layer_set_stroke_width
gimp_vector_layer_set_stroke_width_unit
gimp_vector_load_procedure_extract_dimensions
gimp_vector_load_procedure_get_type
gimp_vector_load_procedure_new

869
libgimp/gimpvectorlayer_pdb.c
View File

@@ -157,3 +157,872 @@ gimp_vector_layer_discard (GimpVectorLayer *layer)
return success;
}
/**
* gimp_vector_layer_get_enable_fill:
* @layer: The vector layer.
*
* Check if fill is enabled in the vector layer.
*
* This procedure checks if fill is enabled in the specified vector
* layer.
*
* Returns: If the fill is enabled on the vector layer.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_get_enable_fill (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enable_fill = FALSE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-enable-fill",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
enable_fill = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);
gimp_value_array_unref (return_vals);
return enable_fill;
}
/**
* gimp_vector_layer_get_enable_stroke:
* @layer: The vector layer.
*
* Check if stroke is enabled in the vector layer.
*
* This procedure checks if stroke is enabled in the specified vector
* layer.
*
* Returns: If the stroke is enabled on the vector layer.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_get_enable_stroke (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean enable_stroke = FALSE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-enable-stroke",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
enable_stroke = GIMP_VALUES_GET_BOOLEAN (return_vals, 1);
gimp_value_array_unref (return_vals);
return enable_stroke;
}
/**
* gimp_vector_layer_get_fill_color:
* @layer: The vector layer.
*
* Get the color of the fill in a vector layer.
*
* This procedure returns the color of the fill in a vector layer.
*
* Returns: (transfer full): The color of the fill.
*
* Since: 2.6
**/
GeglColor *
gimp_vector_layer_get_fill_color (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GeglColor *color = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-fill-color",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
color = g_value_dup_object (gimp_value_array_index (return_vals, 1));
gimp_value_array_unref (return_vals);
return color;
}
/**
* gimp_vector_layer_get_path:
* @layer: The vector layer.
*
* Gets the path from the vector layer if one is associated with it.
*
* This procedure returns the path from the vector layer if one is
* associated with it.
*
* Returns: (transfer none): The path associated with the vector layer.
*
* Since: 3.2
**/
GimpPath *
gimp_vector_layer_get_path (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpPath *path = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-path",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
path = GIMP_VALUES_GET_PATH (return_vals, 1);
gimp_value_array_unref (return_vals);
return path;
}
/**
* gimp_vector_layer_get_stroke_cap_style:
* @layer: The vector layer.
*
* Get the stroke cap style of a vector layer.
*
* This procedure returns the stroke cap style in a vector layer.
*
* Returns: The stroke cap style.
*
* Since: 3.2
**/
GimpCapStyle
gimp_vector_layer_get_stroke_cap_style (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpCapStyle cap_style = 0;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-cap-style",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
cap_style = GIMP_VALUES_GET_ENUM (return_vals, 1);
gimp_value_array_unref (return_vals);
return cap_style;
}
/**
* gimp_vector_layer_get_stroke_color:
* @layer: The vector layer.
*
* Get the color of the stroke in a vector layer.
*
* This procedure returns the color of the stroke in a vector layer.
*
* Returns: (transfer full): The color of the stroke.
*
* Since: 2.6
**/
GeglColor *
gimp_vector_layer_get_stroke_color (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GeglColor *color = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-color",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
color = g_value_dup_object (gimp_value_array_index (return_vals, 1));
gimp_value_array_unref (return_vals);
return color;
}
/**
* gimp_vector_layer_get_stroke_dash_offset:
* @layer: The vector layer.
*
* Get the stroke dash offset of a vector layer.
*
* This procedure returns the stroke dash offset in a vector layer.
*
* Returns: The stroke dash offset.
*
* Since: 3.2
**/
gdouble
gimp_vector_layer_get_stroke_dash_offset (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble dash_offset = 0.0;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-dash-offset",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
dash_offset = GIMP_VALUES_GET_DOUBLE (return_vals, 1);
gimp_value_array_unref (return_vals);
return dash_offset;
}
/**
* gimp_vector_layer_get_stroke_dash_pattern:
* @layer: The vector layer.
* @num_dashes: (out): The number of dashes in the dash_pattern array.
* @dashes: (out) (array length=num_dashes) (element-type gdouble) (transfer full): The stroke dash pattern array.
*
* Get the stroke dash pattern of a vector layer.
*
* This procedure returns the stroke dash pattern in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_get_stroke_dash_pattern (GimpVectorLayer *layer,
gsize *num_dashes,
gdouble **dashes)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-dash-pattern",
args);
gimp_value_array_unref (args);
*num_dashes = 0;
*dashes = NULL;
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
if (success)
{
*dashes = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 1, num_dashes);
}
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_get_stroke_join_style:
* @layer: The vector layer.
*
* Get the stroke join style of a vector layer.
*
* This procedure returns the stroke join style in a vector layer.
*
* Returns: The stroke join style.
*
* Since: 3.2
**/
GimpJoinStyle
gimp_vector_layer_get_stroke_join_style (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpJoinStyle join_style = 0;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-join-style",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
join_style = GIMP_VALUES_GET_ENUM (return_vals, 1);
gimp_value_array_unref (return_vals);
return join_style;
}
/**
* gimp_vector_layer_get_stroke_miter_limit:
* @layer: The vector layer.
*
* Get the stroke miter limit of a vector layer.
*
* This procedure returns the stroke miter limit in a vector layer.
*
* Returns: The stroke miter limit.
*
* Since: 3.2
**/
gdouble
gimp_vector_layer_get_stroke_miter_limit (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble miter = 0.0;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-miter-limit",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
miter = GIMP_VALUES_GET_DOUBLE (return_vals, 1);
gimp_value_array_unref (return_vals);
return miter;
}
/**
* gimp_vector_layer_get_stroke_width:
* @layer: The vector layer.
*
* Get the stroke width of a vector layer.
*
* This procedure returns the stroke width in a vector layer.
*
* Returns: The stroke width.
*
* Since: 3.2
**/
gdouble
gimp_vector_layer_get_stroke_width (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gdouble width = 0.0;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-width",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
width = GIMP_VALUES_GET_DOUBLE (return_vals, 1);
gimp_value_array_unref (return_vals);
return width;
}
/**
* gimp_vector_layer_get_stroke_width_unit:
* @layer: The vector layer.
*
* Get the stroke width unit of a vector layer.
*
* This procedure returns the stroke width unit in a vector layer.
*
* Returns: (transfer none): The stroke width unit.
*
* Since: 3.2
**/
GimpUnit *
gimp_vector_layer_get_stroke_width_unit (GimpVectorLayer *layer)
{
GimpValueArray *args;
GimpValueArray *return_vals;
GimpUnit *unit = NULL;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-get-stroke-width-unit",
args);
gimp_value_array_unref (args);
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
unit = GIMP_VALUES_GET_UNIT (return_vals, 1);
gimp_value_array_unref (return_vals);
return unit;
}
/**
* gimp_vector_layer_set_enable_fill:
* @layer: The vector layer.
* @enable_fill: Whether to enable the fill on the vector layer.
*
* Set whether the fill is enabled on the vector layer.
*
* This procedure sets the fill's visibility in the vector layer
* 'layer'.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_enable_fill (GimpVectorLayer *layer,
gboolean enable_fill)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_BOOLEAN, enable_fill,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-enable-fill",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_enable_stroke:
* @layer: The vector layer.
* @enable_stroke: Whether to enable the stroke on the vector layer.
*
* Set whether the stroke is enabled on the vector layer.
*
* This procedure sets the stroke's visibility in the vector layer
* 'layer'.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_enable_stroke (GimpVectorLayer *layer,
gboolean enable_stroke)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_BOOLEAN, enable_stroke,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-enable-stroke",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_fill_color:
* @layer: The vector layer.
* @color: The color to use for the fill.
*
* Set the color of the fill in the vector layer.
*
* This procedure sets the fill color in the vector layer 'layer'.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_fill_color (GimpVectorLayer *layer,
GeglColor *color)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GEGL_TYPE_COLOR, color,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-fill-color",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_cap_style:
* @layer: The vector layer.
* @cap_style: The stroke cap style.
*
* Set the stroke cap style of a vector layer.
*
* This procedure sets the stroke cap style in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_cap_style (GimpVectorLayer *layer,
GimpCapStyle cap_style)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GIMP_TYPE_CAP_STYLE, cap_style,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-cap-style",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_color:
* @layer: The vector layer.
* @color: The color to use for the stroke.
*
* Set the color of the stroke in the vector layer.
*
* This procedure sets the stroke color in the vector layer 'layer'.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_color (GimpVectorLayer *layer,
GeglColor *color)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GEGL_TYPE_COLOR, color,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-color",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_dash_offset:
* @layer: The vector layer.
* @dash_offset: The stroke dash offset.
*
* Set the stroke dash offset of a vector layer.
*
* This procedure sets the stroke dash offset in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_dash_offset (GimpVectorLayer *layer,
gdouble dash_offset)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_DOUBLE, dash_offset,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-dash-offset",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_dash_pattern:
* @layer: The vector layer.
* @num_dashes: The number of dashes in the dash pattern array.
* @dashes: (array length=num_dashes) (element-type gdouble): The line dash pattern setting.
*
* Set the stroke dash pattern of a vector layer.
*
* This procedure sets the stroke dash pattern in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_dash_pattern (GimpVectorLayer *layer,
gsize num_dashes,
const gdouble *dashes)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE);
gimp_value_set_double_array (gimp_value_array_index (args, 1), dashes, num_dashes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-dash-pattern",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_join_style:
* @layer: The vector layer.
* @join_style: The stroke join style.
*
* Set the stroke join style of a vector layer.
*
* This procedure sets the stroke join style in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_join_style (GimpVectorLayer *layer,
GimpJoinStyle join_style)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GIMP_TYPE_JOIN_STYLE, join_style,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-join-style",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_miter_limit:
* @layer: The vector layer.
* @miter: The stroke miter limit.
*
* Set the stroke miter limit of a vector layer.
*
* This procedure sets the stroke miter limit in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_miter_limit (GimpVectorLayer *layer,
gdouble miter)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_DOUBLE, miter,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-miter-limit",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_width:
* @layer: The vector layer.
* @width: The stroke width.
*
* Set the stroke width of a vector layer.
*
* This procedure sets the stroke width in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_width (GimpVectorLayer *layer,
gdouble width)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
G_TYPE_DOUBLE, width,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-width",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}
/**
* gimp_vector_layer_set_stroke_width_unit:
* @layer: The vector layer.
* @unit: The stroke width unit.
*
* Set the stroke width unit of a vector layer.
*
* This procedure sets the stroke width unit in a vector layer.
*
* Returns: TRUE on success.
*
* Since: 3.2
**/
gboolean
gimp_vector_layer_set_stroke_width_unit (GimpVectorLayer *layer,
GimpUnit *unit)
{
GimpValueArray *args;
GimpValueArray *return_vals;
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_VECTOR_LAYER, layer,
GIMP_TYPE_UNIT, unit,
G_TYPE_NONE);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-vector-layer-set-stroke-width-unit",
args);
gimp_value_array_unref (args);
success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
gimp_value_array_unref (return_vals);
return success;
}

45
libgimp/gimpvectorlayer_pdb.h
View File

@@ -32,10 +32,47 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
GimpVectorLayer* gimp_vector_layer_new (GimpImage *image,
GimpPath *path);
gboolean gimp_vector_layer_refresh (GimpVectorLayer *layer);
gboolean gimp_vector_layer_discard (GimpVectorLayer *layer);
GimpVectorLayer* gimp_vector_layer_new (GimpImage *image,
GimpPath *path);
gboolean gimp_vector_layer_refresh (GimpVectorLayer *layer);
gboolean gimp_vector_layer_discard (GimpVectorLayer *layer);
gboolean gimp_vector_layer_get_enable_fill (GimpVectorLayer *layer);
gboolean gimp_vector_layer_get_enable_stroke (GimpVectorLayer *layer);
GeglColor* gimp_vector_layer_get_fill_color (GimpVectorLayer *layer);
GimpPath* gimp_vector_layer_get_path (GimpVectorLayer *layer);
GimpCapStyle gimp_vector_layer_get_stroke_cap_style (GimpVectorLayer *layer);
GeglColor* gimp_vector_layer_get_stroke_color (GimpVectorLayer *layer);
gdouble gimp_vector_layer_get_stroke_dash_offset (GimpVectorLayer *layer);
gboolean gimp_vector_layer_get_stroke_dash_pattern (GimpVectorLayer *layer,
gsize *num_dashes,
gdouble **dashes);
GimpJoinStyle gimp_vector_layer_get_stroke_join_style (GimpVectorLayer *layer);
gdouble gimp_vector_layer_get_stroke_miter_limit (GimpVectorLayer *layer);
gdouble gimp_vector_layer_get_stroke_width (GimpVectorLayer *layer);
GimpUnit* gimp_vector_layer_get_stroke_width_unit (GimpVectorLayer *layer);
gboolean gimp_vector_layer_set_enable_fill (GimpVectorLayer *layer,
gboolean enable_fill);
gboolean gimp_vector_layer_set_enable_stroke (GimpVectorLayer *layer,
gboolean enable_stroke);
gboolean gimp_vector_layer_set_fill_color (GimpVectorLayer *layer,
GeglColor *color);
gboolean gimp_vector_layer_set_stroke_cap_style (GimpVectorLayer *layer,
GimpCapStyle cap_style);
gboolean gimp_vector_layer_set_stroke_color (GimpVectorLayer *layer,
GeglColor *color);
gboolean gimp_vector_layer_set_stroke_dash_offset (GimpVectorLayer *layer,
gdouble dash_offset);
gboolean gimp_vector_layer_set_stroke_dash_pattern (GimpVectorLayer *layer,
gsize num_dashes,
const gdouble *dashes);
gboolean gimp_vector_layer_set_stroke_join_style (GimpVectorLayer *layer,
GimpJoinStyle join_style);
gboolean gimp_vector_layer_set_stroke_miter_limit (GimpVectorLayer *layer,
gdouble miter);
gboolean gimp_vector_layer_set_stroke_width (GimpVectorLayer *layer,
gdouble width);
gboolean gimp_vector_layer_set_stroke_width_unit (GimpVectorLayer *layer,
GimpUnit *unit);
G_END_DECLS

1
libgimpconfig/gimpconfig-params.c
View File

@@ -316,6 +316,7 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec)
g_strcmp0 (type_name, "GimpLayer") == 0 ||
g_strcmp0 (type_name, "GimpGroupLayer") == 0 ||
g_strcmp0 (type_name, "GimpTextLayer") == 0 ||
g_strcmp0 (type_name, "GimpVectorLayer") == 0 ||
g_strcmp0 (type_name, "GimpChannel") == 0 ||
g_strcmp0 (type_name, "GimpItem") == 0 ||
g_strcmp0 (type_name, "GimpLayerMask") == 0 ||

843
pdb/groups/vector_layer.pdb
View File

@@ -123,16 +123,857 @@ CODE
);
}
sub vector_layer_get_path {
$blurb = 'Gets the path from the vector layer if one is associated with it.';
$help = <<'HELP';
This procedure returns the path from the vector layer if one is associated with it.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' }
);
@outargs = (
{ name => 'path', type => 'path',
desc => 'The path associated with the vector layer' }
);
%invoke = (
code => <<'CODE'
{
path = gimp_vector_layer_get_path (layer);
if (! path)
success = FALSE;
}
CODE
);
}
sub vector_layer_get_enable_stroke {
$blurb = 'Check if stroke is enabled in the vector layer.';
$help = <<'HELP';
This procedure checks if stroke is enabled in the specified vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' }
);
@outargs = (
{ name => 'enable_stroke', type => 'boolean',
desc => 'If the stroke is enabled on the vector layer' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_get (options,
"enable-stroke", &enable_stroke,
NULL);
}
CODE
);
}
sub vector_layer_set_enable_stroke {
$blurb = 'Set whether the stroke is enabled on the vector layer.';
$help = <<'HELP';
This procedure sets the stroke's visibility in the vector layer 'layer'.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' },
{ name => 'enable_stroke', type => 'boolean',
desc => 'Whether to enable the stroke on the vector layer' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
{
g_object_set (options,
"enable-stroke", &enable_stroke,
NULL);
}
}
CODE
);
}
sub vector_layer_get_stroke_color {
$blurb = 'Get the color of the stroke in a vector layer.';
$help = <<'HELP';
This procedure returns the color of the stroke in a vector layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'color', type => 'geglcolor',
desc => 'The color of the stroke.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
color = gegl_color_duplicate (gimp_context_get_foreground (
GIMP_CONTEXT (options->stroke_options)));
}
CODE
);
}
sub vector_layer_get_stroke_width {
$blurb = 'Get the stroke width of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke width in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'width', type => "0 <= double",
desc => 'The stroke width.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
width = gimp_stroke_options_get_width (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_width_unit {
$blurb = 'Get the stroke width unit of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke width unit in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'unit', type => 'unit',
desc => 'The stroke width unit.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
unit = gimp_stroke_options_get_unit (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_cap_style {
$blurb = 'Get the stroke cap style of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke cap style in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'cap_style', type => 'enum GimpCapStyle',
desc => 'The stroke cap style.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
cap_style = gimp_stroke_options_get_cap_style (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_join_style {
$blurb = 'Get the stroke join style of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke join style in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'join_style', type => 'enum GimpJoinStyle',
desc => 'The stroke join style.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
join_style = gimp_stroke_options_get_join_style (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_miter_limit {
$blurb = 'Get the stroke miter limit of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke miter limit in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'miter', type => "0 <= double",
desc => 'The stroke miter limit.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
miter = gimp_stroke_options_get_miter_limit (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_dash_offset {
$blurb = 'Get the stroke dash offset of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke dash offset in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'dash_offset', type => "0 <= double",
desc => 'The stroke dash offset.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
dash_offset = gimp_stroke_options_get_dash_offset (options->stroke_options);
}
CODE
);
}
sub vector_layer_get_stroke_dash_pattern {
$blurb = 'Get the stroke dash pattern of a vector layer.';
$help = <<'HELP';
This procedure returns the stroke dash pattern in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'dashes', type => 'doublearray', void_ret => 1,
desc => 'The stroke dash pattern array.',
array => { desc => 'The number of dashes in the dash_pattern array' } }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
{
GArray *pattern =
gimp_stroke_options_get_dash_info (options->stroke_options);
dashes = gimp_dash_pattern_to_double_array (pattern, &num_dashes);
}
}
CODE
);
}
sub vector_layer_set_stroke_color {
$blurb = 'Set the color of the stroke in the vector layer.';
$help = <<'HELP';
This procedure sets the stroke color in the vector layer 'layer'.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' },
{ name => 'color', type => 'geglcolor',
desc => 'The color to use for the stroke' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
gimp_context_set_foreground (GIMP_CONTEXT (options->stroke_options),
color);
}
CODE
);
}
sub vector_layer_set_stroke_width {
$blurb = 'Set the stroke width of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke width in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'width', type => "0 <= double",
desc => 'The stroke width.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"width", width,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_width_unit {
$blurb = 'Set the stroke width unit of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke width unit in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'unit', type => 'unit',
desc => 'The stroke width unit.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"unit", unit,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_cap_style {
$blurb = 'Set the stroke cap style of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke cap style in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'cap_style', type => 'enum GimpCapStyle',
desc => 'The stroke cap style.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"cap-style", cap_style,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_join_style {
$blurb = 'Set the stroke join style of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke join style in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'join_style', type => 'enum GimpJoinStyle',
desc => 'The stroke join style.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"join-style", join_style,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_miter_limit {
$blurb = 'Set the stroke miter limit of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke miter limit in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'miter', type => "0 <= double",
desc => 'The stroke miter limit.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"miter-limit", miter,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_dash_offset {
$blurb = 'Set the stroke dash offset of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke dash offset in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'dash_offset', type => "0 <= double",
desc => 'The stroke dash offset.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options->stroke_options,
"dash-offset", dash_offset,
NULL);
}
CODE
);
}
sub vector_layer_set_stroke_dash_pattern {
$blurb = 'Set the stroke dash pattern of a vector layer.';
$help = <<'HELP';
This procedure sets the stroke dash pattern in a vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' },
{ name => 'dashes', type => 'doublearray',
desc => 'The line dash pattern setting',
array => { desc => 'The number of dashes in the dash pattern array' } }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
GArray *pattern = NULL;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
{
if (num_dashes > 0)
{
pattern = gimp_dash_pattern_from_double_array (num_dashes, dashes);
if (! pattern)
success = FALSE;
}
if (success)
gimp_stroke_options_take_dash_pattern (options->stroke_options,
GIMP_DASH_CUSTOM, pattern);
}
}
CODE
);
}
sub vector_layer_get_enable_fill {
$blurb = 'Check if fill is enabled in the vector layer.';
$help = <<'HELP';
This procedure checks if fill is enabled in the specified vector layer.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' }
);
@outargs = (
{ name => 'enable_fill', type => 'boolean',
desc => 'If the fill is enabled on the vector layer' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_get (options,
"enable-fill", &enable_fill,
NULL);
}
CODE
);
}
sub vector_layer_set_enable_fill {
$blurb = 'Set whether the fill is enabled on the vector layer.';
$help = <<'HELP';
This procedure sets the fill's visibility in the vector layer 'layer'.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' },
{ name => 'enable_fill', type => 'boolean',
desc => 'Whether to enable the fill on the vector layer' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
g_object_set (options,
"enable-fill", enable_fill,
NULL);
}
CODE
);
}
sub vector_layer_get_fill_color {
$blurb = 'Get the color of the fill in a vector layer.';
$help = <<'HELP';
This procedure returns the color of the fill in a vector layer.
HELP
&marcus_pdb_misc('2008', '2.6');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer.' }
);
@outargs = (
{ name => 'color', type => 'geglcolor',
desc => 'The color of the fill.' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
color =
gegl_color_duplicate (gimp_context_get_foreground (
GIMP_CONTEXT (options->fill_options)));
}
CODE
);
}
sub vector_layer_set_fill_color {
$blurb = 'Set the color of the fill in the vector layer.';
$help = <<'HELP';
This procedure sets the fill color in the vector layer 'layer'.
HELP
&alxsa_pdb_misc('2025', '3.2');
@inargs = (
{ name => 'layer', type => 'vector_layer',
desc => 'The vector layer' },
{ name => 'color', type => 'geglcolor',
desc => 'The color to use for the fill' }
);
%invoke = (
code => <<'CODE'
{
GimpVectorLayerOptions *options;
options = gimp_vector_layer_get_options (layer);
if (! options)
success = FALSE;
if (success)
gimp_context_set_foreground (GIMP_CONTEXT (options->fill_options),
color);
}
CODE
);
}
@headers = qw("libgimpbase/gimpbase.h"
"core/gimpcontext.h"
"core/gimpdashpattern.h"
"core/gimpstrokeoptions.h"
"path/gimpvectorlayer.h"
"path/gimpvectorlayeroptions.h"
"gimppdb-utils.h"
"gimppdberror.h"
"gimp-intl.h");
@procs = qw(vector_layer_new
vector_layer_refresh
vector_layer_discard);
vector_layer_discard
vector_layer_get_enable_fill
vector_layer_get_enable_stroke
vector_layer_get_fill_color
vector_layer_get_path
vector_layer_get_stroke_cap_style
vector_layer_get_stroke_color
vector_layer_get_stroke_dash_offset
vector_layer_get_stroke_dash_pattern
vector_layer_get_stroke_join_style
vector_layer_get_stroke_miter_limit
vector_layer_get_stroke_width
vector_layer_get_stroke_width_unit
vector_layer_set_enable_fill
vector_layer_set_enable_stroke
vector_layer_set_fill_color
vector_layer_set_stroke_cap_style
vector_layer_set_stroke_color
vector_layer_set_stroke_dash_offset
vector_layer_set_stroke_dash_pattern
vector_layer_set_stroke_join_style
vector_layer_set_stroke_miter_limit
vector_layer_set_stroke_width
vector_layer_set_stroke_width_unit);
%exports = (app => [@procs], lib => [@procs]);