Merge lp:~light-locker-settings-team/light-locker-settings/xfconf into lp:light-locker-settings

[Sean Davis]

Ready for merge. Adds xfce4-session and xfce4-power-manager support.

[Simon Steinbeiß (ochosi)]

Makes sense and works great! Go ahead and merge it

review: Approve

=== modified file 'Makefile.in.in'
--- Makefile.in.in	2014-03-12 00:56:48 +0000
+++ Makefile.in.in	2014-04-04 10:52:41 +0000
@@ -21,6 +21,7 @@
 	
 	install -d $(DESTDIR)/$(PREFIX)/share/$(APPNAME)/light-locker-settings
 	install light-locker-settings/light-locker-settings.py $(DESTDIR)/$(PREFIX)/share/$(APPNAME)/light-locker-settings
+	install light-locker-settings/light_locker_xfsync.py $(DESTDIR)/$(PREFIX)/share/$(APPNAME)/light-locker-settings
 	install light-locker-settings/light-locker-settings.glade $(DESTDIR)/$(PREFIX)/share/$(APPNAME)/light-locker-settings
 
 	install -d $(DESTDIR)/$(PREFIX)/share/doc/$(APPNAME)

=== modified file 'NEWS'
--- NEWS	2014-03-25 02:29:49 +0000
+++ NEWS	2014-04-04 10:52:41 +0000
@@ -1,5 +1,10 @@
 Light Locker Settings                                                      NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+04 Apr 2014, Light Locker Settings 1.2.1
+
+- Support for external power management tools
+  . Added support for xfce4-session and xfce4-power-manager (fixes LP:1290737)
+
 24 Mar 2014, Light Locker Settings 1.2.0
 
 - light-locker settings:

