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

3286 lines
100 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 <stdlib.h>
#include <string.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
#endif
#undef GTK_DISABLE_DEPRECATED
#include <gtk/gtk.h>
#include <gimp-print/gimp-print.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include "print_gimp.h"
#include "libgimp/stdplugins-intl.h"
#define MAX_PREVIEW_PPI (40)
/*
* Constants for GUI.
*/
#define PREVIEW_SIZE_VERT 360
#define PREVIEW_SIZE_HORIZ 260
#define MOVE_CONSTRAIN 0
#define MOVE_HORIZONTAL 1
#define MOVE_VERTICAL 2
#define MOVE_ANY (MOVE_HORIZONTAL | MOVE_VERTICAL)
/*
* Main window widgets
*/
static GtkWidget *main_vbox;
static GtkWidget *main_hbox;
static GtkWidget *right_vbox;
static GtkWidget *notebook;
static GtkWidget *print_dialog; /* Print dialog window */
static GtkWidget *recenter_button;
static GtkWidget *recenter_vertical_button;
static GtkWidget *recenter_horizontal_button;
static GtkWidget *left_entry;
static GtkWidget *right_entry;
static GtkWidget *right_border_entry;
static GtkWidget *width_entry;
static GtkWidget *top_entry;
static GtkWidget *bottom_entry;
static GtkWidget *bottom_border_entry;
static GtkWidget *height_entry;
static GtkWidget *unit_inch;
static GtkWidget *unit_cm;
static GtkWidget *media_size_combo = NULL; /* Media size combo box */
static GtkWidget *custom_size_width = NULL;
static GtkWidget *custom_size_height = NULL;
static gint media_size_callback_id = -1;
static GtkWidget *media_type_combo = NULL; /* Media type combo box */
static gint media_type_callback_id = -1; /* Media type calback ID */
static GtkWidget *media_source_combo = NULL; /* Media source combo box */
static gint media_source_callback_id = -1; /* Media source calback ID */
static GtkWidget *ink_type_combo = NULL; /* Ink type combo box */
static gint ink_type_callback_id = -1; /* Ink type calback ID */
static GtkWidget *resolution_combo = NULL; /* Resolution combo box */
static gint resolution_callback_id = -1; /* Resolution calback ID */
static GtkWidget *orientation_menu = NULL; /* Orientation 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 *output_monochrome;
static GtkWidget *image_line_art;
static GtkWidget *image_solid_tone;
static GtkWidget *image_continuous_tone;
static GtkWidget *setup_dialog; /* Setup dialog window */
static GtkWidget *printer_driver; /* Printer driver widget */
static GtkWidget *printer_model_label; /* Printer model name */
static GtkWidget *printer_crawler; /* Scrolled Window for menu */
static GtkWidget *printer_combo; /* Combo for menu */
static gint plist_callback_id = -1;
static GtkWidget *ppd_file; /* PPD file entry */
static GtkWidget *ppd_label; /* PPD file entry */
static GtkWidget *ppd_button; /* PPD file browse button */
static GtkWidget *output_cmd; /* Output command text entry */
static GtkWidget *output_label; /* Output command label */
static GtkWidget *ppd_browser; /* File selection dialog for PPD files */
static GtkWidget *new_printer_dialog; /* New printer dialog window */
static GtkWidget *new_printer_entry; /* New printer text entry */
static GtkWidget *file_browser; /* FSD for print files */
static GtkWidget *adjust_color_button;
static GtkWidget *about_dialog;
static GtkObject *scaling_adjustment; /* Adjustment object for scaling */
static gboolean suppress_scaling_adjustment = FALSE;
static gboolean suppress_scaling_callback = FALSE;
static gint suppress_preview_update = 0;
static gint preview_valid = 0;
static GtkWidget *preview = NULL; /* Preview drawing area widget */
static gint paper_left = 0;
static gint paper_top = 0;
static gint orient = 0;
static gint mouse_x; /* Last mouse X */
static gint mouse_y; /* Last mouse Y */
static gint old_top; /* Previous position */
static gint old_left; /* Previous position */
static gint buttons_pressed = 0;
static gint preview_active = 0;
static gint buttons_mask = 0;
static gint move_constraint = 0;
static gint mouse_button = -1; /* Button being dragged with */
static gint suppress_preview_reset = 0;
static gint printable_left; /* Left pixel column of page */
static gint printable_top; /* Top pixel row of page */
static gint printable_width; /* Width of page on screen */
static gint printable_height;/* Height of page on screen */
static gint print_width; /* Printed width of image */
static gint print_height; /* Printed height of image */
static gint left, right; /* Imageable area */
static gint top, bottom;
static gint paper_width, paper_height; /* Physical width */
static gint num_media_sizes = 0;
static stp_param_t *media_sizes;
static gint num_media_types = 0; /* Number of media types */
static stp_param_t *media_types; /* Media type strings */
static gint num_media_sources = 0; /* Number of media sources */
static stp_param_t *media_sources; /* Media source strings */
static gint num_ink_types = 0; /* Number of ink types */
static stp_param_t *ink_types; /* Ink type strings */
static gint num_resolutions = 0; /* Number of resolutions */
static stp_param_t *resolutions; /* Resolution strings */
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_ink_type_callback (GtkWidget *widget,
gpointer data);
static void gimp_resolution_callback (GtkWidget *widget,
gpointer data);
static void gimp_output_type_callback (GtkWidget *widget,
gpointer data);
static void gimp_unit_callback (GtkWidget *widget,
gpointer data);
static void gimp_orientation_callback (GtkWidget *widget,
gpointer data);
static void gimp_printandsave_callback (void);
static void gimp_about_callback (void);
static void gimp_print_callback (void);
static void gimp_save_callback (void);
static void gimp_setup_update (void);
static void gimp_setup_open_callback (void);
static void gimp_setup_ok_callback (void);
static void gimp_new_printer_open_callback (void);
static void gimp_new_printer_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,
gint row,
gint column,
GdkEventButton *event,
gpointer data);
static void gimp_file_ok_callback (void);
static void gimp_file_cancel_callback (void);
static void gimp_preview_update (void);
static gboolean gimp_preview_expose (void);
static gboolean gimp_preview_button_callback (GtkWidget *widget,
GdkEventButton *bevent,
gpointer data);
static gboolean gimp_preview_motion_callback (GtkWidget *widget,
GdkEventMotion *mevent,
gpointer data);
static void gimp_position_callback (GtkWidget *widget);
static void gimp_image_type_callback (GtkWidget *widget,
gpointer data);
static gdouble preview_ppi = 10;
stp_vars_t *pv;
void
set_adjustment_tooltip (GtkObject *adj,
const gchar *tip,
const gchar *private)
{
gimp_help_set_help_data (GTK_WIDGET (GIMP_SCALE_ENTRY_SCALE (adj)),
tip, private);
gimp_help_set_help_data (GTK_WIDGET (GIMP_SCALE_ENTRY_SPINBUTTON (adj)),
tip, private);
}
static const char *
Combo_get_name(GtkWidget *combo,
gint num_options,
stp_param_t *options)
{
const gchar *text;
gint i;
text = gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (combo)->entry));
if (!text)
return NULL;
if (num_options == 0)
return text;
for (i = 0; i < num_options; i ++)
if (strcasecmp (options[i].text, text) == 0)
return (options[i].name);
return NULL;
}
static stp_param_t *printer_list = 0;
static int printer_count = 0;
static void
reset_preview(void)
{
if (!suppress_preview_reset)
{
gimp_help_enable_tooltips();
buttons_pressed = preview_active = 0;
}
}
static void
set_entry_value (GtkWidget *entry,
gdouble value,
gboolean block)
{
gchar s[255];
g_snprintf (s, sizeof(s), "%.2f", value);
if (block)
{
g_signal_handlers_block_by_func (entry,
gimp_position_callback, NULL);
g_signal_handlers_block_by_func (entry,
gimp_media_size_callback, NULL);
}
gtk_entry_set_text (GTK_ENTRY (entry), s);
if (block)
{
g_signal_handlers_unblock_by_func (entry,
gimp_position_callback, NULL);
g_signal_handlers_unblock_by_func (entry,
gimp_media_size_callback, NULL);
}
}
static void
gimp_build_printer_combo (void)
{
gint i;
if (printer_list)
{
for (i = 0; i < printer_count; i++)
{
g_free((void *)printer_list[i].name);
g_free((void *)printer_list[i].text);
}
g_free(printer_list);
}
printer_list = g_new (stp_param_t, plist_count);
for (i = 0; i < plist_count; i++)
{
if (plist[i].active)
{
printer_list[i].name = g_strdup (plist[i].name);
printer_list[i].text = g_strdup (plist[i].name);
}
else
{
printer_list[i].name = g_malloc (strlen (plist[i].name) + 2);
printer_list[i].text = g_malloc (strlen (plist[i].name) + 2);
strcpy ((char *)printer_list[i].name + 1, plist[i].name);
((char *) printer_list[i].name)[0] = '*';
strcpy ((char *)printer_list[i].text + 1, plist[i].name);
((char *) printer_list[i].text)[0] = '*';
}
}
printer_count = plist_count;
gimp_plist_build_combo (printer_combo,
printer_count,
printer_list,
printer_list[plist_current].text,
NULL,
G_CALLBACK (gimp_plist_callback),
&plist_callback_id);
}
static void
create_top_level_structure(void)
{
gchar *plug_in_name;
/*
* Create the main dialog
*/
plug_in_name = g_strdup_printf (_("%s -- Print v%s"),
image_name, PLUG_IN_VERSION);
print_dialog =
gimp_dialog_new (plug_in_name, "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("About"), gimp_about_callback,
NULL, NULL, NULL, FALSE, FALSE,
_("Save\nSettings"), gimp_save_callback,
NULL, NULL, NULL, FALSE, FALSE,
_("Print and\nSave Settings"), gimp_printandsave_callback,
NULL, NULL, NULL, FALSE, FALSE,
GTK_STOCK_CANCEL, gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
GTK_STOCK_PRINT, gimp_print_callback,
NULL, NULL, NULL, FALSE, FALSE,
NULL);
g_free (plug_in_name);
g_signal_connect (print_dialog, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
/*
* Top-level containers
*/
main_vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (print_dialog)->vbox), main_vbox,
FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
main_hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, FALSE, FALSE, 0);
gtk_widget_show (main_hbox);
right_vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_end (GTK_BOX (main_hbox), right_vbox, TRUE, TRUE, 0);
gtk_widget_show (right_vbox);
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (right_vbox), notebook, FALSE, FALSE, 0);
gtk_widget_show (notebook);
}
static void
create_preview (void)
{
GtkWidget *frame;
GtkWidget *event_box;
frame = gtk_frame_new (_("Preview"));
gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
preview = gtk_drawing_area_new ();
gtk_widget_set_size_request (preview,
PREVIEW_SIZE_HORIZ + 1, PREVIEW_SIZE_VERT + 1);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), preview);
gtk_container_add (GTK_CONTAINER (frame), event_box);
gtk_widget_show (event_box);
g_signal_connect (preview, "expose_event",
G_CALLBACK (gimp_preview_expose), NULL);
g_signal_connect (preview, "button_press_event",
G_CALLBACK (gimp_preview_button_callback), NULL);
g_signal_connect (preview, "button_release_event",
G_CALLBACK (gimp_preview_button_callback), NULL);
g_signal_connect (preview, "motion_notify_event",
G_CALLBACK (gimp_preview_motion_callback), NULL);
gtk_widget_show (GTK_WIDGET (preview));
gimp_help_set_help_data
(event_box,
_("Position the image on the page.\n"
"Click and drag with the primary button to position the image.\n"
"Click and drag with the second button to move the image with finer precision; "
"each unit of motion moves the image one point (1/72\")\n"
"Click and drag with the third (middle) button to move the image in units of "
"the image size.\n"
"Holding down the shift key while clicking and dragging constrains the image to "
"only horizontal or vertical motion.\n"
"If you click another button while dragging the mouse, the image will return "
"to its original position."),
NULL);
gtk_widget_set_events (GTK_WIDGET (preview),
GDK_EXPOSURE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
}
static void
create_positioning_frame (void)
{
GtkWidget *frame;
GtkWidget *table;
GtkWidget *box;
GtkWidget *sep;
frame = gtk_frame_new (_("Position"));
gtk_box_pack_start (GTK_BOX (right_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (7, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 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);
/*
* Orientation option menu.
*/
orientation_menu =
gimp_option_menu_new (FALSE,
_("Auto"), gimp_orientation_callback,
(gpointer) ORIENT_AUTO, NULL, NULL, 0,
_("Portrait"), gimp_orientation_callback,
(gpointer) ORIENT_PORTRAIT, NULL, NULL, 0,
_("Landscape"), gimp_orientation_callback,
(gpointer) ORIENT_LANDSCAPE, NULL, NULL, 0,
_("Upside down"), gimp_orientation_callback,
(gpointer) ORIENT_UPSIDEDOWN, NULL, NULL, 0,
_("Seascape"), gimp_orientation_callback,
(gpointer) ORIENT_SEASCAPE, NULL, NULL, 0,
NULL);
gimp_help_set_help_data (orientation_menu,
_("Select the orientation: portrait, landscape, "
"upside down, or seascape (upside down "
"landscape)"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Orientation:"), 1.0, 0.5,
orientation_menu, 3, TRUE);
sep = gtk_hseparator_new ();
gtk_table_attach_defaults (GTK_TABLE (table), sep, 0, 4, 1, 2);
gtk_widget_show (sep);
/*
* Position entries
*/
left_entry = gtk_entry_new ();
gtk_widget_set_size_request (left_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("Left:"), 1.0, 0.5,
left_entry, 1, TRUE);
gimp_help_set_help_data (left_entry,
_("Distance from the left of the paper to the image"),
NULL);
g_signal_connect (left_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
top_entry = gtk_entry_new ();
gtk_widget_set_size_request (top_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 2, 2,
_("Top:"), 1.0,
0.5, top_entry, 1, TRUE);
gimp_help_set_help_data (top_entry,
_("Distance from the top of the paper to the image"),
NULL);
g_signal_connect (top_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
right_entry = gtk_entry_new ();
gtk_widget_set_size_request (right_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Right:"), 1.0, 0.5,
right_entry, 1, TRUE);
gimp_help_set_help_data (right_entry,
_("Distance from the left of the paper to "
"the right of the image"),
NULL);
g_signal_connect (right_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
right_border_entry = gtk_entry_new ();
gtk_widget_set_size_request (right_border_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
_("Right Border:"), 1.0, 0.5,
right_border_entry, 1, TRUE);
gimp_help_set_help_data (right_border_entry,
_("Distance from the right of the paper to "
"the image"),
NULL);
g_signal_connect (right_border_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
bottom_entry = gtk_entry_new ();
gtk_widget_set_size_request (bottom_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 2, 3,
_("Bottom:"), 1.0, 0.5,
bottom_entry, 1, TRUE);
gimp_help_set_help_data (bottom_entry,
_("Distance from the top of the paper to "
"the bottom of the image"),
NULL);
g_signal_connect (bottom_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
bottom_border_entry = gtk_entry_new ();
gtk_widget_set_size_request (bottom_border_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 2, 4,
_("Bottom Border:"), 1.0, 0.5,
bottom_border_entry, 1, TRUE);
gimp_help_set_help_data (bottom_border_entry,
_("Distance from the bottom of the paper to "
"the image"),
NULL);
g_signal_connect (bottom_border_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
sep = gtk_hseparator_new ();
gtk_table_attach_defaults (GTK_TABLE (table), sep, 0, 4, 5, 6);
gtk_widget_show (sep);
/*
* Center options
*/
box = gtk_hbox_new (TRUE, 4);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 6,
_("Center:"), 1.0, 0.5,
box, 3, FALSE);
recenter_vertical_button =
gtk_button_new_with_label (_("Vertically"));
gtk_box_pack_start (GTK_BOX (box), recenter_vertical_button, FALSE, TRUE, 0);
gtk_widget_show (recenter_vertical_button);
gimp_help_set_help_data (recenter_vertical_button,
_("Center the image vertically on the paper"),
NULL);
g_signal_connect (recenter_vertical_button, "clicked",
G_CALLBACK (gimp_position_callback),
NULL);
recenter_button = gtk_button_new_with_label (_("Both"));
gtk_box_pack_start (GTK_BOX (box), recenter_button, FALSE, TRUE, 0);
gtk_widget_show (recenter_button);
gimp_help_set_help_data (recenter_button,
_("Center the image on the paper"),
NULL);
g_signal_connect (recenter_button, "clicked",
G_CALLBACK (gimp_position_callback),
NULL);
recenter_horizontal_button =
gtk_button_new_with_label (_("Horizontally"));
gtk_box_pack_start (GTK_BOX (box), recenter_horizontal_button, FALSE, TRUE, 0);
gtk_widget_show (recenter_horizontal_button);
gimp_help_set_help_data (recenter_horizontal_button,
_("Center the image horizontally on the paper"),
NULL);
g_signal_connect (recenter_horizontal_button, "clicked",
G_CALLBACK (gimp_position_callback),
NULL);
}
static void
create_printer_dialog (void)
{
GtkWidget *table;
GtkWidget *box;
GtkWidget *label;
GtkWidget *event_box;
gint i;
setup_dialog = gimp_dialog_new (_("Setup Printer"), "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE, FALSE, TRUE, FALSE,
GTK_STOCK_CANCEL, gtk_widget_hide,
NULL, 1, NULL, FALSE, TRUE,
GTK_STOCK_OK, gimp_setup_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
NULL);
/*
* Top-level table for dialog.
*/
table = gtk_table_new (5, 2, FALSE);
gtk_container_set_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_table_set_row_spacing (GTK_TABLE (table), 0, 100);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (setup_dialog)->vbox), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
/*
* Printer driver option menu.
*/
label = gtk_label_new (_("Printer Model:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
event_box = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), event_box, 1, 3, 0, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (event_box);
gimp_help_set_help_data (event_box,
_("Select your printer model"),
NULL);
printer_crawler = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (printer_crawler),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (event_box), printer_crawler);
gtk_widget_show (printer_crawler);
printer_driver = gtk_clist_new (1);
gtk_widget_set_size_request (printer_driver, 200, -1);
gtk_clist_set_selection_mode (GTK_CLIST (printer_driver),
GTK_SELECTION_SINGLE);
gtk_container_add (GTK_CONTAINER (printer_crawler), printer_driver);
gtk_widget_show (printer_driver);
g_signal_connect (printer_driver, "select_row",
G_CALLBACK (gimp_print_driver_callback),
NULL);
for (i = 0; i < stp_known_printers (); i ++)
{
stp_printer_t the_printer = stp_get_printer_by_index (i);
if (strcmp (stp_printer_get_long_name (the_printer), "") != 0)
{
gchar *tmp =
g_strdup (gettext (stp_printer_get_long_name (the_printer)));
gtk_clist_insert (GTK_CLIST (printer_driver), i, &tmp);
gtk_clist_set_row_data (GTK_CLIST (printer_driver), i, (gpointer) i);
}
}
/*
* PPD file.
*/
ppd_label = gtk_label_new (_("PPD File:"));
gtk_misc_set_alignment (GTK_MISC (ppd_label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), ppd_label, 0, 1, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ppd_label);
box = gtk_hbox_new (FALSE, 8);
gtk_table_attach (GTK_TABLE (table), box, 1, 2, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (box);
ppd_file = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box), ppd_file, TRUE, TRUE, 0);
gtk_widget_show (ppd_file);
gimp_help_set_help_data (ppd_file,
_("Enter the correct PPD filename for your printer"),
NULL);
ppd_button = gtk_button_new_with_label (_("Browse"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (ppd_button)->child), 2, 0);
gtk_box_pack_start (GTK_BOX (box), ppd_button, FALSE, FALSE, 0);
gtk_widget_show (ppd_button);
gimp_help_set_help_data (ppd_button,
_("Choose the correct PPD filename for your printer"),
NULL);
g_signal_connect (ppd_button, "clicked",
G_CALLBACK (gimp_ppd_browse_callback),
NULL);
/*
* Print command.
*/
output_label = gtk_label_new (_("Command:"));
gtk_misc_set_alignment (GTK_MISC (output_label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), output_label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (output_label);
output_cmd = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), output_cmd, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (output_cmd);
gimp_help_set_help_data
(output_cmd,
_("Enter the correct command to print to your printer. "
"Note: Please do not remove the `-l' or `-oraw' from "
"the command string, or printing will probably fail!"),
NULL);
/*
* Output file selection dialog.
*/
file_browser = gtk_file_selection_new (_("Print To File?"));
g_signal_connect (GTK_FILE_SELECTION (file_browser)->ok_button, "clicked",
G_CALLBACK (gimp_file_ok_callback),
NULL);
g_signal_connect (GTK_FILE_SELECTION (file_browser)->cancel_button, "clicked",
G_CALLBACK (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));
g_signal_connect (GTK_FILE_SELECTION (ppd_browser)->ok_button, "clicked",
G_CALLBACK (gimp_ppd_ok_callback),
NULL);
g_signal_connect_swapped (GTK_FILE_SELECTION (ppd_browser)->cancel_button,
"clicked",
G_CALLBACK (gtk_widget_hide),
ppd_browser);
}
static void
create_new_printer_dialog (void)
{
GtkWidget *table;
new_printer_dialog =
gimp_dialog_new (_("Define New Printer"), "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE, FALSE, TRUE, FALSE,
GTK_STOCK_CANCEL, gtk_widget_hide,
NULL, 1, NULL, FALSE, TRUE,
GTK_STOCK_OK, gimp_new_printer_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
NULL);
table = gtk_table_new (1, 2, FALSE);
gtk_container_set_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 (new_printer_dialog)->vbox), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
new_printer_entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (new_printer_entry), 127);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Printer Name:"), 1.0,
0.5, new_printer_entry, 1, TRUE);
gimp_help_set_help_data (new_printer_entry,
_("Enter the name you wish to give this logical printer"),
NULL);
g_signal_connect (new_printer_entry, "activate",
G_CALLBACK (gimp_new_printer_ok_callback),
NULL);
}
static void
create_about_dialog (void)
{
GtkWidget *label;
about_dialog =
gimp_dialog_new (_("About Gimp-Print " PLUG_IN_VERSION), "print",
gimp_standard_help_func, "filters/print.html",
GTK_WIN_POS_MOUSE, FALSE, TRUE, FALSE,
GTK_STOCK_CLOSE, gtk_widget_hide,
NULL, 1, NULL, TRUE, TRUE,
NULL);
label = gtk_label_new
(_("Gimp-Print Version " PLUG_IN_VERSION "\n"
"\n"
"Copyright (C) 1997-2001 Michael Sweet, Robert Krawitz,\n"
"and the rest of the Gimp-Print Development Team.\n"
"\n"
"Please visit our web site at http://gimp-print.sourceforge.net.\n"
"\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 2 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 "
"USA\n"));
gtk_misc_set_padding (GTK_MISC (label), 12, 4);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (about_dialog)->vbox), label,
FALSE, FALSE, 0);
gtk_widget_show (label);
}
static void
create_printer_settings_frame (void)
{
GtkWidget *table;
GtkWidget *printer_hbox;
GtkWidget *media_size_hbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *event_box;
create_printer_dialog ();
create_about_dialog ();
create_new_printer_dialog ();
table = gtk_table_new (9, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
table,
gtk_label_new (_("Printer Settings")));
gtk_widget_show (table);
/*
* Printer option menu.
*/
printer_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), printer_combo);
gtk_widget_show (printer_combo);
gimp_help_set_help_data (event_box,
_("Select the name of the printer (not the type, "
"or model, of printer) that you wish to print to"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Printer Name:"), 1.0, 0.5,
event_box, 2, TRUE);
printer_model_label = gtk_label_new ("");
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Printer Model:"), 1.0, 0.5,
printer_model_label, 2, TRUE);
printer_hbox = gtk_hbox_new (TRUE, 4);
gtk_table_attach_defaults (GTK_TABLE (table), printer_hbox, 1, 2, 2, 3);
gtk_widget_show (printer_hbox);
/*
* Setup printer button
*/
button = gtk_button_new_with_label (_("Setup Printer..."));
gimp_help_set_help_data (button,
_("Choose the printer model, PPD file, and command "
"that is used to print to this printer"),
NULL);
gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
gtk_box_pack_start (GTK_BOX (printer_hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_setup_open_callback),
NULL);
/*
* New printer button
*/
button = gtk_button_new_with_label (_("New Printer..."));
gimp_help_set_help_data (button,
_("Define a new logical printer. This can be used to "
"name a collection of settings that you wish to "
"remember for future use."),
NULL);
gtk_box_pack_start (GTK_BOX (printer_hbox), button, FALSE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_new_printer_open_callback),
NULL);
/*
* Media size combo box.
*/
media_size_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), media_size_combo);
gtk_widget_show (media_size_combo);
gimp_help_set_help_data (event_box,
_("Size of paper that you wish to print to"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Media Size:"), 1.0, 0.5,
event_box, 1, TRUE);
/*
* Custom media size entries
*/
media_size_hbox = gtk_hbox_new (FALSE, 4);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
_("Dimensions:"), 1.0, 0.5,
media_size_hbox, 2, TRUE);
label = gtk_label_new (_("Width:"));
gtk_box_pack_start (GTK_BOX (media_size_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
custom_size_width = gtk_entry_new ();
gtk_widget_set_size_request (custom_size_width, 40, -1);
gtk_box_pack_start (GTK_BOX (media_size_hbox), custom_size_width,
FALSE, FALSE, 0);
gtk_widget_show (custom_size_width);
gimp_help_set_help_data (custom_size_width,
_("Width of the paper that you wish to print to"),
NULL);
g_signal_connect (custom_size_width, "activate",
G_CALLBACK (gimp_media_size_callback),
NULL);
label = gtk_label_new (_("Height:"));
gtk_box_pack_start (GTK_BOX (media_size_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
custom_size_height = gtk_entry_new ();
gtk_widget_set_size_request (custom_size_height, 50, -1);
gtk_box_pack_start (GTK_BOX (media_size_hbox), custom_size_height,
FALSE, FALSE, 0);
gtk_widget_show (custom_size_height);
gimp_help_set_help_data (custom_size_height,
_("Height of the paper that you wish to print to"),
NULL);
g_signal_connect (custom_size_height, "activate",
G_CALLBACK (gimp_media_size_callback),
NULL);
/*
* Media type combo box.
*/
media_type_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), media_type_combo);
gtk_widget_show (media_type_combo);
gimp_help_set_help_data (event_box,
_("Type of media you're printing to"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 5,
_("Media Type:"), 1.0, 0.5,
event_box, 2, TRUE);
/*
* Media source combo box.
*/
media_source_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), media_source_combo);
gtk_widget_show (media_source_combo);
gimp_help_set_help_data (event_box,
_("Source (input slot) of media you're printing to"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 6,
_("Media Source:"), 1.0, 0.5,
event_box, 2, TRUE);
/*
* Ink type combo box.
*/
ink_type_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), ink_type_combo);
gtk_widget_show (ink_type_combo);
gimp_help_set_help_data (event_box,
_("Type of ink in the printer"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 7,
_("Ink Type:"), 1.0, 0.5,
event_box, 2, TRUE);
/*
* Resolution combo box.
*/
resolution_combo = gtk_combo_new ();
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box), resolution_combo);
gtk_widget_show (resolution_combo);
gimp_help_set_help_data (event_box,
_("Resolution and quality of the print"),
NULL);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 8,
_("Resolution:"), 1.0, 0.5,
event_box, 2, TRUE);
}
static void
create_scaling_frame (void)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *box;
GtkWidget *label;
GtkWidget *event_box;
GtkWidget *sep;
GSList *group;
frame = gtk_frame_new (_("Size"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/*
* Create the scaling adjustment using percent. It doesn't really matter,
* since as soon as we call gimp_plist_callback at the end of initialization
* everything will be put right.
*/
scaling_adjustment =
gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Scaling:"), 100, 75,
stp_get_scaling (stp_default_settings ()),
stp_get_scaling (stp_minimum_settings ()),
stp_get_scaling (stp_maximum_settings ()),
1.0, 10.0, 1, TRUE, 0, 0, NULL, NULL);
set_adjustment_tooltip (scaling_adjustment,
_("Set the scale (size) of the image"),
NULL);
g_signal_connect (scaling_adjustment, "value_changed",
G_CALLBACK (gimp_scaling_update),
NULL);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
box = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0);
gtk_widget_show (box);
/*
* The scale by percent/ppi toggles
*/
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (box), table, FALSE, FALSE, 0);
gtk_widget_show (table);
event_box = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), event_box, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (event_box);
label = gtk_label_new ("Scale by:");
gtk_container_add (GTK_CONTAINER (event_box), label);
gtk_widget_show (label);
gimp_help_set_help_data (event_box,
_("Select whether scaling is measured as percent of "
"available page size or number of output dots per "
"inch"),
NULL);
scaling_percent = gtk_radio_button_new_with_label (NULL, _("Percent"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (scaling_percent));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0.5, 0.5,
scaling_percent, 1, TRUE);
gimp_help_set_help_data (scaling_percent,
_("Scale the print to the size of the page"),
NULL);
g_signal_connect (scaling_percent, "toggled",
G_CALLBACK (gimp_scaling_callback),
NULL);
scaling_ppi = gtk_radio_button_new_with_label (group, _("PPI"));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0.5, 0.5,
scaling_ppi, 1, TRUE);
gimp_help_set_help_data (scaling_ppi,
_("Scale the print to the number of dots per inch"),
NULL);
g_signal_connect (scaling_ppi, "toggled",
G_CALLBACK (gimp_scaling_callback),
NULL);
sep = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (box), sep, FALSE, FALSE, 8);
gtk_widget_show (sep);
/*
* The width/height enries
*/
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (box), table, FALSE, FALSE, 0);
gtk_widget_show (table);
width_entry = gtk_entry_new ();
gtk_widget_set_size_request (width_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Width:"), 1.0, 0.5,
width_entry, 1, TRUE);
gimp_help_set_help_data (width_entry,
_("Set the width of the print"),
NULL);
g_signal_connect (width_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
height_entry = gtk_entry_new ();
gtk_widget_set_size_request (height_entry, 60, -1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Height:"), 1.0, 0.5,
height_entry, 1, TRUE);
gimp_help_set_help_data (height_entry,
_("Set the height of the print"),
NULL);
g_signal_connect (height_entry, "activate",
G_CALLBACK (gimp_position_callback),
NULL);
/*
* The inch/cm toggles
*/
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (box), table, FALSE, FALSE, 0);
gtk_widget_show (table);
event_box = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), event_box, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (event_box);
label = gtk_label_new (_("Units:"));
gtk_container_add (GTK_CONTAINER (event_box), label);
gtk_widget_show (label);
gimp_help_set_help_data (event_box,
_("Select the base unit of measurement for printing"),
NULL);
unit_inch = gtk_radio_button_new_with_label (NULL, _("Inch"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (unit_inch));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0.5, 0.5,
unit_inch, 1, TRUE);
gimp_help_set_help_data (unit_inch,
_("Set the base unit of measurement to inches"),
NULL);
g_signal_connect (unit_inch, "toggled",
G_CALLBACK (gimp_unit_callback),
(gpointer) 0);
unit_cm = gtk_radio_button_new_with_label (group, _("cm"));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0.5, 0.5,
unit_cm, 1, TRUE);
gimp_help_set_help_data (unit_cm,
_("Set the base unit of measurement to centimetres"),
NULL);
g_signal_connect (unit_cm, "toggled",
G_CALLBACK (gimp_unit_callback),
(gpointer) 1);
/*
* The "image size" button
*/
scaling_image = gtk_button_new_with_label (_("Use Original\nImage Size"));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (scaling_image)->child), 8, 4);
gtk_box_pack_end (GTK_BOX (box), scaling_image, FALSE, TRUE, 0);
gtk_widget_show (scaling_image);
gimp_help_set_help_data (scaling_image,
_("Set the print size to the size of the image"),
NULL);
g_signal_connect (scaling_image, "clicked",
G_CALLBACK (gimp_scaling_callback),
NULL);
}
static void
create_image_settings_frame (void)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GtkWidget *event_box;
GtkWidget *sep;
GSList *group;
gimp_create_color_adjust_window ();
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox,
gtk_label_new (_("Image / Output Settings")));
gtk_widget_show (vbox);
table = gtk_table_new (3, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
event_box = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), event_box, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (event_box);
label = gtk_label_new (_("Image Type:"));
gtk_container_add (GTK_CONTAINER (event_box), label);
gtk_widget_show (label);
gimp_help_set_help_data (event_box,
_("Optimize the output for the type of image "
"being printed"),
NULL);
image_line_art = gtk_radio_button_new_with_label (NULL, _("Line Art"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (image_line_art));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0.5, 0.5,
image_line_art, 1, FALSE);
gimp_help_set_help_data (image_line_art,
_("Fastest and brightest color for text and "
"line art"),
NULL);
g_signal_connect (image_line_art, "toggled",
G_CALLBACK (gimp_image_type_callback),
(gpointer) IMAGE_LINE_ART);
image_solid_tone = gtk_radio_button_new_with_label (group, _("Solid Colors"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (image_solid_tone));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0.5, 0.5,
image_solid_tone, 1, FALSE);
gimp_help_set_help_data (image_solid_tone,
_("Best for images dominated by regions of "
"solid color"),
NULL);
g_signal_connect (image_solid_tone, "toggled",
G_CALLBACK (gimp_image_type_callback),
(gpointer) IMAGE_SOLID_TONE);
image_continuous_tone = gtk_radio_button_new_with_label (group,
_("Photograph"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (image_continuous_tone));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
NULL, 0.5, 0.5,
image_continuous_tone, 1, FALSE);
gtk_widget_show (image_continuous_tone);
gimp_help_set_help_data (image_continuous_tone,
_("Slowest, but most accurate and smoothest color "
"for continuous tone images and photographs"),
NULL);
g_signal_connect (image_continuous_tone, "toggled",
G_CALLBACK (gimp_image_type_callback),
(gpointer) IMAGE_CONTINUOUS);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
/*
* Output type toggles.
*/
table = gtk_table_new (4, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
event_box = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), event_box, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (event_box);
label = gtk_label_new (_("Output Type:"));
gtk_container_add (GTK_CONTAINER (event_box), label);
gtk_widget_show (label);
gimp_help_set_help_data (event_box,
_("Select the desired output type"),
NULL);
output_color = gtk_radio_button_new_with_label (NULL, _("Color"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_color));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0.5, 0.5,
output_color, 1, FALSE);
gimp_help_set_help_data (output_color, _("Color output"), NULL);
g_signal_connect (output_color, "toggled",
G_CALLBACK (gimp_output_type_callback),
(gpointer) OUTPUT_COLOR);
output_gray = gtk_radio_button_new_with_label (group, _("Grayscale"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_gray));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0.5, 0.5,
output_gray, 1, FALSE);
gimp_help_set_help_data (output_gray,
_("Print in shades of gray using black ink"),
NULL);
g_signal_connect (output_gray, "toggled",
G_CALLBACK (gimp_output_type_callback),
(gpointer) OUTPUT_GRAY);
output_monochrome = gtk_radio_button_new_with_label (group,
_("Black and White"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_monochrome));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
NULL, 0.5, 0.5,
output_monochrome, 1, FALSE);
gimp_help_set_help_data (output_monochrome,
_("Print in black and white (no color, and no shades "
"of gray)"),
NULL);
g_signal_connect (output_monochrome, "toggled",
G_CALLBACK (gimp_output_type_callback),
(gpointer) OUTPUT_MONOCHROME);
/*
* Color adjust button
*/
adjust_color_button = gtk_button_new_with_label (_("Adjust Output..."));
gtk_misc_set_padding (GTK_MISC (GTK_BIN (adjust_color_button)->child), 4, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
NULL, 0.5, 0.5,
adjust_color_button, 1, TRUE);
gimp_help_set_help_data (adjust_color_button,
_("Adjust color balance, brightness, contrast, "
"saturation, and dither algorithm"),
NULL);
g_signal_connect_swapped (adjust_color_button, "clicked",
G_CALLBACK (gtk_widget_show),
gimp_color_adjust_dialog);
}
/*
* gimp_create_main_window()
*/
void
gimp_create_main_window (void)
{
pv = &(plist[plist_current].v);
/*
* Create the various dialog components. Note that we're not
* actually initializing the values at this point; that will be done after
* the UI is fully created.
*/
create_top_level_structure ();
create_preview ();
create_printer_settings_frame ();
create_positioning_frame ();
create_scaling_frame ();
create_image_settings_frame ();
/*
* Now actually set up the correct values in the dialog
*/
gimp_build_printer_combo ();
gimp_plist_callback (NULL, (gpointer) plist_current);
gimp_update_adjusted_thumbnail ();
gtk_widget_show (print_dialog);
}
/*
* gimp_scaling_update() - Update the scaling scale using the slider.
*/
static void
gimp_scaling_update (GtkAdjustment *adjustment)
{
gimp_invalidate_preview_thumbnail ();
reset_preview ();
if (stp_get_scaling(*pv) != adjustment->value)
{
if (GTK_TOGGLE_BUTTON (scaling_ppi)->active)
stp_set_scaling (*pv, -adjustment->value);
else
stp_set_scaling (*pv, adjustment->value);
}
suppress_scaling_adjustment = TRUE;
gimp_preview_update ();
suppress_scaling_adjustment = FALSE;
}
/*
* gimp_scaling_callback() - Update the scaling scale using radio buttons.
*/
static void
gimp_scaling_callback (GtkWidget *widget)
{
const stp_vars_t lower = stp_minimum_settings ();
gdouble max_ppi_scaling;
gdouble min_ppi_scaling, min_ppi_scaling1, min_ppi_scaling2;
gdouble current_scale;
reset_preview ();
if (suppress_scaling_callback)
return;
min_ppi_scaling1 = 72.0 * (gdouble) image_width /
(gdouble) printable_width;
min_ppi_scaling2 = 72.0 * (gdouble) image_height /
(gdouble) printable_height;
if (min_ppi_scaling1 > min_ppi_scaling2)
min_ppi_scaling = min_ppi_scaling1;
else
min_ppi_scaling = min_ppi_scaling2;
max_ppi_scaling = min_ppi_scaling * 100 / stp_get_scaling (lower);
if (widget == scaling_ppi)
{
if (! GTK_TOGGLE_BUTTON (scaling_ppi)->active)
return;
GTK_ADJUSTMENT (scaling_adjustment)->lower = min_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->upper = max_ppi_scaling;
/*
* Compute the correct PPI to create an image of the same size
* as the one measured in percent
*/
current_scale = GTK_ADJUSTMENT (scaling_adjustment)->value;
GTK_ADJUSTMENT (scaling_adjustment)->value =
min_ppi_scaling / (current_scale / 100);
stp_set_scaling (*pv, 0.0);
}
else if (widget == scaling_percent)
{
gdouble new_percent;
if (! GTK_TOGGLE_BUTTON (scaling_percent)->active)
return;
current_scale = GTK_ADJUSTMENT (scaling_adjustment)->value;
GTK_ADJUSTMENT (scaling_adjustment)->lower = stp_get_scaling (lower);
GTK_ADJUSTMENT (scaling_adjustment)->upper = 100.0;
new_percent = 100 * min_ppi_scaling / current_scale;
if (new_percent > 100)
new_percent = 100;
if (new_percent < stp_get_scaling(lower))
new_percent = stp_get_scaling(lower);
GTK_ADJUSTMENT (scaling_adjustment)->value = new_percent;
stp_set_scaling (*pv, 0.0);
}
else if (widget == scaling_image)
{
gdouble xres, yres;
gimp_invalidate_preview_thumbnail ();
gimp_image_get_resolution (image_ID, &xres, &yres);
GTK_ADJUSTMENT (scaling_adjustment)->lower = min_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->upper = max_ppi_scaling;
if (yres < min_ppi_scaling)
yres = min_ppi_scaling;
if (yres > max_ppi_scaling)
yres = max_ppi_scaling;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi), TRUE);
GTK_ADJUSTMENT (scaling_adjustment)->value = yres;
stp_set_scaling (*pv, 0.0);
}
gtk_adjustment_changed (GTK_ADJUSTMENT (scaling_adjustment));
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
/****************************************************************************
*
* gimp_plist_build_combo
*
****************************************************************************/
void
gimp_plist_build_combo (GtkWidget *combo, /* I - Combo widget */
gint num_items, /* I - Number of items */
stp_param_t *items, /* I - Menu items */
const gchar *cur_item, /* I - Current item */
const gchar *def_value, /* I - default item */
GCallback callback, /* I - Callback */
gint *callback_id) /* IO - Callback ID (init to -1) */
{
gint i; /* Looping var */
GList *list = NULL;
GtkEntry *entry = GTK_ENTRY (GTK_COMBO (combo)->entry);
if (*callback_id != -1)
g_signal_handler_disconnect (entry, *callback_id);
gtk_entry_set_editable (entry, FALSE);
if (num_items == 0)
{
list = g_list_append (list, _("Standard"));
gtk_combo_set_popdown_strings (GTK_COMBO (combo), list);
*callback_id = -1;
gtk_widget_set_sensitive (combo, FALSE);
gtk_widget_show (combo);
return;
}
for (i = 0; i < num_items; i ++)
list = g_list_prepend (list, g_strdup (items[i].text));
list = g_list_reverse (list);
gtk_combo_set_popdown_strings (GTK_COMBO (combo), list);
*callback_id = g_signal_connect (entry, "changed",
callback,
NULL);
for (i = 0; i < num_items; i ++)
if (strcmp(items[i].name, cur_item) == 0)
break;
if (i >= num_items)
{
if (def_value)
for (i = 0; i < num_items; i ++)
if (strcmp (items[i].name, def_value) == 0)
break;
if (i >= num_items)
i = 0;
}
gtk_entry_set_text (entry, g_strdup (items[i].text));
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_widget_set_sensitive (combo, TRUE);
gtk_widget_show (combo);
}
/*
* gimp_do_misc_updates() - Build an option menu for the given parameters.
*/
static void
gimp_do_misc_updates (void)
{
const stp_vars_t lower = stp_minimum_settings ();
suppress_preview_update++;
gimp_invalidate_preview_thumbnail ();
gimp_preview_update ();
if (stp_get_scaling (*pv) < 0)
{
gdouble tmp = -stp_get_scaling (*pv);
gdouble max_ppi_scaling;
gdouble min_ppi_scaling, min_ppi_scaling1, min_ppi_scaling2;
min_ppi_scaling1 = 72.0 * (gdouble) image_width /
(gdouble) printable_width;
min_ppi_scaling2 = 72.0 * (gdouble) image_height /
(gdouble) printable_height;
if (min_ppi_scaling1 > min_ppi_scaling2)
min_ppi_scaling = min_ppi_scaling1;
else
min_ppi_scaling = min_ppi_scaling2;
max_ppi_scaling = min_ppi_scaling * 100 / stp_get_scaling(lower);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi), TRUE);
GTK_ADJUSTMENT (scaling_adjustment)->lower = min_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->upper = max_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->value = tmp;
gtk_adjustment_changed (GTK_ADJUSTMENT (scaling_adjustment));
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
else
{
gdouble tmp = stp_get_scaling (*pv);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_percent), TRUE);
GTK_ADJUSTMENT (scaling_adjustment)->lower = stp_get_scaling (lower);
GTK_ADJUSTMENT (scaling_adjustment)->upper = 100.0;
GTK_ADJUSTMENT (scaling_adjustment)->value = tmp;
gtk_adjustment_changed (GTK_ADJUSTMENT (scaling_adjustment));
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
switch (stp_get_output_type (*pv))
{
case OUTPUT_GRAY:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_gray), TRUE);
break;
case OUTPUT_COLOR:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_color), TRUE);
break;
case OUTPUT_MONOCHROME:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_monochrome), TRUE);
break;
}
gimp_do_color_updates ();
gtk_option_menu_set_history (GTK_OPTION_MENU (orientation_menu),
stp_get_orientation (*pv) + 1);
if (stp_get_unit(*pv) == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (unit_inch), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (unit_cm), TRUE);
switch (stp_get_image_type (*pv))
{
case IMAGE_LINE_ART:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_line_art), TRUE);
break;
case IMAGE_SOLID_TONE:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_solid_tone), TRUE);
break;
case IMAGE_CONTINUOUS:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_continuous_tone),
TRUE);
break;
default:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_continuous_tone),
TRUE);
stp_set_image_type (*pv, IMAGE_CONTINUOUS);
break;
}
suppress_preview_update--;
gimp_preview_update ();
}
/*
* gimp_position_callback() - callback for position entry widgets
*/
static void
gimp_position_callback (GtkWidget *widget)
{
reset_preview ();
suppress_preview_update++;
if (widget == recenter_button)
{
stp_set_left (*pv, -1);
stp_set_top (*pv, -1);
}
else if (widget == recenter_horizontal_button)
{
stp_set_left (*pv, -1);
}
else if (widget == recenter_vertical_button)
{
stp_set_top (*pv, -1);
}
else
{
gdouble new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
gdouble unit_scaler = 1.0;
gboolean was_percent = 0;
if (stp_get_unit(*pv))
unit_scaler /= 2.54;
new_value *= unit_scaler;
if (widget == top_entry)
stp_set_top (*pv, ((new_value + (1.0 / 144.0)) * 72) - top);
else if (widget == bottom_entry)
stp_set_top (*pv,
((new_value + (1.0 / 144.0)) * 72) - (top + print_height));
else if (widget == bottom_border_entry)
stp_set_top (*pv, paper_height - print_height - top - (new_value * 72));
else if (widget == left_entry)
stp_set_left (*pv, ((new_value + (1.0 / 144.0)) * 72) - left);
else if (widget == right_entry)
stp_set_left (*pv,
((new_value + (1.0 / 144.0)) * 72) - (left +print_width));
else if (widget == right_border_entry)
stp_set_left (*pv, paper_width - print_width - left - (new_value * 72));
else if (widget == width_entry)
{
if (stp_get_scaling(*pv) >= 0)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi),
TRUE);
gimp_scaling_callback (scaling_ppi);
was_percent = 1;
}
GTK_ADJUSTMENT (scaling_adjustment)->value =
((gdouble) image_width) / new_value;
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
if (was_percent)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_percent),
TRUE);
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
}
else if (widget == height_entry)
{
if (stp_get_scaling(*pv) >= 0)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi),
TRUE);
gimp_scaling_callback (scaling_ppi);
was_percent = 1;
}
GTK_ADJUSTMENT (scaling_adjustment)->value =
((gdouble) image_height) / new_value;
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
if (was_percent)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_percent),
TRUE);
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
}
}
if (stp_get_left (*pv) < 0)
stp_set_left (*pv, 0);
if (stp_get_top (*pv) < 0)
stp_set_top (*pv, 0);
}
suppress_preview_update--;
gimp_preview_update ();
}
/*
* gimp_plist_callback() - Update the current system printer.
*/
static void
gimp_plist_callback (GtkWidget *widget,
gpointer data)
{
gint i;
const gchar *default_parameter;
gimp_invalidate_preview_thumbnail ();
reset_preview ();
if (widget)
{
const gchar *text;
text = gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (printer_combo)->entry));
for (i = 0; i < plist_count; i++)
{
if (! strcmp (text, printer_list[i].text))
{
plist_current = i;
break;
}
}
}
else
{
plist_current = (gint) data;
}
pv = &(plist[plist_current].v);
if (strcmp(stp_get_driver(*pv), ""))
current_printer = stp_get_printer_by_driver (stp_get_driver (*pv));
suppress_preview_update++;
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (dither_algo_combo)->entry),
stp_get_dither_algorithm (*pv));
gimp_setup_update ();
gimp_do_misc_updates ();
/*
* Now get option parameters.
*/
if (num_media_sizes > 0)
{
for (i = 0; i < num_media_sizes; i ++)
{
g_free ((void *) media_sizes[i].name);
g_free ((void *) media_sizes[i].text);
}
g_free (media_sizes);
num_media_sizes = 0;
}
media_sizes = (*(stp_printer_get_printfuncs(current_printer)->parameters))
(current_printer, stp_get_ppd_file (*pv), "PageSize", &num_media_sizes);
default_parameter =
((stp_printer_get_printfuncs(current_printer)->default_parameters)
(current_printer, stp_get_ppd_file (*pv), "PageSize"));
if (stp_get_media_size (*pv)[0] == '\0')
stp_set_media_size (*pv, default_parameter);
gimp_plist_build_combo (media_size_combo,
num_media_sizes,
media_sizes,
stp_get_media_size (*pv),
default_parameter,
G_CALLBACK (gimp_media_size_callback),
&media_size_callback_id);
if (num_media_types > 0)
{
for (i = 0; i < num_media_types; i ++)
{
g_free ((void *) media_types[i].name);
g_free ((void *) media_types[i].text);
}
g_free (media_types);
num_media_types = 0;
}
media_types = (*(stp_printer_get_printfuncs (current_printer)->parameters))
(current_printer, stp_get_ppd_file (*pv), "MediaType", &num_media_types);
default_parameter =
((stp_printer_get_printfuncs (current_printer)->default_parameters)
(current_printer, stp_get_ppd_file (*pv), "MediaType"));
if (stp_get_media_type (*pv)[0] == '\0' && media_types != NULL)
stp_set_media_type (*pv, default_parameter);
else if (media_types == NULL)
stp_set_media_type (*pv, NULL);
gimp_plist_build_combo (media_type_combo,
num_media_types,
media_types,
stp_get_media_type (*pv),
default_parameter,
G_CALLBACK (gimp_media_type_callback),
&media_type_callback_id);
if (num_media_sources > 0)
{
for (i = 0; i < num_media_sources; i ++)
{
g_free ((void *) media_sources[i].name);
g_free ((void *) media_sources[i].text);
}
g_free (media_sources);
num_media_sources = 0;
}
media_sources = (*(stp_printer_get_printfuncs (current_printer)->parameters))
(current_printer, stp_get_ppd_file (*pv), "InputSlot", &num_media_sources);
default_parameter =
((stp_printer_get_printfuncs (current_printer)->default_parameters)
(current_printer, stp_get_ppd_file (*pv), "InputSlot"));
if (stp_get_media_source (*pv)[0] == '\0' && media_sources != NULL)
stp_set_media_source (*pv, default_parameter);
else if (media_sources == NULL)
stp_set_media_source (*pv, NULL);
gimp_plist_build_combo (media_source_combo,
num_media_sources,
media_sources,
stp_get_media_source (*pv),
default_parameter,
G_CALLBACK (gimp_media_source_callback),
&media_source_callback_id);
if (num_ink_types > 0)
{
for (i = 0; i < num_ink_types; i ++)
{
g_free ((void *) ink_types[i].name);
g_free ((void *) ink_types[i].text);
}
g_free (ink_types);
num_ink_types = 0;
}
ink_types = (*(stp_printer_get_printfuncs (current_printer)->parameters))
(current_printer, stp_get_ppd_file (*pv), "InkType", &num_ink_types);
default_parameter =
((stp_printer_get_printfuncs (current_printer)->default_parameters)
(current_printer, stp_get_ppd_file (*pv), "InkType"));
if (stp_get_ink_type (*pv)[0] == '\0' && ink_types != NULL)
stp_set_ink_type (*pv, default_parameter);
else if (ink_types == NULL)
stp_set_ink_type (*pv, NULL);
gimp_plist_build_combo (ink_type_combo,
num_ink_types,
ink_types,
stp_get_ink_type (*pv),
default_parameter,
G_CALLBACK (gimp_ink_type_callback),
&ink_type_callback_id);
if (num_resolutions > 0)
{
for (i = 0; i < num_resolutions; i ++)
{
g_free ((void *)resolutions[i].name);
g_free ((void *)resolutions[i].text);
}
g_free (resolutions);
num_resolutions = 0;
}
resolutions = (*(stp_printer_get_printfuncs (current_printer)->parameters))
(current_printer, stp_get_ppd_file (*pv), "Resolution", &num_resolutions);
default_parameter =
((stp_printer_get_printfuncs (current_printer)->default_parameters)
(current_printer, stp_get_ppd_file (*pv), "Resolution"));
if (stp_get_resolution (*pv)[0] == '\0' && resolutions != NULL)
stp_set_resolution (*pv, default_parameter);
else if (resolutions == NULL)
stp_set_resolution (*pv, NULL);
gimp_plist_build_combo (resolution_combo,
num_resolutions,
resolutions,
stp_get_resolution (*pv),
default_parameter,
G_CALLBACK (gimp_resolution_callback),
&resolution_callback_id);
if (dither_algo_combo)
gimp_build_dither_combo ();
suppress_preview_update--;
gimp_preview_update ();
}
/*
* gimp_media_size_callback() - Update the current media size.
*/
static void
gimp_media_size_callback (GtkWidget *widget,
gpointer data)
{
gimp_invalidate_preview_thumbnail ();
reset_preview ();
if (widget == custom_size_width)
{
gint width_limit, height_limit;
gint min_width_limit, min_height_limit;
gdouble new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
gdouble unit_scaler = 1.0;
new_value *= 72;
if (stp_get_unit (*pv))
unit_scaler /= 2.54;
new_value *= unit_scaler;
(stp_printer_get_printfuncs (current_printer)->limit)
(current_printer, *pv, &width_limit, &height_limit,
&min_width_limit, &min_height_limit);
if (new_value < min_width_limit)
new_value = min_width_limit;
else if (new_value > width_limit)
new_value = width_limit;
stp_set_page_width (*pv, new_value);
stp_set_left(*pv, -1);
new_value = new_value / 72.0;
if (stp_get_unit (*pv))
new_value *= 2.54;
set_entry_value (custom_size_width, new_value, FALSE);
gimp_preview_update ();
}
else if (widget == custom_size_height)
{
gint width_limit, height_limit;
gint min_width_limit, min_height_limit;
gdouble new_value = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
gdouble unit_scaler = 1.0;
new_value *= 72;
if (stp_get_unit(*pv))
unit_scaler /= 2.54;
new_value *= unit_scaler;
(stp_printer_get_printfuncs (current_printer)->limit)
(current_printer, *pv, &width_limit, &height_limit,
&min_width_limit, &min_height_limit);
if (new_value < min_height_limit)
new_value = min_height_limit;
else if (new_value > height_limit)
new_value = height_limit;
stp_set_page_height (*pv, new_value);
stp_set_top(*pv, -1);
new_value = new_value / 72.0;
if (stp_get_unit (*pv))
new_value *= 2.54;
set_entry_value (custom_size_height, new_value, FALSE);
gimp_preview_update ();
}
else
{
const gchar *new_media_size;
stp_papersize_t pap;
new_media_size = Combo_get_name (media_size_combo,
num_media_sizes,
media_sizes);
if (!new_media_size)
return;
pap = stp_get_papersize_by_name (new_media_size);
if (pap)
{
gint default_width, default_height;
gdouble size;
if (stp_papersize_get_width (pap) == 0)
{
(stp_printer_get_printfuncs (current_printer)->media_size)
(current_printer, *pv, &default_width, &default_height);
size = default_width / 72.0;
if (stp_get_unit (*pv))
size *= 2.54;
set_entry_value (custom_size_width, size, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (custom_size_width), TRUE);
gtk_entry_set_editable (GTK_ENTRY (custom_size_width), TRUE);
stp_set_page_width (*pv, default_width);
}
else
{
size = stp_papersize_get_width (pap) / 72.0;
if (stp_get_unit (*pv))
size *= 2.54;
set_entry_value (custom_size_width, size, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (custom_size_width), FALSE);
gtk_entry_set_editable (GTK_ENTRY (custom_size_width), FALSE);
stp_set_page_width (*pv, stp_papersize_get_width (pap));
}
if (stp_papersize_get_height (pap) == 0)
{
(stp_printer_get_printfuncs (current_printer)->media_size)
(current_printer, *pv, &default_width, &default_height);
size = default_height / 72.0;
if (stp_get_unit (*pv))
size *= 2.54;
set_entry_value (custom_size_height, size, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (custom_size_height), TRUE);
gtk_entry_set_editable (GTK_ENTRY (custom_size_height), TRUE);
stp_set_page_height (*pv, default_height);
}
else
{
size = stp_papersize_get_height (pap) / 72.0;
if (stp_get_unit (*pv))
size *= 2.54;
set_entry_value (custom_size_height, size, FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (custom_size_height), FALSE);
gtk_entry_set_editable (GTK_ENTRY (custom_size_height), FALSE);
stp_set_page_height (*pv, stp_papersize_get_height (pap));
}
}
if (strcmp (stp_get_media_size (*pv), new_media_size) != 0)
{
stp_set_media_size (*pv, new_media_size);
stp_set_left (*pv, -1);
stp_set_top (*pv, -1);
gimp_preview_update ();
}
}
}
/*
* gimp_media_type_callback() - Update the current media type.
*/
static void
gimp_media_type_callback (GtkWidget *widget,
gpointer data)
{
const gchar *new_media_type =
Combo_get_name (media_type_combo, num_media_types, media_types);
gimp_invalidate_preview_thumbnail ();
reset_preview ();
stp_set_media_type (*pv, new_media_type);
gimp_preview_update ();
}
/*
* gimp_media_source_callback() - Update the current media source.
*/
static void
gimp_media_source_callback (GtkWidget *widget,
gpointer data)
{
const gchar *new_media_source =
Combo_get_name (media_source_combo, num_media_sources, media_sources);
gimp_invalidate_preview_thumbnail ();
reset_preview ();
stp_set_media_source (*pv, new_media_source);
gimp_preview_update ();
}
/*
* gimp_ink_type_callback() - Update the current ink type.
*/
static void
gimp_ink_type_callback (GtkWidget *widget,
gpointer data)
{
const gchar *new_ink_type =
Combo_get_name (ink_type_combo, num_ink_types, ink_types);
gimp_invalidate_preview_thumbnail ();
reset_preview ();
stp_set_ink_type (*pv, new_ink_type);
gimp_preview_update ();
}
/*
* gimp_resolution_callback() - Update the current resolution.
*/
static void
gimp_resolution_callback (GtkWidget *widget,
gpointer data)
{
const gchar *new_resolution =
Combo_get_name (resolution_combo, num_resolutions, resolutions);
gimp_invalidate_preview_thumbnail();
reset_preview();
stp_set_resolution(*pv, new_resolution);
gimp_preview_update ();
}
/*
* gimp_orientation_callback() - Update the current media size.
*/
static void
gimp_orientation_callback (GtkWidget *widget,
gpointer data)
{
reset_preview ();
if (stp_get_orientation (*pv) != (gint) data)
{
gimp_invalidate_preview_thumbnail ();
stp_set_orientation (*pv, (gint) data);
stp_set_left (*pv, -1);
stp_set_top (*pv, -1);
}
gimp_preview_update ();
}
/*
* gimp_output_type_callback() - Update the current output type.
*/
static void
gimp_output_type_callback (GtkWidget *widget,
gpointer data)
{
reset_preview ();
if (GTK_TOGGLE_BUTTON (widget)->active)
{
stp_set_output_type (*pv, (gint) data);
gimp_invalidate_preview_thumbnail ();
gimp_update_adjusted_thumbnail ();
}
if (widget == output_color)
gimp_set_color_sliders_active (TRUE);
else
gimp_set_color_sliders_active (FALSE);
gimp_preview_update ();
}
/*
* gimp_unit_callback() - Update the current unit.
*/
static void
gimp_unit_callback (GtkWidget *widget,
gpointer data)
{
reset_preview ();
if (GTK_TOGGLE_BUTTON (widget)->active)
{
stp_set_unit (*pv, (gint) data);
gimp_preview_update ();
}
}
/*
* gimp_image_type_callback() - Update the current image type mode.
*/
static void
gimp_image_type_callback (GtkWidget *widget,
gpointer data)
{
reset_preview ();
if (GTK_TOGGLE_BUTTON (widget)->active)
{
stp_set_image_type (*pv, (gint) data);
gimp_invalidate_preview_thumbnail ();
gimp_update_adjusted_thumbnail ();
}
gimp_preview_update ();
}
static void
gimp_destroy_dialogs (void)
{
gtk_widget_destroy (gimp_color_adjust_dialog);
gtk_widget_destroy (setup_dialog);
gtk_widget_destroy (print_dialog);
gtk_widget_destroy (new_printer_dialog);
gtk_widget_destroy (about_dialog);
}
static void
gimp_dialogs_set_sensitive (gboolean sensitive)
{
gtk_widget_set_sensitive (gimp_color_adjust_dialog, sensitive);
gtk_widget_set_sensitive (setup_dialog, sensitive);
gtk_widget_set_sensitive (print_dialog, sensitive);
gtk_widget_set_sensitive (new_printer_dialog, sensitive);
gtk_widget_set_sensitive (about_dialog, sensitive);
}
/*
* 'print_callback()' - Start the print.
*/
static void
gimp_print_callback (void)
{
if (plist_current > 0)
{
runme = TRUE;
gimp_destroy_dialogs ();
}
else
{
gimp_dialogs_set_sensitive (FALSE);
gtk_widget_show (file_browser);
}
}
/*
* gimp_printandsave_callback() -
*/
static void
gimp_printandsave_callback (void)
{
saveme = TRUE;
gimp_print_callback();
}
static void
gimp_about_callback (void)
{
gtk_widget_show (about_dialog);
}
/*
* gimp_save_callback() - save settings, don't destroy dialog
*/
static void
gimp_save_callback (void)
{
reset_preview ();
printrc_save ();
}
/*
* gimp_setup_update() - update widgets in the setup dialog
*/
static void
gimp_setup_update (void)
{
gint idx;
current_printer = stp_get_printer_by_driver (stp_get_driver (*pv));
idx = stp_get_printer_index_by_driver (stp_get_driver (*pv));
gtk_clist_select_row (GTK_CLIST (printer_driver), idx, 0);
gtk_entry_set_text (GTK_ENTRY (ppd_file), stp_get_ppd_file (*pv));
if (strncmp (stp_get_driver (*pv),"ps", 2) == 0)
{
gtk_widget_show (ppd_label);
gtk_widget_show (ppd_file);
gtk_widget_show (ppd_button);
}
else
{
gtk_widget_hide (ppd_label);
gtk_widget_hide (ppd_file);
gtk_widget_hide (ppd_button);
}
gtk_entry_set_text (GTK_ENTRY (output_cmd), stp_get_output_to (*pv));
if (plist_current == 0)
{
gtk_widget_hide (output_label);
gtk_widget_hide (output_cmd);
}
else
{
gtk_widget_show (output_label);
gtk_widget_show (output_cmd);
}
gtk_clist_moveto (GTK_CLIST (printer_driver), idx, -1, 0.5, 0.5);
}
/*
* gimp_setup_open_callback() -
*/
static void
gimp_setup_open_callback (void)
{
static gboolean first_time = TRUE;
reset_preview ();
gimp_setup_update ();
gtk_widget_show (setup_dialog);
if (first_time)
{
/* Make sure the driver scroller gets positioned correctly. */
gimp_setup_update ();
first_time = FALSE;
}
}
/*
* gimp_new_printer_open_callback() -
*/
static void
gimp_new_printer_open_callback (void)
{
reset_preview ();
gtk_entry_set_text (GTK_ENTRY (new_printer_entry), "");
gtk_widget_show (new_printer_dialog);
}
/*
* gimp_setup_ok_callback() -
*/
static void
gimp_setup_ok_callback (void)
{
reset_preview ();
gimp_invalidate_preview_thumbnail ();
stp_set_driver (*pv, stp_printer_get_driver (current_printer));
stp_set_output_to (*pv, gtk_entry_get_text (GTK_ENTRY (output_cmd)));
stp_set_ppd_file (*pv, gtk_entry_get_text (GTK_ENTRY (ppd_file)));
gimp_plist_callback (NULL, (gpointer) plist_current);
gtk_widget_hide (setup_dialog);
}
/*
* gimp_setup_ok_callback() -
*/
static void
gimp_new_printer_ok_callback (void)
{
const gchar *data = gtk_entry_get_text (GTK_ENTRY (new_printer_entry));
gp_plist_t key;
gimp_invalidate_preview_thumbnail ();
reset_preview ();
initialize_printer (&key);
(void) strncpy (key.name, data, sizeof(key.name) - 1);
if (strlen (key.name))
{
key.active = 0;
key.v = stp_allocate_copy (*pv);
if (add_printer (&key, 1))
{
plist_current = plist_count - 1;
gimp_build_printer_combo ();
stp_set_driver (*pv, stp_printer_get_driver (current_printer));
stp_set_output_to (*pv, gtk_entry_get_text (GTK_ENTRY (output_cmd)));
stp_set_ppd_file (*pv, gtk_entry_get_text (GTK_ENTRY (ppd_file)));
gimp_plist_callback (NULL, (gpointer) plist_current);
}
}
gtk_widget_hide (new_printer_dialog);
}
/*
* gimp_print_driver_callback() - Update the current printer driver.
*/
static void
gimp_print_driver_callback (GtkWidget *widget, /* I - Driver list */
gint row,
gint column,
GdkEventButton *event,
gpointer data) /* I - Data */
{
stp_vars_t printvars;
gimp_invalidate_preview_thumbnail ();
reset_preview ();
data = gtk_clist_get_row_data (GTK_CLIST (widget), row);
current_printer = stp_get_printer_by_index ((gint) data);
gtk_label_set_text (GTK_LABEL (printer_model_label),
gettext (stp_printer_get_long_name (current_printer)));
if (strncmp (stp_printer_get_driver (current_printer), "ps", 2) == 0)
{
gtk_widget_show (ppd_label);
gtk_widget_show (ppd_file);
gtk_widget_show (ppd_button);
}
else
{
gtk_widget_hide (ppd_label);
gtk_widget_hide (ppd_file);
gtk_widget_hide (ppd_button);
}
printvars = stp_printer_get_printvars (current_printer);
if (stp_get_output_type (printvars) == OUTPUT_COLOR)
{
gtk_widget_set_sensitive (output_color, TRUE);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (output_gray), TRUE);
gtk_widget_set_sensitive (output_color, FALSE);
}
}
/*
* gimp_ppd_browse_callback() -
*/
static void
gimp_ppd_browse_callback (void)
{
reset_preview ();
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)
{
reset_preview ();
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);
stp_set_output_to (*pv,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_browser)));
runme = TRUE;
gimp_destroy_dialogs ();
}
/*
* gimp_file_cancel_callback() -
*/
static void
gimp_file_cancel_callback (void)
{
gtk_widget_hide (file_browser);
gimp_dialogs_set_sensitive (TRUE);
}
/*
* gimp_update_adjusted_thumbnail()
*/
void
gimp_update_adjusted_thumbnail (void)
{
gint x, y;
stp_convert_t colorfunc;
gushort out[3 * THUMBNAIL_MAXW];
guchar *adjusted_data = adjusted_thumbnail_data;
gfloat old_density = stp_get_density(*pv);
if (thumbnail_data == 0 || adjusted_thumbnail_data == 0)
return;
stp_set_density (*pv, 1.0);
stp_compute_lut (*pv, 256);
colorfunc = stp_choose_colorfunc (stp_get_output_type(*pv), thumbnail_bpp,
NULL, &adjusted_thumbnail_bpp, *pv);
for (y = 0; y < thumbnail_h; y++)
{
(*colorfunc) (*pv, thumbnail_data + thumbnail_bpp * thumbnail_w * y,
out, NULL, thumbnail_w, thumbnail_bpp, NULL, NULL, NULL,
NULL);
for (x = 0; x < adjusted_thumbnail_bpp * thumbnail_w; x++)
{
*adjusted_data++ = out[x] / 0x0101U;
}
}
stp_free_lut (*pv);
stp_set_density (*pv, old_density);
gimp_redraw_color_swatch ();
gimp_preview_update ();
}
void
gimp_invalidate_preview_thumbnail (void)
{
preview_valid = 0;
}
static void
draw_arrow (GdkWindow *w,
GdkGC *gc,
gint paper_left,
gint paper_top,
gint orient)
{
gint u = preview_ppi/2;
gint ox = paper_left + preview_ppi * paper_width / 72 / 2;
gint oy = paper_top + preview_ppi * paper_height / 72 / 2;
if (orient == ORIENT_LANDSCAPE)
{
ox += preview_ppi * paper_width / 72 / 4;
if (ox > paper_left + preview_ppi * paper_width / 72 - u)
ox = paper_left + preview_ppi * paper_width / 72 - u;
gdk_draw_line (w, gc, ox + u, oy, ox, oy - u);
gdk_draw_line (w, gc, ox + u, oy, ox, oy + u);
gdk_draw_line (w, gc, ox + u, oy, ox - u, oy);
}
else if (orient == ORIENT_SEASCAPE)
{
ox -= preview_ppi * paper_width / 72 / 4;
if (ox < paper_left + u)
ox = paper_left + u;
gdk_draw_line (w, gc, ox - u, oy, ox, oy - u);
gdk_draw_line (w, gc, ox - u, oy, ox, oy + u);
gdk_draw_line (w, gc, ox - u, oy, ox + u, oy);
}
else if (orient == ORIENT_UPSIDEDOWN)
{
oy += preview_ppi * paper_height / 72 / 4;
if (oy > paper_top + preview_ppi * paper_height / 72 - u)
oy = paper_top + preview_ppi * paper_height / 72 - u;
gdk_draw_line (w, gc, ox, oy + u, ox - u, oy);
gdk_draw_line (w, gc, ox, oy + u, ox + u, oy);
gdk_draw_line (w, gc, ox, oy + u, ox, oy - u);
}
else /* (orient == ORIENT_PORTRAIT) */
{
oy -= preview_ppi * paper_height / 72 / 4;
if (oy < paper_top + u)
oy = paper_top + u;
gdk_draw_line (w, gc, ox, oy - u, ox - u, oy);
gdk_draw_line (w, gc, ox, oy - u, ox + u, oy);
gdk_draw_line (w, gc, ox, oy - u, ox, oy + u);
}
}
/*
* gimp_preview_update_callback() -
*/
static void
gimp_do_preview_thumbnail (void)
{
static GdkGC *gc = NULL;
static GdkGC *gcinv = NULL;
static GdkGC *gcset = NULL;
static guchar *preview_data = NULL;
static gint opx = 0;
static gint opy = 0;
static gint oph = 0;
static gint opw = 0;
gint preview_x = 1 + printable_left + preview_ppi * stp_get_left (*pv) / 72;
gint preview_y = 1 + printable_top + preview_ppi * stp_get_top (*pv) / 72;
gint preview_w = MAX (1, (preview_ppi * print_width) / 72 - 1);
gint preview_h = MAX (1, (preview_ppi * print_height) / 72 - 1);
if (gc == NULL)
{
gc = gdk_gc_new (preview->window);
gcinv = gdk_gc_new (preview->window);
gdk_gc_set_function (gcinv, GDK_INVERT);
gcset = gdk_gc_new (preview->window);
gdk_gc_set_function (gcset, GDK_SET);
}
if (!preview_valid)
{
gint v_denominator = preview_h > 1 ? preview_h - 1 : 1;
gint v_numerator = (thumbnail_h - 1) % v_denominator;
gint v_whole = (thumbnail_h - 1) / v_denominator;
gint h_denominator = preview_w > 1 ? preview_w - 1 : 1;
gint h_numerator = (thumbnail_w - 1) % h_denominator;
gint h_whole = (thumbnail_w - 1) / h_denominator;
gint adjusted_preview_width = adjusted_thumbnail_bpp * preview_w;
gint adjusted_thumbnail_width = adjusted_thumbnail_bpp * thumbnail_w;
gint v_cur = 0;
gint v_last = -1;
gint v_error = v_denominator / 2;
gint y;
gint i;
if (preview_data)
g_free (preview_data);
preview_data = g_malloc (3 * preview_h * preview_w);
for (y = 0; y < preview_h; y++)
{
guchar *outbuf = preview_data + adjusted_preview_width * y;
if (v_cur == v_last)
{
memcpy (outbuf, outbuf - adjusted_preview_width,
adjusted_preview_width);
}
else
{
guchar *inbuf = adjusted_thumbnail_data - adjusted_thumbnail_bpp
+ adjusted_thumbnail_width * v_cur;
gint h_cur = 0;
gint h_last = -1;
gint h_error = h_denominator / 2;
gint x;
v_last = v_cur;
for (x = 0; x < preview_w; x++)
{
if (h_cur == h_last)
{
for (i = 0; i < adjusted_thumbnail_bpp; i++)
outbuf[i] = outbuf[i - adjusted_thumbnail_bpp];
}
else
{
inbuf += adjusted_thumbnail_bpp * (h_cur - h_last);
h_last = h_cur;
for (i = 0; i < adjusted_thumbnail_bpp; i++)
outbuf[i] = inbuf[i];
}
outbuf += adjusted_thumbnail_bpp;
h_cur += h_whole;
h_error += h_numerator;
if (h_error >= h_denominator)
{
h_error -= h_denominator;
h_cur++;
}
}
}
v_cur += v_whole;
v_error += v_numerator;
if (v_error >= v_denominator)
{
v_error -= v_denominator;
v_cur++;
}
}
preview_valid = 1;
}
/* draw paper frame */
gdk_draw_rectangle (preview->window, gc, 0,
paper_left, paper_top,
MAX(2, preview_ppi * paper_width / 72),
MAX(2, preview_ppi * paper_height / 72));
/* draw printable frame */
gdk_draw_rectangle (preview->window, gc, 0,
printable_left, printable_top,
MAX(2, preview_ppi * printable_width / 72),
MAX(2, preview_ppi * printable_height / 72));
draw_arrow (preview->window, gcset, paper_left, paper_top, orient);
if (adjusted_thumbnail_bpp == 1)
gdk_draw_gray_image (preview->window, gc,
preview_x, preview_y, preview_w, preview_h,
GDK_RGB_DITHER_NORMAL, preview_data, preview_w);
else
gdk_draw_rgb_image (preview->window, gc,
preview_x, preview_y, preview_w, preview_h,
GDK_RGB_DITHER_NORMAL, preview_data, 3 * preview_w);
/* draw orientation arrow pointing to top-of-paper */
draw_arrow (preview->window, gcinv, paper_left, paper_top, orient);
opx = preview_x;
opy = preview_y;
oph = preview_h;
opw = preview_w;
}
static gboolean
gimp_preview_expose (void)
{
gimp_do_preview_thumbnail ();
return FALSE;
}
static void
gimp_preview_update (void)
{
gint temp;
gint orient; /* True orientation of page */
gdouble max_ppi_scaling; /* Maximum PPI for current page size */
gdouble min_ppi_scaling; /* Minimum PPI for current page size */
gdouble min_ppi_scaling1; /* Minimum PPI for current page size */
gdouble min_ppi_scaling2; /* Minimum PPI for current page size */
gdouble unit_scaler = 72.0;
(stp_printer_get_printfuncs (current_printer)->media_size)
(current_printer, *pv, &paper_width, &paper_height);
(stp_printer_get_printfuncs (current_printer)->imageable_area)
(current_printer, *pv, &left, &right, &bottom, &top);
/* Rationalise things a bit by measuring everything from the top left */
top = paper_height - top;
bottom = paper_height - bottom;
printable_width = right - left;
printable_height = bottom - top;
if (stp_get_orientation (*pv) == ORIENT_AUTO)
{
if ((printable_width >= printable_height && image_width>=image_height) ||
(printable_height >= printable_width && image_height >= image_width))
orient = ORIENT_PORTRAIT;
else
orient = ORIENT_LANDSCAPE;
}
else
orient = stp_get_orientation (*pv);
/*
* Adjust page dimensions depending on the page orientation.
*/
bottom = paper_height - bottom;
right = paper_width - right;
if (orient == ORIENT_LANDSCAPE || orient == ORIENT_SEASCAPE)
{
temp = printable_width;
printable_width = printable_height;
printable_height = temp;
temp = paper_width;
paper_width = paper_height;
paper_height = temp;
if (orient == ORIENT_LANDSCAPE)
{
temp = left;
left = bottom;
bottom = right;
right = top;
top = temp;
}
else
{
temp = left;
left = top;
top = right;
right = bottom;
bottom = temp;
}
}
else if (orient == ORIENT_UPSIDEDOWN)
{
temp = left;
left = right;
right = temp;
temp = top;
top = bottom;
bottom = temp;
}
bottom = paper_height - bottom;
right = paper_width - right;
if (stp_get_scaling (*pv) < 0)
{
gdouble twidth;
min_ppi_scaling1 = 72.0 * (gdouble) image_width / printable_width;
min_ppi_scaling2 = 72.0 * (gdouble) image_height / printable_height;
if (min_ppi_scaling1 > min_ppi_scaling2)
min_ppi_scaling = min_ppi_scaling1;
else
min_ppi_scaling = min_ppi_scaling2;
max_ppi_scaling = min_ppi_scaling * 20;
if (stp_get_scaling (*pv) < 0 &&
stp_get_scaling (*pv) > -min_ppi_scaling)
stp_set_scaling (*pv, -min_ppi_scaling);
twidth = (72.0 * (gdouble) image_width / -stp_get_scaling(*pv));
print_width = twidth + .5;
print_height = (twidth * (gdouble) image_height / image_width) + .5;
GTK_ADJUSTMENT (scaling_adjustment)->lower = min_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->upper = max_ppi_scaling;
GTK_ADJUSTMENT (scaling_adjustment)->value = -stp_get_scaling(*pv);
if (!suppress_scaling_adjustment)
{
suppress_preview_reset++;
gtk_adjustment_changed (GTK_ADJUSTMENT (scaling_adjustment));
suppress_scaling_callback = TRUE;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (scaling_ppi), TRUE);
suppress_scaling_callback = FALSE;
gtk_adjustment_value_changed (GTK_ADJUSTMENT (scaling_adjustment));
suppress_preview_reset--;
}
}
else
{
/* we do stp_get_scaling(*pv) % of height or width, whatever is less */
/* this is relative to printable size */
if (image_width * printable_height > printable_width * image_height)
/* if image_width/image_height > printable_width/printable_height */
/* i.e. if image is wider relative to its height than the width
of the printable area relative to its height */
{
gdouble twidth = .5 + printable_width * stp_get_scaling(*pv) / 100;
print_width = twidth;
print_height = twidth * (gdouble) image_height /
(gdouble) image_width;
}
else
{
gdouble theight = .5 + printable_height * stp_get_scaling(*pv) /100;
print_height = theight;
print_width = theight * (gdouble) image_width /
(gdouble) image_height;
}
}
preview_ppi = PREVIEW_SIZE_HORIZ * 72.0 / (gdouble) paper_width;
if (PREVIEW_SIZE_VERT * 72 / paper_height < preview_ppi)
preview_ppi = PREVIEW_SIZE_VERT * 72.0 / (gdouble) paper_height;
if (preview_ppi > MAX_PREVIEW_PPI)
preview_ppi = MAX_PREVIEW_PPI;
paper_left = (PREVIEW_SIZE_HORIZ - preview_ppi * paper_width / 72) / 2;
paper_top = (PREVIEW_SIZE_VERT - preview_ppi * paper_height / 72) / 2;
printable_left = paper_left + preview_ppi * left / 72;
printable_top = paper_top + preview_ppi * top / 72 ;
if (preview == NULL || preview->window == NULL)
return;
if (stp_get_left (*pv) < 0)
{
stp_set_left (*pv, (paper_width - print_width) / 2 - left);
if (stp_get_left (*pv) < 0)
stp_set_left (*pv, 0);
}
/* we leave stp_get_left(*pv) etc. relative to printable area */
if (stp_get_left (*pv) > (printable_width - print_width))
stp_set_left (*pv, printable_width - print_width);
if (stp_get_top (*pv) < 0)
{
stp_set_top (*pv, ((paper_height - print_height) / 2) - top);
if (stp_get_top (*pv) < 0)
stp_set_top (*pv, 0);
}
if (stp_get_top (*pv) > (printable_height - print_height))
stp_set_top (*pv, printable_height - print_height);
if(stp_get_unit (*pv))
unit_scaler /= 2.54;
set_entry_value (top_entry, (top + stp_get_top (*pv)) / unit_scaler, 1);
set_entry_value (left_entry, (left + stp_get_left (*pv)) / unit_scaler, 1);
set_entry_value (bottom_entry,
(top + stp_get_top(*pv) + print_height) / unit_scaler, 1);
set_entry_value (bottom_border_entry,
(paper_height - (top + stp_get_top (*pv) + print_height)) /
unit_scaler, 1);
set_entry_value (right_entry,
(left + stp_get_left(*pv) + print_width) / unit_scaler, 1);
set_entry_value (right_border_entry,
(paper_width - (left + stp_get_left (*pv) + print_width)) /
unit_scaler, 1);
set_entry_value (width_entry, print_width / unit_scaler, 1);
set_entry_value (height_entry, print_height / unit_scaler, 1);
set_entry_value (custom_size_width, stp_get_page_width (*pv)/unit_scaler, 1);
set_entry_value (custom_size_height, stp_get_page_height (*pv)/unit_scaler, 1);
/* draw image */
if (! suppress_preview_update)
gtk_widget_queue_draw (preview);
}
/*
* gimp_preview_button_callback() -
*/
static gboolean
gimp_preview_button_callback (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
if (event->type == GDK_BUTTON_PRESS)
{
if (preview_active == 0)
{
mouse_x = event->x;
mouse_y = event->y;
old_left = stp_get_left (*pv);
old_top = stp_get_top (*pv);
mouse_button = event->button;
buttons_mask = 1 << event->button;
buttons_pressed++;
preview_active = 1;
gimp_help_disable_tooltips ();
if (event->state & GDK_SHIFT_MASK)
move_constraint = MOVE_CONSTRAIN;
else
move_constraint = MOVE_ANY;
}
else if (preview_active == 1)
{
if ((buttons_mask & (1 << event->button)) == 0)
{
gimp_help_enable_tooltips ();
preview_active = -1;
stp_set_left (*pv, old_left);
stp_set_top (*pv, old_top);
gimp_preview_update ();
buttons_mask |= 1 << event->button;
buttons_pressed++;
}
}
else
{
if ((buttons_mask & (1 << event->button)) == 0)
{
buttons_mask |= 1 << event->button;
buttons_pressed++;
}
}
}
else if (event->type == GDK_BUTTON_RELEASE)
{
buttons_pressed--;
buttons_mask &= ~(1 << event->button);
if (buttons_pressed == 0)
{
gimp_help_enable_tooltips ();
preview_active = 0;
}
}
return FALSE;
}
/*
* gimp_preview_motion_callback() -
*/
static gboolean
gimp_preview_motion_callback (GtkWidget *widget,
GdkEventMotion *event,
gpointer data)
{
if (event->type != GDK_MOTION_NOTIFY)
return FALSE;
if (preview_active != 1)
return FALSE;
if (stp_get_left(*pv) < 0 || stp_get_top(*pv) < 0)
{
stp_set_left(*pv, 72 * (printable_width - print_width) / 20);
stp_set_top(*pv, 72 * (printable_height - print_height) / 20);
}
if (move_constraint == MOVE_CONSTRAIN)
{
int dx = abs(event->x - mouse_x);
int dy = abs(event->y - mouse_y);
if (dx > dy && dx > 3)
move_constraint = MOVE_HORIZONTAL;
else if (dy > dx && dy > 3)
move_constraint = MOVE_VERTICAL;
else
return FALSE;
}
if (mouse_button == 2)
{
int changes = 0;
int y_threshold = MAX (1, (preview_ppi * print_height) / 72);
if (move_constraint & MOVE_HORIZONTAL)
{
int x_threshold = MAX (1, (preview_ppi * print_width) / 72);
while (event->x - mouse_x >= x_threshold)
{
if (left + stp_get_left (*pv) + (print_width * 2) <= right)
{
stp_set_left (*pv, stp_get_left (*pv) + print_width);
mouse_x += x_threshold;
changes = 1;
}
else
break;
}
while (mouse_x - event->x >= x_threshold)
{
if (stp_get_left (*pv) >= print_width)
{
stp_set_left (*pv, stp_get_left (*pv) - print_width);
mouse_x -= x_threshold;
changes = 1;
}
else
break;
}
}
if (move_constraint & MOVE_VERTICAL)
{
while (event->y - mouse_y >= y_threshold)
{
if (top + stp_get_top (*pv) + (print_height * 2) <= bottom)
{
stp_set_top (*pv, stp_get_top (*pv) + print_height);
mouse_y += y_threshold;
changes = 1;
}
else
break;
}
while (mouse_y - event->y >= y_threshold)
{
if (stp_get_top (*pv) >= print_height)
{
stp_set_top (*pv, stp_get_top (*pv) - print_height);
mouse_y -= y_threshold;
changes = 1;
}
else
break;
}
}
if (!changes)
return FALSE;
}
else
{
gint old_top = stp_get_top (*pv);
gint old_left = stp_get_left (*pv);
gint new_top = old_top;
gint new_left = old_left;
gint changes = 0;
if (mouse_button == 1)
{
if (move_constraint & MOVE_VERTICAL)
new_top += 72 * (event->y - mouse_y) / preview_ppi;
if (move_constraint & MOVE_HORIZONTAL)
new_left += 72 * (event->x - mouse_x) / preview_ppi;
}
else
{
if (move_constraint & MOVE_VERTICAL)
new_top += event->y - mouse_y;
if (move_constraint & MOVE_HORIZONTAL)
new_left += event->x - mouse_x;
}
if (new_top < 0)
new_top = 0;
if (new_top > (bottom - top) - print_height)
new_top = (bottom - top) - print_height;
if (new_left < 0)
new_left = 0;
if (new_left > (right - left) - print_width)
new_left = (right - left) - print_width;
if (new_top != old_top)
{
stp_set_top (*pv, new_top);
changes = 1;
}
if (new_left != old_left)
{
stp_set_left (*pv, new_left);
changes = 1;
}
mouse_x = event->x;
mouse_y = event->y;
if (!changes)
return FALSE;
}
gimp_preview_update ();
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink