path: root/nautilus-desktop/nautilus-desktop-application.c

/* nautilus-desktop-application.c
 *
 * Copyright (C) 2016 Carlos Soriano <csoriano@gnome.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include "nautilus-desktop-application.h"
#include "nautilus-desktop-window.h"
#include "nautilus-desktop-directory.h"
#include "nautilus-file-utilities.h"

#include "nautilus-freedesktop-generated.h"

#include <libnautilus-private/nautilus-global-preferences.h>
#include <eel/eel.h>
#include <gdk/gdkx.h>
#include <stdlib.h>
#include <glib/gi18n.h>

static NautilusFreedesktopFileManager1 *freedesktop_proxy = NULL;

struct _NautilusDesktopApplication
{
  NautilusApplication parent_instance;

  gboolean force;
  GCancellable *freedesktop_cancellable;
};

G_DEFINE_TYPE (NautilusDesktopApplication, nautilus_desktop_application, NAUTILUS_TYPE_APPLICATION)

static void
on_show_folders (GObject      *source_object,
                 GAsyncResult *res,
                 gpointer      user_data)
{
  GError *error = NULL;

  nautilus_freedesktop_file_manager1_call_show_items_finish (freedesktop_proxy,
                                                             res,
                                                             &error);
  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
    {
      g_warning ("Unable to show items with File Manager freedesktop proxy: %s", error->message);
    }

  g_clear_error (&error);
}

static void
open_location_on_dbus (NautilusDesktopApplication *self,
                       const gchar                *uri)
{
  const gchar *uris[] = { uri, NULL };

  nautilus_freedesktop_file_manager1_call_show_folders (freedesktop_proxy,
                                                        uris,
                                                        "",
                                                        self->freedesktop_cancellable,
                                                        on_show_folders,
                                                        self);
}

static void
open_location_full (NautilusApplication     *app,
                    GFile                   *location,
                    NautilusWindowOpenFlags  flags,
                    GList                   *selection,
                    NautilusWindow          *target_window,
                    NautilusWindowSlot      *target_slot)
{
  NautilusDesktopApplication *self = NAUTILUS_DESKTOP_APPLICATION (app);
  gchar *uri;

  uri = g_file_get_uri (location);
  if (eel_uri_is_desktop (uri) && target_window &&
      NAUTILUS_IS_DESKTOP_WINDOW (target_window))
    {
      nautilus_window_open_location_full (target_window, location, flags, selection, NULL);
    }
  else
    {
      if (freedesktop_proxy)
        {
          open_location_on_dbus (self, uri);
        }
      else
        {
          g_warning ("cannot open folder on desktop, freedesktop bus not ready\n");
        }
    }

  g_free (uri);
}

static void
nautilus_application_set_desktop_visible (NautilusDesktopApplication *self,
                                          gboolean                    visible)
{
  GtkWidget *desktop_window;

  if (visible)
    {
      nautilus_desktop_window_ensure ();
    }
  else
    {
      desktop_window = nautilus_desktop_window_get ();
      if (desktop_window != NULL)
        {
          gtk_widget_destroy (desktop_window);
        }
    }
}

static void
update_desktop_from_gsettings (NautilusDesktopApplication *self)
{
  GdkDisplay *display;
  gboolean visible;

#ifdef GDK_WINDOWING_X11
  display = gdk_display_get_default ();
  visible = g_settings_get_boolean (gnome_background_preferences,
                                    NAUTILUS_PREFERENCES_SHOW_DESKTOP);
  visible = visible || self->force;

  if (!GDK_IS_X11_DISPLAY (display))
    {
      if (visible)
        {
          g_warning ("Desktop icons only supported on X11. Desktop not created");
        }

      return;
    }

  nautilus_application_set_desktop_visible (self, visible);

  return;
#endif

  g_warning ("Desktop icons only supported on X11. Desktop not created");
}

static void
init_desktop (NautilusDesktopApplication *self)
{
  if (!self->force)
    {
      g_signal_connect_swapped (gnome_background_preferences, "changed::" NAUTILUS_PREFERENCES_SHOW_DESKTOP,
                                G_CALLBACK (update_desktop_from_gsettings),
                                self);
    }
  update_desktop_from_gsettings (self);
}

static void
nautilus_desktop_application_activate (GApplication *app)
{
  /* Do nothing */
}

static gint
nautilus_desktop_application_command_line (GApplication            *application,
                                           GApplicationCommandLine *command_line)
{
  NautilusDesktopApplication *self = NAUTILUS_DESKTOP_APPLICATION (application);
  GVariantDict *options;

  options = g_application_command_line_get_options_dict (command_line);

  if (g_variant_dict_contains (options, "force"))
    {
      self->force = TRUE;
    }

  init_desktop (self);

  return EXIT_SUCCESS;
}

static void
nautilus_desktop_application_startup (GApplication *app)
{
  NautilusDesktopApplication *self = NAUTILUS_DESKTOP_APPLICATION (app);
  GError *error = NULL;

  nautilus_application_startup_common (NAUTILUS_APPLICATION (app));
  self->freedesktop_cancellable = g_cancellable_new ();
  freedesktop_proxy = nautilus_freedesktop_file_manager1_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
                                                        G_DBUS_PROXY_FLAGS_NONE,
                                                        "org.freedesktop.FileManager1",
                                                        "/org/freedesktop/FileManager1",
                                                        self->freedesktop_cancellable,
                                                        &error);

  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
    {
      g_warning ("Unable to create File Manager freedesktop proxy: %s", error->message);
    }

  g_clear_error (&error);
}

static void
nautilus_desktop_application_dispose (GObject *object)
{
  NautilusDesktopApplication *self = NAUTILUS_DESKTOP_APPLICATION (object);

  g_clear_object (&self->freedesktop_cancellable);


  G_OBJECT_CLASS (nautilus_desktop_application_parent_class)->dispose (object);
}

static void
nautilus_desktop_application_class_init (NautilusDesktopApplicationClass *klass)
{
  GApplicationClass *application_class = G_APPLICATION_CLASS (klass);
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  NautilusApplicationClass *parent_class = NAUTILUS_APPLICATION_CLASS (klass);

  parent_class->open_location_full = open_location_full;

  application_class->startup = nautilus_desktop_application_startup;
  application_class->activate = nautilus_desktop_application_activate;
  application_class->command_line = nautilus_desktop_application_command_line;

  gobject_class->dispose = nautilus_desktop_application_dispose;
}

static void
nautilus_desktop_ensure_builtins (void)
{
  /* Ensure the type so it can be registered early as a directory extension provider*/
  g_type_ensure (NAUTILUS_TYPE_DESKTOP_DIRECTORY);
}

const GOptionEntry desktop_options[] = {
  { "force", '\0', 0, G_OPTION_ARG_NONE, NULL,
    N_("Always manage the desktop (ignore the GSettings preference)."), NULL },
  { NULL }
};

static void
nautilus_desktop_application_init (NautilusDesktopApplication *self)
{
  self->force = FALSE;

  g_application_add_main_option_entries (G_APPLICATION (self), desktop_options);
  nautilus_ensure_extension_points ();
  nautilus_ensure_extension_builtins ();
  nautilus_desktop_ensure_builtins ();
}

NautilusDesktopApplication *
nautilus_desktop_application_new (void)
{
  return g_object_new (NAUTILUS_TYPE_DESKTOP_APPLICATION,
                       "application-id", "org.gnome.NautilusDesktop",
                       "register-session", TRUE,
                       "flags", G_APPLICATION_HANDLES_COMMAND_LINE,
                        NULL);
}