app/diapagelayout.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1998, 1999 Alexander Larsson
   3  *
   4  * diapagelayout.[ch] -- a page settings widget for dia.
   5  * Copyright (C) 1999 James Henstridge
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*#define PAGELAYOUT_TEST*/
  23
  24 #include "diapagelayout.h"
  25 #include "diaunitspinner.h"
  26
  27 #include "intl.h"
  28
  29 #include "pixmaps/portrait.xpm"
  30 #include "pixmaps/landscape.xpm"
  31
  32 #include "paper.h"
  33
  34 enum {
  35   CHANGED,
  36   LAST_SIGNAL
  37 };
  38
  39 static guint pl_signals[LAST_SIGNAL] = { 0 };
  40 static GtkObjectClass *parent_class;
  41
  42 static void dia_page_layout_class_init(DiaPageLayoutClass *class);
  43 static void dia_page_layout_init(DiaPageLayout *self);
  44 static void dia_page_layout_destroy(GtkObject *object);
  45
  46 GtkType
  47 dia_page_layout_get_type(void)
  48 {
  49   static GtkType pl_type = 0;
  50
  51   if (!pl_type) {
  52     GtkTypeInfo pl_info = {
  53       "DiaPageLayout",
  54       sizeof(DiaPageLayout),
  55       sizeof(DiaPageLayoutClass),
  56       (GtkClassInitFunc) dia_page_layout_class_init,
  57       (GtkObjectInitFunc) dia_page_layout_init,
  58       (GtkArgSetFunc) NULL,
  59       (GtkArgGetFunc) NULL
  60     };
  61     pl_type = gtk_type_unique(gtk_table_get_type(), &pl_info);
  62   }
  63   return pl_type;
  64 }
  65
  66 static void
  67 dia_page_layout_class_init(DiaPageLayoutClass *class)
  68 {
  69   GtkObjectClass *object_class;
  70
  71   object_class = (GtkObjectClass*) class;
  72   parent_class = gtk_type_class(gtk_table_get_type());
  73
  74   pl_signals[CHANGED] =
  75     gtk_signal_new("changed",
  76                    GTK_RUN_FIRST,
  77                    object_class->type,
  78                    GTK_SIGNAL_OFFSET(DiaPageLayoutClass, changed),
  79                    gtk_signal_default_marshaller,
  80                    GTK_TYPE_NONE, 0);
  81   gtk_object_class_add_signals(object_class, pl_signals, LAST_SIGNAL);
  82
  83   object_class->destroy = dia_page_layout_destroy;
  84 }
  85
  86 static void darea_size_allocate(DiaPageLayout *self, GtkAllocation *alloc);
  87 static gint darea_expose_event(DiaPageLayout *self, GdkEventExpose *ev);
  88 static void paper_size_change(GtkMenuItem *item, DiaPageLayout *self);
  89 static void orient_changed(DiaPageLayout *self);
  90 static void margin_changed(DiaPageLayout *self);
  91 static void scalemode_changed(DiaPageLayout *self);
  92 static void scale_changed(DiaPageLayout *self);
  93
  94 static void
  95 dia_page_layout_init(DiaPageLayout *self)
  96 {
  97   GtkWidget *frame, *box, *table, *menu, *menuitem, *wid;
  98   GdkPixmap *pix;
  99   GdkBitmap *mask;
 100   GList *paper_names;
 101   gint i;
 102
 103   gtk_table_resize(GTK_TABLE(self), 3, 2);
 104   gtk_table_set_row_spacings(GTK_TABLE(self), 5);
 105   gtk_table_set_col_spacings(GTK_TABLE(self), 5);
 106
 107   /* paper size */
 108   frame = gtk_frame_new(_("Paper Size"));
 109   gtk_table_attach(GTK_TABLE(self), frame, 0,1, 0,1,
 110                    GTK_FILL, GTK_FILL, 0, 0);
 111   gtk_widget_show(frame);
 112
 113   box = gtk_vbox_new(FALSE, 5);
 114   gtk_container_set_border_width(GTK_CONTAINER(box), 5);
 115   gtk_container_add(GTK_CONTAINER(frame), box);
 116   gtk_widget_show(box);
 117
 118   self->paper_size = gtk_option_menu_new();
 119   gtk_box_pack_start(GTK_BOX(box), self->paper_size, TRUE, FALSE, 0);
 120
 121   menu = gtk_menu_new();
 122
 123   paper_names = get_paper_name_list();
 124   for (i = 0; paper_names != NULL;
 125        i++, paper_names = g_list_next(paper_names)) {
 126     menuitem = gtk_menu_item_new_with_label(paper_names->data);
 127     gtk_object_set_user_data(GTK_OBJECT(menuitem), GINT_TO_POINTER(i));
 128     gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 129                        GTK_SIGNAL_FUNC(paper_size_change), self);
 130     gtk_container_add(GTK_CONTAINER(menu), menuitem);
 131     gtk_widget_show(menuitem);
 132   }
 133   gtk_option_menu_set_menu(GTK_OPTION_MENU(self->paper_size), menu);
 134   gtk_widget_show(self->paper_size);
 135
 136   self->paper_label = gtk_label_new("");
 137   gtk_box_pack_start(GTK_BOX(box), self->paper_label, TRUE, TRUE, 0);
 138   gtk_widget_show(self->paper_label);
 139
 140   /* orientation */
 141   frame = gtk_frame_new(_("Orientation"));
 142   gtk_table_attach(GTK_TABLE(self), frame, 1,2, 0,1,
 143                    GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 144   gtk_widget_show(frame);
 145
 146   box = gtk_hbox_new(FALSE, 5);
 147   gtk_container_set_border_width(GTK_CONTAINER(box), 5);
 148   gtk_container_add(GTK_CONTAINER(frame), box);
 149   gtk_widget_show(box);
 150
 151   self->orient_portrait = gtk_radio_button_new(NULL);
 152   pix = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 153                 gtk_widget_get_colormap(GTK_WIDGET(self)), &mask, NULL,
 154                 portrait_xpm);
 155   wid = gtk_pixmap_new(pix, mask);
 156   gdk_pixmap_unref(pix);
 157   gdk_bitmap_unref(mask);
 158   gtk_container_add(GTK_CONTAINER(self->orient_portrait), wid);
 159   gtk_widget_show(wid);
 160
 161   gtk_box_pack_start(GTK_BOX(box), self->orient_portrait, TRUE, TRUE, 0);
 162   gtk_widget_show(self->orient_portrait);
 163
 164   self->orient_landscape = gtk_radio_button_new(
 165         gtk_radio_button_group(GTK_RADIO_BUTTON(self->orient_portrait)));
 166   pix = gdk_pixmap_colormap_create_from_xpm_d(NULL,
 167                 gtk_widget_get_colormap(GTK_WIDGET(self)), &mask, NULL,
 168                 landscape_xpm);
 169   wid = gtk_pixmap_new(pix, mask);
 170   gdk_pixmap_unref(pix);
 171   gdk_bitmap_unref(mask);
 172   gtk_container_add(GTK_CONTAINER(self->orient_landscape), wid);
 173   gtk_widget_show(wid);
 174
 175   gtk_box_pack_start(GTK_BOX(box), self->orient_landscape, TRUE, TRUE, 0);
 176   gtk_widget_show(self->orient_landscape);
 177
 178   /* margins */
 179   frame = gtk_frame_new(_("Margins"));
 180   gtk_table_attach(GTK_TABLE(self), frame, 0,1, 1,2,
 181                    GTK_FILL, GTK_FILL, 0, 0);
 182   gtk_widget_show(frame);
 183
 184   table = gtk_table_new(4, 2, FALSE);
 185   gtk_container_set_border_width(GTK_CONTAINER(table), 5);
 186   gtk_table_set_row_spacings(GTK_TABLE(table), 5);
 187   gtk_table_set_col_spacings(GTK_TABLE(table), 5);
 188   gtk_container_add(GTK_CONTAINER(frame), table);
 189   gtk_widget_show(table);
 190
 191   wid = gtk_label_new(_("Top:"));
 192   gtk_misc_set_alignment(GTK_MISC(wid), 1.0, 0.5);
 193   gtk_table_attach(GTK_TABLE(table), wid, 0,1, 0,1,
 194                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 195   gtk_widget_show(wid);
 196
 197   self->tmargin = dia_unit_spinner_new(
 198         GTK_ADJUSTMENT(gtk_adjustment_new(1, 0,100, 0.1,10,10)),
 199         2, DIA_UNIT_CENTIMETER);
 200   gtk_table_attach(GTK_TABLE(table), self->tmargin, 1,2, 0,1,
 201                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 202   gtk_widget_show(self->tmargin);
 203
 204   wid = gtk_label_new(_("Bottom:"));
 205   gtk_misc_set_alignment(GTK_MISC(wid), 1.0, 0.5);
 206   gtk_table_attach(GTK_TABLE(table), wid, 0,1, 1,2,
 207                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 208   gtk_widget_show(wid);
 209
 210   self->bmargin = dia_unit_spinner_new(
 211         GTK_ADJUSTMENT(gtk_adjustment_new(1, 0,100, 0.1,10,10)),
 212         2, DIA_UNIT_CENTIMETER);
 213   gtk_table_attach(GTK_TABLE(table), self->bmargin, 1,2, 1,2,
 214                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 215   gtk_widget_show(self->bmargin);
 216
 217   wid = gtk_label_new(_("Left:"));
 218   gtk_misc_set_alignment(GTK_MISC(wid), 1.0, 0.5);
 219   gtk_table_attach(GTK_TABLE(table), wid, 0,1, 2,3,
 220                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 221   gtk_widget_show(wid);
 222
 223   self->lmargin = dia_unit_spinner_new(
 224         GTK_ADJUSTMENT(gtk_adjustment_new(1, 0,100, 0.1,10,10)),
 225         2, DIA_UNIT_CENTIMETER);
 226   gtk_table_attach(GTK_TABLE(table), self->lmargin, 1,2, 2,3,
 227                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 228   gtk_widget_show(self->lmargin);
 229
 230   wid = gtk_label_new(_("Right:"));
 231   gtk_misc_set_alignment(GTK_MISC(wid), 1.0, 0.5);
 232   gtk_table_attach(GTK_TABLE(table), wid, 0,1, 3,4,
 233                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 234   gtk_widget_show(wid);
 235
 236   self->rmargin = dia_unit_spinner_new(
 237         GTK_ADJUSTMENT(gtk_adjustment_new(1, 0,100, 0.1,10,10)),
 238         2, DIA_UNIT_CENTIMETER);
 239   gtk_table_attach(GTK_TABLE(table), self->rmargin, 1,2, 3,4,
 240                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 241   gtk_widget_show(self->rmargin);
 242
 243   /* Scaling */
 244   frame = gtk_frame_new(_("Scaling"));
 245   gtk_table_attach(GTK_TABLE(self), frame, 0,1, 2,3,
 246                    GTK_FILL, GTK_FILL, 0, 0);
 247   gtk_widget_show(frame);
 248
 249   table = gtk_table_new(2, 4, FALSE);
 250   gtk_container_set_border_width(GTK_CONTAINER(table), 5);
 251   gtk_table_set_row_spacings(GTK_TABLE(table), 5);
 252   gtk_container_add(GTK_CONTAINER(frame), table);
 253   gtk_widget_show(table);
 254
 255   self->scale = gtk_radio_button_new_with_label(NULL, _("Scale:"));
 256   gtk_table_attach(GTK_TABLE(table), self->scale, 0,1, 0,1,
 257                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 258   gtk_widget_show(self->scale);
 259
 260   self->scaling = gtk_spin_button_new(
 261         GTK_ADJUSTMENT(gtk_adjustment_new(100,1,10000, 1,10,10)), 1, 1);
 262   gtk_table_attach(GTK_TABLE(table), self->scaling, 1,4, 0,1,
 263                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 264   gtk_widget_show(self->scaling);
 265
 266   self->fitto = gtk_radio_button_new_with_label(
 267                         GTK_RADIO_BUTTON(self->scale)->group, _("Fit to:"));
 268   gtk_table_attach(GTK_TABLE(table), self->fitto, 0,1, 1,2,
 269                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 270   gtk_widget_show(self->fitto);
 271
 272   self->fitw = gtk_spin_button_new(
 273         GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 1000, 1, 10, 10)), 1, 0);
 274   gtk_widget_set_sensitive(self->fitw, FALSE);
 275   gtk_table_attach(GTK_TABLE(table), self->fitw, 1,2, 1,2,
 276                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 277   gtk_widget_show(self->fitw);
 278
 279   wid = gtk_label_new(_("by"));
 280   gtk_misc_set_padding(GTK_MISC(wid), 5, 0);
 281   gtk_table_attach(GTK_TABLE(table), wid, 2,3, 1,2,
 282                    GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 283   gtk_widget_show(wid);
 284
 285   self->fith = gtk_spin_button_new(
 286         GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 1000, 1, 10, 10)), 1, 0);
 287   gtk_widget_set_sensitive(self->fith, FALSE);
 288   gtk_table_attach(GTK_TABLE(table), self->fith, 3,4, 1,2,
 289                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 290   gtk_widget_show(self->fith);
 291
 292   /* the drawing area */
 293   self->darea = gtk_drawing_area_new();
 294   gtk_table_attach(GTK_TABLE(self), self->darea, 1,2, 1,3,
 295                    GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 296   gtk_widget_show(self->darea);
 297
 298   /* connect the signal handlers */
 299   gtk_signal_connect_object(GTK_OBJECT(self->orient_portrait), "toggled",
 300                             GTK_SIGNAL_FUNC(orient_changed), GTK_OBJECT(self));
 301
 302   gtk_signal_connect_object(GTK_OBJECT(self->tmargin), "changed",
 303                             GTK_SIGNAL_FUNC(margin_changed), GTK_OBJECT(self));
 304   gtk_signal_connect_object(GTK_OBJECT(self->bmargin), "changed",
 305                             GTK_SIGNAL_FUNC(margin_changed), GTK_OBJECT(self));
 306   gtk_signal_connect_object(GTK_OBJECT(self->lmargin), "changed",
 307                             GTK_SIGNAL_FUNC(margin_changed), GTK_OBJECT(self));
 308   gtk_signal_connect_object(GTK_OBJECT(self->rmargin), "changed",
 309                             GTK_SIGNAL_FUNC(margin_changed), GTK_OBJECT(self));
 310
 311   gtk_signal_connect_object(GTK_OBJECT(self->fitto), "toggled",
 312                             GTK_SIGNAL_FUNC(scalemode_changed),
 313                             GTK_OBJECT(self));
 314   gtk_signal_connect_object(GTK_OBJECT(self->scaling), "changed",
 315                             GTK_SIGNAL_FUNC(scale_changed), GTK_OBJECT(self));
 316   gtk_signal_connect_object(GTK_OBJECT(self->fitw), "changed",
 317                             GTK_SIGNAL_FUNC(scale_changed), GTK_OBJECT(self));
 318   gtk_signal_connect_object(GTK_OBJECT(self->fith), "changed",
 319                             GTK_SIGNAL_FUNC(scale_changed), GTK_OBJECT(self));
 320
 321   gtk_signal_connect_object(GTK_OBJECT(self->darea), "size_allocate",
 322                             GTK_SIGNAL_FUNC(darea_size_allocate),
 323                             GTK_OBJECT(self));
 324   gtk_signal_connect_object(GTK_OBJECT(self->darea), "expose_event",
 325                             GTK_SIGNAL_FUNC(darea_expose_event),
 326                             GTK_OBJECT(self));
 327
 328   gdk_color_white(gtk_widget_get_colormap(GTK_WIDGET(self)), &self->white);
 329   gdk_color_black(gtk_widget_get_colormap(GTK_WIDGET(self)), &self->black);
 330   self->blue.red = 0;
 331   self->blue.green = 0;
 332   self->blue.blue = 0x7fff;
 333   gdk_color_alloc(gtk_widget_get_colormap(GTK_WIDGET(self)), &self->blue);
 334
 335   self->gc = NULL;
 336   self->block_changed = FALSE;
 337 }
 338
 339 GtkWidget *
 340 dia_page_layout_new(void)
 341 {
 342   DiaPageLayout *self = gtk_type_new(dia_page_layout_get_type());
 343
 344   dia_page_layout_set_paper(self, "");
 345   return GTK_WIDGET(self);
 346 }
 347
 348 const gchar *
 349 dia_page_layout_get_paper(DiaPageLayout *self)
 350 {
 351   return get_paper_name(self->papernum);
 352 }
 353
 354 void
 355 dia_page_layout_set_paper(DiaPageLayout *self, const gchar *paper)
 356 {
 357   gint i;
 358
 359   i = find_paper(paper);
 360   if (i == -1)
 361     i = get_default_paper();
 362   gtk_option_menu_set_history(GTK_OPTION_MENU(self->paper_size), i);
 363   gtk_menu_item_activate(
 364         GTK_MENU_ITEM(GTK_OPTION_MENU(self->paper_size)->menu_item));
 365 }
 366
 367 void
 368 dia_page_layout_get_margins(DiaPageLayout *self,
 369                             gfloat *tmargin, gfloat *bmargin,
 370                             gfloat *lmargin, gfloat *rmargin)
 371 {
 372   if (tmargin)
 373     *tmargin = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->tmargin));
 374   if (bmargin)
 375     *bmargin = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->bmargin));
 376   if (lmargin)
 377     *lmargin = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->lmargin));
 378   if (rmargin)
 379     *rmargin = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->rmargin));
 380 }
 381
 382 void
 383 dia_page_layout_set_margins(DiaPageLayout *self,
 384                             gfloat tmargin, gfloat bmargin,
 385                             gfloat lmargin, gfloat rmargin)
 386 {
 387   self->block_changed = TRUE;
 388   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->tmargin), tmargin);
 389   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->bmargin), bmargin);
 390   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->lmargin), lmargin);
 391   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->rmargin), rmargin);
 392   self->block_changed = FALSE;
 393
 394   gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 395 }
 396
 397 DiaPageOrientation
 398 dia_page_layout_get_orientation(DiaPageLayout *self)
 399 {
 400   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active)
 401     return DIA_PAGE_ORIENT_PORTRAIT;
 402   else
 403     return DIA_PAGE_ORIENT_LANDSCAPE;
 404 }
 405
 406 void
 407 dia_page_layout_set_orientation(DiaPageLayout *self,
 408                                 DiaPageOrientation orient)
 409 {
 410   switch (orient) {
 411   case DIA_PAGE_ORIENT_PORTRAIT:
 412     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->orient_portrait),
 413                                  TRUE);
 414     break;
 415   case DIA_PAGE_ORIENT_LANDSCAPE:
 416     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->orient_landscape),
 417                                  TRUE);
 418     break;
 419   }
 420 }
 421
 422 gboolean
 423 dia_page_layout_get_fitto(DiaPageLayout *self)
 424 {
 425   return GTK_TOGGLE_BUTTON(self->fitto)->active;
 426 }
 427
 428 void
 429 dia_page_layout_set_fitto(DiaPageLayout *self, gboolean fitto)
 430 {
 431   if (fitto)
 432     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->fitto), TRUE);
 433   else
 434     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->scale), TRUE);
 435 }
 436
 437 gfloat
 438 dia_page_layout_get_scaling(DiaPageLayout *self)
 439 {
 440   return GTK_SPIN_BUTTON(self->scaling)->adjustment->value / 100.0;
 441 }
 442
 443 void
 444 dia_page_layout_set_scaling(DiaPageLayout *self, gfloat scaling)
 445 {
 446   GTK_SPIN_BUTTON(self->scaling)->adjustment->value = scaling * 100.0;
 447   gtk_adjustment_value_changed(GTK_SPIN_BUTTON(self->scaling)->adjustment);
 448 }
 449
 450 void
 451 dia_page_layout_get_fit_dims(DiaPageLayout *self, gint *w, gint *h)
 452 {
 453   if (w)
 454     *w = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(self->fitw));
 455   if (h)
 456     *h = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(self->fith));
 457 }
 458
 459 void
 460 dia_page_layout_set_fit_dims(DiaPageLayout *self, gint w, gint h)
 461 {
 462   gtk_spin_button_set_value(GTK_SPIN_BUTTON(self->fitw), w);
 463   gtk_spin_button_set_value(GTK_SPIN_BUTTON(self->fith), h);
 464 }
 465
 466 void
 467 dia_page_layout_get_effective_area(DiaPageLayout *self, gfloat *width,
 468                                    gfloat *height)
 469 {
 470   gfloat h, w, scaling;
 471
 472   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active) {
 473     w = get_paper_pswidth(self->papernum);
 474     h = get_paper_psheight(self->papernum);
 475   } else {
 476     h = get_paper_pswidth(self->papernum);
 477     w = get_paper_psheight(self->papernum);
 478   }
 479   h -= dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->tmargin));
 480   h -= dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->bmargin));
 481   w -= dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->lmargin));
 482   w -= dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->rmargin));
 483   scaling = GTK_SPIN_BUTTON(self->scaling)->adjustment->value / 100.0;
 484   h /= scaling;
 485   w /= scaling;
 486
 487   if (width)  *width = w;
 488   if (height) *height = h;
 489 }
 490
 491 void
 492 dia_page_layout_get_paper_size(const gchar *paper,
 493                                gfloat *width, gfloat *height)
 494 {
 495   gint i;
 496
 497   i = find_paper(paper);
 498   if (i == -1)
 499     i = get_default_paper();
 500   if (width)
 501     *width = get_paper_pswidth(i);
 502   if (height)
 503     *height = get_paper_psheight(i);
 504 }
 505
 506 void
 507 dia_page_layout_get_default_margins(const gchar *paper,
 508                                     gfloat *tmargin, gfloat *bmargin,
 509                                     gfloat *lmargin, gfloat *rmargin)
 510 {
 511   gint i;
 512
 513   i = find_paper(paper);
 514   if (i == -1)
 515     i = get_default_paper();
 516   if (tmargin)
 517     *tmargin = get_paper_tmargin(i);
 518   if (bmargin)
 519     *bmargin = get_paper_bmargin(i);
 520   if (lmargin)
 521     *lmargin = get_paper_lmargin(i);
 522   if (rmargin)
 523     *rmargin = get_paper_rmargin(i);
 524 }
 525
 526 static void
 527 size_page(DiaPageLayout *self, GtkAllocation *a)
 528 {
 529   self->width = a->width - 3;
 530   self->height = a->height - 3;
 531
 532   /* change to correct metrics */
 533   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active) {
 534     if (self->width * get_paper_psheight(self->papernum) >
 535         self->height * get_paper_pswidth(self->papernum))
 536       self->width = self->height * get_paper_pswidth(self->papernum) /
 537         get_paper_psheight(self->papernum);
 538     else
 539       self->height = self->width * get_paper_psheight(self->papernum) /
 540         get_paper_pswidth(self->papernum);
 541   } else {
 542     if (self->width * get_paper_pswidth(self->papernum) >
 543         self->height * get_paper_psheight(self->papernum))
 544       self->width = self->height * get_paper_psheight(self->papernum) /
 545         get_paper_pswidth(self->papernum);
 546     else
 547       self->height = self->width * get_paper_pswidth(self->papernum) /
 548         get_paper_psheight(self->papernum);
 549   }
 550
 551   self->x = (a->width - self->width - 3) / 2;
 552   self->y = (a->height - self->height - 3) / 2;
 553 }
 554
 555 static void
 556 darea_size_allocate(DiaPageLayout *self, GtkAllocation *allocation)
 557 {
 558   size_page(self, allocation);
 559 }
 560
 561 static gint
 562 darea_expose_event(DiaPageLayout *self, GdkEventExpose *event)
 563 {
 564   GdkWindow *window= self->darea->window;
 565   gfloat val;
 566   gint num;
 567
 568   if (!window)
 569     return FALSE;
 570
 571   if (!self->gc)
 572     self->gc = gdk_gc_new(window);
 573
 574   gdk_window_clear_area (window,
 575                          0, 0,
 576                          self->darea->allocation.width,
 577                          self->darea->allocation.height);
 578
 579   /* draw the page image */
 580   gdk_gc_set_foreground(self->gc, &self->black);
 581   gdk_draw_rectangle(window, self->gc, TRUE, self->x+3, self->y+3,
 582                      self->width, self->height);
 583   gdk_gc_set_foreground(self->gc, &self->white);
 584   gdk_draw_rectangle(window, self->gc, TRUE, self->x, self->y,
 585                      self->width, self->height);
 586   gdk_gc_set_foreground(self->gc, &self->black);
 587   gdk_draw_rectangle(window, self->gc, FALSE, self->x, self->y,
 588                      self->width-1, self->height-1);
 589
 590   gdk_gc_set_foreground(self->gc, &self->blue);
 591
 592   /* draw margins */
 593   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active) {
 594     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->tmargin));
 595     num = self->y + val * self->height /get_paper_psheight(self->papernum);
 596     gdk_draw_line(window, self->gc, self->x+1, num, self->x+self->width-2,num);
 597
 598     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->bmargin));
 599     num = self->y + self->height -
 600       val * self->height / get_paper_psheight(self->papernum);
 601     gdk_draw_line(window, self->gc, self->x+1, num, self->x+self->width-2,num);
 602
 603     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->lmargin));
 604     num = self->x + val * self->width / get_paper_pswidth(self->papernum);
 605     gdk_draw_line(window, self->gc, num, self->y+1,num,self->y+self->height-2);
 606
 607     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->rmargin));
 608     num = self->x + self->width -
 609       val * self->width / get_paper_pswidth(self->papernum);
 610     gdk_draw_line(window, self->gc, num, self->y+1,num,self->y+self->height-2);
 611   } else {
 612     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->tmargin));
 613     num = self->y + val * self->height /get_paper_pswidth(self->papernum);
 614     gdk_draw_line(window, self->gc, self->x+1, num, self->x+self->width-2,num);
 615
 616     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->bmargin));
 617     num = self->y + self->height -
 618       val * self->height / get_paper_pswidth(self->papernum);
 619     gdk_draw_line(window, self->gc, self->x+1, num, self->x+self->width-2,num);
 620
 621     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->lmargin));
 622     num = self->x + val * self->width / get_paper_psheight(self->papernum);
 623     gdk_draw_line(window, self->gc, num, self->y+1,num,self->y+self->height-2);
 624
 625     val = dia_unit_spinner_get_value(DIA_UNIT_SPINNER(self->rmargin));
 626     num = self->x + self->width -
 627       val * self->width / get_paper_psheight(self->papernum);
 628     gdk_draw_line(window, self->gc, num, self->y+1,num,self->y+self->height-2);
 629   }
 630
 631   return FALSE;
 632 }
 633
 634 static void
 635 paper_size_change(GtkMenuItem *item, DiaPageLayout *self)
 636 {
 637   gchar buf[512];
 638
 639   self->papernum = GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(item)));
 640   size_page(self, &self->darea->allocation);
 641   gtk_widget_queue_draw(self->darea);
 642
 643   self->block_changed = TRUE;
 644   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->tmargin),
 645                              get_paper_tmargin(self->papernum));
 646   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->bmargin),
 647                              get_paper_bmargin(self->papernum));
 648   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->lmargin),
 649                              get_paper_lmargin(self->papernum));
 650   dia_unit_spinner_set_value(DIA_UNIT_SPINNER(self->rmargin),
 651                              get_paper_rmargin(self->papernum));
 652
 653   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active) {
 654     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->tmargin))->upper =
 655       get_paper_psheight(self->papernum);
 656     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->bmargin))->upper =
 657       get_paper_psheight(self->papernum);
 658     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->lmargin))->upper =
 659       get_paper_pswidth(self->papernum);
 660     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->rmargin))->upper =
 661       get_paper_pswidth(self->papernum);
 662   } else {
 663     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->tmargin))->upper =
 664       get_paper_pswidth(self->papernum);
 665     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->bmargin))->upper =
 666       get_paper_pswidth(self->papernum);
 667     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->lmargin))->upper =
 668       get_paper_psheight(self->papernum);
 669     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->rmargin))->upper =
 670       get_paper_psheight(self->papernum);
 671   }
 672   self->block_changed = FALSE;
 673
 674   g_snprintf(buf, sizeof(buf), _("%0.3gcm x %0.3gcm"),
 675              get_paper_pswidth(self->papernum),
 676              get_paper_psheight(self->papernum));
 677   gtk_label_set(GTK_LABEL(self->paper_label), buf);
 678
 679   gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 680 }
 681
 682 static void
 683 orient_changed(DiaPageLayout *self)
 684 {
 685   size_page(self, &self->darea->allocation);
 686   gtk_widget_queue_draw(self->darea);
 687
 688   if (GTK_TOGGLE_BUTTON(self->orient_portrait)->active) {
 689     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->tmargin))->upper =
 690       get_paper_psheight(self->papernum);
 691     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->bmargin))->upper =
 692       get_paper_psheight(self->papernum);
 693     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->lmargin))->upper =
 694       get_paper_pswidth(self->papernum);
 695     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->rmargin))->upper =
 696       get_paper_pswidth(self->papernum);
 697   } else {
 698     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->tmargin))->upper =
 699       get_paper_pswidth(self->papernum);
 700     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->bmargin))->upper =
 701       get_paper_pswidth(self->papernum);
 702     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->lmargin))->upper =
 703       get_paper_psheight(self->papernum);
 704     gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(self->rmargin))->upper =
 705       get_paper_psheight(self->papernum);
 706   }
 707
 708   if (!self->block_changed)
 709     gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 710 }
 711
 712 static void
 713 margin_changed(DiaPageLayout *self)
 714 {
 715   gtk_widget_queue_draw(self->darea);
 716   if (!self->block_changed)
 717     gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 718 }
 719
 720 static void
 721 scalemode_changed(DiaPageLayout *self)
 722 {
 723   if (GTK_TOGGLE_BUTTON(self->fitto)->active) {
 724     gtk_widget_set_sensitive(self->scaling, FALSE);
 725     gtk_widget_set_sensitive(self->fitw, TRUE);
 726     gtk_widget_set_sensitive(self->fith, TRUE);
 727   } else {
 728     gtk_widget_set_sensitive(self->scaling, TRUE);
 729     gtk_widget_set_sensitive(self->fitw, FALSE);
 730     gtk_widget_set_sensitive(self->fith, FALSE);
 731   }
 732   if (!self->block_changed)
 733     gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 734 }
 735
 736 static void
 737 scale_changed(DiaPageLayout *self)
 738 {
 739   if (!self->block_changed)
 740     gtk_signal_emit(GTK_OBJECT(self), pl_signals[CHANGED]);
 741 }
 742
 743 static void
 744 dia_page_layout_destroy(GtkObject *object)
 745 {
 746   DiaPageLayout *self = DIA_PAGE_LAYOUT(object);
 747
 748   if (self->gc)
 749     gdk_gc_unref(self->gc);
 750
 751   if (parent_class->destroy)
 752     (* parent_class->destroy)(object);
 753 }
 754
 755 #ifdef PAGELAYOUT_TEST
 756
 757 void
 758 changed_signal(DiaPageLayout *self)
 759 {
 760   g_message("changed");
 761 }
 762 void
 763 fittopage_signal(DiaPageLayout *self)
 764 {
 765   g_message("fit to page");
 766 }
 767
 768 void
 769 main(int argc, char **argv)
 770 {
 771   GtkWidget *win, *pl;
 772
 773   gtk_init(&argc, &argv);
 774
 775   win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 776   gtk_window_set_title(GTK_WINDOW(win), _("Page Setup"));
 777   gtk_signal_connect(GTK_OBJECT(win), "destroy",
 778                      GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
 779
 780   pl = dia_page_layout_new();
 781   gtk_container_set_border_width(GTK_CONTAINER(pl), 5);
 782   gtk_container_add(GTK_CONTAINER(win), pl);
 783   gtk_widget_show(pl);
 784
 785   gtk_signal_connect(GTK_OBJECT(pl), "changed",
 786                      GTK_SIGNAL_FUNC(changed_signal), NULL);
 787   gtk_signal_connect(GTK_OBJECT(pl), "fittopage",
 788                      GTK_SIGNAL_FUNC(fittopage_signal), NULL);
 789
 790   gtk_widget_show(win);
 791   gtk_main();
 792 }
 793
 794 #endif