mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-19 22:34:37 +00:00
5e8ee554a2
1999-03-16 Michael Natterer <mitschel@cs.tu-berlin.de>
This implements the rest of the unit system (unitrc loading and
saving and full PDB interface)
* Makefile.am
* gimp.1
* user_install
* user_install.bat
* unitrc: new file (default unit database) and some documentation
* app/Makefile.am
* app/gimpunit.c
* app/gimpunit_cmds.h
* app/unitrc.h: new files enabling the unit database and PDB
access to the unit system
* app/app_procs.c: parse and save unitrc
* app/gimprc.[ch]: enable unit parsing. New function
init_parse_buffers() to enable unitrc to be loaded before gimprc
* app/gimage_cmds.[ch]: new PDB procedures which set/return an
image's unit
* app/install.c: mention unitrc installation
* app/xcf.c: new xcf property for user defined units. An image's
unit is saved as either an integer ID (built in units) or as
a full unit definition without any ID
* libgimp/Makefile.am: moved gimpunit.o from libgimpi.a to
libgimp.a
* libgimp/gimp.h
* libgimp/gimpimage.c: get/set an image's unit with PDB calls
* libgimp/gimpunit.h: this file is now the header for both
app/gimpunit.c and libgimp/gimpunit.c
* libgimp/gimpunit.c: does the unit calls as PDB calls now
* libgimp/gimpunitmenu.[ch]: enable user unit functionality and a
unit selection dialog
* libgimp/gimpsizeentry.c: disble hilighting on focus_in_event and
minor bugfixes
* plug-ins/tiff/tiff.c: set image unit to "mm" if tiff unit is
"cm", save "cm" if image unit is metric
358 lines
7.9 KiB
C
358 lines
7.9 KiB
C
/* LIBGIMP - The GIMP Library
|
|
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
|
|
*
|
|
* gimpunit.c
|
|
* Copyright (C) 1999 Michael Natterer <mitschel@cs.tu-berlin.de>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "gimp.h"
|
|
#include "gimpunit.h"
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
/* internal structures */
|
|
|
|
typedef struct {
|
|
guint delete_on_exit;
|
|
float factor;
|
|
gint digits;
|
|
gchar *identifier;
|
|
gchar *symbol;
|
|
gchar *abbreviation;
|
|
gchar *singular;
|
|
gchar *plural;
|
|
} GimpUnitDef;
|
|
|
|
static GimpUnitDef gimp_unit_defs[UNIT_END] =
|
|
{
|
|
/* pseudo unit */
|
|
{ FALSE, 0.0, 0, "pixels", "px", "px", N_("pixel"), N_("pixels") },
|
|
|
|
/* standard units */
|
|
{ FALSE, 1.0, 2, "inches", "''", "in", N_("inch"), N_("inches") },
|
|
{ FALSE, 25.4, 1, "millimeters", "mm", "mm", N_("millimeter"), N_("millimeters") },
|
|
|
|
/* professional units */
|
|
{ FALSE, 72.0, 0, "points", "pt", "pt", N_("point"), N_("points") },
|
|
{ FALSE, 6.0, 1, "picas", "pc", "pc", N_("pica"), N_("picas") },
|
|
};
|
|
|
|
|
|
/* public functions */
|
|
|
|
gint
|
|
gimp_unit_get_number_of_units (void)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
int number;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_number_of_units",
|
|
&nreturn_vals,
|
|
PARAM_END);
|
|
|
|
number = UNIT_END;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
number = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return number;
|
|
}
|
|
|
|
gint
|
|
gimp_unit_get_number_of_built_in_units (void)
|
|
{
|
|
return UNIT_END;
|
|
}
|
|
|
|
|
|
GUnit
|
|
gimp_unit_new (gchar *identifier,
|
|
gfloat factor,
|
|
gint digits,
|
|
gchar *symbol,
|
|
gchar *abbreviation,
|
|
gchar *singular,
|
|
gchar *plural)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
GUnit unit;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_new",
|
|
&nreturn_vals,
|
|
PARAM_STRING, g_strdup (identifier),
|
|
PARAM_FLOAT, factor,
|
|
PARAM_INT32, digits,
|
|
PARAM_STRING, g_strdup (symbol),
|
|
PARAM_STRING, g_strdup (abbreviation),
|
|
PARAM_STRING, g_strdup (singular),
|
|
PARAM_STRING, g_strdup (plural),
|
|
PARAM_END);
|
|
|
|
unit = UNIT_INCH;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
unit = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return unit;
|
|
}
|
|
|
|
|
|
guint
|
|
gimp_unit_get_deletion_flag (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
guint flag;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_PIXEL, TRUE);
|
|
|
|
if (unit < UNIT_END)
|
|
return FALSE;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_deletion_flag",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
flag = TRUE;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
flag = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return flag;
|
|
}
|
|
|
|
void
|
|
gimp_unit_set_deletion_flag (GUnit unit,
|
|
guint deletion_flag)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
g_return_if_fail (unit >= UNIT_PIXEL);
|
|
|
|
if (unit < UNIT_END)
|
|
return;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_set_deletion_flag",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_INT32, deletion_flag,
|
|
PARAM_END);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
}
|
|
|
|
|
|
gfloat
|
|
gimp_unit_get_factor (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gfloat factor;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_INCH, 1.0);
|
|
|
|
if (unit < UNIT_END)
|
|
return gimp_unit_defs[unit].factor;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_factor",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
factor = 1.0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
factor = return_vals[1].data.d_float;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return factor;
|
|
}
|
|
|
|
|
|
gint
|
|
gimp_unit_get_digits (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gint digits;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_INCH, 2.0);
|
|
|
|
if (unit < UNIT_END)
|
|
return gimp_unit_defs[unit].digits;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_digits",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
digits = 2.0;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
digits = return_vals[1].data.d_int32;
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return digits;
|
|
}
|
|
|
|
|
|
gchar *
|
|
gimp_unit_get_identifier (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gchar *identifier;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_PIXEL, g_strdup (""));
|
|
|
|
if (unit < UNIT_END)
|
|
return g_strdup (gimp_unit_defs[unit].identifier);
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_identifier",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
identifier = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
identifier = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return identifier ? identifier : g_strdup ("");
|
|
}
|
|
|
|
|
|
gchar *
|
|
gimp_unit_get_symbol (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gchar *symbol;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_PIXEL, g_strdup (""));
|
|
|
|
if (unit < UNIT_END)
|
|
return g_strdup (gimp_unit_defs[unit].symbol);
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_symbol",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
symbol = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
symbol = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return symbol ? symbol : g_strdup ("");
|
|
}
|
|
|
|
|
|
gchar *
|
|
gimp_unit_get_abbreviation (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gchar *abbreviation;
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_abbreviation",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
abbreviation = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
abbreviation = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return abbreviation ? abbreviation : g_strdup ("");
|
|
}
|
|
|
|
|
|
gchar *
|
|
gimp_unit_get_singular (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gchar *singular;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_PIXEL, g_strdup (""));
|
|
|
|
if (unit < UNIT_END)
|
|
return g_strdup (gettext (gimp_unit_defs[unit].singular));
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_singular",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
singular = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
singular = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return singular ? singular : g_strdup ("");
|
|
}
|
|
|
|
|
|
gchar *
|
|
gimp_unit_get_plural (GUnit unit)
|
|
{
|
|
GParam *return_vals;
|
|
int nreturn_vals;
|
|
|
|
gchar *plural;
|
|
|
|
g_return_val_if_fail (unit >= UNIT_PIXEL, g_strdup (""));
|
|
|
|
if (unit < UNIT_END)
|
|
return g_strdup (gettext (gimp_unit_defs[unit].plural));
|
|
|
|
return_vals = gimp_run_procedure ("gimp_unit_get_plural",
|
|
&nreturn_vals,
|
|
PARAM_INT32, unit,
|
|
PARAM_END);
|
|
|
|
plural = NULL;
|
|
if (return_vals[0].data.d_status == STATUS_SUCCESS)
|
|
plural = g_strdup (return_vals[1].data.d_string);
|
|
|
|
gimp_destroy_params (return_vals, nreturn_vals);
|
|
|
|
return plural ? plural : g_strdup ("");
|
|
}
|