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

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