X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkprintsettings.c;h=b1e8476f03ee9be4da34ffa7d1235a070206dff8;hb=7c2a752b3724ad9ac88b7abfecc63e4e0eb7eb54;hp=e80548e3a4a651f1676123447b54cb6188679d7f;hpb=2878ecf6f7cc2b066d0bdfae7093d9428f4ddaae;p=~andy%2Fgtk diff --git a/gtk/gtkprintsettings.c b/gtk/gtkprintsettings.c index e80548e3a..b1e8476f0 100644 --- a/gtk/gtkprintsettings.c +++ b/gtk/gtkprintsettings.c @@ -13,18 +13,42 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ #include "config.h" + #include #include + #include + #include "gtkprintsettings.h" #include "gtkprintutils.h" -#include "gtkalias.h" +#include "gtktypebuiltins.h" +#include "gtkwidget.h" + + +/** + * SECTION:gtkprintsettings + * @Short_description: Stores print settings + * @Title: GtkPrintSettings + * + * A GtkPrintSettings object represents the settings of a print dialog in + * a system-independent way. The main use for this object is that once + * you've printed you can get a settings object that represents the settings + * the user chose, and the next time you print you can pass that object in so + * that the user doesn't have to re-set all his settings. + * + * Its also possible to enumerate the settings so that you can easily save + * the settings for the next time your app runs, or even store them in a + * document. The predefined keys try to use shared values as much as possible + * so that moving such a document between systems still works. + * + * + * + * Printing support was added in GTK+ 2.10. + */ typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass; @@ -36,7 +60,7 @@ typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass; struct _GtkPrintSettings { GObject parent_instance; - + GHashTable *hash; }; @@ -45,6 +69,8 @@ struct _GtkPrintSettingsClass GObjectClass parent_class; }; +#define KEYFILE_GROUP_NAME "Print Settings" + G_DEFINE_TYPE (GtkPrintSettings, gtk_print_settings, G_TYPE_OBJECT) static void @@ -104,10 +130,10 @@ copy_hash_entry (gpointer key, /** * gtk_print_settings_copy: * @other: a #GtkPrintSettings - * + * * Copies a #GtkPrintSettings object. - * - * Return value: a newly allocated copy of @other + * + * Return value: (transfer full): a newly allocated copy of @other * * Since: 2.10 */ @@ -141,7 +167,7 @@ gtk_print_settings_copy (GtkPrintSettings *other) * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get (GtkPrintSettings *settings, const gchar *key) { @@ -152,11 +178,11 @@ gtk_print_settings_get (GtkPrintSettings *settings, * gtk_print_settings_set: * @settings: a #GtkPrintSettings * @key: a key - * @value: a string value, or %NULL - * + * @value: (allow-none): a string value, or %NULL + * * Associates @value with @key. * - * Since: 2.10 + * Since: 2.10 */ void gtk_print_settings_set (GtkPrintSettings *settings, @@ -229,7 +255,7 @@ gtk_print_settings_get_bool (GtkPrintSettings *settings, const gchar *val; val = gtk_print_settings_get (settings, key); - if (val != NULL && strcmp (val, "true") == 0) + if (g_strcmp0 (val, "true") == 0) return TRUE; return FALSE; @@ -260,10 +286,10 @@ gtk_print_settings_get_bool_with_default (GtkPrintSettings *settings, const gchar *val; val = gtk_print_settings_get (settings, key); - if (val != NULL && strcmp (val, "true") == 0) + if (g_strcmp0 (val, "true") == 0) return TRUE; - if (val != NULL && strcmp (val, "false") == 0) + if (g_strcmp0 (val, "false") == 0) return FALSE; return default_val; @@ -470,9 +496,9 @@ gtk_print_settings_set_int (GtkPrintSettings *settings, /** * gtk_print_settings_foreach: * @settings: a #GtkPrintSettings - * @func: the function to call + * @func: (scope call): the function to call * @user_data: user data for @func - * + * * Calls @func for each key-value pair of @settings. * * Since: 2.10 @@ -496,7 +522,7 @@ gtk_print_settings_foreach (GtkPrintSettings *settings, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get_printer (GtkPrintSettings *settings) { return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PRINTER); @@ -790,8 +816,9 @@ gtk_print_settings_set_use_color (GtkPrintSettings *settings, gboolean gtk_print_settings_get_collate (GtkPrintSettings *settings) { - return gtk_print_settings_get_bool (settings, - GTK_PRINT_SETTINGS_COLLATE); + return gtk_print_settings_get_bool_with_default (settings, + GTK_PRINT_SETTINGS_COLLATE, + TRUE); } /** @@ -1036,6 +1063,73 @@ gtk_print_settings_set_page_set (GtkPrintSettings *settings, gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PAGE_SET, str); } +/** + * gtk_print_settings_get_number_up_layout: + * @settings: a #GtkPrintSettings + * + * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT. + * + * Return value: layout of page in number-up mode + * + * Since: 2.14 + */ +GtkNumberUpLayout +gtk_print_settings_get_number_up_layout (GtkPrintSettings *settings) +{ + GtkNumberUpLayout layout; + GtkTextDirection text_direction; + GEnumClass *enum_class; + GEnumValue *enum_value; + const gchar *val; + + g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM); + + val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT); + text_direction = gtk_widget_get_default_direction (); + + if (text_direction == GTK_TEXT_DIR_LTR) + layout = GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM; + else + layout = GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM; + + if (val == NULL) + return layout; + + enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT); + enum_value = g_enum_get_value_by_nick (enum_class, val); + if (enum_value) + layout = enum_value->value; + g_type_class_unref (enum_class); + + return layout; +} + +/** + * gtk_print_settings_set_number_up_layout: + * @settings: a #GtkPrintSettings + * @number_up_layout: a #GtkNumberUpLayout value + * + * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT. + * + * Since: 2.14 + */ +void +gtk_print_settings_set_number_up_layout (GtkPrintSettings *settings, + GtkNumberUpLayout number_up_layout) +{ + GEnumClass *enum_class; + GEnumValue *enum_value; + + g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings)); + + enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT); + enum_value = g_enum_get_value (enum_class, number_up_layout); + g_return_if_fail (enum_value != NULL); + + gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT, enum_value->value_nick); + g_type_class_unref (enum_class); +} + /** * gtk_print_settings_get_n_copies: * @settings: a #GtkPrintSettings @@ -1082,7 +1176,7 @@ gtk_print_settings_set_n_copies (GtkPrintSettings *settings, gint gtk_print_settings_get_number_up (GtkPrintSettings *settings) { - return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP); + return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_NUMBER_UP, 1); } /** @@ -1115,7 +1209,7 @@ gtk_print_settings_set_number_up (GtkPrintSettings *settings, gint gtk_print_settings_get_resolution (GtkPrintSettings *settings) { - return gtk_print_settings_get_int (settings, GTK_PRINT_SETTINGS_RESOLUTION); + return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION, 300); } /** @@ -1123,7 +1217,9 @@ gtk_print_settings_get_resolution (GtkPrintSettings *settings) * @settings: a #GtkPrintSettings * @resolution: the resolution in dpi * - * Sets the value of %GTK_PRINT_SETTINGS_RESOLUTION. + * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION, + * %GTK_PRINT_SETTINGS_RESOLUTION_X and + * %GTK_PRINT_SETTINGS_RESOLUTION_Y. * * Since: 2.10 */ @@ -1133,6 +1229,100 @@ gtk_print_settings_set_resolution (GtkPrintSettings *settings, { gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION, resolution); + gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_X, + resolution); + gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y, + resolution); +} + +/** + * gtk_print_settings_get_resolution_x: + * @settings: a #GtkPrintSettings + * + * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X. + * + * Return value: the horizontal resolution in dpi + * + * Since: 2.16 + */ +gint +gtk_print_settings_get_resolution_x (GtkPrintSettings *settings) +{ + return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_X, 300); +} + +/** + * gtk_print_settings_get_resolution_y: + * @settings: a #GtkPrintSettings + * + * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y. + * + * Return value: the vertical resolution in dpi + * + * Since: 2.16 + */ +gint +gtk_print_settings_get_resolution_y (GtkPrintSettings *settings) +{ + return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y, 300); +} + +/** + * gtk_print_settings_set_resolution_xy: + * @settings: a #GtkPrintSettings + * @resolution_x: the horizontal resolution in dpi + * @resolution_y: the vertical resolution in dpi + * + * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION, + * %GTK_PRINT_SETTINGS_RESOLUTION_X and + * %GTK_PRINT_SETTINGS_RESOLUTION_Y. + * + * Since: 2.16 + */ +void +gtk_print_settings_set_resolution_xy (GtkPrintSettings *settings, + gint resolution_x, + gint resolution_y) +{ + gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_X, + resolution_x); + gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y, + resolution_y); + gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION, + resolution_x); +} + +/** + * gtk_print_settings_get_printer_lpi: + * @settings: a #GtkPrintSettings + * + * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI. + * + * Return value: the resolution in lpi (lines per inch) + * + * Since: 2.16 + */ +gdouble +gtk_print_settings_get_printer_lpi (GtkPrintSettings *settings) +{ + return gtk_print_settings_get_double_with_default (settings, GTK_PRINT_SETTINGS_PRINTER_LPI, 150.0); +} + +/** + * gtk_print_settings_set_printer_lpi: + * @settings: a #GtkPrintSettings + * @lpi: the resolution in lpi (lines per inch) + * + * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI. + * + * Since: 2.16 + */ +void +gtk_print_settings_set_printer_lpi (GtkPrintSettings *settings, + gdouble lpi) +{ + gtk_print_settings_set_double (settings, GTK_PRINT_SETTINGS_PRINTER_LPI, + lpi); } /** @@ -1190,6 +1380,9 @@ gtk_print_settings_get_print_pages (GtkPrintSettings *settings) if (val == NULL || (strcmp (val, "all") == 0)) return GTK_PRINT_PAGES_ALL; + if (strcmp (val, "selection") == 0) + return GTK_PRINT_PAGES_SELECTION; + if (strcmp (val, "current") == 0) return GTK_PRINT_PAGES_CURRENT; @@ -1223,6 +1416,9 @@ gtk_print_settings_set_print_pages (GtkPrintSettings *settings, case GTK_PRINT_PAGES_CURRENT: str = "current"; break; + case GTK_PRINT_PAGES_SELECTION: + str = "selection"; + break; case GTK_PRINT_PAGES_RANGES: str = "ranges"; break; @@ -1230,16 +1426,17 @@ gtk_print_settings_set_print_pages (GtkPrintSettings *settings, gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_PRINT_PAGES, str); } - + /** * gtk_print_settings_get_page_ranges: * @settings: a #GtkPrintSettings - * @num_ranges: return location for the length of the returned array - * + * @num_ranges: (out): return location for the length of the returned array + * * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES. - * - * Return value: an array of #GtkPageRanges. Use g_free() - * to free the array when it is no longer needed. + * + * Return value: (array length=num_ranges) (transfer full): an array + * of #GtkPageRanges. Use g_free() to free the array when + * it is no longer needed. * * Since: 2.10 */ @@ -1281,8 +1478,6 @@ gtk_print_settings_get_page_ranges (GtkPrintSettings *settings, { str++; end = (gint)strtol (str, NULL, 10); - if (end < start) - end = start; } ranges[i].start = start; @@ -1298,7 +1493,7 @@ gtk_print_settings_get_page_ranges (GtkPrintSettings *settings, /** * gtk_print_settings_set_page_ranges: * @settings: a #GtkPrintSettings - * @page_ranges: an array of #GtkPageRanges + * @page_ranges: (array length=num_ranges): an array of #GtkPageRanges * @num_ranges: the length of @page_ranges * * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES. @@ -1344,7 +1539,7 @@ gtk_print_settings_set_page_ranges (GtkPrintSettings *settings, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get_default_source (GtkPrintSettings *settings) { return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DEFAULT_SOURCE); @@ -1379,7 +1574,7 @@ gtk_print_settings_set_default_source (GtkPrintSettings *settings, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get_media_type (GtkPrintSettings *settings) { return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_MEDIA_TYPE); @@ -1414,7 +1609,7 @@ gtk_print_settings_set_media_type (GtkPrintSettings *settings, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get_dither (GtkPrintSettings *settings) { return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_DITHER); @@ -1478,7 +1673,7 @@ gtk_print_settings_set_finishings (GtkPrintSettings *settings, * * Since: 2.10 */ -G_CONST_RETURN gchar * +const gchar * gtk_print_settings_get_output_bin (GtkPrintSettings *settings) { return gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN); @@ -1499,7 +1694,255 @@ gtk_print_settings_set_output_bin (GtkPrintSettings *settings, { gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_BIN, output_bin); } + +/** + * gtk_print_settings_load_file: + * @settings: a #GtkPrintSettings + * @file_name: (type filename): the filename to read the settings from + * @error: (allow-none): return location for errors, or %NULL + * + * Reads the print settings from @file_name. If the file could not be loaded + * then error is set to either a #GFileError or #GKeyFileError. + * See gtk_print_settings_to_file(). + * + * Return value: %TRUE on success + * + * Since: 2.14 + */ +gboolean +gtk_print_settings_load_file (GtkPrintSettings *settings, + const gchar *file_name, + GError **error) +{ + gboolean retval = FALSE; + GKeyFile *key_file; + + g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE); + g_return_val_if_fail (file_name != NULL, FALSE); + + key_file = g_key_file_new (); + + if (g_key_file_load_from_file (key_file, file_name, 0, error) && + gtk_print_settings_load_key_file (settings, key_file, NULL, error)) + retval = TRUE; + + g_key_file_free (key_file); + + return retval; +} + +/** + * gtk_print_settings_new_from_file: + * @file_name: (type filename): the filename to read the settings from + * @error: (allow-none): return location for errors, or %NULL + * + * Reads the print settings from @file_name. Returns a new #GtkPrintSettings + * object with the restored settings, or %NULL if an error occurred. If the + * file could not be loaded then error is set to either a #GFileError or + * #GKeyFileError. See gtk_print_settings_to_file(). + * + * Return value: the restored #GtkPrintSettings + * + * Since: 2.12 + */ +GtkPrintSettings * +gtk_print_settings_new_from_file (const gchar *file_name, + GError **error) +{ + GtkPrintSettings *settings = gtk_print_settings_new (); + + if (!gtk_print_settings_load_file (settings, file_name, error)) + { + g_object_unref (settings); + settings = NULL; + } + + return settings; +} + +/** + * gtk_print_settings_load_key_file: + * @settings: a #GtkPrintSettings + * @key_file: the #GKeyFile to retrieve the settings from + * @group_name: (allow-none): the name of the group to use, or %NULL to use the default + * "Print Settings" + * @error: (allow-none): return location for errors, or %NULL + * + * Reads the print settings from the group @group_name in @key_file. If the + * file could not be loaded then error is set to either a #GFileError or + * #GKeyFileError. + * + * Return value: %TRUE on success + * + * Since: 2.14 + */ +gboolean +gtk_print_settings_load_key_file (GtkPrintSettings *settings, + GKeyFile *key_file, + const gchar *group_name, + GError **error) +{ + gchar **keys; + gsize n_keys, i; + GError *err = NULL; + + g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE); + g_return_val_if_fail (key_file != NULL, FALSE); + + if (!group_name) + group_name = KEYFILE_GROUP_NAME; + + keys = g_key_file_get_keys (key_file, + group_name, + &n_keys, + &err); + if (err != NULL) + { + g_propagate_error (error, err); + return FALSE; + } + for (i = 0 ; i < n_keys; ++i) + { + gchar *value; + + value = g_key_file_get_string (key_file, + group_name, + keys[i], + NULL); + if (!value) + continue; -#define __GTK_PRINT_SETTINGS_C__ -#include "gtkaliasdef.c" + gtk_print_settings_set (settings, keys[i], value); + g_free (value); + } + + g_strfreev (keys); + + return TRUE; +} + +/** + * gtk_print_settings_new_from_key_file: + * @key_file: the #GKeyFile to retrieve the settings from + * @group_name: (allow-none): the name of the group to use, or %NULL to use + * the default "Print Settings" + * @error: (allow-none): return location for errors, or %NULL + * + * Reads the print settings from the group @group_name in @key_file. Returns a + * new #GtkPrintSettings object with the restored settings, or %NULL if an + * error occurred. If the file could not be loaded then error is set to either + * a #GFileError or #GKeyFileError. + * + * Return value: the restored #GtkPrintSettings + * + * Since: 2.12 + */ +GtkPrintSettings * +gtk_print_settings_new_from_key_file (GKeyFile *key_file, + const gchar *group_name, + GError **error) +{ + GtkPrintSettings *settings = gtk_print_settings_new (); + + if (!gtk_print_settings_load_key_file (settings, key_file, + group_name, error)) + { + g_object_unref (settings); + settings = NULL; + } + + return settings; +} + +/** + * gtk_print_settings_to_file: + * @settings: a #GtkPrintSettings + * @file_name: (type filename): the file to save to + * @error: (allow-none): return location for errors, or %NULL + * + * This function saves the print settings from @settings to @file_name. If the + * file could not be loaded then error is set to either a #GFileError or + * #GKeyFileError. + * + * Return value: %TRUE on success + * + * Since: 2.12 + */ +gboolean +gtk_print_settings_to_file (GtkPrintSettings *settings, + const gchar *file_name, + GError **error) +{ + GKeyFile *key_file; + gboolean retval = FALSE; + char *data = NULL; + gsize len; + GError *err = NULL; + + g_return_val_if_fail (GTK_IS_PRINT_SETTINGS (settings), FALSE); + g_return_val_if_fail (file_name != NULL, FALSE); + + key_file = g_key_file_new (); + gtk_print_settings_to_key_file (settings, key_file, NULL); + + data = g_key_file_to_data (key_file, &len, &err); + if (!data) + goto out; + + retval = g_file_set_contents (file_name, data, len, &err); + +out: + if (err != NULL) + g_propagate_error (error, err); + + g_key_file_free (key_file); + g_free (data); + + return retval; +} + +typedef struct { + GKeyFile *key_file; + const gchar *group_name; +} SettingsData; + +static void +add_value_to_key_file (const gchar *key, + const gchar *value, + SettingsData *data) +{ + g_key_file_set_string (data->key_file, data->group_name, key, value); +} + +/** + * gtk_print_settings_to_key_file: + * @settings: a #GtkPrintSettings + * @key_file: the #GKeyFile to save the print settings to + * @group_name: the group to add the settings to in @key_file, or + * %NULL to use the default "Print Settings" + * + * This function adds the print settings from @settings to @key_file. + * + * Since: 2.12 + */ +void +gtk_print_settings_to_key_file (GtkPrintSettings *settings, + GKeyFile *key_file, + const gchar *group_name) +{ + SettingsData data; + + g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings)); + g_return_if_fail (key_file != NULL); + + if (!group_name) + group_name = KEYFILE_GROUP_NAME; + + data.key_file = key_file; + data.group_name = group_name; + + gtk_print_settings_foreach (settings, + (GtkPrintSettingsFunc) add_value_to_key_file, + &data); +}