[dia] paper: consistently use double
- From: Zander <zbrown src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [dia] paper: consistently use double
- Date: Fri, 1 May 2020 02:36:24 +0000 (UTC)
commit 473c7d875f1da08447b5ae1024fbd3b5945ec6d2
Author: Zander Brown <zbrown gnome org>
Date: Fri May 1 03:12:24 2020 +0100
paper: consistently use double
Instead of sometime double other float or real always use double
Update the layout editor to follow this
app/dia-page-layout.c | 922 ++++++++++++++++++++++++++++++++++++++++++
app/dia-page-layout.h | 92 +++++
app/diapagelayout.c | 879 ----------------------------------------
app/diapagelayout.h | 82 ----
app/meson.build | 5 +-
app/pagesetup.c | 48 +--
docs/dia-app/dia-app-docs.xml | 2 +-
lib/meson.build | 4 +
lib/paper.c | 25 +-
lib/paper.h | 71 ++--
10 files changed, 1107 insertions(+), 1023 deletions(-)
---
diff --git a/app/dia-page-layout.c b/app/dia-page-layout.c
new file mode 100644
index 00000000..49450322
--- /dev/null
+++ b/app/dia-page-layout.c
@@ -0,0 +1,922 @@
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998, 1999 Alexander Larsson
+ *
+ * diapagelayout.[ch] -- a page settings widget for dia.
+ * Copyright (C) 1999 James Henstridge
+ *
+ * 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.
+ */
+
+/*#define PAGELAYOUT_TEST*/
+
+#include <config.h>
+
+#include "dia-page-layout.h"
+#include "widgets.h"
+
+#include "intl.h"
+
+#include "pixmaps/portrait.xpm"
+#include "pixmaps/landscape.xpm"
+
+#include "preferences.h"
+#include "paper.h"
+#include "prefs.h"
+
+#include "diamarshal.h"
+#include "diaoptionmenu.h"
+
+
+struct _DiaPageLayout {
+ GtkTable parent;
+
+ /*<private>*/
+ GtkWidget *paper_size, *paper_label;
+ GtkWidget *orient_portrait, *orient_landscape;
+ GtkWidget *tmargin, *bmargin, *lmargin, *rmargin;
+ GtkWidget *scale, *fitto;
+ GtkWidget *scaling, *fitw, *fith;
+
+ GtkWidget *darea;
+
+ int papernum; /* index into page_metrics array */
+
+ /* position of paper preview */
+ int x, y, width, height;
+
+ gboolean block_changed;
+};
+
+G_DEFINE_TYPE (DiaPageLayout, dia_page_layout, GTK_TYPE_TABLE)
+
+
+enum {
+ CHANGED,
+ LAST_SIGNAL
+};
+static guint pl_signals[LAST_SIGNAL] = { 0 };
+
+
+static void
+dia_page_layout_class_init (DiaPageLayoutClass *klass)
+{
+ pl_signals[CHANGED] =
+ g_signal_new ("changed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_FIRST,
+ 0, NULL, NULL,
+ dia_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+
+static void darea_size_allocate(DiaPageLayout *self, GtkAllocation *alloc);
+static int darea_expose_event(DiaPageLayout *self, GdkEventExpose *ev);
+static void paper_size_change(GtkWidget *widget, DiaPageLayout *self);
+static void orient_changed(DiaPageLayout *self);
+static void margin_changed(DiaPageLayout *self);
+static void scalemode_changed(DiaPageLayout *self);
+static void scale_changed(DiaPageLayout *self);
+
+
+static void
+dia_page_layout_init (DiaPageLayout *self)
+{
+ GtkWidget *frame, *box, *table, *wid;
+ GList *paper_names;
+ int i;
+
+ gtk_table_resize (GTK_TABLE (self), 3, 2);
+ gtk_table_set_row_spacings (GTK_TABLE (self), 5);
+ gtk_table_set_col_spacings (GTK_TABLE (self), 5);
+
+ /* paper size */
+ frame = gtk_frame_new (_("Paper Size"));
+ gtk_table_attach (GTK_TABLE (self), frame, 0,1, 0,1,
+ GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show (frame);
+
+ box = gtk_vbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box), 5);
+ gtk_container_add (GTK_CONTAINER (frame), box);
+ gtk_widget_show (box);
+
+ self->paper_size = dia_option_menu_new ();
+ gtk_box_pack_start (GTK_BOX (box), self->paper_size, TRUE, FALSE, 0);
+
+ g_signal_connect (self->paper_size,
+ "changed",
+ G_CALLBACK (paper_size_change),
+ self);
+
+ paper_names = get_paper_name_list ();
+ for (i = 0; paper_names != NULL;
+ i++, paper_names = g_list_next(paper_names)) {
+
+ dia_option_menu_add_item (DIA_OPTION_MENU (self->paper_size),
+ paper_names->data,
+ i);
+ }
+ gtk_widget_show (self->paper_size);
+
+ self->paper_label = gtk_label_new (NULL);
+ gtk_box_pack_start (GTK_BOX (box), self->paper_label, TRUE, TRUE, 0);
+ gtk_widget_show (self->paper_label);
+
+ /* orientation */
+ frame = gtk_frame_new (_("Orientation"));
+ gtk_table_attach (GTK_TABLE(self), frame, 1,2, 0,1,
+ GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
+ gtk_widget_show (frame);
+
+ box = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (box), 5);
+ gtk_container_add (GTK_CONTAINER (frame), box);
+ gtk_widget_show (box);
+
+ self->orient_portrait = gtk_radio_button_new (NULL);
+
+ wid = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_xpm_data (portrait_xpm));
+ gtk_container_add (GTK_CONTAINER (self->orient_portrait), wid);
+ gtk_widget_show (wid);
+
+ gtk_box_pack_start (GTK_BOX(box), self->orient_portrait, TRUE, TRUE, 0);
+ gtk_widget_show (self->orient_portrait);
+
+ self->orient_landscape = gtk_radio_button_new (
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (self->orient_portrait)));
+ wid = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_xpm_data (landscape_xpm));
+ gtk_container_add (GTK_CONTAINER (self->orient_landscape), wid);
+ gtk_widget_show (wid);
+
+ gtk_box_pack_start (GTK_BOX (box), self->orient_landscape, TRUE, TRUE, 0);
+ gtk_widget_show (self->orient_landscape);
+
+ /* margins */
+ frame = gtk_frame_new (_("Margins"));
+ gtk_table_attach (GTK_TABLE (self), frame, 0,1, 1,2,
+ GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show (frame);
+
+ table = gtk_table_new (4, 2, FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 5);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 5);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 5);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+ gtk_widget_show (table);
+
+ wid = gtk_label_new (_("Top:"));
+ gtk_misc_set_alignment (GTK_MISC (wid), 1.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), wid, 0,1, 0,1,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (wid);
+
+ self->tmargin = dia_unit_spinner_new (
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 0.1, 10, 0)),
+ prefs_get_length_unit ());
+ gtk_table_attach (GTK_TABLE (table), self->tmargin, 1,2, 0,1,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->tmargin);
+
+ wid = gtk_label_new (_("Bottom:"));
+ gtk_misc_set_alignment (GTK_MISC (wid), 1.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), wid, 0,1, 1,2,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (wid);
+
+ self->bmargin = dia_unit_spinner_new (
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 0.1, 10, 0)),
+ prefs_get_length_unit ());
+ gtk_table_attach (GTK_TABLE (table), self->bmargin, 1,2, 1,2,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->bmargin);
+
+ wid = gtk_label_new (_("Left:"));
+ gtk_misc_set_alignment (GTK_MISC (wid), 1.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), wid, 0,1, 2,3,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (wid);
+
+ self->lmargin = dia_unit_spinner_new(
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 0.1, 10, 0)),
+ prefs_get_length_unit ());
+ gtk_table_attach (GTK_TABLE (table), self->lmargin, 1,2, 2,3,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->lmargin);
+
+ wid = gtk_label_new (_("Right:"));
+ gtk_misc_set_alignment (GTK_MISC (wid), 1.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), wid, 0,1, 3,4,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (wid);
+
+ self->rmargin = dia_unit_spinner_new(
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 0.1, 10, 0)),
+ prefs_get_length_unit ());
+ gtk_table_attach (GTK_TABLE (table), self->rmargin, 1,2, 3,4,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->rmargin);
+
+ /* Scaling */
+ frame = gtk_frame_new (_("Scaling"));
+ gtk_table_attach (GTK_TABLE (self), frame, 0,1, 2,3,
+ GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show (frame);
+
+ table = gtk_table_new (2, 4, FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 5);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 5);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+ gtk_widget_show (table);
+
+ self->scale = gtk_radio_button_new_with_label (NULL, _("Scale:"));
+ gtk_table_attach (GTK_TABLE (table), self->scale, 0,1, 0,1,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->scale);
+
+ self->scaling = gtk_spin_button_new(
+ GTK_ADJUSTMENT (gtk_adjustment_new (100, 1, 10000, 1, 10, 0)), 1, 0);
+ gtk_table_attach (GTK_TABLE (table), self->scaling, 1,4, 0,1,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->scaling);
+
+ self->fitto = gtk_radio_button_new_with_label (
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (self->scale)),
+ _("Fit to:"));
+ gtk_table_attach (GTK_TABLE (table), self->fitto, 0,1, 1,2,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->fitto);
+
+ self->fitw = gtk_spin_button_new (
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 1, 1000, 1, 10, 0)), 1, 0);
+ gtk_widget_set_sensitive (self->fitw, FALSE);
+ gtk_table_attach (GTK_TABLE (table), self->fitw, 1,2, 1,2,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->fitw);
+
+ wid = gtk_label_new (_("by"));
+ gtk_misc_set_padding (GTK_MISC (wid), 5, 0);
+ gtk_table_attach (GTK_TABLE (table), wid, 2,3, 1,2,
+ GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (wid);
+
+ self->fith = gtk_spin_button_new(
+ GTK_ADJUSTMENT (gtk_adjustment_new (1, 1, 1000, 1, 10, 0)), 1, 0);
+ gtk_widget_set_sensitive (self->fith, FALSE);
+ gtk_table_attach (GTK_TABLE (table), self->fith, 3,4, 1,2,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->fith);
+
+ /* the drawing area */
+ self->darea = gtk_drawing_area_new ();
+ gtk_table_attach (GTK_TABLE (self), self->darea, 1,2, 1,3,
+ GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
+ gtk_widget_show (self->darea);
+
+ /* connect the signal handlers */
+ g_signal_connect_swapped (G_OBJECT (self->orient_portrait),
+ "toggled",
+ G_CALLBACK (orient_changed),
+ G_OBJECT (self));
+
+ g_signal_connect_swapped (G_OBJECT (self->tmargin),
+ "changed",
+ G_CALLBACK (margin_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->bmargin),
+ "changed",
+ G_CALLBACK (margin_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT(self->lmargin),
+ "changed",
+ G_CALLBACK (margin_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->rmargin),
+ "changed",
+ G_CALLBACK (margin_changed),
+ G_OBJECT (self));
+
+ g_signal_connect_swapped (G_OBJECT (self->fitto),
+ "toggled",
+ G_CALLBACK (scalemode_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->scaling),
+ "changed",
+ G_CALLBACK (scale_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->fitw),
+ "changed",
+ G_CALLBACK (scale_changed),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->fith),
+ "changed",
+ G_CALLBACK (scale_changed),
+ G_OBJECT (self));
+
+ g_signal_connect_swapped (G_OBJECT (self->darea),
+ "size_allocate",
+ G_CALLBACK (darea_size_allocate),
+ G_OBJECT (self));
+ g_signal_connect_swapped (G_OBJECT (self->darea),
+ "expose_event",
+ G_CALLBACK (darea_expose_event),
+ G_OBJECT (self));
+
+ self->block_changed = FALSE;
+}
+
+
+GtkWidget *
+dia_page_layout_new (void)
+{
+ DiaPageLayout *self = g_object_new (DIA_TYPE_PAGE_LAYOUT, NULL);
+
+ dia_page_layout_set_paper (self, "");
+
+ return GTK_WIDGET (self);
+}
+
+
+const char *
+dia_page_layout_get_paper (DiaPageLayout *self)
+{
+ return dia_paper_get_name (self->papernum);
+}
+
+
+void
+dia_page_layout_set_paper (DiaPageLayout *self, const char *paper)
+{
+ int i;
+
+ i = find_paper (paper);
+ if (i == -1) {
+ i = find_paper (prefs.new_diagram.papertype);
+ }
+
+ dia_option_menu_set_active (DIA_OPTION_MENU (self->paper_size), i);
+}
+
+
+void
+dia_page_layout_get_margins (DiaPageLayout *self,
+ double *tmargin,
+ double *bmargin,
+ double *lmargin,
+ double *rmargin)
+{
+ if (tmargin) {
+ *tmargin = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->tmargin));
+ }
+ if (bmargin) {
+ *bmargin = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->bmargin));
+ }
+ if (lmargin) {
+ *lmargin = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->lmargin));
+ }
+ if (rmargin) {
+ *rmargin = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->rmargin));
+ }
+}
+
+
+void
+dia_page_layout_set_margins (DiaPageLayout *self,
+ double tmargin,
+ double bmargin,
+ double lmargin,
+ double rmargin)
+{
+ self->block_changed = TRUE;
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->tmargin), tmargin);
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->bmargin), bmargin);
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->lmargin), lmargin);
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->rmargin), rmargin);
+ self->block_changed = FALSE;
+
+ g_signal_emit (G_OBJECT (self), pl_signals[CHANGED], 0);
+}
+
+
+DiaPageOrientation
+dia_page_layout_get_orientation (DiaPageLayout *self)
+{
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->orient_portrait))) {
+ return DIA_PAGE_ORIENT_PORTRAIT;
+ } else {
+ return DIA_PAGE_ORIENT_LANDSCAPE;
+ }
+}
+
+
+void
+dia_page_layout_set_orientation (DiaPageLayout *self,
+ DiaPageOrientation orient)
+{
+ switch (orient) {
+ case DIA_PAGE_ORIENT_PORTRAIT:
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->orient_portrait),
+ TRUE);
+ break;
+ case DIA_PAGE_ORIENT_LANDSCAPE:
+ default:
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->orient_landscape),
+ TRUE);
+ break;
+ }
+}
+
+
+gboolean
+dia_page_layout_get_fitto (DiaPageLayout *self)
+{
+ return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->fitto));
+}
+
+
+void
+dia_page_layout_set_fitto (DiaPageLayout *self, gboolean fitto)
+{
+ if (fitto) {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->fitto), TRUE);
+ } else {
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->scale), TRUE);
+ }
+}
+
+
+double
+dia_page_layout_get_scaling (DiaPageLayout *self)
+{
+ GtkAdjustment *adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(self->scaling));
+
+ return gtk_adjustment_get_value (adj) / 100.0;
+}
+
+
+void
+dia_page_layout_set_scaling (DiaPageLayout *self, double scaling)
+{
+ GtkAdjustment *adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (self->scaling));
+
+ gtk_adjustment_set_value (adj, scaling * 100.0);
+}
+
+
+void
+dia_page_layout_set_changed (DiaPageLayout *self, gboolean changed)
+{
+ self->block_changed = changed;
+}
+
+
+void
+dia_page_layout_get_fit_dims (DiaPageLayout *self, int *w, int *h)
+{
+ if (w) {
+ *w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (self->fitw));
+ }
+
+ if (h) {
+ *h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (self->fith));
+ }
+}
+
+
+void
+dia_page_layout_set_fit_dims (DiaPageLayout *self, int w, int h)
+{
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (self->fitw), w);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (self->fith), h);
+}
+
+
+void
+dia_page_layout_get_effective_area (DiaPageLayout *self,
+ double *width,
+ double *height)
+{
+ double h, w, scaling;
+ GtkAdjustment *adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (self->scaling));
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->orient_portrait))) {
+ w = get_paper_pswidth (self->papernum);
+ h = get_paper_psheight (self->papernum);
+ } else {
+ h = get_paper_pswidth (self->papernum);
+ w = get_paper_psheight (self->papernum);
+ }
+ h -= dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->tmargin));
+ g_return_if_fail (h > 0.0);
+ h -= dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->bmargin));
+ g_return_if_fail (h > 0.0);
+ w -= dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->lmargin));
+ g_return_if_fail (w > 0.0);
+ w -= dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->rmargin));
+ g_return_if_fail (w > 0.0);
+ scaling = gtk_adjustment_get_value (adj) / 100.0;
+ h /= scaling;
+ w /= scaling;
+
+ if (width) {
+ *width = w;
+ }
+
+ if (height) {
+ *height = h;
+ }
+}
+
+
+void
+dia_page_layout_get_paper_size (const char *paper,
+ double *width,
+ double *height)
+{
+ int i;
+
+ i = find_paper (paper);
+ if (i == -1) {
+ i = find_paper (prefs.new_diagram.papertype);
+ }
+
+ if (width) {
+ *width = get_paper_pswidth (i);
+ }
+
+ if (height) {
+ *height = get_paper_psheight (i);
+ }
+}
+
+
+void
+dia_page_layout_get_default_margins (const char *paper,
+ double *tmargin,
+ double *bmargin,
+ double *lmargin,
+ double *rmargin)
+{
+ int i;
+
+ i = find_paper (paper);
+ if (i == -1) {
+ i = find_paper (prefs.new_diagram.papertype);
+ }
+
+ if (tmargin) {
+ *tmargin = get_paper_tmargin (i);
+ }
+
+ if (bmargin) {
+ *bmargin = get_paper_bmargin (i);
+ }
+
+ if (lmargin) {
+ *lmargin = get_paper_lmargin (i);
+ }
+
+ if (rmargin) {
+ *rmargin = get_paper_rmargin (i);
+ }
+}
+
+
+static void
+size_page (DiaPageLayout *self, GtkAllocation *a)
+{
+ self->width = a->width - 3;
+ self->height = a->height - 3;
+
+ /* change to correct metrics */
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->orient_portrait))) {
+ if (self->width * get_paper_psheight(self->papernum) >
+ self->height * get_paper_pswidth (self->papernum)) {
+ self->width = self->height * get_paper_pswidth (self->papernum) /
+ get_paper_psheight (self->papernum);
+ } else {
+ self->height = self->width * get_paper_psheight (self->papernum) /
+ get_paper_pswidth (self->papernum);
+ }
+ } else {
+ if (self->width * get_paper_pswidth (self->papernum) >
+ self->height * get_paper_psheight (self->papernum)) {
+ self->width = self->height * get_paper_psheight (self->papernum) /
+ get_paper_pswidth (self->papernum);
+ } else {
+ self->height = self->width * get_paper_pswidth (self->papernum) /
+ get_paper_psheight (self->papernum);
+ }
+ }
+
+ self->x = (a->width - self->width - 3) / 2;
+ self->y = (a->height - self->height - 3) / 2;
+}
+
+
+static void
+darea_size_allocate (DiaPageLayout *self, GtkAllocation *allocation)
+{
+ size_page (self, allocation);
+}
+
+
+static int
+darea_expose_event (DiaPageLayout *self, GdkEventExpose *event)
+{
+ GdkWindow *window = gtk_widget_get_window (self->darea);
+ double val;
+ int num;
+ cairo_t *ctx;
+ GtkAllocation alloc;
+
+ if (!window)
+ return FALSE;
+
+ ctx = gdk_cairo_create (window);
+ cairo_set_line_cap (ctx, CAIRO_LINE_CAP_SQUARE);
+ cairo_set_line_width (ctx, 1);
+ cairo_set_antialias (ctx, CAIRO_ANTIALIAS_NONE);
+
+ gtk_widget_get_allocation (self->darea, &alloc);
+
+ cairo_set_source_rgba (ctx, 0, 0, 0, 0);
+ cairo_rectangle (ctx, 0, 0,
+ alloc.width,
+ alloc.height);
+ cairo_fill (ctx);
+
+ /* draw the page image */
+ cairo_set_source_rgba (ctx, 0, 0, 0, 1.0);
+ cairo_rectangle(ctx, self->x+3, self->y+3, self->width, self->height);
+ cairo_fill (ctx);
+ cairo_set_source_rgba (ctx, 1.0, 1.0, 1.0, 1.0);
+ cairo_rectangle (ctx, self->x, self->y, self->width, self->height);
+ cairo_fill (ctx);
+ cairo_set_source_rgba (ctx, 0, 0, 0, 1.0);
+ cairo_rectangle (ctx, self->x + 1, self->y, self->width, self->height);
+ cairo_stroke (ctx);
+
+ cairo_set_source_rgba (ctx, 0, 0, 0.8, 1.0);
+
+ /* draw margins */
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->orient_portrait))) {
+ /* Top */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->tmargin));
+ num = self->y + val * self->height / get_paper_psheight (self->papernum);
+ cairo_move_to (ctx, self->x + 2, num);
+ cairo_line_to (ctx, self->x + self->width, num);
+ cairo_stroke (ctx);
+
+ /* Bottom */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->bmargin));
+ num = self->y + self->height -
+ val * self->height / get_paper_psheight (self->papernum);
+ cairo_move_to (ctx, self->x + 2, num);
+ cairo_line_to (ctx, self->x + self->width, num);
+ cairo_stroke (ctx);
+
+ /* Left */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->lmargin));
+ num = self->x + val * self->width / get_paper_pswidth (self->papernum);
+ cairo_move_to (ctx, num + 1, self->y + 1);
+ cairo_line_to (ctx, num + 1, self->y + self->height - 1);
+ cairo_stroke (ctx);
+
+ /* Right */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->rmargin));
+ num = self->x + self->width -
+ val * self->width / get_paper_pswidth (self->papernum);
+ cairo_move_to (ctx, num + 1, self->y + 1);
+ cairo_line_to (ctx, num + 1, self->y + self->height - 1);
+ cairo_stroke (ctx);
+ } else {
+ /* Top */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->tmargin));
+ num = self->y + val * self->height / get_paper_pswidth (self->papernum);
+ cairo_move_to (ctx, self->x + 2, num);
+ cairo_line_to (ctx, self->x + self->width, num);
+ cairo_stroke (ctx);
+
+ /* Bottom */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->bmargin));
+ num = self->y + self->height -
+ val * self->height / get_paper_pswidth (self->papernum);
+ cairo_move_to (ctx, self->x + 2, num);
+ cairo_line_to (ctx, self->x + self->width, num);
+ cairo_stroke (ctx);
+
+ /* Left */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->lmargin));
+ num = self->x + val * self->width / get_paper_psheight (self->papernum);
+ cairo_move_to (ctx, num + 1, self->y + 1);
+ cairo_line_to (ctx, num + 1, self->y + self->height - 1);
+ cairo_stroke (ctx);
+
+ /* Right */
+ val = dia_unit_spinner_get_value (DIA_UNIT_SPINNER (self->rmargin));
+ num = self->x + self->width -
+ val * self->width / get_paper_psheight (self->papernum);
+ cairo_move_to (ctx, num + 1, self->y + 1);
+ cairo_line_to (ctx, num + 1, self->y + self->height - 1);
+ cairo_stroke (ctx);
+ }
+
+ return FALSE;
+}
+
+
+/**
+ * max_margin:
+ * @size: page size
+ *
+ * Given a (page) size calculate the maximum margin size from it
+ *
+ * The function calculation assumes that more than half the size is not useful
+ * for the margin. For safety it allows a little less.
+ */
+static float
+max_margin (float size)
+{
+ return size / 2.0 - 0.5;
+}
+
+
+static void
+paper_size_change (GtkWidget *widget, DiaPageLayout *self)
+{
+ char buf[512];
+ GtkAllocation alloc;
+
+ gtk_widget_get_allocation (self->darea, &alloc);
+
+ self->papernum = dia_option_menu_get_active (DIA_OPTION_MENU (widget));
+ size_page (self, &alloc);
+ gtk_widget_queue_draw (self->darea);
+
+ self->block_changed = TRUE;
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->tmargin),
+ get_paper_tmargin (self->papernum));
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->bmargin),
+ get_paper_bmargin (self->papernum));
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->lmargin),
+ get_paper_lmargin (self->papernum));
+ dia_unit_spinner_set_value (DIA_UNIT_SPINNER (self->rmargin),
+ get_paper_rmargin (self->papernum));
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->orient_portrait))) {
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER (self->tmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->bmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->lmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->rmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ } else {
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER (self->tmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER (self->bmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER (self->lmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER (self->rmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ }
+ self->block_changed = FALSE;
+
+ g_snprintf (buf, sizeof (buf), _("%0.3gcm x %0.3gcm"),
+ get_paper_pswidth (self->papernum),
+ get_paper_psheight (self->papernum));
+ gtk_label_set_text (GTK_LABEL (self->paper_label), buf);
+
+ g_signal_emit (G_OBJECT (self), pl_signals[CHANGED], 0);
+}
+
+
+static void
+orient_changed (DiaPageLayout *self)
+{
+ GtkAllocation alloc;
+
+ gtk_widget_get_allocation (self->darea, &alloc);
+
+ size_page (self, &alloc);
+ gtk_widget_queue_draw (self->darea);
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(self->orient_portrait))) {
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->tmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->bmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->lmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->rmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ } else {
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->tmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->bmargin),
+ max_margin (get_paper_pswidth (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->lmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ dia_unit_spinner_set_upper (DIA_UNIT_SPINNER(self->rmargin),
+ max_margin (get_paper_psheight (self->papernum)));
+ }
+
+ if (!self->block_changed) {
+ g_signal_emit (G_OBJECT (self), pl_signals[CHANGED], 0);
+ }
+}
+
+
+static void
+margin_changed (DiaPageLayout *self)
+{
+ gtk_widget_queue_draw (self->darea);
+ if (!self->block_changed) {
+ g_signal_emit (G_OBJECT(self), pl_signals[CHANGED], 0);
+ }
+}
+
+
+static void
+scalemode_changed (DiaPageLayout *self)
+{
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->fitto))) {
+ gtk_widget_set_sensitive (self->scaling, FALSE);
+ gtk_widget_set_sensitive (self->fitw, TRUE);
+ gtk_widget_set_sensitive (self->fith, TRUE);
+ } else {
+ gtk_widget_set_sensitive (self->scaling, TRUE);
+ gtk_widget_set_sensitive (self->fitw, FALSE);
+ gtk_widget_set_sensitive (self->fith, FALSE);
+ }
+
+ if (!self->block_changed) {
+ g_signal_emit (G_OBJECT (self), pl_signals[CHANGED], 0);
+ }
+}
+
+
+static void
+scale_changed (DiaPageLayout *self)
+{
+ if (!self->block_changed) {
+ g_signal_emit (G_OBJECT (self), pl_signals[CHANGED], 0);
+ }
+}
+
+
+#ifdef PAGELAYOUT_TEST
+
+void
+changed_signal(DiaPageLayout *self)
+{
+ g_message("changed");
+}
+void
+fittopage_signal(DiaPageLayout *self)
+{
+ g_message("fit to page");
+}
+
+void
+main(int argc, char **argv)
+{
+ GtkWidget *win, *pl;
+
+ gtk_init(&argc, &argv);
+
+ win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(win), _("Page Setup"));
+ g_signal_connect(G_OBJECT(win), "destroy",
+ G_CALLBACK(gtk_main_quit), NULL);
+
+ pl = dia_page_layout_new();
+ gtk_container_set_border_width(GTK_CONTAINER(pl), 5);
+ gtk_container_add(GTK_CONTAINER(win), pl);
+ gtk_widget_show(pl);
+
+ g_signal_connect(G_OBJECT(pl), "changed",
+ G_CALLBACK(changed_signal), NULL);
+ g_signal_connect(G_OBJECT(pl), "fittopage",
+ G_CALLBACK(fittopage_signal), NULL);
+
+ gtk_widget_show(win);
+ gtk_main();
+}
+
+#endif
diff --git a/app/dia-page-layout.h b/app/dia-page-layout.h
new file mode 100644
index 00000000..d246e305
--- /dev/null
+++ b/app/dia-page-layout.h
@@ -0,0 +1,92 @@
+/* Dia -- an diagram creation/manipulation program
+ * Copyright (C) 1998, 1999 Alexander Larsson
+ *
+ * diapagelayout.[ch] -- a page settings widget for dia.
+ * Copyright (C) 1999 James Henstridge
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include "dia-autoptr.h"
+#include "dia-app-enums.h"
+
+G_BEGIN_DECLS
+
+
+#define DIA_TYPE_PAGE_LAYOUT dia_page_layout_get_type ()
+G_DECLARE_FINAL_TYPE (DiaPageLayout, dia_page_layout, DIA, PAGE_LAYOUT, GtkTable)
+
+
+/**
+ * DiaPageOrientation:
+ * @DIA_PAGE_ORIENT_PORTRAIT: The page is portrait
+ * @DIA_PAGE_ORIENT_LANDSCAPE: The page is landscape
+ *
+ * Since: dawn-of-time
+ */
+typedef enum /*< enum,prefix=DIA >*/ {
+ DIA_PAGE_ORIENT_PORTRAIT, /*< nick=portrait >*/
+ DIA_PAGE_ORIENT_LANDSCAPE /*< nick=landscape >*/
+} DiaPageOrientation;
+
+
+GtkWidget *dia_page_layout_new (void);
+const char *dia_page_layout_get_paper (DiaPageLayout *pl);
+void dia_page_layout_set_paper (DiaPageLayout *pl,
+ const char *paper);
+void dia_page_layout_get_margins (DiaPageLayout *pl,
+ double *tmargin,
+ double *bmargin,
+ double *lmargin,
+ double *rmargin);
+void dia_page_layout_set_margins (DiaPageLayout *pl,
+ double tmargin,
+ double bmargin,
+ double lmargin,
+ double rmargin);
+DiaPageOrientation dia_page_layout_get_orientation (DiaPageLayout *pl);
+void dia_page_layout_set_orientation (DiaPageLayout *pl,
+ DiaPageOrientation orient);
+gboolean dia_page_layout_get_fitto (DiaPageLayout *self);
+void dia_page_layout_set_fitto (DiaPageLayout *self,
+ gboolean fitto);
+double dia_page_layout_get_scaling (DiaPageLayout *self);
+void dia_page_layout_set_scaling (DiaPageLayout *self,
+ double scaling);
+void dia_page_layout_get_fit_dims (DiaPageLayout *self,
+ int *w,
+ int *h);
+void dia_page_layout_set_fit_dims (DiaPageLayout *self,
+ int w,
+ int h);
+void dia_page_layout_set_changed (DiaPageLayout *self,
+ gboolean changed);
+void dia_page_layout_get_effective_area (DiaPageLayout *self,
+ double *width,
+ double *height);
+
+/* get paper sizes and default margins ... */
+void dia_page_layout_get_paper_size (const char *paper,
+ double *width,
+ double *height);
+void dia_page_layout_get_default_margins (const char *paper,
+ double *tmargin,
+ double *bmargin,
+ double *lmargin,
+ double *rmargin);
diff --git a/app/meson.build b/app/meson.build
index f416cc26..6ee60339 100644
--- a/app/meson.build
+++ b/app/meson.build
@@ -52,7 +52,7 @@ dia_sources = [
'cut_n_paste.c',
'ruler.c',
'tool.c',
- 'diapagelayout.c',
+ 'dia-page-layout.c',
'pagesetup.c',
'filedlg.c',
'find-and-replace.c',
@@ -82,7 +82,8 @@ dia_sources = [
'textedit_tool.c',
]
-sources += gnome.mkenums_simple('dia-app-enums', sources: 'exit_dialog.h')
+dia_sources += gnome.mkenums_simple('dia-app-enums',
+ sources: ['dia-page-layout.h', 'exit_dialog.h'])
#TODO: this is workaround for openbsd where libraries are in /usr/lib/local
# Potential parent issues: https://github.com/mesonbuild/meson/issues/3570
diff --git a/app/pagesetup.c b/app/pagesetup.c
index e5766cc1..ae1a31fc 100644
--- a/app/pagesetup.c
+++ b/app/pagesetup.c
@@ -27,7 +27,7 @@
#include "pagesetup.h"
#include "intl.h"
-#include "diapagelayout.h"
+#include "dia-page-layout.h"
#include "display.h"
typedef struct _PageSetup PageSetup;
@@ -57,7 +57,7 @@ pagesetup_respond (GtkWidget *widget,
}
if (response_id != GTK_RESPONSE_APPLY) {
- g_object_unref (&ps->dia);
+ g_clear_object (&ps->dia);
gtk_widget_destroy(ps->window);
}
@@ -71,9 +71,8 @@ create_page_setup_dlg(Diagram *dia)
PageSetup *ps;
GtkWidget *vbox;
- ps = g_new(PageSetup, 1);
- ps->dia = dia;
- g_object_ref(ps->dia);
+ ps = g_new (PageSetup, 1);
+ ps->dia = g_object_ref (dia);
ps->window = gtk_dialog_new_with_buttons (_("Page Setup"),
GTK_WINDOW (ddisplay_active()->shell),
GTK_DIALOG_DESTROY_WITH_PARENT,
@@ -120,17 +119,20 @@ create_page_setup_dlg(Diagram *dia)
gtk_widget_show(ps->window);
}
+
static void
-pagesetup_changed(GtkWidget *wid, PageSetup *ps)
+pagesetup_changed (GtkWidget *wid, PageSetup *ps)
{
- gfloat dwidth, dheight;
- gfloat pwidth, pheight;
- gfloat xscale, yscale;
- gint fitw = 0, fith = 0;
- gfloat cur_scaling;
+ double dwidth, dheight;
+ double pwidth, pheight;
+ double xscale, yscale;
+ int fitw = 0, fith = 0;
+ double cur_scaling;
/* set sensitivity on apply button */
- gtk_dialog_set_response_sensitive(GTK_DIALOG(ps->window), GTK_RESPONSE_APPLY, TRUE);
+ gtk_dialog_set_response_sensitive (GTK_DIALOG (ps->window),
+ GTK_RESPONSE_APPLY,
+ TRUE);
ps->changed = TRUE;
dwidth = ps->dia->data->extents.right - ps->dia->data->extents.left;
@@ -139,25 +141,25 @@ pagesetup_changed(GtkWidget *wid, PageSetup *ps)
if (dwidth <= 0.0 || dheight <= 0.0)
return;
- dia_page_layout_set_changed (DIA_PAGE_LAYOUT(ps->paper), TRUE);
+ dia_page_layout_set_changed (DIA_PAGE_LAYOUT (ps->paper), TRUE);
- cur_scaling = dia_page_layout_get_scaling(DIA_PAGE_LAYOUT(ps->paper));
- dia_page_layout_get_effective_area(DIA_PAGE_LAYOUT(ps->paper),
- &pwidth, &pheight);
+ cur_scaling = dia_page_layout_get_scaling (DIA_PAGE_LAYOUT (ps->paper));
+ dia_page_layout_get_effective_area (DIA_PAGE_LAYOUT (ps->paper),
+ &pwidth, &pheight);
g_return_if_fail (pwidth > 0.0 && pheight > 0.0);
pwidth *= cur_scaling;
pheight *= cur_scaling;
- if (dia_page_layout_get_fitto(DIA_PAGE_LAYOUT(ps->paper))) {
- dia_page_layout_get_fit_dims(DIA_PAGE_LAYOUT(ps->paper), &fitw, &fith);
+ if (dia_page_layout_get_fitto (DIA_PAGE_LAYOUT (ps->paper))) {
+ dia_page_layout_get_fit_dims (DIA_PAGE_LAYOUT (ps->paper), &fitw, &fith);
xscale = fitw * pwidth / dwidth;
yscale = fith * pheight / dheight;
- dia_page_layout_set_scaling(DIA_PAGE_LAYOUT(ps->paper),
- MIN(xscale, yscale));
+ dia_page_layout_set_scaling (DIA_PAGE_LAYOUT (ps->paper),
+ MIN (xscale, yscale));
} else {
- fitw = ceil(dwidth * cur_scaling / pwidth);
- fith = ceil(dheight * cur_scaling / pheight);
- dia_page_layout_set_fit_dims(DIA_PAGE_LAYOUT(ps->paper), fitw, fith);
+ fitw = ceil (dwidth * cur_scaling / pwidth);
+ fith = ceil (dheight * cur_scaling / pheight);
+ dia_page_layout_set_fit_dims (DIA_PAGE_LAYOUT (ps->paper), fitw, fith);
}
dia_page_layout_set_changed (DIA_PAGE_LAYOUT(ps->paper), FALSE);
diff --git a/docs/dia-app/dia-app-docs.xml b/docs/dia-app/dia-app-docs.xml
index cae5583b..550c38f2 100644
--- a/docs/dia-app/dia-app-docs.xml
+++ b/docs/dia-app/dia-app-docs.xml
@@ -40,7 +40,7 @@
<xi:include href="xml/diagram.xml" />
<xi:include href="xml/diagrid.xml" />
<xi:include href="xml/dia-line-width-area.xml" />
- <xi:include href="xml/diapagelayout.xml" />
+ <xi:include href="xml/dia-page-layout.xml" />
<xi:include href="xml/dia-props.xml" />
<xi:include href="xml/app_procs.xml" />
<xi:include href="xml/disp_callbacks.xml" />
diff --git a/lib/meson.build b/lib/meson.build
index 0e2eda5d..634981e4 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -159,9 +159,13 @@ libdia_sources = stdprop_sources + [
'dia-line-cell-renderer.h',
'dia-simple-list.c',
'dia-simple-list.h',
+ 'dia-autoptr.h',
]
gnome = import('gnome')
+
+libdia_sources += gnome.mkenums_simple('dia-lib-enums', sources: 'units.h')
+
diamarshal = gnome.genmarshal(
'diamarshal',
prefix: 'dia_marshal',
diff --git a/lib/paper.c b/lib/paper.c
index 15ca9574..86cfdd5c 100644
--- a/lib/paper.c
+++ b/lib/paper.c
@@ -28,9 +28,9 @@
* All measurements are in centimetres. */
static const struct _dia_paper_metrics {
- gchar *paper;
- gdouble pswidth, psheight;
- gdouble lmargin, tmargin, rmargin, bmargin;
+ char *paper;
+ double pswidth, psheight;
+ double lmargin, tmargin, rmargin, bmargin;
} paper_metrics[] = {
{ "A0", 84.1, 118.9, 2.8222, 2.8222, 2.8222, 2.8222 },
{ "A1", 59.4, 84.1, 2.8222, 2.8222, 2.8222, 2.8222 },
@@ -69,14 +69,15 @@ static const struct _dia_paper_metrics {
{ NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }
};
+
int
-find_paper(const gchar *name)
+find_paper (const char *name)
{
int i;
if (name == NULL) return -1;
for (i = 0; paper_metrics[i].paper != NULL; i++) {
- if (!g_ascii_strncasecmp(paper_metrics[i].paper, name,
+ if (!g_ascii_strncasecmp(paper_metrics[i].paper, name,
strlen(paper_metrics[i].paper)))
break;
}
@@ -135,11 +136,11 @@ get_paper_info(PaperInfo *paper, int i, NewDiagramData *prefs)
paper->fitto = FALSE;
paper->fitwidth = 1;
paper->fitheight = 1;
- paper->width = paper_metrics[i].pswidth -
- paper_metrics[i].lmargin -
+ paper->width = paper_metrics[i].pswidth -
+ paper_metrics[i].lmargin -
paper_metrics[i].rmargin;
- paper->height = paper_metrics[i].psheight -
- paper_metrics[i].tmargin -
+ paper->height = paper_metrics[i].psheight -
+ paper_metrics[i].tmargin -
paper_metrics[i].bmargin;
if (!paper->is_portrait) {
double tmp = paper->width;
@@ -163,12 +164,14 @@ get_paper_name_list(void)
return name_list;
}
-const gchar *
-get_paper_name(int i)
+
+const char *
+dia_paper_get_name (int i)
{
return paper_metrics[i].paper;
}
+
gdouble
get_paper_psheight(int i)
{
diff --git a/lib/paper.h b/lib/paper.h
index 5c65cf14..5f141090 100644
--- a/lib/paper.h
+++ b/lib/paper.h
@@ -16,36 +16,57 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-#ifndef PAPER_H
-#define PAPER_H
+#pragma once
#include <glib.h>
#include <diatypes.h>
-struct _PaperInfo {
- gchar *name; /* name of the paper */
- gfloat tmargin, bmargin, lmargin, rmargin; /* margin widths in centimeters */
- gboolean is_portrait; /* page is in portrait orientation? */
- gfloat scaling; /* scaling factor for image on page */
- gboolean fitto; /* if we want to use the fitto mode for scaling */
- gint fitwidth, fitheight; /* how many pages in each direction */
- gfloat width, height; /* usable width/height -- calculated from paper type,
- * margin widths and paper orientation; the real paper
- * size is width*scaling, height*scaling */
+/**
+ * PaperInfo:
+ * @name: name of the paper
+ * @tmargin: margin widths in %DIA_UNIT_CENTIMETER
+ * @bmargin: "
+ * @lmargin: "
+ * @rmargin: "
+ * @is_portrait: page is in portrait orientation?
+ * @scaling: scaling factor for image on page
+ * @fitto: if we want to use the fitto mode for scaling
+ * @fitwidth: how many pages in each direction
+ * @fitheight: "
+ * @width: usable width/height -- calculated from paper type,
+ * margin widths and paper orientation; the real paper
+ * size is width*scaling, height*scaling
+ * @height: "
+ *
+ * Since: dawn-of-time
+ */
+struct _PaperInfo {
+ char *name;
+ double tmargin;
+ double bmargin;
+ double lmargin;
+ double rmargin;
+ gboolean is_portrait;
+ double scaling;
+ gboolean fitto;
+ int fitwidth;
+ int fitheight;
+ double width;
+ double height;
};
-int find_paper(const gchar* name);
-int get_default_paper(void);
-void get_paper_info(PaperInfo *paper, int i, NewDiagramData *data);
-
-GList *get_paper_name_list(void);
-const gchar *get_paper_name(int i);
-gdouble get_paper_psheight(int i);
-gdouble get_paper_pswidth(int i);
-gdouble get_paper_lmargin(int i);
-gdouble get_paper_rmargin(int i);
-gdouble get_paper_bmargin(int i);
-gdouble get_paper_tmargin(int i);
-#endif
+int find_paper (const char *name);
+int get_default_paper (void);
+void get_paper_info (PaperInfo *paper,
+ int i,
+ NewDiagramData *data);
+GList *get_paper_name_list (void);
+const char *dia_paper_get_name (int i);
+double get_paper_psheight (int i);
+double get_paper_pswidth (int i);
+double get_paper_lmargin (int i);
+double get_paper_rmargin (int i);
+double get_paper_bmargin (int i);
+double get_paper_tmargin (int i);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
