app/app_procs.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1998 Alexander Larsson
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <sys/types.h>
  24 #include <errno.h>
  25 #include <sys/stat.h>
  26 #include <string.h>
  27 #include <signal.h>
  28 #include <locale.h>
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32
  33 /* wants to be included early to avoid complains about setjmp.h */
  34 #ifdef HAVE_LIBPNG
  35 #include <png.h> /* just for the version stuff */
  36 #endif
  37
  38 #include <gtk/gtk.h>
  39 #include <gmodule.h>
  40
  41 #if (defined (HAVE_LIBPOPT) && defined (HAVE_POPT_H)) || defined (GNOME)
  42 #define HAVE_POPT
  43 #endif
  44
  45 #ifdef GNOME
  46 #include <gnome.h>
  47 #else
  48 #  ifdef HAVE_POPT_H
  49 #    include <popt.h>
  50 #  else
  51 /* sorry about the mess, but one should not use conditional defined types in
  52  * unconditional function call in the first place ... --hb */
  53 typedef void* poptContext;
  54 #  endif
  55 #endif
  56
  57 /* apparently there is no clean way to use glib-2.6 GOption with gnome */
  58 #if GLIB_CHECK_VERSION(2,5,5) && !defined GNOME
  59 #  define USE_GOPTION 1
  60 #else
  61 #  define USE_GOPTION 0
  62 #endif
  63
  64 #ifdef HAVE_FREETYPE
  65 #include <pango/pangoft2.h>
  66 #endif
  67
  68 #include <libxml/parser.h>
  69 #include <libxml/xmlerror.h>
  70
  71 #ifdef G_OS_WIN32
  72 #include <direct.h>
  73 #define mkdir(s,a) _mkdir(s)
  74 #endif
  75
  76 #include "intl.h"
  77 #include "app_procs.h"
  78 #include "object.h"
  79 #include "color.h"
  80 #include "tool.h"
  81 #include "interface.h"
  82 #include "modify_tool.h"
  83 #include "group.h"
  84 #include "message.h"
  85 #include "display.h"
  86 #include "layer_dialog.h"
  87 #include "load_save.h"
  88 #include "preferences.h"
  89 #include "dia_dirs.h"
  90 #include "render_eps.h"
  91 #include "sheet.h"
  92 #include "plug-ins.h"
  93 #include "recent_files.h"
  94 #include "authors.h"
  95 #include "autosave.h"
  96 #include "dynamic_refresh.h"
  97 #include "dia_image.h"
  98 #include "persistence.h"
  99 #include "sheets.h"
 100 #include "utils.h"
 101
 102 #if defined(HAVE_LIBPNG) && defined(HAVE_LIBART)
 103 extern DiaExportFilter png_export_filter;
 104 #endif
 105
 106 static gboolean
 107 handle_initial_diagram(const char *input_file_name,
 108                        const char *export_file_name,
 109                        const char *export_file_format,
 110                        const char *size,
 111                        char *show_layers);
 112
 113 static void create_user_dirs(void);
 114 static PluginInitResult internal_plugin_init(PluginInfo *info);
 115 static void process_opts(int argc, char **argv,
 116 #if USE_GOPTION
 117                          GOptionContext* context, GOptionEntry options[],
 118 #elif defined HAVE_POPT
 119                          poptContext poptCtx, struct poptOption options[],
 120 #endif
 121                          GSList **files, char **export_file_name,
 122                          char **export_file_format, char **size,
 123                          char **show_layers, gboolean *nosplash);
 124 static gboolean handle_all_diagrams(GSList *files, char *export_file_name,
 125                                     char *export_file_format, char *size, char *show_layers);
 126 static void print_credits(gboolean credits);
 127
 128 static gboolean dia_is_interactive = TRUE;
 129 static void
 130 stderr_message_internal(const char *title, const char *fmt,
 131                         va_list *args,  va_list *args2);
 132
 133 static void
 134 stderr_message_internal(const char *title, const char *fmt,
 135                         va_list *args,  va_list *args2)
 136 {
 137   static gchar *buf = NULL;
 138   static gint   alloc = 0;
 139   gint len;
 140
 141   len = format_string_length_upper_bound (fmt, args);
 142
 143   if (len >= alloc) {
 144     if (buf)
 145       g_free (buf);
 146
 147     alloc = nearest_pow (MAX(len + 1, 1024));
 148
 149     buf = g_new (char, alloc);
 150   }
 151
 152   vsprintf (buf, fmt, *args2);
 153
 154   fprintf(stderr,
 155           "%s: %s\n",
 156           title,buf);
 157 }
 158
 159 #ifdef GNOME
 160
 161 static void
 162 session_die (gpointer client_data)
 163 {
 164   gtk_main_quit ();
 165 }
 166
 167 static int
 168 save_state (GnomeClient        *client,
 169             gint                phase,
 170             GnomeRestartStyle   save_style,
 171             gint                shutdown,
 172             GnomeInteractStyle  interact_style,
 173             gint                fast,
 174             gpointer            client_data)
 175 {
 176   gchar *argv[20];
 177   gint i = 0;
 178   GList *l;
 179   Diagram *dia;
 180
 181   argv[i++] = "dia";
 182
 183   for(l = dia_open_diagrams(); l != NULL; l = g_list_next(l)) {
 184     dia = (Diagram *)l->data;
 185     if(!dia->unsaved) {
 186       argv[i++] = dia->filename;
 187     }
 188   }
 189
 190   gnome_client_set_restart_command (client, i, argv);
 191   gnome_client_set_clone_command (client, i, argv);
 192
 193   return TRUE;
 194 }
 195 #endif
 196
 197 char *
 198 build_output_file_name(const char *infname, const char *format)
 199 {
 200   /* FIXME: probably overly confident... */
 201   char *p = strrchr(infname,'.');
 202   char *tmp;
 203   if (!p) {
 204     return g_strconcat(infname,".",format,NULL);
 205   }
 206   tmp = g_malloc0(strlen(infname)+1+strlen(format)+1);
 207   memcpy(tmp,infname,p-infname);
 208   strcat(tmp,".");
 209   strcat(tmp,format);
 210   return tmp;
 211 }
 212
 213 /* Handle the string between commas. We have either of:
 214  *
 215  * 1. XX, the number XX
 216  * 2. -XX, every number until XX
 217  * 3. XX-, every number from XX until n_layers
 218  * 4. XX-YY, every number between XX-YY
 219  */
 220 static void
 221 show_layers_parse_numbers(DiagramData *diagdata, gboolean *visible_layers, gint n_layers, const char *str)
 222 {
 223   char *p;
 224   unsigned long int low = 0;
 225   unsigned long int high = n_layers;
 226   unsigned long int i;
 227
 228   if (str == NULL)
 229     return;
 230
 231   /* Case 2, starts with '-' */
 232   if (*str == '-') {
 233     str++;
 234     low = 0;
 235     high = strtoul(str, &p, 10)+1;
 236     /* This must be a number (otherwise we would have called parse_name) */
 237     g_assert(p != str);
 238   }
 239   else {
 240     /* Case 1, 3 or 4 */
 241     low = strtoul(str, &p, 10);
 242     high = low+1; /* Assume case 1 */
 243     g_assert(p != str);
 244     if (*p == '-')
 245       {
 246         /* Case 3 or 4 */
 247         str = p + 1;
 248         if (*str == '\0') /* Case 3 */
 249           high = n_layers;
 250         else
 251           {
 252             high = strtoul(str, &p, 10)+1;
 253             g_assert(p != str);
 254           }
 255       }
 256   }
 257
 258   if ( high <= low ) {
 259     /* This is not an errror */
 260     g_print(_("Warning: invalid layer range %lu - %lu\n"), low, high-1 );
 261     return;
 262   }
 263   if (high > n_layers)
 264     high = n_layers;
 265
 266   /* Set the visible layers */
 267   for ( i = low; i < high; i++ )
 268     {
 269       Layer *lay = (Layer *)g_ptr_array_index(diagdata->layers, i);
 270
 271       if (visible_layers[i] == TRUE)
 272         g_print(_("Warning: Layer %lu (%s) selected more than once.\n"), i, lay->name);
 273       visible_layers[i] = TRUE;
 274     }
 275 }
 276
 277 static void
 278 show_layers_parse_word(DiagramData *diagdata, gboolean *visible_layers, gint n_layers, const char *str)
 279 {
 280   GPtrArray *layers = diagdata->layers;
 281   gboolean found = FALSE;
 282
 283   /* Apply --show-layers=LAYER,LAYER,... switch. 13.3.2004 sampo@iki.fi */
 284   if (layers) {
 285     int len,k = 0;
 286     Layer *lay;
 287     char *p;
 288     for (k = 0; k < layers->len; k++) {
 289       lay = (Layer *)g_ptr_array_index(layers, k);
 290
 291       if (lay->name) {
 292         len =  strlen(lay->name);
 293         if ((p = strstr(str, lay->name)) != NULL) {
 294           if (((p == str) || (p[-1] == ','))    /* zap false positives */
 295               && ((p[len] == 0) || (p[len] == ','))){
 296             found = TRUE;
 297             if (visible_layers[k] == TRUE)
 298               g_print(_("Warning: Layer %d (%s) selected more than once.\n"), k, lay->name);
 299             visible_layers[k] = TRUE;
 300           }
 301         }
 302       }
 303     }
 304   }
 305
 306   if (found == FALSE)
 307     g_print(_("Warning: There is no layer named %s\n"), str);
 308 }
 309
 310 static void
 311 show_layers_parse_string(DiagramData *diagdata, gboolean *visible_layers, gint n_layers, const char *str)
 312 {
 313   gchar **pp;
 314   int i;
 315
 316   pp = g_strsplit(str, ",", 100);
 317
 318   for (i = 0; pp[i]; i++) {
 319     gchar *p = pp[i];
 320
 321     /* Skip the empty string */
 322     if (strlen(p) == 0)
 323       continue;
 324
 325     /* If the string is only numbers and '-' chars, it is parsed as a
 326      * number range. Otherwise it is parsed as a layer name.
 327      */
 328     if (strlen(p) != strspn(p, "0123456789-") )
 329       show_layers_parse_word(diagdata, visible_layers, n_layers, p);
 330     else
 331       show_layers_parse_numbers(diagdata, visible_layers, n_layers, p);
 332   }
 333
 334   g_strfreev(pp);
 335 }
 336
 337
 338 static void
 339 handle_show_layers(DiagramData *diagdata, const char *show_layers)
 340 {
 341   gboolean *visible_layers;
 342   Layer *layer;
 343   int i;
 344
 345   visible_layers = g_malloc(diagdata->layers->len * sizeof(gboolean));
 346   /* Assume all layers are non-visible */
 347   for (i=0;i<diagdata->layers->len;i++)
 348     visible_layers[i] = FALSE;
 349
 350   /* Split the layer-range by commas */
 351   show_layers_parse_string(diagdata, visible_layers, diagdata->layers->len,
 352                            show_layers);
 353
 354   /* Set the visibility of the layers */
 355   for (i=0;i<diagdata->layers->len;i++) {
 356     layer = g_ptr_array_index(diagdata->layers, i);
 357
 358     if (visible_layers[i] == TRUE)
 359       layer->visible = TRUE;
 360     else
 361       layer->visible = FALSE;
 362   }
 363   g_free(visible_layers);
 364 }
 365
 366
 367 const char *argv0 = NULL;
 368
 369 /** Convert infname to outfname, using input filter inf and export filter
 370  * ef.  If either is null, try to guess them.
 371  * size might be NULL.
 372  */
 373 static gboolean
 374 do_convert(const char *infname,
 375            const char *outfname, DiaExportFilter *ef,
 376            const char *size,
 377            char *show_layers)
 378 {
 379   DiaImportFilter *inf;
 380   DiagramData *diagdata = NULL;
 381
 382   inf = filter_guess_import_filter(infname);
 383   if (!inf)
 384     inf = &dia_import_filter;
 385
 386   if (ef == NULL) {
 387     ef = filter_guess_export_filter(outfname);
 388     if (!ef) {
 389       g_error(_("%s error: don't know how to export into %s\n"),
 390               argv0,outfname);
 391       exit(1);
 392     }
 393   }
 394
 395   dia_is_interactive = FALSE;
 396
 397   if (0==strcmp(infname,outfname)) {
 398     g_error(_("%s error: input and output file name is identical: %s"),
 399             argv0, infname);
 400     exit(1);
 401   }
 402
 403   diagdata = g_object_new (DIA_TYPE_DIAGRAM_DATA, NULL);
 404
 405   if (!inf->import_func(infname,diagdata,inf->user_data)) {
 406     g_error(_("%s error: need valid input file %s\n"),
 407             argv0, infname);
 408     exit(1);
 409   }
 410
 411   /* Apply --show-layers */
 412   if (show_layers)
 413     handle_show_layers(diagdata, show_layers);
 414
 415   /* Do our best in providing the size to the filter, but don't abuse user_data
 416    * too much for it. It _must not_ be changed after initialization and there
 417    * are quite some filter selecting their output format by it. --hb
 418    */
 419   if (size) {
 420     if (ef == filter_get_by_name ("png-libart")) /* the warning we get is appropriate, don't cast */
 421       ef->export_func(diagdata, outfname, infname, size);
 422     else {
 423       g_warning ("--size parameter unsupported for %s filter",
 424                  ef->unique_name ? ef->unique_name : "selected");
 425       ef->export_func(diagdata, outfname, infname, ef->user_data);
 426     }
 427   }
 428   else
 429     ef->export_func(diagdata, outfname, infname, ef->user_data);
 430   /* if (!quiet) */ fprintf(stdout,
 431                       _("%s --> %s\n"),
 432                         infname,outfname);
 433   g_object_unref(diagdata);
 434   return TRUE;
 435 }
 436
 437 void debug_break(void); /* shut gcc up */
 438 int debug_break_dont_optimize = 1;
 439 void
 440 debug_break(void)
 441 {
 442   if (debug_break_dont_optimize > 0)
 443     debug_break_dont_optimize -= 1;
 444 }
 445
 446 static void
 447 dump_dependencies(void)
 448 {
 449 #ifdef __GNUC__
 450   g_print ("Compiler: GCC " __VERSION__ "\n");
 451 #elif defined _MSC_VER
 452   g_print ("Compiler: MSC %d\n", _MSC_VER);
 453 #else
 454   g_print ("Compiler: unknown\n");
 455 #endif
 456   /* some flags/defines which may be interesting */
 457   g_print ("  with : "
 458 #ifdef G_THREADS_ENABLED
 459   "threads "
 460 #endif
 461 #ifdef HAVE_CAIRO
 462   "cairo "
 463 #endif
 464 #ifdef GNOME
 465   "gnome "
 466 #endif
 467 #ifdef HAVE_GNOMEPRINT
 468   "gnomeprint "
 469 #endif
 470 #ifdef HAVE_LIBART
 471   "libart "
 472 #endif
 473   "\n");
 474
 475   /* print out all those dependies, both compile and runtime if possible
 476    * Note: this is not meant to be complete but does only include libaries
 477    * which may or have cause(d) us trouble in some versions
 478    */
 479   g_print ("Library versions\n");
 480 #ifdef HAVE_LIBPNG
 481   g_print ("libpng  : %s (%s)\n", png_get_header_ver(NULL), PNG_LIBPNG_VER_STRING);
 482 #endif
 483 #ifdef HAVE_FREETYPE
 484   {
 485     FT_Library ft_library;
 486     FT_Int     ft_major_version;
 487     FT_Int     ft_minor_version;
 488     FT_Int     ft_micro_version;
 489
 490     if (FT_Init_FreeType (&ft_library) == 0) {
 491       FT_Library_Version (ft_library,
 492                           &ft_major_version,
 493                           &ft_minor_version,
 494                           &ft_micro_version);
 495
 496       g_print ("freetype: %d.%d.%d\n", ft_major_version, ft_minor_version, ft_micro_version);
 497       FT_Done_FreeType (ft_library);
 498     }
 499     else
 500       g_print ("freetype: ?.?.?\n");
 501   }
 502 #endif
 503   {
 504     gint   libxml_version   = atoi(xmlParserVersion);
 505
 506     g_print ("libxml  : %d.%d.%d (%s)\n",
 507              libxml_version / 100 / 100, libxml_version / 100 % 100, libxml_version % 100, LIBXML_DOTTED_VERSION);
 508   }
 509   g_print ("glib    : %d.%d.%d (%d.%d.%d)\n",
 510            glib_major_version, glib_minor_version, glib_micro_version,
 511            GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
 512   g_print ("pango   : version not available\n"); /* Pango does not provide such */
 513 #if 0
 514   {
 515     gchar  linkedname[1024];
 516     gint   len = 0;
 517
 518     /* relying on PREFIX is wrong */
 519     if ((len = readlink (PREFIX "/lib/libpango-1.0.so", linkedname, 1023)) > 0) {
 520       /* man 2 readlink : does not append a  NUL  character */
 521       linkedname[len] = '\0';
 522       g_print ("%s/%s\n", PREFIX, linkedname);
 523     }
 524   }
 525 #endif
 526   g_print ("gtk+    : %d.%d.%d (%d.%d.%d)\n",
 527            gtk_major_version, gtk_minor_version, gtk_micro_version,
 528            GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
 529
 530 #if 0
 531   /* we could read $PREFIX/share/gnome-about/gnome-version.xml
 532    * but is it worth the effort ? */
 533   g_print ("gnome   : %d.%d.%d (%d.%d.%d)\n"
 534            gnome_major_version, gnome_minor_version, gnome_micro_version,
 535            GNOME_MAJOR_VERSION, GNOME_MINOR_VERSION, GNOME_MICRO_VERSION);
 536 #endif
 537 }
 538
 539 gboolean
 540 app_is_interactive(void)
 541 {
 542   return dia_is_interactive;
 543 }
 544
 545 /** Handle loading of diagrams given on command line, including conversions.
 546  * Returns TRUE if any automatic conversions were performed.
 547  * Note to future hackers:  'size' is currently the only argument that can be
 548  * sent to exporters.  If more arguments are desired, please don't just add
 549  * even more arguments, but create a more general system.
 550  */
 551 static gboolean
 552 handle_initial_diagram(const char *in_file_name,
 553                        const char *out_file_name,
 554                        const char *export_file_format,
 555                        const char *size,
 556                        char* show_layers) {
 557   DDisplay *ddisp = NULL;
 558   Diagram *diagram = NULL;
 559   gboolean made_conversions = FALSE;
 560
 561   if (export_file_format) {
 562     char *export_file_name = NULL;
 563     DiaExportFilter *ef = NULL;
 564
 565     /* First try guessing based on extension */
 566     export_file_name = build_output_file_name(in_file_name,
 567                                               export_file_format);
 568
 569     /* to make the --size hack even uglier but work again for the only filter supporting it */
 570     if (   size && strcmp(export_file_format, "png") == 0)
 571       ef = filter_get_by_name ("png-libart");
 572     if (!ef)
 573       ef = filter_guess_export_filter(export_file_name);
 574     if (ef == NULL) {
 575       ef = filter_get_by_name(export_file_format);
 576       if (ef == NULL) {
 577         g_error(_("Can't find output format/filter %s\n"), export_file_format);
 578         return FALSE;
 579       }
 580       g_free (export_file_name);
 581       export_file_name = build_output_file_name(in_file_name,
 582                                                 ef->extensions[0]);
 583     }
 584     made_conversions |= do_convert(in_file_name,
 585       (out_file_name != NULL?out_file_name:export_file_name),
 586                                    ef, size, show_layers);
 587     g_free(export_file_name);
 588   } else if (out_file_name) {
 589     DiaExportFilter *ef = NULL;
 590
 591     /* if this looks like an ugly hack to you, agreed ;)  */
 592     if (size && strstr(out_file_name, ".png"))
 593       ef = filter_get_by_name ("png-libart");
 594
 595     made_conversions |= do_convert(in_file_name, out_file_name, ef,
 596                                    size, show_layers);
 597   } else {
 598     if (g_file_test(in_file_name, G_FILE_TEST_EXISTS)) {
 599       diagram = diagram_load (in_file_name, NULL);
 600     } else
 601       diagram = new_diagram (in_file_name);
 602
 603     if (diagram != NULL) {
 604       diagram_update_extents(diagram);
 605       if (app_is_interactive()) {
 606         layer_dialog_set_diagram(diagram);
 607         /* the display initial diagram holds two references */
 608         ddisp = new_display(diagram);
 609       } else {
 610         g_object_unref(diagram);
 611       }
 612     }
 613   }
 614   return made_conversions;
 615 }
 616
 617 #ifdef G_OS_WIN32
 618 static void
 619 myXmlErrorReporting (void *ctx, const char* msg, ...)
 620 {
 621   va_list args;
 622   gchar *string;
 623
 624   va_start(args, msg);
 625   string = g_strdup_vprintf (msg, args);
 626   g_print ("%s", string ? string : "xml error (null)?");
 627   va_end(args);
 628
 629   g_free(string);
 630 }
 631 #endif
 632
 633 #ifdef HAVE_FREETYPE
 634 /* Translators:  This is an option, not to be translated */
 635 #define EPS_PANGO "eps-pango, "
 636 #else
 637 #define EPS_PANGO ""
 638 #endif
 639
 640 #ifdef G_OS_WIN32
 641 /* Translators:  This is an option, not to be translated */
 642 #define WMF "wmf, "
 643 #else
 644 #define WMF ""
 645 #endif
 646
 647 void
 648 app_init (int argc, char **argv)
 649 {
 650   static gboolean nosplash = FALSE;
 651   static gboolean credits = FALSE;
 652   static gboolean version = FALSE;
 653   static gboolean verbose = FALSE;
 654   static gboolean log_to_stderr = FALSE;
 655 #ifdef GNOME
 656   GnomeClient *client;
 657 #endif
 658   static char *export_file_name = NULL;
 659   static char *export_file_format = NULL;
 660   static char *size = NULL;
 661   static char *show_layers = NULL;
 662   gboolean made_conversions = FALSE;
 663   GSList *files = NULL;
 664
 665   gchar *export_format_string =
 666      /* Translators:  The argument is a list of options, not to be translated */
 667     g_strdup_printf(_("Select the filter/format out of: %s"),
 668                     "cgm, dia, dxf, eps, eps-builtin, " EPS_PANGO
 669                     "fig, mp, plt, hpgl, png ("
 670 #  if defined(HAVE_LIBPNG) && defined(HAVE_LIBART)
 671                     "png-libart, "
 672 #  endif
 673 #  ifdef HAVE_CAIRO
 674                     "cairo-png, cairo-alpha-png, "
 675 #  endif
 676                     /* we always have pixbuf but don't know exactly all it's *few* save formats */
 677                     "pixbuf-png), jpg, "
 678                     "shape, svg, tex, " WMF
 679                     "wpg");
 680
 681 #if USE_GOPTION
 682   GOptionContext *context = NULL;
 683   static GOptionEntry options[] =
 684   {
 685     {"export", 'e', 0, G_OPTION_ARG_STRING, NULL /* &export_file_name */,
 686      N_("Export loaded file and exit"), N_("OUTPUT")},
 687     {"filter",'t', 0, G_OPTION_ARG_STRING, NULL /* &export_file_format */,
 688      NULL /* &export_format_string */, N_("TYPE") },
 689     {"size", 's', 0, G_OPTION_ARG_STRING, NULL,
 690      N_("Export graphics size"), N_("WxH")},
 691     {"show-layers", 'L', 0, G_OPTION_ARG_STRING, NULL,
 692      N_("Show only specified layers (e.g. when exporting). Can be either the layer name or a range of layer numbers (X-Y)"),
 693      N_("LAYER,LAYER,...")},
 694     {"nosplash", 'n', 0, G_OPTION_ARG_NONE, &nosplash,
 695      N_("Don't show the splash screen"), NULL },
 696     {"log-to-stderr", 'l', 0, G_OPTION_ARG_NONE, &log_to_stderr,
 697      N_("Send error messages to stderr instead of showing dialogs."), NULL },
 698     {"credits", 'c', 0, G_OPTION_ARG_NONE, &credits,
 699      N_("Display credits list and exit"), NULL },
 700     {"verbose", 0, 0, G_OPTION_ARG_NONE, &verbose,
 701      N_("Generate verbose output"), NULL },
 702     {"version", 'v', 0, G_OPTION_ARG_NONE, &version,
 703      N_("Display version and exit"), NULL },
 704     { NULL }
 705   };
 706 #elif defined HAVE_POPT
 707   poptContext context = NULL;
 708   struct poptOption options[] =
 709   {
 710     {"export", 'e', POPT_ARG_STRING, NULL /* &export_file_name */, 0,
 711      N_("Export loaded file and exit"), N_("OUTPUT")},
 712     {"filter",'t', POPT_ARG_STRING, NULL /* &export_file_format */,
 713      0, export_format_string, N_("TYPE")
 714     },
 715     {"size", 's', POPT_ARG_STRING, NULL, 0,
 716      N_("Export graphics size"), N_("WxH")},
 717     {"show-layers", 'L', POPT_ARG_STRING, NULL, 0,  /* 13.3.2004 sampo@iki.fi */
 718      N_("Show only specified layers (e.g. when exporting). Can be either the layer name or a range of layer numbers (X-Y)"),
 719      N_("LAYER,LAYER,...")},
 720     {"nosplash", 'n', POPT_ARG_NONE, &nosplash, 0,
 721      N_("Don't show the splash screen"), NULL },
 722     {"log-to-stderr", 'l', POPT_ARG_NONE, &log_to_stderr, 0,
 723      N_("Send error messages to stderr instead of showing dialogs."), NULL },
 724     {"credits", 'c', POPT_ARG_NONE, &credits, 0,
 725      N_("Display credits list and exit"), NULL },
 726     {"verbose", 0, POPT_ARG_NONE, &verbose, 0,
 727      N_("Generate verbose output"), NULL },
 728     {"version", 'v', POPT_ARG_NONE, &version, 0,
 729      N_("Display version and exit"), NULL },
 730     {"help", 'h', POPT_ARG_NONE, 0, 1, N_("Show this help message") },
 731     {(char *) NULL, '\0', 0, NULL, 0}
 732   };
 733 #endif
 734
 735 #if USE_GOPTION
 736   options[0].arg_data = &export_file_name;
 737   options[1].arg_data = &export_file_format;
 738   options[1].description = export_format_string;
 739   options[2].arg_data = &size;
 740   options[3].arg_data = &show_layers;
 741 #elif defined HAVE_POPT
 742   options[0].arg = &export_file_name;
 743   options[1].arg = &export_file_format;
 744   options[2].arg = &size;
 745   options[3].arg = &show_layers;
 746 #endif
 747
 748   argv0 = (argc > 0) ? argv[0] : "(none)";
 749
 750   gtk_set_locale();
 751   setlocale(LC_NUMERIC, "C");
 752
 753   bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
 754   textdomain(GETTEXT_PACKAGE);
 755
 756   process_opts(argc, argv,
 757 #if defined HAVE_POPT || USE_GOPTION
 758                context, options,
 759 #endif
 760                &files,
 761              &export_file_name, &export_file_format, &size, &show_layers, &nosplash);
 762
 763 #if defined ENABLE_NLS && defined HAVE_BIND_TEXTDOMAIN_CODESET
 764   bind_textdomain_codeset(GETTEXT_PACKAGE,"UTF-8");
 765 #endif
 766   textdomain(GETTEXT_PACKAGE);
 767
 768   if (argv && dia_is_interactive && !version) {
 769 #ifdef GNOME
 770     GnomeProgram *program =
 771       gnome_program_init (PACKAGE, VERSION, LIBGNOMEUI_MODULE,
 772                           argc, argv,
 773                           /* haven't found a quick way to pass GOption here */
 774                           GNOME_PARAM_POPT_TABLE, options,
 775                           GNOME_PROGRAM_STANDARD_PROPERTIES,
 776                           GNOME_PARAM_NONE);
 777     g_object_get(program, "popt-context", &context, NULL);
 778     client = gnome_master_client();
 779     if(client == NULL) {
 780       g_warning(_("Can't connect to session manager!\n"));
 781     }
 782     else {
 783       g_signal_connect(GTK_OBJECT (client), "save_yourself",
 784                        G_CALLBACK (save_state), NULL);
 785       g_signal_connect(GTK_OBJECT (client), "die",
 786                        G_CALLBACK (session_die), NULL);
 787     }
 788
 789     /* This smaller icon is 48x48, standard Gnome size */
 790     gnome_window_icon_set_default_from_file (GNOME_ICONDIR"/dia_gnome_icon.png");
 791
 792 #else
 793 #  ifdef G_THREADS_ENABLED
 794     g_thread_init (NULL);
 795 #  endif
 796     gtk_init(&argc, &argv);
 797 #endif
 798   }
 799   else {
 800 #  ifdef G_THREADS_ENABLED
 801     g_thread_init (NULL);
 802 #  endif
 803     g_type_init();
 804   }
 805
 806   /* done with option parsing, don't leak */
 807   g_free(export_format_string);
 808
 809   if (version) {
 810 #if (defined __TIME__) && (defined __DATE__)
 811     /* TRANSLATOR: 2nd and 3rd %s are time and date respectively. */
 812     printf(g_locale_from_utf8(_("Dia version %s, compiled %s %s\n"), -1, NULL, NULL, NULL), VERSION, __TIME__, __DATE__);
 813 #else
 814     printf(g_locale_from_utf8(_("Dia version %s\n"), -1, NULL, NULL, NULL), VERSION);
 815 #endif
 816     if (verbose)
 817       dump_dependencies();
 818     exit(0);
 819   }
 820
 821   if (!dia_is_interactive)
 822     log_to_stderr = TRUE;
 823   else {
 824 #ifdef G_OS_WIN32
 825     dia_redirect_console ();
 826 #endif
 827   }
 828
 829   if (log_to_stderr)
 830     set_message_func(stderr_message_internal);
 831
 832   print_credits(credits);
 833
 834   LIBXML_TEST_VERSION;
 835
 836 #ifdef G_OS_WIN32
 837   xmlSetGenericErrorFunc(NULL, myXmlErrorReporting);
 838 #endif
 839
 840   stdprops_init();
 841
 842   if (dia_is_interactive) {
 843     dia_image_init();
 844
 845     gdk_rgb_init();
 846
 847     gtk_rc_parse("diagtkrc");
 848
 849     if (!nosplash) {
 850       app_splash_init("");
 851     }
 852   }
 853
 854   if (dia_is_interactive)
 855     create_user_dirs();
 856
 857   /* Init cursors: */
 858   if (dia_is_interactive) {
 859     color_init();
 860     default_cursor = gdk_cursor_new(GDK_LEFT_PTR);
 861     ddisplay_set_all_cursor(default_cursor);
 862   }
 863
 864   object_registry_init();
 865
 866   dia_register_plugins();
 867   dia_register_builtin_plugin(internal_plugin_init);
 868
 869   load_all_sheets();     /* new mechanism */
 870
 871   dia_object_defaults_load (NULL, TRUE /* prefs.object_defaults_create_lazy */);
 872
 873   debug_break();
 874
 875   if (object_get_type("Standard - Box") == NULL) {
 876     message_error(_("Couldn't find standard objects when looking for "
 877                   "object-libs, exiting...\n"));
 878     g_error( _("Couldn't find standard objects when looking for "
 879             "object-libs, exiting...\n"));
 880     exit(1);
 881   }
 882
 883   persistence_load();
 884
 885   /** Must load prefs after persistence */
 886   prefs_init();
 887
 888   if (dia_is_interactive) {
 889
 890     /* further initialization *before* reading files */
 891     active_tool = create_modify_tool();
 892
 893     create_toolbox();
 894
 895     persistence_register_window_create("layer_window",
 896                                        (NullaryFunc*)&create_layer_dialog);
 897
 898
 899     /*fill recent file menu */
 900     recent_file_history_init();
 901
 902     /* Set up autosave to check every 5 minutes */
 903     gtk_timeout_add(5*60*1000, autosave_check_autosave, NULL);
 904
 905     create_tree_window();
 906
 907     persistence_register_window_create("sheets_main_dialog",
 908                                        (NullaryFunc*)&sheets_dialog_create);
 909
 910
 911     /* In current setup, we can't find the autosaved files. */
 912     /*autosave_restore_documents();*/
 913
 914   }
 915
 916   made_conversions = handle_all_diagrams(files, export_file_name,
 917                                          export_file_format, size, show_layers);
 918   if (dia_is_interactive && files == NULL) {
 919     gchar *filename = g_filename_from_utf8(_("Diagram1.dia"), -1, NULL, NULL, NULL);
 920     Diagram *diagram = new_diagram (filename);
 921     g_free(filename);
 922
 923
 924     if (diagram != NULL) {
 925       diagram_update_extents(diagram);
 926       if (app_is_interactive()) {
 927         layer_dialog_set_diagram(diagram);
 928         new_display(diagram);
 929       }
 930     }
 931   }
 932   g_slist_free(files);
 933   if (made_conversions) exit(0);
 934
 935   dynobj_refresh_init();
 936 }
 937
 938 #if 0
 939 /* app_procs.c: warning: `set_true_callback' defined but not used */
 940 static void
 941 set_true_callback(GtkWidget *w, int *data)
 942 {
 943   *data = TRUE;
 944 }
 945 #endif
 946
 947 gboolean
 948 app_exit(void)
 949 {
 950   GList *list;
 951   GSList *slist;
 952
 953   /*
 954    * The following "solves" a crash related to a second call of app_exit,
 955    * after gtk_main_quit was called. It may be a win32 gtk-1.3.x bug only
 956    * but the check shouldn't hurt on *ix either.          --hb
 957    */
 958   static gboolean app_exit_once = FALSE;
 959
 960   if (app_exit_once) {
 961     g_error(_("This shouldn't happen.  Please file a bug report at bugzilla.gnome.org\n"
 962               "describing how you can cause this message to appear.\n"));
 963     return FALSE;
 964   }
 965
 966   if (diagram_modified_exists()) {
 967     GtkWidget *dialog;
 968     GtkWidget *button;
 969
 970     dialog = gtk_message_dialog_new(
 971                NULL, GTK_DIALOG_MODAL,
 972                GTK_MESSAGE_QUESTION,
 973                GTK_BUTTONS_NONE, /* no standard buttons */
 974                _("Modified diagrams exist.\n"
 975                  "Are you sure you want to quit Dia\n"
 976                  "without saving them?"));
 977     gtk_window_set_title (GTK_WINDOW(dialog), _("Quit Dia"));
 978
 979     button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
 980     gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_CANCEL);
 981     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 982     gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
 983
 984     button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
 985     gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);
 986
 987     gtk_widget_show_all (dialog);
 988
 989     if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
 990       gtk_widget_destroy(dialog);
 991       return FALSE;
 992     }
 993     gtk_widget_destroy(dialog);
 994   }
 995   prefs_save();
 996
 997   persistence_save();
 998
 999   dynobj_refresh_finish();
