Pileus Git - ~andy/gtk/blob - tests/print-editor.c

   1 #include <math.h>
   2 #include <pango/pangocairo.h>
   3 #include <gtk/gtk.h>
   4
   5 static GtkWidget *main_window;
   6 static char *filename = NULL;
   7 static GtkPageSetup *page_setup = NULL;
   8 static GtkPrintSettings *settings = NULL;
   9 static gboolean file_changed = FALSE;
  10 static GtkTextBuffer *buffer;
  11 static GtkWidget *statusbar;
  12 static GList *active_prints = NULL;
  13
  14 static void
  15 update_title (void)
  16 {
  17   char *basename;
  18   char *title;
  19
  20   if (filename == NULL)
  21     basename = g_strdup ("Untitled");
  22   else
  23     basename = g_path_get_basename (filename);
  24
  25   title = g_strdup_printf ("Simple Editor with printing - %s", basename);
  26   g_free (basename);
  27
  28   gtk_window_set_title (GTK_WINDOW (main_window), title);
  29   g_free (title);
  30 }
  31
  32 static void
  33 update_statusbar (void)
  34 {
  35   gchar *msg;
  36   gint row, col;
  37   GtkTextIter iter;
  38   const char *print_str;
  39
  40   gtk_statusbar_pop (GTK_STATUSBAR (statusbar), 0);
  41
  42   gtk_text_buffer_get_iter_at_mark (buffer,
  43                                     &iter,
  44                                     gtk_text_buffer_get_insert (buffer));
  45
  46   row = gtk_text_iter_get_line (&iter);
  47   col = gtk_text_iter_get_line_offset (&iter);
  48
  49   print_str = "";
  50   if (active_prints)
  51     {
  52       GtkPrintOperation *op = active_prints->data;
  53       print_str = gtk_print_operation_get_status_string (op);
  54     }
  55
  56   msg = g_strdup_printf ("%d, %d%s %s",
  57                          row, col,
  58                          file_changed?" - Modified":"",
  59                          print_str);
  60
  61   gtk_statusbar_push (GTK_STATUSBAR (statusbar), 0, msg);
  62
  63   g_free (msg);
  64 }
  65
  66 static void
  67 update_ui (void)
  68 {
  69   update_title ();
  70   update_statusbar ();
  71 }
  72
  73 static char *
  74 get_text (void)
  75 {
  76   GtkTextIter start, end;
  77
  78   gtk_text_buffer_get_start_iter (buffer, &start);
  79   gtk_text_buffer_get_end_iter (buffer, &end);
  80   return gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
  81 }
  82
  83 static void
  84 set_text (const char *text, gsize len)
  85 {
  86   gtk_text_buffer_set_text (buffer, text, len);
  87   file_changed = FALSE;
  88   update_ui ();
  89 }
  90
  91 static void
  92 do_new (GtkAction *action)
  93 {
  94   g_free (filename);
  95   filename = NULL;
  96   set_text ("", 0);
  97 }
  98
  99 static void
 100 load_file (const char *open_filename)
 101 {
 102   GtkWidget *error_dialog;
 103   char *contents;
 104   GError *error;
 105   gsize len;
 106
 107   error_dialog = NULL;
 108   error = NULL;
 109   if (g_file_get_contents (open_filename, &contents, &len, &error))
 110     {
 111       if (g_utf8_validate (contents, len, NULL))
 112         {
 113           filename = g_strdup (open_filename);
 114           set_text (contents, len);
 115           g_free (contents);
 116         }
 117       else
 118         {
 119           error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 120                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
 121                                                  GTK_MESSAGE_ERROR,
 122                                                  GTK_BUTTONS_CLOSE,
 123                                                  "Error loading file %s:\n%s",
 124                                                  open_filename,
 125                                                  "Not valid utf8");
 126         }
 127     }
 128   else
 129     {
 130       error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 131                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 132                                              GTK_MESSAGE_ERROR,
 133                                              GTK_BUTTONS_CLOSE,
 134                                              "Error loading file %s:\n%s",
 135                                              open_filename,
 136                                              error->message);
 137
 138       g_error_free (error);
 139     }
 140   if (error_dialog)
 141     {
 142       g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 143       gtk_widget_show (error_dialog);
 144     }
 145 }
 146
 147 static void
 148 do_open (GtkAction *action)
 149 {
 150   GtkWidget *dialog;
 151   gint response;
 152   char *open_filename;
 153
 154   dialog = gtk_file_chooser_dialog_new ("Select file",
 155                                         GTK_WINDOW (main_window),
 156                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 157                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 158                                         GTK_STOCK_OPEN, GTK_RESPONSE_OK,
 159                                         NULL);
 160   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 161   response = gtk_dialog_run (GTK_DIALOG (dialog));
 162
 163   if (response == GTK_RESPONSE_OK)
 164     {
 165       open_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 166       load_file (open_filename);
 167       g_free (open_filename);
 168     }
 169
 170   gtk_widget_destroy (dialog);
 171 }
 172
 173 static void
 174 save_file (const char *save_filename)
 175 {
 176   char *text = get_text ();
 177   GtkWidget *error_dialog;
 178   GError *error;
 179
 180   error = NULL;
 181   if (g_file_set_contents (save_filename,
 182                            text, -1, &error))
 183     {
 184       if (save_filename != filename)
 185         {
 186           g_free (filename);
 187           filename = g_strdup (save_filename);
 188         }
 189       file_changed = FALSE;
 190       update_ui ();
 191     }
 192   else
 193     {
 194       error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 195                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 196                                              GTK_MESSAGE_ERROR,
 197                                              GTK_BUTTONS_CLOSE,
 198                                              "Error saving to file %s:\n%s",
 199                                              filename,
 200                                              error->message);
 201
 202       g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 203       gtk_widget_show (error_dialog);
 204
 205       g_error_free (error);
 206     }
 207 }
 208
 209 static void
 210 do_save_as (GtkAction *action)
 211 {
 212   GtkWidget *dialog;
 213   gint response;
 214   char *save_filename;
 215
 216   dialog = gtk_file_chooser_dialog_new ("Select file",
 217                                         GTK_WINDOW (main_window),
 218                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 219                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 220                                         GTK_STOCK_SAVE, GTK_RESPONSE_OK,
 221                                         NULL);
 222   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 223   response = gtk_dialog_run (GTK_DIALOG (dialog));
 224
 225   if (response == GTK_RESPONSE_OK)
 226     {
 227       save_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 228       save_file (save_filename);
 229       g_free (save_filename);
 230     }
 231
 232   gtk_widget_destroy (dialog);
 233 }
 234
 235 static void
 236 do_save (GtkAction *action)
 237 {
 238   if (filename == NULL)
 239     do_save_as (action);
 240   else
 241     save_file (filename);
 242 }
 243
 244 typedef struct {
 245   char *text;
 246   PangoLayout *layout;
 247   GList *page_breaks;
 248   GtkWidget *font_button;
 249   char *font;
 250 } PrintData;
 251
 252 static void
 253 begin_print (GtkPrintOperation *operation,
 254              GtkPrintContext *context,
 255              PrintData *print_data)
 256 {
 257   PangoFontDescription *desc;
 258   PangoLayoutLine *layout_line;
 259   double width, height;
 260   double page_height;
 261   GList *page_breaks;
 262   int num_lines;
 263   int line;
 264
 265   width = gtk_print_context_get_width (context);
 266   height = gtk_print_context_get_height (context);
 267
 268   print_data->layout = gtk_print_context_create_pango_layout (context);
 269
 270   desc = pango_font_description_from_string (print_data->font);
 271   pango_layout_set_font_description (print_data->layout, desc);
 272   pango_font_description_free (desc);
 273
 274   pango_layout_set_width (print_data->layout, width * PANGO_SCALE);
 275
 276   pango_layout_set_text (print_data->layout, print_data->text, -1);
 277
 278   num_lines = pango_layout_get_line_count (print_data->layout);
 279
 280   page_breaks = NULL;
 281   page_height = 0;
 282
 283   for (line = 0; line < num_lines; line++)
 284     {
 285       PangoRectangle ink_rect, logical_rect;
 286       double line_height;
 287
 288       layout_line = pango_layout_get_line (print_data->layout, line);
 289       pango_layout_line_get_extents (layout_line, &ink_rect, &logical_rect);
 290
 291       line_height = logical_rect.height / 1024.0;
 292
 293       if (page_height + line_height > height)
 294         {
 295           page_breaks = g_list_prepend (page_breaks, GINT_TO_POINTER (line));
 296           page_height = 0;
 297         }
 298
 299       page_height += line_height;
 300     }
 301
 302   page_breaks = g_list_reverse (page_breaks);
 303   gtk_print_operation_set_n_pages (operation, g_list_length (page_breaks) + 1);
 304
 305   print_data->page_breaks = page_breaks;
 306 }
 307
 308 static void
 309 draw_page (GtkPrintOperation *operation,
 310            GtkPrintContext *context,
 311            int page_nr,
 312            PrintData *print_data)
 313 {
 314   cairo_t *cr;
 315   GList *pagebreak;
 316   int start, end, i;
 317   PangoLayoutIter *iter;
 318   double start_pos;
 319
 320   if (page_nr == 0)
 321     start = 0;
 322   else
 323     {
 324       pagebreak = g_list_nth (print_data->page_breaks, page_nr - 1);
 325       start = GPOINTER_TO_INT (pagebreak->data);
 326     }
 327
 328   pagebreak = g_list_nth (print_data->page_breaks, page_nr);
 329   if (pagebreak == NULL)
 330     end = pango_layout_get_line_count (print_data->layout);
 331   else
 332     end = GPOINTER_TO_INT (pagebreak->data);
 333
 334   cr = gtk_print_context_get_cairo_context (context);
 335
 336   cairo_set_source_rgb (cr, 0, 0, 0);
 337
 338   i = 0;
 339   start_pos = 0;
 340   iter = pango_layout_get_iter (print_data->layout);
 341   do
 342     {
 343       PangoRectangle   logical_rect;
 344       PangoLayoutLine *line;
 345       int              baseline;
 346
 347       if (i >= start)
 348         {
 349           line = pango_layout_iter_get_line (iter);
 350
 351           pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
 352           baseline = pango_layout_iter_get_baseline (iter);
 353
 354           if (i == start)
 355             start_pos = logical_rect.y / 1024.0;
 356
 357           cairo_move_to (cr, logical_rect.x / 1024.0, baseline / 1024.0 - start_pos);
 358
 359           pango_cairo_show_layout_line  (cr, line);
 360         }
 361       i++;
 362     }
 363   while (i < end &&
 364          pango_layout_iter_next_line (iter));
 365
 366   pango_layout_iter_free (iter);
 367 }
 368
 369 static void
 370 do_page_setup (GtkAction *action)
 371 {
 372   GtkPageSetup *new_page_setup;
 373
 374   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
 375                                                     page_setup, settings);
 376
 377   if (page_setup)
 378     g_object_unref (page_setup);
 379
 380   page_setup = new_page_setup;
 381 }
 382
 383 static void
 384 status_changed_cb (GtkPrintOperation *op,
 385                    gpointer user_data)
 386 {
 387   if (gtk_print_operation_is_finished (op))
 388     {
 389       active_prints = g_list_remove (active_prints, op);
 390       g_object_unref (op);
 391     }
 392   update_statusbar ();
 393 }
 394
 395 static GtkWidget *
 396 create_custom_widget (GtkPrintOperation *operation,
 397                       PrintData *data)
 398 {
 399   GtkWidget *vbox, *hbox, *font, *label;
 400
 401   gtk_print_operation_set_custom_tab_label (operation, "Other");
 402   vbox = gtk_vbox_new (FALSE, 0);
 403   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
 404
 405   hbox = gtk_hbox_new (FALSE, 8);
 406   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 407   gtk_widget_show (hbox);
 408
 409   label = gtk_label_new ("Font:");
 410   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 411   gtk_widget_show (label);
 412
 413   font = gtk_font_button_new_with_font  (data->font);
 414   gtk_box_pack_start (GTK_BOX (hbox), font, FALSE, FALSE, 0);
 415   gtk_widget_show (font);
 416   data->font_button = font;
 417
 418   return vbox;
 419 }
 420
 421 static void
 422 custom_widget_apply (GtkPrintOperation *operation,
 423                      GtkWidget *widget,
 424                      PrintData *data)
 425 {
 426   const char *selected_font;
 427   selected_font = gtk_font_button_get_font_name  (GTK_FONT_BUTTON (data->font_button));
 428   g_free (data->font);
 429   data->font = g_strdup (selected_font);
 430 }
 431
 432 typedef struct
 433 {
 434   GtkPrintOperation *op;
 435   GtkPrintOperationPreview *preview;
 436   GtkWidget         *spin;
 437   GtkWidget         *area;
 438   gint               page;
 439   PrintData *data;
 440   gdouble dpi_x, dpi_y;
 441 } PreviewOp;
 442
 443 static gboolean
 444 preview_expose (GtkWidget      *widget,
 445                 GdkEventExpose *event,
 446                 gpointer        data)
 447 {
 448   PreviewOp *pop = data;
 449
 450   gdk_window_clear (pop->area->window);
 451   gtk_print_operation_preview_render_page (pop->preview,
 452                                            pop->page - 1);
 453
 454   return TRUE;
 455 }
 456
 457 static void
 458 preview_ready (GtkPrintOperationPreview *preview,
 459                GtkPrintContext          *context,
 460                gpointer                  data)
 461 {
 462   PreviewOp *pop = data;
 463   gint n_pages;
 464
 465   g_object_get (pop->op, "n-pages", &n_pages, NULL);
 466
 467   gtk_spin_button_set_range (GTK_SPIN_BUTTON (pop->spin),
 468                              1.0, n_pages);
 469
 470   g_signal_connect (pop->area, "expose_event",
 471                     G_CALLBACK (preview_expose),
 472                     pop);
 473
 474   gtk_widget_queue_draw (pop->area);
 475 }
 476
 477 static void
 478 preview_got_page_size (GtkPrintOperationPreview *preview,
 479                        GtkPrintContext          *context,
 480                        GtkPageSetup             *page_setup,
 481                        gpointer                  data)
 482 {
 483   PreviewOp *pop = data;
 484   GtkPaperSize *paper_size;
 485   double w, h;
 486   cairo_t *cr;
 487   gdouble dpi_x, dpi_y;
 488
 489   paper_size = gtk_page_setup_get_paper_size (page_setup);
 490
 491   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_INCH);
 492   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_INCH);
 493
 494   cr = gdk_cairo_create (pop->area->window);
 495
 496   dpi_x = pop->area->allocation.width/w;
 497   dpi_y = pop->area->allocation.height/h;
 498
 499   if (fabs (dpi_x - pop->dpi_x) > 0.001 ||
 500       fabs (dpi_y - pop->dpi_y) > 0.001)
 501     {
 502       gtk_print_context_set_cairo_context (context, cr, dpi_x, dpi_y);
 503       pop->dpi_x = dpi_x;
 504       pop->dpi_y = dpi_y;
 505     }
 506
 507   pango_cairo_update_layout (cr, pop->data->layout);
 508   cairo_destroy (cr);
 509 }
 510
 511 static void
 512 update_page (GtkSpinButton *widget,
 513              gpointer       data)
 514 {
 515   PreviewOp *pop = data;
 516
 517   pop->page = gtk_spin_button_get_value_as_int (widget);
 518   gtk_widget_queue_draw (pop->area);
 519 }
 520
 521 static void
 522 preview_destroy (GtkWindow *window,
 523                  PreviewOp *pop)
 524 {
 525   gtk_print_operation_preview_end_preview (pop->preview);
 526   g_object_unref (pop->op);
 527
 528   g_free (pop);
 529 }
 530
 531 static gboolean
 532 preview_cb (GtkPrintOperation        *op,
 533             GtkPrintOperationPreview *preview,
 534             GtkPrintContext          *context,
 535             GtkWindow                *parent,
 536             gpointer                  data)
 537 {
 538   GtkPrintSettings *settings;
 539   GtkWidget *window, *close, *page, *hbox, *vbox, *da;
 540   gdouble width, height;
 541   cairo_t *cr;
 542   PreviewOp *pop;
 543   PrintData *print_data = data;
 544
 545   pop = g_new0 (PreviewOp, 1);
 546
 547   pop->data = print_data;
 548   settings = gtk_print_operation_get_print_settings (op);
 549
 550   width = 200;
 551   height = 300;
 552   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 553   gtk_window_set_transient_for (GTK_WINDOW (window),
 554                                 GTK_WINDOW (main_window));
 555   vbox = gtk_vbox_new (FALSE, 0);
 556   gtk_container_add (GTK_CONTAINER (window), vbox);
 557   hbox = gtk_hbox_new (FALSE, 0);
 558   gtk_box_pack_start (GTK_BOX (vbox), hbox,
 559                       FALSE, FALSE, 0);
 560   page = gtk_spin_button_new_with_range (1, 100, 1);
 561   gtk_box_pack_start (GTK_BOX (hbox), page, FALSE, FALSE, 0);
 562
 563   close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 564   gtk_box_pack_start (GTK_BOX (hbox), close, FALSE, FALSE, 0);
 565
 566   da = gtk_drawing_area_new ();
 567   gtk_widget_set_size_request (GTK_WIDGET (da), width, height);
 568   gtk_box_pack_start (GTK_BOX (vbox), da, TRUE, TRUE, 0);
 569
 570   gtk_widget_set_double_buffered (da, FALSE);
 571
 572   gtk_widget_realize (da);
 573
 574   cr = gdk_cairo_create (da->window);
 575
 576   /* TODO: What dpi to use here? This will be used for pagination.. */
 577   gtk_print_context_set_cairo_context (context, cr, 72, 72);
 578   cairo_destroy (cr);
 579
 580   pop->op = g_object_ref (op);
 581   pop->preview = preview;
 582   pop->spin = page;
 583   pop->area = da;
 584   pop->page = 1;
 585
 586   g_signal_connect (page, "value-changed",
 587                     G_CALLBACK (update_page), pop);
 588   g_signal_connect_swapped (close, "clicked",
 589                             G_CALLBACK (gtk_widget_destroy), window);
 590
 591   g_signal_connect (preview, "ready",
 592                     G_CALLBACK (preview_ready), pop);
 593   g_signal_connect (preview, "got-page-size",
 594                     G_CALLBACK (preview_got_page_size), pop);
 595
 596   g_signal_connect (window, "destroy",
 597                     G_CALLBACK (preview_destroy), pop);
 598
 599   gtk_widget_show_all (window);
 600
 601   return TRUE;
 602 }
 603
 604 static void
 605 print_done (GtkPrintOperation *op,
 606             GtkPrintOperationResult res,
 607             PrintData *print_data)
 608 {
 609   GError *error = NULL;
 610
 611   if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
 612     {
 613
 614       GtkWidget *error_dialog;
 615
 616       gtk_print_operation_get_error (op, &error);
 617
 618       error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 619                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 620                                              GTK_MESSAGE_ERROR,
 621                                              GTK_BUTTONS_CLOSE,
 622                                              "Error printing file:\n%s",
 623                                              error ? error->message : "no details");
 624       g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 625       gtk_widget_show (error_dialog);
 626     }
 627   else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
 628     {
 629       if (settings != NULL)
 630         g_object_unref (settings);
 631       settings = g_object_ref (gtk_print_operation_get_print_settings (op));
 632     }
 633
 634   g_free (print_data->text);
 635   g_free (print_data->font);
 636   g_free (print_data);
 637
 638   if (!gtk_print_operation_is_finished (op))
 639     {
 640       g_object_ref (op);
 641       active_prints = g_list_append (active_prints, op);
 642       update_statusbar ();
 643
 644       /* This ref is unref:ed when we get the final state change */
 645       g_signal_connect (op, "status_changed",
 646                         G_CALLBACK (status_changed_cb), NULL);
 647     }
 648 }
 649
 650 static void
 651 end_print (GtkPrintOperation *op, GtkPrintContext *context, PrintData *print_data)
 652 {
 653   g_list_free (print_data->page_breaks);
 654   print_data->page_breaks = NULL;
 655   g_object_unref (print_data->layout);
 656   print_data->layout = NULL;
 657 }
 658
 659 static void
 660 do_print_or_preview (GtkAction *action, GtkPrintOperationAction print_action)
 661 {
 662   GtkPrintOperation *print;
 663   PrintData *print_data;
 664
 665   print_data = g_new0 (PrintData, 1);
 666
 667   print_data->text = get_text ();
 668   print_data->font = g_strdup ("Sans 12");
 669
 670   print = gtk_print_operation_new ();
 671
 672   gtk_print_operation_set_track_print_status (print, TRUE);
 673
 674   if (settings != NULL)
 675     gtk_print_operation_set_print_settings (print, settings);
 676
 677   if (page_setup != NULL)
 678     gtk_print_operation_set_default_page_setup (print, page_setup);
 679
 680   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), print_data);
 681   g_signal_connect (print, "end-print", G_CALLBACK (end_print), print_data);
 682   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), print_data);
 683   g_signal_connect (print, "create_custom_widget", G_CALLBACK (create_custom_widget), print_data);
 684   g_signal_connect (print, "custom_widget_apply", G_CALLBACK (custom_widget_apply), print_data);
 685   g_signal_connect (print, "preview", G_CALLBACK (preview_cb), print_data);
 686
 687   g_signal_connect (print, "done", G_CALLBACK (print_done), print_data);
 688
 689   gtk_print_operation_set_export_filename (print, "test.pdf");
 690
 691 #if 0
 692   gtk_print_operation_set_allow_async (print, TRUE);
 693 #endif
 694   gtk_print_operation_run (print, print_action, GTK_WINDOW (main_window), NULL);
 695
 696   g_object_unref (print);
 697 }
 698
 699 static void
 700 do_print (GtkAction *action)
 701 {
 702   do_print_or_preview (action, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG);
 703 }
 704
 705 static void
 706 do_preview (GtkAction *action)
 707 {
 708   do_print_or_preview (action, GTK_PRINT_OPERATION_ACTION_PREVIEW);
 709 }
 710
 711 static void
 712 do_about (GtkAction *action)
 713 {
 714   const gchar *authors[] = {
 715     "Alexander Larsson",
 716     NULL
 717   };
 718   gtk_show_about_dialog (GTK_WINDOW (main_window),
 719                          "name", "print test editor",
 720                          "version", "0.1",
 721                          "copyright", "(C) Red Hat, Inc",
 722                          "comments", "Program to demonstrate GTK+ printing.",
 723                          "authors", authors,
 724                          NULL);
 725 }
 726
 727 static void
 728 do_quit (GtkAction *action)
 729 {
 730   gtk_main_quit ();
 731 }
 732
 733 static GtkActionEntry entries[] = {
 734   { "FileMenu", NULL, "_File" },               /* name, stock id, label */
 735   { "HelpMenu", NULL, "_Help" },               /* name, stock id, label */
 736   { "New", GTK_STOCK_NEW,                      /* name, stock id */
 737     "_New", "<control>N",                      /* label, accelerator */
 738     "Create a new file",                       /* tooltip */
 739     G_CALLBACK (do_new) },
 740   { "Open", GTK_STOCK_OPEN,                    /* name, stock id */
 741     "_Open","<control>O",                      /* label, accelerator */
 742     "Open a file",                             /* tooltip */
 743     G_CALLBACK (do_open) },
 744   { "Save", GTK_STOCK_SAVE,                    /* name, stock id */
 745     "_Save","<control>S",                      /* label, accelerator */
 746     "Save current file",                       /* tooltip */
 747     G_CALLBACK (do_save) },
 748   { "SaveAs", GTK_STOCK_SAVE,                  /* name, stock id */
 749     "Save _As...", NULL,                       /* label, accelerator */
 750     "Save to a file",                          /* tooltip */
 751     G_CALLBACK (do_save_as) },
 752   { "Quit", GTK_STOCK_QUIT,                    /* name, stock id */
 753     "_Quit", "<control>Q",                     /* label, accelerator */
 754     "Quit",                                    /* tooltip */
 755     G_CALLBACK (do_quit) },
 756   { "About", NULL,                             /* name, stock id */
 757     "_About", "<control>A",                    /* label, accelerator */
 758     "About",                                   /* tooltip */
 759     G_CALLBACK (do_about) },
 760   { "PageSetup", NULL,                         /* name, stock id */
 761     "Page _Setup", NULL,                       /* label, accelerator */
 762     "Set up the page",                         /* tooltip */
 763     G_CALLBACK (do_page_setup) },
 764   { "Preview", NULL,                           /* name, stock id */
 765     "Print Preview", NULL,                     /* label, accelerator */
 766     "Preview the printed document",            /* tooltip */
 767     G_CALLBACK (do_preview) },
 768   { "Print", GTK_STOCK_PRINT,                  /* name, stock id */
 769      NULL, NULL,                               /* label, accelerator */
 770     "Print the document",                      /* tooltip */
 771     G_CALLBACK (do_print) }
 772 };
 773 static guint n_entries = G_N_ELEMENTS (entries);
 774
 775 static const gchar *ui_info =
 776 "<ui>"
 777 "  <menubar name='MenuBar'>"
 778 "    <menu action='FileMenu'>"
 779 "      <menuitem action='New'/>"
 780 "      <menuitem action='Open'/>"
 781 "      <menuitem action='Save'/>"
 782 "      <menuitem action='SaveAs'/>"
 783 "      <menuitem action='PageSetup'/>"
 784 "      <menuitem action='Preview'/>"
 785 "      <menuitem action='Print'/>"
 786 "      <separator/>"
 787 "      <menuitem action='Quit'/>"
 788 "    </menu>"
 789 "    <menu action='HelpMenu'>"
 790 "      <menuitem action='About'/>"
 791 "    </menu>"
 792 "  </menubar>"
 793 "</ui>";
 794
 795 static void
 796 buffer_changed_callback (GtkTextBuffer *buffer)
 797 {
 798   file_changed = TRUE;
 799   update_statusbar ();
 800 }
 801
 802 static void
 803 mark_set_callback (GtkTextBuffer     *buffer,
 804                    const GtkTextIter *new_location,
 805                    GtkTextMark       *mark,
 806                    gpointer           data)
 807 {
 808   update_statusbar ();
 809 }
 810
 811 static void
 812 update_resize_grip (GtkWidget           *widget,
 813                     GdkEventWindowState *event,
 814                     GtkStatusbar        *statusbar)
 815 {
 816   if (event->changed_mask & (GDK_WINDOW_STATE_MAXIMIZED |
 817                              GDK_WINDOW_STATE_FULLSCREEN))
 818     {
 819       gboolean maximized;
 820
 821       maximized = event->new_window_state & (GDK_WINDOW_STATE_MAXIMIZED |
 822                                              GDK_WINDOW_STATE_FULLSCREEN);
 823       gtk_statusbar_set_has_resize_grip (statusbar, !maximized);
 824     }
 825 }
 826
 827 static void
 828 create_window (void)
 829 {
 830   GtkWidget *bar;
 831   GtkWidget *table;
 832   GtkWidget *contents;
 833   GtkUIManager *ui;
 834   GtkWidget *sw;
 835   GtkActionGroup *actions;
 836   GError *error;
 837   GtkWindowGroup *group;
 838
 839   main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 840
 841   group = gtk_window_group_new ();
 842   gtk_window_group_add_window (group, GTK_WINDOW (main_window));
 843   g_object_unref (group);
 844
 845   gtk_window_set_default_size (GTK_WINDOW (main_window),
 846                                400, 600);
 847
 848   g_signal_connect (main_window, "delete-event",
 849                     G_CALLBACK (gtk_main_quit), NULL);
 850
 851   actions = gtk_action_group_new ("Actions");
 852   gtk_action_group_add_actions (actions, entries, n_entries, NULL);
 853
 854   ui = gtk_ui_manager_new ();
 855   gtk_ui_manager_insert_action_group (ui, actions, 0);
 856   gtk_window_add_accel_group (GTK_WINDOW (main_window),
 857                               gtk_ui_manager_get_accel_group (ui));
 858   gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
 859
 860   error = NULL;
 861   if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
 862     {
 863       g_message ("building menus failed: %s", error->message);
 864       g_error_free (error);
 865     }
 866
 867   table = gtk_table_new (1, 3, FALSE);
 868   gtk_container_add (GTK_CONTAINER (main_window), table);
 869
 870   bar = gtk_ui_manager_get_widget (ui, "/MenuBar");
 871   gtk_widget_show (bar);
 872   gtk_table_attach (GTK_TABLE (table),
 873                     bar,
 874                     /* X direction */          /* Y direction */
 875                     0, 1,                      0, 1,
 876                     GTK_EXPAND | GTK_FILL,     0,
 877                     0,                         0);
 878
 879   /* Create document  */
 880   sw = gtk_scrolled_window_new (NULL, NULL);
 881
 882   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 883                                   GTK_POLICY_AUTOMATIC,
 884                                   GTK_POLICY_AUTOMATIC);
 885
 886   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 887                                        GTK_SHADOW_IN);
 888
 889   gtk_table_attach (GTK_TABLE (table),
 890                     sw,
 891                     /* X direction */       /* Y direction */
 892                     0, 1,                   1, 2,
 893                     GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
 894                     0,                      0);
 895
 896   contents = gtk_text_view_new ();
 897   gtk_widget_grab_focus (contents);
 898
 899   gtk_container_add (GTK_CONTAINER (sw),
 900                      contents);
 901
 902   /* Create statusbar */
 903
 904   statusbar = gtk_statusbar_new ();
 905   gtk_table_attach (GTK_TABLE (table),
 906                     statusbar,
 907                     /* X direction */       /* Y direction */
 908                     0, 1,                   2, 3,
 909                     GTK_EXPAND | GTK_FILL,  0,
 910                     0,                      0);
 911
 912   /* Show text widget info in the statusbar */
 913   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
 914
 915   g_signal_connect_object (buffer,
 916                            "changed",
 917                            G_CALLBACK (buffer_changed_callback),
 918                            NULL,
 919                            0);
 920
 921   g_signal_connect_object (buffer,
 922                            "mark_set", /* cursor moved */
 923                            G_CALLBACK (mark_set_callback),
 924                            NULL,
 925                            0);
 926
 927   g_signal_connect_object (main_window,
 928                            "window_state_event",
 929                            G_CALLBACK (update_resize_grip),
 930                            statusbar,
 931                            0);
 932
 933   update_ui ();
 934
 935   gtk_widget_show_all (main_window);
 936 }
 937
 938 int
 939 main (int argc, char **argv)
 940 {
 941   GError *error = NULL;
 942
 943   g_set_application_name ("Print editor");
 944   gtk_init (&argc, &argv);
 945
 946   settings = gtk_print_settings_new_from_file ("print-settings.ini", &error);
 947   if (error) {
 948     g_print ("Failed to load print settings: %s\n", error->message);
 949     g_clear_error (&error);
 950
 951     settings = gtk_print_settings_new ();
 952   }
 953   g_assert (settings != NULL);
 954
 955   page_setup = gtk_page_setup_new_from_file ("page-setup.ini", &error);
 956   if (error) {
 957     g_print ("Failed to load page setup: %s\n", error->message);
 958     g_clear_error (&error);
 959   }
 960
 961   create_window ();
 962
 963   if (argc == 2)
 964     load_file (argv[1]);
 965
 966   gtk_main ();
 967
 968   if (!gtk_print_settings_to_file (settings, "print-settings.ini", &error)) {
 969     g_print ("Failed to save print settings: %s\n", error->message);
 970     g_clear_error (&error);
 971   }
 972   if (page_setup &&
 973       !gtk_page_setup_to_file (page_setup, "page-setup.ini", &error)) {
 974     g_print ("Failed to save page setup: %s\n", error->message);
 975     g_clear_error (&error);
 976   }
 977
 978   return 0;
 979 }