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_box_new (GTK_ORIENTATION_VERTICAL, 0);
 403   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
 404
 405   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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   GtkPrintContext   *context;
 437   GtkWidget         *spin;
 438   GtkWidget         *area;
 439   gint               page;
 440   PrintData *data;
 441   gdouble dpi_x, dpi_y;
 442 } PreviewOp;
 443
 444 static gboolean
 445 preview_draw (GtkWidget *widget,
 446               cairo_t   *cr,
 447               gpointer   data)
 448 {
 449   PreviewOp *pop = data;
 450   cairo_t *prev_cr;
 451   double dpi_x, dpi_y;
 452
 453   prev_cr = gtk_print_context_get_cairo_context (pop->context);
 454   cairo_reference (prev_cr);
 455   dpi_x = gtk_print_context_get_dpi_x (pop->context);
 456   dpi_y = gtk_print_context_get_dpi_y (pop->context);
 457
 458   gtk_print_context_set_cairo_context (pop->context,
 459                                        cr, dpi_x, dpi_y);
 460   gtk_print_operation_preview_render_page (pop->preview,
 461                                            pop->page - 1);
 462   gtk_print_context_set_cairo_context (pop->context,
 463                                        prev_cr, dpi_x, dpi_y);
 464   cairo_destroy (prev_cr);
 465
 466   return TRUE;
 467 }
 468
 469 static void
 470 preview_ready (GtkPrintOperationPreview *preview,
 471                GtkPrintContext          *context,
 472                gpointer                  data)
 473 {
 474   PreviewOp *pop = data;
 475   gint n_pages;
 476
 477   g_object_get (pop->op, "n-pages", &n_pages, NULL);
 478
 479   gtk_spin_button_set_range (GTK_SPIN_BUTTON (pop->spin),
 480                              1.0, n_pages);
 481
 482   g_signal_connect (pop->area, "draw",
 483                     G_CALLBACK (preview_draw),
 484                     pop);
 485
 486   gtk_widget_queue_draw (pop->area);
 487 }
 488
 489 static void
 490 preview_got_page_size (GtkPrintOperationPreview *preview,
 491                        GtkPrintContext          *context,
 492                        GtkPageSetup             *page_setup,
 493                        gpointer                  data)
 494 {
 495   PreviewOp *pop = data;
 496   GtkAllocation allocation;
 497   GtkPaperSize *paper_size;
 498   double w, h;
 499   cairo_t *cr;
 500   gdouble dpi_x, dpi_y;
 501
 502   paper_size = gtk_page_setup_get_paper_size (page_setup);
 503
 504   w = gtk_paper_size_get_width (paper_size, GTK_UNIT_INCH);
 505   h = gtk_paper_size_get_height (paper_size, GTK_UNIT_INCH);
 506
 507   cr = gdk_cairo_create (gtk_widget_get_window (pop->area));
 508
 509   gtk_widget_get_allocation (pop->area, &allocation);
 510   dpi_x = allocation.width/w;
 511   dpi_y = allocation.height/h;
 512
 513   if (fabs (dpi_x - pop->dpi_x) > 0.001 ||
 514       fabs (dpi_y - pop->dpi_y) > 0.001)
 515     {
 516       gtk_print_context_set_cairo_context (context, cr, dpi_x, dpi_y);
 517       pop->dpi_x = dpi_x;
 518       pop->dpi_y = dpi_y;
 519     }
 520
 521   pango_cairo_update_layout (cr, pop->data->layout);
 522   cairo_destroy (cr);
 523 }
 524
 525 static void
 526 update_page (GtkSpinButton *widget,
 527              gpointer       data)
 528 {
 529   PreviewOp *pop = data;
 530
 531   pop->page = gtk_spin_button_get_value_as_int (widget);
 532   gtk_widget_queue_draw (pop->area);
 533 }
 534
 535 static void
 536 preview_destroy (GtkWindow *window,
 537                  PreviewOp *pop)
 538 {
 539   gtk_print_operation_preview_end_preview (pop->preview);
 540   g_object_unref (pop->op);
 541
 542   g_free (pop);
 543 }
 544
 545 static gboolean
 546 preview_cb (GtkPrintOperation        *op,
 547             GtkPrintOperationPreview *preview,
 548             GtkPrintContext          *context,
 549             GtkWindow                *parent,
 550             gpointer                  data)
 551 {
 552   GtkWidget *window, *close, *page, *hbox, *vbox, *da;
 553   gdouble width, height;
 554   cairo_t *cr;
 555   PreviewOp *pop;
 556   PrintData *print_data = data;
 557
 558   pop = g_new0 (PreviewOp, 1);
 559
 560   pop->data = print_data;
 561
 562   width = 200;
 563   height = 300;
 564   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 565   gtk_window_set_transient_for (GTK_WINDOW (window),
 566                                 GTK_WINDOW (main_window));
 567   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 568   gtk_container_add (GTK_CONTAINER (window), vbox);
 569   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 570   gtk_box_pack_start (GTK_BOX (vbox), hbox,
 571                       FALSE, FALSE, 0);
 572   page = gtk_spin_button_new_with_range (1, 100, 1);
 573   gtk_box_pack_start (GTK_BOX (hbox), page, FALSE, FALSE, 0);
 574
 575   close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 576   gtk_box_pack_start (GTK_BOX (hbox), close, FALSE, FALSE, 0);
 577
 578   da = gtk_drawing_area_new ();
 579   gtk_widget_set_size_request (GTK_WIDGET (da), width, height);
 580   gtk_box_pack_start (GTK_BOX (vbox), da, TRUE, TRUE, 0);
 581
 582   gtk_widget_realize (da);
 583
 584   cr = gdk_cairo_create (gtk_widget_get_window (da));
 585   /* TODO: What dpi to use here? This will be used for pagination.. */
 586   gtk_print_context_set_cairo_context (context, cr, 72, 72);
 587   cairo_destroy (cr);
 588
 589   pop->op = g_object_ref (op);
 590   pop->preview = preview;
 591   pop->context = context;
 592   pop->spin = page;
 593   pop->area = da;
 594   pop->page = 1;
 595
 596   g_signal_connect (page, "value-changed",
 597                     G_CALLBACK (update_page), pop);
 598   g_signal_connect_swapped (close, "clicked",
 599                             G_CALLBACK (gtk_widget_destroy), window);
 600
 601   g_signal_connect (preview, "ready",
 602                     G_CALLBACK (preview_ready), pop);
 603   g_signal_connect (preview, "got-page-size",
 604                     G_CALLBACK (preview_got_page_size), pop);
 605
 606   g_signal_connect (window, "destroy",
 607                     G_CALLBACK (preview_destroy), pop);
 608
 609   gtk_widget_show_all (window);
 610
 611   return TRUE;
 612 }
 613
 614 static void
 615 print_done (GtkPrintOperation *op,
 616             GtkPrintOperationResult res,
 617             PrintData *print_data)
 618 {
 619   GError *error = NULL;
 620
 621   if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
 622     {
 623
 624       GtkWidget *error_dialog;
 625
 626       gtk_print_operation_get_error (op, &error);
 627
 628       error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 629                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 630                                              GTK_MESSAGE_ERROR,
 631                                              GTK_BUTTONS_CLOSE,
 632                                              "Error printing file:\n%s",
 633                                              error ? error->message : "no details");
 634       g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 635       gtk_widget_show (error_dialog);
 636     }
 637   else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
 638     {
 639       if (settings != NULL)
 640         g_object_unref (settings);
 641       settings = g_object_ref (gtk_print_operation_get_print_settings (op));
 642     }
 643
 644   g_free (print_data->text);
 645   g_free (print_data->font);
 646   g_free (print_data);
 647
 648   if (!gtk_print_operation_is_finished (op))
 649     {
 650       g_object_ref (op);
 651       active_prints = g_list_append (active_prints, op);
 652       update_statusbar ();
 653
 654       /* This ref is unref:ed when we get the final state change */
 655       g_signal_connect (op, "status_changed",
 656                         G_CALLBACK (status_changed_cb), NULL);
 657     }
 658 }
 659
 660 static void
 661 end_print (GtkPrintOperation *op, GtkPrintContext *context, PrintData *print_data)
 662 {
 663   g_list_free (print_data->page_breaks);
 664   print_data->page_breaks = NULL;
 665   g_object_unref (print_data->layout);
 666   print_data->layout = NULL;
 667 }
 668
 669 static void
 670 do_print_or_preview (GtkAction *action, GtkPrintOperationAction print_action)
 671 {
 672   GtkPrintOperation *print;
 673   PrintData *print_data;
 674
 675   print_data = g_new0 (PrintData, 1);
 676
 677   print_data->text = get_text ();
 678   print_data->font = g_strdup ("Sans 12");
 679
 680   print = gtk_print_operation_new ();
 681
 682   gtk_print_operation_set_track_print_status (print, TRUE);
 683
 684   if (settings != NULL)
 685     gtk_print_operation_set_print_settings (print, settings);
 686
 687   if (page_setup != NULL)
 688     gtk_print_operation_set_default_page_setup (print, page_setup);
 689
 690   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), print_data);
 691   g_signal_connect (print, "end-print", G_CALLBACK (end_print), print_data);
 692   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), print_data);
 693   g_signal_connect (print, "create_custom_widget", G_CALLBACK (create_custom_widget), print_data);
 694   g_signal_connect (print, "custom_widget_apply", G_CALLBACK (custom_widget_apply), print_data);
 695   g_signal_connect (print, "preview", G_CALLBACK (preview_cb), print_data);
 696
 697   g_signal_connect (print, "done", G_CALLBACK (print_done), print_data);
 698
 699   gtk_print_operation_set_export_filename (print, "test.pdf");
 700
 701 #if 0
 702   gtk_print_operation_set_allow_async (print, TRUE);
 703 #endif
 704   gtk_print_operation_run (print, print_action, GTK_WINDOW (main_window), NULL);
 705
 706   g_object_unref (print);
 707 }
 708
 709 static void
 710 do_print (GtkAction *action)
 711 {
 712   do_print_or_preview (action, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG);
 713 }
 714
 715 static void
 716 do_preview (GtkAction *action)
 717 {
 718   do_print_or_preview (action, GTK_PRINT_OPERATION_ACTION_PREVIEW);
 719 }
 720
 721 static void
 722 do_about (GtkAction *action)
 723 {
 724   const gchar *authors[] = {
 725     "Alexander Larsson",
 726     NULL
 727   };
 728   gtk_show_about_dialog (GTK_WINDOW (main_window),
 729                          "name", "print test editor",
 730                          "version", "0.1",
 731                          "copyright", "(C) Red Hat, Inc",
 732                          "comments", "Program to demonstrate GTK+ printing.",
 733                          "authors", authors,
 734                          NULL);
 735 }
 736
 737 static void
 738 do_quit (GtkAction *action)
 739 {
 740   gtk_main_quit ();
 741 }
 742
 743 static GtkActionEntry entries[] = {
 744   { "FileMenu", NULL, "_File" },               /* name, stock id, label */
 745   { "HelpMenu", NULL, "_Help" },               /* name, stock id, label */
 746   { "New", GTK_STOCK_NEW,                      /* name, stock id */
 747     "_New", "<control>N",                      /* label, accelerator */
 748     "Create a new file",                       /* tooltip */
 749     G_CALLBACK (do_new) },
 750   { "Open", GTK_STOCK_OPEN,                    /* name, stock id */
 751     "_Open","<control>O",                      /* label, accelerator */
 752     "Open a file",                             /* tooltip */
 753     G_CALLBACK (do_open) },
 754   { "Save", GTK_STOCK_SAVE,                    /* name, stock id */
 755     "_Save","<control>S",                      /* label, accelerator */
 756     "Save current file",                       /* tooltip */
 757     G_CALLBACK (do_save) },
 758   { "SaveAs", GTK_STOCK_SAVE,                  /* name, stock id */
 759     "Save _As...", NULL,                       /* label, accelerator */
 760     "Save to a file",                          /* tooltip */
 761     G_CALLBACK (do_save_as) },
 762   { "Quit", GTK_STOCK_QUIT,                    /* name, stock id */
 763     "_Quit", "<control>Q",                     /* label, accelerator */
 764     "Quit",                                    /* tooltip */
 765     G_CALLBACK (do_quit) },
 766   { "About", NULL,                             /* name, stock id */
 767     "_About", "<control>A",                    /* label, accelerator */
 768     "About",                                   /* tooltip */
 769     G_CALLBACK (do_about) },
 770   { "PageSetup", NULL,                         /* name, stock id */
 771     "Page _Setup", NULL,                       /* label, accelerator */
 772     "Set up the page",                         /* tooltip */
 773     G_CALLBACK (do_page_setup) },
 774   { "Preview", NULL,                           /* name, stock id */
 775     "Print Preview", NULL,                     /* label, accelerator */
 776     "Preview the printed document",            /* tooltip */
 777     G_CALLBACK (do_preview) },
 778   { "Print", GTK_STOCK_PRINT,                  /* name, stock id */
 779      NULL, NULL,                               /* label, accelerator */
 780     "Print the document",                      /* tooltip */
 781     G_CALLBACK (do_print) }
 782 };
 783 static guint n_entries = G_N_ELEMENTS (entries);
 784
 785 static const gchar *ui_info =
 786 "<ui>"
 787 "  <menubar name='MenuBar'>"
 788 "    <menu action='FileMenu'>"
 789 "      <menuitem action='New'/>"
 790 "      <menuitem action='Open'/>"
 791 "      <menuitem action='Save'/>"
 792 "      <menuitem action='SaveAs'/>"
 793 "      <menuitem action='PageSetup'/>"
 794 "      <menuitem action='Preview'/>"
 795 "      <menuitem action='Print'/>"
 796 "      <separator/>"
 797 "      <menuitem action='Quit'/>"
 798 "    </menu>"
 799 "    <menu action='HelpMenu'>"
 800 "      <menuitem action='About'/>"
 801 "    </menu>"
 802 "  </menubar>"
 803 "</ui>";
 804
 805 static void
 806 buffer_changed_callback (GtkTextBuffer *buffer)
 807 {
 808   file_changed = TRUE;
 809   update_statusbar ();
 810 }
 811
 812 static void
 813 mark_set_callback (GtkTextBuffer     *buffer,
 814                    const GtkTextIter *new_location,
 815                    GtkTextMark       *mark,
 816                    gpointer           data)
 817 {
 818   update_statusbar ();
 819 }
 820
 821 static void
 822 create_window (void)
 823 {
 824   GtkWidget *bar;
 825   GtkWidget *box;
 826   GtkWidget *contents;
 827   GtkUIManager *ui;
 828   GtkWidget *sw;
 829   GtkActionGroup *actions;
 830   GError *error;
 831   GtkWindowGroup *group;
 832
 833   main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 834
 835   group = gtk_window_group_new ();
 836   gtk_window_group_add_window (group, GTK_WINDOW (main_window));
 837   g_object_unref (group);
 838
 839   gtk_window_set_default_size (GTK_WINDOW (main_window),
 840                                400, 600);
 841
 842   g_signal_connect (main_window, "delete-event",
 843                     G_CALLBACK (gtk_main_quit), NULL);
 844
 845   actions = gtk_action_group_new ("Actions");
 846   gtk_action_group_add_actions (actions, entries, n_entries, NULL);
 847
 848   ui = gtk_ui_manager_new ();
 849   gtk_ui_manager_insert_action_group (ui, actions, 0);
 850   gtk_window_add_accel_group (GTK_WINDOW (main_window),
 851                               gtk_ui_manager_get_accel_group (ui));
 852   gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
 853
 854   error = NULL;
 855   if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
 856     {
 857       g_message ("building menus failed: %s", error->message);
 858       g_error_free (error);
 859     }
 860
 861   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 862   gtk_container_add (GTK_CONTAINER (main_window), box);
 863
 864   bar = gtk_ui_manager_get_widget (ui, "/MenuBar");
 865   gtk_widget_show (bar);
 866   gtk_container_add (GTK_CONTAINER (box), bar);
 867
 868   /* Create document  */
 869   sw = gtk_scrolled_window_new (NULL, NULL);
 870
 871   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 872                                   GTK_POLICY_AUTOMATIC,
 873                                   GTK_POLICY_AUTOMATIC);
 874
 875   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 876                                        GTK_SHADOW_IN);
 877
 878   gtk_widget_set_vexpand (sw, TRUE);
 879   gtk_container_add (GTK_CONTAINER (box), sw);
 880
 881   contents = gtk_text_view_new ();
 882   gtk_widget_grab_focus (contents);
 883
 884   gtk_container_add (GTK_CONTAINER (sw),
 885                      contents);
 886
 887   /* Create statusbar */
 888
 889   statusbar = gtk_statusbar_new ();
 890   gtk_container_add (GTK_CONTAINER (box), statusbar);
 891
 892   /* Show text widget info in the statusbar */
 893   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
 894
 895   g_signal_connect_object (buffer,
 896                            "changed",
 897                            G_CALLBACK (buffer_changed_callback),
 898                            NULL,
 899                            0);
 900
 901   g_signal_connect_object (buffer,
 902                            "mark_set", /* cursor moved */
 903                            G_CALLBACK (mark_set_callback),
 904                            NULL,
 905                            0);
 906
 907   update_ui ();
 908
 909   gtk_widget_show_all (main_window);
 910 }
 911
 912 int
 913 main (int argc, char **argv)
 914 {
 915   GError *error = NULL;
 916
 917   g_set_application_name ("Print editor");
 918   gtk_init (&argc, &argv);
 919
 920   settings = gtk_print_settings_new_from_file ("print-settings.ini", &error);
 921   if (error) {
 922     g_print ("Failed to load print settings: %s\n", error->message);
 923     g_clear_error (&error);
 924
 925     settings = gtk_print_settings_new ();
 926   }
 927   g_assert (settings != NULL);
 928
 929   page_setup = gtk_page_setup_new_from_file ("page-setup.ini", &error);
 930   if (error) {
 931     g_print ("Failed to load page setup: %s\n", error->message);
 932     g_clear_error (&error);
 933   }
 934
 935   create_window ();
 936
 937   if (argc == 2)
 938     load_file (argv[1]);
 939
 940   gtk_main ();
 941
 942   if (!gtk_print_settings_to_file (settings, "print-settings.ini", &error)) {
 943     g_print ("Failed to save print settings: %s\n", error->message);
 944     g_clear_error (&error);
 945   }
 946   if (page_setup &&
 947       !gtk_page_setup_to_file (page_setup, "page-setup.ini", &error)) {
 948     g_print ("Failed to save page setup: %s\n", error->message);
 949     g_clear_error (&error);
 950   }
 951
 952   return 0;
 953 }