← Back to branch summary

~ubuntu-branches/ubuntu/vivid/xfce4-session/vivid-proposed

« back to all changes in this revision

Viewing changes to xfce4-session/xfsm-manager.c

  • Committer: Package Import Robot
  • Author(s): Lionel Le Folgoc
  • Date: 2012-05-18 20:21:52 UTC
  • mfrom: (4.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20120518202152-7bm9pla0j3ccfsnk
Tags: 4.10.0-1ubuntu1
* Merge from Debian experimental, remaining Ubuntu changes:
  - debian/control: build-depends on libgnome-keyring-dev to enable GNOME
    Keyring services support.
  - debian/rules: pass --enable-libgnome-keyring to dh_auto_configure.
  - debian/patches:
    + xubuntu_ignore-gdm-lang.patch: do not set $LANG to $GDM_LANG, there's
      already an xsession script to do that, and $GDM_LANG might not contain
      a valid locale code.

* debian/patches:
  - xubuntu_set-xdg-current-desktop.patch: added. Taken from xfce4-utils,
    export XDG_CURRENT_DESKTOP=XFCE, can be useful with alacarte and
    gnome-menus. lp #927172

Show diffs side-by-side

added added

removed removed

Lines of Context:
xfce4-session/xfsm-manager.c
71
71
 
72
72
#include <libwnck/libwnck.h>
73
73
 
74
 
#include "xfsm-shutdown-helper.h"
75
74
#include <libxfce4ui/libxfce4ui.h>
76
75
 
77
76
#include <libxfsm/xfsm-splash-engine.h>
78
77
#include <libxfsm/xfsm-util.h>
79
78
 
80
 
#include "xfsm-manager.h"
81
 
#include "chooser-icon.h"
82
 
#include "xfsm-chooser.h"
83
 
#include "xfsm-global.h"
84
 
#include "xfsm-legacy.h"
85
 
#include "xfsm-startup.h"
86
 
#include "xfsm-marshal.h"
87
 
#include "xfsm-error.h"
 
79
#include <xfce4-session/xfsm-manager.h>
 
80
#include <xfce4-session/xfsm-chooser-icon.h>
 
81
#include <xfce4-session/xfsm-chooser.h>
 
82
#include <xfce4-session/xfsm-global.h>
 
83
#include <xfce4-session/xfsm-legacy.h>
 
84
#include <xfce4-session/xfsm-startup.h>
 
85
#include <xfce4-session/xfsm-marshal.h>
 
86
#include <xfce4-session/xfsm-error.h>
 
87
#include <xfce4-session/xfsm-logout-dialog.h>
88
88
 
89
89
 
90
90
#define DEFAULT_SESSION_NAME "Default"
95
95
  GObject parent;
96
96
 
97
97
  XfsmManagerState state;
98
 
  XfsmShutdownType shutdown_type;
 
98
 
 
99
  XfsmShutdownType  shutdown_type;
 
100
  XfsmShutdown     *shutdown_helper;
99
101
 
100
102
  gboolean         session_chooser;
101
103
  gchar           *session_name;
102
104
  gchar           *session_file;
103
105
  gchar           *checkpoint_session_name;
104
106
 
 
107
  gboolean         start_at;
 
108
 
105
109
  gboolean         compat_gnome;
106
110
  gboolean         compat_kde;
107
111
 
225
229
  manager->session_chooser = FALSE;
226
230
  manager->failsafe_mode = TRUE;
227
231
  manager->shutdown_type = XFSM_SHUTDOWN_LOGOUT;
 
232
  manager->shutdown_helper = xfsm_shutdown_get ();
228
233
 
229
234
  manager->pending_properties = g_queue_new ();
230
235
  manager->starting_properties = g_queue_new ();
243
248
  if (manager->die_timeout_id != 0)
244
249
    g_source_remove (manager->die_timeout_id);
245
250
 
 
251
  g_object_unref (manager->shutdown_helper);
 
252
 
246
253
  g_queue_foreach (manager->pending_properties, (GFunc) xfsm_properties_free, NULL);
247
254
  g_queue_free (manager->pending_properties);
248
255
 
478
485
            {
479
486
              if (G_UNLIKELY (preview_default == NULL))
480
487
                {
481
 
                  preview_default = gdk_pixbuf_new_from_inline (-1, chooser_icon_data,
 
488
                  preview_default = gdk_pixbuf_new_from_inline (-1, xfsm_chooser_icon_data,
482
489
                                                                FALSE, NULL);
483
490
                }
484
491
 
729
736
 
730
737
  manager->compat_gnome = xfconf_channel_get_bool (channel, "/compat/LaunchGNOME", FALSE);
731
738
  manager->compat_kde = xfconf_channel_get_bool (channel, "/compat/LaunchKDE", FALSE);
 
739
  manager->start_at = xfconf_channel_get_bool (channel, "/general/StartAssistiveTechnologies", FALSE);
732
740
 
733
741
  display_name  = xfsm_gdk_display_get_fullname (gdk_display_get_default ());
734
742
 
763
771
  /* tell splash screen that the session is starting now */
764
772
  preview = xfsm_load_session_preview (manager->session_name);
765
773
  if (preview == NULL)
766
 
    preview = gdk_pixbuf_new_from_inline (-1, chooser_icon_data, FALSE, NULL);
 
774
    preview = gdk_pixbuf_new_from_inline (-1, xfsm_chooser_icon_data, FALSE, NULL);
767
775
  steps = g_queue_get_length (manager->failsafe_mode ? manager->failsafe_clients : manager->pending_properties);
768
776
  xfsm_splash_screen_start (splash_screen, manager->session_name, preview, steps);
769
777
  g_object_unref (preview);
1081
1089
                                   XfsmShutdownType shutdown_type,
1082
1090
                                   gboolean         allow_shutdown_save)
1083
1091
{
1084
 
  gboolean shutdown_save = allow_shutdown_save;
1085
 
  GList *lp;
 
1092
  gboolean  shutdown_save = allow_shutdown_save;
 
1093
  GList    *lp;
 
1094
  GError   *error = NULL;
1086
1095
 
1087
1096
  if (shutdown)
1088
1097
    {
1090
1099
        {
1091
1100
          /* if we're not specifying fast shutdown, and we're ok with
1092
1101
           * prompting then ask the user what to do */
1093
 
          if (!shutdownDialog (manager->session_name, &manager->shutdown_type, &shutdown_save))
 
1102
          if (!xfsm_logout_dialog (manager->session_name, &manager->shutdown_type, &shutdown_save))
1094
1103
            return;
1095
1104
 
1096
1105
          /* |allow_shutdown_save| is ignored if we prompt the user.  i think
1107
1116
      if (manager->shutdown_type == XFSM_SHUTDOWN_SUSPEND
1108
1117
          || manager->shutdown_type == XFSM_SHUTDOWN_HIBERNATE)
1109
1118
        {
1110
 
          XfsmShutdownHelper *shutdown_helper;
1111
 
          GError *error = NULL;
1112
 
 
1113
 
          shutdown_helper = xfsm_shutdown_helper_new ();
1114
 
 
1115
 
          if (!xfsm_shutdown_helper_send_command (shutdown_helper,
1116
 
                                                  manager->shutdown_type,
1117
 
                                                  &error))
 
1119
          if (!xfsm_shutdown_try_type (manager->shutdown_helper,
 
1120
                                       manager->shutdown_type,
 
1121
                                       &error))
1118
1122
            {
1119
1123
              xfce_message_dialog (NULL, _("Shutdown Failed"),
1120
1124
                                   GTK_STOCK_DIALOG_ERROR,
1127
1131
              g_error_free (error);
1128
1132
            }
1129
1133
 
1130
 
          /* clean up and return */
1131
 
          g_object_unref (shutdown_helper);
1132
 
 
1133
 
 
1134
1134
          /* at this point, either we failed to suspend/hibernate, or we
1135
1135
           * successfully suspended/hibernated, and we've been woken back
1136
1136
           * up, so return control to the user */
1137
1137
          return;
1138
1138
        }
1139
1139
    }
1140
 
#if defined(__NR_ioprio_set) && defined(HAVE_SYNC)
1141
 
  /* if we're on Linux and have ioprio_set(), we start sync()ing the
1142
 
   * disks now, and set the i/o priority to idle so we don't create
1143
 
   * a poor user experience if any apps need to interact with the user
1144
 
   * during shutdown.  if we *don't* have ioprio_set(), we sync at the
1145
 
   * end of shutdown, right before quitting.
1146
 
   */
1147
 
  if (shutdown == TRUE && fork () == 0)
1148
 
    {
1149
 
#ifdef HAVE_SETSID
1150
 
      setsid ();
1151
 
#endif
1152
 
      if(!syscall (__NR_ioprio_set, IOPRIO_WHO_PROCESS, getpid (),
1153
 
                   IOPRIO_PRIO_VALUE (IOPRIO_CLASS_IDLE, 0)))
1154
 
        {
1155
 
          sync ();
1156
 
        }
1157
 
      _exit (EXIT_SUCCESS);
1158
 
    }
1159
 
#endif
1160
1140
 
1161
1141
  if (!shutdown || shutdown_save)
1162
1142
    {
1211
1191
{
1212
1192
  if (G_UNLIKELY (xfsm_client_get_state (client) != XFSM_CLIENT_IDLE))
1213
1193
    {
 
1194
 
 
1195
 
1214
1196
      xfsm_verbose ("Client Id = %s, requested SAVE YOURSELF, but client is not in IDLE mode.\n"
1215
1197
                    "   Client will be nuked now.\n\n",
1216
1198
                    xfsm_client_get_id (client));
1774
1756
}
1775
1757
 
1776
1758
 
 
1759
gboolean
 
1760
xfsm_manager_get_start_at (XfsmManager *manager)
 
1761
{
 
1762
  return manager->start_at;
 
1763
}
 
1764
 
1777
1765
 
1778
1766
/*
1779
1767
 * dbus server impl
1797
1785
static gboolean xfsm_manager_dbus_checkpoint (XfsmManager *manager,
1798
1786
                                              const gchar *session_name,
1799
1787
                                              GError     **error);
 
1788
static gboolean xfsm_manager_dbus_logout (XfsmManager *manager,
 
1789
                                          gboolean     show_dialog,
 
1790
                                          gboolean     allow_save,
 
1791
                                          GError     **error);
1800
1792
static gboolean xfsm_manager_dbus_shutdown (XfsmManager *manager,
1801
 
                                            guint        type,
1802
1793
                                            gboolean     allow_save,
1803
1794
                                            GError     **error);
 
1795
static gboolean xfsm_manager_dbus_can_shutdown (XfsmManager *manager,
 
1796
                                                gboolean    *can_shutdown,
 
1797
                                                GError     **error);
 
1798
static gboolean xfsm_manager_dbus_restart (XfsmManager *manager,
 
1799
                                           gboolean     allow_save,
 
1800
                                           GError     **error);
 
1801
static gboolean xfsm_manager_dbus_can_restart (XfsmManager *manager,
 
1802
                                               gboolean    *can_restart,
 
1803
                                               GError     **error);
 
1804
static gboolean xfsm_manager_dbus_suspend (XfsmManager *manager,
 
1805
                                           GError     **error);
 
1806
static gboolean xfsm_manager_dbus_can_suspend (XfsmManager *manager,
 
1807
                                               gboolean    *can_suspend,
 
1808
                                               GError     **error);
 
1809
static gboolean xfsm_manager_dbus_hibernate (XfsmManager *manager,
 
1810
                                             GError     **error);
 
1811
static gboolean xfsm_manager_dbus_can_hibernate (XfsmManager *manager,
 
1812
                                                 gboolean    *can_hibernate,
 
1813
                                                 GError     **error);
1804
1814
 
1805
1815
 
1806
1816
/* eader needs the above fwd decls */
1807
 
#include "xfsm-manager-dbus.h"
 
1817
#include <xfce4-session/xfsm-manager-dbus.h>
1808
1818
 
1809
1819
 
1810
1820
static void
1974
1984
 
1975
1985
 
1976
1986
static gboolean
1977
 
xfsm_manager_dbus_shutdown (XfsmManager *manager,
1978
 
                            guint        type,
1979
 
                            gboolean     allow_save,
1980
 
                            GError     **error)
 
1987
xfsm_manager_save_yourself_dbus (XfsmManager       *manager,
 
1988
                                 XfsmShutdownType   type,
 
1989
                                 gboolean           allow_save,
 
1990
                                 GError           **error)
1981
1991
{
1982
1992
  ShutdownIdleData *idata;
1983
1993
 
1988
1998
      return FALSE;
1989
1999
    }
1990
2000
 
1991
 
  if (type > XFSM_SHUTDOWN_HIBERNATE)
1992
 
    {
1993
 
      g_set_error (error, XFSM_ERROR, XFSM_ERROR_BAD_VALUE,
1994
 
                   _("Invalid shutdown type \"%u\""), type);
1995
 
      return FALSE;
1996
 
    }
1997
 
 
1998
2001
  idata = g_new (ShutdownIdleData, 1);
1999
2002
  idata->manager = manager;
2000
2003
  idata->type = type;
2004
2007
 
2005
2008
  return TRUE;
2006
2009
}
 
2010
 
 
2011
 
 
2012
static gboolean
 
2013
xfsm_manager_dbus_logout (XfsmManager *manager,
 
2014
                          gboolean     show_dialog,
 
2015
                          gboolean     allow_save,
 
2016
                          GError     **error)
 
2017
{
 
2018
  XfsmShutdownType type;
 
2019
 
 
2020
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2021
 
 
2022
  type = show_dialog ? XFSM_SHUTDOWN_ASK : XFSM_SHUTDOWN_LOGOUT;
 
2023
  return xfsm_manager_save_yourself_dbus (manager, type,
 
2024
                                          allow_save, error);
 
2025
}
 
2026
 
 
2027
 
 
2028
static gboolean
 
2029
xfsm_manager_dbus_shutdown (XfsmManager *manager,
 
2030
                            gboolean     allow_save,
 
2031
                            GError     **error)
 
2032
{
 
2033
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2034
  return xfsm_manager_save_yourself_dbus (manager, XFSM_SHUTDOWN_SHUTDOWN,
 
2035
                                          allow_save, error);
 
2036
}
 
2037
 
 
2038
 
 
2039
static gboolean
 
2040
xfsm_manager_dbus_can_shutdown (XfsmManager *manager,
 
2041
                                gboolean    *can_shutdown,
 
2042
                                GError     **error)
 
2043
{
 
2044
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2045
  return xfsm_shutdown_can_shutdown (manager->shutdown_helper,
 
2046
                                     can_shutdown, error);
 
2047
}
 
2048
 
 
2049
 
 
2050
static gboolean
 
2051
xfsm_manager_dbus_restart (XfsmManager *manager,
 
2052
                           gboolean     allow_save,
 
2053
                           GError     **error)
 
2054
{
 
2055
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2056
  return xfsm_manager_save_yourself_dbus (manager, XFSM_SHUTDOWN_RESTART,
 
2057
                                          allow_save, error);
 
2058
}
 
2059
 
 
2060
 
 
2061
static gboolean
 
2062
xfsm_manager_dbus_can_restart (XfsmManager *manager,
 
2063
                               gboolean    *can_restart,
 
2064
                               GError     **error)
 
2065
{
 
2066
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2067
  return xfsm_shutdown_can_restart (manager->shutdown_helper,
 
2068
                                    can_restart, error);
 
2069
}
 
2070
 
 
2071
 
 
2072
static gboolean
 
2073
xfsm_manager_dbus_suspend (XfsmManager *manager,
 
2074
                           GError     **error)
 
2075
{
 
2076
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2077
  return xfsm_shutdown_try_suspend (manager->shutdown_helper, error);
 
2078
}
 
2079
 
 
2080
 
 
2081
static gboolean
 
2082
xfsm_manager_dbus_can_suspend (XfsmManager *manager,
 
2083
                               gboolean    *can_suspend,
 
2084
                               GError     **error)
 
2085
{
 
2086
  gboolean retval;
 
2087
  gboolean auth_suspend;
 
2088
 
 
2089
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2090
  retval = xfsm_shutdown_can_suspend (manager->shutdown_helper,
 
2091
                                      can_suspend, &auth_suspend, error);
 
2092
 
 
2093
  if (!auth_suspend)
 
2094
    *can_suspend = FALSE;
 
2095
 
 
2096
  return retval;
 
2097
}
 
2098
 
 
2099
static gboolean
 
2100
xfsm_manager_dbus_hibernate (XfsmManager *manager,
 
2101
                             GError     **error)
 
2102
{
 
2103
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2104
  return xfsm_shutdown_try_hibernate (manager->shutdown_helper, error);
 
2105
}
 
2106
 
 
2107
 
 
2108
static gboolean
 
2109
xfsm_manager_dbus_can_hibernate (XfsmManager *manager,
 
2110
                                 gboolean    *can_hibernate,
 
2111
                                 GError     **error)
 
2112
{
 
2113
  gboolean retval;
 
2114
  gboolean auth_hibernate;
 
2115
 
 
2116
  g_return_val_if_fail (XFSM_IS_MANAGER (manager), FALSE);
 
2117
  retval = xfsm_shutdown_can_hibernate (manager->shutdown_helper,
 
2118
                                        can_hibernate, &auth_hibernate, error);
 
2119
 
 
2120
  if (!auth_hibernate)
 
2121
    *can_hibernate = FALSE;
 
2122
 
 
2123
  return retval;
 
2124
}