mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-23 13:01:42 +00:00
12d9a44686
2004-05-25 Sven Neumann <sven@gimp.org> * plug-ins/print/gimp_color_window.c * plug-ins/print/gimp_main_window.c: HIG-ified and ported to GtkFileChooser. * plug-ins/ifscompose/ifscompose.c (ifsfile_load_response): ported forgotten callback to GtkFileChooser. * plug-ins/imagemap/imap_browse.c * plug-ins/imagemap/imap_file.c: finished port to GtkFileChooser.
3297 lines
102 KiB
C
3297 lines
102 KiB
C
/*
|
|
* 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 RESPONSE_ABOUT 1
|
|
#define RESPONSE_SAVE 2
|
|
#define RESPONSE_PRINTSAVE 3
|
|
|
|
#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_response_callback (GtkWidget *dialog,
|
|
gint response_id,
|
|
gpointer data);
|
|
|
|
static void gimp_setup_update (void);
|
|
static void gimp_setup_open_callback (void);
|
|
static void gimp_setup_response (GtkWidget *widget,
|
|
gint response_id,
|
|
gpointer data);
|
|
static void gimp_new_printer_open_callback (void);
|
|
static void gimp_new_printer_activate (GtkWidget *widget,
|
|
gpointer data);
|
|
static void gimp_new_printer_response (GtkWidget *widget,
|
|
gint response_id,
|
|
gpointer data);
|
|
static void gimp_ppd_browse_callback (void);
|
|
static void gimp_ppd_response (GtkWidget *dialog,
|
|
gint response_id);
|
|
static void gimp_print_driver_callback (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *event,
|
|
gpointer data);
|
|
|
|
static void gimp_file_response (GtkWidget *dialog,
|
|
gint response_id);
|
|
|
|
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",
|
|
NULL, 0,
|
|
gimp_standard_help_func, "file-print-gimp",
|
|
|
|
_("About"), RESPONSE_ABOUT,
|
|
_("Save\nSettings"), RESPONSE_SAVE,
|
|
_("Print and\nSave Settings"), RESPONSE_PRINTSAVE,
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_PRINT, GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
|
|
g_free (plug_in_name);
|
|
|
|
g_signal_connect (print_dialog, "response",
|
|
G_CALLBACK (gimp_response_callback),
|
|
NULL);
|
|
g_signal_connect (print_dialog, "destroy",
|
|
G_CALLBACK (gtk_main_quit), NULL);
|
|
|
|
/*
|
|
* Top-level containers
|
|
*/
|
|
|
|
main_vbox = gtk_vbox_new (FALSE, 12);
|
|
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
|
|
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, 12);
|
|
gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (main_hbox);
|
|
|
|
right_vbox = gtk_vbox_new (FALSE, 12);
|
|
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 *event_box;
|
|
GtkWidget *vbox;
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (vbox);
|
|
|
|
event_box = gtk_event_box_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), event_box, FALSE, FALSE, 0);
|
|
gtk_widget_show (event_box);
|
|
|
|
preview = gtk_drawing_area_new ();
|
|
gtk_widget_set_size_request (preview,
|
|
PREVIEW_SIZE_HORIZ + 1, PREVIEW_SIZE_VERT + 1);
|
|
gtk_container_add (GTK_CONTAINER (event_box), preview);
|
|
gtk_widget_show (preview);
|
|
|
|
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;
|
|
|
|
frame = gimp_frame_new (_("Position"));
|
|
gtk_box_pack_start (GTK_BOX (right_vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
table = gtk_table_new (5, 4, FALSE);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 12);
|
|
gtk_table_set_col_spacing (GTK_TABLE (table), 3, 12);
|
|
gtk_container_add (GTK_CONTAINER (frame), table);
|
|
gtk_widget_show (table);
|
|
|
|
/*
|
|
* Orientation option menu.
|
|
*/
|
|
|
|
orientation_menu =
|
|
gimp_int_combo_box_new (_("Auto"), ORIENT_AUTO,
|
|
_("Portrait"), ORIENT_PORTRAIT,
|
|
_("Landscape"), ORIENT_LANDSCAPE,
|
|
_("Upside down"), ORIENT_UPSIDEDOWN,
|
|
_("Seascape"), ORIENT_SEASCAPE,
|
|
NULL);
|
|
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (orientation_menu),
|
|
ORIENT_AUTO);
|
|
|
|
g_signal_connect (orientation_menu, "changed",
|
|
G_CALLBACK (gimp_orientation_callback),
|
|
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:"), 0.0, 0.5,
|
|
orientation_menu, 3, FALSE);
|
|
|
|
/*
|
|
* 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:"), 0.0, 0.5,
|
|
left_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
top_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
right_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
right_border_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
bottom_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
bottom_border_entry, 1, FALSE);
|
|
|
|
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);
|
|
|
|
/*
|
|
* Center options
|
|
*/
|
|
|
|
box = gtk_hbox_new (TRUE, 6);
|
|
gimp_table_attach_aligned (GTK_TABLE (table), 0, 6,
|
|
_("Center:"), 0.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",
|
|
NULL, 0,
|
|
gimp_standard_help_func, "file-print-gimp",
|
|
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_OK, GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
|
|
g_signal_connect (setup_dialog, "response",
|
|
G_CALLBACK (gimp_setup_response),
|
|
NULL);
|
|
|
|
/*
|
|
* Top-level table for dialog.
|
|
*/
|
|
|
|
table = gtk_table_new (5, 2, FALSE);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (setup_dialog)->vbox), table,
|
|
TRUE, TRUE, 0);
|
|
gtk_widget_show (table);
|
|
|
|
/*
|
|
* Printer driver option menu.
|
|
*/
|
|
|
|
label = gtk_label_new (_("Printer Model:"));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
|
|
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_EXPAND, GTK_FILL | GTK_EXPAND, 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, GINT_TO_POINTER (i));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* PPD file.
|
|
*/
|
|
|
|
ppd_label = gtk_label_new (_("PPD File:"));
|
|
gtk_misc_set_alignment (GTK_MISC (ppd_label), 0.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, 6);
|
|
gtk_table_attach (GTK_TABLE (table), box, 1, 2, 3, 4,
|
|
GTK_FILL | GTK_EXPAND, 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 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 PPD file 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), 0.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 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);
|
|
|
|
/*
|
|
* PPD file selection dialog.
|
|
*/
|
|
|
|
ppd_browser =
|
|
gtk_file_chooser_dialog_new (_("Choose PPD File"),
|
|
GTK_WINDOW (setup_dialog),
|
|
GTK_FILE_CHOOSER_ACTION_OPEN,
|
|
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_OK, GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
gtk_dialog_set_default_response (GTK_DIALOG (ppd_browser), GTK_RESPONSE_OK);
|
|
|
|
g_signal_connect (ppd_browser, "response",
|
|
G_CALLBACK (gimp_ppd_response),
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
create_new_printer_dialog (void)
|
|
{
|
|
GtkWidget *table;
|
|
|
|
new_printer_dialog =
|
|
gimp_dialog_new (_("Define New Printer"), "print",
|
|
NULL, 0,
|
|
gimp_standard_help_func, "file-print-gimp",
|
|
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_OK, GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
|
|
g_signal_connect (new_printer_dialog, "response",
|
|
G_CALLBACK (gimp_new_printer_response),
|
|
NULL);
|
|
|
|
table = gtk_table_new (1, 2, FALSE);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
|
|
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:"),
|
|
0.0, 0.5, new_printer_entry, 1, FALSE);
|
|
|
|
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_activate),
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
create_about_dialog (void)
|
|
{
|
|
GtkWidget *label;
|
|
|
|
about_dialog =
|
|
gimp_dialog_new (_("About Gimp-Print " PLUG_IN_VERSION), "print",
|
|
NULL, 0,
|
|
gimp_standard_help_func, "file-print-gimp",
|
|
|
|
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
|
|
|
|
NULL);
|
|
|
|
g_signal_connect (about_dialog, "response",
|
|
G_CALLBACK (gtk_widget_hide),
|
|
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, 12);
|
|
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), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
|
|
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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
|
|
printer_model_label = gtk_label_new ("");
|
|
gtk_misc_set_alignment (GTK_MISC (printer_model_label), 0.0, 0.5);
|
|
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
|
|
_("Printer Model:"), 0.0, 0.5,
|
|
printer_model_label, 2, FALSE);
|
|
|
|
printer_hbox = gtk_hbox_new (TRUE, 6);
|
|
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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
|
|
/*
|
|
* Custom media size entries
|
|
*/
|
|
|
|
media_size_hbox = gtk_hbox_new (FALSE, 12);
|
|
gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
|
|
_("Dimensions:"), 0.0, 0.5,
|
|
media_size_hbox, 1, FALSE);
|
|
|
|
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,
|
|
TRUE, TRUE, 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,
|
|
TRUE, TRUE, 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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
|
|
/*
|
|
* 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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
|
|
/*
|
|
* 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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
|
|
/*
|
|
* 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:"), 0.0, 0.5,
|
|
event_box, 1, FALSE);
|
|
}
|
|
|
|
static void
|
|
create_scaling_frame (void)
|
|
{
|
|
GtkWidget *frame;
|
|
GtkWidget *vbox;
|
|
GtkWidget *table;
|
|
GtkWidget *box;
|
|
GtkWidget *label;
|
|
GtkWidget *event_box;
|
|
GSList *group;
|
|
|
|
frame = gimp_frame_new (_("Size"));
|
|
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 6);
|
|
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), 6);
|
|
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);
|
|
|
|
box = gtk_hbox_new (FALSE, 12);
|
|
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), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
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, FALSE);
|
|
|
|
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, FALSE);
|
|
|
|
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);
|
|
|
|
/*
|
|
* The width/height enries
|
|
*/
|
|
|
|
table = gtk_table_new (2, 2, FALSE);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
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:"), 0.0, 0.5,
|
|
width_entry, 1, FALSE);
|
|
|
|
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:"), 0.0, 0.5,
|
|
height_entry, 1, FALSE);
|
|
|
|
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), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
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, FALSE);
|
|
|
|
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),
|
|
GINT_TO_POINTER (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, FALSE);
|
|
|
|
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),
|
|
GINT_TO_POINTER (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), 6, 6);
|
|
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)
|
|
{
|
|
GtkSizeGroup *size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
|
|
GtkWidget *vbox;
|
|
GtkWidget *table;
|
|
GtkWidget *label;
|
|
GtkWidget *event_box;
|
|
GSList *group;
|
|
|
|
gimp_create_color_adjust_window ();
|
|
|
|
vbox = gtk_vbox_new (FALSE, 12);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
|
|
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), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
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);
|
|
|
|
gtk_size_group_add_widget (size_group, label);
|
|
g_object_unref (size_group);
|
|
|
|
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),
|
|
GINT_TO_POINTER (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),
|
|
GINT_TO_POINTER (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),
|
|
GINT_TO_POINTER (IMAGE_CONTINUOUS));
|
|
|
|
/*
|
|
* Output type toggles.
|
|
*/
|
|
|
|
table = gtk_table_new (4, 2, FALSE);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 6);
|
|
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);
|
|
|
|
gtk_size_group_add_widget (size_group, 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),
|
|
GINT_TO_POINTER (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),
|
|
GINT_TO_POINTER (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),
|
|
GINT_TO_POINTER (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, FALSE);
|
|
|
|
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_window_present),
|
|
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 ();
|
|
|
|
/*
|
|
* Output file selection dialog.
|
|
*/
|
|
file_browser =
|
|
gtk_file_chooser_dialog_new (_("Print to File"),
|
|
GTK_WINDOW (print_dialog),
|
|
GTK_FILE_CHOOSER_ACTION_SAVE,
|
|
|
|
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
|
|
GTK_STOCK_PRINT, GTK_RESPONSE_OK,
|
|
|
|
NULL);
|
|
gtk_dialog_set_default_response (GTK_DIALOG (file_browser), GTK_RESPONSE_OK);
|
|
|
|
g_signal_connect (file_browser, "response",
|
|
G_CALLBACK (gimp_file_response),
|
|
NULL);
|
|
|
|
/*
|
|
* Now actually set up the correct values in the dialog
|
|
*/
|
|
|
|
gimp_build_printer_combo ();
|
|
gimp_plist_callback (NULL, GINT_TO_POINTER (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_editable_set_editable (GTK_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 ();
|
|
|
|
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (orientation_menu),
|
|
stp_get_orientation (*pv));
|
|
|
|
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 = GPOINTER_TO_INT (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_editable_set_editable (GTK_EDITABLE (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_editable_set_editable (GTK_EDITABLE (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_editable_set_editable (GTK_EDITABLE (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_editable_set_editable (GTK_EDITABLE (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)
|
|
{
|
|
gint orientation;
|
|
|
|
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &orientation);
|
|
|
|
reset_preview ();
|
|
|
|
if (stp_get_orientation (*pv) != orientation)
|
|
{
|
|
gimp_invalidate_preview_thumbnail ();
|
|
stp_set_orientation (*pv, orientation);
|
|
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, GPOINTER_TO_INT (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, GPOINTER_TO_INT (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, GPOINTER_TO_INT (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);
|
|
}
|
|
|
|
static void
|
|
gimp_response_callback (GtkWidget *dialog,
|
|
gint response_id,
|
|
gpointer data)
|
|
{
|
|
switch (response_id)
|
|
{
|
|
case RESPONSE_ABOUT:
|
|
gtk_widget_show (about_dialog);
|
|
break;
|
|
|
|
case RESPONSE_SAVE:
|
|
reset_preview ();
|
|
printrc_save ();
|
|
break;
|
|
|
|
case RESPONSE_PRINTSAVE:
|
|
saveme = TRUE;
|
|
|
|
case GTK_RESPONSE_OK:
|
|
if (plist_current > 0)
|
|
{
|
|
runme = TRUE;
|
|
gimp_destroy_dialogs ();
|
|
}
|
|
else
|
|
{
|
|
gimp_dialogs_set_sensitive (FALSE);
|
|
gtk_widget_show (file_browser);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
gimp_destroy_dialogs ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* gimp_setup_update() - update widgets in the setup dialog
|
|
*/
|
|
static void
|
|
gimp_setup_update (void)
|
|
{
|
|
gboolean ppd;
|
|
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));
|
|
|
|
ppd = (strncmp (stp_get_driver (*pv), "ps", 2) == 0);
|
|
|
|
gtk_widget_set_sensitive (ppd_label, ppd);
|
|
gtk_widget_set_sensitive (ppd_file, ppd);
|
|
gtk_widget_set_sensitive (ppd_button, ppd);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (output_cmd), stp_get_output_to (*pv));
|
|
|
|
gtk_widget_set_sensitive (output_label, plist_current != 0);
|
|
gtk_widget_set_sensitive (output_cmd, plist_current != 0);
|
|
|
|
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_response (GtkWidget *widget,
|
|
gint response_id,
|
|
gpointer data)
|
|
{
|
|
if (response_id == GTK_RESPONSE_OK)
|
|
{
|
|
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, GINT_TO_POINTER (plist_current));
|
|
}
|
|
|
|
gtk_widget_hide (setup_dialog);
|
|
}
|
|
|
|
/*
|
|
* gimp_setup_ok_callback() -
|
|
*/
|
|
static void
|
|
gimp_new_printer_activate (GtkWidget *widget,
|
|
gpointer data)
|
|
{
|
|
gtk_dialog_response (GTK_DIALOG (gtk_widget_get_toplevel (widget)),
|
|
GTK_RESPONSE_OK);
|
|
}
|
|
|
|
static void
|
|
gimp_new_printer_response (GtkWidget *widget,
|
|
gint response_id,
|
|
gpointer data)
|
|
{
|
|
if (response_id == GTK_RESPONSE_OK)
|
|
{
|
|
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, GINT_TO_POINTER (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;
|
|
gboolean ppd;
|
|
|
|
gimp_invalidate_preview_thumbnail ();
|
|
reset_preview ();
|
|
data = gtk_clist_get_row_data (GTK_CLIST (widget), row);
|
|
current_printer = stp_get_printer_by_index (GPOINTER_TO_INT (data));
|
|
gtk_label_set_text (GTK_LABEL (printer_model_label),
|
|
gettext (stp_printer_get_long_name (current_printer)));
|
|
|
|
ppd = (strncmp (stp_printer_get_driver (current_printer), "ps", 2) == 0);
|
|
|
|
gtk_widget_set_sensitive (ppd_label, ppd);
|
|
gtk_widget_set_sensitive (ppd_file, ppd);
|
|
gtk_widget_set_sensitive (ppd_button, ppd);
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_ppd_browse_callback (void)
|
|
{
|
|
const gchar *filename = gtk_entry_get_text (GTK_ENTRY (ppd_file));
|
|
|
|
reset_preview ();
|
|
|
|
if (filename && g_path_is_absolute (filename))
|
|
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (ppd_browser), filename);
|
|
|
|
gtk_widget_show (ppd_browser);
|
|
}
|
|
|
|
static void
|
|
gimp_ppd_response (GtkWidget *dialog,
|
|
gint response_id)
|
|
{
|
|
gtk_widget_hide (dialog);
|
|
|
|
if (response_id == GTK_RESPONSE_OK)
|
|
{
|
|
gchar *filename;
|
|
|
|
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (ppd_file), filename);
|
|
|
|
g_free (filename);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_file_response (GtkWidget *dialog,
|
|
gint response_id)
|
|
{
|
|
gtk_widget_hide (dialog);
|
|
|
|
if (response_id == GTK_RESPONSE_OK)
|
|
{
|
|
gchar *filename;
|
|
|
|
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
|
|
|
|
stp_set_output_to (*pv, filename);
|
|
|
|
g_free (filename);
|
|
|
|
runme = TRUE;
|
|
gimp_destroy_dialogs ();
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
}
|