static void
query (void)
{
/*
* Description:
* Register the services provided by this plug-in
*/
static const GimpParamDef load_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" }
};
gimp_install_procedure (LOAD_PROC,
"loads files of the Alias|Wavefront Pix file format",
"loads files of the Alias|Wavefront Pix file format",
"Michael Taylor",
"Michael Taylor",
"1997",
N_("Alias Pix image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_uri (LOAD_PROC);
gimp_register_load_handler (LOAD_PROC, "pix,matte,mask,alpha,als", "");
gimp_install_procedure (SAVE_PROC,
"save file in the Alias|Wavefront pix/matte file format",
"save file in the Alias|Wavefront pix/matte file format",
"Michael Taylor",
"Michael Taylor",
"1997",
N_("Alias Pix image"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_uri (SAVE_PROC);
gimp_register_save_handler (SAVE_PROC, "pix,matte,mask,alpha,als", "");
}
static void
query (void)
{
static const GimpParamDef load_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" }
};
gimp_install_procedure (LOAD_PROC,
"Load raw images, specifying image information",
"Load raw images, specifying image information",
"timecop, [email protected]",
"timecop, [email protected]",
"Aug 2004",
N_("Raw image data"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_load_handler (LOAD_PROC, "data", "");
gimp_install_procedure (SAVE_PROC,
"Dump images to disk in raw format",
"Dump images to disk in raw format",
"timecop, [email protected]",
"timecop, [email protected]",
"Aug 2004",
N_("Raw image data"),
"INDEXED, GRAY, RGB, RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_save_handler (SAVE_PROC, "data", "");
}
static void query_888(void)
{
gimp_install_procedure(
PLUGIN_NAME,
"raw file RGB-888 load",
"Load raw file in RGB 888 format",
"Marcel Tunnissen",
"Copyright Marcel Tunnissen",
PLUGIN_VERSION,
"<Load>/RGB888",
NULL,
GIMP_PLUGIN,
nr_args, nr_results, args, results
);
gimp_register_load_handler(PLUGIN_NAME, "RGB-888, 888", "");
}
void ptQuery() {
printf("(%s,%d) '%s'\n",__FILE__,__LINE__,__PRETTY_FUNCTION__);
static const GimpParamDef SendToGimpArguments[] = {
{ GIMP_PDB_INT32,
(gchar*) "run_mode",
(gchar*) "Interactive, non-interactive" },
{ GIMP_PDB_STRING,
(gchar*) "filename",
(gchar*) "The name of the send to gimp descriptor" },
{ GIMP_PDB_STRING,
(gchar*) "raw_filename",
(gchar*) "The name of the send to gimp descriptor" },
};
static const GimpParamDef SendToGimpReturnValues[] = {
{ GIMP_PDB_IMAGE,
(gchar*) "image",
(gchar*) "Output image" },
};
gimp_install_procedure("photivoSendToGimp",
"photivo send to gimp loader",
"photivo send to gimp loader",
"Jos De Laender, Michael Munzert",
"Copyright 2009 by Jos De Laender\n Copyright 2010 by Michael Munzert",
"April 5, 2009",
// No menu path required in this case.
"photivo",
// image types
NULL,
// GimpPDBProcType
GIMP_PLUGIN,
G_N_ELEMENTS(SendToGimpArguments),
G_N_ELEMENTS(SendToGimpReturnValues),
SendToGimpArguments,
SendToGimpReturnValues);
gimp_register_load_handler("photivoSendToGimp",(char *)"ptg","");
}
static void
query (void)
{
static const GimpParamDef load_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" }
};
GError *error = NULL;
if (! uri_backend_init (PLUG_IN_BINARY,
FALSE,
GIMP_RUN_NONINTERACTIVE,
&error))
{
g_message ("%s", error->message);
g_clear_error (&error);
return;
}
if (uri_backend_get_load_protocols ())
{
gimp_install_procedure (LOAD_PROC,
"loads files given an URI",
uri_backend_get_load_help (),
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-2008",
N_("URI"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_plugin_icon_register (LOAD_PROC, GIMP_ICON_TYPE_STOCK_ID,
(const guint8 *) GIMP_STOCK_WEB);
gimp_register_load_handler (LOAD_PROC,
"", uri_backend_get_load_protocols ());
}
if (uri_backend_get_save_protocols ())
{
gimp_install_procedure (SAVE_PROC,
"saves files given an URI",
uri_backend_get_save_help (),
"Michael Natterer, Sven Neumann",
"Michael Natterer",
"2005-2008",
N_("URI"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_plugin_icon_register (SAVE_PROC, GIMP_ICON_TYPE_STOCK_ID,
(const guint8 *) GIMP_STOCK_WEB);
gimp_register_save_handler (SAVE_PROC,
"", uri_backend_get_save_protocols ());
}
uri_backend_shutdown ();
}
static void
query (void)
{
char *date=NULL;
static GimpParamDef load_args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw_filename", "The name of the file to load." },
};
static GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" },
};
static int nload_args = (int)sizeof (load_args) / (int)sizeof (load_args[0]);
static int nload_return_vals = (int)sizeof (load_return_vals) / (int)sizeof (load_return_vals[0]);
static GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ GIMP_PDB_STRING, "raw_filename", "The name of the file to save the image in" },
};
static int nsave_args = (int)sizeof (save_args) / (int)sizeof (save_args[0]);
m_new (date, char,(200 + strlen(version())), gimp_quit())
sprintf (date,"%s\n2005-2007", version());
gimp_install_procedure ("file_pnm_load",
"loads files of the pnm file format",
"This plug-in loades PNM files. "
"The RAW_WIDTH, RAW_HEIGHT, RAW_TYPE and RAW_MAXVAL "
"variables can be used to load raw data ending with "
"\".raw\" .",
"Kai-Uwe Behrmann",
"2005-2007 Kai-Uwe Behrmann",
date,
"<Load>/PNM",
NULL,
GIMP_PLUGIN,
nload_args, nload_return_vals,
load_args, load_return_vals);
gimp_register_load_handler ("file_pnm_load", "pgm,pnm,ppm,pfm,raw", "");
gimp_install_procedure ("file_pnm_save",
"saves files in the pnm file format",
"This plug-in saves PNM files.",
"Kai-Uwe Behrmann",
"2005-2007 Kai-Uwe Behrmann",
date,
"<Save>/PNM",
"RGB*, GRAY*, U16_RGB*, U16_GRAY*",
GIMP_PLUGIN,
nsave_args, 0,
save_args, NULL);
gimp_register_save_handler ("file_pnm_save", "pgm,pnm,ppm", "");
gimp_install_procedure ("file_pfm_save",
"saves files in the pfm file format",
"This plug-in saves PFM files.",
"Kai-Uwe Behrmann",
"2005-2007 Kai-Uwe Behrmann",
date,
"<Save>/PFM",
"FLOAT_RGB*, FLOAT_GRAY*",
GIMP_PLUGIN,
nsave_args, 0,
save_args, NULL);
gimp_register_save_handler ("file_pfm_save", "pfm", "");
m_free (date)
}
static void query(void)
{
// Load procedure arguments
static const GimpParamDef load_args[] =
{
{GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive"},
{GIMP_PDB_STRING, (gchar*)"filename", (gchar*)"The name of the file to load"},
{GIMP_PDB_STRING, (gchar*)"raw-filename", (gchar*)"The name entered"}
};
// Load procedure return values
static const GimpParamDef load_return_values[] =
{
{GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Output image"}
};
// Install load procedure
gimp_install_procedure(LOAD_PROCEDURE,
"Load a Packed Layer Texture (.plt)",
"Load a Packed Layer Texture (.plt)",
"Attila Gyoerkoes",
"GPL v3",
"2016",
"<Load>/Packed Layer Texture",
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS(load_args),
G_N_ELEMENTS(load_return_values),
load_args,
load_return_values);
// Register Load handlers
gimp_register_file_handler_mime(LOAD_PROCEDURE, "image/plt");
gimp_register_load_handler(LOAD_PROCEDURE, "plt", "");
// Save procedure arguments
static const GimpParamDef save_args[] =
{
{GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive" },
{GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Input image" },
{GIMP_PDB_DRAWABLE, (gchar*)"drawable", (gchar*)"Drawable to save" },
{GIMP_PDB_STRING, (gchar*)"filename", (gchar*)"The name of the file to save the image in" },
{GIMP_PDB_STRING, (gchar*)"raw-filename", (gchar*)"The name entered" }
};
// Install save procedure
gimp_install_procedure(SAVE_PROCEDURE,
"Save a Packed Layer Texture (.plt)",
"Save a Packed Layer Texture (.plt)",
"Attila Gyoerkoes",
"GPL v3",
"2016",
"<Save>/Packed Layer Texture",
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS(save_args),
0,
save_args,
NULL);
// Register Save handlers
gimp_register_file_handler_mime(SAVE_PROCEDURE, "image/plt");
gimp_register_save_handler(SAVE_PROCEDURE, "plt", "");
// Add Layers procedure arguments
static const GimpParamDef addl_args[] =
{
{GIMP_PDB_INT32, (gchar*)"run-mode", (gchar*)"Interactive, non-interactive" },
{GIMP_PDB_IMAGE, (gchar*)"image", (gchar*)"Input image" }
};
// Install Add Layers procedure
gimp_install_procedure(ADDL_PROCEDURE,
"Add plt layers",
"Add plt layers",
"Attila Gyoerkoes",
"GPL v3",
"2016",
"Add missing plt layers",
"*",
GIMP_PLUGIN,
G_N_ELEMENTS(addl_args),
0,
addl_args,
NULL);
// Register Add Layers handlers
gimp_plugin_menu_register(ADDL_PROCEDURE, "<Image>/Tools");
}
static void
query (void)
{
static const GimpParamDef load_arguments[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" }
};
static const GimpParamDef load_return_values[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
static const GimpParamDef save_arguments[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image to" },
{ GIMP_PDB_STRING, "raw-filename", "The name entered" },
{ GIMP_PDB_INT32, "preset", "preset (Default=0, Picture=1, Photo=2, Drawing=3, Icon=4, Text=5)" },
{ GIMP_PDB_INT32, "lossless", "Use lossless encoding (0/1)" },
{ GIMP_PDB_FLOAT, "quality", "Quality of the image (0 <= quality <= 100)" },
{ GIMP_PDB_FLOAT, "alpha-quality", "Quality of the image's alpha channel (0 <= alpha-quality <= 100)" },
{ GIMP_PDB_INT32, "animation", "Use layers for animation (0/1)" },
{ GIMP_PDB_INT32, "anim-loop", "Loop animation infinitely (0/1)" },
{ GIMP_PDB_INT32, "minimize-size", "Minimize animation size (0/1)" },
{ GIMP_PDB_INT32, "kf-distance", "Maximum distance between key-frames (>=0)" },
{ GIMP_PDB_INT32, "exif", "Toggle saving exif data (0/1)" },
{ GIMP_PDB_INT32, "iptc", "Toggle saving iptc data (0/1)" },
{ GIMP_PDB_INT32, "xmp", "Toggle saving xmp data (0/1)" },
{ GIMP_PDB_INT32, "delay", "Delay to use when timestamps are not available or forced" },
{ GIMP_PDB_INT32, "force-delay", "Force delay on all frames" }
};
gimp_install_procedure (LOAD_PROC,
"Loads images in the WebP file format",
"Loads images in the WebP file format",
"Nathan Osman, Ben Touchette",
"(C) 2015-2016 Nathan Osman, (C) 2016 Ben Touchette",
"2015,2016",
N_("WebP image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_arguments),
G_N_ELEMENTS (load_return_values),
load_arguments,
load_return_values);
gimp_register_file_handler_mime (LOAD_PROC, "image/webp");
gimp_register_load_handler (LOAD_PROC, "webp", "");
gimp_register_magic_load_handler (LOAD_PROC,
"webp",
"",
"8,string,WEBP");
gimp_install_procedure (SAVE_PROC,
"Saves files in the WebP image format",
"Saves files in the WebP image format",
"Nathan Osman, Ben Touchette",
"(C) 2015-2016 Nathan Osman, (C) 2016 Ben Touchette",
"2015,2016",
N_("WebP image"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_arguments),
0,
save_arguments,
NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/webp");
gimp_register_save_handler (SAVE_PROC, "webp", "");
}
