src/nautilus-shell.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2
   3 /*
   4  * Nautilus
   5  *
   6  * Copyright (C) 2000 Eazel, Inc.
   7  *
   8  * Nautilus is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * Nautilus is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public
  19  * License along with this program; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* nautilus-shell.h: Server side of the Nautilus:Shell CORBA object
  25  * that represents the shell across processes.
  26  */
  27
  28 #include <config.h>
  29 #include "nautilus-shell.h"
  30
  31 #include "nautilus-desktop-window.h"
  32 #include "nautilus-main.h"
  33 #include "nautilus-window-private.h"
  34 #include <eel/eel-glib-extensions.h>
  35 #include <eel/eel-gtk-extensions.h>
  36 #include <eel/eel-gtk-macros.h>
  37 #include <eel/eel-stock-dialogs.h>
  38 #include <eel/eel-string.h>
  39 #include <gtk/gtkframe.h>
  40 #include <gtk/gtkhbox.h>
  41 #include <gtk/gtklabel.h>
  42 #include <gtk/gtkmain.h>
  43 #include <gtk/gtksignal.h>
  44 #include <glib/gi18n.h>
  45 #include <libgnomeui/gnome-stock-icons.h>
  46 #include <libgnomeui/gnome-uidefs.h>
  47 #include <libnautilus-private/nautilus-file-utilities.h>
  48 #include <libnautilus-private/nautilus-global-preferences.h>
  49 #include <stdlib.h>
  50
  51 /* Keep window from shrinking down ridiculously small; numbers are somewhat arbitrary */
  52 #define APPLICATION_WINDOW_MIN_WIDTH    300
  53 #define APPLICATION_WINDOW_MIN_HEIGHT   100
  54
  55 #define START_STATE_CONFIG "start-state"
  56
  57 struct NautilusShellDetails {
  58         NautilusApplication *application;
  59 };
  60
  61 static void     finalize                         (GObject              *shell);
  62 static void     corba_open_windows              (PortableServer_Servant  servant,
  63                                                  const Nautilus_URIList *list,
  64                                                  const CORBA_char       *startup_id,
  65                                                  const CORBA_char       *geometry,
  66                                                  CORBA_boolean           browser_window,
  67                                                  CORBA_Environment      *ev);
  68 static void     corba_open_default_window       (PortableServer_Servant  servant,
  69                                                  const CORBA_char       *startup_id,
  70                                                  const CORBA_char       *geometry,
  71                                                  CORBA_boolean           browser_window,
  72                                                  CORBA_Environment      *ev);
  73 static void     corba_load_session              (PortableServer_Servant  servant,
  74                                                  const CORBA_char       *filename,
  75                                                  CORBA_Environment      *ev);
  76 static void     corba_start_desktop             (PortableServer_Servant  servant,
  77                                                  CORBA_Environment      *ev);
  78 static void     corba_stop_desktop              (PortableServer_Servant  servant,
  79                                                  CORBA_Environment      *ev);
  80 static void     corba_quit                      (PortableServer_Servant  servant,
  81                                                  CORBA_Environment      *ev);
  82 static void     corba_restart                   (PortableServer_Servant  servant,
  83                                                  CORBA_Environment      *ev);
  84
  85 BONOBO_CLASS_BOILERPLATE_FULL (NautilusShell, nautilus_shell,
  86                                Nautilus_Shell,
  87                                BonoboObject, BONOBO_OBJECT_TYPE)
  88
  89 static void
  90 nautilus_shell_class_init (NautilusShellClass *klass)
  91 {
  92         G_OBJECT_CLASS (klass)->finalize = finalize;
  93
  94         klass->epv.open_windows = corba_open_windows;
  95         klass->epv.open_default_window = corba_open_default_window;
  96         klass->epv.load_session = corba_load_session;
  97         klass->epv.start_desktop = corba_start_desktop;
  98         klass->epv.stop_desktop = corba_stop_desktop;
  99         klass->epv.quit = corba_quit;
 100         klass->epv.restart = corba_restart;
 101 }
 102
 103 static void
 104 nautilus_shell_instance_init (NautilusShell *shell)
 105 {
 106         shell->details = g_new0 (NautilusShellDetails, 1);
 107 }
 108
 109 static void
 110 finalize (GObject *object)
 111 {
 112         NautilusShell *shell;
 113
 114         shell = NAUTILUS_SHELL (object);
 115         g_free (shell->details);
 116
 117         EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
 118 }
 119
 120 NautilusShell *
 121 nautilus_shell_new (NautilusApplication *application)
 122 {
 123         NautilusShell *shell;
 124
 125         shell = NAUTILUS_SHELL (g_object_new (NAUTILUS_TYPE_SHELL, NULL));
 126         shell->details->application = application;
 127         return shell;
 128 }
 129
 130 static void
 131 open_window (NautilusShell *shell, const char *uri, const char *startup_id,
 132              const char *geometry, gboolean browser_window)
 133 {
 134         GFile *location;
 135         NautilusWindow *window;
 136
 137         if (browser_window ||
 138             eel_preferences_get_boolean (NAUTILUS_PREFERENCES_ALWAYS_USE_BROWSER)) {
 139                 window = nautilus_application_create_navigation_window (shell->details->application,
 140                                                                         startup_id,
 141                                                                         gdk_screen_get_default ());
 142                 if (uri == NULL) {
 143                         nautilus_window_go_home (window);
 144                 } else {
 145                         location = g_file_new_for_uri (uri);
 146                         nautilus_window_go_to (window, location);
 147                         g_object_unref (location);
 148                 }
 149         } else {
 150                 if (uri == NULL) {
 151                         location = g_file_new_for_path (g_get_home_dir ());
 152                 } else {
 153                         location = g_file_new_for_uri (uri);
 154                 }
 155
 156                 window = nautilus_application_present_spatial_window (shell->details->application,
 157                                                                       NULL,
 158                                                                       startup_id,
 159                                                                       location,
 160                                                                       gdk_screen_get_default ());
 161                 g_object_unref (location);
 162         }
 163
 164         if (geometry != NULL && !GTK_WIDGET_VISIBLE (window)) {
 165                 eel_gtk_window_set_initial_geometry_from_string (GTK_WINDOW (window),
 166                                                                  geometry,
 167                                                                  APPLICATION_WINDOW_MIN_WIDTH,
 168                                                                  APPLICATION_WINDOW_MIN_HEIGHT,
 169                                                                  FALSE);
 170         }
 171 }
 172
 173 typedef struct {
 174         NautilusShell *shell;
 175         char *startup_id;
 176         char *geometry;
 177         GList *uris;
 178         gboolean browser_window;
 179 } OpenWindowData;
 180
 181 static gboolean
 182 open_windows_at_idle (gpointer _data)
 183 {
 184         OpenWindowData *data = _data;
 185         char *uri;
 186         GList *l;
 187
 188         if (data->uris == NULL) {
 189                 /* Open a window pointing at the default location. */
 190                 open_window (data->shell, NULL, data->startup_id,
 191                              data->geometry, data->browser_window);
 192         } else {
 193                 /* Open windows at each requested location. */
 194                 for (l = data->uris; l != NULL; l = l->next) {
 195                         uri = (char *)l->data;
 196                         open_window (data->shell, uri, data->startup_id,
 197                                      data->geometry, data->browser_window);
 198                         g_free (uri);
 199                 }
 200         }
 201
 202         g_free (data->startup_id);
 203         g_free (data->geometry);
 204         g_list_free (data->uris);
 205         g_free (data);
 206         return FALSE;
 207 }
 208
 209 static void
 210 corba_open_windows (PortableServer_Servant servant,
 211                     const Nautilus_URIList *list,
 212                     const CORBA_char *startup_id,
 213                     const CORBA_char *geometry,
 214                     CORBA_boolean browser_window,
 215                     CORBA_Environment *ev)
 216 {
 217         OpenWindowData *data;
 218         guint i;
 219
 220         data = g_new0 (OpenWindowData, 1);
 221
 222         data->shell = NAUTILUS_SHELL (bonobo_object_from_servant (servant));
 223         data->startup_id = g_strdup (startup_id);
 224         data->geometry = g_strdup (geometry);
 225         data->browser_window = browser_window;
 226
 227         for (i = 0; i < list->_length; i++) {
 228                 g_assert (list->_buffer[i] != NULL);
 229                 data->uris = g_list_prepend (data->uris,
 230                                              g_strdup (list->_buffer[i]));
 231         }
 232         data->uris = g_list_reverse (data->uris);
 233
 234         g_idle_add (open_windows_at_idle, data);
 235
 236 }
 237
 238 static void
 239 corba_open_default_window (PortableServer_Servant servant,
 240                            const CORBA_char *startup_id,
 241                            const CORBA_char *geometry,
 242                            CORBA_boolean browser_window,
 243                            CORBA_Environment *ev)
 244 {
 245         OpenWindowData *data;
 246
 247         data = g_new0 (OpenWindowData, 1);
 248
 249         data->shell = NAUTILUS_SHELL (bonobo_object_from_servant (servant));
 250         data->startup_id = g_strdup (startup_id);
 251         data->geometry = g_strdup (geometry);
 252         data->browser_window = browser_window;
 253
 254         g_idle_add (open_windows_at_idle, data);
 255 }
 256
 257 typedef struct {
 258         NautilusShell *shell;
 259         char *filename;
 260 } LoadSessionData;
 261
 262 static gboolean
 263 load_session_at_idle (gpointer _data)
 264 {
 265         NautilusApplication *application;
 266         LoadSessionData *data = _data;
 267
 268         application = NAUTILUS_APPLICATION (data->shell->details->application);
 269         nautilus_application_load_session (application, data->filename);
 270
 271         g_free (data->filename);
 272         g_free (data);
 273         return FALSE;
 274 }
 275
 276 static void
 277 corba_load_session (PortableServer_Servant servant,
 278                     const CORBA_char *filename,
 279                     CORBA_Environment *ev)
 280 {
 281         LoadSessionData *data;
 282
 283         data = g_new0 (LoadSessionData, 1);
 284         data->shell = NAUTILUS_SHELL (bonobo_object_from_servant (servant));
 285         data->filename = g_strdup (filename);
 286
 287         g_idle_add (load_session_at_idle, data);
 288 }
 289
 290 typedef struct {
 291         NautilusShell *shell;
 292 } StartDesktopData;
 293
 294 static gboolean
 295 start_desktop_at_idle (gpointer _data)
 296 {
 297         StartDesktopData *data = _data;
 298         NautilusApplication *application;
 299
 300         application = NAUTILUS_APPLICATION (data->shell->details->application);
 301         nautilus_application_open_desktop (application);
 302
 303         g_free (data);
 304         return FALSE;
 305 }
 306
 307
 308 static void
 309 corba_start_desktop (PortableServer_Servant servant,
 310                       CORBA_Environment *ev)
 311 {
 312         StartDesktopData  *data;
 313
 314         data = g_new0 (StartDesktopData, 1);
 315         data->shell = NAUTILUS_SHELL (bonobo_object_from_servant (servant));
 316
 317         g_idle_add (start_desktop_at_idle, data);
 318 }
 319
 320 static gboolean
 321 stop_desktop_at_idle (gpointer data)
 322 {
 323         nautilus_application_close_desktop ();
 324         return FALSE;
 325 }
 326
 327 static void
 328 corba_stop_desktop (PortableServer_Servant servant,
 329                     CORBA_Environment *ev)
 330 {
 331         g_idle_add (stop_desktop_at_idle, NULL);
 332 }
 333
 334 static gboolean
 335 quit_at_idle (gpointer data)
 336 {
 337         nautilus_main_event_loop_quit (TRUE);
 338         return FALSE;
 339 }
 340
 341
 342 static void
 343 corba_quit (PortableServer_Servant servant,
 344             CORBA_Environment *ev)
 345 {
 346         g_idle_add (quit_at_idle, NULL);
 347 }
 348
 349 static gboolean
 350 restart_at_idle (gpointer data)
 351 {
 352         char *filename;
 353
 354         filename = nautilus_application_save_session_to_file ();
 355         if (filename != NULL) {
 356                 nautilus_main_event_loop_quit (TRUE);
 357                 g_setenv ("_NAUTILUS_RESTART_SESSION_FILENAME", filename, 1);
 358                 g_free (filename);
 359         } else {
 360                 g_message ("Could not save session. Not restarting.");
 361         }
 362
 363
 364         return FALSE;
 365 }
 366
 367 static void
 368 corba_restart (PortableServer_Servant servant,
 369                CORBA_Environment *ev)
 370 {
 371         g_idle_add (restart_at_idle, NULL);
 372 }