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

   1 #include <pango/pangocairo.h>
   2 #include <gtk/gtk.h>
   3 #include <gtk/gtkprintoperation.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_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
 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   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);
 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
 367 static void
 368 do_page_setup (GtkAction *action)
 369 {
 370   GtkPageSetup *new_page_setup;
 371
 372   if (settings == NULL)
 373     settings = gtk_print_settings_new ();
 374
 375   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
 376                                                     page_setup, settings);
 377
 378   if (page_setup)
 379     g_object_unref (page_setup);
 380
 381   page_setup = new_page_setup;
 382 }
 383
 384 static void
 385 status_changed_cb (GtkPrintOperation *op,
 386                    gpointer user_data)
 387 {
 388   if (gtk_print_operation_is_finished (op))
 389     {
 390       active_prints = g_list_remove (active_prints, op);
 391       g_object_unref (op);
 392     }
 393   update_statusbar ();
 394 }
 395
 396 static GtkWidget *
 397 create_custom_widget (GtkPrintOperation *operation,
 398                       PrintData *data)
 399 {
 400   GtkWidget *vbox, *hbox, *font, *label;
 401
 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 static void
 433 do_print (GtkAction *action)
 434 {
 435   GtkWidget *error_dialog;
 436   GtkPrintOperation *print;
 437   PrintData print_data;
 438   GtkPrintOperationResult res;
 439   GError *error;
 440
 441   print_data.text = get_text ();
 442   print_data.font = g_strdup ("Sans 12");
 443
 444   print = gtk_print_operation_new ();
 445
 446   gtk_print_operation_set_track_print_status (print, TRUE);
 447
 448   if (settings != NULL)
 449     gtk_print_operation_set_print_settings (print, settings);
 450
 451   if (page_setup != NULL)
 452     gtk_print_operation_set_default_page_setup (print, page_setup);
 453
 454   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), &print_data);
 455   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), &print_data);
 456   g_signal_connect (print, "create_custom_widget", G_CALLBACK (create_custom_widget), &print_data);
 457   g_signal_connect (print, "custom_widget_apply", G_CALLBACK (custom_widget_apply), &print_data);
 458
 459   error = NULL;
 460   res = gtk_print_operation_run (print, GTK_WINDOW (main_window), &error);
 461
 462   if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
 463     {
 464       error_dialog = gtk_message_dialog_new (GTK_WINDOW (main_window),
 465                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 466                                              GTK_MESSAGE_ERROR,
 467                                              GTK_BUTTONS_CLOSE,
 468                                              "Error printing file:\n%s",
 469                                              error->message);
 470       g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 471       gtk_widget_show (error_dialog);
 472       g_error_free (error);
 473     }
 474   else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
 475     {
 476       if (settings != NULL)
 477         g_object_unref (settings);
 478       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
 479     }
 480
 481   if (!gtk_print_operation_is_finished (print))
 482     {
 483       g_object_ref (print);
 484       active_prints = g_list_append (active_prints, print);
 485       update_statusbar ();
 486
 487       /* This ref is unref:ed when we get the final state change */
 488       g_signal_connect (print, "status_changed",
 489                         G_CALLBACK (status_changed_cb), NULL);
 490     }
 491
 492   g_object_unref (print);
 493   g_free (print_data.text);
 494   g_free (print_data.font);
 495 }
 496
 497 static void
 498 do_about (GtkAction *action)
 499 {
 500   const gchar *authors[] = {
 501     "Alexander Larsson",
 502     NULL
 503   };
 504   gtk_show_about_dialog (GTK_WINDOW (main_window),
 505                          "name", "print test editor",
 506                          "version", "0.1",
 507                          "copyright", "(C) Red Hat, Inc",
 508                          "comments", "Program to demonstrate GTK+ printing.",
 509                          "authors", authors,
 510                          NULL);
 511 }
 512
 513 static void
 514 do_quit (GtkAction *action)
 515 {
 516   gtk_main_quit ();
 517 }
 518
 519 static GtkActionEntry entries[] = {
 520   { "FileMenu", NULL, "_File" },               /* name, stock id, label */
 521   { "HelpMenu", NULL, "_Help" },               /* name, stock id, label */
 522   { "New", GTK_STOCK_NEW,                      /* name, stock id */
 523     "_New", "<control>N",                      /* label, accelerator */
 524     "Create a new file",                       /* tooltip */
 525     G_CALLBACK (do_new) },
 526   { "Open", GTK_STOCK_OPEN,                    /* name, stock id */
 527     "_Open","<control>O",                      /* label, accelerator */
 528     "Open a file",                             /* tooltip */
 529     G_CALLBACK (do_open) },
 530   { "Save", GTK_STOCK_SAVE,                    /* name, stock id */
 531     "_Save","<control>S",                      /* label, accelerator */
 532     "Save current file",                       /* tooltip */
 533     G_CALLBACK (do_save) },
 534   { "SaveAs", GTK_STOCK_SAVE,                  /* name, stock id */
 535     "Save _As...", NULL,                       /* label, accelerator */
 536     "Save to a file",                          /* tooltip */
 537     G_CALLBACK (do_save_as) },
 538   { "Quit", GTK_STOCK_QUIT,                    /* name, stock id */
 539     "_Quit", "<control>Q",                     /* label, accelerator */
 540     "Quit",                                    /* tooltip */
 541     G_CALLBACK (do_quit) },
 542   { "About", NULL,                             /* name, stock id */
 543     "_About", "<control>A",                    /* label, accelerator */
 544     "About",                                   /* tooltip */
 545     G_CALLBACK (do_about) },
 546   { "PageSetup", NULL,                         /* name, stock id */
 547     "Page _Setup", NULL,                       /* label, accelerator */
 548     "Set up the page",                         /* tooltip */
 549     G_CALLBACK (do_page_setup) },
 550   { "Print", GTK_STOCK_PRINT,                  /* name, stock id */
 551      NULL, NULL,                               /* label, accelerator */
 552     "Print the document",                      /* tooltip */
 553     G_CALLBACK (do_print) },
 554 };
 555 static guint n_entries = G_N_ELEMENTS (entries);
 556
 557 static const gchar *ui_info =
 558 "<ui>"
 559 "  <menubar name='MenuBar'>"
 560 "    <menu action='FileMenu'>"
 561 "      <menuitem action='New'/>"
 562 "      <menuitem action='Open'/>"
 563 "      <menuitem action='Save'/>"
 564 "      <menuitem action='SaveAs'/>"
 565 "      <menuitem action='PageSetup'/>"
 566 "      <menuitem action='Print'/>"
 567 "      <separator/>"
 568 "      <menuitem action='Quit'/>"
 569 "    </menu>"
 570 "    <menu action='HelpMenu'>"
 571 "      <menuitem action='About'/>"
 572 "    </menu>"
 573 "  </menubar>"
 574 "</ui>";
 575
 576 static void
 577 buffer_changed_callback (GtkTextBuffer *buffer)
 578 {
 579   file_changed = TRUE;
 580   update_statusbar ();
 581 }
 582
 583 static void
 584 mark_set_callback (GtkTextBuffer     *buffer,
 585                    const GtkTextIter *new_location,
 586                    GtkTextMark       *mark,
 587                    gpointer           data)
 588 {
 589   update_statusbar ();
 590 }
 591
 592 static void
 593 update_resize_grip (GtkWidget           *widget,
 594                     GdkEventWindowState *event,
 595                     GtkStatusbar        *statusbar)
 596 {
 597   if (event->changed_mask & (GDK_WINDOW_STATE_MAXIMIZED |
 598                              GDK_WINDOW_STATE_FULLSCREEN))
 599     {
 600       gboolean maximized;
 601
 602       maximized = event->new_window_state & (GDK_WINDOW_STATE_MAXIMIZED |
 603                                              GDK_WINDOW_STATE_FULLSCREEN);
 604       gtk_statusbar_set_has_resize_grip (statusbar, !maximized);
 605     }
 606 }
 607
 608 static void
 609 create_window (void)
 610 {
 611   GtkWidget *bar;
 612   GtkWidget *table;
 613   GtkWidget *contents;
 614   GtkUIManager *ui;
 615   GtkWidget *sw;
 616   GtkActionGroup *actions;
 617   GError *error;
 618
 619   main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 620
 621   gtk_window_set_default_size (GTK_WINDOW (main_window),
 622                                400, 600);
 623
 624   g_signal_connect (main_window, "delete-event",
 625                     G_CALLBACK (gtk_main_quit), NULL);
 626
 627   actions = gtk_action_group_new ("Actions");
 628   gtk_action_group_add_actions (actions, entries, n_entries, NULL);
 629
 630   ui = gtk_ui_manager_new ();
 631   gtk_ui_manager_insert_action_group (ui, actions, 0);
 632   gtk_window_add_accel_group (GTK_WINDOW (main_window),
 633                               gtk_ui_manager_get_accel_group (ui));
 634   gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
 635
 636   error = NULL;
 637   if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
 638     {
 639       g_message ("building menus failed: %s", error->message);
 640       g_error_free (error);
 641     }
 642
 643   table = gtk_table_new (1, 3, FALSE);
 644   gtk_container_add (GTK_CONTAINER (main_window), table);
 645
 646   bar = gtk_ui_manager_get_widget (ui, "/MenuBar");
 647   gtk_widget_show (bar);
 648   gtk_table_attach (GTK_TABLE (table),
 649                     bar,
 650                     /* X direction */          /* Y direction */
 651                     0, 1,                      0, 1,
 652                     GTK_EXPAND | GTK_FILL,     0,
 653                     0,                         0);
 654
 655   /* Create document  */
 656   sw = gtk_scrolled_window_new (NULL, NULL);
 657
 658   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 659                                   GTK_POLICY_AUTOMATIC,
 660                                   GTK_POLICY_AUTOMATIC);
 661
 662   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 663                                        GTK_SHADOW_IN);
 664
 665   gtk_table_attach (GTK_TABLE (table),
 666                     sw,
 667                     /* X direction */       /* Y direction */
 668                     0, 1,                   1, 2,
 669                     GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
 670                     0,                      0);
 671
 672   contents = gtk_text_view_new ();
 673   gtk_widget_grab_focus (contents);
 674
 675   gtk_container_add (GTK_CONTAINER (sw),
 676                      contents);
 677
 678   /* Create statusbar */
 679
 680   statusbar = gtk_statusbar_new ();
 681   gtk_table_attach (GTK_TABLE (table),
 682                     statusbar,
 683                     /* X direction */       /* Y direction */
 684                     0, 1,                   2, 3,
 685                     GTK_EXPAND | GTK_FILL,  0,
 686                     0,                      0);
 687
 688   /* Show text widget info in the statusbar */
 689   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
 690
 691   g_signal_connect_object (buffer,
 692                            "changed",
 693                            G_CALLBACK (buffer_changed_callback),
 694                            NULL,
 695                            0);
 696
 697   g_signal_connect_object (buffer,
 698                            "mark_set", /* cursor moved */
 699                            G_CALLBACK (mark_set_callback),
 700                            NULL,
 701                            0);
 702
 703   g_signal_connect_object (main_window,
 704                            "window_state_event",
 705                            G_CALLBACK (update_resize_grip),
 706                            statusbar,
 707                            0);
 708
 709   update_ui ();
 710
 711   gtk_widget_show_all (main_window);
 712 }
 713
 714 int
 715 main (int argc, char **argv)
 716 {
 717   g_set_application_name ("Print editor");
 718   gtk_init (&argc, &argv);
 719
 720   create_window ();
 721
 722   if (argc == 2)
 723     load_file (argv[1]);
 724
 725   gtk_main ();
 726   return 0;
 727 }