1000
1001   dia_object_defaults_save (NULL);
1002
1003   /* Free loads of stuff (toolbox) */
1004
1005   list = dia_open_diagrams();
1006   while (list!=NULL) {
1007     Diagram *dia = (Diagram *)list->data;
1008     list = g_list_next(list);
1009
1010     slist = dia->displays;
1011     while (slist!=NULL) {
1012       DDisplay *ddisp = (DDisplay *)slist->data;
1013       slist = g_slist_next(slist);
1014
1015       gtk_widget_destroy(ddisp->shell);
1016
1017     }
1018     /* The diagram is freed when the last display is destroyed */
1019
1020   }
1021
1022   /* save pluginrc */
1023   if (dia_is_interactive)
1024     dia_pluginrc_write();
1025
1026   gtk_main_quit();
1027 #ifndef G_OS_WIN32
1028   /* This printf seems to prevent a race condition with unrefs. */
1029   /* Yuck.  -Lars */
1030   g_print(_("Thank you for using Dia.\n"));
1031 #endif
1032   app_exit_once = TRUE;
1033
1034   return TRUE;
1035 }
1036
1037 static void create_user_dirs(void)
1038 {
1039   gchar *dir, *subdir;
1040
1041 #ifdef G_OS_WIN32
1042   /* not necessary to quit the program with g_error, everywhere else
1043    * dia_config_filename appears to be used. Spit out a warning ...
1044    */
1045   if (!g_get_home_dir())
1046   {
1047     g_warning(_("Could not create per-user Dia config directory"));
1048     return; /* ... and return. Probably removes my one and only FAQ. --HB */
1049   }
1050 #endif
1051   dir = g_strconcat(g_get_home_dir(), G_DIR_SEPARATOR_S ".dia", NULL);
1052   if (mkdir(dir, 0755) && errno != EEXIST)
1053 #ifndef G_OS_WIN32
1054     g_error(_("Could not create per-user Dia config directory"));
1055 #else /* HB: it this really a reason to exit the program on *nix ? */
1056     g_warning(_("Could not create per-user Dia config directory. Please make "
1057         "sure that the environment variable HOME points to an existing directory."));
1058 #endif
1059
1060   /* it is no big deal if these directories can't be created */
1061   subdir = g_strconcat(dir, G_DIR_SEPARATOR_S "objects", NULL);
1062   mkdir(subdir, 0755);
1063   g_free(subdir);
1064   subdir = g_strconcat(dir, G_DIR_SEPARATOR_S "shapes", NULL);
1065   mkdir(subdir, 0755);
1066   g_free(subdir);
1067   subdir = g_strconcat(dir, G_DIR_SEPARATOR_S "sheets", NULL);
1068   mkdir(subdir, 0755);
1069   g_free(subdir);
1070
1071   g_free(dir);
1072 }
1073
1074 static PluginInitResult
1075 internal_plugin_init(PluginInfo *info)
1076 {
1077   if (!dia_plugin_info_init(info, "Internal",
1078                             _("Objects and filters internal to dia"),
1079                             NULL, NULL))
1080     return DIA_PLUGIN_INIT_ERROR;
1081
1082   /* register the group object type */
1083   object_register_type(&group_type);
1084
1085   /* register import filters */
1086   filter_register_import(&dia_import_filter);
1087
1088   /* register export filters */
1089   /* Standard Dia format */
1090   filter_register_export(&dia_export_filter);
1091   /* EPS with PS fonts */
1092   filter_register_export(&eps_export_filter);
1093 #ifdef HAVE_FREETYPE
1094   /* EPS with Pango rendering */
1095   filter_register_export(&eps_ft2_export_filter);
1096 #endif
1097 #if defined(HAVE_LIBPNG) && defined(HAVE_LIBART)
1098   /* PNG with libart rendering */
1099   filter_register_export(&png_export_filter);
1100 #endif
1101
1102   return DIA_PLUGIN_INIT_OK;
1103 }
1104
1105 /* Note: running in locale encoding */
1106 static void
1107 process_opts(int argc, char **argv,
1108 #if USE_GOPTION
1109              GOptionContext *context, GOptionEntry options[],
1110 #elif defined HAVE_POPT
1111              poptContext poptCtx, struct poptOption options[],
1112 #endif
1113              GSList **files, char **export_file_name,
1114              char **export_file_format, char **size,
1115              char **show_layers, gboolean* nosplash)
1116 {
1117 #if defined HAVE_POPT && !USE_GOPTION
1118   int rc = 0;
1119   poptCtx = poptGetContext(PACKAGE, argc, (const char **)argv, options, 0);
1120   poptSetOtherOptionHelp(poptCtx, _("[OPTION...] [FILE...]"));
1121   while (rc >= 0) {
1122     if((rc = poptGetNextOpt(poptCtx)) < -1) {
1123       fprintf(stderr,_("Error on option %s: %s.\nRun '%s --help' to see a full list of available command line options.\n"),
1124               poptBadOption(poptCtx, 0),
1125               poptStrerror(rc),
1126               argv[0]);
1127       exit(1);
1128     }
1129     if(rc == 1) {
1130       poptPrintHelp(poptCtx, stderr, 0);
1131       exit(0);
1132     }
1133   }
1134 #endif
1135   if (argv) {
1136 #if defined HAVE_POPT && !USE_GOPTION
1137       while (poptPeekArg(poptCtx)) {
1138           char *in_file_name = (char *)poptGetArg(poptCtx);
1139           if (*in_file_name != '\0')
1140             *files = g_slist_append(*files, in_file_name);
1141       }
1142       poptFreeContext(poptCtx);
1143 #elif USE_GOPTION
1144       GError *error = NULL;
1145       int i;
1146
1147       context = g_option_context_new(_("[FILE...]"));
1148       g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
1149 #  if GTK_CHECK_VERSION(2,5,7)
1150       /* at least Gentoo was providing GLib-2.6 but Gtk+-2.4.14 */
1151       g_option_context_add_group (context, gtk_get_option_group (FALSE));
1152 #  endif
1153       if (!g_option_context_parse (context, &argc, &argv, &error)) {
1154         g_print (error->message);
1155         g_error_free (error);
1156         g_option_context_free(context);
1157         exit(0);
1158       }
1159       if (argc < 2) {
1160         g_option_context_free(context);
1161         return;
1162       }
1163       for (i = 1; i < argc; i++) {
1164         if (!g_file_test (argv[i], G_FILE_TEST_IS_REGULAR)) {
1165           g_print (_("'%s' not found!\n"), argv[i]);
1166           g_option_context_free(context);
1167           exit(2);
1168         }
1169         *files = g_slist_append(*files, argv[i]);
1170       }
1171       g_option_context_free(context);
1172 #else
1173       int i;
1174
1175       for (i=1; i<argc; i++) {
1176           char *in_file_name = argv[i]; /* unless it's an option... */
1177
1178           if (0==strcmp(argv[i],"-t")) {
1179               if (i < (argc-1)) {
1180                   i++;
1181                   *export_file_format = argv[i];
1182                   continue;
1183               }
1184           } else if (0 == strcmp(argv[i],"-e")) {
1185               if (i < (argc-1)) {
1186                   i++;
1187                   *export_file_name = argv[i];
1188                   continue;
1189               }
1190           } else if (0 == strcmp(argv[i],"-s")) {
1191               if (i < (argc-1)) {
1192                   i++;
1193                   *size = argv[i];
1194                   continue;
1195               }
1196           } else if (0 == strcmp(argv[i],"-L")) {
1197               if (i < (argc-1)) {
1198                   i++;
1199                   *show_layers = argv[i];
1200                   continue;
1201               }
1202           } else if (0 == strcmp(argv[i],"-n")) {
1203               *nosplash = 1;
1204               continue;
1205           }
1206           *files = g_slist_append(*files, in_file_name);
1207       }
1208 #endif
1209   }
1210   if (*export_file_name || *export_file_format || *size)
1211     dia_is_interactive = FALSE;
1212 }
1213
1214 static gboolean
1215 handle_all_diagrams(GSList *files, char *export_file_name,
1216                     char *export_file_format, char *size, char *show_layers)
1217 {
1218   GSList *node = NULL;
1219   gboolean made_conversions = FALSE;
1220
1221   for (node = files; node; node = node->next) {
1222     made_conversions |=
1223       handle_initial_diagram(node->data, export_file_name,
1224                              export_file_format, size, show_layers);
1225   }
1226   return made_conversions;
1227 }
1228
1229 /* --credits option. Added by Andrew Ferrier.
1230
1231    Hopefully we're not ignoring anything too crucial by
1232    quitting directly after the credits.
1233
1234    The phrasing of the English here might need changing
1235    if we switch from plural to non-plural (say, only
1236    one maintainer).
1237 */
1238 static void
1239 print_credits(gboolean credits)
1240 {
1241   if (credits) {
1242       int i;
1243       const gint nauthors = (sizeof(authors) / sizeof(authors[0])) - 1;
1244       const gint ndocumentors = (sizeof(documentors) / sizeof(documentors[0])) - 1;
1245
1246       g_print(_("The original author of Dia was:\n\n"));
1247       for (i = 0; i < NUMBER_OF_ORIG_AUTHORS; i++) {
1248           g_print(authors[i]); g_print("\n");
1249       }
1250
1251       g_print(_("\nThe current maintainers of Dia are:\n\n"));
1252       for (i = NUMBER_OF_ORIG_AUTHORS; i < NUMBER_OF_ORIG_AUTHORS + NUMBER_OF_MAINTAINERS; i++) {
1253           g_print(authors[i]); g_print("\n");
1254       }
1255
1256       g_print(_("\nOther authors are:\n\n"));
1257       for (i = NUMBER_OF_ORIG_AUTHORS + NUMBER_OF_MAINTAINERS; i < nauthors; i++) {
1258           g_print(authors[i]); g_print("\n");
1259       }
1260
1261       g_print(_("\nDia is documented by:\n\n"));
1262       for (i = 0; i < ndocumentors; i++) {
1263           g_print(documentors[i]); g_print("\n");
1264       }
1265
1266       exit(0);
1267   }
1268 }
1269
1270 /* parses a string of the form "[0-9]*x[0-9]*" and transforms it into
1271    two long values width and height. */
1272 void
1273 parse_size(gchar *size, long *width, long *height)
1274 {
1275   if (size) {
1276     gchar** array = g_strsplit(size, "x", 3);
1277     *width  = (array[0])? strtol(array[0], NULL, 10): 0;
1278     *height = (array[1])? strtol(array[1], NULL, 10): 0;
1279     g_strfreev(array);
1280   }
1281   else {
1282     *width  = 0;
1283     *height = 0;
1284   }
1285 }