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