src/main.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15
  16 #include "cache.h"
  17 #include "collect.h"
  18 #include "collect-io.h"
  19 #include "dnd.h"
  20 #include "editors.h"
  21 #include "filedata.h"
  22 #include "filefilter.h"
  23 #include "fullscreen.h"
  24 #include "image-overlay.h"
  25 #include "img-view.h"
  26 #include "info.h"
  27 #include "layout.h"
  28 #include "layout_image.h"
  29 #include "menu.h"
  30 #include "pixbuf_util.h"
  31 #include "preferences.h"
  32 #include "rcfile.h"
  33 #include "remote.h"
  34 #include "similar.h"
  35 #include "slideshow.h"
  36 #include "utilops.h"
  37 #include "ui_bookmark.h"
  38 #include "ui_help.h"
  39 #include "ui_fileops.h"
  40 #include "ui_tabcomp.h"
  41 #include "ui_utildlg.h"
  42 #include "window.h"
  43
  44 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  45
  46
  47 #include <math.h>
  48 #ifdef G_OS_UNIX
  49 #include <pwd.h>
  50 #endif
  51
  52
  53 static RemoteConnection *remote_connection = NULL;
  54
  55
  56 /*
  57  *-----------------------------------------------------------------------------
  58  * misc (public)
  59  *-----------------------------------------------------------------------------
  60  */
  61
  62
  63 gdouble get_zoom_increment(void)
  64 {
  65         return ((options->image.zoom_increment != 0) ? (gdouble)options->image.zoom_increment / 10.0 : 1.0);
  66 }
  67
  68 gchar *utf8_validate_or_convert(gchar *text)
  69 {
  70         gint len;
  71
  72         if (!text) return NULL;
  73
  74         len = strlen(text);
  75         if (!g_utf8_validate(text, len, NULL))
  76                 {
  77                 gchar *conv_text;
  78
  79                 conv_text = g_convert(text, len, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
  80                 g_free(text);
  81                 text = conv_text;
  82                 }
  83
  84         return text;
  85 }
  86
  87 /* Borrowed from gtkfilesystemunix.c */
  88 gchar *expand_tilde(const gchar *filename)
  89 {
  90 #ifndef G_OS_UNIX
  91         return g_strdup(filename);
  92 #else
  93         const char *notilde;
  94         const char *slash;
  95         const char *home;
  96
  97         if (filename[0] != '~')
  98                 return g_strdup(filename);
  99
 100         notilde = filename + 1;
 101         slash = strchr(notilde, G_DIR_SEPARATOR);
 102         if (slash == notilde || !*notilde)
 103                 {
 104                 home = g_get_home_dir();
 105                 if (!home)
 106                         return g_strdup(filename);
 107                 }
 108         else
 109                 {
 110                 gchar *username;
 111                 struct passwd *passwd;
 112
 113                 if (slash)
 114                         username = g_strndup(notilde, slash - notilde);
 115                 else
 116                         username = g_strdup(notilde);
 117
 118                 passwd = getpwnam(username);
 119                 g_free(username);
 120
 121                 if (!passwd)
 122                         return g_strdup(filename);
 123
 124                 home = passwd->pw_dir;
 125                 }
 126
 127         if (slash)
 128                 return g_build_filename(home, G_DIR_SEPARATOR_S, slash + 1, NULL);
 129         else
 130                 return g_build_filename(home, G_DIR_SEPARATOR_S, NULL);
 131 #endif
 132 }
 133
 134
 135 /*
 136  *-----------------------------------------------------------------------------
 137  * keyboard functions
 138  *-----------------------------------------------------------------------------
 139  */
 140
 141 void keyboard_scroll_calc(gint *x, gint *y, GdkEventKey *event)
 142 {
 143         static gint delta = 0;
 144         static guint32 time_old = 0;
 145         static guint keyval_old = 0;
 146
 147         if (event->state & GDK_CONTROL_MASK)
 148                 {
 149                 if (*x < 0) *x = G_MININT / 2;
 150                 if (*x > 0) *x = G_MAXINT / 2;
 151                 if (*y < 0) *y = G_MININT / 2;
 152                 if (*y > 0) *y = G_MAXINT / 2;
 153
 154                 return;
 155                 }
 156
 157         if (options->progressive_key_scrolling)
 158                 {
 159                 guint32 time_diff;
 160
 161                 time_diff = event->time - time_old;
 162
 163                 /* key pressed within 125ms ? (1/8 second) */
 164                 if (time_diff > 125 || event->keyval != keyval_old) delta = 0;
 165
 166                 time_old = event->time;
 167                 keyval_old = event->keyval;
 168
 169                 delta += 2;
 170                 }
 171         else
 172                 {
 173                 delta = 8;
 174                 }
 175
 176         *x = *x * delta;
 177         *y = *y * delta;
 178 }
 179
 180
 181
 182 /*
 183  *-----------------------------------------------------------------------------
 184  * command line parser (private) hehe, who needs popt anyway?
 185  *-----------------------------------------------------------------------------
 186  */
 187
 188 static gint startup_blank = FALSE;
 189 static gint startup_full_screen = FALSE;
 190 static gint startup_in_slideshow = FALSE;
 191 static gint startup_command_line_collection = FALSE;
 192
 193
 194 static void parse_command_line_add_file(const gchar *file_path, gchar **path, gchar **file,
 195                                         GList **list, GList **collection_list)
 196 {
 197         gchar *path_parsed;
 198
 199         path_parsed = g_strdup(file_path);
 200         parse_out_relatives(path_parsed);
 201
 202         if (file_extension_match(path_parsed, ".gqv"))
 203                 {
 204                 *collection_list = g_list_append(*collection_list, path_parsed);
 205                 }
 206         else
 207                 {
 208                 if (!*path) *path = remove_level_from_path(path_parsed);
 209                 if (!*file) *file = g_strdup(path_parsed);
 210                 *list = g_list_prepend(*list, file_data_new_simple(path_parsed));
 211                 }
 212 }
 213
 214 static void parse_command_line_add_dir(const gchar *dir, gchar **path, gchar **file,
 215                                        GList **list)
 216 {
 217         GList *files = NULL;
 218         gchar *path_parsed;
 219
 220         path_parsed = g_strdup(dir);
 221         parse_out_relatives(path_parsed);
 222
 223         if (filelist_read(path_parsed, &files, NULL))
 224                 {
 225                 GList *work;
 226
 227                 files = filelist_filter(files, FALSE);
 228                 files = filelist_sort_path(files);
 229
 230                 work = files;
 231                 while (work)
 232                         {
 233                         FileData *fd = work->data;
 234                         if (!*path) *path = remove_level_from_path(fd->path);
 235                         if (!*file) *file = g_strdup(fd->path);
 236                         *list = g_list_prepend(*list, fd);
 237
 238                         work = work->next;
 239                         }
 240
 241                 g_list_free(files);
 242                 }
 243
 244         g_free(path_parsed);
 245 }
 246
 247 static void parse_command_line_process_dir(const gchar *dir, gchar **path, gchar **file,
 248                                            GList **list, gchar **first_dir)
 249 {
 250
 251         if (!*list && !*first_dir)
 252                 {
 253                 *first_dir = g_strdup(dir);
 254                 }
 255         else
 256                 {
 257                 if (*first_dir)
 258                         {
 259                         parse_command_line_add_dir(*first_dir, path, file, list);
 260                         g_free(*first_dir);
 261                         *first_dir = NULL;
 262                         }
 263                 parse_command_line_add_dir(dir, path, file, list);
 264                 }
 265 }
 266
 267 static void parse_command_line_process_file(const gchar *file_path, gchar **path, gchar **file,
 268                                             GList **list, GList **collection_list, gchar **first_dir)
 269 {
 270
 271         if (*first_dir)
 272                 {
 273                 parse_command_line_add_dir(*first_dir, path, file, list);
 274                 g_free(*first_dir);
 275                 *first_dir = NULL;
 276                 }
 277         parse_command_line_add_file(file_path, path, file, list, collection_list);
 278 }
 279
 280 static void parse_command_line(int argc, char *argv[], gchar **path, gchar **file,
 281                                GList **cmd_list, GList **collection_list,
 282                                gchar **geometry)
 283 {
 284         GList *list = NULL;
 285         GList *remote_list = NULL;
 286         GList *remote_errors = NULL;
 287         gint remote_do = FALSE;
 288         gchar *first_dir = NULL;
 289
 290         if (argc > 1)
 291                 {
 292                 gint i;
 293                 gchar *base_dir = get_current_dir();
 294                 i = 1;
 295                 while (i < argc)
 296                         {
 297                         const gchar *cmd_line = argv[i];
 298                         gchar *cmd_all = g_build_filename(base_dir, cmd_line, NULL);
 299
 300                         if (cmd_line[0] == G_DIR_SEPARATOR && isdir(cmd_line))
 301                                 {
 302                                 parse_command_line_process_dir(cmd_line, path, file, &list, &first_dir);
 303                                 }
 304                         else if (isdir(cmd_all))
 305                                 {
 306                                 parse_command_line_process_dir(cmd_all, path, file, &list, &first_dir);
 307                                 }
 308                         else if (cmd_line[0] == G_DIR_SEPARATOR && isfile(cmd_line))
 309                                 {
 310                                 parse_command_line_process_file(cmd_line, path, file,
 311                                                                 &list, collection_list, &first_dir);
 312                                 }
 313                         else if (isfile(cmd_all))
 314                                 {
 315                                 parse_command_line_process_file(cmd_all, path, file,
 316                                                                 &list, collection_list, &first_dir);
 317                                 }
 318                         else if (strncmp(cmd_line, "--debug", 7) == 0 && (cmd_line[7] == '\0' || cmd_line[7] == '='))
 319                                 {
 320                                 /* do nothing but do not produce warnings */
 321                                 }
 322                         else if (strcmp(cmd_line, "+t") == 0 ||
 323                                  strcmp(cmd_line, "--with-tools") == 0)
 324                                 {
 325                                 options->layout.tools_float = FALSE;
 326                                 options->layout.tools_hidden = FALSE;
 327
 328                                 remote_list = g_list_append(remote_list, "+t");
 329                                 }
 330                         else if (strcmp(cmd_line, "-t") == 0 ||
 331                                  strcmp(cmd_line, "--without-tools") == 0)
 332                                 {
 333                                 options->layout.tools_hidden = TRUE;
 334
 335                                 remote_list = g_list_append(remote_list, "-t");
 336                                 }
 337                         else if (strcmp(cmd_line, "-f") == 0 ||
 338                                  strcmp(cmd_line, "--fullscreen") == 0)
 339                                 {
 340                                 startup_full_screen = TRUE;
 341                                 }
 342                         else if (strcmp(cmd_line, "-s") == 0 ||
 343                                  strcmp(cmd_line, "--slideshow") == 0)
 344                                 {
 345                                 startup_in_slideshow = TRUE;
 346                                 }
 347                         else if (strcmp(cmd_line, "-l") == 0 ||
 348                                  strcmp(cmd_line, "--list") == 0)
 349                                 {
 350                                 startup_command_line_collection = TRUE;
 351                                 }
 352                         else if (strncmp(cmd_line, "--geometry=", 11) == 0)
 353                                 {
 354                                 if (!*geometry) *geometry = g_strdup(cmd_line + 11);
 355                                 }
 356                         else if (strcmp(cmd_line, "-r") == 0 ||
 357                                  strcmp(cmd_line, "--remote") == 0)
 358                                 {
 359                                 if (!remote_do)
 360                                         {
 361                                         remote_do = TRUE;
 362                                         remote_list = remote_build_list(remote_list, argc - i, &argv[i], &remote_errors);
 363                                         }
 364                                 }
 365                         else if (strcmp(cmd_line, "-rh") == 0 ||
 366                                  strcmp(cmd_line, "--remote-help") == 0)
 367                                 {
 368                                 remote_help();
 369                                 exit(0);
 370                                 }
 371                         else if (strcmp(cmd_line, "--blank") == 0)
 372                                 {
 373                                 startup_blank = TRUE;
 374                                 }
 375                         else if (strcmp(cmd_line, "-v") == 0 ||
 376                                  strcmp(cmd_line, "--version") == 0)
 377                                 {
 378                                 printf_term("%s %s\n", GQ_APPNAME, VERSION);
 379                                 exit(0);
 380                                 }
 381                         else if (strcmp(cmd_line, "--alternate") == 0)
 382                                 {
 383                                 /* enable faster experimental algorithm */
 384                                 log_printf("Alternate similarity algorithm enabled\n");
 385                                 image_sim_alternate_set(TRUE);
 386                                 }
 387                         else if (strcmp(cmd_line, "-h") == 0 ||
 388                                  strcmp(cmd_line, "--help") == 0)
 389                                 {
 390                                 printf_term("%s %s\n", GQ_APPNAME, VERSION);
 391                                 printf_term(_("Usage: %s [options] [path]\n\n"), GQ_APPNAME_LC);
 392                                 print_term(_("valid options are:\n"));
 393                                 print_term(_("  +t, --with-tools           force show of tools\n"));
 394                                 print_term(_("  -t, --without-tools        force hide of tools\n"));
 395                                 print_term(_("  -f, --fullscreen           start in full screen mode\n"));
 396                                 print_term(_("  -s, --slideshow            start in slideshow mode\n"));
 397                                 print_term(_("  -l, --list                 open collection window for command line\n"));
 398                                 print_term(_("      --geometry=GEOMETRY    set main window location\n"));
 399                                 print_term(_("  -r, --remote               send following commands to open window\n"));
 400                                 print_term(_("  -rh,--remote-help          print remote command list\n"));
 401 #ifdef DEBUG
 402                                 print_term(_("  --debug[=level]            turn on debug output\n"));
 403 #endif
 404                                 print_term(_("  -v, --version              print version info\n"));
 405                                 print_term(_("  -h, --help                 show this message\n\n"));
 406
 407 #if 0
 408                                 /* these options are not officially supported!
 409                                  * only for testing new features, no need to translate them */
 410                                 print_term(  "  --alternate                use alternate similarity algorithm\n");
 411 #endif
 412
 413                                 exit(0);
 414                                 }
 415                         else if (!remote_do)
 416                                 {
 417                                 printf_term(_("invalid or ignored: %s\nUse --help for options\n"), cmd_line);
 418                                 }
 419
 420                         g_free(cmd_all);
 421                         i++;
 422                         }
 423                 g_free(base_dir);
 424                 parse_out_relatives(*path);
 425                 parse_out_relatives(*file);
 426                 }
 427
 428         list = g_list_reverse(list);
 429
 430         if (!*path && first_dir)
 431                 {
 432                 *path = first_dir;
 433                 first_dir = NULL;
 434
 435                 parse_out_relatives(*path);
 436                 }
 437         g_free(first_dir);
 438
 439         if (remote_do)
 440                 {
 441                 if (remote_errors)
 442                         {
 443                         GList *work = remote_errors;
 444
 445                         printf_term(_("Invalid or ignored remote options: "));
 446                         while (work)
 447                                 {
 448                                 gchar *opt = work->data;
 449
 450                                 printf_term("%s%s", (work == remote_errors) ? "" : ", ", opt);
 451                                 work = work->next;
 452                                 }
 453
 454                         printf_term(_("\nUse --remote-help for valid remote options.\n"));
 455                         }
 456
 457                 remote_control(argv[0], remote_list, *path, list, *collection_list);
 458                 }
 459         g_list_free(remote_list);
 460
 461         if (list && list->next)
 462                 {
 463                 *cmd_list = list;
 464                 }
 465         else
 466                 {
 467                 filelist_free(list);
 468                 *cmd_list = NULL;
 469                 }
 470 }
 471
 472 static void parse_command_line_for_debug_option(int argc, char *argv[])
 473 {
 474 #ifdef DEBUG
 475         const gchar *debug_option = "--debug";
 476         gint len = strlen(debug_option);
 477
 478         if (argc > 1)
 479                 {
 480                 gint i;
 481
 482                 for (i = 1; i < argc; i++)
 483                         {
 484                         const gchar *cmd_line = argv[i];
 485                         if (strncmp(cmd_line, debug_option, len) == 0)
 486                                 {
 487                                 gint cmd_line_len = strlen(cmd_line);
 488
 489                                 /* we now increment the debug state for verbosity */
 490                                 if (cmd_line_len == len)
 491                                         debug_level_add(1);
 492                                 else if (cmd_line[len] == '=' && g_ascii_isdigit(cmd_line[len+1]))
 493                                         {
 494                                         gint n = atoi(cmd_line + len + 1);
 495                                         if (n < 0) n = 1;
 496                                         debug_level_add(n);
 497                                         }
 498                                 }
 499                         }
 500                 }
 501
 502         DEBUG_1("debugging output enabled (level %d)", get_debug_level());
 503 #endif
 504 }
 505
 506 /*
 507  *-----------------------------------------------------------------------------
 508  * startup, init, and exit
 509  *-----------------------------------------------------------------------------
 510  */
 511
 512 #define RC_HISTORY_NAME "history"
 513
 514 static void keys_load(void)
 515 {
 516         gchar *path;
 517
 518         path = g_build_filename(homedir(), GQ_RC_DIR, RC_HISTORY_NAME, NULL);
 519         history_list_load(path);
 520         g_free(path);
 521 }
 522
 523 static void keys_save(void)
 524 {
 525         gchar *path;
 526
 527         path = g_build_filename(homedir(), GQ_RC_DIR, RC_HISTORY_NAME, NULL);
 528         history_list_save(path);
 529         g_free(path);
 530 }
 531
 532 static void check_for_home_path(gchar *path)
 533 {
 534         gchar *buf;
 535
 536         buf = g_build_filename(homedir(), path, NULL);
 537         if (!isdir(buf))
 538                 {
 539                 log_printf(_("Creating %s dir:%s\n"), GQ_APPNAME, buf);
 540
 541                 if (!mkdir_utf8(buf, 0755))
 542                         {
 543                         log_printf(_("Could not create dir:%s\n"), buf);
 544                         }
 545                 }
 546         g_free(buf);
 547 }
 548
 549 static void setup_default_options(void)
 550 {
 551         gchar *path;
 552         gint i;
 553
 554         for (i = 0; i < GQ_EDITOR_SLOTS; i++)
 555                 {
 556                 options->editor[i].name = NULL;
 557                 options->editor[i].command = NULL;
 558                 }
 559
 560         editor_reset_defaults();
 561
 562         bookmark_add_default(_("Home"), homedir());
 563         path = g_build_filename(homedir(), "Desktop", NULL);
 564         bookmark_add_default(_("Desktop"), path);
 565         g_free(path);
 566         path = g_build_filename(homedir(), GQ_RC_DIR_COLLECTIONS, NULL);
 567         bookmark_add_default(_("Collections"), path);
 568         g_free(path);
 569
 570         g_free(options->file_ops.safe_delete_path);
 571         options->file_ops.safe_delete_path = g_build_filename(homedir(), GQ_RC_DIR_TRASH, NULL);
 572
 573         for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
 574                 {
 575                 options->color_profile.input_file[i] = NULL;
 576                 options->color_profile.input_name[i] = NULL;
 577                 }
 578
 579         set_default_image_overlay_template_string(&options->image_overlay.common.template_string);
 580         sidecar_ext_add_defaults();
 581         options->layout.order = g_strdup("123");
 582         options->properties.tabs_order = g_strdup(info_tab_default_order());
 583
 584         options->shell.path = g_strdup(GQ_DEFAULT_SHELL_PATH);
 585         options->shell.options = g_strdup(GQ_DEFAULT_SHELL_OPTIONS);
 586 }
 587
 588 static void exit_program_final(void)
 589 {
 590         gchar *path;
 591         gchar *pathl;
 592         LayoutWindow *lw = NULL;
 593
 594         remote_close(remote_connection);
 595
 596         collect_manager_flush();
 597
 598         if (layout_valid(&lw))
 599                 {
 600                 options->layout.main_window.maximized =  window_maximized(lw->window);
 601                 if (!options->layout.main_window.maximized)
 602                         {
 603                         layout_geometry_get(NULL, &options->layout.main_window.x, &options->layout.main_window.y,
 604                                             &options->layout.main_window.w, &options->layout.main_window.h);
 605                         }
 606
 607                 options->image_overlay.common.state = image_osd_get(lw->image);
 608                 }
 609
 610         layout_geometry_get_dividers(NULL, &options->layout.main_window.hdivider_pos, &options->layout.main_window.vdivider_pos);
 611
 612         layout_views_get(NULL, &options->layout.dir_view_type, &options->layout.file_view_type);
 613
 614         options->layout.show_thumbnails = layout_thumb_get(NULL);
 615         options->layout.show_marks = layout_marks_get(NULL);
 616
 617         layout_sort_get(NULL, &options->file_sort.method, &options->file_sort.ascending);
 618
 619         layout_geometry_get_tools(NULL, &options->layout.float_window.x, &options->layout.float_window.y,
 620                                   &options->layout.float_window.w, &options->layout.float_window.h, &options->layout.float_window.vdivider_pos);
 621         layout_tools_float_get(NULL, &options->layout.tools_float, &options->layout.tools_hidden);
 622         options->layout.toolbar_hidden = layout_toolbar_hidden(NULL);
 623
 624         options->color_profile.enabled = layout_image_color_profile_get_use(NULL);
 625         layout_image_color_profile_get(NULL,
 626                                        &options->color_profile.input_type,
 627                                        &options->color_profile.screen_type,
 628                                        &options->color_profile.use_image);
 629
 630         if (options->startup.restore_path && options->startup.use_last_path)
 631                 {
 632                 g_free(options->startup.path);
 633                 options->startup.path = g_strdup(layout_get_path(NULL));
 634                 }
 635
 636         save_options();
 637         keys_save();
 638
 639         path = g_build_filename(homedir(), GQ_RC_DIR, "accels", NULL);
 640         pathl = path_from_utf8(path);
 641         gtk_accel_map_save(pathl);
 642         g_free(pathl);
 643         g_free(path);
 644
 645         gtk_main_quit();
 646 }
 647
 648 static GenericDialog *exit_dialog = NULL;
 649
 650 static void exit_confirm_cancel_cb(GenericDialog *gd, gpointer data)
 651 {
 652         exit_dialog = NULL;
 653         generic_dialog_close(gd);
 654 }
 655
 656 static void exit_confirm_exit_cb(GenericDialog *gd, gpointer data)
 657 {
 658         exit_dialog = NULL;
 659         generic_dialog_close(gd);
 660         exit_program_final();
 661 }
 662
 663 static gint exit_confirm_dlg(void)
 664 {
 665         GtkWidget *parent;
 666         LayoutWindow *lw;
 667         gchar *msg;
 668
 669         if (exit_dialog)
 670                 {
 671                 gtk_window_present(GTK_WINDOW(exit_dialog->dialog));
 672                 return TRUE;
 673                 }
 674
 675         if (!collection_window_modified_exists()) return FALSE;
 676
 677         parent = NULL;
 678         lw = NULL;
 679         if (layout_valid(&lw))
 680                 {
 681                 parent = lw->window;
 682                 }
 683
 684         msg = g_strdup_printf("%s - %s", GQ_APPNAME, _("exit"));
 685         exit_dialog = generic_dialog_new(msg,
 686                                 GQ_WMCLASS, "exit", parent, FALSE,
 687                                 exit_confirm_cancel_cb, NULL);
 688         g_free(msg);
 689         msg = g_strdup_printf(_("Quit %s"), GQ_APPNAME);
 690         generic_dialog_add_message(exit_dialog, GTK_STOCK_DIALOG_QUESTION,
 691                                    msg, _("Collections have been modified. Quit anyway?"));
 692         g_free(msg);
 693         generic_dialog_add_button(exit_dialog, GTK_STOCK_QUIT, NULL, exit_confirm_exit_cb, TRUE);
 694
 695         gtk_widget_show(exit_dialog->dialog);
 696
 697         return TRUE;
 698 }
 699
 700 void exit_program(void)
 701 {
 702         layout_image_full_screen_stop(NULL);
 703
 704         if (exit_confirm_dlg()) return;
 705
 706         exit_program_final();
 707 }
 708
 709 int main(int argc, char *argv[])
 710 {
 711         LayoutWindow *lw;
 712         gchar *path = NULL;
 713         gchar *cmd_path = NULL;
 714         gchar *cmd_file = NULL;
 715         GList *cmd_list = NULL;
 716         GList *collection_list = NULL;
 717         CollectionData *first_collection = NULL;
 718         gchar *geometry = NULL;
 719         gchar *buf;
 720         gchar *bufl;
 721         CollectionData *cd = NULL;
 722
 723         /* init execution time counter (debug only) */
 724         init_exec_time();
 725
 726         /* setup locale, i18n */
 727         gtk_set_locale();
 728
 729 #ifdef ENABLE_NLS
 730         bindtextdomain(PACKAGE, GQ_LOCALEDIR);
 731         bind_textdomain_codeset(PACKAGE, "UTF-8");
 732         textdomain(PACKAGE);
 733 #endif
 734
 735         /* setup random seed for random slideshow */
 736         srand(time(NULL));
 737
 738 #if 1
 739         log_printf("%s %s, This is an alpha release.\n", GQ_APPNAME, VERSION);
 740 #endif
 741         parse_command_line_for_debug_option(argc, argv);
 742
 743         options = init_options(NULL);
 744         setup_default_options();
 745         load_options();
 746
 747         parse_command_line(argc, argv, &cmd_path, &cmd_file, &cmd_list, &collection_list, &geometry);
 748
 749         gtk_init(&argc, &argv);
 750
 751         if (gtk_major_version < GTK_MAJOR_VERSION ||
 752             (gtk_major_version == GTK_MAJOR_VERSION && gtk_minor_version < GTK_MINOR_VERSION) )
 753                 {
 754                 log_printf("!!! This is a friendly warning.\n");
 755                 log_printf("!!! The version of GTK+ in use now is older than when %s was compiled.\n", GQ_APPNAME);
 756                 log_printf("!!!  compiled with GTK+-%d.%d\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION);
 757                 log_printf("!!!   running with GTK+-%d.%d\n", gtk_major_version, gtk_minor_version);
 758                 log_printf("!!! %s may quit unexpectedly with a relocation error.\n", GQ_APPNAME);
 759                 }
 760
 761         check_for_home_path(GQ_RC_DIR);
 762         check_for_home_path(GQ_RC_DIR_COLLECTIONS);
 763         check_for_home_path(GQ_CACHE_RC_THUMB);
 764         check_for_home_path(GQ_CACHE_RC_METADATA);
 765
 766         keys_load();
 767         filter_add_defaults();
 768         filter_rebuild();
 769
 770         buf = g_build_filename(homedir(), GQ_RC_DIR, "accels", NULL);
 771         bufl = path_from_utf8(buf);
 772         gtk_accel_map_load(bufl);
 773         g_free(bufl);
 774         g_free(buf);
 775
 776         if (startup_blank)
 777                 {
 778                 g_free(cmd_path);
 779                 cmd_path = NULL;
 780                 g_free(cmd_file);
 781                 cmd_file = NULL;
 782                 filelist_free(cmd_list);
 783                 cmd_list = NULL;
 784                 string_list_free(collection_list);
 785                 collection_list = NULL;
 786
 787                 path = NULL;
 788                 }
 789         else if (cmd_path)
 790                 {
 791                 path = g_strdup(cmd_path);
 792                 }
 793         else if (options->startup.restore_path && options->startup.path && isdir(options->startup.path))
 794                 {
 795                 path = g_strdup(options->startup.path);
 796                 }
 797         else
 798                 {
 799                 path = get_current_dir();
 800                 }
 801
 802         lw = layout_new_with_geometry(NULL, options->layout.tools_float, options->layout.tools_hidden, geometry);
 803         layout_sort_set(lw, options->file_sort.method, options->file_sort.ascending);
 804
 805         if (collection_list && !startup_command_line_collection)
 806                 {
 807                 GList *work;
 808
 809                 work = collection_list;
 810                 while (work)
 811                         {
 812                         CollectWindow *cw;
 813                         const gchar *path;
 814
 815                         path = work->data;
 816                         work = work->next;
 817
 818                         cw = collection_window_new(path);
 819                         if (!first_collection && cw) first_collection = cw->cd;
 820                         }
 821                 }
 822
 823         if (cmd_list ||
 824             (startup_command_line_collection && collection_list))
 825                 {
 826                 GList *work;
 827
 828                 if (startup_command_line_collection)
 829                         {
 830                         CollectWindow *cw;
 831
 832                         cw = collection_window_new("");
 833                         cd = cw->cd;
 834                         }
 835                 else
 836                         {
 837                         cd = collection_new("");        /* if we pass NULL, untitled counter is falsely increm. */
 838                         }
 839
 840                 g_free(cd->path);
 841                 cd->path = NULL;
 842                 g_free(cd->name);
 843                 cd->name = g_strdup(_("Command line"));
 844
 845                 collection_path_changed(cd);
 846
 847                 work = cmd_list;
 848                 while (work)
 849                         {
 850                         collection_add(cd, file_data_new_simple((gchar *)work->data), FALSE);
 851                         work = work->next;
 852                         }
 853
 854                 work = collection_list;
 855                 while (work)
 856                         {
 857                         collection_load(cd, (gchar *)work->data, COLLECTION_LOAD_APPEND);
 858                         work = work->next;
 859                         }
 860
 861                 layout_set_path(lw, path);
 862                 if (cd->list) layout_image_set_collection(lw, cd, cd->list->data);
 863
 864                 /* mem leak, we never unref this collection when !startup_command_line_collection
 865                  * (the image view of the main window does not hold a ref to the collection)
 866                  * this is sort of unavoidable, for if it did hold a ref, next/back
 867                  * may not work as expected when closing collection windows.
 868                  *
 869                  * collection_unref(cd);
 870                  */
 871
 872                 }
 873         else if (cmd_file)
 874                 {
 875                 layout_set_path(lw, cmd_file);
 876                 }
 877         else
 878                 {
 879                 layout_set_path(lw, path);
 880                 if (first_collection)
 881                         {
 882                         layout_image_set_collection(lw, first_collection,
 883                                                     collection_get_first(first_collection));
 884                         }
 885                 }
 886
 887         image_osd_set(lw->image, options->image_overlay.common.state | (options->image_overlay.common.show_at_startup ? OSD_SHOW_INFO : OSD_SHOW_NOTHING));
 888
 889         g_free(geometry);
 890         g_free(cmd_path);
 891         g_free(cmd_file);
 892         filelist_free(cmd_list);
 893         string_list_free(collection_list);
 894         g_free(path);
 895
 896         if (startup_full_screen) layout_image_full_screen_start(lw);
 897         if (startup_in_slideshow) layout_image_slideshow_start(lw);
 898
 899         buf = g_build_filename(homedir(), GQ_RC_DIR, ".command", NULL);
 900         remote_connection = remote_server_init(buf, cd);
 901         g_free(buf);
 902
 903         gtk_main();
 904         return 0;
 905 }