dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/print/gimp_main_window.c

1605 lines
48 KiB
C
Raw Blame History

/*
* "$Id$"
*
* Main window code for Print plug-in for the GIMP.
*
* Copyright 1997-2000 Michael Sweet (mike@easysw.com),
* Robert Krawitz (rlk@alum.mit.edu), Steve Miller (smiller@rni.net)
* and Michael Natterer (mitch@gimp.org)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program 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 General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include "print_gimp.h"
#ifndef GIMP_1_0
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
/*
* Constants for GUI...
*/
extern vars_t vars;
extern gint plist_count; /* Number of system printers */
extern gint plist_current; /* Current system printer */
extern plist_t plist[MAX_PLIST]; /* System printers */
extern gint32 image_ID;
extern gint image_width;
extern gint image_height;
extern const printer_t *current_printer;
extern gint runme;
extern gint saveme;
extern GtkWidget *gimp_color_adjust_dialog;
void printrc_save (void);
/*
* Main window widgets
*/
static GtkWidget *print_dialog; /* Print dialog window */
static GtkWidget *recenter_button;
static GtkWidget *left_entry;
static GtkWidget *right_entry;
static GtkWidget *top_entry;
static GtkWidget *bottom_entry;
static GtkWidget *media_size; /* Media size option button */
static GtkWidget *media_size_menu=NULL; /* Media size menu */
static GtkWidget *media_type; /* Media type option button */
static GtkWidget *media_type_menu=NULL; /* Media type menu */
static GtkWidget *media_source; /* Media source option button */
static GtkWidget *media_source_menu=NULL; /* Media source menu */
static GtkWidget *resolution; /* Resolution option button */
static GtkWidget *resolution_menu=NULL; /* Resolution menu */
static GtkWidget *scaling_percent; /* Scale by percent */
static GtkWidget *scaling_ppi; /* Scale by pixels-per-inch */
static GtkWidget *scaling_image; /* Scale to the image */
static GtkWidget *output_gray; /* Output type toggle, black */
static GtkWidget *output_color; /* Output type toggle, color */
static GtkWidget *setup_dialog; /* Setup dialog window */
static GtkWidget *printer_driver; /* Printer driver widget */
static GtkWidget *ppd_file; /* PPD file entry */
static GtkWidget *ppd_button; /* PPD file browse button */
static GtkWidget *output_cmd; /* Output command text entry */
static GtkWidget *ppd_browser; /* File selection dialog for PPD files */
static GtkWidget *file_browser; /* FSD for print files */
static GtkWidget *printandsave_button;
static GtkWidget *adjust_color_button;
static GtkObject *scaling_adjustment; /* Adjustment object for scaling */
static gint num_media_sizes = 0; /* Number of media sizes */
static gchar **media_sizes; /* Media size strings */
static gint num_media_types = 0; /* Number of media types */
static gchar **media_types; /* Media type strings */
static gint num_media_sources = 0; /* Number of media sources */
static gchar **media_sources; /* Media source strings */
static gint num_resolutions = 0; /* Number of resolutions */
static gchar **resolutions; /* Resolution strings */
static GtkDrawingArea *preview; /* Preview drawing area widget */
static gint mouse_x; /* Last mouse X */
static gint mouse_y; /* Last mouse Y */
static gint page_left; /* Left pixel column of page */
static gint page_top; /* Top pixel row of page */
static gint page_width; /* Width of page on screen */
static gint page_height; /* Height of page on screen */
static gint print_width; /* Printed width of image */
static gint print_height; /* Printed height of image */
extern GtkObject *brightness_adjustment; /* Adjustment object for brightness */
extern GtkObject *saturation_adjustment; /* Adjustment object for saturation */
extern GtkObject *density_adjustment; /* Adjustment object for density */
extern GtkObject *contrast_adjustment; /* Adjustment object for contrast */
extern GtkObject *red_adjustment; /* Adjustment object for red */
extern GtkObject *green_adjustment; /* Adjustment object for green */
extern GtkObject *blue_adjustment; /* Adjustment object for blue */
extern GtkObject *gamma_adjustment; /* Adjustment object for gamma */
static void gimp_scaling_update (GtkAdjustment *adjustment);
static void gimp_scaling_callback (GtkWidget *widget);
static void gimp_plist_callback (GtkWidget *widget,
gpointer data);
static void gimp_media_size_callback (GtkWidget *widget,
gpointer data);
static void gimp_media_type_callback (GtkWidget *widget,
gpointer data);
static void gimp_media_source_callback (GtkWidget *widget,
gpointer data);
static void gimp_resolution_callback (GtkWidget *widget,
gpointer data);
static void gimp_output_type_callback (GtkWidget *widget,
gpointer data);
#ifdef DO_LINEAR
static void gimp_linear_callback (GtkWidget *widget,
gpointer data);
#endif
static void gimp_orientation_callback (GtkWidget *widget,
gpointer data);
static void gimp_printandsave_callback (void);
static void gimp_print_callback (void);
static void gimp_save_callback (void);
static void gimp_setup_open_callback (void);
static void gimp_setup_ok_callback (void);
static void gimp_ppd_browse_callback (void);
static void gimp_ppd_ok_callback (void);
static void gimp_print_driver_callback (GtkWidget *widget,
gpointer data);
static void gimp_file_ok_callback (void);
static void gimp_file_cancel_callback (void);
static void gimp_preview_update (void);
static void gimp_preview_button_callback (GtkWidget *widget,
GdkEventButton *bevent,
gpointer data);
static void gimp_preview_motion_callback (GtkWidget *widget,
GdkEventMotion *mevent,
gpointer data);
static void gimp_position_callback (GtkWidget *widget);
extern void gimp_create_color_adjust_window (void);
/*
* gimp_create_main_window()
*/
void
gimp_create_main_window (void)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *printer_table;
GtkWidget *label;
GtkWidget *button;
GtkWidget *entry;
GtkWidget *menu;
GtkWidget *item;
GtkWidget *option;
GtkWidget *box;
GSList *group;
#ifdef DO_LINEAR
GSList *linear_group;
#endif
gint i;
gchar s[100];
const printer_t *the_printer = get_printer_by_index (0);
gchar *plug_in_name;
/*
* Create the main dialog
*/
plug_in_name = g_strdup_printf (_("Print v%s"), PLUG_IN_VERSION);
print_dialog = dialog =
gimp_dialog_new (plug_in_name, "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("Print and\nSave Settings"), gimp_printandsave_callback,
NULL, NULL, &printandsave_button, FALSE, FALSE,
_("Save\nSettings"), gimp_save_callback,
NULL, NULL, NULL, FALSE, FALSE,
_("Print"), gimp_print_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
g_free (plug_in_name);
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/*
* Top-level vbox for dialog...
*/
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox,
FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
frame = gtk_frame_new (_("Preview"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
/*
* Drawing area for page preview...
*/
preview = (GtkDrawingArea *) gtk_drawing_area_new ();
gtk_drawing_area_size (preview, PREVIEW_SIZE_HORIZ, PREVIEW_SIZE_VERT);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (preview), FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (preview), "expose_event",
GTK_SIGNAL_FUNC (gimp_preview_update),
NULL);
gtk_signal_connect (GTK_OBJECT (preview), "button_press_event",
GTK_SIGNAL_FUNC (gimp_preview_button_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (preview), "button_release_event",
GTK_SIGNAL_FUNC (gimp_preview_button_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (preview), "motion_notify_event",
GTK_SIGNAL_FUNC (gimp_preview_motion_callback),
NULL);
gtk_widget_show (GTK_WIDGET (preview));
gtk_widget_set_events (GTK_WIDGET (preview),
GDK_EXPOSURE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
table = gtk_table_new (3, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
recenter_button = button = gtk_button_new_with_label (_("Center Image"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_signal_connect(GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gimp_position_callback),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0, 0,
button, 2, TRUE);
left_entry = entry = gtk_entry_new ();
g_snprintf (s, sizeof (s), "%.3f", fabs (vars.left));
gtk_entry_set_text (GTK_ENTRY (entry), s);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (gimp_position_callback),
NULL);
gtk_widget_set_usize (entry, 60, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Left:"), 1.0, 0.5,
entry, 1, TRUE);
top_entry = entry = gtk_entry_new ();
g_snprintf (s, sizeof (s), "%.3f", fabs (vars.top));
gtk_entry_set_text (GTK_ENTRY (entry), s);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (gimp_position_callback),
NULL);
gtk_widget_set_usize (entry, 60, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 2, 1,
_("Top:"), 1.0, 0.5,
entry, 1, TRUE);
right_entry = entry = gtk_entry_new ();
g_snprintf (s, sizeof (s), "%.3f", fabs (vars.left));
gtk_entry_set_text (GTK_ENTRY (entry), s);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (gimp_position_callback),
NULL);
gtk_widget_set_usize (entry, 60, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Right:"), 1.0, 0.5,
entry, 1, TRUE);
bottom_entry = entry = gtk_entry_new ();
g_snprintf (s, sizeof (s), "%.3f", fabs (vars.left));
gtk_entry_set_text (GTK_ENTRY (entry), s);
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (gimp_position_callback),
NULL);
gtk_widget_set_usize (entry, 60, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 2, 2,
_("Bottom:"), 1.0, 0.5,
entry, 1, TRUE);
/*
* Printer settings frame...
*/
frame = gtk_frame_new (_("Printer Settings"));
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
table = printer_table = gtk_table_new (8, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/*
* Media size option menu...
*/
media_size = option = gtk_option_menu_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Media Size:"), 1.0, 0.5,
option, 1, TRUE);
/*
* Media type option menu...
*/
media_type = option = gtk_option_menu_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Media Type:"), 1.0, 0.5,
option, 1, TRUE);
/*
* Media source option menu...
*/
media_source = option = gtk_option_menu_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Media Source:"), 1.0, 0.5,
option, 1, TRUE);
/*
* Orientation option menu...
*/
option = gimp_option_menu_new (FALSE,
_("Auto"), gimp_orientation_callback,
(gpointer) -1, NULL, NULL, TRUE,
_("Portrait"), gimp_orientation_callback,
(gpointer) 0, NULL, NULL, FALSE,
_("Landscape"), gimp_orientation_callback,
(gpointer) 1, NULL, NULL, FALSE,
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 5,
_("Orientation:"), 1.0, 0.5,
option, 1, TRUE);
/*
* Resolution option menu...
*/
resolution = option = gtk_option_menu_new ();
gimp_table_attach_aligned (GTK_TABLE (table), 0, 6,
_("Resolution:"), 1.0, 0.5,
option, 1, TRUE);
/*
* Output type toggles...
*/
box = gtk_vbox_new (FALSE, 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 7,
_("Output Type:"), 1.0, 0.15,
box, 1, TRUE);
output_gray = button = gtk_radio_button_new_with_label (NULL, _("B&W"));
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
if (vars.output_type == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_output_type_callback),
(gpointer) OUTPUT_GRAY);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
output_color = button = gtk_radio_button_new_with_label (group, _("Color"));
if (vars.output_type == 1)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_output_type_callback),
(gpointer) OUTPUT_COLOR);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
#ifdef DO_LINEAR
box = gtk_vbox_new (FALSE, 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 8,
_("Output Level:"), 1.0, 0.15,
box, 1, TRUE);
linear_off = button =
gtk_radio_button_new_with_label (NULL, _("Normal Scale"));
linear_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
if (vars.linear == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_linear_callback),
(gpointer) 0);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
linear_on = button =
gtk_radio_button_new_with_label (linear_group,
_("Experimental Linear Scale"));
if (vars.linear == 1)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_linear_callback),
(gpointer) 1);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
#endif
/*
* Scaling...
*/
frame = gtk_frame_new (_("Scaling and Color Settings"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
if (vars.scaling < 0.0)
{
scaling_adjustment =
gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Scaling:"), 200, 0,
-vars.scaling, 36.0, 1201.0, 1.0, 10.0, 1,
TRUE, 0, 0,
NULL, NULL);
}
else
{
scaling_adjustment =
gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Scaling:"), 200, 75,
vars.scaling, 5.0, 100.0, 1.0, 10.0, 1,
TRUE, 0, 0,
NULL, NULL);
}
gtk_signal_connect (GTK_OBJECT (scaling_adjustment), "value_changed",
GTK_SIGNAL_FUNC (gimp_scaling_update),
NULL);
box = gtk_hbox_new (FALSE, 4);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0, 0,
box, 1, FALSE);
scaling_percent = button =
gtk_radio_button_new_with_label (NULL, _("Percent"));
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
if (vars.scaling > 0.0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_scaling_callback),
NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
scaling_ppi = button = gtk_radio_button_new_with_label (group, _("PPI"));
if (vars.scaling < 0.0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_scaling_callback),
NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
scaling_image = button = gtk_button_new_with_label (_("Set Image Scale"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gimp_scaling_callback),
NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Color adjust button
*/
gimp_create_color_adjust_window ();
adjust_color_button = button = gtk_button_new_with_label (_("Adjust Color"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (gimp_color_adjust_dialog));
gtk_box_pack_end (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/*
* Printer option menu...
*/
menu = gtk_menu_new ();
for (i = 0; i < plist_count; i ++)
{
if (plist[i].active)
item = gtk_menu_item_new_with_label (gettext (plist[i].name));
else
{
gchar buf[18];
buf[0] = '*';
memcpy (buf + 1, plist[i].name, 17);
item = gtk_menu_item_new_with_label (gettext (buf));
}
gtk_menu_append (GTK_MENU (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
GTK_SIGNAL_FUNC (gimp_plist_callback),
(gpointer) i);
gtk_widget_show (item);
}
box = gtk_hbox_new (FALSE, 6);
gimp_table_attach_aligned (GTK_TABLE (printer_table), 0, 0,
_("Printer:"), 1.0, 0.5,
box, 1, TRUE);
option = gtk_option_menu_new ();
gtk_box_pack_start (GTK_BOX (box), option, FALSE, FALSE, 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option), plist_current);
gtk_widget_show (option);
button = gtk_button_new_with_label (_("Setup"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gimp_setup_open_callback),
NULL);
gtk_widget_show (button);
/*
* Setup dialog window...
*/
setup_dialog = dialog =
gimp_dialog_new (_("Setup"), "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), gimp_setup_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_hide,
NULL, 1, NULL, FALSE, TRUE,
NULL);
/*
* Top-level table for dialog...
*/
table = gtk_table_new (3, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
/*
* Printer driver option menu...
*/
label = gtk_label_new (_("Driver:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
menu = gtk_menu_new ();
for (i = 0; i < known_printers (); i ++)
{
if (!strcmp (the_printer->long_name, ""))
continue;
item = gtk_menu_item_new_with_label (gettext (the_printer->long_name));
gtk_menu_append (GTK_MENU (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
GTK_SIGNAL_FUNC (gimp_print_driver_callback),
(gpointer) i);
gtk_widget_show (item);
the_printer++;
}
printer_driver = option = gtk_option_menu_new ();
gtk_table_attach (GTK_TABLE (table), option, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), menu);
gtk_widget_show (option);
/*
* PPD file...
*/
label = gtk_label_new (_("PPD File:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
box = gtk_hbox_new (FALSE, 8);
gtk_table_attach (GTK_TABLE (table), box, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (box);
ppd_file = entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
ppd_button = button = gtk_button_new_with_label (_("Browse"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gimp_ppd_browse_callback),
NULL);
gtk_widget_show (button);
/*
* Print command...
*/
label = gtk_label_new (_("Command:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
output_cmd = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (entry);
/*
* Output file selection dialog...
*/
file_browser = gtk_file_selection_new (_("Print To File?"));
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_browser)->ok_button),
"clicked",
GTK_SIGNAL_FUNC (gimp_file_ok_callback),
NULL);
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_browser)->cancel_button),
"clicked",
GTK_SIGNAL_FUNC (gimp_file_cancel_callback),
NULL);
/*
* PPD file selection dialog...
*/
ppd_browser = gtk_file_selection_new (_("PPD File?"));
gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (ppd_browser));
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (ppd_browser)->ok_button),
"clicked",
GTK_SIGNAL_FUNC (gimp_ppd_ok_callback),
NULL);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (ppd_browser)->cancel_button),
"clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (ppd_browser));
/*
* Show the main dialog and wait for the user to do something...
*/
gimp_plist_callback (NULL, (gpointer) plist_current);
gtk_widget_show (print_dialog);
}
/*
* gimp_scaling_update() - Update the scaling scale using the slider.
*/
static void
gimp_scaling_update (GtkAdjustment *adjustment)
{
if (vars.scaling != adjustment->value)
{
if (GTK_TOGGLE_BUTTON (scaling_ppi)->active)
vars.scaling = -adjustment->value;
else
vars.scaling = adjustment->value;
plist[plist_current].v.scaling = vars.scaling;
}
gimp_preview_update ();
}
/*
* gimp_scaling_callback() - Update the scaling scale using radio buttons.
*/
static void
gimp_scaling_callback (GtkWidget *widget)
{
if (widget == scaling_ppi)
{
GTK_ADJUSTMENT (scaling_adjustment)->lower = 36.0;
GTK_ADJUSTMENT (scaling_adjustment)->upper = 1200.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = 72.0;
vars.scaling = 0.0;
plist[plist_current].v.scaling = vars.scaling;
}
else if (widget == scaling_percent)
{
GTK_ADJUSTMENT (scaling_adjustment)->lower = 5.0;
GTK_ADJUSTMENT (scaling_adjustment)->upper = 100.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = 100.0;
vars.scaling = 0.0;
plist[plist_current].v.scaling = vars.scaling;
}
else if (widget == scaling_image)
{
gdouble xres, yres;
gimp_image_get_resolution (image_ID, &xres, &yres);
GTK_ADJUSTMENT (scaling_adjustment)->lower = 36.0;
GTK_ADJUSTMENT (scaling_adjustment)->upper = 1201.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = yres;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi), TRUE);
vars.scaling = 0.0;
plist[plist_current].v.scaling = vars.scaling;
}
gtk_adjustment_changed (GTK_ADJUSTMENT (scaling_adjustment));
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
/*
* gimp_plist_build_menu ()
*/
static void
gimp_plist_build_menu (GtkWidget *option,
GtkWidget **menu,
gint num_items,
gchar **items,
gchar *cur_item,
GtkSignalFunc callback)
{
gint i;
GtkWidget *item;
GtkWidget *item0 = NULL;
if (*menu != NULL)
{
gtk_widget_destroy (*menu);
*menu = NULL;
}
*menu = gtk_menu_new ();
if (num_items == 0)
{
item = gtk_menu_item_new_with_label (_("Standard"));
gtk_menu_append (GTK_MENU (*menu), item);
gtk_widget_show (item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), *menu);
gtk_widget_set_sensitive (option, FALSE);
gtk_widget_show (option);
return;
}
else
{
gtk_widget_set_sensitive (option, TRUE);
}
for (i = 0; i < num_items; i ++)
{
item = gtk_menu_item_new_with_label (gettext (items[i]));
if (i == 0)
item0 = item;
gtk_menu_append (GTK_MENU (*menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
callback,
(gpointer) i);
gtk_widget_show (item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), *menu);
#ifdef DEBUG
printf ("cur_item = \'%s\'\n", cur_item);
#endif /* DEBUG */
for (i = 0; i < num_items; i ++)
{
#ifdef DEBUG
printf ("item[%d] = \'%s\'\n", i, items[i]);
#endif /* DEBUG */
if (strcmp (items[i], cur_item) == 0)
{
gtk_option_menu_set_history (GTK_OPTION_MENU (option), i);
break;
}
}
if (i == num_items)
{
gtk_option_menu_set_history (GTK_OPTION_MENU (option), 0);
gtk_signal_emit_by_name (GTK_OBJECT (item0), "activate");
}
}
/*
* gimp_do_misc_updates() - Build an option menu for the given parameters...
*/
static void
gimp_do_misc_updates (void)
{
vars.scaling = plist[plist_current].v.scaling;
vars.orientation = plist[plist_current].v.orientation;
vars.left = plist[plist_current].v.left;
vars.top = plist[plist_current].v.top;
if (plist[plist_current].v.scaling < 0)
{
float tmp = -plist[plist_current].v.scaling;
plist[plist_current].v.scaling = -plist[plist_current].v.scaling;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi), TRUE);
GTK_ADJUSTMENT (scaling_adjustment)->lower = 36.0;
GTK_ADJUSTMENT (scaling_adjustment)->upper = 1201.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = tmp;
gtk_signal_emit_by_name (scaling_adjustment, "changed");
gtk_signal_emit_by_name (scaling_adjustment, "value_changed");
}
else
{
float tmp = plist[plist_current].v.scaling;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_percent), TRUE);
GTK_ADJUSTMENT (scaling_adjustment)->lower = 5.0;
GTK_ADJUSTMENT (scaling_adjustment)->upper = 101.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = tmp;
gtk_signal_emit_by_name (scaling_adjustment, "changed");
gtk_signal_emit_by_name (scaling_adjustment, "value_changed");
}
gtk_adjustment_set_value (GTK_ADJUSTMENT (brightness_adjustment),
plist[plist_current].v.brightness);
gtk_adjustment_set_value (GTK_ADJUSTMENT (gamma_adjustment),
plist[plist_current].v.gamma);
gtk_adjustment_set_value (GTK_ADJUSTMENT (contrast_adjustment),
plist[plist_current].v.contrast);
gtk_adjustment_set_value (GTK_ADJUSTMENT (red_adjustment),
plist[plist_current].v.red);
gtk_adjustment_set_value (GTK_ADJUSTMENT (green_adjustment),
plist[plist_current].v.green);
gtk_adjustment_set_value (GTK_ADJUSTMENT (blue_adjustment),
plist[plist_current].v.blue);
gtk_adjustment_set_value (GTK_ADJUSTMENT (saturation_adjustment),
plist[plist_current].v.saturation);
gtk_adjustment_set_value (GTK_ADJUSTMENT (density_adjustment),
plist[plist_current].v.density);
if (plist[plist_current].v.output_type == OUTPUT_GRAY)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_gray), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_color), TRUE);
#ifdef DO_LINEAR
if (plist[plist_current].v.linear == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linear_off), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linear_on), TRUE);
#endif
gimp_preview_update ();
}
/*
* gimp_position_callback() - callback for position entry widgets
*/
static void
gimp_position_callback (GtkWidget *widget)
{
gboolean dontcheck = FALSE;
if (widget == top_entry)
{
gfloat new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
vars.top = (new_value + 1.0 / 144) * 72;
}
else if (widget == left_entry)
{
gfloat new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
vars.left = (new_value + 1.0 / 144) * 72;
}
else if (widget == bottom_entry)
{
gfloat new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
if (vars.scaling < 0)
vars.top =
(new_value + 1.0 / 144) * 72 - (image_height * -72.0 / vars.scaling);
else
vars.top = (new_value + 1.0 / 144) * 72 - print_height;
}
else if (widget == right_entry)
{
gfloat new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
if (vars.scaling < 0)
vars.left =
(new_value + 1.0 / 144) * 72 - (image_width * -72.0 / vars.scaling);
else
vars.left = (new_value + 1.0 / 144) * 72 - print_width;
}
else if (widget == recenter_button)
{
vars.left = -1;
vars.top = -1;
dontcheck = TRUE;
}
if (!dontcheck)
{
if (vars.left < 0)
vars.left = 0;
if (vars.top < 0)
vars.top = 0;
}
plist[plist_current].v.left = vars.left;
plist[plist_current].v.top = vars.top;
gimp_preview_update ();
}
/*
* gimp_plist_callback() - Update the current system printer...
*/
static void
gimp_plist_callback (GtkWidget *widget,
gpointer data)
{
gint i;
plist_t *p;
plist_current = (gint) data;
p = plist + plist_current;
if (p->v.driver[0] != '\0')
{
strcpy(vars.driver, p->v.driver);
current_printer = get_printer_by_driver (vars.driver);
}
strcpy (vars.ppd_file, p->v.ppd_file);
strcpy (vars.media_size, p->v.media_size);
strcpy (vars.media_type, p->v.media_type);
strcpy (vars.media_source, p->v.media_source);
strcpy (vars.resolution, p->v.resolution);
strcpy (vars.output_to, p->v.output_to);
gimp_do_misc_updates ();
/*
* Now get option parameters...
*/
if (num_media_sizes > 0)
{
for (i = 0; i < num_media_sizes; i ++)
free (media_sizes[i]);
free (media_sizes);
}
media_sizes = (*(current_printer->parameters))(current_printer->model,
p->v.ppd_file,
"PageSize", &num_media_sizes);
if (vars.media_size[0] == '\0')
strcpy (vars.media_size, media_sizes[0]);
gimp_plist_build_menu (media_size,
&media_size_menu,
num_media_sizes,
media_sizes,
p->v.media_size,
gimp_media_size_callback);
if (num_media_types > 0)
{
for (i = 0; i < num_media_types; i ++)
free (media_types[i]);
free (media_types);
}
media_types = (*(current_printer->parameters))(current_printer->model,
p->v.ppd_file,
"MediaType",
&num_media_types);
if (vars.media_type[0] == '\0' && media_types != NULL)
strcpy (vars.media_type, media_types[0]);
gimp_plist_build_menu (media_type,
&media_type_menu,
num_media_types,
media_types,
p->v.media_type,
gimp_media_type_callback);
if (num_media_sources > 0)
{
for (i = 0; i < num_media_sources; i ++)
free (media_sources[i]);
free (media_sources);
}
media_sources = (*(current_printer->parameters))(current_printer->model,
p->v.ppd_file,
"InputSlot",
&num_media_sources);
if (vars.media_source[0] == '\0' && media_sources != NULL)
strcpy (vars.media_source, media_sources[0]);
gimp_plist_build_menu (media_source,
&media_source_menu,
num_media_sources,
media_sources,
p->v.media_source,
gimp_media_source_callback);
if (num_resolutions > 0)
{
for (i = 0; i < num_resolutions; i ++)
free (resolutions[i]);
free (resolutions);
}
resolutions = (*(current_printer->parameters))(current_printer->model,
p->v.ppd_file,
"Resolution",
&num_resolutions);
if (vars.resolution[0] == '\0' && resolutions != NULL)
strcpy (vars.resolution, resolutions[0]);
gimp_plist_build_menu (resolution,
&resolution_menu,
num_resolutions,
resolutions,
p->v.resolution,
gimp_resolution_callback);
}
/*
* gimp_media_size_callback() - Update the current media size...
*/
static void
gimp_media_size_callback(GtkWidget *widget,
gpointer data)
{
strcpy (vars.media_size, media_sizes[(gint) data]);
strcpy (plist[plist_current].v.media_size, media_sizes[(gint) data]);
vars.left = -1;
vars.top = -1;
plist[plist_current].v.left = vars.left;
plist[plist_current].v.top = vars.top;
gimp_preview_update ();
}
/*
* gimp_media_type_callback() - Update the current media type...
*/
static void
gimp_media_type_callback (GtkWidget *widget,
gpointer data)
{
strcpy (vars.media_type, media_types[(gint) data]);
strcpy (plist[plist_current].v.media_type, media_types[(gint) data]);
}
/*
* gimp_media_source_callback() - Update the current media source...
*/
static void
gimp_media_source_callback (GtkWidget *widget,
gpointer data)
{
strcpy (vars.media_source, media_sources[(gint) data]);
strcpy (plist[plist_current].v.media_source, media_sources[(gint) data]);
}
/*
* gimp_resolution_callback() - Update the current resolution...
*/
static void
gimp_resolution_callback (GtkWidget *widget,
gpointer data)
{
strcpy (vars.resolution, resolutions[(gint) data]);
strcpy (plist[plist_current].v.resolution, resolutions[(gint) data]);
}
/*
* gimp_orientation_callback() - Update the current media size...
*/
static void
gimp_orientation_callback (GtkWidget *widget,
gpointer data)
{
vars.orientation = (gint) data;
vars.left = -1;
vars.top = -1;
plist[plist_current].v.orientation = vars.orientation;
plist[plist_current].v.left = vars.left;
plist[plist_current].v.top = vars.top;
gimp_preview_update ();
}
/*
* gimp_output_type_callback() - Update the current output type...
*/
static void
gimp_output_type_callback (GtkWidget *widget,
gpointer data)
{
if (GTK_TOGGLE_BUTTON (widget)->active)
{
vars.output_type = (gint) data;
plist[plist_current].v.output_type = (gint) data;
}
}
/*
* gimp_linear_callback() - Update the current linear gradient mode...
*/
#ifdef DO_LINEAR
static void
gimp_linear_callback (GtkWidget *widget,
gpointer data)
{
if (GTK_TOGGLE_BUTTON (widget)->active)
{
vars.linear = (gint) data;
plist[plist_current].v.linear = (gint) data;
}
}
#endif
/*
* 'print_callback()' - Start the print...
*/
static void
gimp_print_callback (void)
{
if (plist_current > 0)
{
runme = TRUE;
gtk_widget_destroy (print_dialog);
}
else
{
gtk_widget_set_sensitive (print_dialog, FALSE);
gtk_widget_show (file_browser);
}
}
/*
* gimp_printandsave_callback() -
*/
static void
gimp_printandsave_callback (void)
{
saveme = TRUE;
if (plist_current > 0)
{
runme = TRUE;
gtk_widget_destroy (print_dialog);
}
else
{
gtk_widget_set_sensitive (print_dialog, FALSE);
gtk_widget_show (file_browser);
}
}
/*
* gimp_save_callback() - save settings, don't destroy dialog
*/
static void
gimp_save_callback (void)
{
printrc_save ();
}
/*
* gimp_setup_open__callback() -
*/
static void
gimp_setup_open_callback (void)
{
gint idx;
current_printer = get_printer_by_driver (plist[plist_current].v.driver);
idx = get_printer_index_by_driver (plist[plist_current].v.driver);
gtk_option_menu_set_history (GTK_OPTION_MENU (printer_driver), idx);
gtk_entry_set_text (GTK_ENTRY (ppd_file), plist[plist_current].v.ppd_file);
if (strncmp (plist[plist_current].v.driver, "ps", 2) == 0)
gtk_widget_show (ppd_file);
else
gtk_widget_show (ppd_file);
gtk_entry_set_text (GTK_ENTRY (output_cmd), plist[plist_current].v.output_to);
if (plist_current == 0)
gtk_widget_hide (output_cmd);
else
gtk_widget_show (output_cmd);
gtk_widget_show (setup_dialog);
}
/*
* gimp_setup_ok_callback() -
*/
static void
gimp_setup_ok_callback (void)
{
strcpy (vars.driver, current_printer->driver);
strcpy (plist[plist_current].v.driver, current_printer->driver);
strcpy (vars.output_to, gtk_entry_get_text (GTK_ENTRY (output_cmd)));
strcpy (plist[plist_current].v.output_to, vars.output_to);
strcpy (vars.ppd_file, gtk_entry_get_text (GTK_ENTRY (ppd_file)));
strcpy (plist[plist_current].v.ppd_file, vars.ppd_file);
gimp_plist_callback (NULL, (gpointer) plist_current);
gtk_widget_hide (setup_dialog);
}
/*
* gimp_print_driver_callback() - Update the current printer driver...
*/
static void
gimp_print_driver_callback (GtkWidget *widget,
gpointer data)
{
current_printer = get_printer_by_index ((gint) data);
if (strncmp (current_printer->driver, "ps", 2) == 0)
{
gtk_widget_show (ppd_file);
gtk_widget_show (ppd_button);
}
else
{
gtk_widget_hide (ppd_file);
gtk_widget_hide (ppd_button);
}
}
/*
* gimp_ppd_browse_callback() -
*/
static void
gimp_ppd_browse_callback (void)
{
gtk_file_selection_set_filename (GTK_FILE_SELECTION (ppd_browser),
gtk_entry_get_text (GTK_ENTRY (ppd_file)));
gtk_widget_show (ppd_browser);
}
/*
* gimp_ppd_ok_callback() -
*/
static void
gimp_ppd_ok_callback (void)
{
gtk_widget_hide (ppd_browser);
gtk_entry_set_text
(GTK_ENTRY (ppd_file),
gtk_file_selection_get_filename (GTK_FILE_SELECTION (ppd_browser)));
}
/*
* gimp_file_ok_callback() - print to file and go away
*/
static void
gimp_file_ok_callback (void)
{
gtk_widget_hide (file_browser);
strcpy (vars.output_to,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_browser)));
runme = TRUE;
gtk_widget_destroy (print_dialog);
}
/*
* gimp_file_cancel_callback() -
*/
static void
gimp_file_cancel_callback (void)
{
gtk_widget_hide (file_browser);
gtk_widget_set_sensitive (print_dialog, TRUE);
}
/*
* gimp_preview_update_callback() -
*/
static void
gimp_preview_update (void)
{
gint temp;
gint orient; /* True orientation of page */
gint tw0, tw1; /* Temporary page_widths */
gint th0, th1; /* Temporary page_heights */
gint ta0 = 0, ta1 = 0; /* Temporary areas */
gint left, right; /* Imageable area */
gint top, bottom;
gint width, length; /* Physical width */
static GdkGC *gc = NULL;
gchar s[255];
if (preview->widget.window == NULL)
return;
gdk_window_clear (preview->widget.window);
if (gc == NULL)
gc = gdk_gc_new (preview->widget.window);
(*current_printer->imageable_area) (current_printer->model, vars.ppd_file,
vars.media_size, &left, &right,
&bottom, &top);
page_width = right - left;
page_height = top - bottom;
(*current_printer->media_size) (current_printer->model, vars.ppd_file,
vars.media_size, &width, &length);
if (vars.scaling < 0)
{
tw0 = 72 * -image_width / vars.scaling;
th0 = tw0 * image_height / image_width;
tw1 = tw0;
th1 = th0;
}
else
{
/* Portrait */
tw0 = page_width * vars.scaling / 100;
th0 = tw0 * image_height / image_width;
if (th0 > page_height * vars.scaling / 100)
{
th0 = page_height * vars.scaling / 100;
tw0 = th0 * image_width / image_height;
}
ta0 = tw0 * th0;
/* Landscape */
tw1 = page_height * vars.scaling / 100;
th1 = tw1 * image_height / image_width;
if (th1 > page_width * vars.scaling / 100)
{
th1 = page_width * vars.scaling / 100;
tw1 = th1 * image_width / image_height;
}
ta1 = tw1 * th1;
}
if (vars.orientation == ORIENT_AUTO)
{
if (vars.scaling < 0)
{
if ((page_width > page_height && tw0 > th0) ||
(page_height > page_width && th0 > tw0))
{
orient = ORIENT_PORTRAIT;
if (tw0 > page_width)
{
vars.scaling *= (double) page_width / (double) tw0;
th0 = th0 * page_width / tw0;
}
if (th0 > page_height)
{
vars.scaling *= (double) page_height / (double) th0;
tw0 = tw0 * page_height / th0;
}
}
else
{
orient = ORIENT_LANDSCAPE;
if (tw1 > page_height)
{
vars.scaling *= (double) page_height / (double) tw1;
th1 = th1 * page_height / tw1;
}
if (th1 > page_width)
{
vars.scaling *= (double) page_width / (double) th1;
tw1 = tw1 * page_width / th1;
}
}
}
else
{
if (ta0 >= ta1)
orient = ORIENT_PORTRAIT;
else
orient = ORIENT_LANDSCAPE;
}
}
else
{
orient = vars.orientation;
}
if (orient == ORIENT_LANDSCAPE)
{
temp = page_width;
page_width = page_height;
page_height = temp;
temp = width;
width = length;
length = temp;
print_width = tw1;
print_height = th1;
}
else
{
print_width = tw0;
print_height = th0;
}
page_left = (PREVIEW_SIZE_HORIZ - 10 * page_width / 72) / 2;
page_top = (PREVIEW_SIZE_VERT - 10 * page_height / 72) / 2;
gdk_draw_rectangle (preview->widget.window, gc, 0,
(PREVIEW_SIZE_HORIZ - (10 * width / 72)) / 2,
(PREVIEW_SIZE_VERT - (10 * length / 72)) / 2,
10 * width / 72, 10 * length / 72);
if (vars.left < 0)
vars.left = (page_width - print_width) / 2;
left = vars.left;
if (left > (page_width - print_width))
{
left = page_width - print_width;
vars.left = left;
plist[plist_current].v.left = vars.left;
}
if (vars.top < 0)
vars.top = (page_height - print_height) / 2;
top = vars.top;
if (top > (page_height - print_height))
{
top = page_height - print_height;
vars.top = top;
plist[plist_current].v.top = vars.top;
}
g_snprintf (s, sizeof (s), "%.2f", vars.top / 72.0);
gtk_signal_handler_block_by_data (GTK_OBJECT (top_entry), NULL);
gtk_entry_set_text (GTK_ENTRY (top_entry), s);
gtk_signal_handler_unblock_by_data (GTK_OBJECT (top_entry), NULL);
g_snprintf (s, sizeof (s), "%.2f", vars.left / 72.0);
gtk_signal_handler_block_by_data (GTK_OBJECT (left_entry), NULL);
gtk_entry_set_text (GTK_ENTRY (left_entry), s);
gtk_signal_handler_unblock_by_data (GTK_OBJECT (left_entry), NULL);
gtk_signal_handler_block_by_data (GTK_OBJECT (bottom_entry), NULL);
if (vars.scaling < 0)
g_snprintf(s, sizeof (s), "%.2f",
(vars.top + (image_height * -72.0 / vars.scaling)) / 72.0);
else
g_snprintf (s, sizeof (s), "%.2f", (vars.top + print_height) / 72.0);
gtk_entry_set_text (GTK_ENTRY (bottom_entry), s);
gtk_signal_handler_unblock_by_data (GTK_OBJECT (bottom_entry), NULL);
gtk_signal_handler_block_by_data (GTK_OBJECT (right_entry), NULL);
if (vars.scaling < 0)
g_snprintf (s, sizeof (s), "%.2f",
(vars.left + (image_width * -72.0 / vars.scaling)) / 72.0);
else
g_snprintf (s, sizeof (s), "%.2f", (vars.left + print_width) / 72.0);
gtk_entry_set_text (GTK_ENTRY (right_entry), s);
gtk_signal_handler_unblock_by_data (GTK_OBJECT (right_entry), NULL);
gdk_draw_rectangle (preview->widget.window, gc, 1,
page_left + 10 * left / 72, page_top + 10 * top / 72,
10 * print_width / 72, 10 * print_height / 72);
gdk_flush ();
}
/*
* gimp_preview_button_callback() -
*/
static void
gimp_preview_button_callback (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
mouse_x = event->x;
mouse_y = event->y;
}
/*
* gimp_preview_motion_callback() -
*/
static void
gimp_preview_motion_callback (GtkWidget *widget,
GdkEventMotion *event,
gpointer data)
{
if (vars.left < 0 || vars.top < 0)
{
vars.left = 72 * (page_width - print_width) / 20;
vars.top = 72 * (page_height - print_height) / 20;
}
vars.left += 72 * (event->x - mouse_x) / 10;
vars.top += 72 * (event->y - mouse_y) / 10;
if (vars.left < 0)
vars.left = 0;
if (vars.top < 0)
vars.top = 0;
plist[plist_current].v.left = vars.left;
plist[plist_current].v.top = vars.top;
gimp_preview_update ();
mouse_x = event->x;
mouse_y = event->y;
}
#endif /* ! GIMP_1_0 */
Reference in New Issue View Git Blame Copy Permalink