void loadgame::show_dialog(bool show_replay, bool allow_network) { //FIXME: Integrate the load_game dialog into this class //something to watch for the curious, but not yet ready to go gui2::tgame_load load_dialog(gui_, heros_, game_config_, allow_network); load_dialog.show(gui_.video()); if (load_dialog.get_retval() == gui2::twindow::OK){ filename_ = load_dialog.filename(); show_replay_ = false; } }
void loadgame::show_dialog(bool show_replay, bool cancel_orders) { //FIXME: Integrate the load_game dialog into this class //something to watch for the curious, but not yet ready to go if (gui2::new_widgets){ gui2::tgame_load load_dialog(game_config_); load_dialog.show(gui_.video()); if (load_dialog.get_retval() == gui2::twindow::OK) { select_difficulty_ = load_dialog.change_difficulty(); filename_ = load_dialog.filename(); show_replay_ = load_dialog.show_replay(); cancel_orders_ = load_dialog.cancel_orders(); } } else { bool show_replay_dialog = show_replay; bool cancel_orders_dialog = cancel_orders; filename_ = dialogs::load_game_dialog(gui_, game_config_, &select_difficulty_, &show_replay_dialog, &cancel_orders_dialog); show_replay_ = show_replay_dialog; cancel_orders_ = cancel_orders_dialog; } }
/* * '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; }
void run( const gchar* plugin_name, gint nparams, const GimpParam* param, gint* nreturn_vals, GimpParam** return_vals, enum pix_fmt fmt, struct raw_data* img_data ) { static GimpParam values[2]; GimpRunMode run_mode; gchar* check_button_label; gint32 img = ERROR; if (!img_data) goto call_error; run_mode = param[0].data.d_int32; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_SUCCESS; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = ERROR; *return_vals = values; *nreturn_vals = 2; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data(plugin_name, img_data); switch(fmt) { case RGB_888: check_button_label = "BGR"; break; case UYVY_422: check_button_label = "YUYV"; break; default: check_button_label = NULL; break; } if (!load_dialog(img_data, check_button_label)) goto exec_error; break; case GIMP_RUN_NONINTERACTIVE: /* TODO */ goto call_error; break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data(plugin_name, img_data); break; } if (img_data->checked) { switch(fmt) { case RGB_888: fmt = BGR_888; break; case UYVY_422: fmt = YUYV_422; break; default: break; } } img = open_raw(param[1].data.d_string, fmt, img_data, plugin_name); if (img == ERROR) goto exec_error; if (run_mode != GIMP_RUN_INTERACTIVE) { gimp_image_clean_all(img); } else { gimp_set_data(plugin_name, img_data, sizeof(struct raw_data)); } values[0].data.d_status = GIMP_PDB_SUCCESS; values[1].data.d_image = img; return; call_error: values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; exec_error: values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[6]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_ID = -1; PopplerDocument *doc = NULL; GError *error = NULL; 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 = GIMP_PDB_EXECUTION_ERROR; if (! g_thread_supported ()) g_thread_init (NULL); if (strcmp (name, LOAD_PROC) == 0) { PdfSelectedPages pages = { 0, NULL }; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve last settings */ gimp_get_data (LOAD_PROC, &loadvals); doc = open_document (param[1].data.d_string, &error); if (!doc) { status = GIMP_PDB_EXECUTION_ERROR; break; } if (load_dialog (doc, &pages)) gimp_set_data (LOAD_PROC, &loadvals, sizeof(loadvals)); else status = GIMP_PDB_CANCEL; break; case GIMP_RUN_WITH_LAST_VALS: /* FIXME: implement last vals mode */ status = GIMP_PDB_EXECUTION_ERROR; break; case GIMP_RUN_NONINTERACTIVE: doc = open_document (param[1].data.d_string, &error); if (doc) { PopplerPage *test_page = poppler_document_get_page (doc, 0); if (test_page) { pages.n_pages = 1; pages.pages = g_new (gint, 1); pages.pages[0] = 0; g_object_unref (test_page); } else { status = GIMP_PDB_EXECUTION_ERROR; g_object_unref (doc); } } else { status = GIMP_PDB_EXECUTION_ERROR; } break; } if (status == GIMP_PDB_SUCCESS) { image_ID = load_image (doc, param[1].data.d_string, run_mode, loadvals.target, loadvals.resolution, &pages); 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 (doc) g_object_unref (doc); g_free (pages.pages); } else if (strcmp (name, LOAD_THUMB_PROC) == 0) { if (nparams < 2) { status = GIMP_PDB_CALLING_ERROR; } else { gdouble width = 0; gdouble height = 0; gdouble scale; gint32 image = -1; gint num_pages = 0; GdkPixbuf *pixbuf = NULL; /* Possibly retrieve last settings */ gimp_get_data (LOAD_PROC, &loadvals); doc = open_document (param[0].data.d_string, &error); if (doc) { PopplerPage *page = poppler_document_get_page (doc, 0); if (page) { poppler_page_get_size (page, &width, &height); g_object_unref (page); } num_pages = poppler_document_get_n_pages (doc); pixbuf = get_thumbnail (doc, 0, param[1].data.d_int32); g_object_unref (doc); } if (pixbuf) { image = gimp_image_new (gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), GIMP_RGB); gimp_image_undo_disable (image); layer_from_pixbuf (image, "thumbnail", 0, pixbuf, 0.0, 1.0); g_object_unref (pixbuf); gimp_image_undo_enable (image); gimp_image_clean_all (image); } scale = loadvals.resolution / gimp_unit_get_factor (GIMP_UNIT_POINT); width *= scale; height *= scale; if (image != -1) { *nreturn_vals = 6; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image; values[2].type = GIMP_PDB_INT32; values[2].data.d_int32 = width; values[3].type = GIMP_PDB_INT32; values[3].data.d_int32 = height; values[4].type = GIMP_PDB_INT32; values[4].data.d_int32 = GIMP_RGB_IMAGE; values[5].type = GIMP_PDB_INT32; values[5].data.d_int32 = num_pages; } else { status = GIMP_PDB_EXECUTION_ERROR; } } } else { status = GIMP_PDB_CALLING_ERROR; } 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[5]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; gint32 pc; gint32 image_ID; gint32 drawable_ID; gint32 orig_image_ID; GimpExportReturn export = GIMP_EXPORT_CANCEL; GError *error = NULL; INIT_I18N (); gegl_init (NULL, NULL); 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) { switch (run_mode) { case GIMP_RUN_NONINTERACTIVE: /* * check for valid parameters: * (Or can I trust GIMP ?) */ if ((nparams < G_N_ELEMENTS (load_args) - 2) || (G_N_ELEMENTS (load_args) < nparams)) { status = GIMP_PDB_CALLING_ERROR; break; } for (pc = 0; pc < G_N_ELEMENTS (load_args) - 2; pc++) { if (load_args[pc].type != param[pc].type) { status = GIMP_PDB_CALLING_ERROR; break; } } for (pc = G_N_ELEMENTS (load_args) - 2; pc < nparams; pc++) { if (load_args[pc].type != param[pc].type) { status = GIMP_PDB_CALLING_ERROR; break; } } to_frame = ((nparams < G_N_ELEMENTS (load_args) - 1) ? 1 : param[3].data.d_int32); from_frame = ((nparams < G_N_ELEMENTS (load_args)) ? -1 : param[4].data.d_int32); image_ID = load_image (param[1].data.d_string, from_frame, to_frame, &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; } break; case GIMP_RUN_INTERACTIVE: if (load_dialog (param[1].data.d_string)) { image_ID = load_image (param[1].data.d_string, from_frame, to_frame, &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; } } else { status = GIMP_PDB_CANCEL; } break; case GIMP_RUN_WITH_LAST_VALS: status = GIMP_PDB_CALLING_ERROR; break; } } else if (strcmp (name, SAVE_PROC) == 0) { image_ID = orig_image_ID = param[1].data.d_int32; drawable_ID = param[2].data.d_int32; switch (run_mode) { case GIMP_RUN_NONINTERACTIVE: if (nparams != G_N_ELEMENTS (save_args)) { status = GIMP_PDB_CALLING_ERROR; break; } for (pc = 0; pc < G_N_ELEMENTS (save_args); pc++) { if (save_args[pc].type!=param[pc].type) { status = GIMP_PDB_CALLING_ERROR; break; } } if (! save_image (param[3].data.d_string, image_ID, param[5].data.d_int32, param[6].data.d_int32, &error)) { status = GIMP_PDB_EXECUTION_ERROR; } break; 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, NULL, GIMP_EXPORT_CAN_HANDLE_INDEXED | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_ALPHA | GIMP_EXPORT_CAN_HANDLE_LAYERS); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } if (save_dialog (param[1].data.d_image)) { if (! save_image (param[3].data.d_string, image_ID, from_frame, to_frame, &error)) { status = GIMP_PDB_EXECUTION_ERROR; } } else { status = GIMP_PDB_CANCEL; } break; }
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; GError *error = NULL; 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; /* MUST call this before any RSVG funcs */ g_type_init (); if (strcmp (name, LOAD_PROC) == 0) { 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; if (nparams > 6) { load_vals.import = param[6].data.d_int32 != FALSE; load_vals.merge = param[6].data.d_int32 > TRUE; } break; case GIMP_RUN_INTERACTIVE: status = load_dialog (param[1].data.d_string, &error); break; case GIMP_RUN_WITH_LAST_VALS: break; } /* Don't clamp this; insane values are probably not meant to be * used as resolution anyway. */ if (load_vals.resolution < GIMP_MIN_RESOLUTION || load_vals.resolution > GIMP_MAX_RESOLUTION) { load_vals.resolution = SVG_DEFAULT_RESOLUTION; } if (status == GIMP_PDB_SUCCESS) { const gchar *filename = param[1].data.d_string; gint32 image_ID = load_image (filename, &error); if (image_ID != -1) { if (load_vals.import) { gint32 *vectors; gint num_vectors; gimp_vectors_import_from_file (image_ID, filename, load_vals.merge, TRUE, &num_vectors, &vectors); if (num_vectors > 0) g_free (vectors); } *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; } else { status = GIMP_PDB_EXECUTION_ERROR; } gimp_set_data (LOAD_PROC, &load_vals, sizeof (load_vals)); } } else if (strcmp (name, LOAD_THUMB_PROC) == 0) { if (nparams < 2) { status = GIMP_PDB_CALLING_ERROR; } else { const gchar *filename = param[0].data.d_string; gint width = 0; gint height = 0; gint32 image_ID; if (load_rsvg_size (filename, &load_vals, NULL)) { width = load_vals.width; height = load_vals.height; } load_vals.resolution = SVG_DEFAULT_RESOLUTION; load_vals.width = - param[1].data.d_int32; load_vals.height = - param[1].data.d_int32; image_ID = load_image (filename, &error); if (image_ID != -1) { *nreturn_vals = 4; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; 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 { status = GIMP_PDB_EXECUTION_ERROR; } } } else { status = GIMP_PDB_CALLING_ERROR; } 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[2]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GError *error = NULL; gint32 image; TiffSelectedPages pages; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; gegl_init (NULL, NULL); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; TIFFSetWarningHandler (tiff_warning); TIFFSetErrorHandler (tiff_error); if (strcmp (name, LOAD_PROC) == 0) { const gchar *filename = param[1].data.d_string; TIFF *tif = NULL; gint fd; fd = g_open (filename, O_RDONLY | _O_BINARY, 0); if (fd == -1) { g_set_error (&error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), g_strerror (errno)); status = GIMP_PDB_EXECUTION_ERROR; } else { tif = TIFFFdOpen (fd, filename, "r"); } if (tif) { gimp_get_data (LOAD_PROC, &target); pages.n_pages = pages.o_pages = TIFFNumberOfDirectories (tif); if (pages.n_pages == 0) { g_set_error (&error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("TIFF '%s' does not contain any directories"), gimp_filename_to_utf8 (filename)); status = GIMP_PDB_EXECUTION_ERROR; } else { gboolean run_it = FALSE; gint i; if (run_mode != GIMP_RUN_INTERACTIVE) { pages.pages = g_new (gint, pages.n_pages); for (i = 0; i < pages.n_pages; i++) pages.pages[i] = i; run_it = TRUE; } if (pages.n_pages == 1) { target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; pages.pages = g_new0 (gint, pages.n_pages); run_it = TRUE; } if ((! run_it) && (run_mode == GIMP_RUN_INTERACTIVE)) run_it = load_dialog (tif, &pages); if (run_it) { gimp_set_data (LOAD_PROC, &target, sizeof (target)); image = load_image (param[1].data.d_string, tif, &pages, &error); g_free (pages.pages); 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 { status = GIMP_PDB_CANCEL; } } TIFFClose (tif); close (fd); } else { close (fd); status = GIMP_PDB_EXECUTION_ERROR; } } else { status = GIMP_PDB_CALLING_ERROR; } 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[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GError *error = NULL; gint32 image_id; gint32 drawable_id; GimpExportReturn export = GIMP_EXPORT_CANCEL; INIT_I18N (); gegl_init (NULL, NULL); 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; /* allocate config structure and fill with defaults */ runtime = g_new0 (RawConfig, 1); runtime->file_offset = 0; runtime->image_width = PREVIEW_SIZE; runtime->image_height = PREVIEW_SIZE; runtime->palette_offset = 0; runtime->palette_type = RAW_PALETTE_RGB; if (strcmp (name, LOAD_PROC) == 0) { if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_get_data (LOAD_PROC, runtime); preview_fd = g_open (param[1].data.d_string, O_RDONLY, 0); if (preview_fd < 0) { g_set_error (&error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (param[1].data.d_string), g_strerror (errno)); status = GIMP_PDB_EXECUTION_ERROR; } else { if (! load_dialog (param[1].data.d_string)) status = GIMP_PDB_CANCEL; close (preview_fd); } } else { /* we only run interactively due to the nature of this plugin. * things like generate preview etc like to call us non- * interactively. here we stop that. */ status = GIMP_PDB_CALLING_ERROR; } /* we are okay, and the user clicked OK in the load dialog */ if (status == GIMP_PDB_SUCCESS) { image_id = load_image (param[1].data.d_string, &error); if (image_id != -1) { gimp_set_data (LOAD_PROC, runtime, sizeof (RawConfig)); *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_id; } 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; /* export the image */ export = gimp_export_image (&image_id, &drawable_id, "RAW",
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; GError *error = NULL; INIT_I18N (); gegl_init (NULL, NULL); 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) { const gchar *filename = param[1].data.d_string; TIFF *tif; tif = tiff_open (filename, "r", &error); if (tif) { TiffSelectedPages pages; pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; gimp_get_data (LOAD_PROC, &pages.target); pages.n_pages = pages.o_pages = TIFFNumberOfDirectories (tif); if (pages.n_pages == 0) { g_set_error (&error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("TIFF '%s' does not contain any directories"), gimp_filename_to_utf8 (filename)); status = GIMP_PDB_EXECUTION_ERROR; } else { gboolean run_it = FALSE; gint i; if (run_mode != GIMP_RUN_INTERACTIVE) { pages.pages = g_new (gint, pages.n_pages); for (i = 0; i < pages.n_pages; i++) pages.pages[i] = i; run_it = TRUE; } else { gimp_ui_init (PLUG_IN_BINARY, FALSE); } if (pages.n_pages == 1) { pages.pages = g_new0 (gint, pages.n_pages); pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; run_it = TRUE; } if ((! run_it) && (run_mode == GIMP_RUN_INTERACTIVE)) run_it = load_dialog (tif, LOAD_PROC, &pages); if (run_it) { gint32 image; gboolean resolution_loaded = FALSE; gimp_set_data (LOAD_PROC, &pages.target, sizeof (pages.target)); image = load_image (param[1].data.d_string, tif, &pages, &resolution_loaded, &error); g_free (pages.pages); if (image > 0) { GFile *file; GimpMetadata *metadata; file = g_file_new_for_path (param[1].data.d_string); metadata = gimp_image_metadata_load_prepare (image, "image/tiff", file, NULL); if (metadata) { GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL; if (resolution_loaded) flags &= ~GIMP_METADATA_LOAD_RESOLUTION; gimp_image_metadata_load_finish (image, "image/tiff", metadata, flags, run_mode == GIMP_RUN_INTERACTIVE); g_object_unref (metadata); } g_object_unref (file); *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image; } else { status = GIMP_PDB_EXECUTION_ERROR; } } else { status = GIMP_PDB_CANCEL; } } TIFFClose (tif); } else { status = GIMP_PDB_EXECUTION_ERROR; } } else if ((strcmp (name, SAVE_PROC) == 0) || (strcmp (name, SAVE2_PROC) == 0)) { /* Plug-in is either file_tiff_save or file_tiff_save2 */ GimpMetadata *metadata; GimpMetadataSaveFlags metadata_flags; GimpParasite *parasite; gint32 image = param[1].data.d_int32; gint32 drawable = param[2].data.d_int32; gint32 orig_image = image; GimpExportReturn export = GIMP_EXPORT_CANCEL; 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, &drawable, "TIFF", GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED | GIMP_EXPORT_CAN_HANDLE_ALPHA); 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[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_ID; gint32 drawable_ID; GimpExportReturn export = GIMP_EXPORT_CANCEL; GError *error = NULL; INIT_I18N (); gegl_init (NULL, NULL); l_run_mode = run_mode = (GimpRunMode)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) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (LOAD_PROC, &plvals); if (!load_dialog ()) status = GIMP_PDB_CANCEL; break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 3) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (LOAD_PROC, &plvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { check_load_vals (); image_ID = load_image (param[1].data.d_string, &error); /* Write out error messages of FITS-Library */ show_fits_errors (); 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; } /* Store plvals data */ if (status == GIMP_PDB_SUCCESS) gimp_set_data (LOAD_PROC, &plvals, sizeof (FITSLoadVals)); } } 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, "FITS", GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }