static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; GimpRunMode run_mode; gint image_id, layer_num; run_mode = param[0].data.d_int32; image_id = param[1].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch ( run_mode ) { case GIMP_RUN_INTERACTIVE: gimp_image_get_layers (image_id, &layer_num); if (layer_num < 2) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = _("There are not enough layers to align."); return; } gimp_get_data (PLUG_IN_PROC, &VALS); VALS.grid_size = MAX (VALS.grid_size, 1); if (! align_layers_dialog ()) return; break; case GIMP_RUN_NONINTERACTIVE: break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &VALS); break; } status = align_layers (image_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS) gimp_set_data (PLUG_IN_PROC, &VALS, sizeof (ValueType)); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; INIT_I18N (); run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_int32); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (HSV_NOISE_PROC, &VALS); if (!gimp_drawable_is_rgb (drawable->drawable_id)) { g_message (_("Can only operate on RGB drawables.")); return; } if (! scatter_hsv_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: VALS.holdness = CLAMP (param[3].data.d_int32, 1, 8); VALS.hue_distance = CLAMP (param[4].data.d_int32, 0, 180); VALS.saturation_distance = CLAMP (param[5].data.d_int32, 0, 255); VALS.value_distance = CLAMP (param[6].data.d_int32, 0, 255); break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (HSV_NOISE_PROC, &VALS); break; } scatter_hsv (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush(); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS ) gimp_set_data (HSV_NOISE_PROC, &VALS, sizeof (ValueType)); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpDrawable *drawable; static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; GimpRunMode run_mode; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_drawable); INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &pvals); /* Since a channel might be selected, we must check wheter RGB or not. */ if (!gimp_drawable_is_rgb (drawable->drawable_id)) { g_message (_("Can only operate on RGB drawables.")); return; } if (! max_rgb_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* You must copy the values of parameters to pvals or dialog variables. */ pvals.max_p = param[3].data.d_int32; break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &pvals); break; } status = main_function (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS) gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (ValueType)); values[0].data.d_status = status; }
/* ----------------------------------- * 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 */
static void params_load_from_gimp (void) { gimp_get_data (PLUG_IN_PROC, &p.params); if (0 < p.params.division_x) { p.params.tile_width = p.drawable->width / p.params.division_x; if (0 < p.params.tile_width) { p.params.division_y = p.drawable->height / p.params.tile_height; } } if (p.params.tile_width <= 0 || p.params.tile_height <= 0 || p.params.division_x <= 0 || p.params.division_y <= 0) { p.params.tile_width = p.drawable->width; p.params.tile_height = p.drawable->height; p.params.division_x = p.drawable->width / p.params.tile_width; p.params.division_y = p.drawable->height / p.params.tile_height; } if (!p.drawable_has_alpha) { if (p.params.background_type == BACKGROUND_TYPE_TRANSPARENT) { p.params.background_type = BACKGROUND_TYPE_INVERTED; } gimp_rgb_set_alpha (&p.params.background_color, 1.0); } }
static void run(const gchar G_GNUC_UNUSED *nome, gint nparams, const GimpParam * params, gint *nretvals, GimpParam ** retparams) { static GimpParam ret[1]; GimpPDBStatusType* status; GimpDrawable* drawable; param_type p = VIZ4; *nretvals = 1; *retparams = ret; ret[0].type = GIMP_PDB_STATUS; status = (GimpPDBStatusType*) &(ret[0].data.d_status); *status = GIMP_PDB_CALLING_ERROR; drawable = gimp_drawable_get(params[2].data.d_drawable); if (!gimp_get_data(nome, &p)) p = VIZ4; switch (params[0].data.d_int32) { case GIMP_RUN_INTERACTIVE: if (!show_dialog(&p)) { ret[0].data.d_status = GIMP_PDB_CANCEL; return; } break; case GIMP_RUN_WITH_LAST_VALS: break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 4) { /* retorna o erro de chamadoa para o gimp */ ret[0].data.d_status = GIMP_PDB_CALLING_ERROR; return; } p = params[3].data.d_int8; break; default: g_error("programa no lugar errado"); ret[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; } gimp_set_data(nome, &p, sizeof(param_type)); *status = execute_plugin(drawable, nome, &p); ret[0].data.d_status = GIMP_PDB_SUCCESS; return; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GError *error = NULL; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; gimp_get_data (SAVE_PROC, >mvals); if (save_dialog (param[1].data.d_int32)) { GeglBuffer *buffer; buffer = gimp_drawable_get_buffer (param[2].data.d_int32); if (save_image (param[3].data.d_string, buffer, &error)) { gimp_set_data (SAVE_PROC, >mvals, sizeof (GTMValues)); } else { status = GIMP_PDB_EXECUTION_ERROR; } g_object_unref (buffer); } else { status = GIMP_PDB_CANCEL; } if (status != GIMP_PDB_SUCCESS && error) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = error->message; } values[0].data.d_status = status; }
/* ----------------------------------- * 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 */
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpExportReturn export = GIMP_EXPORT_CANCEL; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (run_mode == GIMP_RUN_INTERACTIVE && strcmp (name, SAVE_PROC) == 0) { gint32 image_ID = param[1].data.d_int32; gint32 drawable_ID = param[2].data.d_int32; GimpParasite *parasite; gchar *x; GimpImageType drawable_type = gimp_drawable_type (drawable_ID); gimp_get_data (SAVE_PROC, &config); config.prefixed_name = "gimp_image"; config.comment = NULL; config.file_name = param[3].data.d_string; config.alpha = (drawable_type == GIMP_RGBA_IMAGE || drawable_type == GIMP_GRAYA_IMAGE || drawable_type == GIMP_INDEXEDA_IMAGE); parasite = gimp_image_parasite_find (image_ID, "gimp-comment"); if (parasite) { config.comment = g_strndup (gimp_parasite_data (parasite), gimp_parasite_data_size (parasite)); gimp_parasite_free (parasite); } x = config.comment; gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_ID, "C Source",
/* ------------------------------- * 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 void gimp_aspect_preview_constructed (GObject *object) { gchar *data_name; PreviewSettings settings; G_OBJECT_CLASS (parent_class)->constructed (object); data_name = g_strdup_printf ("%s-aspect-preview-%d", g_get_prgname (), gimp_aspect_preview_counter++); if (gimp_get_data (data_name, &settings)) { gimp_preview_set_update (GIMP_PREVIEW (object), settings.update); } g_object_set_data_full (object, "gimp-aspect-preview-data-name", data_name, (GDestroyNotify) g_free); }
/* ============================================================================ * 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]; GimpRunMode run_mode; GimpDrawable *drawable; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); /* set the tile cache size */ gimp_tile_cache_ntiles (TILE_CACHE_SIZE); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; INIT_I18N(); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &cvals); /* First acquire information with a dialog */ if (! cartoon_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: cvals.mask_radius = param[3].data.d_float; cvals.pct_black = param[4].data.d_float; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &cvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is RGB or GRAY color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init ("Cartoon"); cartoon (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &cvals, sizeof (CartoonVals)); } else { status = GIMP_PDB_EXECUTION_ERROR; *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = _("Cannot operate on indexed color images."); } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; GimpPDBStatusType status; GimpDrawable *drawable; gint x1, y1, x2, y2; INIT_I18N (); status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the active drawable info */ drawable = gimp_drawable_get (param[2].data.d_drawable); img_width = gimp_drawable_width (drawable->drawable_id); img_height = gimp_drawable_height (drawable->drawable_id); img_bpp = gimp_drawable_bpp (drawable->drawable_id); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); mbvals.center_x = (gdouble) (x1 + x2 - 1) / 2.0; mbvals.center_y = (gdouble) (y1 + y2 - 1) / 2.0; /* Set the tile cache size */ gimp_tile_cache_ntiles (2 * drawable->ntile_cols); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &mbvals); /* Get information from the dialog */ if (! mblur_dialog (param[1].data.d_image, drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: if (strcmp (name, PLUG_IN_PROC_INWARD) == 0) mbvals.blur_outward = FALSE; if (nparams == 8) { mbvals.center_x = param[6].data.d_float; mbvals.center_y = param[7].data.d_float; } else if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { mbvals.mblur_type = param[3].data.d_int32; mbvals.length = param[4].data.d_int32; mbvals.angle = param[5].data.d_int32; } if ((mbvals.mblur_type < 0) || (mbvals.mblur_type > MBLUR_MAX)) status= GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &mbvals); break; default: break; } /* Blur the image */ if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb(drawable->drawable_id) || gimp_drawable_is_gray(drawable->drawable_id))) { /* Run! */ has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); mblur (drawable, NULL); /* If run mode is interactive, flush displays */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &mbvals, sizeof (mblur_vals_t)); } else if (status == GIMP_PDB_SUCCESS) status = GIMP_PDB_EXECUTION_ERROR; values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; INIT_I18N (); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &svals); /* In order to prepare the dialog I need to know wether it's grayscale or not */ drawable = gimp_drawable_get (param[2].data.d_drawable); thePreview = mw_preview_build_virgin(drawable); drawable_is_grayscale = gimp_drawable_is_gray (drawable->drawable_id); if (! sinus_dialog ()) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 17) { status = GIMP_PDB_CALLING_ERROR; } else { svals.scalex = param[3].data.d_float; svals.scaley = param[4].data.d_float; svals.cmplx = param[5].data.d_float; svals.seed = param[6].data.d_int32; svals.tiling = param[7].data.d_int32; svals.perturbation = param[8].data.d_int32; svals.colors = param[9].data.d_int32; svals.col1 = param[10].data.d_color; svals.col2 = param[11].data.d_color; gimp_rgb_set_alpha (&svals.col1, param[12].data.d_float); gimp_rgb_set_alpha (&svals.col2, param[13].data.d_float); svals.colorization = param[14].data.d_int32; svals.blend_power = param[15].data.d_float; if (svals.random_seed) svals.seed = g_random_int (); } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &svals); if (svals.random_seed) svals.seed = g_random_int (); break; default: break; } /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); /* Make sure that the drawable is gray or RGB */ if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id))) { gimp_progress_init (_("Sinus: rendering")); gimp_tile_cache_ntiles (1); sinus (); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &svals, sizeof (SinusVals)); } else { status = GIMP_PDB_EXECUTION_ERROR; } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
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; }
/* * 'run()' - Run the plug-in... */ static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[4]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; const gchar *filename = NULL; GError *error = NULL; gint32 image_ID = -1; gint width = 0; gint height = 0; INIT_I18N (); run_mode = param[0].data.d_int32; *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) { filename = param[1].data.d_string; gimp_get_data (LOAD_PROC, &load_vals); switch (run_mode) { case GIMP_RUN_NONINTERACTIVE: if (nparams > 3) load_vals.resolution = param[3].data.d_float; if (nparams > 4) load_vals.width = param[4].data.d_int32; if (nparams > 5) load_vals.height = param[5].data.d_int32; break; case GIMP_RUN_INTERACTIVE: if (!load_dialog (param[1].data.d_string)) status = GIMP_PDB_CANCEL; break; case GIMP_RUN_WITH_LAST_VALS: break; } } else if (strcmp (name, LOAD_THUMB_PROC) == 0) { gint size = param[1].data.d_int32; filename = param[0].data.d_string; if (size > 0 && load_wmf_size (filename, &load_vals) && load_vals.width > 0 && load_vals.height > 0) { width = load_vals.width; height = load_vals.height; if ((gdouble) load_vals.width > (gdouble) load_vals.height) { load_vals.width = size; load_vals.height *= size / (gdouble) load_vals.width; } else { load_vals.width *= size / (gdouble) load_vals.height; load_vals.height = size; } } else { status = GIMP_PDB_EXECUTION_ERROR; } } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { if (load_vals.resolution < GIMP_MIN_RESOLUTION || load_vals.resolution > GIMP_MAX_RESOLUTION) { load_vals.resolution = WMF_DEFAULT_RESOLUTION; } image_ID = load_image (filename, &error); if (image_ID != -1) { *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; } else { status = GIMP_PDB_EXECUTION_ERROR; } } if (status == GIMP_PDB_SUCCESS) { if (strcmp (name, LOAD_THUMB_PROC) == 0) { *nreturn_vals = 4; values[2].type = GIMP_PDB_INT32; values[2].data.d_int32 = width; values[3].type = GIMP_PDB_INT32; values[3].data.d_int32 = height; } else { gimp_set_data (LOAD_PROC, &load_vals, sizeof (load_vals)); } } if (status != GIMP_PDB_SUCCESS && error) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = error->message; } values[0].data.d_status = status; }
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; gint32 new_layer = -1; gint width; gint height; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 3; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_IMAGE; values[2].type = GIMP_PDB_LAYER; width = gimp_drawable_width (param[2].data.d_drawable); height = gimp_drawable_height (param[2].data.d_drawable); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &tvals); /* First acquire information with a dialog */ if (! tile_dialog (param[1].data.d_image, param[2].data.d_drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } else { tvals.new_width = param[3].data.d_int32; tvals.new_height = param[4].data.d_int32; tvals.new_image = param[5].data.d_int32 ? TRUE : FALSE; if (tvals.new_width < 0 || tvals.new_height < 0) status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &tvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { gimp_progress_init (_("Tiling")); values[1].data.d_image = tile (param[1].data.d_image, param[2].data.d_drawable, &new_layer); values[2].data.d_layer = new_layer; /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &tvals, sizeof (TileVals)); if (run_mode != GIMP_RUN_NONINTERACTIVE) { if (tvals.new_image) gimp_display_new (values[1].data.d_image); else gimp_displays_flush (); } } values[0].data.d_status = status; }
/* --------------------------------- * run * --------------------------------- */ static void run(const gchar *name , gint n_params , const GimpParam *param , gint *nreturn_vals , GimpParam **return_vals) { const gchar *l_env; static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GapBlueboxGlobalParams *bbp; gint32 l_rc; *nreturn_vals = 1; *return_vals = values; l_rc = 0; INIT_I18N(); l_env = g_getenv("GAP_DEBUG"); if(l_env != NULL) { if((*l_env != 'n') && (*l_env != 'N')) gap_debug = 1; } bbp = gap_bluebox_bbp_new(param[2].data.d_drawable); run_mode = param[0].data.d_int32; bbp->run_mode = param[0].data.d_int32; bbp->image_id = param[1].data.d_image; gimp_image_undo_group_start (bbp->image_id); gap_bluebox_init_default_vals(bbp); if(gap_debug) printf("\n\ngap_bluebox main: debug name = %s\n", name); if (strcmp (name, GAP_BLUEBOX_PLUGIN_NAME) == 0) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: { /* Possibly retrieve data */ gimp_get_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals); l_rc = gap_bluebox_dialog(bbp); if(l_rc < 0) { status = GIMP_PDB_CANCEL; } } break; case GIMP_RUN_NONINTERACTIVE: { if (n_params != G_N_ELEMENTS (args_bluebox)) { status = GIMP_PDB_CALLING_ERROR; } else { bbp->vals.keycolor = param[3].data.d_color; bbp->vals.thres_mode = param[4].data.d_int32; bbp->vals.thres_r = param[5].data.d_float; bbp->vals.thres_g = param[6].data.d_float; bbp->vals.thres_b = param[7].data.d_float; bbp->vals.thres_h = param[8].data.d_float; bbp->vals.thres_s = param[9].data.d_float; bbp->vals.thres_v = param[10].data.d_float; bbp->vals.thres = param[11].data.d_float; bbp->vals.tolerance = param[12].data.d_float; bbp->vals.grow = (gdouble)param[13].data.d_int32; bbp->vals.feather_edges = param[14].data.d_int32; bbp->vals.feather_radius = param[15].data.d_float; bbp->vals.source_alpha = param[16].data.d_float; bbp->vals.target_alpha = param[17].data.d_float; bbp->run_flag = TRUE; } } break; case GIMP_RUN_WITH_LAST_VALS: { /* Possibly retrieve data */ gimp_get_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals); bbp->run_flag = TRUE; } break; default: break; } } if(status == GIMP_PDB_SUCCESS) { bbp->layer_id = bbp->drawable_id; l_rc = gap_bluebox_apply(bbp); if(l_rc < 0) { status = GIMP_PDB_EXECUTION_ERROR; } else { gimp_set_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals, sizeof (bbp->vals)); } } gimp_image_undo_group_end (bbp->image_id); /* ---------- return handling --------- */ values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; } /* end run */
void browser_dialog_open (const gchar *plug_in_binary) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *paned; GtkWidget *scrolled; GtkToolItem *item; GtkAction *action; DialogData data = { 720, 560, 240, TRUE, 1.0 }; gimp_ui_init (plug_in_binary, TRUE); gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data); /* the dialog window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser")); gtk_window_set_role (GTK_WINDOW (window), plug_in_binary); gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); window_set_icons (window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); ui_manager = ui_manager_new (window); toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show (toolbar); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/forward"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_next = GTK_WIDGET (item); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/back"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_prev = GTK_WIDGET (item); item = GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/space")); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_tool_item_set_expand (item, TRUE); /* the horizontal paned */ paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); gtk_widget_show (paned); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled); gtk_paned_set_position (GTK_PANED (paned), data.paned_position); sidebar = scrolled; if (data.show_index) gtk_widget_show (sidebar); tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_container_add (GTK_CONTAINER (scrolled), tree_view); gtk_widget_show (tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, NULL, gtk_cell_renderer_text_new (), "text", 1, NULL); g_signal_connect (tree_view, "row-activated", G_CALLBACK (row_activated), NULL); /* HTML view */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (main_vbox); gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled, 300, 200); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show (scrolled); view = webkit_web_view_new (); webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view), TRUE); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_widget_show (view); g_signal_connect (view, "realize", G_CALLBACK (view_realize), NULL); g_signal_connect (view, "unrealize", G_CALLBACK (view_unrealize), NULL); g_signal_connect (view, "popup-menu", G_CALLBACK (view_popup_menu), NULL); g_signal_connect (view, "button-press-event", G_CALLBACK (view_button_press), NULL); g_signal_connect (view, "key-press-event", G_CALLBACK (view_key_press), NULL); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom); g_signal_connect (view, "title-changed", G_CALLBACK (title_changed), window); g_signal_connect (view, "load-started", G_CALLBACK (load_started), NULL); g_signal_connect (view, "load-finished", G_CALLBACK (load_finished), NULL); gtk_widget_grab_focus (view); g_signal_connect (window, "unmap", G_CALLBACK (dialog_unmap), paned); update_actions (); /* Searchbar */ searchbar = build_searchbar (); gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0); }
/* A function that takes care of loading the basic * parameters */ static gboolean init_vals (const gchar *name, gint nparams, const GimpParam *param, gboolean *single_image, gboolean *defaults_proc, GimpRunMode *run_mode) { gboolean had_saved_list = FALSE; gboolean single; gboolean defaults = FALSE; gint32 i; gint32 image; if (g_str_equal (name, SAVE_PROC)) { single = TRUE; if (nparams != SA_ARG_COUNT && nparams != SA_ARG_COUNT_DEFAULT) return FALSE; *run_mode = param[SA_RUN_MODE].data.d_int32; image = param[SA_IMAGE].data.d_int32; file_name = param[SA_FILENAME].data.d_string; if (nparams == SA_ARG_COUNT) { optimize.apply_masks = param[SA_APPLY_MASKS].data.d_int32; optimize.vectorize = param[SA_VECTORIZE].data.d_int32; optimize.ignore_hidden = param[SA_IGNORE_HIDDEN].data.d_int32; } else defaults = TRUE; } else if (g_str_equal (name, SAVE_MULTI_PROC)) { single = FALSE; if (nparams != SMA_ARG_COUNT) return FALSE; *run_mode = param[SMA_RUN_MODE].data.d_int32; image = -1; file_name = param[SA_FILENAME].data.d_string; optimize.apply_masks = param[SMA_APPLY_MASKS].data.d_int32; optimize.vectorize = param[SMA_VECTORIZE].data.d_int32; optimize.ignore_hidden = param[SMA_IGNORE_HIDDEN].data.d_int32; } else return FALSE; switch (*run_mode) { case GIMP_RUN_NONINTERACTIVE: if (single) { init_image_list_defaults (image); } else { multi_page.image_count = param[SMA_COUNT].data.d_int32; if (param[SMA_IMAGES].data.d_int32array != NULL) for (i = 0; i < param[SMA_COUNT].data.d_int32; i++) multi_page.images[i] = param[SMA_IMAGES].data.d_int32array[i]; } break; case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (DATA_OPTIMIZE, &optimize); had_saved_list = gimp_get_data (DATA_IMAGE_LIST, &multi_page); if (had_saved_list && (file_name == NULL || strlen (file_name) == 0)) { file_name = multi_page.file_name; } if (single || ! had_saved_list ) init_image_list_defaults (image); break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ if (!single) { had_saved_list = gimp_get_data (DATA_IMAGE_LIST, &multi_page); if (had_saved_list) { file_name = multi_page.file_name; } } else { init_image_list_defaults (image); } gimp_get_data (DATA_OPTIMIZE, &optimize); break; } *defaults_proc = defaults; *single_image = single; validate_image_list (); return TRUE; }
static void run (const gchar *name, gint n_params, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; gint32 image_ID; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; *nreturn_vals = 1; *return_vals = values; /* Initialize i18n support */ bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); run_mode = param[0].data.d_int32; image_ID = param[1].data.d_int32; drawable = gimp_drawable_get(param[2].data.d_drawable); /* Initialize with default values */ vals = default_vals; image_vals = default_image_vals; drawable_vals = default_drawable_vals; ui_vals = default_ui_vals; if (strcmp (name, PROCEDURE_NAME) == 0) { switch (run_mode) { case GIMP_RUN_NONINTERACTIVE: if (n_params != 8) { status = GIMP_PDB_CALLING_ERROR; } else { vals.SampleTileWidth = param[3].data.d_int32; vals.SampleTileHeight = param[4].data.d_int32; vals.ActualTileWidth = param[5].data.d_int32; vals.ActualTileHeight = param[6].data.d_int32; vals.DestinationWidth = param[7].data.d_int32; vals.DestinationHeight = param[8].data.d_int32; vals.SourceWidth = param[9].data.d_int32; vals.SourceHeight = param[10].data.d_int32; vals.MetricType = param[11].data.d_int8; vals.minMetric = param[12].data.d_float; } break; case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (DATA_KEY_VALS, &vals); gimp_get_data (DATA_KEY_UI_VALS, &ui_vals); if (! dialog (image_ID, drawable, &vals, &image_vals, &drawable_vals, &ui_vals)) { status = GIMP_PDB_CANCEL; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (DATA_KEY_VALS, &vals); break; default: break; } } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { render (image_ID, drawable, &vals, &image_vals, &drawable_vals); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (DATA_KEY_VALS, &vals, sizeof (vals)); gimp_set_data (DATA_KEY_UI_VALS, &ui_vals, sizeof (ui_vals)); } gimp_drawable_detach (drawable); } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; gint32 image_ID; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified image and drawable */ image_ID = param[1].data.d_image; drawable = gimp_drawable_get (param[2].data.d_drawable); /* set the tile cache size so that the gaussian blur works well */ gimp_tile_cache_ntiles (2 * (MAX (drawable->width, drawable->height) / gimp_tile_width () + 1)); if (strcmp (name, PLUG_IN_PROC) == 0) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &dogvals); /* First acquire information with a dialog */ if (! dog_dialog (image_ID, drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 7) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { dogvals.inner = param[3].data.d_float; dogvals.outer = param[4].data.d_float; dogvals.normalize = param[5].data.d_int32; dogvals.invert = param[6].data.d_int32; } if (status == GIMP_PDB_SUCCESS && (dogvals.inner <= 0.0 && dogvals.outer <= 0.0)) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &dogvals); break; default: break; } } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("DoG Edge Detect")); /* run the Difference of Gaussians */ gimp_image_undo_group_start (image_ID); dog (image_ID, drawable, dogvals.inner, dogvals.outer, TRUE); gimp_image_undo_group_end (image_ID); gimp_progress_update (1.0); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &dogvals, sizeof (DoGValues)); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else { g_message (_("Cannot operate on indexed color images.")); status = GIMP_PDB_EXECUTION_ERROR; } gimp_drawable_detach (drawable); } values[0].data.d_status = status; }
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; gint pwidth; gint pheight; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint sel_width; gint sel_height; run_mode = param[0].data.d_int32; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); image_ID = param[1].data.d_image; gimp_drawable_mask_bounds (drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2); sel_width = sel_x2 - sel_x1; sel_height = sel_y2 - sel_y1; /* Calculate preview size */ if (sel_width > sel_height) { pwidth = MIN (sel_width, PREVIEW_SIZE); pheight = sel_height * pwidth / sel_width; } else { pheight = MIN (sel_height, PREVIEW_SIZE); pwidth = sel_width * pheight / sel_height; } preview_width = MAX (pwidth, 2); preview_height = MAX (pheight, 2); /* See how we will run */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data ("plug_in_fractalexplorer", &wvals); /* Get information from the dialog */ if (!explorer_dialog ()) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are present */ if (nparams != 22) { status = GIMP_PDB_CALLING_ERROR; } else { wvals.fractaltype = param[3].data.d_int8; wvals.xmin = param[4].data.d_float; wvals.xmax = param[5].data.d_float; wvals.ymin = param[6].data.d_float; wvals.ymax = param[7].data.d_float; wvals.iter = param[8].data.d_float; wvals.cx = param[9].data.d_float; wvals.cy = param[10].data.d_float; wvals.colormode = param[11].data.d_int8; wvals.redstretch = param[12].data.d_float; wvals.greenstretch = param[13].data.d_float; wvals.bluestretch = param[14].data.d_float; wvals.redmode = param[15].data.d_int8; wvals.greenmode = param[16].data.d_int8; wvals.bluemode = param[17].data.d_int8; wvals.redinvert = param[18].data.d_int8; wvals.greeninvert = param[19].data.d_int8; wvals.blueinvert = param[20].data.d_int8; wvals.ncolors = CLAMP (param[21].data.d_int32, 2, MAXNCOLORS); } make_color_map(); break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data ("plug_in_fractalexplorer", &wvals); make_color_map (); break; default: break; } xmin = wvals.xmin; xmax = wvals.xmax; ymin = wvals.ymin; ymax = wvals.ymax; cx = wvals.cx; cy = wvals.cy; if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is not indexed */ if (! gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_progress_init (_("Rendering fractal")); /* Set the tile cache size */ gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width() + 1)); /* Run! */ explorer (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data ("plug_in_fractalexplorer", &wvals, sizeof (explorer_vals_t)); } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_ID; gint32 drawable_ID; INIT_I18N (); run_mode = param[0].data.d_int32; image_ID = param[1].data.d_image; drawable_ID = param[2].data.d_drawable; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (strcmp (name, PLUG_IN_PROC) == 0) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &mail_info); { gchar *filename = gimp_image_get_filename (image_ID); if (filename) { gchar *basename = g_filename_display_basename (filename); g_strlcpy (mail_info.filename, basename, BUFFER_SIZE); g_free (basename); g_free (filename); } } if (! save_dialog ()) status = GIMP_PDB_CANCEL; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams < 8) { status = GIMP_PDB_CALLING_ERROR; } else { g_strlcpy (mail_info.filename, param[3].data.d_string, BUFFER_SIZE); g_strlcpy (mail_info.receipt, param[4].data.d_string, BUFFER_SIZE); g_strlcpy (mail_info.from, param[5].data.d_string, BUFFER_SIZE); g_strlcpy (mail_info.subject, param[6].data.d_string, BUFFER_SIZE); g_strlcpy (mail_info.comment, param[7].data.d_string, BUFFER_SIZE); } break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &mail_info); break; default: break; } if (status == GIMP_PDB_SUCCESS) { status = save_image (mail_info.filename, image_ID, drawable_ID, run_mode); if (status == GIMP_PDB_SUCCESS) { if (mesg_body) g_strlcpy (mail_info.comment, mesg_body, BUFFER_SIZE); gimp_set_data (PLUG_IN_PROC, &mail_info, sizeof (m_info)); } } } else { status = GIMP_PDB_CALLING_ERROR; } values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_int32); INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: if (strcmp (name, VPROPAGATE_PROC) == 0) { gimp_get_data (VPROPAGATE_PROC, &vpvals); /* building the values of dialog variables from vpvals. */ propagate_alpha = (vpvals.propagating_channel & PROPAGATING_ALPHA) ? TRUE : FALSE; propagate_value = (vpvals.propagating_channel & PROPAGATING_VALUE) ? TRUE : FALSE; { gint i; for (i = 0; i < 4; i++) direction_mask_vec[i] = (vpvals.direction_mask & (1 << i)) ? TRUE : FALSE; } if (! vpropagate_dialog (drawable)) return; } else if (strcmp (name, ERODE_PROC) == 0 || strcmp (name, DILATE_PROC) == 0) { vpvals.propagating_channel = PROPAGATING_VALUE; vpvals.propagating_rate = 1.0; vpvals.direction_mask = 15; vpvals.lower_limit = 0; vpvals.upper_limit = 255; if (strcmp (name, ERODE_PROC) == 0) vpvals.propagate_mode = 1; else if (strcmp (name, DILATE_PROC) == 0) vpvals.propagate_mode = 0; } break; case GIMP_RUN_NONINTERACTIVE: if (strcmp (name, VPROPAGATE_PROC) == 0) { vpvals.propagate_mode = param[3].data.d_int32; vpvals.propagating_channel = param[4].data.d_int32; vpvals.propagating_rate = param[5].data.d_float; vpvals.direction_mask = param[6].data.d_int32; vpvals.lower_limit = param[7].data.d_int32; vpvals.upper_limit = param[8].data.d_int32; } else if (strcmp (name, ERODE_PROC) == 0 || strcmp (name, DILATE_PROC) == 0) { vpvals.propagating_channel = PROPAGATING_VALUE; vpvals.propagating_rate = 1.0; vpvals.direction_mask = 15; vpvals.lower_limit = 0; vpvals.upper_limit = 255; if (strcmp (name, ERODE_PROC) == 0) vpvals.propagate_mode = 1; else if (strcmp (name, DILATE_PROC) == 0) vpvals.propagate_mode = 0; } break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (name, &vpvals); break; } status = value_propagate (drawable); if (status == GIMP_PDB_SUCCESS) { if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (name, &vpvals, sizeof (VPValueType)); } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
/* * run * * The plug-in is being requested to run. * Capture an window image. */ static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpRunMode run_mode; /* Initialize the return values * Always return at least the status to the caller. */ values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_SUCCESS; *nreturn_vals = 1; *return_vals = values; /* Get the runmode from the in-parameters */ run_mode = param[0].data.d_int32; INIT_I18N (); /* Set up the rest of the return parameters */ values[1].type = GIMP_PDB_INT32; values[1].data.d_int32 = 0; /* Get the data from last run */ gimp_get_data (PLUG_IN_PROC, &winsnapvals); /* How are we running today? */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Get information from the dialog */ if (!snap_dialog()) return; break; case GIMP_RUN_NONINTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: if (!winsnapvals.root) values[0].data.d_status = GIMP_PDB_CALLING_ERROR; break; default: break; } /* switch */ /* Do the actual window capture */ if (winsnapvals.root) doRootWindowCapture(); else doWindowCapture(); /* Check to make sure we got at least one valid * image. */ if (values[1].data.d_int32 > 0) { /* A window was captured. * Do final Interactive steps. */ if (run_mode == GIMP_RUN_INTERACTIVE) { /* Store variable states for next run */ gimp_set_data (PLUG_IN_PROC, &winsnapvals, sizeof(WinSnapValues)); } /* Set return values */ *nreturn_vals = 2; } else { values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; } }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpDrawable *drawable; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_tile_cache_ntiles (2 * (drawable->ntile_cols)); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, >vals); /* First acquire information with a dialog */ if (! glasstile_dialog (drawable)) { gimp_drawable_detach (drawable); return; } break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 5) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { gtvals.xblock = (gint) param[3].data.d_int32; gtvals.yblock = (gint) param[4].data.d_int32; } if (gtvals.xblock < 10 || gtvals.xblock > 50) status = GIMP_PDB_CALLING_ERROR; if (gtvals.yblock < 10 || gtvals.yblock > 50) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, >vals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Glass Tile")); glasstile (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (PLUG_IN_PROC, >vals, sizeof (GlassValues)); } } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PIXELIZE_PROC, &pvals); /* First acquire information with a dialog */ if (! pixelize_dialog (drawable)) { gimp_drawable_detach (drawable); return; } break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if ((! strcmp (name, PIXELIZE_PROC) && nparams != 4) || (! strcmp (name, PIXELIZE2_PROC) && nparams != 5)) { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { pvals.pixelwidth = (gdouble) param[3].data.d_int32; if (nparams == 4) pvals.pixelheight = pvals.pixelwidth; else pvals.pixelheight = (gdouble) param[4].data.d_int32; } if ((status == GIMP_PDB_SUCCESS) && (pvals.pixelwidth <= 0 || pvals.pixelheight <= 0)) { status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PIXELIZE_PROC, &pvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Pixelizing")); /* set the tile cache size */ gimp_tile_cache_ntiles (TILE_CACHE_SIZE); /* run the pixelize effect */ pixelize (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PIXELIZE_PROC, &pvals, sizeof (PixelizeValues)); } else { /* g_message ("pixelize: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpRunMode run_mode = param[0].data.d_int32; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GdkScreen *screen = NULL; gint32 image_ID; static GimpParam values[2]; /* initialize the return of the status */ values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); /* how are we running today? */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data from a previous run */ gimp_get_data (PLUG_IN_PROC, &shootvals); shootvals.window_id = 0; /* Get information from the dialog */ if (! shoot_dialog (&screen)) status = GIMP_PDB_CANCEL; break; case GIMP_RUN_NONINTERACTIVE: if (nparams == 3) { gboolean do_root = param[1].data.d_int32; shootvals.shoot_type = do_root ? SHOOT_ROOT : SHOOT_WINDOW; shootvals.window_id = param[2].data.d_int32; shootvals.select_delay = 0; } else if (nparams == 7) { shootvals.shoot_type = SHOOT_REGION; shootvals.window_id = param[2].data.d_int32; shootvals.select_delay = 0; shootvals.x1 = param[3].data.d_int32; shootvals.y1 = param[4].data.d_int32; shootvals.x2 = param[5].data.d_int32; shootvals.y2 = param[6].data.d_int32; } else { status = GIMP_PDB_CALLING_ERROR; } if (! gdk_init_check (NULL, NULL)) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data from a previous run */ gimp_get_data (PLUG_IN_PROC, &shootvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { if (shootvals.select_delay > 0) shoot_delay (shootvals.select_delay); if (shootvals.shoot_type != SHOOT_ROOT && ! shootvals.window_id) { shootvals.window_id = select_window (screen); if (! shootvals.window_id) status = GIMP_PDB_CANCEL; } } if (status == GIMP_PDB_SUCCESS) { image_ID = shoot (screen); if (image_ID == -1) status = GIMP_PDB_EXECUTION_ERROR; } if (status == GIMP_PDB_SUCCESS) { if (run_mode == GIMP_RUN_INTERACTIVE) { /* Store variable states for next run */ gimp_set_data (PLUG_IN_PROC, &shootvals, sizeof (ScreenshotValues)); gimp_display_new (image_ID); } /* set return values */ *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; } values[0].data.d_status = status; }