=== modified file 'debian/changelog'
--- debian/changelog	2014-03-25 02:37:45 +0000
+++ debian/changelog	2014-04-04 10:52:41 +0000
@@ -1,4 +1,11 @@
-light-locker-settings (1.2.0-0ubuntu1) UNRELEASED; urgency=medium
+light-locker-settings (1.2.1-0ubuntu1) trusty; urgency=medium
+
+  * New upstream release. (LP: #1302484)
+    - Fixes XFCE Power Manager setttings sync (LP: #1290737)
+
+ -- Sean Davis <[e-mail]>  Fri, 04 Apr 2014 06:46:52 -0400
+
+light-locker-settings (1.2.0-0ubuntu1) trusty; urgency=medium
 
   * New upstream release. (LP: #1297058)
 

=== modified file 'light-locker-settings/light-locker-settings.py'
--- light-locker-settings/light-locker-settings.py	2014-03-24 02:59:57 +0000
+++ light-locker-settings/light-locker-settings.py	2014-04-04 10:52:41 +0000
@@ -30,6 +30,8 @@
 
 import psutil
 
+import light_locker_xfsync
+
 ''' Settings window for the light-locker '''
 
 username = GLib.get_user_name()
@@ -40,7 +42,8 @@
 
     def __init__(self):
         '''Initialize the Light Locker Settings application.'''
-        self.systemwide_desktop_file = "/etc/xdg/autostart/light-locker.desktop"
+        self.systemwide_desktop_file = \
+            "/etc/xdg/autostart/light-locker.desktop"
         self.user_desktop_file = os.path.join(os.path.expanduser('~'),
                                               '.config',
                                               'autostart',
@@ -91,32 +94,9 @@
             self.screenoff_timeout.add_mark(i * 10, 3, None)
             self.lock_delay.add_mark(i * 10, 3, None)
 
-        ''' if there is a file exists in ~/.config/autostart/ parse that
-            for current settings picked by the user else load in the
-            systemwide '''
-        if os.path.isfile(self.user_desktop_file):
-            self.read_in_desktop(self.user_desktop_file)
-        else:
-            self.read_in_desktop(self.systemwide_desktop_file)
-
-        ''' read in the X11 screensaver settings from bash '''
-        screensaver_output = self.run_command('xset q', check_output=True)
-        screenblank_timeout_grep = re.search(
-            "timeout: *(\d+)", screensaver_output)
-        if screenblank_timeout_grep:
-            screenblank_timeout = re.findall(
-                '\d+', screenblank_timeout_grep.group(1))
-            self.screenblank_timeout.set_value(
-                int(screenblank_timeout[0]) / 60)
-        screenoff_timeout_grep = re.search(
-            "Standby: *(\d+)", screensaver_output)
-        if screenoff_timeout_grep:
-            screenoff_timeout = re.findall(
-                '\d+', screenoff_timeout_grep.group(1))
-            self.screenoff_timeout.set_value(int(screenoff_timeout[0]) / 60)
+        self.init_settings()
 
         ''' Monitor changes to the settings '''
-
         self.apply.set_sensitive(False)
         self.locksettings_changed = False
         self.screenblank_timeout.connect(
@@ -126,6 +106,115 @@
         self.lock_delay.connect(
             "value-changed", self.lock_delay_value_changed_cb)
 
+# Application Callbacks
+    def screenblank_value_changed_cb(self, gparam):
+        '''Sync screenblank and screenoff settings when values are modified.'''
+        self.apply.set_sensitive(True)
+
+        blank_timeout = int(self.screenblank_timeout.get_value())
+        off_timeout = int(self.screenoff_timeout.get_value())
+
+        ''' screenoff can never be shorter than screenblank-timeout '''
+        if (blank_timeout >= off_timeout) and (off_timeout != 0):
+            self.screenoff_timeout.set_value(blank_timeout)
+
+    def screenoff_value_changed_cb(self, gparam):
+        '''Sync screenblank and screenoff settings when values are modified.'''
+        self.apply.set_sensitive(True)
+
+        blank_timeout = int(self.screenblank_timeout.get_value())
+        off_timeout = int(self.screenoff_timeout.get_value())
+
+        ''' screenoff can never be shorter than screenblank-timeout '''
+        if off_timeout <= blank_timeout:
+            self.screenblank_timeout.set_value(off_timeout)
+
+    def use_lightlocker_cb(self, switch, gparam):
+        '''Update the displayed lock controls when light-locker is enabled or
+        disabled.'''
+        ''' if on then allow for the timeout to be set '''
+        self.locksettings_changed = True
+        self.apply.set_sensitive(True)
+        if switch.get_active():
+            self.lock_delay.set_sensitive(False)
+            self.session_lock_combo.set_sensitive(False)
+            self.lock_on_suspend.set_sensitive(False)
+        else:
+            self.session_lock_combo.set_sensitive(True)
+            self.lock_on_suspend.set_sensitive(True)
+            if self.session_lock_combo.get_active() != 2:
+                self.lock_delay.set_sensitive(True)
+
+    def on_session_lock_combo_changed(self, widget):
+        '''Update the displayed screen blanking controls when locking is
+        enabled or disabled.'''
+        self.locksettings_changed = True
+        self.apply.set_sensitive(True)
+
+        # Check the session lock combo:
+        #  0. lock when screensaver is activated
+        #  1. lock when screensaver is deactivated
+        #  2. never lock
+        active = widget.get_active()
+        self.lock_delay.set_sensitive(active != 2)
+
+    def lock_delay_value_changed_cb(self, gparam):
+        '''Enable saving of lock setting when the delay has been modified.'''
+        self.locksettings_changed = True
+        self.apply.set_sensitive(True)
+
+    def lock_on_suspend_cb(self, widget, gparam):
+        '''Enable saving when locking on suspend is changed.'''
+        self.locksettings_changed = True
+        self.apply.set_sensitive(True)
+
+    def apply_cb(self, button, data=None):
+        '''Apply changes and update the relevant setting files.'''
+        ''' Check whether the autostart-directory exists and if not
+        create it '''
+        autostart_dir = os.path.dirname(self.user_desktop_file)
+        if not os.path.exists(autostart_dir):
+            os.makedirs(autostart_dir)
+
+        self.apply_settings()
+        self.apply.set_sensitive(False)
+
+    def on_window_destroy(self, *args):
+        '''Exit the application when the window is closed.'''
+        Gtk.main_quit()
+
+    def on_close_clicked(self, *args):
+        '''Exit the application when the window is closed.'''
+        Gtk.main_quit()
+
+# Process Management
+    def check_running_process(self, process_name):
+        """Return True if the specified process is active."""
+        # Find the process...
+        for pid in psutil.get_pid_list():
+            p = psutil.Process(pid)
+            if p.username == username:
+                # When found, end the light-locker process.
+                try:
+                    if os.path.basename(p.exe) == process_name:
+                        return True
+                except psutil._error.AccessDenied:
+                    pass
+        return False
+
+    def stop_light_locker(self):
+        """Safely stop the light-locker process."""
+        # Find the process...
+        for pid in psutil.get_pid_list():
+            p = psutil.Process(pid)
+            if p.username == username:
+                # When found, end the light-locker process.
+                try:
+                    if os.path.basename(p.exe) == 'light-locker':
+                        p.terminate()
+                except psutil._error.AccessDenied:
+                    pass
+
     def run_command(self, cmd, check_output=False):
         '''Run a shell command, return its output.'''
         if len(cmd) == 0:
@@ -137,18 +226,62 @@
             subprocess.Popen(cmd.split(" "))
             return None
 
-    def stop_light_locker(self):
-        """Safely stop the light-locker process."""
-        # Find the process...
-        for pid in psutil.get_pid_list():
-            p = psutil.Process(pid)
-            if p.username == username:
-                # When found, end the light-locker process.
-                try:
-                    if os.path.basename(p.exe) == 'light-locker':
-                        p.terminate()
-                except psutil._error.AccessDenied:
-                    pass
+# Settings Parsing
+    def init_settings(self):
+        # Get the Settings, first from light-locker, then override as needed
+        ''' if there is a file exists in ~/.config/autostart/ parse that
+            for current settings picked by the user else load in the
+            systemwide '''
+        if os.path.isfile(self.user_desktop_file):
+            desktop_file = self.user_desktop_file
+        else:
+            desktop_file = self.systemwide_desktop_file
+        settings = self.read_in_desktop(desktop_file)
+        use_light_locker = settings['light-locker-enabled']
+        lock_after_screensaver = settings['lock-after-screensaver']
+        late_locking = settings['late-locking']
+        lock_on_suspend = settings['lock-on-suspend']
+        lock_time = settings['lock-time']
+        screen_blank_timeout, screen_off_timeout = \
+            self.get_screen_blank_timeout()
+
+        # Replace settings with xfce4-session
+        if self.check_running_process("xfce4-session"):
+            session_sync = light_locker_xfsync.XfceSessionSync()
+            lock_on_suspend = session_sync.get_lock()
+
+        # Replace settings with xfce4-power-manager
+        if self.check_running_process("xfce4-power-manager"):
+            xfpm_sync = light_locker_xfsync.XfpmSync()
+            screen_blank_timeout, screen_off_timeout = xfpm_sync.get_dpms()
+            screen_blank_timeout = self.light_locker_time_down_scaler(
+                screen_blank_timeout)
+            screen_off_timeout = self.light_locker_time_down_scaler(
+                screen_off_timeout)
+
+        # Apply the settings
+        self.use_lightlocker.set_active(use_light_locker)
+        self.session_lock_combo.set_sensitive(use_light_locker)
+        self.lock_on_suspend.set_sensitive(use_light_locker)
+
+        self.lock_delay.set_value(lock_time)
+
+        if lock_after_screensaver:
+            self.lock_delay.set_sensitive(True)
+            if late_locking:
+                self.session_lock_combo.set_active(1)
+            else:
+                self.session_lock_combo.set_active(0)
+        else:
+            self.lock_delay.set_sensitive(False)
+            self.session_lock_combo.set_active(2)
+
+        self.lock_on_suspend.set_active(lock_on_suspend)
+
+        blank = self.light_locker_time_down_scaler(screen_blank_timeout)
+        off = self.light_locker_time_down_scaler(screen_off_timeout)
+        self.screenblank_timeout.set_value(blank)
+        self.screenoff_timeout.set_value(off)
 
     def read_in_desktop(self, filepath):
         '''Parse the .desktop file for light-locker settings.'''
@@ -156,7 +289,7 @@
             self.content = f.readlines()
             for line in self.content:
                 if line.startswith("Exec="):
-                    self.parse_options(line)
+                    return self.parse_options(line)
 
     def parse_options(self, options_line):
         '''Parse command-line arguments from the Exec line.'''
@@ -197,107 +330,44 @@
             if args.lock_on_suspend:
                 lock_on_suspend = True
 
-        # Apply the settings
-        self.use_lightlocker.set_active(use_light_locker)
-        self.session_lock_combo.set_sensitive(use_light_locker)
-        self.lock_on_suspend.set_sensitive(use_light_locker)
-
-        self.lock_delay.set_value(lock_time)
-
-        if lock_after_screensaver:
-            self.lock_delay.set_sensitive(True)
-            if late_locking:
-                self.session_lock_combo.set_active(1)
-            else:
-                self.session_lock_combo.set_active(0)
-        else:
-            self.lock_delay.set_sensitive(False)
-            self.session_lock_combo.set_active(2)
-
-        self.lock_on_suspend.set_active(lock_on_suspend)
-
-    def write_light_locker_file(self, filepath, light_locker_command):
-        '''Write the updated light-locker settings to its .desktop file.'''
-        exec_str = "Exec=%s\n" % light_locker_command
-        with open(filepath, 'w') as f:
-            for line in self.content:
-                if line.startswith("Exec="):
-                    f.write(exec_str)
-                else:
-                    f.write(line)
-
-    def write_screensaver_file(self, filepath, screensaver_command):
-        '''Write the updated screensaver settings to its .desktop file.'''
-        with open(filepath, 'w') as f:
-            f.write(
-                "[Desktop Entry]\n"
-                "Name=%s\n"
-                "Comment=%s\n"
-                "Exec=%s\n"
-                % (_("Screensaver"), _("Set screensaver timeouts"),
-                    screensaver_command))
-
-    def use_lightlocker_cb(self, switch, gparam):
-        '''Update the displayed lock controls when light-locker is enabled or
-        disabled.'''
-        ''' if on then allow for the timeout to be set '''
-        self.locksettings_changed = True
-        self.apply.set_sensitive(True)
-        if switch.get_active():
-            self.lock_delay.set_sensitive(False)
-            self.session_lock_combo.set_sensitive(False)
-            self.lock_on_suspend.set_sensitive(False)
-        else:
-            self.session_lock_combo.set_sensitive(True)
-            self.lock_on_suspend.set_sensitive(True)
-            if self.session_lock_combo.get_active() != 2:
-                self.lock_delay.set_sensitive(True)
-
-    def on_session_lock_combo_changed(self, widget):
-        '''Update the displayed screen blanking controls when locking is
-        enabled or disabled.'''
-        self.locksettings_changed = True
-        self.apply.set_sensitive(True)
-
-        # Check the session lock combo:
-        #  0. lock when screensaver is activated
-        #  1. lock when screensaver is deactivated
-        #  2. never lock
-        active = widget.get_active()
-        self.lock_delay.set_sensitive(active != 2)
-
-    def lock_on_suspend_cb(self, widget, gparam):
-        '''Enable saving when locking on suspend is changed.'''
-        self.locksettings_changed = True
-        self.apply.set_sensitive(True)
-
-    def screenblank_value_changed_cb(self, gparam):
-        '''Sync screenblank and screenoff settings when values are modified.'''
-        self.apply.set_sensitive(True)
-
-        blank_timeout = int(self.screenblank_timeout.get_value())
-        off_timeout = int(self.screenoff_timeout.get_value())
-
-        ''' screenoff can never be shorter than screenblank-timeout '''
-        if (blank_timeout >= off_timeout) and (off_timeout != 0):
-            self.screenoff_timeout.set_value(blank_timeout)
-
-    def screenoff_value_changed_cb(self, gparam):
-        '''Sync screenblank and screenoff settings when values are modified.'''
-        self.apply.set_sensitive(True)
-
-        blank_timeout = int(self.screenblank_timeout.get_value())
-        off_timeout = int(self.screenoff_timeout.get_value())
-
-        ''' screenoff can never be shorter than screenblank-timeout '''
-        if off_timeout <= blank_timeout:
-            self.screenblank_timeout.set_value(off_timeout)
-
-    def lock_delay_value_changed_cb(self, gparam):
-        '''Enable saving of lock setting when the delay has been modified.'''
-        self.locksettings_changed = True
-        self.apply.set_sensitive(True)
-
+        settings = dict()
+        settings['light-locker-enabled'] = use_light_locker
+        settings['lock-after-screensaver'] = lock_after_screensaver
+        settings['late-locking'] = late_locking
+        settings['lock-on-suspend'] = lock_on_suspend
+        settings['lock-time'] = lock_time
+
+        return settings
+
+    def get_screen_blank_timeout(self):
+        ''' read in the X11 screensaver settings from bash '''
+        # Defaults
+        screen_blank = 10
+        screen_off = 15
+
+        # Get the xset output to parse.
+        screensaver_output = self.run_command('xset q', check_output=True)
+
+        # Get the Screen-Blank timeout
+        screenblank_timeout_grep = re.search(
+            "timeout: *(\d+)", screensaver_output)
+        if screenblank_timeout_grep:
+            screenblank_timeout = re.findall(
+                '\d+', screenblank_timeout_grep.group(1))
+            screen_blank = int(screenblank_timeout[0]) / 60
+
+        # Get the Screen-Off timeout
+        screenoff_timeout_grep = re.search(
+            "Standby: *(\d+)", screensaver_output)
+        if screenoff_timeout_grep:
+            screenoff_timeout = re.findall(
+                '\d+', screenoff_timeout_grep.group(1))
+            screen_off = int(screenoff_timeout[0]) / 60
+
+        # Return the current timeout settings
+        return screen_blank, screen_off
+
+# Label Formatters
     def screensaver_label_formatter(self, screenblank_timeout, max_value):
         '''Convert timeout values to a more friendly format.'''
         value = int(screenblank_timeout.get_value())
@@ -316,6 +386,15 @@
             formatted_string = self.secs_to_readable(value)
         return formatted_string
 
+    def secs_to_readable(self, seconds):
+        '''Convert seconds to a more friendly format.'''
+        if seconds >= 60:
+            minutes = seconds / 60
+            return ngettext("%d minute", "%d minutes", minutes) % (minutes,)
+        else:
+            return ngettext("%d second", "%d seconds", seconds) % (seconds,)
+
+# Time Scalers
     def light_locker_time_up_scaler(self, time):
         '''Scale times up.'''
         if time > 60:
@@ -328,49 +407,94 @@
             time = time / 60 + 60
         return time
 
-    def apply_cb(self, button, data=None):
-        '''Apply changes and update the relevant setting files.'''
-        ''' Check whether the autostart-directory exists and if not
-        create it '''
-        autostart_dir = os.path.dirname(self.user_desktop_file)
-        if not os.path.exists(autostart_dir):
-            os.makedirs(autostart_dir)
-
-        # Apply changes.
-        self.apply_light_locker_settings()
-        self.apply_screen_blank_settings()
-
-        self.apply.set_sensitive(False)
-
-    def apply_light_locker_settings(self):
-        '''Apply the light-locker settings'''
-        # Stop any running light-locker processes.
-        self.stop_light_locker()
-
+# Settings Writing
+    def get_updated_settings(self):
+        """Return a dictionary with the updated settings from the GUI."""
         # Get the lock-after-screensaver timeout.
         session_lock = self.session_lock_combo.get_active()
         if session_lock == 2:  # never lock with screensaver
-            late_locking = ""
-            timeout = "0"
+            late_locking = False
+            lock_delay = 0
         else:
             if session_lock == 0:  # lock when screensaver is activated
-                late_locking = "--no-late-locking"
+                late_locking = False
             if session_lock == 1:  # lock when screensaver is deactivated
-                late_locking = "--late-locking"
-            lock_delay_scaled = self.light_locker_time_up_scaler(
+                late_locking = True
+            lock_delay = self.light_locker_time_up_scaler(
                 int(self.lock_delay.get_value()))
-            timeout = str(lock_delay_scaled)
-        lock_after_screensaver = "--lock-after-screensaver=" + timeout
+
+        # Lock Enabled?
+        lock_enabled = self.use_lightlocker.get_active()
 
         # Get the suspend setting.
-        if self.lock_on_suspend.get_active():
+        lock_on_suspend = self.lock_on_suspend.get_active()
+
+        # Get the screen-blank and screen-off timeout.
+        screenblank_timeout = \
+            int(self.screenblank_timeout.get_value()) * 60
+        screenoff_timeout = int(self.screenoff_timeout.get_value()) * 60
+
+        settings = {
+            "lock-enabled": lock_enabled,
+            "late-locking": late_locking,
+            "lock-after-screensaver": lock_delay,
+            "lock-on-suspend": lock_on_suspend,
+            "screen-blank-timeout": screenblank_timeout,
+            "screen-off-timeout": screenoff_timeout
+        }
+
+        return settings
+
+    def apply_settings(self):
+        """Apply updated settings."""
+        # Get the current settings from the GUI.
+        settings = self.get_updated_settings()
+
+        # If xfce4-sesssion is running, sync the lock-on-suspend setting.
+        if self.check_running_process("xfce4-session"):
+            session_sync = light_locker_xfsync.XfceSessionSync()
+            session_sync.set_lock(settings['lock-on-suspend'])
+
+            # If xfce4-session manages locking, disable it for light-locker.
+            settings['lock-on-suspend'] = False
+
+        # If xfce4-power-manager is running, sync the DPMS settings.
+        if self.check_running_process("xfce4-power-manager"):
+            xfpm_sync = light_locker_xfsync.XfpmSync()
+            screen_off = settings['screen-off-timeout'] / 60
+            screen_blank = settings['screen-blank-timeout'] / 60
+            xfpm_sync.set_dpms(screen_blank, screen_off)
+
+        # Apply the remaining settings to light-locker.
+        self.apply_light_locker_settings(settings)
+        self.apply_screen_blank_settings(settings)
+
+    def apply_light_locker_settings(self, settings):
+        '''Apply the light-locker settings'''
+        # Stop any running light-locker processes.
+        self.stop_light_locker()
+
+        lock_enabled = settings['lock-enabled']
+        late_locking = settings['late-locking']
+        lock_on_suspend = settings['lock-on-suspend']
+        lock_after_screensaver = settings['lock-after-screensaver']
+
+        if late_locking:
+            late_locking = "--late-locking"
+        else:
+            late_locking = "--no-late-locking"
+
+        if lock_on_suspend:
             lock_on_suspend = "--lock-on-suspend"
         else:
             lock_on_suspend = "--no-lock-on-suspend"
 
+        lock_after_screensaver = "--lock-after-screensaver=%i" % \
+            lock_after_screensaver
+
         # Build the light-locker command.
         light_locker_exec = ""
-        if self.use_lightlocker.get_active():
+        if lock_enabled:
             light_locker_exec = \
                 "light-locker %s %s %s" % (lock_after_screensaver,
                                            lock_on_suspend, late_locking)
@@ -381,16 +505,14 @@
         # Execute the updated light-locker command.
         self.run_command(light_locker_exec)
 
-    def apply_screen_blank_settings(self):
+    def apply_screen_blank_settings(self, settings):
         '''Apply the screen blank settings.'''
-        # Get the screen-blank and screen-off timeout.
-        screenblank_timeout = str(
-            int(self.screenblank_timeout.get_value()) * 60)
-        screenoff_timeout = str(int(self.screenoff_timeout.get_value()) * 60)
+        screenblank_timeout = settings['screen-blank-timeout']
+        screenoff_timeout = settings['screen-off-timeout']
 
         # Build the screen-blank/off command.
         screensaver_exec = \
-            "xset s %s dpms %s 0 0" % (screenblank_timeout, screenoff_timeout)
+            "xset s %i dpms %i 0 0" % (screenblank_timeout, screenoff_timeout)
 
         # Execute the updated screensaver command.
         self.run_command(screensaver_exec)
@@ -399,24 +521,26 @@
         self.write_screensaver_file(
             self.screenblank_timeout_desktop_file, screensaver_exec)
 
-        # Does this command really need to be run after we run the right one?
-        #self.run_command('xset s ' + screenblank_timeout)
-
-    def secs_to_readable(self, seconds):
-        '''Convert seconds to a more friendly format.'''
-        if seconds >= 60:
-            minutes = seconds / 60
-            return ngettext("%d minute", "%d minutes", minutes) % (minutes,)
-        else:
-            return ngettext("%d second", "%d seconds", seconds) % (seconds,)
-
-    def on_window_destroy(self, *args):
-        '''Exit the application when the window is closed.'''
-        Gtk.main_quit()
-
-    def on_close_clicked(self, *args):
-        '''Exit the application when the window is closed.'''
-        Gtk.main_quit()
+    def write_light_locker_file(self, filepath, light_locker_command):
+        '''Write the updated light-locker settings to its .desktop file.'''
+        exec_str = "Exec=%s\n" % light_locker_command
+        with open(filepath, 'w') as f:
+            for line in self.content:
+                if line.startswith("Exec="):
+                    f.write(exec_str)
+                else:
+                    f.write(line)
+
+    def write_screensaver_file(self, filepath, screensaver_command):
+        '''Write the updated screensaver settings to its .desktop file.'''
+        with open(filepath, 'w') as f:
+            f.write(
+                "[Desktop Entry]\n"
+                "Name=%s\n"
+                "Comment=%s\n"
+                "Exec=%s\n"
+                % (_("Screensaver"), _("Set screensaver timeouts"),
+                    screensaver_command))
 
 
 if __name__ == "__main__":

=== added file 'light-locker-settings/light_locker_xfsync.py'
--- light-locker-settings/light_locker_xfsync.py	1970-01-01 00:00:00 +0000
+++ light-locker-settings/light_locker_xfsync.py	2014-04-04 10:52:41 +0000
@@ -0,0 +1,177 @@
+import subprocess
+
+
+def convert_value(value):
+    """Make output agreeable to xfconf."""
+    if isinstance(value, bool):
+        if value is True:
+            value = 'true'
+        else:
+            value = 'false'
+    return value
+
+
+def xfconf_init_property(channel, p_name, p_type, initial_value):
+    """Initialize the specified xfconf property."""
+    p_type = p_type.__name__
+    initial_value = str(convert_value(initial_value))
+    cmd = 'xfconf-query -c %s -p %s -n -s %s -t %s' % (channel, p_name,
+                                                       initial_value, p_type)
+    subprocess.call(cmd.split())
+
+
+def xfconf_list_properties(channel):
+    """List the properties defined for the given channel."""
+    settings = dict()
+    cmd = 'xfconf-query -c %s -l -v' % channel
+    for line in subprocess.check_output(cmd, shell=True).split('\n'):
+        try:
+            key, value = line.split(None, 1)
+        except ValueError:
+            key = line.strip()
+            value = ""
+        if str.isdigit(value):
+            value = int(value)
+        elif value.lower() in ['true', 'false']:
+            value = value.lower() == 'true'
+        else:
+            value = str(value)
+        settings[key] = value
+    return settings
+
+
+def xfconf_set_property(channel, prop, value):
+    """Set the specified xfconf property."""
+    value = str(value).lower()
+    cmd = 'xfconf-query -c %s -p %s -s %s' % (channel, prop, value)
+    subprocess.call(cmd.split())
+
+
+class XfceSessionSync():
+    """
+    Class to set/get xfce4-session lock settings.
+    """
+    def __init__(self):
+        """Initialize the XfceSessionSync instance."""
+        self.settings = {'/shutdown/LockScreen': False}
+        current_settings = self._get_xfce4_session_settings()
+        self._update_settings(current_settings)
+        self._init_xfconf_properties(current_settings)
+
+    def _init_xfconf_properties(self, current_settings):
+        """If xfce4-session has not been configured, some of its properties
+        may not exist. Create any missing properties."""
+        channel = 'xfce4-session'
+        for key, value in list(self.settings.items()):
+            if key not in list(current_settings.keys()):
+                xfconf_init_property(channel, key, type(value), value)
+
+    def _get_xfce4_session_settings(self):
+        """Return a dictionary of the xfce4-session settings."""
+        return xfconf_list_properties('xfce4-session')
+
+    def _update_settings(self, settings):
+        """Update the internal settings."""
+        for key, value in list(settings.items()):
+            if key in list(self.settings.keys()):
+                self.settings[key] = value
+
+    def get_lock(self):
+        """Return True if Lock on Sleep is enabled."""
+        return self.settings['/shutdown/LockScreen']
+
+    def set_lock(self, value):
+        """Set the Lock on Sleep setting."""
+        xfconf_set_property('xfce4-session', '/shutdown/LockScreen', value)
+        self.settings['/shutdown/LockScreen'] = value
+
+
+class XfpmSync():
+    """
+    Class to set/get xserver dpms timings via xfpm, thus keeping xfpm in sync.
+    """
+    def __init__(self):
+        '''Following settings should concur with xfpm defaults'''
+        self.settings = {'/xfce4-power-manager/dpms-enabled': True,
+                         '/xfce4-power-manager/dpms-on-battery-sleep': 5,
+                         '/xfce4-power-manager/dpms-on-battery-off': 10,
+                         '/xfce4-power-manager/dpms-on-ac-sleep': 10,
+                         '/xfce4-power-manager/dpms-on-ac-off': 15,
+                         }
+        current_settings = self._get_xfpm_settings()
+        self._update_settings(current_settings)
+        self._init_xfconf_properties(current_settings)
+
+    def _init_xfconf_properties(self, current_settings):
+        """
+        If xfpm has never been used, some xfconf channel properties may not be
+        set. Ensures that we don't get complains about missing properties.
+        """
+        channel = 'xfce4-power-manager'
+        for key, value in list(self.settings.items()):
+            if key not in list(current_settings.keys()):
+                xfconf_init_property(channel, key, type(value), value)
+
+    def _get_power_state(self):
+        """
+        Get the power state from /sys/class/power_supply/AC/online if present.
+        Returns:
+            1: AC connected
+            0: AC disconnected
+        (Do we always have this file, if a battery is present?)
+        """
+        try:
+            with open('/sys/class/power_supply/AC/online', 'rb') as f:
+                pstate = int(f.readline())
+        except:
+            pstate = 1
+
+        return pstate
+
+    def _get_xfpm_settings(self):
+        """Returns xfpm xfconf settings as string"""
+        return xfconf_list_properties('xfce4-power-manager')
+
+    def _update_settings(self, settings):
+        """Update the internal settings."""
+        for key, value in list(settings.items()):
+            if key in list(self.settings.keys()):
+                self.settings[key] = value
+
+    def _get_timings_scope(self):
+        """Return the timings scope (Batter or AC)."""
+        if self._get_power_state() == 0:
+            sleep = '/xfce4-power-manager/dpms-on-battery-sleep'
+            off = '/xfce4-power-manager/dpms-on-battery-off'
+        else:  # we assume on ac for all other cases
+            sleep = '/xfce4-power-manager/dpms-on-ac-sleep'
+            off = '/xfce4-power-manager/dpms-on-ac-off'
+
+        return sleep, off
+
+    def set_dpms(self, sleep_time, off_time):
+        """
+        For most monitors *_sleep and *_off have probably the same outcome.
+        So, basically we set the lower value for the corresponding power state.
+        But xfpm ignores settings not in:
+            0 <= *_sleep <= *_off
+        or
+            *_off == 0 and *_sleep >= 0
+        i.e. sometimes we have to adapt both.
+        """
+        sleep, off = self._get_timings_scope()
+
+        if not (sleep_time == 0 and off_time == 0):
+            if sleep_time + 1 > off_time:
+                off_time = sleep_time + 1
+
+        xfconf_set_property('xfce4-power-manager', off, off_time)
+        self.settings[off] = off_time
+
+        xfconf_set_property('xfce4-power-manager', sleep, sleep_time)
+        self.settings[sleep] = sleep_time
+
+    def get_dpms(self):
+        """Return the current DPMS timeouts."""
+        sleep, off = self._get_timings_scope()
+        return self.settings[sleep], self.settings[off]