callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5e8ee554a218fcf0f7c7a26ed44d2607bdebe800
gimp/libgimpwidgets/gimpunitmenu.c
Michael Natterer 5e8ee554a2 This implements the rest of the unit system (unitrc loading and saving and 
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
1999-03-16 20:14:07 +00:00

540 lines
15 KiB
C
Raw Blame History

/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpunitmenu.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 "gimpunitmenu.h"
#include "libgimp/gimpintl.h"
static const gchar* gimp_unit_menu_build_string (gchar *format, GUnit unit);
static void gimp_unit_menu_callback (GtkWidget *widget, gpointer data);
enum {
GUM_UNIT_CHANGED_SIGNAL,
LAST_SIGNAL
};
static gint gimp_unit_menu_signals[LAST_SIGNAL] = { 0 };
static void
gimp_unit_menu_class_init (GimpUnitMenuClass *class)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass*) class;
gimp_unit_menu_signals[GUM_UNIT_CHANGED_SIGNAL] =
gtk_signal_new ("unit_changed",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpUnitMenuClass, gimp_unit_menu),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, gimp_unit_menu_signals,
LAST_SIGNAL);
class->gimp_unit_menu = NULL;
}
static void
gimp_unit_menu_init (GimpUnitMenu *gum)
{
gum->selection = NULL;
gum->unit = UNIT_PIXEL;
gum->start = 0;
}
guint
gimp_unit_menu_get_type ()
{
static guint gum_type = 0;
if (!gum_type)
{
GtkTypeInfo gum_info =
{
"GimpUnitMenu",
sizeof (GimpUnitMenu),
sizeof (GimpUnitMenuClass),
(GtkClassInitFunc) gimp_unit_menu_class_init,
(GtkObjectInitFunc) gimp_unit_menu_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL
};
gum_type = gtk_type_unique (gtk_option_menu_get_type (), &gum_info);
}
return gum_type;
}
GtkWidget*
gimp_unit_menu_new (gchar *format,
GUnit unit,
gboolean with_pixels,
gboolean with_custom)
{
GimpUnitMenu *gum;
GtkWidget *menu;
GtkWidget *menuitem;
GUnit u;
g_return_val_if_fail ((unit >= UNIT_PIXEL) &&
(unit < gimp_unit_get_number_of_units ()), NULL);
if (with_custom); /* avoid 'unused variable' compiler warning */
gum = gtk_type_new (gimp_unit_menu_get_type ());
gum->format = g_strdup (format);
/* if we don't want pixels, start with inches */
gum->start = with_pixels ? UNIT_PIXEL : UNIT_INCH;
if (unit < gum->start)
unit = gum->start;
menu = gtk_menu_new();
for (u = gum->start; u < gimp_unit_get_number_of_built_in_units(); u++)
{
menuitem =
gtk_menu_item_new_with_label (gimp_unit_menu_build_string (format, u));
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) gimp_unit_menu_callback, gum);
gtk_object_set_data (GTK_OBJECT (menuitem), "gimp_unit_menu", (gpointer)u);
gtk_widget_show(menuitem);
/* add a separator after pixels */
if (u == UNIT_PIXEL)
{
menuitem = gtk_menu_item_new ();
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_widget_show (menuitem);
}
}
if (unit >= gimp_unit_get_number_of_built_in_units ())
{
menuitem = gtk_menu_item_new ();
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_widget_show (menuitem);
menuitem =
gtk_menu_item_new_with_label (gimp_unit_menu_build_string (format, unit));
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) gimp_unit_menu_callback, gum);
gtk_object_set_data (GTK_OBJECT (menuitem), "gimp_unit_menu", (gpointer)unit);
gtk_widget_show(menuitem);
}
menuitem = gtk_menu_item_new ();
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_widget_show (menuitem);
menuitem =
gtk_menu_item_new_with_label (_("More..."));
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) gimp_unit_menu_callback, gum);
gtk_object_set_data (GTK_OBJECT (menuitem), "gimp_unit_menu",
(gpointer)65536);
gtk_widget_show(menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (gum), menu);
gum->unit = unit;
gtk_option_menu_set_history (GTK_OPTION_MENU (gum),
((unit < UNIT_END) ?
(unit - gum->start +
(with_pixels ? 1 : 0)) :
(UNIT_END + (with_pixels ? 2 : 0))));
return GTK_WIDGET (gum);
}
void
gimp_unit_menu_set_unit (GimpUnitMenu *gum,
GUnit unit)
{
GtkWidget *menuitem = NULL;
GList *items;
gint user_unit;
g_return_if_fail (gum != NULL);
g_return_if_fail (GIMP_IS_UNIT_MENU (gum));
g_return_if_fail ((unit >= gum->start) &&
(unit < gimp_unit_get_number_of_units ()));
if (unit == gum->unit)
return;
items = GTK_MENU_SHELL (GTK_OPTION_MENU (gum)->menu)->children;
user_unit = UNIT_END + ((gum->start == UNIT_PIXEL) ? 2 : 0);
if (unit >= UNIT_END)
{
if ((g_list_length (items) - 3) >= user_unit)
{
gtk_widget_destroy (GTK_WIDGET (g_list_nth_data (items,
user_unit - 1)));
gtk_widget_destroy (GTK_WIDGET (g_list_nth_data (items,
user_unit - 1)));
}
menuitem = gtk_menu_item_new ();
gtk_menu_append (GTK_MENU (GTK_OPTION_MENU (gum)->menu), menuitem);
gtk_menu_reorder_child (GTK_MENU (GTK_OPTION_MENU (gum)->menu),
menuitem, user_unit - 1);
gtk_widget_show(menuitem);
menuitem =
gtk_menu_item_new_with_label (gimp_unit_menu_build_string (gum->format, unit));
gtk_menu_append (GTK_MENU (GTK_OPTION_MENU (gum)->menu), menuitem);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
(GtkSignalFunc) gimp_unit_menu_callback, gum);
gtk_object_set_data (GTK_OBJECT (menuitem), "gimp_unit_menu", (gpointer)unit);
gtk_menu_reorder_child (GTK_MENU (GTK_OPTION_MENU (gum)->menu),
menuitem, user_unit);
gtk_widget_show(menuitem);
}
gum->unit = unit;
gtk_option_menu_set_history (GTK_OPTION_MENU (gum),
((unit < UNIT_END) ?
(unit - gum->start +
((gum->start == UNIT_PIXEL) ? 1 : 0)) :
(UNIT_END + ((gum->start == UNIT_PIXEL) ? 2 : 0))));
}
GUnit
gimp_unit_menu_get_unit (GimpUnitMenu *gum)
{
g_return_val_if_fail (gum != NULL, UNIT_INCH);
g_return_val_if_fail (GIMP_IS_UNIT_MENU (gum), UNIT_INCH);
return gum->unit;
}
/* most of the next two functions is stolen from app/gdisplay.h ;-) */
static int
print (char *buf, int len, int start, const char *fmt, ...)
{
va_list args;
int printed;
va_start (args, fmt);
printed = g_vsnprintf (buf + start, len - start, fmt, args);
if (printed < 0)
printed = len - start;
va_end (args);
return printed;
}
static const gchar*
gimp_unit_menu_build_string (gchar *format, GUnit unit)
{
#define BUFFER_LEN 64
static gchar buffer[BUFFER_LEN];
gchar format_buffer[16];
int i = 0;
while (i < (BUFFER_LEN - 1) && *format)
{
switch (*format)
{
case '%':
format++;
switch (*format)
{
case 0:
g_warning (_("unit-menu-format string ended within %%-sequence"));
break;
case '%':
buffer[i++] = '%';
break;
case 'f': /* factor (how many units make up an inch) */
g_snprintf(format_buffer, 16, "%%.%df",
gimp_unit_get_digits (unit));
i += print (buffer, BUFFER_LEN, i, format_buffer,
gimp_unit_get_factor (unit));
break;
case 'y': /* symbol ("''" for inch) */
i += print (buffer, BUFFER_LEN, i, "%s",
gimp_unit_get_symbol (unit));
break;
case 'a': /* abbreviation */
i += print (buffer, BUFFER_LEN, i, "%s",
gimp_unit_get_abbreviation (unit));
break;
case 's': /* singular */
i += print (buffer, BUFFER_LEN, i, "%s",
gimp_unit_get_singular (unit));
break;
case 'p': /* plural */
i += print (buffer, BUFFER_LEN, i, "%s",
gimp_unit_get_plural (unit));
break;
default:
g_warning (_("unit-menu-format contains unknown"
"format sequence '%%%c'"), *format);
break;
}
break;
default:
buffer[i++] = *format;
break;
}
format++;
}
buffer[MIN(i, BUFFER_LEN - 1)] = 0;
return buffer;
}
/* private callbacks of gimp_unit_menu_create_selection ()
*/
static void
gimp_unit_menu_selection_select_callback (GtkWidget *widget,
gpointer data)
{
GimpUnitMenu *gum;
GUnit unit;
gum = GIMP_UNIT_MENU (data);
if (gum->selection && GTK_CLIST (gum->clist)->selection)
{
unit = (GUnit)gtk_clist_get_row_data (GTK_CLIST (gum->clist),
(int)(GTK_CLIST (gum->clist)->selection->data));
gimp_unit_menu_set_unit (gum, unit);
gtk_signal_emit (GTK_OBJECT (gum),
gimp_unit_menu_signals[GUM_UNIT_CHANGED_SIGNAL]);
gtk_widget_destroy (gum->selection);
gum->selection = NULL;
gum->clist = NULL;
}
}
static void
gimp_unit_menu_selection_close_callback (GtkWidget *widget,
gpointer data)
{
GimpUnitMenu *gum;
gum = GIMP_UNIT_MENU (data);
if (gum->selection)
{
gtk_widget_destroy (gum->selection);
gum->selection = NULL;
gum->clist = NULL;
}
}
static gint
gimp_unit_menu_selection_delete_callback (GtkWidget *widget,
GdkEvent *event,
gpointer data)
{
gimp_unit_menu_selection_close_callback (NULL, data);
return TRUE;
}
/* private function of gimp_unit_menu_callback ()
*/
static void
gimp_unit_menu_create_selection (GimpUnitMenu *gum)
{
GtkWidget *hbox;
GtkWidget *hbbox;
GtkWidget *vbox;
GtkWidget *scrolled_win;
GtkWidget *button;
gchar *row[2];
GUnit unit;
gint num_units;
gchar buffer[32];
gum->selection = gtk_dialog_new ();
gtk_window_set_wmclass (GTK_WINDOW (gum->selection),
"unitselection", "Gimp");
gtk_window_set_title (GTK_WINDOW (gum->selection), _("Unit Selection"));
gtk_window_set_policy(GTK_WINDOW(gum->selection), FALSE, TRUE, FALSE);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (gum->selection)->vbox), vbox);
gtk_container_border_width (GTK_CONTAINER (vbox), 2);
gtk_widget_show (vbox);
gtk_signal_connect (GTK_OBJECT (gum->selection), "delete_event",
GTK_SIGNAL_FUNC (gimp_unit_menu_selection_delete_callback),
gum);
gtk_signal_connect (GTK_OBJECT (gum), "destroy",
GTK_SIGNAL_FUNC (gimp_unit_menu_selection_close_callback),
gum);
gtk_signal_connect (GTK_OBJECT (gum), "unmap",
GTK_SIGNAL_FUNC (gimp_unit_menu_selection_close_callback),
gum);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gum->clist = gtk_clist_new (2);
gtk_clist_set_shadow_type (GTK_CLIST (gum->clist), GTK_SHADOW_IN);
gtk_clist_set_selection_mode (GTK_CLIST (gum->clist), GTK_SELECTION_BROWSE);
gtk_widget_set_usize (gum->clist, 200, 150);
gtk_clist_set_column_title (GTK_CLIST (gum->clist), 0, _("Unit"));
gtk_clist_set_column_auto_resize (GTK_CLIST (gum->clist), 0, TRUE);
gtk_clist_set_column_title (GTK_CLIST (gum->clist), 1, _("Factor"));
gtk_clist_set_column_auto_resize (GTK_CLIST (gum->clist), 1, TRUE);
gtk_clist_column_titles_show (GTK_CLIST (gum->clist));
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_win, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (scrolled_win), gum->clist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_widget_show(scrolled_win);
gtk_widget_show(gum->clist);
gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (gum->selection)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (gum->selection)->action_area),
FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end(GTK_BOX (GTK_DIALOG (gum->selection)->action_area), hbbox,
FALSE, FALSE, 0);
gtk_widget_show(hbbox);
button = gtk_button_new_with_label (_("Select"));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gimp_unit_menu_selection_select_callback,
gum);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Close"));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gimp_unit_menu_selection_close_callback,
gum);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
num_units = gimp_unit_get_number_of_units ();
for (unit = UNIT_END; unit < num_units; unit++)
{
row[0] = gimp_unit_menu_build_string (gum->format, unit);
g_snprintf (buffer, sizeof(buffer), "(%f)",
gimp_unit_get_factor (unit));
row[1] = buffer;
gtk_clist_append (GTK_CLIST (gum->clist), row);
gtk_clist_set_row_data (GTK_CLIST (gum->clist),
unit - UNIT_END, (gpointer)unit);
}
/* Now show the dialog */
gtk_widget_show(vbox);
gtk_widget_show(gum->selection);
if(gum->unit >= UNIT_END)
{
gtk_clist_select_row (GTK_CLIST (gum->clist), gum->unit - UNIT_END, 0);
gtk_clist_moveto (GTK_CLIST (gum->clist), gum->unit - UNIT_END,
0, 0.0, 0.0);
}
}
static void
gimp_unit_menu_callback (GtkWidget *widget,
gpointer data)
{
GimpUnitMenu *gum;
GUnit new_unit;
gum = data;
new_unit = (guint) gtk_object_get_data (GTK_OBJECT (widget),
"gimp_unit_menu");
if (gum->unit == new_unit)
return;
if (new_unit == 65536)
{
gtk_option_menu_set_history (GTK_OPTION_MENU (gum),
((gum->unit < UNIT_END) ?
(gum->unit - gum->start +
((gum->start == UNIT_PIXEL) ? 1 : 0)) :
(UNIT_END + ((gum->start == UNIT_PIXEL) ?
2 : 0))));
if (! gum->selection)
gimp_unit_menu_create_selection (gum);
return;
}
else if (gum->selection)
{
gtk_widget_destroy (gum->selection);
gum->selection = NULL;
}
gimp_unit_menu_set_unit (gum, new_unit);
gtk_signal_emit (GTK_OBJECT (gum),
gimp_unit_menu_signals[GUM_UNIT_CHANGED_SIGNAL]);
}
Reference in New Issue View Git Blame Copy Permalink