static void
query (void)
{
/*
* Load/save procedures
*/
gimp_install_procedure (LOAD_PROC,
"load FLI-movies",
"This is an experimantal plug-in to handle FLI movies",
"Jens Ch. Restemeier",
"Jens Ch. Restemeier",
"1997",
N_("AutoDesk FLIC animation"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args) - 2,
G_N_ELEMENTS (load_return_vals),
load_args,
load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-flic");
gimp_register_magic_load_handler (LOAD_PROC,
"fli,flc",
"",
"");
gimp_install_procedure (SAVE_PROC,
"save FLI-movies",
"This is an experimantal plug-in to handle FLI movies",
"Jens Ch. Restemeier",
"Jens Ch. Restemeier",
"1997",
N_("AutoDesk FLIC animation"),
"INDEXED,GRAY",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-flic");
gimp_register_save_handler (SAVE_PROC,
"fli,flc",
"");
/*
* Utility functions:
*/
gimp_install_procedure (INFO_PROC,
"Get information about a Fli movie",
"This is a experimantal plug-in to handle FLI movies",
"Jens Ch. Restemeier",
"Jens Ch. Restemeier",
"1997",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (info_args),
G_N_ELEMENTS (info_return_vals),
info_args,
info_return_vals);
}
static void
query (void)
{
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_PDB_STRING, "file-type", "File type to use"}
};
gimp_install_procedure (SAVE_PROC,
"Saves grayscale image in various text formats",
"This plug-in uses aalib to save grayscale image "
"as ascii art into a variety of text formats",
"Tim Newsome <*****@*****.**>",
"Tim Newsome <*****@*****.**>",
"1997",
N_("ASCII art"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/plain");
gimp_register_save_handler (SAVE_PROC, "txt,ansi,text", "");
}
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 of the file to load" },
};
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,
"load file of the FITS file format",
"load file of the FITS file format "
"(Flexible Image Transport System)",
"Peter Kirchgessner",
"Peter Kirchgessner ([email protected])",
"1997",
N_("Flexible Image Transport System"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-fits");
gimp_register_magic_load_handler (LOAD_PROC,
"fit,fits",
"",
"0,string,SIMPLE");
gimp_install_procedure (SAVE_PROC,
"save file in the FITS file format",
"FITS saving handles all image types except "
"those with alpha channels.",
"Peter Kirchgessner",
"Peter Kirchgessner ([email protected])",
"1997",
N_("Flexible Image Transport System"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-fits");
gimp_register_save_handler (SAVE_PROC, "fit,fits", "");
}
static void
query (void)
{
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" },
{ 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 (SAVE_PROC,
"GIMP Table Magic",
"Allows you to draw an HTML table in GIMP. See help for more info.",
"Daniel Dunbar",
"Daniel Dunbar",
"1998",
_("HTML table"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/html");
gimp_register_save_handler (SAVE_PROC, "html,htm", "");
}
static void
query (void)
{
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 (SAVE_PROC,
"saves files as C unsigned character array",
"FIXME: write help",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1997",
N_("C source code header"),
"INDEXED, RGB",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/x-chdr");
gimp_register_save_handler (SAVE_PROC, "h", "");
}
static void
query (void)
{
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" },
{ 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 (SAVE_PROC,
"Dump image data in RGB(A) format for C source",
"CSource cannot be run non-interactively.",
"Tim Janik",
"Tim Janik",
"1999",
N_("C source code"),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/x-csrc");
gimp_register_file_handler_uri (SAVE_PROC);
gimp_register_save_handler (SAVE_PROC, "c", "");
}
static void
query ()
{
static GParamDef load_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" },
};
static GParamDef load_return_vals[] =
{
{ PARAM_IMAGE, "image", "Output image" },
};
static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Drawable to save" },
{ PARAM_STRING, "filename", "The name of the file to save the image in" },
{ PARAM_STRING, "raw_filename", "The name of the file to save the image in" },
};
static int nsave_args = sizeof (save_args) / sizeof (save_args[0]);
static GParamDef config_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
};
gint nconfig_args = sizeof (config_args) / sizeof (config_args[0]);
gimp_install_procedure ("file_rgba_save",
"Saves OpenGL textures (RGBA)",
"...",
"Daniel Balster <*****@*****.**>",
"Daniel Balster <*****@*****.**>",
"2000",
"<Save>/RGBA",
"RGB",
PROC_PLUG_IN,
nsave_args, 0,
save_args, NULL);
gimp_install_procedure ("file_rgba_load",
"Loads OpenGL textures (RGBA)",
"...",
"Daniel Balster <*****@*****.**>",
"Daniel Balster <*****@*****.**>",
"2000",
"<Load>/RGBA",
NULL,
PROC_PLUG_IN,
nload_args, nload_return_vals,
load_args, load_return_vals);
gimp_register_magic_load_handler ("file_rgba_load", "rgba", "",NULL);
gimp_register_save_handler ("file_rgba_save", "rgba", "");
}
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), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "filename", "Filename to load image from" },
{ GIMP_PDB_STRING, "raw-filename", "Name entered" },
{ GIMP_PDB_STRING, "palette-filename", "Filename to load palette from" }
};
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 export" },
{ GIMP_PDB_STRING, "filename", "Filename to export image to" },
{ GIMP_PDB_STRING, "raw-filename", "Name entered" },
{ GIMP_PDB_STRING, "palette-filename", "Filename to save palette to" },
};
gimp_install_procedure (LOAD_PROC,
"Loads files in KISS CEL file format",
"This plug-in loads individual KISS cell files.",
"Nick Lamb",
"Nick Lamb <*****@*****.**>",
"May 1998",
N_("KISS CEL"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_magic_load_handler (LOAD_PROC,
"cel",
"",
"0,string,KiSS\\040");
gimp_install_procedure (SAVE_PROC,
"Exports files in KISS CEL file format",
"This plug-in exports individual KISS cell files.",
"Nick Lamb",
"Nick Lamb <*****@*****.**>",
"May 1998",
N_("KISS CEL"),
"RGB*, 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, "cel", "");
}
static void
query (void)
{
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 entered" }
};
static GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" },
};
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 entered" },
};
gimp_install_procedure ("file_icns_load",
"Loads files of Macintosh ICNS file format",
"Loads files of Macintosh ICNS file format",
"Christian Kreibich <*****@*****.**>",
"Christian Kreibich <*****@*****.**>",
"2002",
"<Load>/icns",
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_magic_load_handler ("file_icns_load",
"icns",
"",
"0,string,icns");
gimp_install_procedure ("file_icns_save",
"Saves files in Macintosh ICNS file format",
"Saves files in Macintosh ICNS file format",
"Brion Vibber",
"Brion Vibber",
"2004",
"<Save>/icns",
"INDEXEDA, GRAYA, RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_save_handler ("file_icns_save",
"icns",
"");
}
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 entered" }
};
gimp_install_procedure (LOAD_PROC,
"Loads files in Zsoft PCX file format",
"FIXME: write help for pcx_load",
"Francisco Bustamante & Nick Lamb",
"Nick Lamb <*****@*****.**>",
"January 1997",
N_("ZSoft PCX image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-pcx");
gimp_register_magic_load_handler (LOAD_PROC,
"pcx,pcc",
"",
"0&,byte,10,2&,byte,1,3&,byte,>0,3,byte,<9");
gimp_install_procedure (SAVE_PROC,
"Saves files in ZSoft PCX file format",
"FIXME: write help for pcx_save",
"Francisco Bustamante & Nick Lamb",
"Nick Lamb <*****@*****.**>",
"January 1997",
N_("ZSoft PCX image"),
"INDEXED, RGB, GRAY",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-pcx");
gimp_register_save_handler (SAVE_PROC, "pcx,pcc", "");
}
static void
query (void)
{
static const 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 entered" },
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" },
};
static const 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 entered" },
};
gimp_install_procedure (LOAD_PROC,
"Loads files of Windows BMP file format",
"Loads files of Windows BMP file format",
"Alexander Schulz",
"Alexander Schulz",
"1997",
N_("Windows BMP image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/bmp");
gimp_register_magic_load_handler (LOAD_PROC,
"bmp",
"",
"0,string,BM");
gimp_install_procedure (SAVE_PROC,
"Saves files in Windows BMP file format",
"Saves files in Windows BMP file format",
"Alexander Schulz",
"Alexander Schulz",
"1997",
N_("Windows BMP image"),
"INDEXED, GRAY, RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/bmp");
gimp_register_save_handler (SAVE_PROC, "bmp", "");
}
static void
query ()
{
static GParamDef load_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name of the file to load" },
};
static GParamDef load_return_vals[] =
{
{ PARAM_IMAGE, "image", "Output image" },
};
static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Drawable to save" },
{ PARAM_STRING, "filename", "The name of the file to save the image in" },
{ PARAM_STRING, "raw_filename", "The name of the file to save the image in" },
{ PARAM_FLOAT, "quality", "Quality of saved image (0 <= quality <= 1)" },
{ PARAM_FLOAT, "smoothing", "Smoothing factor for saved image (0 <= smoothing <= 1)" },
{ PARAM_INT32, "optimize", "Optimization of entropy encoding parameters" },
};
static int nsave_args = sizeof (save_args) / sizeof (save_args[0]);
gimp_install_procedure ("file_jpeg_load",
"loads files of the jpeg file format",
"FIXME: write help for jpeg_load",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
"<Load>/Jpeg",
NULL,
PROC_PLUG_IN,
nload_args, nload_return_vals,
load_args, load_return_vals);
gimp_install_procedure ("file_jpeg_save",
"saves files in the jpeg file format",
"FIXME: write help for jpeg_save",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
"<Save>/Jpeg",
"*",
PROC_PLUG_IN,
nsave_args, 0,
save_args, NULL);
gimp_register_magic_load_handler ("file_jpeg_load", "jpg,jpeg,jp4", "", "6,string,JFIF");
gimp_register_save_handler ("file_jpeg_save", "jpg,jpeg", "");
}
static void
query (void)
{
#define COMMON_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_PDB_INT32, "compression", "Compression type: { NONE (0), LZW (1), PACKBITS (2), DEFLATE (3), JPEG (4), CCITT G3 Fax (5), CCITT G4 Fax (6) }" }
static const GimpParamDef save_args_old[] =
{
COMMON_SAVE_ARGS
};
static const GimpParamDef save_args[] =
{
COMMON_SAVE_ARGS,
{ GIMP_PDB_INT32, "save-transp-pixels", "Keep the color data masked by an alpha channel intact" }
};
gimp_install_procedure (SAVE_PROC,
"saves files in the tiff file format",
"Saves files in the Tagged Image File Format. "
"The value for the saved comment is taken "
"from the 'gimp-comment' parasite.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996,2000-2003",
N_("TIFF image"),
"RGB*, GRAY*, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args_old), 0,
save_args_old, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/tiff");
gimp_register_save_handler (SAVE_PROC, "tif,tiff", "");
gimp_install_procedure (SAVE2_PROC,
"saves files in the tiff file format",
"Saves files in the Tagged Image File Format. "
"The value for the saved comment is taken "
"from the 'gimp-comment' parasite.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996,2000-2003",
N_("TIFF image"),
"RGB*, GRAY*, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE2_PROC, "image/tiff");
}
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 (void)
{
static const GimpParamDef gih_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 export" },
{ GIMP_PDB_STRING, "uri", "The URI of the file to export the brush pipe in" },
{ GIMP_PDB_STRING, "raw-uri", "The URI of the file to export the brush pipe in" },
{ GIMP_PDB_INT32, "spacing", "Spacing of the brush" },
{ GIMP_PDB_STRING, "description", "Short description of the brush pipe" },
{ GIMP_PDB_INT32, "cell-width", "Width of the brush cells" },
{ GIMP_PDB_INT32, "cell-height", "Width of the brush cells" },
{ GIMP_PDB_INT8, "display-cols", "Display column number" },
{ GIMP_PDB_INT8, "display-rows", "Display row number" },
{ GIMP_PDB_INT32, "dimension", "Dimension of the brush pipe" },
/* The number of rank and sel args depend on the dimension */
{ GIMP_PDB_INT8ARRAY, "rank", "Ranks of the dimensions" },
{ GIMP_PDB_INT32, "dimension", "Dimension (again)" },
{ GIMP_PDB_STRINGARRAY, "sel", "Selection modes" }
};
gimp_install_procedure (SAVE_PROC,
"exports images in GIMP brush pipe format",
"This plug-in exports an image in the GIMP brush pipe "
"format. For a colored brush pipe, RGBA layers are "
"used, otherwise the layers should be grayscale "
"masks. The image can be multi-layered, and "
"additionally the layers can be divided into a "
"rectangular array of brushes.",
"Tor Lillqvist",
"Tor Lillqvist",
"1999",
N_("GIMP brush (animated)"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (gih_save_args), 0,
gih_save_args, NULL);
gimp_plugin_icon_register (SAVE_PROC, GIMP_ICON_TYPE_ICON_NAME,
(const guint8 *) GIMP_ICON_BRUSH);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-gimp-gih");
gimp_register_file_handler_uri (SAVE_PROC);
gimp_register_save_handler (SAVE_PROC, "gih", "");
}
static void
query (void)
{
gimp_install_procedure (LOAD_PROC,
"Loads files in DDS image format",
"Loads files in DDS image format",
"Shawn Kirst",
"Shawn Kirst",
"2008",
N_("DDS image"),
0,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/dds");
gimp_register_magic_load_handler (LOAD_PROC,
"dds",
"",
"0,string,DDS");
gimp_install_procedure (SAVE_PROC,
"Saves files in DDS image format",
"Saves files in DDS image format",
"Shawn Kirst",
"Shawn Kirst",
"2008",
N_("DDS image"),
"INDEXED, GRAY, RGB",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, 0);
gimp_register_file_handler_mime (SAVE_PROC, "image/dds");
gimp_register_save_handler (SAVE_PROC,
"dds",
"");
gimp_install_procedure (DECODE_YCOCG_PROC,
"Converts YCoCg encoded pixels to RGB",
"Converts YCoCg encoded pixels to RGB",
"Shawn Kirst",
"Shawn Kirst",
"2008",
N_("Decode YCoCg"),
"RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_YCOCG_PROC, "<Image>/Filters/Colors");*/
gimp_install_procedure (DECODE_YCOCG_SCALED_PROC,
"Converts YCoCg (scaled) encoded pixels to RGB",
"Converts YCoCg (scaled) encoded pixels to RGB",
"Shawn Kirst",
"Shawn Kirst",
"2008",
N_("Decode YCoCg (scaled)"),
"RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_YCOCG_SCALED_PROC, "<Image>/Filters/Colors");*/
gimp_install_procedure (DECODE_ALPHA_EXP_PROC,
"Converts alpha exponent encoded pixels to RGB",
"Converts alpha exponent encoded pixels to RGB",
"Shawn Kirst",
"Shawn Kirst",
"2008",
N_("Decode Alpha exponent"),
"RGBA",
GIMP_PLUGIN,
G_N_ELEMENTS (decode_args), 0,
decode_args, 0);
/*gimp_plugin_menu_register (DECODE_ALPHA_EXP_PROC, "<Image>/Filters/Colors");*/
}
static void
query (void)
{
/* Register parameters */
/* File Load */
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 of the file to load" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
/* Thumbnail Load */
static const GimpParamDef thumb_args[] =
{
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" }
};
static const GimpParamDef thumb_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Thumbnail image" },
{ GIMP_PDB_INT32, "image-width", "Width of full-sized image" },
{ GIMP_PDB_INT32, "image-height", "Height of full-sized image" }
};
#ifdef PSD_SAVE
/* File save */
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" }
};
#endif /* PSD_SAVE */
/* Register procedures */
/* File load */
gimp_install_procedure (LOAD_PROC,
"Loads images from the Photoshop PSD file format",
"This plug-in loads images in Adobe "
"Photoshop (TM) native PSD format.",
"John Marshall",
"John Marshall",
"2007",
N_("Photoshop image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-psd");
gimp_register_magic_load_handler (LOAD_PROC,
"psd",
"",
"0,string,8BPS");
/* Thumbnail load */
gimp_install_procedure (LOAD_THUMB_PROC,
"Loads thumbnails from the Photoshop PSD file format",
"This plug-in loads thumnail images from Adobe "
"Photoshop (TM) native PSD format files.",
"John Marshall",
"John Marshall",
"2007",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (thumb_args),
G_N_ELEMENTS (thumb_return_vals),
thumb_args, thumb_return_vals);
gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC);
#ifdef PSD_SAVE
/* File save*/
gimp_install_procedure (SAVE_PROC,
"Saves images to the Photoshop PSD file format",
"This plug-in saves images in Adobe "
"Photoshop (TM) native PSD format.",
"John Marshall",
"John Marshall",
"2007",
N_("Photoshop image"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_save_handler (SAVE_PROC, "psd", "");
gimp_register_file_handler_mime (SAVE_PROC, "image/x-psd");
#endif /* PSD_SAVE */
}
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" },
{ GIMP_PDB_INT32, "threshold", "Alpha threshold (0-255)" }
};
gimp_install_procedure (LOAD_PROC,
"Load files in XPM (X11 Pixmap) format.",
"Load files in XPM (X11 Pixmap) format. "
"XPM is a portable image format designed to be "
"included in C source code. XLib provides utility "
"functions to read this format. Newer code should "
"however be using gdk-pixbuf-csource instead. "
"XPM supports colored images, unlike the XBM "
"format which XPM was designed to replace.",
"Spencer Kimball & Peter Mattis & Ray Lehtiniemi",
"Spencer Kimball & Peter Mattis",
"1997",
N_("X PixMap image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-xpixmap");
gimp_register_magic_load_handler (LOAD_PROC,
"xpm",
"",
"0, string,/*\\040XPM\\040*/");
gimp_install_procedure (SAVE_PROC,
"Save files in XPM (X11 Pixmap) format.",
"Save files in XPM (X11 Pixmap) format. "
"XPM is a portable image format designed to be "
"included in C source code. XLib provides utility "
"functions to read this format. Newer code should "
"however be using gdk-pixbuf-csource instead. "
"XPM supports colored images, unlike the XBM "
"format which XPM was designed to replace.",
"Spencer Kimball & Peter Mattis & Ray Lehtiniemi & Nathan Summers",
"Spencer Kimball & Peter Mattis",
"1997",
N_("X PixMap image"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-xpixmap");
gimp_register_save_handler (SAVE_PROC, "xpm", "");
}
static void
query (void)
{
static GimpParamDef save_args[] =
{
{GIMP_PDB_INT32, "run-mode", "Run mode"},
{GIMP_PDB_IMAGE, "image", "Input image"},
{GIMP_PDB_DRAWABLE, "drawable", "Input drawable"},
{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_PDB_INT32, "vectorize", "Convert bitmaps to vector graphics where possible. TRUE or FALSE"},
{GIMP_PDB_INT32, "ignore-hidden","Omit hidden layers and layers with zero opacity. TRUE or FALSE"},
{GIMP_PDB_INT32, "apply-masks", "Apply layer masks before saving. TRUE or FALSE (Keeping them will not change the output)"}
};
static GimpParamDef save_multi_args[] =
{
{GIMP_PDB_INT32, "run-mode", "Run mode"},
{GIMP_PDB_INT32ARRAY, "images", "Input image for each page (An image can appear more than once)"},
{GIMP_PDB_INT32, "count", "The amount of images entered (This will be the amount of pages). 1 <= count <= MAX_PAGE_COUNT"},
{GIMP_PDB_INT32, "vectorize", "Convert bitmaps to vector graphics where possible. TRUE or FALSE"},
{GIMP_PDB_INT32, "ignore-hidden","Omit hidden layers and layers with zero opacity. TRUE or FALSE"},
{GIMP_PDB_INT32, "apply-masks", "Apply layer masks before saving. TRUE or FALSE (Keeping them will not change the output)"},
{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 (SAVE_PROC,
"Save files in PDF format",
"Saves files in Adobe's Portable Document Format. "
"PDF is designed to be easily processed by a variety "
"of different platforms, and is a distant cousin of "
"PostScript.",
"Barak Itkin",
"Copyright Barak Itkin",
"August 2009",
N_("Portable Document Format"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_install_procedure (SAVE_MULTI_PROC,
"Save files in PDF format",
"Saves files in Adobe's Portable Document Format. "
"PDF is designed to be easily processed by a variety "
"of different platforms, and is a distant cousin of "
"PostScript.",
"Barak Itkin",
"Copyright Barak Itkin",
"August 2009",
N_("_Create multipage PDF..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_multi_args), 0,
save_multi_args, NULL);
/* gimp_plugin_menu_register (SAVE_MULTI_PROC,
"<Image>/File/Create/PDF"); */
gimp_register_file_handler_mime (SAVE_PROC, "application/pdf");
gimp_register_save_handler (SAVE_PROC, "pdf", "");
}
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, "uri", "The URI of the file to load" },
{ GIMP_PDB_STRING, "raw-uri", "The URI of the file to load" }
};
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, "uri", "The URI of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-uri", "The URI of the file to save the image in" },
{ GIMP_PDB_INT32, "spacing", "Spacing of the brush" },
{ GIMP_PDB_STRING, "description", "Short description of the brush" }
};
gimp_install_procedure (LOAD_PROC,
"Loads GIMP brushes",
"Loads GIMP brushes (1 or 4 bpp and old .gpb format)",
"Tim Newsome, Jens Lautenbacher, Sven Neumann",
"Tim Newsome, Jens Lautenbacher, Sven Neumann",
"1997-2005",
N_("GIMP brush"),
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_ICON_NAME,
(const guint8 *) GIMP_STOCK_BRUSH);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-gimp-gbr");
gimp_register_file_handler_uri (LOAD_PROC);
gimp_register_magic_load_handler (LOAD_PROC,
"gbr, gpb",
"",
"20, string, GIMP");
gimp_install_procedure (SAVE_PROC,
"Saves files in the GIMP brush file format",
"Saves files in the GIMP brush file format",
"Tim Newsome, Jens Lautenbacher, Sven Neumann",
"Tim Newsome, Jens Lautenbacher, Sven Neumann",
"1997-2000",
N_("GIMP brush"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_plugin_icon_register (SAVE_PROC, GIMP_ICON_TYPE_ICON_NAME,
(const guint8 *) GIMP_STOCK_BRUSH);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-gimp-gbr");
gimp_register_file_handler_uri (SAVE_PROC);
gimp_register_save_handler (SAVE_PROC, "gbr", "");
}
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 of the file to load" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
#ifdef HAVE_EXIF
static const GimpParamDef thumb_args[] =
{
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" }
};
static const GimpParamDef thumb_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Thumbnail image" },
{ GIMP_PDB_INT32, "image-width", "Width of full-sized image" },
{ GIMP_PDB_INT32, "image-height", "Height of full-sized image" }
};
#endif /* HAVE_EXIF */
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_PDB_FLOAT, "quality", "Quality of saved image (0 <= quality <= 1)" },
{ GIMP_PDB_FLOAT, "smoothing", "Smoothing factor for saved image (0 <= smoothing <= 1)" },
{ GIMP_PDB_INT32, "optimize", "Optimization of entropy encoding parameters (0/1)" },
{ GIMP_PDB_INT32, "progressive", "Enable progressive jpeg image loading (0/1)" },
{ GIMP_PDB_STRING, "comment", "Image comment" },
{ GIMP_PDB_INT32, "subsmp", "The subsampling option number" },
{ GIMP_PDB_INT32, "baseline", "Force creation of a baseline JPEG (non-baseline JPEGs can't be read by all decoders) (0/1)" },
{ GIMP_PDB_INT32, "restart", "Frequency of restart markers (in rows, 0 = no restart markers)" },
{ GIMP_PDB_INT32, "dct", "DCT algorithm to use (speed/quality tradeoff)" }
};
gimp_install_procedure (LOAD_PROC,
"loads files in the JPEG file format",
"loads files in the JPEG file format",
"Spencer Kimball, Peter Mattis & others",
"Spencer Kimball & Peter Mattis",
"1995-2007",
N_("JPEG image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/jpeg");
gimp_register_magic_load_handler (LOAD_PROC,
"jpg,jpeg,jpe",
"",
"6,string,JFIF,6,string,Exif");
#ifdef HAVE_EXIF
gimp_install_procedure (LOAD_THUMB_PROC,
"Loads a thumbnail from a JPEG image",
"Loads a thumbnail from a JPEG image (only if it exists)",
"Mukund Sivaraman <*****@*****.**>, Sven Neumann <*****@*****.**>",
"Mukund Sivaraman <*****@*****.**>, Sven Neumann <*****@*****.**>",
"November 15, 2004",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (thumb_args),
G_N_ELEMENTS (thumb_return_vals),
thumb_args, thumb_return_vals);
gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC);
#endif /* HAVE_EXIF */
gimp_install_procedure (SAVE_PROC,
"saves files in the JPEG file format",
"saves files in the lossy, widely supported JPEG format",
"Spencer Kimball, Peter Mattis & others",
"Spencer Kimball & Peter Mattis",
"1995-2007",
N_("JPEG image"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/jpeg");
gimp_register_save_handler (SAVE_PROC, "jpg,jpeg,jpe", "");
}
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, "uri", "The URI of the file to load" },
{ GIMP_PDB_STRING, "raw-uri", "The URI of the file to load" }
};
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, "uri", "The URI of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-uri", "The URI of the file to save the image in" },
{ GIMP_PDB_STRING, "description", "Short description of the pattern" }
};
gimp_install_procedure (LOAD_PROC,
"Loads Gimp's .PAT pattern files",
"The images in the pattern dialog can be loaded "
"directly with this plug-in",
"Tim Newsome",
"Tim Newsome",
"1997",
N_("GIMP pattern"),
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_ICON_NAME,
(const guint8 *) GIMP_STOCK_PATTERN);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-gimp-pat");
gimp_register_file_handler_uri (LOAD_PROC);
gimp_register_magic_load_handler (LOAD_PROC,
"pat",
"",
"20,string,GPAT");
gimp_install_procedure (SAVE_PROC,
"Saves Gimp pattern file (.PAT)",
"New Gimp patterns can be created by saving them "
"in the appropriate place with this plug-in.",
"Tim Newsome",
"Tim Newsome",
"1997",
N_("GIMP pattern"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_plugin_icon_register (SAVE_PROC, GIMP_ICON_TYPE_ICON_NAME,
(const guint8 *) GIMP_STOCK_PATTERN);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-gimp-pat");
gimp_register_file_handler_uri (SAVE_PROC);
gimp_register_save_handler (SAVE_PROC, "pat", "");
}
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 of the file to load" }
};
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_PDB_INT32, "raw", "TRUE for raw output, FALSE for ascii output" }
};
gimp_install_procedure (LOAD_PROC,
"Loads files in the PNM file format",
"This plug-in loads files in the various Netpbm portable file formats.",
"Erik Nygren",
"Erik Nygren",
"1996",
N_("PNM Image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-portable-anymap");
gimp_register_file_handler_uri (LOAD_PROC);
gimp_register_magic_load_handler (LOAD_PROC,
"pnm,ppm,pgm,pbm",
"",
"0,string,P1,0,string,P2,0,string,P3,0,"
"string,P4,0,string,P5,0,string,P6");
gimp_install_procedure (PNM_SAVE_PROC,
"Saves files in the PNM file format",
"PNM saving handles all image types without transparency.",
"Erik Nygren",
"Erik Nygren",
"1996",
N_("PNM image"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_install_procedure (PBM_SAVE_PROC,
"Saves files in the PBM file format",
"PBM saving produces mono images without transparency.",
"Martin K Collins",
"Erik Nygren",
"2006",
N_("PBM image"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_install_procedure (PGM_SAVE_PROC,
"Saves files in the PGM file format",
"PGM saving produces grayscale images without transparency.",
"Erik Nygren",
"Erik Nygren",
"1996",
N_("PGM image"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_install_procedure (PPM_SAVE_PROC,
"Saves files in the PPM file format",
"PPM saving handles RGB images without transparency.",
"Erik Nygren",
"Erik Nygren",
"1996",
N_("PPM image"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (PNM_SAVE_PROC, "image/x-portable-anymap");
gimp_register_file_handler_mime (PBM_SAVE_PROC, "image/x-portable-bitmap");
gimp_register_file_handler_mime (PGM_SAVE_PROC, "image/x-portable-graymap");
gimp_register_file_handler_mime (PPM_SAVE_PROC, "image/x-portable-pixmap");
gimp_register_file_handler_uri (PNM_SAVE_PROC);
gimp_register_file_handler_uri (PBM_SAVE_PROC);
gimp_register_file_handler_uri (PGM_SAVE_PROC);
gimp_register_file_handler_uri (PPM_SAVE_PROC);
gimp_register_save_handler (PNM_SAVE_PROC, "pnm", "");
gimp_register_save_handler (PBM_SAVE_PROC, "pbm", "");
gimp_register_save_handler (PGM_SAVE_PROC, "pgm", "");
gimp_register_save_handler (PPM_SAVE_PROC, "ppm", "");
}
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_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 of the file to load" }
};
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_PDB_INT32, "rle", "Specify non-zero for rle output, zero for standard output" }
};
gimp_install_procedure (LOAD_PROC,
"load file of the SunRaster file format",
"load file of the SunRaster file format",
"Peter Kirchgessner",
"Peter Kirchgessner",
"1996",
N_("SUN Rasterfile image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-sun-raster");
gimp_register_magic_load_handler (LOAD_PROC,
"im1,im8,im24,im32,rs,ras",
"",
"0,long,0x59a66a95");
gimp_install_procedure (SAVE_PROC,
"save file in the SunRaster file format",
"SUNRAS saving handles all image types except "
"those with alpha channels.",
"Peter Kirchgessner",
"Peter Kirchgessner",
"1996",
N_("SUN Rasterfile image"),
"RGB, GRAY, INDEXED",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-sun-raster");
gimp_register_save_handler (SAVE_PROC,
"im1,im8,im24,im32,rs,ras", "");
}
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)
{
/* File Load */
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 of the file to load" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
/* Thumbnail Load */
static const GimpParamDef thumb_args[] =
{
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size" }
};
static const GimpParamDef thumb_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Thumbnail image" },
{ GIMP_PDB_INT32, "image-width", "Width of full-sized image" },
{ GIMP_PDB_INT32, "image-height", "Height of full-sized image" }
};
/* File save */
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_PDB_INT32, "compression", "Compression type: { NONE (0), LZW (1), PACKBITS (2)" },
{ GIMP_PDB_INT32, "fill-order", "Fill Order: { MSB to LSB (0), LSB to MSB (1)" }
};
/* File load */
gimp_install_procedure (LOAD_PROC,
"Loads images from the Photoshop PSD file format",
"This plug-in loads images in Adobe "
"Photoshop (TM) native PSD format.",
"John Marshall",
"John Marshall",
"2007",
N_("Photoshop image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-psd");
gimp_register_magic_load_handler (LOAD_PROC,
"psd",
"",
"0,string,8BPS");
/* Thumbnail load */
gimp_install_procedure (LOAD_THUMB_PROC,
"Loads thumbnails from the Photoshop PSD file format",
"This plug-in loads thumbnail images from Adobe "
"Photoshop (TM) native PSD format files.",
"John Marshall",
"John Marshall",
"2007",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (thumb_args),
G_N_ELEMENTS (thumb_return_vals),
thumb_args, thumb_return_vals);
gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC);
gimp_install_procedure (SAVE_PROC,
"saves files in the Photoshop(tm) PSD file format",
"This filter saves files of Adobe Photoshop(tm) native PSD format. These files may be of any image type supported by GIMP, with or without layers, layer masks, aux channels and guides.",
"Monigotes",
"Monigotes",
"2000",
N_("Photoshop image"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-psd");
gimp_register_save_handler (SAVE_PROC, "psd", "");
}
static void
query ()
{
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 thumb_args[] = {
{GIMP_PDB_STRING, "filename", "The name of the file to load"},
{GIMP_PDB_INT32, "thumb-size", "Preferred thumbnail size"}
};
static const GimpParamDef thumb_return_vals[] = {
{GIMP_PDB_IMAGE, "image", "Thumbnail image"},
{GIMP_PDB_INT32, "image-width", "Width of full-sized image"},
{GIMP_PDB_INT32, "image-height", "Height of full-sized 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,
"Loads files of Valve Texture File format",
"Loads files of Valve Texture File format",
"Alexander AB <*****@*****.**>",
"Alexander AB <*****@*****.**>",
"2012",
"Valve Texture",
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args,
load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/x-vtf");
gimp_register_magic_load_handler (LOAD_PROC,
"vtf",
"",
"0,string,VTF\\000");
gimp_install_procedure (LOAD_THUMB_PROC,
"Loads a preview from an Valve Texture file",
"",
"Alexander AB <*****@*****.**>",
"Alexander AB <*****@*****.**>",
"2012",
NULL,
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (thumb_args),
G_N_ELEMENTS (thumb_return_vals),
thumb_args,
thumb_return_vals);
gimp_register_thumbnail_loader (LOAD_PROC, LOAD_THUMB_PROC);
gimp_install_procedure (SAVE_PROC,
"Saves files in Valve Texture File format",
"Saves files in Valve Texture File format",
"Alexander AB <*****@*****.**>",
"Alexander AB <*****@*****.**>",
"2012",
"Valve Texture",
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args),
0,
save_args,
NULL);
gimp_register_file_handler_mime (SAVE_PROC, "image/x-vtf");
gimp_register_save_handler (SAVE_PROC, "vtf", "");
}
