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