/* -----------------------------------
* gap_detail_xml_align_get_values
* -----------------------------------
* This procedure is typically called
* on the snapshot image created by the Player.
* This image has one layer at the first snapshot
* and each further snapshot adds one layer on top of the layerstack.
*
* The start is detected when the image has only one layer.
* optionally the numer of layers can be limted
* to 2 (or more) layers.
*/
void
gap_detail_xml_align_get_values(XmlAlignValues *xaVals)
{
int l_len;
/* init default values */
xaVals->framePhase = DEFAULT_framePhase;
xaVals->moveLogFile[0] = '\0';
l_len = gimp_get_data_size (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME);
if (l_len == sizeof(XmlAlignValues))
{
/* Possibly retrieve data from a previous interactive run */
gimp_get_data (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME, xaVals);
if(gap_debug)
{
printf("gap_detail_xml_align_get_values FOUND data for key:%s\n"
, GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME
);
}
}
if(gap_debug)
{
printf("gap_detail_xml_align_get_values:\n"
" framePhase:%d moveLogFile:%s\n"
, (int)xaVals->framePhase
, xaVals->moveLogFile
);
}
} /* end gap_detail_xml_align_get_values */
/* -----------------------------------
* gap_detail_tracking_get_values
* -----------------------------------
* This procedure is typically called
* on the snapshot image created by the Player.
* This image has one layer at the first snapshot
* and each further snapshot adds one layer on top of the layerstack.
*
* The start is detected when the image has only one layer.
* optionally the numer of layers can be limted
* to 2 (or more) layers.
*/
void
gap_detail_tracking_get_values(FilterValues *fiVals)
{
int l_len;
/* init default values */
fiVals->refShapeRadius = DEFAULT_refShapeRadius;
fiVals->targetMoveRadius = DEFAULT_targetMoveRadius;
fiVals->loacteColodiffThreshold = DEFAULT_loacteColodiffThreshold;
fiVals->coordsRelToFrame1 = DEFAULT_coordsRelToFrame1;
fiVals->offsX = DEFAULT_offsX;
fiVals->offsY = DEFAULT_offsY;
fiVals->offsRotate = DEFAULT_offsRotate;
fiVals->enableScaling = DEFAULT_enableScaling;
fiVals->removeMidlayers = DEFAULT_removeMidlayers;
fiVals->bgLayerIsReference = DEFAULT_bgLayerIsReference;
fiVals->moveLogFile[0] = '\0';
l_len = gimp_get_data_size (GAP_DETAIL_TRACKING_PLUG_IN_NAME);
if (l_len == sizeof(FilterValues))
{
/* Possibly retrieve data from a previous interactive run */
gimp_get_data (GAP_DETAIL_TRACKING_PLUG_IN_NAME, fiVals);
if(gap_debug)
{
printf("gap_detail_tracking_get_values FOUND data for key:%s\n"
, GAP_DETAIL_TRACKING_PLUG_IN_NAME
);
}
}
if(gap_debug)
{
printf("gap_detail_tracking_get_values:\n"
" refShapeRadius:%d targetMoveRadius:%d locateColordiff:%.4f\n"
" coordsRelToFrame1:%d offsX:%d offsY:%d removeMidlayers:%d bgLayerIsReference:%d\n"
" moveLogFile:%s\n"
, (int)fiVals->refShapeRadius
, (int)fiVals->targetMoveRadius
, (float)fiVals->loacteColodiffThreshold
, (int)fiVals->coordsRelToFrame1
, (int)fiVals->offsX
, (int)fiVals->offsY
, (int)fiVals->removeMidlayers
, (int)fiVals->bgLayerIsReference
, fiVals->moveLogFile
);
}
} /* end gap_detail_tracking_get_values */
/* -------------------------------
* p_get_frameHistInfo
* -------------------------------
*/
static void
p_get_frameHistInfo(FrameHistInfo *frameHistInfo)
{
int l_len;
frameHistInfo->workImageId = -1;
frameHistInfo->frameNr = 0;
frameHistInfo->startCoords.valid = FALSE;
frameHistInfo->startCoords.px = 0;
frameHistInfo->startCoords.py = 0;
frameHistInfo->lostTraceCount = 0;
l_len = gimp_get_data_size (GAP_DETAIL_FRAME_HISTORY_INFO);
if(gap_debug)
{
printf("p_get_frameHistInfo: %s len:%d sizeof(FrameHistInfo):%d\n"
, GAP_DETAIL_FRAME_HISTORY_INFO
, (int)l_len
, (int)sizeof(FrameHistInfo)
);
}
if (l_len == sizeof(FrameHistInfo))
{
gimp_get_data(GAP_DETAIL_FRAME_HISTORY_INFO, frameHistInfo);
if(gap_debug)
{
printf("p_get_frameHistInfo: %s frameNr:%d px:%d py:%d valid:%d\n"
" prevPx:%d prevPy:%d prevValid:%d lostTraceCount:%d\n"
, GAP_DETAIL_FRAME_HISTORY_INFO
, (int)frameHistInfo->frameNr
, (int)frameHistInfo->startCoords.px
, (int)frameHistInfo->startCoords.py
, (int)frameHistInfo->startCoords.valid
, (int)frameHistInfo->prevCoords.px
, (int)frameHistInfo->prevCoords.py
, (int)frameHistInfo->prevCoords.valid
, (int)frameHistInfo->lostTraceCount
);
}
}
} /* end p_get_frameHistInfo */
static gchar *
p_alloc_plugin_data(char *key)
{
int l_len;
gchar *l_plugin_data;
l_len = gimp_get_data_size (key);
if(l_len < 1)
{
fprintf(stderr, "ERROR: no stored data found for Key %s\n", key);
return NULL;
}
l_plugin_data = g_malloc0(l_len+1);
if(gap_debug) printf("DEBUG Key:%s plugin_data length %d\n", key, (int)l_len);
return (l_plugin_data);
}
/* ============================================================================
* p_get_data
* try to get the plugin's data (key is usually the name of the plugin)
* and check for the length of the retrieved data.
* if all done OK return the length of the retrieved data,
* return -1 in case of errors.
* ============================================================================
*/
gint p_get_data(char *key)
{
int l_len;
l_len = gimp_get_data_size (key);
if(l_len < 1)
{
fprintf(stderr, "ERROR: no stored data found for Key %s\n", key);
return -1;
}
if(global_plugin_data)
{
g_free(global_plugin_data);
}
global_plugin_data = g_malloc0(l_len+1);
gimp_get_data(key, global_plugin_data);
if(gap_debug) printf("DEBUG p_get_data Key:%s retrieved bytes %d\n", key, (int)l_len);
return (l_len);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2]; /* Return values */
GimpRunMode run_mode;
gint32 image_ID;
gint32 drawable_ID;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
GError *error = NULL;
run_mode = param[0].data.d_int32;
INIT_I18N ();
/* Set up default return values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
data_length = gimp_get_data_size (SAVE_PROC);
if (data_length > 0)
{
palette_file = g_malloc (data_length);
gimp_get_data (SAVE_PROC, palette_file);
}
else
{
palette_file = g_strdup ("*.kcf");
data_length = strlen (palette_file) + 1;
}
}
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
palette_file = param[3].data.d_string;
data_length = strlen (palette_file) + 1;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Let user choose KCF palette (cancel ignores) */
if (need_palette (param[1].data.d_string))
palette_dialog (_("Load KISS Palette"));
gimp_set_data (SAVE_PROC, palette_file, data_length);
}
image = load_image (param[1].data.d_string, param[2].data.d_string,
&error);
if (image != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if (strcmp (name, SAVE_PROC) == 0)
{
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "CEL",
(GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_INDEXED
));
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
static void run ( const gchar *name, gint nparams, const GimpParam *param,
gint *nreturn_vals, GimpParam **return_vals)
{
static GimpParam values[3];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
SeparateContext mysc;
//enum separate_function func = SEP_NONE;
run_mode = param[0].data.d_int32;
/* setup for localization */
INIT_I18N ();
cmsErrorAction( LCMS_ERROR_IGNORE );
mysc.filename = NULL;
if( nparams != ( run_mode == GIMP_RUN_NONINTERACTIVE ? 2 : 1 ) )
status = GIMP_PDB_CALLING_ERROR;
else if( run_mode == GIMP_RUN_NONINTERACTIVE ) {
if( param[1].type != GIMP_PDB_STRING || strlen( param[1].data.d_string ) == 0 )
status = GIMP_PDB_CALLING_ERROR;
else
mysc.filename = g_strdup( param[1].data.d_string );
} else {
gint size = gimp_get_data_size( "plug-in-separate-import/lastpath" );
if( size ) {
mysc.filename = g_malloc( size );
gimp_get_data( "plug-in-separate-import/lastpath", mysc.filename );
}
}
if( status == GIMP_PDB_SUCCESS && ( run_mode == GIMP_RUN_NONINTERACTIVE || separate_import_dialog( &mysc ) ) ) {
gint i, j, x, y;
TIFF *in;
guint32 width, height, stripSize, stripCount, stripHeight;
gint16 bps, spp, step, planerConfig, photometric, inkset, resolutionUnit;
float xres, yres;
const gchar *layerNames[] = { "C", "M", "Y", "K" };
guchar *buf, *maskbuf[4], *srcbuf, *destbuf[4], *iccProfile;
gint32 layers[5], masks[4];
GimpDrawable *drw[4];
GimpPixelRgn rgn[4];
GimpRGB primaries[4] = { { .180, .541, .870, 1.0 },
{ .925, .149, .388, 1.0 },
{ .929, .862, .129, 1.0 },
{ 0, 0, 0, 1.0 } };
gchar *str = NULL;
gchar *baseName = g_path_get_basename( gimp_filename_to_utf8( mysc.filename ) );
#ifdef G_OS_WIN32
{
gchar *_filename = NULL; // win32 filename encoding(not UTF-8)
_filename = g_win32_locale_filename_from_utf8( mysc.filename );
in = TIFFOpen( _filename ? _filename : mysc.filename, "r" );
g_free( _filename );
}
#else
in = TIFFOpen( mysc.filename, "r" );
#endif
if( !in ) {
str = g_strdup_printf( _( "Cannot open : \"%s\"" ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
if( ( TIFFGetField( in, TIFFTAG_BITSPERSAMPLE, &bps ) == FALSE || ( bps != 8 && bps != 16 ) ) ||
( TIFFGetField( in, TIFFTAG_SAMPLESPERPIXEL, &spp ) == FALSE || spp != 4 ) ||
( TIFFGetField( in, TIFFTAG_PHOTOMETRIC, &photometric ) == FALSE || photometric != PHOTOMETRIC_SEPARATED ) ||
( TIFFGetField( in, TIFFTAG_PLANARCONFIG, &planerConfig ) == FALSE || planerConfig != PLANARCONFIG_CONTIG ) ||
( TIFFGetField( in, TIFFTAG_INKSET, &inkset ) == TRUE && inkset != INKSET_CMYK ) ) {
str = g_strdup_printf( _( "\"%s\" is unsupported." ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
stripCount = TIFFNumberOfStrips( in );
stripSize = TIFFStripSize( in );
TIFFGetField( in, TIFFTAG_IMAGEWIDTH, &width );
TIFFGetField( in, TIFFTAG_IMAGELENGTH, &height );
TIFFGetField( in, TIFFTAG_ROWSPERSTRIP, &stripHeight );
TIFFGetField( in, TIFFTAG_RESOLUTIONUNIT, &resolutionUnit );
TIFFGetField( in, TIFFTAG_XRESOLUTION, &xres );
TIFFGetField( in, TIFFTAG_YRESOLUTION, &yres );
#if 0
str = g_strdup_printf( "Photometric : %d BPS : %d SPP : %d\nInkset : %d StripCount : %d", photometric, bps, spp, inkset, stripCount );
gimp_message( str );
g_free( str );
#endif
step = ( bps == 16 ) ? 2 : 1;
buf = g_malloc( stripSize );
values[1].data.d_image = gimp_image_new( width, height, GIMP_RGB );
gimp_image_set_resolution( values[1].data.d_image, xres, yres );
gimp_context_push();
for( i = 0; i < 4; i++ ) {
layers[i] = gimp_layer_new( values[1].data.d_image, layerNames[i], width, height, GIMP_RGBA_IMAGE, 100.0, GIMP_DARKEN_ONLY_MODE );
gimp_context_set_foreground( &primaries[i] );
gimp_drawable_fill( layers[i], GIMP_FOREGROUND_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[i], i );
masks[i] = gimp_layer_create_mask( layers[i], GIMP_ADD_BLACK_MASK );
gimp_layer_add_mask( layers[i], masks[i] );
drw[i] = gimp_drawable_get( masks[i] );
maskbuf[i] = g_malloc( width * stripHeight );
}
gimp_context_pop();
layers[4] = gimp_layer_new( values[1].data.d_image, _( "Background" ), width, height, GIMP_RGB_IMAGE, 100.0, GIMP_NORMAL_MODE );
gimp_drawable_fill( layers[4], GIMP_WHITE_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[4], 4 );
str = g_strdup_printf( _( "Reading \"%s\"..." ), baseName );
gimp_progress_init( str );
g_free( str );
for( i = 0; i < stripCount; i++ ) {
guint32 size = TIFFReadEncodedStrip( in, i, buf, stripSize );
guint32 rowCount = ( size < stripSize ? height % stripHeight : stripHeight );
srcbuf = buf;
if( bps == 16 )
srcbuf++;
for( j = 0; j < 4; j++ ) {
gimp_pixel_rgn_init( &( rgn[j] ), drw[j],
0, stripHeight * i, width, rowCount,
FALSE, FALSE );
destbuf[j] = maskbuf[j];
}
for( y = 0; y < rowCount; y++ ) {
for( x = 0; x < width; x++ ) {
*destbuf[0]++ = *srcbuf;
srcbuf += step;
*destbuf[1]++ = *srcbuf;
srcbuf += step;
*destbuf[2]++ = *srcbuf;
srcbuf += step;
*destbuf[3]++ = *srcbuf;
srcbuf += step;
//srcbuf += spp > 4 ? spp - 4 : 0;
}
}
gimp_pixel_rgn_set_rect( &( rgn[0] ), maskbuf[0], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[1] ), maskbuf[1], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[2] ), maskbuf[2], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[3] ), maskbuf[3], 0, stripHeight * i, width, rowCount );
gimp_progress_update( (gdouble)i / stripCount );
}
g_free( buf );
for( i = 0; i < 4; i++ ) {
g_free( maskbuf[i] );
gimp_drawable_detach( drw[i] );
}
#ifdef ENABLE_COLOR_MANAGEMENT
if ( TIFFGetField( in, TIFFTAG_ICCPROFILE, &width, &iccProfile ) ) {
GimpParasite *parasite;
parasite = gimp_parasite_new( CMYKPROFILE, 0, width, iccProfile );
gimp_image_parasite_attach( values[1].data.d_image, parasite );
gimp_parasite_free( parasite );
//g_free( iccProfile ); // This causes clash on TIFFClose( in ).
}
#endif
}
TIFFClose( in );
}
g_free( baseName );
} else
status = GIMP_PDB_CANCEL;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
if( status == GIMP_PDB_SUCCESS ) {
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
if( run_mode != GIMP_RUN_NONINTERACTIVE ) {
gimp_image_undo_enable( values[1].data.d_image );
gimp_display_new( values[1].data.d_image );
gimp_displays_flush();
}
gimp_set_data( "plug-in-separate-import/lastpath", mysc.filename, strlen( mysc.filename ) + 1 );
} else
*nreturn_vals = 1;
g_free( mysc.filename );
}
// Run the plugin
static void
run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals)
{
// Return values
static GimpParam values[1];
gint sel_x1, sel_y1, sel_x2, sel_y2, w, h, padding;
PluginData pd;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
if (param[0].type!= GIMP_PDB_INT32)
status=GIMP_PDB_CALLING_ERROR;
if (param[2].type!=GIMP_PDB_DRAWABLE)
status=GIMP_PDB_CALLING_ERROR;
run_mode = (GimpRunMode) param[0].data.d_int32;
pd.drawable = gimp_drawable_get(param[2].data.d_drawable);
gimp_drawable_mask_bounds(pd.drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
pd.selection_width = sel_x2 - sel_x1;
pd.selection_height = sel_y2 - sel_y1;
pd.selection_offset_x = sel_x1;
pd.selection_offset_y = sel_y1;
pd.image_width = gimp_drawable_width(pd.drawable->drawable_id);
pd.image_height = gimp_drawable_height(pd.drawable->drawable_id);
pd.channel_count = gimp_drawable_bpp(pd.drawable->drawable_id);
pd.point_grabbed = -1;
if (run_mode == GIMP_RUN_INTERACTIVE)
{
// Interactive call with dialog
dialog(&pd);
if (pd.curve_user.count > 0)
{
gimp_set_data (PLUG_IN_BINARY, pd.curve_user.user_points, sizeof (GdkPoint) * pd.curve_user.count);
}
}
else if (run_mode == GIMP_RUN_WITH_LAST_VALS)
{
// Read a saved curve and apply it
fft_prepare(&pd);
gimp_get_data(PLUG_IN_BINARY, pd.curve_user.user_points);
pd.curve_user.count = gimp_get_data_size(PLUG_IN_BINARY) / sizeof (GdkPoint);
gimp_pixel_rgn_init(&pd.region, pd.drawable, 0, 0, pd.image_width, pd.image_height, TRUE, TRUE);
fft_apply(&pd);
gimp_pixel_rgn_set_rect(&pd.region, pd.img_pixels, 0, 0, pd.image_width, pd.image_height);
gimp_drawable_flush(pd.drawable);
gimp_drawable_merge_shadow(pd.drawable->drawable_id, TRUE);
gimp_drawable_update(pd.drawable->drawable_id, pd.selection_offset_x, pd.selection_offset_y, pd.selection_width, pd.selection_height);
fft_destroy(&pd);
gimp_displays_flush();
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gimp_drawable_detach(pd.drawable);
}
void
gimp_lastval_desc_update(void)
{
gchar *fname;
gchar *file_buff;
gchar *l_keyname;
gchar *key_description;
gint arg_cnt;
gint max_expected_argc;
GimpLastvalDescType *lastval_desc_arr;
gchar *ptr;
gchar *next_line_ptr;
gint32 l_idx;
gint32 l_filesize;
time_t l_timestamp;
GStatBuf stat_buf;
arg_cnt = 0;
fname = gimp_lastval_desc_filename();
/* check timestamps */
if(gimp_get_data_size(TIMESTAMP_DESCFILE_CHECKED) > 1)
{
gimp_get_data(TIMESTAMP_DESCFILE_CHECKED, &l_timestamp);
if(g_stat(fname, &stat_buf) == 0)
{
if(l_timestamp > stat_buf.st_mtime)
{
/* file last modification is older than timestamp of last check
* (we dont need to read the file again)
*/
g_free(fname);
return;
}
}
else
{
/* file not found, no need to continue */
g_free(fname);
return;
}
}
l_timestamp = gap_base_get_current_time();
gimp_set_data(TIMESTAMP_DESCFILE_CHECKED, &l_timestamp, sizeof(l_timestamp));
p_init_token_table();
/* read all descriptions from file */
file_buff = p_load_lastval_desc_file(fname);
if(file_buff == NULL)
{
return;
}
l_filesize = strlen(file_buff);
/* set/replace all descriptions in memory for the current gimp session */
max_expected_argc = 10 + (l_filesize / 7);
lastval_desc_arr = g_new(GimpLastvalDescType, max_expected_argc);
l_keyname = NULL;
key_description = g_strdup(" ");
for(ptr = file_buff; *ptr != '\0'; ptr = next_line_ptr)
{
/* skip blanks */
while (*ptr == ' ' || *ptr == '\t') { ptr++;}
/* findout start on next line (and terminate the current line with '\0') */
next_line_ptr = ptr;
while (*next_line_ptr != '\0')
{
if(*next_line_ptr == '\n')
{
*next_line_ptr = '\0';
next_line_ptr++;
break;
}
next_line_ptr++;
}
/* printf("LINE:%s\n", ptr); */
/* ignore empty lines and comment lines */
if ((*ptr != '\n')
&& (*ptr != '\0')
&& (*ptr != '#'))
{
if (*ptr == '"')
{
l_idx = 1;
l_keyname = &ptr[1];
while (1)
{
if (ptr[l_idx] == '"' || ptr[l_idx] == '\n' || ptr[l_idx] == '\0')
{
ptr[l_idx] = '\0';
g_free(key_description);
/* printf("KEY:%s\n", l_keyname); */
key_description = gimp_lastval_desc_keyname(l_keyname);
break;
}
l_idx++;
}
}
else
{
for(l_idx=0; l_idx <= GIMP_LASTVAL_END; l_idx++)
{
char *l_token;
l_token = g_strdup_printf("%s;", token_tab[l_idx].token);
if(0 == strncmp(ptr, l_token, strlen(l_token)))
{
/* found a matching datatype token */
if(strcmp("END;",l_token) == 0)
{
lastval_desc_arr[arg_cnt].lastval_type = GIMP_LASTVAL_END;
lastval_desc_arr[arg_cnt].offset = 0;
lastval_desc_arr[arg_cnt].elem_size = 0;
lastval_desc_arr[arg_cnt].iter_flag = 0;
lastval_desc_arr[arg_cnt].elem_name[0] = '\0';
arg_cnt++;
/* if it is the END of description block store array in memory */
/* printf("SET_DATA:%s\n", key_description); */
gimp_set_data(key_description, lastval_desc_arr, sizeof(GimpLastvalDescType) * arg_cnt);
arg_cnt = 0;
g_free(key_description);
key_description = g_strdup(" ");
}
else
{
int l_nscan;
lastval_desc_arr[arg_cnt].elem_name[0] = '\0';
lastval_desc_arr[arg_cnt].lastval_type = token_tab[l_idx].lastval_type;
l_nscan = sscanf(&ptr[strlen(l_token)], "%d;%d;%d;%50s"
, &lastval_desc_arr[arg_cnt].offset
, &lastval_desc_arr[arg_cnt].elem_size
, &lastval_desc_arr[arg_cnt].iter_flag
, lastval_desc_arr[arg_cnt].elem_name
);
if(l_nscan != 3 && l_nscan != 4)
{
printf("ERROR while scanning datatype %s in file %s\n", ptr, fname);
}
else
{
arg_cnt++;
}
}
break;
}
g_free(l_token);
}
if (l_idx > GIMP_LASTVAL_END)
{
printf("ERROR unknown datatype %s in file %s %d %d\n", ptr, fname, l_idx, GIMP_LASTVAL_END);
}
}
}
}
g_free(key_description);
g_free(lastval_desc_arr);
g_free(fname);
} /* end gimp_lastval_desc_update */
static GimpPDBStatusType
run_pspi_settings (gint n_params,
const GimpParam *param)
{
GimpRunMode run_mode = param[0].data.d_int32;
GString *sp;
int i;
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (n_params != pspi_settings_nargs)
return GIMP_PDB_CALLING_ERROR;
if (param[1].data.d_int32 <= 0 || param[1].data.d_int32 > 10)
return GIMP_PDB_CALLING_ERROR;
sp = g_string_new ("");
for (i = 0; i < param[1].data.d_int32; i++)
{
if (sp->len > 0)
g_string_append_c (sp, G_SEARCHPATH_SEPARATOR);
g_string_append (sp, param[2].data.d_stringarray[i]);
search_path = sp->str;
}
break;
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
i = gimp_get_data_size (PSPI_PATH_TOKEN);
if (i > 0)
{
search_path = g_malloc (i);
gimp_get_data (PSPI_PATH_TOKEN, search_path);
}
else
{
search_path = gimp_gimprc_query (PSPI_PATH_TOKEN);
if (search_path == NULL)
search_path = g_strdup ("");
}
if (! pspi_settings_dialog (&search_path))
return GIMP_PDB_CANCEL;
gimp_message (_("The new search path will be used next time GIMP is started"));
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
default:
break;
}
if (search_path == NULL)
search_path = g_strdup ("");
gimp_set_data (PSPI_PATH_TOKEN, search_path, strlen (search_path) + 1);
gimp_gimprc_set (PSPI_PATH_TOKEN, search_path);
return GIMP_PDB_SUCCESS;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint32 image_ID;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gboolean no_dialog;
INIT_I18N ();
gegl_init (NULL, NULL);
run_mode = param[0].data.d_int32;
no_dialog = (strcmp (name, "plug-in-sel2path") == 0);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
image_ID = param[1].data.d_image;
if (image_ID < 0)
{
g_warning ("plug-in-sel2path needs a valid image ID");
return;
}
if (gimp_selection_is_empty (image_ID))
{
g_message (_("No selection to convert"));
return;
}
fit_set_default_params (&selVals);
if (!no_dialog)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (gimp_get_data_size ("plug-in-sel2path-advanced") > 0)
{
gimp_get_data ("plug-in-sel2path-advanced", &selVals);
}
if (!sel2path_dialog (&selVals))
return;
/* Get the current settings */
fit_set_params (&selVals);
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 23)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
selVals.align_threshold = param[3].data.d_float;
selVals.corner_always_threshold = param[4].data.d_float;
selVals.corner_surround = param[5].data.d_int8;
selVals.corner_threshold = param[6].data.d_float;
selVals.error_threshold = param[7].data.d_float;
selVals.filter_alternative_surround = param[8].data.d_int8;
selVals.filter_epsilon = param[9].data.d_float;
selVals.filter_iteration_count = param[10].data.d_int8;
selVals.filter_percent = param[11].data.d_float;
selVals.filter_secondary_surround = param[12].data.d_int8;
selVals.filter_surround = param[13].data.d_int8;
selVals.keep_knees = param[14].data.d_int8;
selVals.line_reversion_threshold = param[15].data.d_float;
selVals.line_threshold = param[16].data.d_float;
selVals.reparameterize_improvement = param[17].data.d_float;
selVals.reparameterize_threshold = param[18].data.d_float;
selVals.subdivide_search = param[19].data.d_float;
selVals.subdivide_surround = param[20].data.d_int8;
selVals.subdivide_threshold = param[21].data.d_float;
selVals.tangent_surround = param[22].data.d_int8;
fit_set_params (&selVals);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
if(gimp_get_data_size ("plug-in-sel2path-advanced") > 0)
{
gimp_get_data ("plug-in-sel2path-advanced", &selVals);
/* Set up the last values */
fit_set_params (&selVals);
}
break;
default:
break;
}
}
sel2path (image_ID);
values[0].data.d_status = status;
if (status == GIMP_PDB_SUCCESS)
{
dialog_print_selVals(&selVals);
if (run_mode == GIMP_RUN_INTERACTIVE && !no_dialog)
gimp_set_data ("plug-in-sel2path-advanced", &selVals, sizeof(SELVALS));
}
}
