Merge lp:~bkerensa/ubuntu/raring/kazam/new-upstream into lp:ubuntu/raring/kazam

[Benjamin Kerensa]

[Charlie_Smotherman (cjsmo)]

bzr branch lp:ubuntu/kazam
...
bzr merge lp:~bkerensa/ubuntu/raring/kazam/new-upstream
...
bzr builddeb -S -- -sa -us -uc
Building using working tree
Building package in normal mode
Looking for a way to retrieve the upstream tarball
Using apt to look for the upstream tarball.
apt could not find the needed tarball.
Trying to use get-packaged-orig-source to retrieve needed tarball.
dh --with python2 get-packaged-orig-source
dh: Unknown sequence get-packaged-orig-source (choose from: binary binary-arch binary-indep build build-arch build-indep clean install install-arch install-indep)
make: *** [get-packaged-orig-source] Error 255
Trying to run get-packaged-orig-source rule failed
Trying to use get-orig-source to retrieve needed tarball (deprecated).
dh --with python2 get-orig-source
dh: Unknown sequence get-orig-source (choose from: binary binary-arch binary-indep build build-arch build-indep clean install install-arch install-indep)
make: *** [get-orig-source] Error 255
Trying to run get-orig-source rule failed
Using uscan to look for the upstream tarball.
uscan warning: In /tmp/tmprFZq6l no matching hrefs for version 1.3.1 in watch line
  http://launchpad.net/kazam/+download .*/kazam-([0-9.]+)\.tar\.gz
uscan could not find the needed tarball.
bzr: ERROR: Unable to find the needed upstream tarball for package kazam, version 1.3.1.

Please fix debian/watch :)

review: Needs Fixing

[Bryce Harrington (bryce)]

Set status back to Needs Review once the requested fix is made.

[Benjamin Kerensa (bkerensa)]

> Set status back to Needs Review once the requested fix is made.

Any advice on a fix... I am not too familiar with watch file formats so I'm not sure where to begin to fix this but I definately want to fix it and get this into quantal.

Thanks

[Charlie_Smotherman (cjsmo)]

Had to make some additional changes to the packaging so I went ahead and fixed the watchfile while I was there :) Uploaded to raring. If you would like to get kazam 1.3.4 into quantal please have a look at

https://wiki.ubuntu.com/StableReleaseUpdates
https://wiki.ubuntu.com/UbuntuBackports

Thank you for your contribution to Ubuntu

=== modified file 'AUTHORS'
--- AUTHORS	2012-02-09 21:56:49 +0000
+++ AUTHORS	2012-11-15 10:17:01 +0000
@@ -9,4 +9,8 @@
 K.Vishnoo Charan Reddy - Artwork, Bughelp, Design
 Gary Lasker - Coding
 David Klasinc - Coding
+Georgi Karavasilev - Design, Testing
+Alan Pope - Testing
+Mattew Paul Thomas - Design, Testing
+Ken VanDine - Packaging
 

=== added file 'NEWS'
--- NEWS	1970-01-01 00:00:00 +0000
+++ NEWS	2012-11-15 10:17:01 +0000
@@ -0,0 +1,36 @@
+Kazam 1.3.4 - NCC-2893 (Stargazer Edition)
+
+- Instant mode, to capture screenshots from command line, use
+  the following switches:
+    -f / --fullscreen   capture full screen
+    -w / --window       capture currently active window
+    -a / --area         capture a preselected screen area
+    -g / --godmode      disable sounds, use automatic file saving and
+                        capture full screen & active window at the same
+                        time
+
+- New area and window selection screens.
+- Unity Launcher quicklist added.
+
+Kazam 1.3.1 - NCC-2893 (Stargazer Edition)
+------------------------------------------
+
+- GStreamer 1.0 support, Kazam will no longer work with older versions
+  of GStreamer. This includes 0.11 (1.0 alpha/beta/rc) version. Some
+  encoders were changed in transition from beta to final release which
+  messed up a lot of things.
+
+- Completely new GUI. Designed by https://launchpad.net/~kokoto-java with
+  the omnipresent guiding hand of https://launchpad.net/~mpt
+
+- Support for taking still screen captures, also known as screenshots.
+
+- Support for automatic file saving. You can set the prefix filename
+  separately for screenshots and screencasts.
+
+- Support for selecting a single window to screencast. Screenshots are
+  still limited to full screen and/or area selection.
+
+- Theme-able shutter sounds. Right now you can choose between Canon 7D
+  and Nikon D80. ;)
+

=== modified file 'README'
--- README	2012-04-25 16:49:23 +0000
+++ README	2012-11-15 10:17:01 +0000
@@ -1,5 +1,5 @@
 
-           Kazam Screencaster v1.0.6 "NCC-1701D"
+           Kazam Screencaster v1.3.1 "NCC-2893"
 
 
 Introduction
@@ -18,15 +18,25 @@
 
 Kazam is always available from Launchpad under https://launchpad.net/kazam
 
-Right now there are only unstable versions available, the project is still
-in development and a stable release is planned for Ubuntu 12.04.
-
-
-Installation
-------------
-
-For Ubuntu, the best way to install is to add a PPA repository and then
-use apt-get command or Software Centre.
+Latest stable release is 1.0.6.
+Latest unstable release is 1.3.1 - Stargazer edition
+
+
+Installation - stable release
+-----------------------------
+
+If you are using Ubuntu 12.04 or 12.10 then stable version (1.0.x)
+is available from universe repository. You can find it in Ubuntu Softare
+Center or install it from the terminal with the following command:
+
+$ sudo apt-get install kazam
+
+For Ubuntu 11.10 - Oneiric Ocelot, the best way to install Kazam is to add
+a PPA repository and then use apt-get command or Software Centre.
+
+$ sudo add-apt-repository ppa:kazam-team/stable-series
+$ sudo apt-get update
+$ sudo apt-get install kazam
 
 For distribution independent installation you will have to get the latest
 tarball release from Launchpad:
@@ -43,6 +53,9 @@
    # python setup.py install
 
 
+Installation - development version
+----------------------------------
+
 If you want bleeding edge, development version then you will have to get
 source code from Launchpad by running the following command:
 
@@ -57,6 +70,39 @@
 path is /usr/local.
 
 
+Running Kazam
+-------------
+
+If you want to run Kazam from the source tree, there are a few limitations
+that you have to take into account. Right now Ubuntu App indicator will not
+allow setting custom icons. Every icon has to be taken from currently
+installed icon theme. See https://bugs.launchpad.net/kazam/+bug/657857 for
+more information.
+
+To run Kazam simply execute te following commands in the source tree:
+
+$ cd bin
+$ ./kazam
+
+If you already have Kazam installed then Kazam icon will show in the
+indicator, if not, the only way to get to the menu is to click on one
+of the icons in the indicator and then move around with the cursor keys.
+
+Keyboard shortcuts
+------------------
+
+If you have keybinder3.0 from the unstable PPA installed, then you can
+use these keyboard shortcuts for controlling Kazam:
+
+SUPER-CTRL-Q - Quit
+SUPER-CTRL-W - Show/Hide main window
+SUPER-CTRL-R - Start Recording
+SUPER-CTRL-F - Finish Recording
+
+Keyboard shortcuts will work if you installed Kazam 1.3.1 from a PPA,
+keybinder 3.0 is now a dependency and will be installed automatically.
+
+
 Known Issues
 ------------
 
@@ -67,30 +113,14 @@
 - Placing Region selector outside of screen borders will produce unknown
 results and you will probably end up with no video.
 
-- Two warnings appear during the normal usage:
-
-/usr/lib/python2.7/dist-packages/gobject/constants.py:24: Warning:
-g_boxed_type_register_static: assertion `g_type_from_name (name) == 0' failed
-
-This happens when Gtk.GObject was imported before importing gst in python
-and is still being investigated. So far it appears to be mostly harmless.
-
-Second warning comes from Gtk.FileChooser():
-
-kazam:5144): Gtk-WARNING **: Unable to retrieve the file info for <file>
-Error stating file <file> : No such file or directory
-
-This happens when you confirm file save in the dialog box. This is an error
-in Gtk.FileChooser and in Precise Pangolin it is fixed.
-
 - Trouble with recording from certain Monitor sources. I noticed this with
 Logitech G110 USB Keyboard that can play audio. Pulse Audio will see two
 devices: USP PnP Stereo Device and Monitor of USB PnP Stereo Device. When
 recording from the monitor, volume controls for both devices will affect
 the volume in the final recording.
 
-- I have no idea where to put Mute/Unmute button, so you'll have to check
-that in pavucontrol or sound settings. :)
+- I have no idea where to put Mute/Unmute button, so right now every audio
+source you select is automatically unmuted.
 
 - It was reported that sound is disappearing after couple of minutes into
 the recording. I wasn't able to reproduce this bug and any more info is
@@ -100,10 +130,9 @@
 Recording Tips
 --------------
 
-Framerates above 20fps are unlikely to work because of software and hardware
-limitations. If you increase framerate and in resulting video
-framerate actually drops, that is because encoder can't keep up with
-the framerate.
+Framerates above 20fps are unlikely to work well because of software and
+hardware limitations. If you increase framerate and framerate in
+resulting video drops, that is because encoder can't keep up.
 
 Always do a sound check. Especially if you are recording a live commentary
 with background sound. I got the best results when I used earphones to listen
@@ -117,9 +146,5 @@
 If you encounter a bug or any kind of unexpected behavior please try to
 reproduce it while you run Kazam from standard terminal with --debug option.
 Use Launchpad to report bugs (https://bugs.launchpad.net/kazam/+filebug) and
-include generated output. It will also be helpful if you can attach generated
-'dot' file. You will find this file in /tmp/kazam_debug.dot.
-
-If you have graphviz package installed there is also /tmp/kazam_pipeline.png
-file and you can inspect GStreamer pipeline if everything checks out ok.
+include generated output.
 

=== modified file 'TODO'
--- TODO	2012-02-29 20:43:50 +0000
+++ TODO	2012-11-15 10:17:01 +0000
@@ -1,8 +1,14 @@
 TODO
 ----
-Short term:
- - Make a list of new features
-
-Long(er) term:
- - Implement new features ;)
+
+Whishlist (by BigWhale) and reasons why is something still on a whishlist
+
+- Frame marking the capture area while recording is in progress
+  A transparent window with no input mask is required on screen. However,
+  for that to work, Gdk.cairo_region_create_from_surface() is required. For
+  some reason, this fuction still isn't introspected. See:
+
+  http://askubuntu.com/questions/97789/creating-a-gtk-window-with-input-shape-mask-in-python
+
+  (This is still an issue ... :'( )
 

=== modified file 'bin/kazam'
--- bin/kazam	2012-02-29 20:43:50 +0000
+++ bin/kazam	2012-11-15 10:17:01 +0000
@@ -30,25 +30,36 @@
 
 if __name__ == "__main__":
 
-    log =  logging.getLogger()
-    log.name = "Kazam"
+    logger =  logging.getLogger()
+    logger.name = "Kazam"
     handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(levelname)s %(name)-10s - %(message)s')
+    formatter = logging.Formatter('%(levelname)s %(name)s - %(message)s')
     handler.setFormatter(formatter)
-    log.addHandler(handler)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
 
-    log.info("Logger intialized.")
+    logger.info("Logger intialized.")
 
     if os.path.exists("../data"):
-        log.info("Running locally, AppIndicator icons might be missing.")
+        logger.info("Running locally, AppIndicator icons might be missing.")
         datadir = "../data"
         sys.path.insert(0, "..")
     else:
         # A bit more flexible setting of datadir, it works
         # when base install path is not /usr
         curpath = os.path.abspath(__file__)
+        curpath = os.path.realpath(curpath)
         datadir = curpath.split('bin/')[0] + "share/kazam/"
 
+    try:
+        import platform
+        dist = platform.linux_distribution()
+        logger.info("Running on: {0} {1}".format(dist[0], dist[1]))
+    except:
+        # Fallback to the almighty Ubuntu 12.10 ;)
+        dist = ('Ubuntu', '12.10', 'quantal')
+        logger.warning("Failed to correctly detect operating system.")
+
     from kazam.version import *
     version = "%(prog)s {0} '{1}'".format(VERSION, CODENAME)
     parser = ArgumentParser(description = "Screen recording program.")
@@ -62,16 +73,72 @@
                         action = "version",
                         version = version)
 
+    parser.add_argument("-t", "--test",
+                        action = "store_true",
+                        help = "generate test video signal",
+                        default = False)
+
+    parser.add_argument("-n", "--nosound",
+                        action = "store_true",
+                        help = "disable PulseAudio",
+                        default = False)
+
+    parser.add_argument("-s", "--silent",
+                        action = "store_true",
+                        help = "silent start",
+                        default = False)
+
+    parser.add_argument("-f", "--fullscreen",
+                        action = "store_true",
+                        help = "instant screenshot of full screen",
+                        default = False)
+
+    parser.add_argument("-a", "--area",
+                        action = "store_true",
+                        help = "instant screenshot of preselected screen area",
+                        default = False)
+
+    parser.add_argument("-w", "--window",
+                        action = "store_true",
+                        help = "instant screenshot of active window",
+                        default = False)
+
+    parser.add_argument("-p", "--preferences",
+                        action = "store_true",
+                        help = "show preferences window",
+                        default = False)
+
+    parser.add_argument("-g", "--godmode",
+                        action = "store_true",
+                        help = "god mode of capture",
+                        default = False)
+
     args = parser.parse_args()
     if args.debug:
-        log.setLevel(logging.DEBUG)
-    else:
-        log.setLevel(logging.INFO)
-
-    from kazam.app import KazamApp
-
-    log.debug("Starting ...")
-    appWindow = KazamApp(datadir, args.debug)
-    appWindow.show_all()
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+
+    logger.debug("Starting ...")
+
+    if args.fullscreen:
+        from kazam.instant import InstantApp
+        app = InstantApp(datadir, dist, args.debug, 1) # MODE_ALL
+    elif args.area:
+        from kazam.instant import InstantApp
+        app = InstantApp(datadir, dist, args.debug, 2) # MODE_AREA
+    elif args.window:
+        from kazam.instant import InstantApp
+        app = InstantApp(datadir, dist, args.debug, 4) # MODE_ACTIVE
+    elif args.godmode:
+        from kazam.instant import InstantApp
+        app = InstantApp(datadir, dist, args.debug, 666) # MODE_ACTIVE
+    elif args.preferences:
+        from kazam.instant import InstantApp
+        app = InstantApp(datadir, dist, args.debug, 0, preferences=True)
+    else:
+        from kazam.app import KazamApp
+        appWindow = KazamApp(datadir, dist, args.debug, args.test, args.nosound, args.silent)
+
     Gtk.main()
-    log.debug("Finishing ...")
+    logger.debug("Finishing ...")

=== added directory 'build'
=== added directory 'build/lib.linux-x86_64-2.7'
=== added directory 'build/lib.linux-x86_64-2.7/kazam'
=== added file 'build/lib.linux-x86_64-2.7/kazam/__init__.py'
--- build/lib.linux-x86_64-2.7/kazam/__init__.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/__init__.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,1 @@
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/app.py'
--- build/lib.linux-x86_64-2.7/kazam/app.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/app.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,748 @@
+# -*- coding: utf-8 -*-
+#
+#       app.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import sys
+import locale
+import shutil
+import gettext
+import logging
+
+from subprocess import Popen
+from gi.repository import Gtk, Gdk, GObject
+from gettext import gettext as _
+
+from kazam.utils import *
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+from kazam.backend.grabber import Grabber
+from kazam.frontend.main_menu import MainMenu
+from kazam.frontend.window_area import AreaWindow
+from kazam.backend.gstreamer import Screencast
+from kazam.frontend.preferences import Preferences
+from kazam.frontend.about_dialog import AboutDialog
+from kazam.frontend.indicator import KazamIndicator
+from kazam.frontend.window_select import SelectWindow
+from kazam.frontend.done_recording import DoneRecording
+from kazam.frontend.window_countdown import CountdownWindow
+
+logger = logging.getLogger("Main")
+
+#
+# Detect GStreamer version and bail out if lower than 1.0 and no GI
+#
+try:
+    from gi.repository import Gst
+    gst_gi = Gst.version()
+    if not gst_gi[0]:
+        logger.critical("Gstreamer 1.0 or higher requred, bailing out.")
+        gst_gi = None
+        sys.exit(0)
+    else:
+        logger.debug("Gstreamer version detected: {0}.{1}.{2}.{3}".format(gst_gi[0],
+                                                                      gst_gi[1],
+                                                                      gst_gi[2],
+                                                                      gst_gi[3]))
+except ImportError:
+    logger.critical("Gstreamer 1.0 or higher requred, bailing out.")
+    sys.exit(0)
+
+class KazamApp(GObject.GObject):
+
+    def __init__(self, datadir, dist, debug, test, sound, silent):
+        GObject.GObject.__init__(self)
+        logger.debug("Setting variables.")
+
+        prefs.datadir = datadir
+        prefs.get_sound_files()
+
+        self.startup = True
+        prefs.debug = debug
+        prefs.test = test
+        prefs.dist = dist
+        prefs.silent = silent
+        prefs.sound = not sound     # Parameter is called nosound and if true, then we don't have sound.
+                                    # Tricky parameters are tricky!
+
+        self.setup_translations()
+
+        if prefs.sound:
+            try:
+                from kazam.pulseaudio.pulseaudio import pulseaudio_q
+                prefs.sound = True
+            except:
+                logger.warning("Pulse Audio Failed to load. Sound recording disabled.")
+                prefs.sound = False
+
+        self.icons = Gtk.IconTheme.get_default()
+        self.icons.append_search_path(os.path.join(prefs.datadir,"icons", "48x48", "apps"))
+        self.icons.append_search_path(os.path.join(prefs.datadir,"icons", "16x16", "apps"))
+
+        try:
+            from gi.repository import Unity, Dbusmenu
+            launcher = Unity.LauncherEntry.get_for_desktop_id("kazam.desktop")
+            ql = Dbusmenu.Menuitem.new()
+            ql_item1 = Dbusmenu.Menuitem.new()
+            ql_item1.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Record screencast"))
+            ql_item1.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
+            ql_item1.connect("item-activated", self.cb_ql_screencast)
+            ql.child_append(ql_item1)
+            ql_item2 = Dbusmenu.Menuitem.new()
+            ql_item2.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Take screenshot"))
+            ql_item2.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
+            ql_item2.connect("item-activated", self.cb_ql_screenshot)
+            ql.child_append(ql_item2)
+            ql_item3 = Dbusmenu.Menuitem.new()
+            ql_item3.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Preferences"))
+            ql_item3.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
+            ql_item3.connect("item-activated", self.cb_ql_preferences)
+            ql.child_append(ql_item3)
+            launcher.set_property("quicklist", ql)
+        except ImportError:
+            logger.warning("Unity and Dbusmenu not found. Skipping launcher integration.")
+
+        # Initialize all the variables
+
+        self.main_x = 0
+        self.main_y = 0
+        self.countdown = None
+        self.tempfile = ""
+        self.recorder = None
+        self.area_window = None
+        self.old_vid_path = None
+        self.old_pic_path = None
+        self.in_countdown = False
+        self.recording_paused = False
+        self.recording = False
+        self.main_mode = 0
+        self.record_mode = 0
+        self.last_mode = None
+
+        if prefs.sound:
+            prefs.pa_q = pulseaudio_q()
+            prefs.pa_q.start()
+
+        self.mainmenu = MainMenu()
+
+        logger.debug("Connecting indicator signals.")
+        logger.debug("Starting in silent mode: {0}".format(prefs.silent))
+        self.indicator = KazamIndicator(prefs.silent)
+        self.indicator.connect("indicator-quit-request", self.cb_quit_request)
+        self.indicator.connect("indicator-show-request", self.cb_show_request)
+        self.indicator.connect("indicator-start-request", self.cb_start_request)
+        self.indicator.connect("indicator-stop-request", self.cb_stop_request)
+        self.indicator.connect("indicator-pause-request", self.cb_pause_request)
+        self.indicator.connect("indicator-unpause-request", self.cb_unpause_request)
+        self.indicator.connect("indicator-about-request", self.cb_about_request)
+
+        self.mainmenu.connect("file-quit", self.cb_quit_request)
+        self.mainmenu.connect("file-preferences", self.cb_preferences_request)
+        self.mainmenu.connect("help-about", self.cb_help_about)
+
+        #
+        # Setup UI
+        #
+        logger.debug("Main Window UI setup.")
+
+        self.builder = Gtk.Builder()
+        self.builder.add_from_file(os.path.join(prefs.datadir, "ui", "kazam.ui"))
+        self.builder.connect_signals(self)
+        for w in self.builder.get_objects():
+            if issubclass(type(w), Gtk.Buildable):
+                name = Gtk.Buildable.get_name(w)
+                setattr(self, name, w)
+            else:
+                logger.debug("Unable to get name for '%s'" % w)
+
+        # Main Menu
+        self.MainGrid.attach(self.mainmenu.menubar, 0, 0, 1, 1)
+
+        self.context = self.toolbar_main.get_style_context()
+        self.context.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
+
+        self.btn_cast = Gtk.RadioToolButton(group=None)
+        self.btn_cast.set_label(_("Screencast"))
+        self.btn_cast.set_tooltip_text(_("Record a video of your desktop."))
+        img1 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "light", "screencast.png"))
+        self.btn_cast.set_icon_widget(img1)
+        self.btn_cast.set_active(True)
+        self.btn_cast.set_name("MAIN_SCREENCAST")
+        self.btn_cast.connect("toggled", self.cb_main_toggled)
+
+        self.btn_shot = Gtk.RadioToolButton(group=self.btn_cast)
+        self.btn_shot.set_label(_("Screenshot"))
+        self.btn_shot.set_tooltip_text(_("Record a picture of your desktop."))
+        img2 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "light", "screenshot-1.png"))
+        self.btn_shot.set_icon_widget(img2)
+        self.btn_shot.set_name("MAIN_SCREENSHOT")
+        self.btn_shot.connect("toggled", self.cb_main_toggled)
+
+        self.sep_1 = Gtk.SeparatorToolItem()
+        self.sep_1.set_draw(False)
+        self.sep_1.set_expand(True)
+        self.toolbar_main.insert(self.sep_1, -1)
+        self.toolbar_main.insert(self.btn_cast, -1)
+        self.toolbar_main.insert(self.btn_shot, -1)
+        self.toolbar_main.insert(self.sep_1, -1)
+
+        # Auxiliary toolbar
+        self.btn_full = Gtk.RadioToolButton(group=None)
+        self.btn_full.set_label(_("Fullscreen"))
+        self.btn_full.set_tooltip_text(_("Capture contents of the current screen."))
+        img3 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "dark", "fullscreen.png"))
+        self.btn_full.set_icon_widget(img3)
+        self.btn_full.set_active(True)
+        self.btn_full.set_name("MODE_FULL")
+        self.btn_full.connect("toggled", self.cb_record_mode_toggled)
+
+        self.btn_allscreens = Gtk.RadioToolButton(group=self.btn_full)
+        self.btn_allscreens.set_label(_("All Screens"))
+        self.btn_allscreens.set_tooltip_text(_("Capture contents of all of your screens."))
+        img4 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "dark", "all-screens.png"))
+        self.btn_allscreens.set_icon_widget(img4)
+        self.btn_allscreens.set_name("MODE_ALL")
+        self.btn_allscreens.connect("toggled", self.cb_record_mode_toggled)
+
+        self.btn_window = Gtk.RadioToolButton(group=self.btn_full)
+        self.btn_window.set_label(_("Window"))
+        self.btn_window.set_tooltip_text(_("Capture contents of a single window."))
+        img5 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "dark", "window.png"))
+        self.btn_window.set_icon_widget(img5)
+        self.btn_window.set_name("MODE_WIN")
+        self.btn_window.connect("toggled", self.cb_record_mode_toggled)
+        self.btn_window.connect("clicked", self.cb_record_window_clicked)
+
+        self.btn_area = Gtk.RadioToolButton(group=self.btn_full)
+        self.btn_area.set_label(_("Area"))
+        self.btn_area.set_tooltip_text(_("Capture a pre-selected area of your screen."))
+        img6 = Gtk.Image.new_from_file(os.path.join(prefs.datadir, "icons", "dark", "area.png"))
+        self.btn_area.set_icon_widget(img6)
+        self.btn_area.set_name("MODE_AREA")
+        self.btn_area.connect("toggled", self.cb_record_mode_toggled)
+        self.btn_area.connect("clicked", self.cb_record_area_clicked)
+
+        self.sep_2 = Gtk.SeparatorToolItem()
+        self.sep_2.set_draw(False)
+        self.sep_2.set_expand(True)
+        #self.toolbar_aux.insert(self.sep_2, -1)
+        self.toolbar_aux.insert(self.btn_full, -1)
+        self.toolbar_aux.insert(self.btn_allscreens, -1)
+        self.toolbar_aux.insert(self.btn_window, -1)
+        self.toolbar_aux.insert(self.btn_area, -1)
+        #self.toolbar_aux.insert(self.sep_2, -1)
+
+        self.ntb_main.set_current_page(0)
+
+        #
+        # Take care of screen size changes.
+        #
+        self.default_screen = Gdk.Screen.get_default()
+        self.default_screen.connect("size-changed", self.cb_screen_size_changed)
+        self.window.connect("configure-event", self.cb_configure_event)
+
+        # Fetch sources info, take care of all the widgets and saved settings and show main window
+        if prefs.sound:
+            prefs.get_audio_sources()
+
+        if not prefs.silent:
+            self.window.show_all()
+        else:
+            logger.info("""Starting in silent mode:\n"""
+                        """  SUPER-CTRL-W to toggle main window.\n"""
+                        """  SUPER-CTRL-R to start recording.\n"""
+                        """  SUPER-CTRL-F to finish recording.\n"""
+                        """  SUPER-CTRL-P to pause/resume recording.\n"""
+                        """  SUPER-CTRL-Q to quit.\n"""
+                       )
+
+        self.restore_UI()
+
+        if not prefs.sound:
+            self.combobox_audio.set_sensitive(False)
+            self.combobox_audio2.set_sensitive(False)
+            self.volumebutton_audio.set_sensitive(False)
+            self.volumebutton_audio2.set_sensitive(False)
+
+        HW.get_current_screen(self.window)
+        self.startup = False
+
+    #
+    # Callbacks, go down here ...
+    #
+
+    #
+    # Mode of operation toggles
+    #
+
+    def cb_main_toggled(self, widget):
+        name = widget.get_name()
+        if name == "MAIN_SCREENCAST" and widget.get_active():
+            logger.debug("Main toggled: {0}".format(name))
+            self.main_mode = MODE_SCREENCAST
+            self.ntb_main.set_current_page(0)
+            self.indicator.menuitem_start.set_label(_("Start recording"))
+
+        elif name == "MAIN_SCREENSHOT" and widget.get_active():
+            logger.debug("Main toggled: {0}".format(name))
+            self.main_mode = MODE_SCREENSHOT
+            self.ntb_main.set_current_page(1)
+            if self.record_mode == MODE_WIN:
+                self.last_mode.set_active(True)
+            self.indicator.menuitem_start.set_label(_("Take screenshot"))
+
+    #
+    # Record mode toggles
+    #
+    def cb_record_mode_toggled(self, widget):
+        if widget.get_active():
+            self.current_mode = widget
+        else:
+            self.last_mode = widget
+
+        if widget.get_name() == "MODE_AREA" and widget.get_active():
+            logger.debug("Area ON.")
+            self.area_window = AreaWindow()
+            self.tmp_sig1 = self.area_window.connect("area-selected", self.cb_area_selected)
+            self.tmp_sig2 = self.area_window.connect("area-canceled", self.cb_area_canceled)
+            self.record_mode = MODE_AREA
+
+        if widget.get_name() == "MODE_AREA" and not widget.get_active():
+            logger.debug("Area OFF.")
+            if self.area_window:
+                self.area_window.disconnect(self.tmp_sig1)
+                self.area_window.disconnect(self.tmp_sig2)
+                self.area_window.window.destroy()
+                self.area_window = None
+
+        if widget.get_name() == "MODE_FULL" and widget.get_active():
+            logger.debug("Capture full screen.")
+            self.record_mode = MODE_FULL
+
+        if widget.get_name() == "MODE_ALL" and widget.get_active():
+            logger.debug("Capture all screens.")
+            self.record_mode = MODE_ALL
+
+        if widget.get_name() == "MODE_WIN" and widget.get_active():
+            logger.debug("Window capture ON.")
+            self.select_window = SelectWindow()
+            self.tmp_sig3 = self.select_window.connect("window-selected", self.cb_window_selected)
+            self.tmp_sig4 = self.select_window.connect("window-canceled", self.cb_window_canceled)
+            self.record_mode = MODE_WIN
+
+        if widget.get_name() == "MODE_WIN" and not widget.get_active():
+            logger.debug("Window capture OFF.")
+            if self.select_window:
+                self.select_window.disconnect(self.tmp_sig3)
+                self.select_window.disconnect(self.tmp_sig4)
+                self.select_window.window.destroy()
+                self.select_window = None
+
+
+    #
+    # Unity quick list callbacks
+    #
+
+    def cb_ql_screencast(self, menu, data):
+        logger.debug("Screencast quicklist activated.")
+        self.btn_cast.set_active(True)
+        self.run_counter()
+
+    def cb_ql_screenshot(self, menu, data):
+        logger.debug("Screenshot quicklist activated.")
+        self.btn_shot.set_active(True)
+        self.run_counter()
+
+    def cb_ql_preferences(self, menu, data):
+        logger.debug("Preferences quicklist activated.")
+        self.cb_preferences_request(None)
+
+    def cb_record_area_clicked(self, widget):
+        if self.area_window:
+            logger.debug("Area mode clicked.")
+            self.area_window.window.show_all()
+            self.window.set_sensitive(False)
+
+    def cb_record_window_clicked(self, widget):
+        if self.select_window:
+            logger.debug("Window mode clicked.")
+            self.select_window.window.show_all()
+            self.window.set_sensitive(False)
+
+    def cb_area_selected(self, widget):
+        logger.debug("Area selected: SX: {0}, SY: {1}, EX: {2}, EY: {3}".format(
+            self.area_window.startx,
+            self.area_window.starty,
+            self.area_window.endx,
+            self.area_window.endy))
+        self.window.set_sensitive(True)
+        prefs.area = (self.area_window.startx,
+                     self.area_window.starty,
+                     self.area_window.endx,
+                     self.area_window.endy,
+                     self.area_window.width,
+                     self.area_window.height)
+
+    def cb_area_canceled(self, widget):
+        logger.debug("Area selection canceled.")
+        self.window.set_sensitive(True)
+        self.last_mode.set_active(True)
+
+    def cb_window_selected(self, widget):
+        prefs.xid = self.select_window.xid
+        prefs.xid_geometry = self.select_window.geometry
+        logger.debug("Window selected: {0} - {1}".format(self.select_window.win_name, prefs.xid))
+        logger.debug("Window geometry: {0}".format(self.select_window.geometry))
+        self.window.set_sensitive(True)
+
+    def cb_window_canceled(self, widget):
+        logger.debug("Window selection canceled.")
+        self.window.set_sensitive(True)
+        self.last_mode.set_active(True)
+
+    def cb_screen_size_changed(self, screen):
+        logger.debug("Screen size changed.")
+        HW.get_screens()
+        #
+        # I combined screen was set to none, turn off the button for all screens
+        #
+        if HW.combined_screen:
+            self.btn_allscreens.set_sensitive(True)
+        else:
+            self.btn_allscreens.set_sensitive(False)
+
+
+    def cb_configure_event(self, widget, event):
+        if event.type == Gdk.EventType.CONFIGURE:
+            prefs.main_x = event.x
+            prefs.main_y = event.y
+
+    def cb_quit_request(self, indicator):
+        logger.debug("Quit requested.")
+        (prefs.main_x, prefs.main_y) = self.window.get_position()
+        try:
+            os.remove(self.recorder.tempfile)
+            os.remove("{0}.mux".format(self.recorder.tempfile))
+        except OSError:
+            logger.info("Unable to delete one of the temporary files. Check your temporary directory.")
+        except AttributeError:
+            pass
+
+        prefs.save_config()
+
+        if prefs.sound:
+            prefs.pa_q.end()
+
+        Gtk.main_quit()
+
+    def cb_preferences_request(self, indicator):
+        logger.debug("Preferences requested.")
+        self.preferences_window = Preferences()
+        self.preferences_window.open()
+
+    def cb_show_request(self, indicator):
+        if not self.window.get_property("visible"):
+            logger.debug("Show requested, raising window.")
+            self.window.show_all()
+            self.window.present()
+            self.window.move(prefs.main_x, prefs.main_y)
+        else:
+            self.window.hide()
+
+    def cb_close_clicked(self, indicator):
+        (prefs.main_x, prefs.main_y) = self.window.get_position()
+        self.window.hide()
+
+    def cb_about_request(self, activated):
+        AboutDialog(self.icons)
+
+    def cb_delete_event(self, widget, user_data):
+        self.cb_quit_request(None)
+
+    def cb_start_request(self, widget):
+        logger.debug("Start recording selected.")
+        self.run_counter()
+
+    def cb_record_clicked(self, widget):
+        logger.debug("Record clicked, invoking Screencast.")
+        self.run_counter()
+
+    def cb_counter_finished(self, widget):
+        logger.debug("Counter finished.")
+        self.in_countdown = False
+        self.countdown = None
+        self.indicator.blink_set_state(BLINK_STOP)
+        if self.main_mode == MODE_SCREENCAST:
+            self.indicator.menuitem_finish.set_label(_("Finish recording"))
+            self.indicator.menuitem_pause.set_sensitive(True)
+            self.indicator.start_recording()
+            self.recorder.start_recording()
+        elif self.main_mode == MODE_SCREENSHOT:
+            self.indicator.hide_it()
+            self.grabber.grab()
+            self.indicator.show_it()
+
+    def cb_stop_request(self, widget):
+        self.recording = False
+        if self.in_countdown:
+            logger.debug("Cancel countdown request.")
+            self.countdown.cancel_countdown()
+            self.countdown = None
+            self.indicator.menuitem_finish.set_label(_("Finish recording"))
+            self.window.set_sensitive(True)
+            self.window.show()
+            self.window.present()
+        else:
+            if self.recording_paused:
+                self.recorder.unpause_recording()
+            logger.debug("Stop request.")
+            self.recorder.stop_recording()
+            self.tempfile = self.recorder.get_tempfile()
+            logger.debug("Recorded tmp file: {0}".format(self.tempfile))
+            logger.debug("Waiting for data to flush.")
+
+    def cb_flush_done(self, widget):
+        if self.main_mode == MODE_SCREENCAST and prefs.autosave_video:
+            logger.debug("Autosaving enabled.")
+            fname = get_next_filename(prefs.video_dest,
+                                      prefs.autosave_video_file,
+                                      CODEC_LIST[prefs.codec][3])
+
+            shutil.move(self.tempfile, fname)
+
+            self.window.set_sensitive(True)
+            self.window.show()
+            self.window.present()
+        elif self.main_mode == MODE_SCREENCAST:
+            self.done_recording = DoneRecording(self.icons,
+                                            self.tempfile,
+                                            prefs.codec,
+                                            self.old_vid_path)
+            logger.debug("Done Recording initialized.")
+            self.done_recording.connect("save-done", self.cb_save_done)
+            self.done_recording.connect("save-cancel", self.cb_save_cancel)
+            self.done_recording.connect("edit-request", self.cb_edit_request)
+            logger.debug("Done recording signals connected.")
+            self.done_recording.show_all()
+            self.window.set_sensitive(False)
+
+        elif self.main_mode == MODE_SCREENSHOT:
+            self.grabber.connect("save-done", self.cb_save_done)
+            self.indicator.recording = False
+            self.indicator.menuitem_start.set_sensitive(True)
+            self.indicator.menuitem_pause.set_sensitive(False)
+            self.indicator.menuitem_pause.set_active(False)
+            self.indicator.menuitem_finish.set_sensitive(False)
+            self.indicator.menuitem_show.set_sensitive(True)
+            self.indicator.menuitem_quit.set_sensitive(True)
+
+            if prefs.autosave_picture:
+                fname = get_next_filename(prefs.picture_dest, prefs.autosave_picture_file, ".png")
+                self.grabber.autosave(fname)
+            else:
+                self.grabber.save_capture(self.old_pic_path)
+
+
+    def cb_pause_request(self, widget):
+        logger.debug("Pause requested.")
+        self.recording_paused = True
+        self.recorder.pause_recording()
+
+    def cb_unpause_request(self, widget):
+        logger.debug("Unpause requested.")
+        self.recording_paused = False
+        self.recorder.unpause_recording()
+
+    def cb_save_done(self, widget, result):
+        logger.debug("Save Done, result: {0}".format(result))
+        if self.main_mode == MODE_SCREENCAST:
+            self.old_vid_path = result
+        else:
+            self.old_pic_path = result
+
+        self.window.set_sensitive(True)
+        self.window.show_all()
+        self.window.present()
+        self.window.move(prefs.main_x, prefs.main_y)
+
+    def cb_save_cancel(self, widget):
+        try:
+            logger.debug("Save canceled, removing {0}".format(self.tempfile))
+            os.remove(self.tempfile)
+        except OSError:
+            logger.info("Failed to remove tempfile {0}".format(self.tempfile))
+        except AttributeError:
+            logger.info("Failed to remove tempfile {0}".format(self.tempfile))
+            pass
+
+        self.window.set_sensitive(True)
+        self.window.show_all()
+        self.window.present()
+        self.window.move(prefs.main_x, prefs.main_y)
+
+    def cb_help_about(self, widget):
+        AboutDialog(self.icons)
+
+    def cb_edit_request(self, widget, data):
+        (command, arg_list) = data
+        arg_list.insert(0, command)
+        #
+        # Even if we're not autosaving get the next autosave file and move currently recorded file there
+        # In case user might lost it.
+        #
+        fname = get_next_filename(prefs.video_dest,
+                                  prefs.autosave_video_file,
+                                  CODEC_LIST[prefs.codec][3])
+
+        shutil.move(self.tempfile, fname)
+        arg_list.append(fname)
+        logger.debug("Edit request, cmd: {0}".format(arg_list))
+        try:
+            Popen(arg_list)
+        except:
+            logger.warning("Failed to open selected editor. Have no ")
+        self.window.set_sensitive(True)
+        self.window.show_all()
+
+    def cb_check_cursor(self, widget):
+        prefs.capture_cursor = widget.get_active()
+        logger.debug("Capture cursor: {0}.".format(prefs.capture_cursor))
+
+    def cb_check_cursor_pic(self, widget):
+        prefs.capture_cursor_pic = widget.get_active()
+        logger.debug("Capture cursor_pic: {0}.".format(prefs.capture_cursor_pic))
+
+    def cb_check_borders_pic(self, widget):
+        prefs.capture_borders_pic = widget.get_active()
+        logger.debug("Capture borders_pic: {0}.".format(prefs.capture_borders_pic))
+
+    def cb_check_speakers(self, widget):
+        prefs.capture_speakers = widget.get_active()
+        logger.debug("Capture speakers: {0}.".format(prefs.capture_speakers))
+
+    def cb_check_microphone(self, widget):
+        prefs.capture_microphone = widget.get_active()
+        logger.debug("Capture microphone: {0}.".format(prefs.capture_microphone))
+
+    def cb_spinbutton_delay_change(self, widget):
+        prefs.countdown_timer = widget.get_value_as_int()
+        logger.debug("Start delay now: {0}".format(prefs.countdown_timer))
+
+    #
+    # Other somewhat useful stuff ...
+    #
+
+    def run_counter(self):
+        #
+        # Annoyances with the menus
+        #
+        (main_x, main_y) = self.window.get_position()
+        if main_x and main_y:
+            prefs.main_x = main_x
+            prefs.main_y = main_y
+
+        self.indicator.recording = True
+        self.indicator.menuitem_start.set_sensitive(False)
+        self.indicator.menuitem_pause.set_sensitive(False)
+        self.indicator.menuitem_finish.set_sensitive(True)
+        self.indicator.menuitem_show.set_sensitive(False)
+        self.indicator.menuitem_quit.set_sensitive(False)
+        self.indicator.menuitem_finish.set_label(_("Cancel countdown"))
+        self.in_countdown = True
+
+        self.indicator.blink_set_state(BLINK_START)
+
+        if self.main_mode == MODE_SCREENCAST and prefs.sound:
+            if prefs.capture_speakers and prefs.audio_source > 0:
+                audio_source = prefs.audio_sources[prefs.audio_source][1]
+            else:
+                audio_source = None
+
+            if prefs.capture_microphone and prefs.audio2_source > 0:
+                audio2_source = prefs.audio_sources[prefs.audio2_source][1]
+            else:
+                audio2_source = None
+        else:
+            audio_source = None
+            audio2_source = None
+
+        #
+        # Get appropriate coordinates for recording
+        #
+
+        video_source = None
+
+        if self.record_mode == MODE_FULL:
+            screen = HW.get_current_screen(self.window)
+            video_source = HW.screens[screen]
+        else:
+            video_source = HW.combined_screen
+
+        if self.main_mode == MODE_SCREENCAST:
+            self.recorder = Screencast()
+            self.recorder.setup_sources(video_source,
+                                        audio_source,
+                                        audio2_source,
+                                        prefs.area if self.record_mode == MODE_AREA else None,
+                                        prefs.xid if self.record_mode == MODE_WIN else None)
+
+            self.recorder.connect("flush-done", self.cb_flush_done)
+
+        elif self.main_mode == MODE_SCREENSHOT:
+            self.grabber = Grabber()
+            self.grabber.setup_sources(video_source,
+                                       prefs.area if self.record_mode == MODE_AREA else None,
+                                       prefs.xid if self.record_mode == MODE_WIN else None)
+            self.grabber.connect("flush-done", self.cb_flush_done)
+
+
+        self.countdown = CountdownWindow(self.indicator, show_window = prefs.countdown_splash)
+        self.countdown.connect("counter-finished", self.cb_counter_finished)
+        self.countdown.run(prefs.countdown_timer)
+        self.recording = True
+        logger.debug("Hiding main window.")
+        self.window.hide()
+
+    def setup_translations(self):
+        gettext.bindtextdomain("kazam", "/usr/share/locale")
+        gettext.textdomain("kazam")
+        try:
+            locale.setlocale(locale.LC_ALL, "")
+        except Exception as e:
+            logger.exception("EXCEPTION: Setlocale failed, no language support.")
+
+
+    def restore_UI (self):
+        self.window.move(prefs.main_x, prefs.main_y)
+        self.chk_cursor.set_active(prefs.capture_cursor)
+        self.chk_speakers.set_active(prefs.capture_speakers)
+        self.chk_microphone.set_active(prefs.capture_microphone)
+        self.chk_cursor_pic.set_active(prefs.capture_cursor_pic)
+        self.chk_borders_pic.set_active(prefs.capture_borders_pic)
+        self.spinbutton_delay.set_value(prefs.countdown_timer)
+
+        #
+        # Turn off the combined screen icon if we don't have more than one screen.
+        #
+        if HW.combined_screen:
+            self.btn_allscreens.set_sensitive(True)
+        else:
+            self.btn_allscreens.set_sensitive(False)

=== added directory 'build/lib.linux-x86_64-2.7/kazam/backend'
=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/__init__.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/__init__.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/__init__.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,1 @@
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/config.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/config.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/config.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+#
+#       config.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+from ConfigParser import SafeConfigParser, NoSectionError, NoOptionError
+from xdg.BaseDirectory import xdg_config_home
+
+class KazamConfig(SafeConfigParser):
+
+    DEFAULTS = [{
+                "name": "main",
+                "keys": {
+                         "video_toggled"          : "True",
+                         "video_source"           : "0",
+                         "audio_toggled"          : "False",
+                         "audio_source"           : "0",
+                         "audio_volume"           : "0",
+                         "audio2_toggled"         : "False",
+                         "audio2_source"          : "0",
+                         "audio2_volume"          : "0",
+                         "codec"                  : "0",
+                         "counter"                : "5",
+                         "capture_cursor"         : "True",
+                         "capture_microphone"     : "False",
+                         "capture_speakers"       : "False",
+                         "capture_cursor_pic"     : "True",
+                         "capture_borders_pic"    : "True",
+                         "framerate"              : "15",
+                         "countdown_splash"       : "True",
+                         "last_x"                 : "60",
+                         "last_y"                 : "25",
+                         "advanced"               : "0",
+                         "silent"                 : "0",
+                         "autosave_video"         : "False",
+                         "autosave_video_dir"     : "",
+                         "autosave_video_file"    : "Kazam_screencast",
+                         "autosave_picture"       : "False",
+                         "autosave_picture_dir"   : "",
+                         "autosave_picture_file"  : "Kazam_screenshot",
+                         "shutter_sound"          : "True",
+                         "shutter_type"           : "0",
+                         },
+                },
+                {
+                 "name": "keyboard_shortcuts",
+                 "keys": {
+                          "pause":  "<Shift><Control>p",
+                          "finish": "<Shift><Control>f",
+                          "show":   "<Shift><Control>s",
+                          "quit":   "<Shift><Control>q",
+                         },
+                 }]
+
+    CONFIGDIR = os.path.join(xdg_config_home, "kazam")
+    CONFIGFILE = os.path.join(CONFIGDIR, "kazam.conf")
+
+    def __init__(self):
+        SafeConfigParser.__init__(self, self.DEFAULTS[0]['keys'])
+        if not os.path.isdir(self.CONFIGDIR):
+            os.makedirs(self.CONFIGDIR)
+        if not os.path.isfile(self.CONFIGFILE):
+            self.create_default()
+            self.write()
+        self.read(self.CONFIGFILE)
+
+    def create_default(self):
+        # For every section
+        for section in self.DEFAULTS:
+            # Add the section
+            self.add_section(section["name"])
+            # And add every key in it, with its default value
+            for key in section["keys"]:
+                value = section["keys"][key]
+                self.set(section["name"], key, value)
+
+    def find_default(self, section, key):
+        for d_section in self.DEFAULTS:
+            if d_section["name"] == section:
+                for d_key in d_section["keys"]:
+                    if d_key == key:
+                        return d_section["keys"][key]
+
+    def get(self, section, key):
+        try:
+            return SafeConfigParser.get(self, section, key)
+        except NoSectionError:
+            default = self.find_default(section, key)
+            self.set(section, key, default)
+            self.write()
+            return default
+        except NoOptionError:
+            default = self.find_default(section, key)
+            self.set(section, key, default)
+            self.write()
+            return default
+
+    def set(self, section, option, value):
+        # If the section referred to doesn't exist (rare case),
+        # then create it
+        if not self.has_section(section):
+            self.add_section(section)
+        SafeConfigParser.set(self, section, option, str(value))
+
+    def write(self):
+        file_ = open(self.CONFIGFILE, "w")
+        SafeConfigParser.write(self, file_)
+        file_.close()
+
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/constants.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/constants.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/constants.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+#
+#       constants.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+
+# Codecs
+
+CODEC_RAW = 0
+CODEC_VP8 = 1
+CODEC_H264 = 2
+CODEC_HUFF = 3
+CODEC_JPEG = 4
+
+#
+# Number, gstreamer element name, string description, file extension, advanced
+#
+
+CODEC_LIST = [
+              [0, None, 'RAW / AVI', '.avi', True],
+              [1, 'vp8enc', 'VP8 / WEBM', '.webm', False],
+              [2, 'x264enc', 'H264 / MP4', '.mp4', False],
+              [3, 'ffenc_huffyuv', 'HUFFYUV / AVI', '.avi', True],
+              [4, 'ffenc_ljpeg', 'Lossless JPEG / AVI', '.avi', True],
+             ]
+
+# PulseAudio Error Codes
+PA_LOAD_ERROR = 1
+PA_GET_STATE_ERROR = 2
+PA_STARTUP_ERROR = 3
+PA_UNABLE_TO_CONNECT = 4
+PA_UNABLE_TO_CONNECT2 = 5
+PA_MAINLOOP_START_ERROR = 6
+PA_GET_SOURCES_ERROR = 7
+PA_GET_SOURCES_TIMEOUT = 8
+PA_GET_SOURCE_ERROR = 9
+PA_GET_SOURCE_TIMEOUT = 10
+PA_MAINLOOP_END_ERROR = 11
+
+
+# PulseAudio Status Codes
+PA_STOPPED = 0
+PA_WORKING = 1
+PA_FINISHED = 2
+PA_ERROR = 3
+
+# PulseAudio State Codes
+PA_STATE_READY = 0
+PA_STATE_BUSY = 1
+PA_STATE_FAILED = 2
+PA_STATE_WORKING = 3
+
+
+# Various actions
+ACTION_SAVE = 0
+ACTION_EDIT = 1
+
+# Blink modes and states
+BLINK_STOP = 0
+BLINK_START = 1
+BLINK_SLOW = 2
+BLINK_FAST = 3
+BLINK_STOP_ICON = 4
+BLINK_READY_ICON = 5
+
+# Main modes
+MODE_SCREENCAST = 0
+MODE_SCREENSHOT = 1
+
+# Record modes
+MODE_FULL = 0
+MODE_ALL = 1
+MODE_AREA = 2
+MODE_WIN = 3
+MODE_ACTIVE = 4
+MODE_GOD = 666
+
+import logging
+
+from gi.repository import Gdk, GdkX11
+
+class hw:
+    def __init__(self):
+        self.logger = logging.getLogger("Constants")
+        self.logger.debug("Getting hardware specs")
+        self.screens = None
+        self.combined_screen = None
+
+        self.get_screens()
+
+    def get_current_screen(self, window = None):
+        try:
+            if window:
+                screen = self.default_screen.get_monitor_at_window(window.get_window())
+            else:
+                disp = GdkX11.X11Display.get_default()
+                dm = Gdk.Display.get_device_manager(disp)
+                pntr_device = dm.get_client_pointer()
+                (src, x, y) = pntr_device.get_position()
+                screen = self.default_screen.get_monitor_at_point(x, y)
+        except:
+           screen = 0
+        return screen
+
+    def get_screens(self):
+        try:
+            self.logger.debug("Getting Video sources.")
+            self.screens = []
+            self.default_screen = Gdk.Screen.get_default()
+            self.logger.debug("Found {0} monitors.".format(self.default_screen.get_n_monitors()))
+
+            for i in range(self.default_screen.get_n_monitors()):
+                rect = self.default_screen.get_monitor_geometry(i)
+                self.logger.debug("  Monitor {0} - X: {1}, Y: {2}, W: {3}, H: {4}".format(i,
+                                                                                     rect.x,
+                                                                                     rect.y,
+                                                                                     rect.width,
+                                                                                     rect.height))
+                self.screens.append({"x": rect.x,
+                                     "y": rect.y,
+                                     "width": rect.width,
+                                      "height": rect.height})
+
+            if self.default_screen.get_n_monitors() > 1:
+                self.combined_screen = {"x": 0, "y": 0,
+                                       "width": self.default_screen.get_width(),
+                                       "height": self.default_screen.get_height()}
+                self.logger.debug("  Combined screen - X: 0, Y: 0, W: {0}, H: {1}".format(self.default_screen.get_width(),
+                                                                                          self.default_screen.get_height()))
+            else:
+                self.combined_screen = None
+
+        except:
+            self.logger.warning("Unable to find any video sources.")
+
+HW = hw()

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/export.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/export.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/export.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+#
+#       export_backend.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+
+from gi.repository import GObject
+
+import kazam.backend.export_sources
+from kazam.utils import *
+
+class ExportBackend(GObject.GObject):
+
+    __gsignals__ = {
+    "authenticate-requested"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ([GObject.TYPE_PYOBJECT,
+                                GObject.TYPE_PYOBJECT,
+                                GObject.TYPE_PYOBJECT]),),
+    "login-started"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ( ),),
+    "login-completed"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ([bool]),),
+    "convert-started"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ( ),),
+    "convert-completed"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ([bool]),),
+    "upload-started"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ( ),),
+    "upload-completed"     : (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           ([bool, str]),),
+    }
+
+    def __init__(self, frontend, datadir):
+        super(ExportBackend, self).__init__()
+
+        self.frontend = frontend
+        self.frontend.connect("export-requested", self.cb_export_requested)
+
+        self.datadir = datadir
+        self.active_export_object = None
+
+        self.error = False
+
+        export_module_files = self._get_export_module_files()
+        self.export_objects = self._create_export_objects(export_module_files)
+
+    def _get_export_module_files(self):
+        """
+        Returns a list of export source files
+        """
+        export_module_list = []
+        # For each directory that provides kazam.export_sources
+        for path in kazam.backend.export_sources.__path__:
+            directory = os.path.abspath(path)
+            # List files in that directory
+            for f in os.listdir(directory):
+                # If the file is a python file append the file to our list
+                if f[-3:] == ".py":
+                    export_module_list.append(f)
+
+        # Remove __init__.py and any duplicates
+        export_module_list.remove("__init__.py")
+        export_module_list = remove_list_dups(export_module_list)
+
+        return export_module_list
+
+    def _import_export_module(self, name):
+        """
+        Import an export_source module and return the module
+        """
+        return getattr(__import__("kazam.backend.export_sources", globals(),
+                                    locals(), [name], -1), name)
+
+    def _create_export_objects(self, export_module_files):
+        """
+        Return a list of export objects
+        """
+        export_objects = []
+        for f in export_module_files:
+            f = f[:-3]
+            # Find and import the module for each file
+            module = self._import_export_module(f)
+            # Append an instance of it, to our export_objects list
+            upload_source = module.UploadSource()
+            upload_source.gui_extra(self.datadir)
+            export_objects.append(upload_source)
+        return export_objects
+
+    def get_export_objects(self):
+        return self.export_objects
+
+    def set_active_export_object(self, i):
+        self.active_export_object = self.export_objects[i]
+        return self.active_export_object
+
+    def get_active_export_object(self):
+        return self.active_export_object
+
+    def get_export_meta(self):
+        return self.export_object.META
+
+    def cb_export_requested(self, frontend):
+        self.error = False
+        self.login()
+        if not self.error:
+            self.create_meta()
+        if not self.error:
+            self.convert()
+        if not self.error:
+            self.upload()
+
+    def login(self):
+        if self.active_export_object.authentication == True:
+            self.emit("authenticate-requested",
+                        self.active_export_object.ICONS,
+                        self.active_export_object.NAME,
+                        self.active_export_object.REGISTER_URL)
+        else:
+            self.details = (None, None)
+        if hasattr(self, "details"):
+            try:
+                self.emit("login-started")
+                (username, password) = self.details
+                self.active_export_object.login_pre(username, password)
+                create_wait_thread(self.active_export_object.login_in)
+                self.active_export_object.login_post()
+                success = True
+            except Exception, e:
+                print e
+                self.error = True
+                success = False
+        else:
+            success = False
+            self.error = True
+        self.emit("login-completed", success)
+
+    def create_meta(self):
+        self.active_export_object.create_meta(**self.frontend.get_meta())
+
+    def convert(self):
+        self.emit("convert-started")
+        try:
+            screencast = self.frontend.get_screencast()
+            screencast.convert(self.active_export_object.FFMPEG_OPTIONS,
+                    self.active_export_object.FFMPEG_FILE_EXTENSION,
+                    self.frontend.get_video_quality(),
+                    self.frontend.get_audio_quality())
+            while not hasattr(screencast, "converted_file"):
+                gtk.main_iteration()
+            self.converted_file_path = screencast.converted_file
+            self.emit("convert-completed", True)
+        except Exception, e:
+            print e
+            self.error = True
+            self.emit("convert-completed", False)
+
+    def upload(self):
+        self.emit("upload-started")
+        url = ""
+        try:
+            self.active_export_object.upload_pre()
+            create_wait_thread(self.active_export_object.upload_in, (self.converted_file_path,))
+            url = self.active_export_object.upload_post()
+            success = True
+        except Exception, e:
+            print e
+            self.error = True
+            success = False
+        self.emit("upload-completed", success, url)

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/ffmpeg.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/ffmpeg.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/ffmpeg.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#       recording.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+from subprocess import Popen
+import tempfile
+import os
+import gobject
+import glib
+import signal
+
+class Screencast(object):
+    def __init__(self):
+        self.tempfile = tempfile.mktemp(prefix="kazam_", suffix=".mkv")
+
+    def setup_sources(self, video_source, audio_source):
+        self.audio_source = audio_source
+        self.video_source = video_source
+
+        # TODO: use gstreamer instead (see gstreamer.py for start)
+        self.args_list = ["ffmpeg"]
+
+        # Add the audio source if selected
+        if audio_source:
+            self.args_list += ["-f", "alsa", "-i", "pulse"]
+
+        # Add the video source
+        if video_source:
+            x = video_source.x
+            y = video_source.y
+            width = video_source.width
+            height = video_source.height
+            display = video_source.display
+            self.args_list += ["-f", "x11grab", "-r", "30", "-s",
+                        "%sx%s" % (width, height), "-i",
+                        "%s+%s,%s" % (display, x, y)]
+        if audio_source:
+            self.args_list += ["-ac", "2", "-acodec", "flac", "-ab", "128k"]
+
+        if video_source:
+            self.args_list += ["-vcodec", "libx264",
+                               "-crf", "0",
+                               "-preset", "fast",
+                               "-tune", "stillimage",
+                               "-vf", "unsharp=3:3:0.5:3:3:0.0"
+
+                              ]
+        self.args_list += ["-threads", "0", self.tempfile]
+
+        arg_string = ""
+        for arg in self.args_list:
+            arg_string += " %s" % arg
+        print arg_string
+
+    def start_recording(self):
+        self.recording_command = Popen(self.args_list)
+
+    def pause_recording(self):
+        self.recording_command.send_signal(signal.SIGTSTP)
+
+    def unpause_recording(self):
+        self.recording_command.send_signal(signal.SIGCONT)
+
+    def stop_recording(self):
+        self.recording_command.send_signal(signal.SIGINT)
+
+    def get_recording_filename(self):
+        return self.tempfile
+
+    def get_audio_recorded(self):
+        return self.audio_source
+
+    def get_video_recorded(self):
+        return self.video_source
+
+    def convert(self, options, converted_file_extension, video_quality=None,
+                    audio_quality=None):
+
+        self.converted_file_extension = converted_file_extension
+
+        # Create our ffmpeg arguments list
+        args_list = ["ffmpeg"]
+        # Add the input file
+        args_list += ["-i", self.tempfile]
+        # Add any UploadSource specific options
+        args_list += options
+
+        # Configure the quality as selected by the user
+        # If the quality slider circle is at the right-most position
+        # use the same quality option
+        if video_quality == 6001:
+            args_list += ["-sameq"]
+        elif video_quality:
+            args_list += ["-b", "%sk" % video_quality]
+        if audio_quality:
+            args_list += ["-ab", "%sk" % audio_quality]
+        # Finally add the desired output file
+        args_list += ["%s%s" %(self.tempfile[:-4], converted_file_extension)]
+
+        # Run the ffmpeg command and when it is done, set a variable to
+        # show we have finished
+        command = Popen(args_list)
+        glib.timeout_add(100, self._poll, command)
+
+    def _poll(self, command):
+        ret = command.poll()
+        if ret is None:
+            # Keep monitoring
+            return True
+        else:
+            self.converted_file = "%s%s" %(self.tempfile[:-4], self.converted_file_extension)
+            return False
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/grabber.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/grabber.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/grabber.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+#
+#       grabber.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+
+import os
+import subprocess
+import logging
+logger = logging.getLogger("Grabber")
+
+from gi.repository import GObject, Gtk, Gdk, GdkPixbuf, GdkX11
+
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+from kazam.frontend.save_dialog import SaveDialog
+from gettext import gettext as _
+
+class Grabber(GObject.GObject):
+    __gsignals__ = {
+        "save-done"       : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                             [GObject.TYPE_PYOBJECT],),
+        "flush-done"      : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                             (),),
+        }
+
+    def __init__(self):
+        GObject.GObject.__init__(self)
+        logger.debug("Starting Grabber.")
+
+
+    def setup_sources(self, video_source, area, xid, active = False, god = False):
+        self.video_source = video_source
+        self.area = area
+        self.xid = xid
+        self.god = god
+        if active:
+            from gi.repository import GdkX11
+            active_win = HW.default_screen.get_active_window()
+            self.xid = GdkX11.X11Window.get_xid(active_win)
+
+        logger.debug("Grabber source: {0}, {1}, {2}, {3}".format(self.video_source['x'],
+                                                                 self.video_source['y'],
+                                                                 self.video_source['width'],
+                                                                 self.video_source['height']))
+
+    def grab(self):
+        self.pixbuf = None
+        disp = GdkX11.X11Display.get_default()
+        dm = Gdk.Display.get_device_manager(disp)
+        pntr_device = dm.get_client_pointer()
+
+        #
+        # Rewrite this, because it sucks
+        #
+        if prefs.shutter_sound and (not self.god):
+            soundfile = os.path.join(prefs.datadir, 'sounds', prefs.sound_files[prefs.shutter_type])
+            subprocess.call(['/usr/bin/canberra-gtk-play', '-f', soundfile])
+
+        if self.xid:
+            if prefs.capture_borders_pic:
+                app_win = GdkX11.X11Window.foreign_new_for_display(disp, self.xid)
+                (rx, ry, rw, rh) = app_win.get_geometry()
+                area = app_win.get_frame_extents()
+                (fx, fy, fw, fh) = (area.x, area.y, area.width, area.height)
+                win = Gdk.get_default_root_window()
+                logger.debug("Coordinates RX {0} RY {1} RW {2} RH {3}".format(rx, ry, rw, rh))
+                logger.debug("Coordinates FX {0} FY {1} FW {2} FH {3}".format(fx, fy, fw, fh))
+                dx = fw - rw
+                dy = fh - rh
+                (x, y, w, h) = (fx, fy, fw, fh)
+                logger.debug("Coordinates delta: DX {0} DY {1}".format(dx, dy))
+            else:
+                win = GdkX11.X11Window.foreign_new_for_display(disp, self.xid)
+                (x, y, w, h) = win.get_geometry()
+        else:
+            win = Gdk.get_default_root_window()
+            (x, y, w, h) = (self.video_source['x'],
+                            self.video_source['y'],
+                            self.video_source['width'],
+                            self.video_source['height'])
+
+        logger.debug("Coordinates X {0} Y {1} W {2} H {3}".format(x, y, w, h))
+        self.pixbuf = Gdk.pixbuf_get_from_window(win, x, y, w, h)
+
+        if prefs.capture_cursor_pic:
+            logger.debug("Adding cursor.")
+
+            cursor = Gdk.Cursor.new_for_display(Gdk.Display.get_default(), Gdk.CursorType.LEFT_PTR)
+            c_picbuf = Gdk.Cursor.get_image(cursor)
+
+            if self.xid and prefs.capture_borders_pic:
+                pointer = app_win.get_device_position(pntr_device)
+                (px, py) = (pointer[1], pointer[2])
+                c_picbuf.composite(self.pixbuf, rx, ry, rw, rh,
+                                   px + dx - 6,
+                                   py + dy - 2,
+                                   1.0,
+                                   1.0,
+                                   GdkPixbuf.InterpType.BILINEAR,
+                                   255)
+            else:
+                pointer = win.get_device_position(pntr_device)
+                (px, py) = (pointer[1], pointer[2])
+                #
+                # Cursor is offseted by 6 pixels to the right and 2 down
+                #
+                c_picbuf.composite(self.pixbuf, x, y, w, h,
+                                   px - 6,
+                                   py - 2,
+                                   1.0,
+                                   1.0,
+                                   GdkPixbuf.InterpType.BILINEAR,
+                                   255)
+
+            logger.debug("Cursor coords: {0} {1}".format(px, py))
+
+        if self.area is not None:
+            logger.debug("Cropping image.")
+            self.area_buf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, self.area[4], self.area[5])
+            self.pixbuf.copy_area(self.area[0], self.area[1], self.area[4], self.area[5], self.area_buf, 0, 0)
+            self.pixbuf = None
+            self.pixbuf = self.area_buf
+
+        self.emit("flush-done")
+
+    def save(self, filename):
+        if self.pixbuf is not None:
+            self.pixbuf.savev(filename, "png", "", "")
+
+    def save_capture(self, old_path):
+        logger.debug("Saving screenshot.")
+        self.old_path = old_path
+        (dialog, result, self.old_path) = SaveDialog(_("Save capture"),
+                                                     self.old_path, None, main_mode=MODE_SCREENSHOT)
+
+        if result == Gtk.ResponseType.OK:
+            uri = os.path.join(dialog.get_current_folder(), dialog.get_filename())
+
+            self.save(uri)
+
+        dialog.destroy()
+        self.emit("save-done", self.old_path)
+
+    def autosave(self, filename):
+        logger.debug("Autosaving to: {0}".format(filename))
+        self.save(filename)
+        self.emit("save-done", filename)

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/gstreamer.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/gstreamer.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/gstreamer.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,416 @@
+# -*- coding: utf-8 -*-
+#
+#       gstreamer.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import logging
+logger = logging.getLogger("GStreamer-GI")
+
+import tempfile
+import multiprocessing
+
+#
+# This needs to be set before we load GStreamer modules!
+#
+os.environ["GST_DEBUG_DUMP_DOT_DIR"] = "/tmp"
+os.putenv("GST_DEBUG_DUMP_DOT_DIR", "/tmp")
+
+from gi.repository import GObject, Gst
+
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+
+GObject.threads_init()
+Gst.init(None)
+Gst.debug_set_active(True)
+
+class Screencast(GObject.GObject):
+    __gsignals__ = {
+        "flush-done" : (GObject.SIGNAL_RUN_LAST,
+                        None,
+                        (),
+            ),
+        }
+    def __init__(self):
+        GObject.GObject.__init__(self)
+
+        self.temp_fh = tempfile.mkstemp(prefix="kazam_", dir=prefs.video_dest, suffix=".movie")
+        self.tempfile = self.temp_fh[1]
+        self.muxer_tempfile = "{0}.mux".format(self.tempfile)
+        self.pipeline = Gst.Pipeline()
+        self.area = None
+        self.xid = None
+        self.crop_vid = False
+
+    def setup_sources(self,
+                      video_source,
+                      audio_source,
+                      audio2_source,
+                      area,
+                      xid):
+
+
+        # Get the number of cores available then use all except one for encoding
+        self.cores = multiprocessing.cpu_count()
+
+        if self.cores > 1:
+            self.cores -= 1
+
+        self.audio_source = audio_source
+        self.audio2_source = audio2_source
+        self.video_source = video_source
+        self.area = area
+        self.xid = xid
+
+        logger.debug("audio_source : {0}".format(audio_source))
+        logger.debug("video_source: {0}".format(video_source))
+        logger.debug("xid: {0}".format(xid))
+        logger.debug("area: {0}".format(area))
+
+        logger.debug("Capture Cursor: {0}".format(prefs.capture_cursor))
+        logger.debug("Framerate : {0}".format(prefs.framerate))
+        logger.debug("Codec: {0}".format(CODEC_LIST[prefs.codec][1]))
+
+        if self.video_source or self.area:
+            self.setup_video_source()
+
+        if self.audio_source:
+            self.setup_audio_source()
+
+        if self.audio2_source:
+            self.setup_audio2_source()
+
+        self.setup_filesink()
+        self.setup_pipeline()
+        self.setup_links()
+
+        self.bus = self.pipeline.get_bus()
+        self.bus.add_signal_watch()
+        self.bus.connect("message", self.on_message)
+
+    def setup_video_source(self):
+
+        if prefs.test:
+            self.videosrc = Gst.ElementFactory.make("videotestsrc", "video_src")
+            self.videosrc.set_property("pattern", "smpte")
+        else:
+            self.videosrc = Gst.ElementFactory.make("ximagesrc", "video_src")
+
+        if self.area:
+            logger.debug("Capturing area.")
+            startx = self.area[0] if self.area[0] > 0 else 0
+            starty = self.area[1] if self.area[1] > 0 else 0
+            endx = self.area[2]
+            endy = self.area[3]
+        else:
+            startx = self.video_source['x']
+            starty = self.video_source['y']
+            width = self.video_source['width']
+            height = self.video_source['height']
+            endx = startx + width - 1
+            endy = starty + height - 1
+
+        #
+        # H264 requirement is that video dimensions are divisible by 2.
+        # If they are not, we have to get rid of that extra pixel.
+        #
+        if not abs(startx - endx) % 2 and prefs.codec == CODEC_H264:
+            endx -= 1
+
+        if not abs(starty - endy) % 2 and prefs.codec == CODEC_H264:
+            endy -= 1
+
+        logger.debug("Coordinates SX: {0} SY: {1} EX: {2} EY: {3}".format(startx, starty, endx, endy))
+
+        if prefs.test:
+            logger.info("Using test signal instead of screen capture.")
+            self.vid_caps = Gst.caps_from_string("video/x-raw,format=(x-raw-rgb),framerate={0}/1, width={1}, height={2}".format(
+                  prefs.framerate,
+                  endx - startx,
+                  endy - starty))
+            self.vid_caps_filter = Gst.ElementFactory.make("capsfilter", "vid_filter")
+            self.vid_caps_filter.set_property("caps", self.vid_caps)
+        else:
+            logger.debug("testing for xid: {0}".format(self.xid))
+            if self.xid:   # xid was passed, so we have to capture a single window.
+                logger.debug("Capturing Window: {0} {1}".format(self.xid, prefs.xid_geometry))
+                self.videosrc.set_property("xid", self.xid)
+
+                if prefs.codec == CODEC_H264:
+                    self.videocrop = Gst.ElementFactory.make("videocrop", "cropper")
+                    if prefs.xid_geometry[2] % 2:
+                        self.videocrop.set_property("left", 1)
+                        self.crop_vid = True
+                    if prefs.xid_geometry[3] % 2:
+                        self.videocrop.set_property("bottom", 1)
+                        self.crop_vid = True
+            else:
+                self.videosrc.set_property("startx", startx)
+                self.videosrc.set_property("starty", starty)
+                self.videosrc.set_property("endx", endx)
+                self.videosrc.set_property("endy", endy)
+
+            self.videosrc.set_property("use-damage", False)
+            self.videosrc.set_property("show-pointer", prefs.capture_cursor)
+
+        self.vid_caps = Gst.caps_from_string("video/x-raw,format=(x-raw-rgb),framerate={0}/1".format(prefs.framerate))
+        self.vid_caps_filter = Gst.ElementFactory.make("capsfilter", "vid_filter")
+        self.vid_caps_filter.set_property("caps", self.vid_caps)
+
+        self.videoconvert = Gst.ElementFactory.make("videoconvert", "videoconvert")
+        self.videorate = Gst.ElementFactory.make("videorate", "video_rate")
+
+        logger.debug("Codec: {0}".format(CODEC_LIST[prefs.codec][2]))
+
+        if prefs.codec is not CODEC_RAW:
+            self.videnc = Gst.ElementFactory.make(CODEC_LIST[prefs.codec][1], "video_encoder")
+
+        if prefs.codec == CODEC_RAW:
+            self.mux = Gst.ElementFactory.make("avimux", "muxer")
+        elif prefs.codec == CODEC_VP8:
+            self.videnc.set_property("cpu-used", 2)
+            self.videnc.set_property("end-usage", "vbr")
+            self.videnc.set_property("target-bitrate", 800000000)
+            self.videnc.set_property("static-threshold", 1000)
+            self.videnc.set_property("token-partitions", 2)
+            self.videnc.set_property("max-quantizer", 30)
+            self.videnc.set_property("threads", self.cores)
+            self.mux = Gst.ElementFactory.make("webmmux", "muxer")
+        elif prefs.codec == CODEC_H264:
+            self.videnc.set_property("speed-preset", "ultrafast")
+            self.videnc.set_property("pass", 4)
+            self.videnc.set_property("quantizer", 15)
+            #
+            # x264enc supports maximum of four cores
+            #
+            self.videnc.set_property("threads", self.cores if self.cores <= 4 else 4)
+            self.mux = Gst.ElementFactory.make("mp4mux", "muxer")
+            self.mux.set_property("faststart", 1)
+            self.mux.set_property("faststart-file", self.muxer_tempfile)
+            self.mux.set_property("streamable", 1)
+        elif prefs.codec == CODEC_HUFF:
+            self.mux = Gst.ElementFactory.make("avimux", "muxer")
+            self.videnc.set_property("bitrate", 500000)
+        elif prefs.codec == CODEC_JPEG:
+            self.mux = Gst.ElementFactory.make("avimux", "muxer")
+
+        self.vid_in_queue = Gst.ElementFactory.make("queue", "queue_v1")
+        self.vid_out_queue = Gst.ElementFactory.make("queue", "queue_v2")
+
+    def setup_audio_source(self):
+        logger.debug("Audio1 Source:\n  {0}".format(self.audio_source))
+        self.audiosrc = Gst.ElementFactory.make("pulsesrc", "audio_src")
+        self.audiosrc.set_property("device", self.audio_source)
+        self.aud_caps = Gst.caps_from_string("audio/x-raw")
+        self.aud_caps_filter = Gst.ElementFactory.make("capsfilter", "aud_filter")
+        self.aud_caps_filter.set_property("caps", self.aud_caps)
+        self.audioconv = Gst.ElementFactory.make("audioconvert", "audio_conv")
+        if prefs.codec == CODEC_VP8:
+            self.audioenc = Gst.ElementFactory.make("vorbisenc", "audio_encoder")
+            self.audioenc.set_property("quality", 1)
+        else:
+            self.audioenc = Gst.ElementFactory.make("lamemp3enc", "audio_encoder")
+            self.audioenc.set_property("quality", 0)
+
+        self.aud_in_queue = Gst.ElementFactory.make("queue", "queue_a_in")
+        self.aud_out_queue = Gst.ElementFactory.make("queue", "queue_a_out")
+
+    def setup_audio2_source(self):
+        logger.debug("Audio2 Source:\n  {0}".format(self.audio2_source))
+        self.audiomixer = Gst.ElementFactory.make("adder", "audiomixer")
+        self.audio2src = Gst.ElementFactory.make("pulsesrc", "audio2_src")
+        self.audio2src.set_property("device", self.audio2_source)
+        self.aud2_caps = Gst.caps_from_string("audio/x-raw")
+        self.aud2_caps_filter = Gst.ElementFactory.make("capsfilter", "aud2_filter")
+        self.aud2_caps_filter.set_property("caps", self.aud2_caps)
+        self.aud2_in_queue = Gst.ElementFactory.make("queue", "queue_a2_in")
+        self.audio2conv = Gst.ElementFactory.make("audioconvert", "audio2_conv")
+
+    def setup_filesink(self):
+        logger.debug("Filesink: {0}".format(self.tempfile))
+        self.sink = Gst.ElementFactory.make("filesink", "sink")
+        self.sink.set_property("location", self.tempfile)
+        self.file_queue = Gst.ElementFactory.make("queue", "queue_file")
+
+    #
+    # One day, this horrific code will be optimised... I promise!
+    #
+    def setup_pipeline(self):
+        #
+        # Behold, setup the master pipeline
+        #
+        self.pipeline.add(self.videosrc)
+        self.pipeline.add(self.vid_in_queue)
+        if self.crop_vid:
+            self.pipeline.add(self.videocrop)
+        self.pipeline.add(self.videorate)
+        self.pipeline.add(self.vid_caps_filter)
+        self.pipeline.add(self.videoconvert)
+        self.pipeline.add(self.vid_out_queue)
+        self.pipeline.add(self.file_queue)
+
+        if prefs.codec is not CODEC_RAW:
+            self.pipeline.add(self.videnc)
+
+        if self.audio_source:
+            self.pipeline.add(self.audiosrc)
+            self.pipeline.add(self.aud_in_queue)
+            self.pipeline.add(self.aud_caps_filter)
+            self.pipeline.add(self.aud_out_queue)
+            self.pipeline.add(self.audioconv)
+            self.pipeline.add(self.audioenc)
+
+        if self.audio2_source:
+            self.pipeline.add(self.audiomixer)
+            self.pipeline.add(self.aud2_in_queue)
+            self.pipeline.add(self.audio2src)
+            self.pipeline.add(self.aud2_caps_filter)
+
+        self.pipeline.add(self.mux)
+        self.pipeline.add(self.sink)
+
+    # gst-launch-1.0 -e ximagesrc endx=1919 endy=1079 use-damage=false show-pointer=true ! \
+    #   queue ! videorate ! video/x-raw,framerate=15/1 ! videoconvert ! \
+    #   vp8enc end-usage=vbr target-bitrate=800000000 threads=3 static-threshold=1000 \
+    #     token-partitions=2 max-quantizer=30 ! queue name=before_mux ! webmmux name=mux ! \
+    #   queue ! filesink location="test-videorate.webm"
+
+    def setup_links(self):
+        # Connect everything together
+        self.videosrc.link(self.vid_in_queue)
+        if self.crop_vid:
+            self.vid_in_queue.link(self.videocrop)
+            self.videocrop.link(self.videorate)
+        else:
+            self.vid_in_queue.link(self.videorate)
+        self.videorate.link(self.vid_caps_filter)
+        self.vid_caps_filter.link(self.videoconvert)
+        if prefs.codec is CODEC_RAW:
+            self.videoconvert.link(self.vid_out_queue)
+            logger.debug("Linking RAW Video")
+        else:
+            logger.debug("Linking Video")
+            self.videoconvert.link(self.videnc)
+            self.videnc.link(self.vid_out_queue)
+
+        self.vid_out_queue.link(self.mux)
+
+        if self.audio_source:
+            logger.debug("Linking Audio")
+            ret = self.audiosrc.link(self.aud_in_queue)
+            logger.debug(" Link audiosrc -> aud_in_queue: %s" % ret)
+            ret = self.aud_in_queue.link(self.aud_caps_filter)
+            logger.debug(" Link aud_in_queue -> aud_caps_filter: %s" % ret)
+
+            if self.audio2_source:
+                logger.debug("Linking Audio2")
+                # Link first audio source to mixer
+                ret = self.aud_caps_filter.link(self.audiomixer)
+                logger.debug(" Link aud_caps_filter -> audiomixer: %s" % ret)
+
+                # Link second audio source to mixer
+                ret = self.audio2src.link(self.aud2_in_queue)
+                logger.debug(" Link audio2src -> aud2_in_queue: %s" % ret)
+                ret = self.aud2_in_queue.link(self.aud2_caps_filter)
+                logger.debug(" Link aud2_in_queue -> aud2_caps_filter: %s" % ret)
+                ret = self.aud2_caps_filter.link(self.audiomixer)
+                logger.debug(" Link aud2_caps_filter -> audiomixer: %s" % ret)
+
+                # Link mixer to audio convert
+                ret = self.audiomixer.link(self.audioconv)
+                logger.debug(" Link audiomixer -> audioconv: %s" % ret)
+
+            else:
+                # Link first audio source to audio convert
+                ret = self.aud_caps_filter.link(self.audioconv)
+                logger.debug(" Link aud_caps_filter -> audioconv: %s" % ret)
+
+            # Link audio to muxer
+            ret = self.audioconv.link(self.audioenc)
+            logger.debug("Link audioconv -> audioenc: %s" % ret)
+            ret = self.audioenc.link(self.aud_out_queue)
+            logger.debug("Link audioenc -> aud_out_queue: %s" % ret)
+            ret = self.aud_out_queue.link(self.mux)
+            logger.debug("Link aud_out_queue -> mux: %s" % ret)
+
+        ret = self.mux.link(self.file_queue)
+        logger.debug("Link mux -> file queue: %s" % ret)
+        ret = self.file_queue.link(self.sink)
+        logger.debug("Link file queue -> sink: %s" % ret)
+
+    def start_recording(self):
+        logger.debug("Setting STATE_PLAYING")
+        self.pipeline.set_state(Gst.State.PLAYING)
+
+    def pause_recording(self):
+        logger.debug("Setting STATE_PAUSED")
+        self.pipeline.set_state(Gst.State.PAUSED)
+
+    def unpause_recording(self):
+        logger.debug("Setting STATE_PLAYING - UNPAUSE")
+        self.pipeline.set_state(Gst.State.PLAYING)
+
+    def stop_recording(self):
+        logger.debug("Sending new EOS event")
+        self.pipeline.send_event(Gst.Event.new_eos())
+
+    def get_tempfile(self):
+        return self.tempfile
+
+    def get_audio_recorded(self):
+        return self.audio
+
+    def on_message(self, bus, message):
+        t = message.type
+        if t == Gst.MessageType.EOS:
+            logger.debug("Received EOS, setting pipeline to NULL.")
+            self.pipeline.set_state(Gst.State.NULL)
+            logger.debug("Emitting flush-done.")
+            self.emit("flush-done")
+        elif t == Gst.MessageType.ERROR:
+            logger.debug("Received an error message: %s", message.parse_error()[1])
+
+
+def detect_codecs():
+    codecs_supported = []
+    codec_test = None
+    for codec in CODEC_LIST:
+        if codec[0]:
+            try:
+                codec_test = Gst.ElementFactory.make(codec[1], "video_encoder")
+            except:
+                logger.info("Unable to find {0} GStreamer plugin - support disabled.".format(codec))
+                codec_test = None
+
+            if codec_test:
+                codecs_supported.append(codec[0])
+                logger.info("Supported encoder: {0}.".format(codec[2]))
+        else:
+            # RAW codec is None, so we don't try to load it.
+            codecs_supported.append(codec[0])
+            logger.info("Supported encoder: {0}.".format(codec[2]))
+        codec_test = None
+    return codecs_supported
+
+def get_codec(codec):
+    for c in CODEC_LIST:
+        if c[0] == codec:
+            return c
+    return None

=== added file 'build/lib.linux-x86_64-2.7/kazam/backend/prefs.py'
--- build/lib.linux-x86_64-2.7/kazam/backend/prefs.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/backend/prefs.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+#
+#       prefs.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import logging
+from gettext import gettext as _
+from xdg.BaseDirectory import xdg_config_home
+
+from kazam.backend.config import KazamConfig
+
+
+class Prefs():
+    def __init__(self):
+        """Initialize prefs and set all the preference variables to their
+           default values.
+
+        Args:
+            None
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        self.logger = logging.getLogger("Prefs")
+
+        #
+        # GUI preferences and stuff
+        #
+        self.capture_cursor = False
+        self.capture_speakers = False
+        self.capture_microphone = False
+
+        self.capture_cursor_pic = False
+        self.capture_borders_pic = False
+
+        self.countdown_timer = 5
+
+        self.speakers_source = None
+        self.microphone_source = None
+
+        self.speakers_volume = 0
+        self.microphone_volume = 0
+
+        self.countdown_splash = True
+        self.silent_start = False
+
+        #
+        # Other stuff
+        #
+        self.datadir = None
+
+        #
+        # Capture related stuff
+        #
+        self.codec = None
+        self.pa_q = None
+        self.framerate = 15
+        self.autosave_video = False
+        self.autosave_video_file = None
+
+        self.autosave_picture = False
+        self.autosave_picture_file = None
+        self.shutter_sound = True
+        self.shutter_type = 0
+        self.shutter_sound_file = ""
+
+        self.area = None
+        self.xid = None
+        self.xid_geometry = None
+
+        #
+        # Audio sources
+        #  - Tuple of all sources
+        #  - Selected first source
+        #  - Selected second source
+        #
+        self.audio_sources = None
+        self.audio_source = None
+        self.audio2_source = None
+
+        #
+        # Command line parameters
+        #
+        self.debug = False
+        self.test = False
+        self.dist = ('Ubuntu', '12.10', 'quantal')
+        self.silent = False
+        self.sound = True
+
+        self.config = KazamConfig()
+
+        self.read_config()
+
+        self.get_dirs()
+
+    def get_audio_sources(self):
+        self.logger.debug("Getting Audio sources.")
+        try:
+            self.audio_sources = prefs.pa_q.get_audio_sources()
+            #self.audio_sources.insert(0, [])
+            if prefs.debug:
+                for src in self.audio_sources:
+                    self.logger.debug(" Device found: ")
+                    for item in src:
+                        self.logger.debug("  - {0}".format(item))
+        except:
+            # Something went wrong, just fallback to no-sound
+            self.logger.warning("Unable to find any audio devices.")
+            self.audio_sources = [[0, _("Unknown"), _("Unknown")]]
+
+    def get_dirs(self):
+        paths = {}
+        f = None
+        try:
+            f = open(os.path.join(xdg_config_home, "user-dirs.dirs"))
+            for la in f:
+                if la.startswith("XDG_VIDEOS") or la.startswith("XDG_DOCUMENTS") or la.startswith("XDG_PICTURES") :
+                    (idx, val) = la.strip()[:-1].split('="')
+                    paths[idx] = os.path.expandvars(val)
+        except:
+            paths['XDG_VIDEOS_DIR'] = os.path.expanduser("~/Videos/")
+            paths['XDG_PICTURES_DIR'] = os.path.expanduser("~/Pictures/")
+            paths['XDG_DOCUMENTS_DIR'] = os.path.expanduser("~/Documents/")
+        finally:
+            if f is not None:
+                f.close()
+
+        paths['HOME_DIR'] = os.path.expandvars("$HOME")
+
+        if os.path.isdir(paths['XDG_VIDEOS_DIR']):
+            self.video_dest = paths['XDG_VIDEOS_DIR']
+        elif os.path.isdir(paths['XDG_DOCUMENTS_DIR']):
+            self.video_dest = paths['XDG_DOCUMENTS_DIR']
+        elif os.path.isdir(paths['HOME_DIR']):
+            self.video_dest = paths['HOME_DIR']
+
+        if os.path.isdir(paths['XDG_PICTURES_DIR']):
+            self.picture_dest = paths['XDG_PICTURES_DIR']
+        elif os.path.isdir(paths['XDG_DOCUMENTS_DIR']):
+            self.picture_dest = paths['XDG_DOCUMENTS_DIR']
+        elif os.path.isdir(paths['HOME_DIR']):
+            self.picture_dest = paths['HOME_DIR']
+
+
+    def get_sound_files(self):
+        self.sound_files = []
+        for root, dir, files in os.walk(os.path.join(self.datadir, "sounds")):
+            for file in files:
+                if file.endswith('.ogg'):
+                    self.sound_files.append(file)
+
+
+    def read_config (self):
+        self.audio_source = self.config.getint("main", "audio_source")
+        self.audio2_source = self.config.getint("main", "audio2_source")
+
+        self.main_x = self.config.getint("main", "last_x")
+        self.main_y = self.config.getint("main", "last_y")
+
+        self.codec = self.config.getint("main", "codec")
+
+        self.countdown_timer = self.config.getfloat("main", "counter")
+        self.framerate = self.config.getfloat("main", "framerate")
+
+        self.capture_cursor = self.config.getboolean("main", "capture_cursor")
+        self.capture_microphone = self.config.getboolean("main", "capture_microphone")
+        self.capture_speakers = self.config.getboolean("main", "capture_speakers")
+
+        self.capture_cursor_pic = self.config.getboolean("main", "capture_cursor_pic")
+        self.capture_borders_pic = self.config.getboolean("main", "capture_borders_pic")
+
+        self.countdown_splash = self.config.getboolean("main", "countdown_splash")
+
+        self.autosave_video = self.config.getboolean("main", "autosave_video")
+        self.autosave_video_file = self.config.get("main", "autosave_video_file")
+
+        self.autosave_picture = self.config.getboolean("main", "autosave_picture")
+        self.autosave_picture_file = self.config.get("main", "autosave_picture_file")
+
+        self.shutter_sound = self.config.getboolean("main", "shutter_sound")
+        self.shutter_type = self.config.getint("main", "shutter_type")
+
+
+    def save_config(self):
+        self.config.set("main", "capture_cursor", self.capture_cursor)
+        self.config.set("main", "capture_speakers", self.capture_speakers)
+        self.config.set("main", "capture_microphone", self.capture_microphone)
+
+        self.config.set("main", "capture_cursor_pic", self.capture_cursor_pic)
+        self.config.set("main", "capture_borders_pic", self.capture_borders_pic)
+
+        self.config.set("main", "last_x", self.main_x)
+        self.config.set("main", "last_y", self.main_y)
+
+        if self.sound:
+            self.config.set("main", "audio_source", self.audio_source)
+            self.config.set("main", "audio2_source", self.audio2_source)
+
+        self.config.set("main", "countdown_splash", self.countdown_splash)
+        self.config.set("main", "counter", self.countdown_timer)
+        self.config.set("main", "codec", self.codec)
+        self.config.set("main", "framerate", self.framerate)
+        self.config.set("main", "autosave_video", self.autosave_video)
+        self.config.set("main", "autosave_video_file", self.autosave_video_file)
+        self.config.set("main", "autosave_picture", self.autosave_picture)
+        self.config.set("main", "autosave_picture_file", self.autosave_picture_file)
+        self.config.set("main", "shutter_sound", self.shutter_sound)
+        self.config.set("main", "shutter_type", self.shutter_type)
+
+        self.config.write()
+
+prefs = Prefs()

=== added directory 'build/lib.linux-x86_64-2.7/kazam/frontend'
=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/__init__.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/__init__.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/__init__.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,1 @@
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/about_dialog.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/about_dialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/about_dialog.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+#
+#       authenticate.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+from gettext import gettext as _
+from gi.repository import Gtk
+from kazam.version import *
+
+AUTHORS = """
+Andrew Higginson <[e-mail]>
+David Klasinc <[e-mail]>
+"""
+
+ARTISTS = """
+Robert McKenna <[e-mail]>
+Andrew Higginson <[e-mail]>
+"""
+LICENSE = """
+    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/>.
+"""
+
+def AboutDialog(icons):
+    dialog = Gtk.AboutDialog()
+    dialog.set_program_name(_("Kazam Screencaster") + " - \"" + CODENAME + "\"")
+    dialog.set_comments(_("Record a video of activity on your screen."))
+    dialog.set_license(LICENSE)
+    dialog.set_version(VERSION)
+    dialog.set_copyright("© 2010 Andrew Higginson, © 2012 David Klasinc")
+    dialog.set_website("http://launchpad.net/kazam")
+    dialog.set_authors(AUTHORS.split("\n"))
+    dialog.set_artists(ARTISTS.split("\n"))
+    try:
+        icon = icons.load_icon("kazam", 96, Gtk.IconLookupFlags.GENERIC_FALLBACK)
+        dialog.set_logo(icon)
+    except:
+        # Not important, we just don't get to show our lovely logo.. :)
+        pass
+    dialog.show_all()
+    dialog.set_position(Gtk.WindowPosition.CENTER)
+    dialog.run()
+    dialog.hide()

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/combobox.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/combobox.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/combobox.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+#
+#       combobox.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+
+from xdg.DesktopEntry import DesktopEntry
+from gi.repository import Gtk, GdkPixbuf, GObject
+
+from kazam.backend.prefs import *
+
+class EditComboBox(Gtk.ComboBox):
+
+    KDENLIVE_VERSION = [0,8]
+
+    #
+    # This really needs to be done differently ...
+    #
+    if prefs.dist[2] == 'quantal':
+        EDITORS = {
+                    "/usr/share/app-install/desktop/openshot:openshot.desktop":[],
+                    "/usr/share/app-install/desktop/pitivi:pitivi.desktop":["-i", "-a"],
+                    "/usr/share/app-install/desktop/avidemux:avidemux-gtk.desktop":[],
+                    "/usr/share/app-install/desktop/kdenlive:kde4__kdenlive.desktop":["-i"],
+            }
+    else:
+        EDITORS = {
+                   "/usr/share/applications/openshot.desktop":[],
+                   "/usr/share/applications/pitivi.desktop":["-i", "-a"],
+                   "/usr/share/applications/avidemux-gtk.desktop":[],
+                   "/usr/share/applications/kde4/kdenlive.desktop":["-i"],
+                  }
+
+    def __init__(self, icons):
+        Gtk.ComboBox.__init__(self)
+        self.icons = icons
+        self.empty = True
+        cr_pixbuf = Gtk.CellRendererPixbuf()
+        self.pack_start(cr_pixbuf, True)
+        self.add_attribute(cr_pixbuf, 'pixbuf', 0)
+        cr_text = Gtk.CellRendererText()
+        self.pack_start(cr_text, True)
+        self.add_attribute(cr_text, 'text', 1)
+
+        self.box_model = Gtk.ListStore(GdkPixbuf.Pixbuf, str,
+                                       GObject.TYPE_PYOBJECT,
+                                       GObject.TYPE_PYOBJECT
+                                      )
+        self.set_model(self.box_model)
+        self._populate()
+        self.set_active(0)
+        self.set_sensitive(True)
+        self.show()
+
+    def get_active_value(self):
+        i = self.get_active()
+        model = self.get_model()
+        model_iter = model.get_iter(i)
+        return (model.get_value(model_iter, 2),
+                model.get_value(model_iter, 3))
+
+    def _populate(self):
+        for item in self.EDITORS:
+            if os.path.isfile(item):
+                args = self.EDITORS[item]
+                desktop_entry = DesktopEntry(item)
+                command = desktop_entry.getExec()
+
+                # For .desktop files with ' %U' or ' # %F'
+                command = command.split(" ")[0]
+
+                name = desktop_entry.getName()
+                icon_name = desktop_entry.getIcon()
+
+                self._add_item(icon_name, name, command, args)
+
+        if len(self.get_model()):
+            self.empty = False
+        else:
+            self.empty = True
+
+    def _add_item(self, icon_name, name, command, args):
+        liststore = self.get_model()
+        try:
+            pixbuf = self.icons.load_icon(icon_name, 16, Gtk.IconLookupFlags.GENERIC_FALLBACK)
+        except:
+            pixbuf = self.icons.load_icon("application-x-executable", 16, Gtk.IconLookupFlags.GENERIC_FALLBACK)
+
+        liststore.append([pixbuf, name, command, args])
+
+    def _version_is_gte(self, required_version, current_version):
+        i = 0
+        for digit in current_version:
+            required_digit = required_version[i]
+            current_digit = int(digit)
+            if current_digit < required_digit:
+                return False
+        return True

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/done_recording.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/done_recording.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/done_recording.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+#
+#       app.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import shutil
+import logging
+logger = logging.getLogger("Done Recording")
+
+from gettext import gettext as _
+from gi.repository import Gtk, GObject
+
+from kazam.backend.constants import *
+from kazam.frontend.combobox import EditComboBox
+from kazam.frontend.save_dialog import SaveDialog
+
+class DoneRecording(Gtk.Window):
+
+    __gsignals__ = {
+    "save-done"       : (GObject.SIGNAL_RUN_LAST,
+                            None,
+                            [GObject.TYPE_PYOBJECT],),
+    "edit-request"  : (GObject.SIGNAL_RUN_LAST,
+                            None,
+                            [GObject.TYPE_PYOBJECT],),
+    "save-cancel"     : (GObject.SIGNAL_RUN_LAST,
+                            None,
+                            (),)
+    }
+
+    def __init__(self, icons, tempfile, codec, old_path):
+        Gtk.Window.__init__(self, title=_("Kazam Screencaster - Recording finished"))
+        self.icons = icons
+        self.tempfile = tempfile
+        self.codec = codec
+        self.action = ACTION_SAVE
+        self.old_path = old_path
+        self.set_position(Gtk.WindowPosition.NONE)
+
+        # Setup UI
+        self.set_border_width(10)
+        self.vbox = Gtk.Box(spacing = 20, orientation = Gtk.Orientation.VERTICAL)
+        self.label_box = Gtk.Box()
+        self.done_label = Gtk.Label(_("Kazam finished recording.\nWhat do you want to do now?"))
+        self.label_box.add(self.done_label)
+        self.grid = Gtk.Grid(row_spacing = 10, column_spacing = 5)
+        self.radiobutton_edit = Gtk.RadioButton.new_with_label_from_widget(None, _("Edit with:"))
+        self.combobox_editor = EditComboBox(self.icons)
+        self.grid.add(self.radiobutton_edit)
+        self.grid.attach_next_to(self.combobox_editor,
+                                 self.radiobutton_edit,
+                                 Gtk.PositionType.RIGHT,
+                                 1, 1)
+        self.radiobutton_save = Gtk.RadioButton.new_from_widget(self.radiobutton_edit)
+        self.radiobutton_save.set_label(_("Save for later"))
+
+        if self.combobox_editor.empty:
+            self.radiobutton_edit.set_active(False)
+            self.radiobutton_edit.set_sensitive(False)
+
+        self.radiobutton_save.set_active(True)
+
+        self.radiobutton_save.connect("toggled", self.cb_radiobutton_save_toggled)
+        self.radiobutton_edit.connect("toggled", self.cb_radiobutton_edit_toggled)
+        self.btn_cancel = Gtk.Button(label = _("Cancel"))
+        self.btn_cancel.set_size_request(100, -1)
+        self.btn_continue = Gtk.Button(label = _("Continue"))
+        self.btn_continue.set_size_request(100, -1)
+
+        self.btn_continue.connect("clicked", self.cb_continue_clicked)
+        self.btn_cancel.connect("clicked", self.cb_cancel_clicked)
+
+        self.hbox = Gtk.Box(spacing = 10)
+        self.left_hbox = Gtk.Box()
+        self.right_hbox = Gtk.Box(spacing = 5)
+
+        self.right_hbox.pack_start(self.btn_cancel, False, True, 0)
+        self.right_hbox.pack_start(self.btn_continue, False, True, 0)
+
+        self.hbox.pack_start(self.left_hbox, True, True, 0)
+        self.hbox.pack_start(self.right_hbox, False, False, 0)
+
+        self.vbox.pack_start(self.label_box, True, True, 0)
+        self.vbox.pack_start(self.grid, True, True, 0)
+        self.vbox.pack_start(self.radiobutton_save, True, True, 0)
+        self.vbox.pack_start(self.hbox, True, True, 0)
+        self.add(self.vbox)
+        self.connect("delete-event", self.cb_delete_event)
+        self.show_all()
+        self.present()
+
+
+    def cb_continue_clicked(self, widget):
+        if self.action == ACTION_EDIT:
+            logger.debug("Continue - Edit.")
+            (command, args)  = self.combobox_editor.get_active_value()
+            self.emit("edit-request", (command, args))
+            self.destroy()
+        else:
+            self.set_sensitive(False)
+            logger.debug("Continue - Save ({0}).".format(self.codec))
+            (dialog, result, self.old_path) = SaveDialog(_("Save screencast"),
+                                          self.old_path, self.codec)
+
+            if result == Gtk.ResponseType.OK:
+                uri = os.path.join(dialog.get_current_folder(), dialog.get_filename())
+
+                if not uri.endswith(CODEC_LIST[self.codec][3]):
+                    uri += CODEC_LIST[self.codec][3]
+
+                shutil.move(self.tempfile, uri)
+                dialog.destroy()
+                self.emit("save-done", self.old_path)
+                self.destroy()
+            else:
+                self.set_sensitive(True)
+                dialog.destroy()
+
+
+    def cb_cancel_clicked(self, widget):
+        self.emit("save-cancel")
+        self.destroy()
+
+    def cb_delete_event(self, widget, data):
+        self.emit("save-cancel")
+        self.destroy()
+
+    def cb_radiobutton_save_toggled(self, widget):
+        if not widget.get_active():
+            return
+        else:
+            self.action = ACTION_SAVE
+            self.combobox_editor.set_sensitive(False)
+
+    def cb_radiobutton_edit_toggled(self, widget):
+        if not widget.get_active():
+            return
+        else:
+            self.action = ACTION_EDIT
+            self.combobox_editor.set_sensitive(True)
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/export.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/export.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/export.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+#
+#       export_frontend.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import logging
+import os
+
+from gettext import gettext as _
+from gi.repository import Gtk, GObject
+
+from kazam.utils import *
+from kazam.backend.export import ExportBackend
+
+class ExportFrontend(GObject.GObject):
+
+    __gsignals__ = {
+    "back-requested"     : (GObject.SIGNAL_RUN_LAST,
+                            GObject.TYPE_NONE,
+                            ( ),),
+    "export-requested"   : (GObject.SIGNAL_RUN_LAST,
+                            GObject.TYPE_NONE,
+                            ( ),)
+    }
+
+    def __init__(self, datadir, icons, recorder):
+        GObject.GObject.__init__(self)
+
+        self.recorder = recorder
+
+        # Setup Backend
+        self.backend = ExportBackend(self, datadir)
+        self.backend.connect("authenticate-requested", self.cb_authenticate_requested)
+        self.backend.connect("login-started", self.cb_login_started)
+        self.backend.connect("login-completed", self.cb_login_completed)
+        self.backend.connect("convert-started", self.cb_convert_started)
+        self.backend.connect("convert-completed", self.cb_convert_completed)
+        self.backend.connect("upload-started", self.cb_upload_started)
+        self.backend.connect("upload-completed", self.cb_upload_completed)
+
+        self.active_alignment = None
+
+        # Setup UI
+        builder = Gtk.Builder()
+        builder.add_from_file(os.path.join(datadir, "ui", "export.ui"))
+
+        # Get window
+        self.window = builder.get_object("window_export")
+        self.window.connect("delete-event", Gtk.main_quit)
+
+        # Setup quality sliders
+        self.setup_quality_sliders()
+
+        # Export combobox setup
+        export_objects = self.backend.get_export_objects()
+        export_object_details = []
+        for obj in export_objects:
+            name = obj.NAME
+            icon = obj.ICONS[0]
+            tup = (icon, name)
+            export_object_details.append(tup)
+
+        self.combobox_export = ExportCombobox(self.icons, export_object_details)
+        self.combobox_export.connect("changed", self.on_combobox_export_changed)
+        self.hbox_export.pack_start(self.combobox_export, False, True)
+        self.hbox_export.reorder_child(self.combobox_export, 1)
+        self.on_combobox_export_changed(None)
+
+    def run(self):
+        self.window.show_all()
+
+    def setup_quality_sliders(self):
+
+        if self.screencast.get_video_recorded():
+            # Video Quality Slider
+            self.adjustment_quality_video = Gtk.Adjustment(3000, 200, 6001, 1)
+            self.hscale_quality_video = Gtk.HScale(self.adjustment_quality_video)
+            self.hscale_quality_video.set_draw_value(False)
+            self.hbox_quality_video.pack_start(self.hscale_quality_video)
+        else:
+            self.vbox_quality_video.destroy()
+
+        # (If audio was recorded) Audio Quality Slider
+        if self.screencast.get_audio_recorded():
+            self.adjustment_quality_audio = Gtk.Adjustment(140, 32, 256, 1)
+            self.hscale_quality_audio = Gtk.HScale(self.adjustment_quality_audio)
+            self.hscale_quality_audio.set_draw_value(False)
+            self.hbox_quality_audio.pack_start(self.hscale_quality_audio)
+        else:
+            self.vbox_quality_audio.destroy()
+
+    def on_button_back_clicked(self, button):
+        self.emit("back-requested")
+        self.window.destroy()
+
+    def on_button_export_clicked(self, button):
+        self.emit("export-requested")
+
+    def on_combobox_export_changed(self, combobox):
+        # If we already have an alignment, unpack it
+        if self.active_alignment:
+             self.vbox_main.remove(self.active_alignment)
+
+        # Get our current item's object
+        i = self.combobox_export.get_active()
+        active_object = self.backend.set_active_export_object(i)
+        # And its alignment
+        self.active_alignment = active_object.alignment_properties
+
+        # Run the alignment's expose function
+        active_object.property_alignment_expose()
+
+        # Pack our alignment
+        self.vbox_main.pack_start(self.active_alignment, True, True)
+        self.vbox_main.reorder_child(self.active_alignment, 2)
+
+    def _change_status(self, img, text):
+        for child in self.hbox_status.get_children():
+            child.destroy()
+        if img == "spinner":
+            img_widget = gtk.Spinner()
+            img_widget.start()
+        else:
+            img_widget = Gtk.image_new_from_stock(img, Gtk.ICON_SIZE_MENU)
+        text_widget = Gtk.Label(text)
+        self.hbox_status.pack_start(img_widget, False, False)
+        self.hbox_status.pack_start(text_widget, False, False)
+        self.hbox_status.show_all()
+
+    def get_screencast(self):
+        return self.screencast
+
+    def get_meta(self):
+        active_export_object = self.backend.get_active_export_object()
+        meta = active_export_object.META.copy()
+        # For every property in the meta dict...
+        for prop in meta:
+            # ..get the corresponding widget in the meta dict
+            widget = getattr(active_export_object, meta[prop])
+            # ...get the corresponding widget value and add to the dict
+            # inplace of the widget
+            meta[prop] = self.get_property_value(widget)
+        return meta
+
+    def get_video_quality(self):
+        if self.screencast.get_video_recorded():
+            return self.adjustment_quality_video.get_value()
+        return False
+
+    def get_audio_quality(self):
+        if self.screencast.get_audio_recorded():
+            return self.adjustment_quality_audio.get_value()
+        return False
+
+    def get_property_value(self, widget):
+        # Convenience function to get property value based on widget type
+        if isinstance(widget, gtk.Entry):
+            return widget.get_text()
+        elif isinstance(widget, gtk.TextView):
+            buf = widget.get_buffer()
+            return buf.get_text(buf.get_start_iter(), buf.get_end_iter())
+        elif isinstance(widget, EasyTextAndObjectComboBox):
+            tuple_ = (widget.get_active_value(0), widget.get_active_value(1))
+            return tuple_
+        elif issubclass(widget.__class__, EasyComboBox):
+            return widget.get_active_value(0)
+
+    def sensitise_content_action_widgets(self, sensitive):
+        self.active_alignment.set_sensitive(sensitive)
+        self.button_export.set_sensitive(sensitive)
+        self.button_back.set_sensitive(sensitive)
+        self.combobox_export.set_sensitive(sensitive)
+        self.label_export.set_sensitive(sensitive)
+
+    def cb_authenticate_requested(self, backend, icons, name, register_url):
+        authenticate_dialog = AuthenticateDialog(self.datadir, name, self.icons, icons, register_url)
+        authenticate_dialog.window.set_transient_for(self.window)
+        authenticate_dialog.run()
+        self.window.set_sensitive(False)
+        while (not hasattr(authenticate_dialog, "details")):
+            if authenticate_dialog.action == authenticate_dialog.ACTION_CANCEL:
+                break
+            gtk.main_iteration()
+        self.window.set_sensitive(True)
+        if authenticate_dialog.action == authenticate_dialog.ACTION_CANCEL:
+            return
+        self.backend.details = authenticate_dialog.details
+
+    def cb_login_started(self, backend):
+        self._change_status("spinner", _("Logging in..."))
+        # Make buttons, combobox, label and the alignment insensitive
+        self.sensitise_content_action_widgets(False)
+
+    def cb_login_completed(self, backend, success):
+        if success:
+            self._change_status(gtk.STOCK_OK, _("Log-in completed."))
+        else:
+            self._change_status(gtk.STOCK_DIALOG_ERROR, _("There was an error logging in."))
+            # Set buttons, combobox and the alignment sensitive
+            self.sensitise_content_action_widgets(True)
+
+    def cb_convert_started(self, backend):
+        self._change_status("spinner", _("Converting screencast..."))
+
+    def cb_convert_completed(self, backend, success):
+        if success:
+            self._change_status(Gtk.STOCK_OK, _("Screencast converted."))
+        else:
+            self._change_status(Gtk.STOCK_DIALOG_ERROR, _("There was an error converting."))
+            # Set buttons, combobox and the alignment sensitive
+            self.sensitise_content_action_widgets(True)
+
+    def cb_upload_started(self, backend):
+        self._change_status("spinner", _("Uploading screencast..."))
+
+    def cb_upload_completed(self, backend, success, url):
+        if success:
+            self._change_status(Gtk.STOCK_OK, _("Screencast uploaded."))
+            # Set buttons, combobox and the alignment sensitive
+            self.sensitise_content_action_widgets(True)
+            # Show a dialog with the url of the uploaded file
+            new_linkbutton_dialog(url, _("Your screencast has uploaded successfully."),
+                            _("It is available at the location below:"), self.window)
+        else:
+            self._change_status(Gtk.STOCK_DIALOG_ERROR, _("There was an error uploading."))
+            # Set buttons, combobox and the alignment sensitive
+            self.sensitise_content_action_widgets(True)
+
+
+#if __name__ == "__main__":
+#    from kazam.backend.ffmpeg import Screencast
+#
+#    if os.path.exists("./data/ui/export.ui"):
+#        logging.info("Running locally")
+#        datadir = "./data"
+#    else:
+#        datadir = "/usr/share/kazam/"
+#    icons = gtk.icon_theme_get_default()
+#    icons.append_search_path(os.path.join(datadir,"icons", "48x48", "apps"))
+#    icons.append_search_path(os.path.join(datadir,"icons", "16x16", "apps"))
+
+#    screencast = Screencast()
+#    screencast.audio = True
+
+ #   export = ExportFrontend(datadir, icons, screencast)
+ #   export.connect("back-requested", gtk.main_quit)
+ #   export.connect("export-requested", gtk.main_quit)
+ #   export.connect("quit-requested", gtk.main_quit)
+ #   export.run()
+ #   gtk.main()
+
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/indicator.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/indicator.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/indicator.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+#
+#       indicator.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import logging
+logger = logging.getLogger("Indicator")
+
+from gettext import gettext as _
+from gi.repository import Gtk, GObject
+
+from kazam.backend.constants import *
+
+class KazamSuperIndicator(GObject.GObject):
+    __gsignals__ = {
+        "indicator-pause-request" : (GObject.SIGNAL_RUN_LAST,
+                                     None,
+                                     (), ),
+        "indicator-unpause-request" : (GObject.SIGNAL_RUN_LAST,
+                                       None,
+                                       (), ),
+        "indicator-quit-request" : (GObject.SIGNAL_RUN_LAST,
+                                    None,
+                                    (), ),
+        "indicator-show-request" : (GObject.SIGNAL_RUN_LAST,
+                                    None,
+                                    (), ),
+        "indicator-stop-request" : (GObject.SIGNAL_RUN_LAST,
+                                    None,
+                                    (), ),
+        "indicator-start-request" : (GObject.SIGNAL_RUN_LAST,
+                                     None,
+                                     (), ),
+
+        "indicator-about-request" : (GObject.SIGNAL_RUN_LAST,
+                                     None,
+                                     (), ),
+        }
+
+    def __init__(self, silent = False):
+        super(KazamSuperIndicator, self).__init__()
+        self.blink_icon = BLINK_STOP_ICON
+        self.blink_state = False
+        self.blink_mode = BLINK_SLOW
+        self.recording = False
+        self.silent = silent
+        logger.debug("Indicatior silent: {0}".format(self.silent))
+
+        self.menu = Gtk.Menu()
+
+        self.menuitem_start = Gtk.MenuItem(_("Start recording"))
+        self.menuitem_start.set_sensitive(True)
+        self.menuitem_start.connect("activate", self.on_menuitem_start_activate)
+
+        self.menuitem_pause = Gtk.CheckMenuItem(_("Pause recording"))
+        self.menuitem_pause.set_sensitive(False)
+        self.menuitem_pause.connect("toggled", self.on_menuitem_pause_activate)
+
+        self.menuitem_finish = Gtk.MenuItem(_("Finish recording"))
+        self.menuitem_finish.set_sensitive(False)
+        self.menuitem_finish.connect("activate", self.on_menuitem_finish_activate)
+
+        self.menuitem_separator = Gtk.SeparatorMenuItem()
+        self.menuitem_separator2 = Gtk.SeparatorMenuItem()
+
+        self.menuitem_show = Gtk.MenuItem(_("Record setup"))
+        self.menuitem_show.connect("activate", self.on_menuitem_show_activate)
+
+        self.menuitem_about = Gtk.MenuItem(_("About"))
+        self.menuitem_about.connect("activate", self.on_menuitem_about_activate)
+
+
+        self.menuitem_quit = Gtk.MenuItem(_("Quit"))
+        self.menuitem_quit.connect("activate", self.on_menuitem_quit_activate)
+
+        self.menu.append(self.menuitem_start)
+        self.menu.append(self.menuitem_pause)
+        self.menu.append(self.menuitem_finish)
+        self.menu.append(self.menuitem_separator)
+        self.menu.append(self.menuitem_show)
+        self.menu.append(self.menuitem_about)
+        self.menu.append(self.menuitem_separator2)
+        self.menu.append(self.menuitem_quit)
+
+        self.menu.show_all()
+
+        #
+        # Setup keybindings - Hardcore way
+        #
+        try:
+            from gi.repository import Keybinder
+            logger.debug("Trying to bind hotkeys.")
+            Keybinder.init()
+            Keybinder.bind("<Super><Ctrl>R", self.cb_hotkeys, "start-request")
+            Keybinder.bind("<Super><Ctrl>F", self.cb_hotkeys, "stop-request")
+            Keybinder.bind("<Super><Ctrl>P", self.cb_hotkeys, "pause-request")
+            Keybinder.bind("<Super><Ctrl>W", self.cb_hotkeys, "show-request")
+            Keybinder.bind("<Super><Ctrl>Q", self.cb_hotkeys, "quit-request")
+            self.recording = False
+        except ImportError:
+            logger.info("Unable to import Keybinder, hotkeys not available.")
+
+    def cb_hotkeys(self, key, action):
+        logger.debug("KEY {0}, ACTION {1}".format(key, action))
+        if action == "start-request" and not self.recording:
+            self.on_menuitem_start_activate(None)
+        elif action == "stop-request" and self.recording:
+            self.on_menuitem_finish_activate(None)
+        elif action == "pause-request" and self.recording:
+            if not self.menuitem_pause.get_active():
+                self.menuitem_pause.set_active(True)
+            else:
+                self.menuitem_pause.set_active(False)
+        elif action == "show-request" and not self.recording:
+            self.emit("indicator-show-request")
+        elif action == "quit-request" and not self.recording:
+            self.emit("indicator-quit-request")
+
+    def on_menuitem_pause_activate(self, menuitem):
+        if self.menuitem_pause.get_active():
+            self.emit("indicator-pause-request")
+        else:
+            self.emit("indicator-unpause-request")
+
+    def on_menuitem_start_activate(self, menuitem):
+        self.recording = True
+        self.emit("indicator-start-request")
+
+    def on_menuitem_finish_activate(self, menuitem):
+        self.recording = False
+        self.menuitem_start.set_sensitive(True)
+        self.menuitem_pause.set_sensitive(False)
+        self.menuitem_pause.set_active(False)
+        self.menuitem_finish.set_sensitive(False)
+        self.menuitem_show.set_sensitive(True)
+        self.menuitem_quit.set_sensitive(True)
+        self.emit("indicator-stop-request")
+
+    def on_menuitem_quit_activate(self, menuitem):
+        self.emit("indicator-quit-request")
+
+    def on_menuitem_show_activate(self, menuitem):
+        self.emit("indicator-show-request")
+
+    def on_menuitem_about_activate(self, menuitem):
+        self.emit("indicator-about-request")
+
+try:
+    from gi.repository import AppIndicator3
+
+    class KazamIndicator(KazamSuperIndicator):
+        def __init__(self, silent = False):
+            super(KazamIndicator, self).__init__(silent)
+            self.silent = silent
+
+            self.indicator = AppIndicator3.Indicator.new("kazam",
+                             "kazam-stopped",
+                             AppIndicator3.IndicatorCategory.APPLICATION_STATUS)
+
+            self.indicator.set_menu(self.menu)
+            self.indicator.set_attention_icon("kazam-recording")
+            self.indicator.set_icon("kazam-stopped")
+
+            if self.silent:
+                self.indicator.set_status(AppIndicator3.IndicatorStatus.PASSIVE)
+            else:
+                self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+
+        def hide_it(self):
+            self.indicator.set_status(AppIndicator3.IndicatorStatus.PASSIVE)
+
+        def show_it(self):
+            self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+
+        def on_menuitem_pause_activate(self, menuitem):
+            if menuitem.get_active():
+                self.indicator.set_attention_icon("kazam-paused")
+                logger.debug("Recording paused.")
+            else:
+                self.indicator.set_attention_icon("kazam-recording")
+                logger.debug("Recording resumed.")
+            KazamSuperIndicator.on_menuitem_pause_activate(self, menuitem)
+
+        def on_menuitem_finish_activate(self, menuitem):
+            logger.debug("Recording stopped.")
+            if not self.silent:
+                self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+            KazamSuperIndicator.on_menuitem_finish_activate(self, menuitem)
+
+        def blink_set_state(self, state):
+            if state == BLINK_STOP:
+                self.blink_state = BLINK_STOP
+                self.indicator.set_icon("kazam-stopped")
+            elif state == BLINK_START:
+                self.blink_state = BLINK_SLOW
+                GObject.timeout_add(500, self.blink)
+            elif state == BLINK_SLOW:
+                self.blink_state = BLINK_SLOW
+            elif state == BLINK_FAST:
+                self.blink_state = BLINK_FAST
+
+        def blink(self):
+            if self.blink_state != BLINK_STOP:
+                if self.blink_icon == BLINK_READY_ICON:
+                    if not self.silent:
+                        self.indicator.set_icon("kazam-stopped")
+                    self.blink_icon = BLINK_STOP_ICON
+                else:
+                    if not self.silent:
+                        self.indicator.set_icon("kazam-countdown")
+                    self.blink_icon = BLINK_READY_ICON
+
+                if self.blink_state == BLINK_SLOW:
+                    GObject.timeout_add(500, self.blink)
+                elif self.blink_state == BLINK_FAST:
+                    GObject.timeout_add(200, self.blink)
+
+        def start_recording(self):
+            logger.debug("Recording started.")
+            if not self.silent:
+                self.indicator.set_status(AppIndicator3.IndicatorStatus.ATTENTION)
+
+except ImportError:
+    #
+    # AppIndicator failed to import, not running Ubuntu?
+    # Fallback to Gtk.StatusIcon.
+    #
+    class KazamIndicator(KazamSuperIndicator):
+
+        def __init__(self, silent = False):
+            super(KazamIndicator, self).__init__()
+            self.silent = silent
+
+            self.indicator = Gtk.StatusIcon()
+            self.indicator.set_from_icon_name("kazam-stopped")
+            self.indicator.connect("popup-menu", self.cb_indicator_popup_menu)
+            self.indicator.connect("activate", self.cb_indicator_activate)
+
+            if self.silent:
+                self.indicator.set_visible(False)
+
+        def cb_indicator_activate(self, widget):
+            def position(menu, widget):
+		        return (Gtk.StatusIcon.position_menu(self.menu, widget))
+            self.menu.popup(None, None, position, self.indicator, 0, Gtk.get_current_event_time())
+
+        def cb_indicator_popup_menu(self, icon, button, time):
+            def position(menu, icon):
+		        return (Gtk.StatusIcon.position_menu(self.menu, icon))
+            self.menu.popup(None, None, position, self.indicator, button, time)
+
+        def on_menuitem_finish_activate(self, menuitem):
+            logger.debug("Recording stopped.")
+            self.indicator.set_from_icon_name("kazam-stopped")
+            KazamSuperIndicator.on_menuitem_finish_activate(self, menuitem)
+
+        def on_menuitem_pause_activate(self, menuitem):
+            if menuitem.get_active():
+                self.indicator.set_from_icon_name("kazam-paused")
+                logger.debug("Recording paused.")
+            else:
+                self.indicator.set_from_icon_name("kazam-recording")
+                logger.debug("Recording resumed.")
+            KazamSuperIndicator.on_menuitem_pause_activate(self, menuitem)
+
+        def blink_set_state(self, state):
+            if state == BLINK_STOP:
+                self.blink_state = BLINK_STOP
+                self.indicator.set_from_icon_name("kazam-stopped")
+            elif state == BLINK_START:
+                self.blink_state = BLINK_SLOW
+                GObject.timeout_add(500, self.blink)
+            elif state == BLINK_SLOW:
+                self.blink_state = BLINK_SLOW
+            elif state == BLINK_FAST:
+                self.blink_state = BLINK_FAST
+
+        def blink(self):
+            if self.blink_state != BLINK_STOP:
+                if self.blink_icon == BLINK_READY_ICON:
+                    self.indicator.set_from_icon_name("kazam-stopped")
+                    self.blink_icon = BLINK_STOP_ICON
+                else:
+                    self.indicator.set_from_icon_name("kazam-countdown")
+                    self.blink_icon = BLINK_READY_ICON
+
+                if self.blink_state == BLINK_SLOW:
+                    GObject.timeout_add(500, self.blink)
+                elif self.blink_state == BLINK_FAST:
+                    GObject.timeout_add(200, self.blink)
+
+        def start_recording(self):
+            logger.debug("Recording started.")
+            self.indicator.set_from_icon_name("kazam-recording")

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/main_menu.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/main_menu.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/main_menu.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+#
+#       main_menu.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+from gettext import gettext as _
+
+from gi.repository import Gtk, GObject
+
+MENUBAR = """
+    <ui>
+        <menubar name='MenuBar'>
+            <menu action='FileMenu'>
+                <menuitem action='FilePreferences' />
+                <menuitem action='FileQuit' />
+            </menu>
+            <separator />
+            <menu action='HelpMenu'>
+                <menuitem action='HelpAbout' />
+            </menu>
+        </menubar>
+</ui>
+"""
+
+class MainMenu(GObject.GObject):
+    __gsignals__ = {
+        "file-preferences" : (GObject.SIGNAL_RUN_LAST,
+                              None,
+                              (),
+                             ),
+        "file-quit" : (GObject.SIGNAL_RUN_LAST,
+                           None,
+                           (),
+                           ),
+        "help-about" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                             (),
+                             ),
+    }
+
+    def __init__(self):
+        GObject.GObject.__init__(self)
+
+        self.action_group = Gtk.ActionGroup("kazam_actions")
+        self.action_group.add_actions([
+                ("FileMenu", None, _("File")),
+                ("FileQuit", Gtk.STOCK_QUIT, _("Quit"), None, _("Quit Kazam"),
+                               self.cb_file_quit),
+                ("FilePreferences", Gtk.STOCK_PREFERENCES, _("Preferences"), None, _("Open preferences"),
+                               self.cb_file_preferences),
+                ("HelpMenu", None, _("Help")),
+                ("HelpAbout", None, _("About"), None , _("About Kazam"),
+                              self.cb_help_about)
+            ])
+
+        self.uimanager = Gtk.UIManager()
+        self.uimanager.add_ui_from_string(MENUBAR)
+        self.uimanager.insert_action_group(self.action_group)
+        self.menubar = self.uimanager.get_widget("/MenuBar")
+
+
+    def cb_file_quit(self, action):
+        self.emit("file-quit")
+
+    def cb_file_preferences(self, action):
+        self.emit("file-preferences")
+
+    def cb_help_about(self, action):
+        self.emit("help-about")
+
+
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/preferences.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/preferences.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/preferences.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+#
+#       preferences.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import math
+import logging
+logger = logging.getLogger("Preferences")
+
+from gi.repository import Gtk, Gdk, GObject, Pango
+from gettext import gettext as _
+
+from kazam.utils import *
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+from kazam.backend.gstreamer import detect_codecs, get_codec
+
+class Preferences(GObject.GObject):
+    __gsignals__ = {
+        "prefs-quit" : (GObject.SIGNAL_RUN_LAST,
+                        None,
+                        (),
+            ),
+        }
+
+    def __init__(self):
+        GObject.GObject.__init__(self)
+        logger.debug("Preferences Init.")
+        #
+        # Setup UI
+        #
+        logger.debug("Preferences UI setup.")
+
+        self.audio_source_info = None
+        self.audio2_source_info = None
+
+        self.builder = Gtk.Builder()
+        self.builder.add_from_file(os.path.join(prefs.datadir, "ui", "preferences.ui"))
+        self.builder.connect_signals(self)
+        for w in self.builder.get_objects():
+            if issubclass(type(w), Gtk.Buildable):
+                name = Gtk.Buildable.get_name(w)
+                setattr(self, name, w)
+            else:
+                logger.debug("Unable to get name for '%s'" % w)
+
+        codec_renderer = Gtk.CellRendererText()
+
+        audio_renderer = Gtk.CellRendererText()
+        audio_renderer.props.ellipsize = Pango.EllipsizeMode.END
+        audio_renderer.props.max_width_chars = 40
+
+        self.combobox_codec.pack_start(codec_renderer, True)
+        self.combobox_codec.add_attribute(codec_renderer, "text", 1)
+
+        self.combobox_audio.pack_start(audio_renderer, True)
+        self.combobox_audio.add_attribute(audio_renderer, "text", 0)
+
+        self.combobox_audio2.pack_start(audio_renderer, True)
+        self.combobox_audio2.add_attribute(audio_renderer, "text", 0)
+
+        self.filechooser_video.set_current_folder(prefs.video_dest)
+
+        self.populate_codecs()
+        self.populate_audio_sources()
+        self.populate_shutter_sounds()
+
+        self.restore_UI()
+
+    def open(self):
+        self.window.show_all()
+
+    def is_separator(self, model, iter, data):
+        if model.get_value(iter, 0) == 99:
+            return True
+        return False
+
+    def populate_codecs(self):
+        #
+        # Is this necessary?
+        #
+        old_model = self.combobox_codec.get_model()
+        old_model = None
+
+        codec_model = Gtk.ListStore(int, str)
+        codecs = detect_codecs()
+
+        #
+        # I'm sure this could be done without going through the list twice, right?
+        # Fist, we add basic codecs, then a dummy separator item and then advanced codecs.
+        #
+
+        for codec in codecs:
+            if not CODEC_LIST[codec][4]:
+                codec_model.append([CODEC_LIST[codec][0], CODEC_LIST[codec][2]])
+
+        codec_model.append([99, "--"]) # Insert dummy item for separator
+
+        for codec in codecs:
+            if CODEC_LIST[codec][4]:
+                codec_model.append([CODEC_LIST[codec][0], CODEC_LIST[codec][2]])
+
+        self.combobox_codec.set_model(codec_model)
+        self.combobox_codec.set_row_separator_func(self.is_separator, None)
+
+    def populate_audio_sources(self):
+        audio_source_model = Gtk.ListStore(str)
+        for source in prefs.audio_sources:
+            audio_source_model.append([source[2]])
+
+        self.combobox_audio.set_model(audio_source_model)
+        self.combobox_audio2.set_model(audio_source_model)
+
+    def populate_shutter_sounds(self):
+        for file in prefs.sound_files:
+            self.combobox_shutter_type.append(None, file[:-4])
+
+    def restore_UI(self):
+        logger.debug("Restoring UI.")
+
+        if prefs.sound:
+            self.combobox_audio.set_active(prefs.audio_source)
+            self.combobox_audio2.set_active(prefs.audio2_source)
+        else:
+            self.combobox_audio.set_sensitive(False)
+            self.combobox_audio2.set_sensitive(False)
+            self.volumebutton_audio.set_sensitive(False)
+            self.volumebutton_audio2.set_sensitive(False)
+
+        if prefs.countdown_splash:
+            self.switch_countdown_splash.set_active(True)
+        else:
+            self.switch_countdown_splash.set_active(False)
+
+        self.spinbutton_framerate.set_value(prefs.framerate)
+
+        if prefs.autosave_video:
+            self.switch_autosave_video.set_active(True)
+            self.filechooser_video.set_sensitive(True)
+            self.entry_autosave_video.set_sensitive(True)
+        else:
+            self.switch_autosave_video.set_active(False)
+            self.filechooser_video.set_sensitive(False)
+            self.entry_autosave_video.set_sensitive(False)
+
+        self.entry_autosave_video.set_text(prefs.autosave_video_file)
+
+        self.filechooser_video.set_current_folder(prefs.video_dest)
+
+
+        if prefs.shutter_sound:
+            self.switch_shutter_sound.set_active(True)
+            self.combobox_shutter_type.set_sensitive(True)
+        else:
+            self.switch_shutter_sound.set_active(False)
+            self.combobox_shutter_type.set_sensitive(False)
+
+        self.combobox_shutter_type.set_active(prefs.shutter_type)
+
+        if prefs.autosave_picture:
+            self.switch_autosave_picture.set_active(True)
+            self.filechooser_picture.set_sensitive(True)
+            self.entry_autosave_picture.set_sensitive(True)
+
+        else:
+            self.switch_autosave_picture.set_active(False)
+            self.filechooser_picture.set_sensitive(False)
+            self.entry_autosave_picture.set_sensitive(False)
+
+        self.entry_autosave_picture.set_text(prefs.autosave_picture_file)
+
+        self.filechooser_picture.set_current_folder(prefs.picture_dest)
+
+
+        #
+        # Crappy code below ... Can this be done some other way?
+        #
+        codec_model = self.combobox_codec.get_model()
+        cnt = 0
+        bingo = False
+        for entry in codec_model:
+            if prefs.codec == entry[0]:
+                bingo = True
+                break
+            cnt += 1
+        if not bingo:
+            cnt = 0
+
+        #
+        # No, I wasn't kidding ...
+        #
+        codec_iter = codec_model.get_iter(cnt)
+        self.combobox_codec.set_active_iter(codec_iter)
+        prefs.codec = codec_model.get_value(codec_iter, 0)
+
+    #
+    # General callbacks
+    #
+
+    def cb_delete_event(self, widget, user_data):
+        logger.debug("Deleteting preferences window")
+        self.emit("prefs-quit")
+
+    def cb_switch_countdown_splash(self, widget, user_data):
+        prefs.countdown_splash = widget.get_active()
+        logger.debug("Countdown splash: {0}.".format(prefs.countdown_splash))
+
+    def cb_audio_changed(self, widget):
+        logger.debug("Audio Changed.")
+        prefs.audio_source = self.combobox_audio.get_active()
+        logger.debug("  - A_1 {0}".format(prefs.audio_source))
+
+        pa_audio_idx =  prefs.audio_sources[prefs.audio_source][0]
+        prefs.pa_q.set_source_mute_by_index(pa_audio_idx, 0)
+
+        logger.debug("  - PA Audio1 IDX: {0}".format(pa_audio_idx))
+        self.audio_source_info = prefs.pa_q.get_source_info_by_index(pa_audio_idx)
+        if len(self.audio_source_info) > 0:
+            val = prefs.pa_q.cvolume_to_dB(self.audio_source_info[2])
+            if math.isinf(val):
+                vol = 0
+            else:
+                vol = 60 + val
+            self.volumebutton_audio.set_value(vol)
+        else:
+            logger.debug("Error getting volume info for Audio 1")
+        if len(self.audio_source_info):
+           logger.debug("New Audio1: {0}".format(self.audio_source_info[3]))
+        else:
+            logger.debug("New Audio1: Error retrieving data.")
+
+        if prefs.audio_source == prefs.audio2_source:
+            if prefs.audio_source < len(prefs.audio_sources) - 1:
+                prefs.audio2_source += 1
+            else:
+                prefs.audio2_source = 0
+            self.combobox_audio2.set_active(prefs.audio2_source)
+
+    def cb_audio2_changed(self, widget):
+        logger.debug("Audio2 Changed.")
+
+        prefs.audio2_source = self.combobox_audio2.get_active()
+        logger.debug("  - A_2 {0}".format(prefs.audio2_source))
+
+        pa_audio2_idx =  prefs.audio_sources[prefs.audio2_source][0]
+        prefs.pa_q.set_source_mute_by_index(pa_audio2_idx, 0)
+
+        logger.debug("  - PA Audio2 IDX: {0}".format(pa_audio2_idx))
+        self.audio2_source_info = prefs.pa_q.get_source_info_by_index(pa_audio2_idx)
+
+        if len(self.audio2_source_info) > 0:
+            val = prefs.pa_q.cvolume_to_dB(self.audio2_source_info[2])
+            if math.isinf(val):
+                vol = 0
+            else:
+                vol = 60 + val
+            self.volumebutton_audio2.set_value(vol)
+        else:
+            logger.debug("Error getting volume info for Audio 1")
+
+        if len(self.audio2_source_info):
+            logger.debug("New Audio2:\n  {0}".format(self.audio2_source_info[3]))
+        else:
+            logger.debug("New Audio2:\n  Error retrieving data.")
+
+        if prefs.audio_source == prefs.audio2_source:
+            if prefs.audio_source < len(prefs.audio_sources) - 1:
+                prefs.audio2_source += 1
+            else:
+                prefs.audio2_source = 0
+            self.combobox_audio2.set_active(prefs.audio2_source)
+
+    def cb_volume_changed(self, widget, value):
+        logger.debug("Volume 1 changed, new value: {0}".format(value))
+        idx = self.combobox_audio.get_active()
+        pa_idx =  prefs.audio_sources[idx][0]
+        chn = self.audio_source_info[2].channels
+        cvol = prefs.pa_q.dB_to_cvolume(chn, value-60)
+        prefs.pa_q.set_source_volume_by_index(pa_idx, cvol)
+
+    def cb_volume2_changed(self, widget, value):
+        logger.debug("Volume 2 changed, new value: {0}".format(value))
+        idx = self.combobox_audio2.get_active()
+        pa_idx =  prefs.audio_sources[idx][0]
+        chn = self.audio_source_info[2].channels
+        cvol = prefs.pa_q.dB_to_cvolume(chn, value-60)
+        prefs.pa_q.set_source_volume_by_index(pa_idx, cvol)
+
+    #
+    # Screencasting callbacks
+    #
+
+    def cb_spinbutton_framerate_change(self, widget):
+        prefs.framerate = widget.get_value_as_int()
+        logger.debug("Framerate now: {0}".format(prefs.framerate))
+
+    def cb_codec_changed(self, widget):
+        i = widget.get_active()
+        model = widget.get_model()
+        iter = model.get_iter(i)
+        prefs.codec = model.get_value(iter, 0)
+        logger.debug('Codec selected: {0} - {1}'.format(get_codec(prefs.codec)[2], prefs.codec))
+
+    def cb_switch_autosave_video(self, widget, user_data):
+        prefs.autosave_video = widget.get_active()
+        logger.debug("Autosave for Video: {0}.".format(prefs.autosave_video))
+
+        if prefs.autosave_video:
+            self.filechooser_video.set_sensitive(True)
+            self.entry_autosave_video.set_sensitive(True)
+        else:
+            self.filechooser_video.set_sensitive(False)
+            self.entry_autosave_video.set_sensitive(False)
+
+    def cb_filechooser_video(self, widget):
+        prefs.video_dest = self.filechooser_video.get_current_folder()
+        logger.debug("Video folder set to: {0}".format(prefs.video_dest))
+
+    def cb_entry_autosave_video(self, widget):
+        prefs.autosave_video_file = widget.get_text()
+        logger.debug("Video autosave file set to: {0}".format(prefs.autosave_video_file))
+
+    #
+    # Screenshot callbacks
+    #
+
+    def cb_switch_shutter_sound(self, widget, user_data):
+        prefs.shutter_sound = widget.get_active()
+        logger.debug("Shutter sound: {0}.".format(prefs.shutter_sound))
+
+        if prefs.shutter_sound:
+            self.combobox_shutter_type.set_sensitive(True)
+        else:
+            self.combobox_shutter_type.set_sensitive(False)
+
+    def cb_shutter_type(self, widget):
+        prefs.shutter_type = self.combobox_shutter_type.get_active()
+        logger.debug("Shutter type set to: {0} - {1}".format(prefs.shutter_type, prefs.shutter_sound_file))
+
+    def cb_switch_autosave_picture(self, widget, user_data):
+        prefs.autosave_picture = widget.get_active()
+        logger.debug("Autosave for Picture: {0}.".format(prefs.autosave_picture))
+
+        if prefs.autosave_picture:
+            self.filechooser_picture.set_sensitive(True)
+            self.entry_autosave_picture.set_sensitive(True)
+        else:
+            self.filechooser_picture.set_sensitive(False)
+            self.entry_autosave_picture.set_sensitive(False)
+
+    def cb_filechooser_picture(self, widget):
+        prefs.picture_dest = self.filechooser_picture.get_current_folder()
+        logger.debug("Picture folder set to: {0}".format(prefs.picture_dest))
+
+    def cb_entry_autosave_picture(self, widget):
+        prefs.autosave_picture_file = widget.get_text()
+        logger.debug("Picture autosave file set to: {0}".format(prefs.autosave_picture_file))
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/save_dialog.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/save_dialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/save_dialog.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+#       save_dialog.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import os
+import logging
+logger = logging.getLogger("Save Dialog")
+
+from gi.repository import Gtk
+from gettext import gettext as _
+from datetime import datetime
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+
+def SaveDialog(title, old_path, codec, main_mode=MODE_SCREENCAST):
+    logger.debug("Save dialog called.")
+    dialog = Gtk.FileChooserDialog(title, None,
+                                   Gtk.FileChooserAction.SAVE,
+                                   (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                                   _("Save"), Gtk.ResponseType.OK))
+
+
+    dt = datetime.today().strftime("%Y-%m-%d %H:%M:%S")
+    if main_mode == MODE_SCREENCAST:
+        dialog.set_current_name("{0} {1}{2}".format(_("Screencast"), dt, CODEC_LIST[codec][3]))
+    elif main_mode == MODE_SCREENSHOT:
+        dialog.set_current_name("{0} {1}.png".format(_("Screenshot"), dt))
+
+    dialog.set_do_overwrite_confirmation(True)
+
+    if old_path and os.path.isdir(old_path):
+            dialog.set_current_folder(old_path)
+    else:
+        if main_mode == MODE_SCREENCAST:
+            dialog.set_current_folder(prefs.video_dest)
+        elif main_mode == MODE_SCREENSHOT:
+            dialog.set_current_folder(prefs.picture_dest)
+
+
+    dialog.show_all()
+    result = dialog.run()
+    old_path = dialog.get_current_folder()
+    return dialog, result, old_path
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/widgets.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/widgets.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/widgets.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+#       widgets.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+from gi.repository import Gtk, Gdk, Pango, GObject, GdkPixbuf
+
+class _Tile(object):
+    def __init__(self):
+        self.set_focus_on_click(False)
+        self.set_relief(Gtk.ReliefStyle.NONE)
+        self.box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
+        self.box.set_size_request(62, -1)
+        self.add(self.box)
+
+    def create_default(self, label, icon):
+        if icon is not None:
+            if isinstance(icon, Gtk.Image):
+                self.image = icon
+            else:
+                self.image = Gtk.Image()
+            self.box.pack_start(self.image, True, True, 0)
+
+        self.label = Gtk.Label.new(label)
+        self.box.pack_start(self.label, True, True, 0)
+
+class TileToggleButton(Gtk.RadioButton, _Tile):
+    def __init__(self):
+        Gtk.RadioButton.__init__(self)
+        self.set_mode(False)
+        _Tile.__init__(self)
+
+class ModeButton(TileToggleButton):
+    def __init__(self, label, icon):
+        TileToggleButton.__init__(self)
+        html = "<small>%s</small>" % label
+        self.create_default(html, icon)
+        self.label.set_use_markup(True)
+        self.label.set_justify(Gtk.Justification.CENTER)
+
+    #def do_draw(self, cr):
+        #for child in self:
+        #    self.propagate_draw(child, cr)
+

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/window_area.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/window_area.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/window_area.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+#
+#       window_select.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import time
+import cairo
+import logging
+logger = logging.getLogger("Window Select")
+
+from gettext import gettext as _
+
+from gi.repository import Gtk, GObject, Gdk, Wnck, GdkX11
+
+from kazam.backend.constants import *
+class AreaWindow(GObject.GObject):
+
+    __gsignals__ = {
+        "area-selected" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+        "area-canceled" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+    }
+
+    def __init__(self):
+        super(AreaWindow, self).__init__()
+        logger.debug("Initializing select window.")
+
+        self.startx = 0
+        self.starty = 0
+        self.endx = 0
+        self.endy = 0
+        self.height = 0
+        self.width = 0
+
+        self.window = Gtk.Window()
+        self.box = Gtk.Box()
+        self.drawing = Gtk.DrawingArea()
+        self.box.pack_start(self.drawing, True, True, 0)
+        self.drawing.set_size_request(500, 500)
+        self.window.add(self.box)
+
+        self.window.connect("delete-event", Gtk.main_quit)
+        self.window.connect("key-press-event", self.cb_keypress_event)
+
+        self.drawing.connect("draw", self.cb_draw)
+        self.drawing.connect("motion-notify-event", self.cb_draw_motion_notify_event)
+        self.drawing.connect("button-press-event", self.cb_draw_button_press_event)
+        self.drawing.connect("leave-notify-event", self.cb_leave_notify_event)
+        self.drawing.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.POINTER_MOTION_HINT_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK)
+
+        self.window.set_border_width(0)
+        self.window.set_app_paintable(True)
+        self.window.set_has_resize_grip(False)
+        self.window.set_resizable(True)
+        self.window.set_decorated(False)
+        self.window.set_property("skip-taskbar-hint", True)
+        self.window.set_keep_above(True)
+        self.screen = self.window.get_screen()
+        self.visual = self.screen.get_rgba_visual()
+
+        self.disp = GdkX11.X11Display.get_default()
+        self.dm = Gdk.Display.get_device_manager(self.disp)
+        self.pntr_device = self.dm.get_client_pointer()
+
+        if self.visual is not None and self.screen.is_composited():
+            logger.debug("Compositing window manager detected.")
+            self.window.set_visual(self.visual)
+            self.compositing = True
+        else:
+            self.compositing = False
+
+        (scr, x, y) = self.pntr_device.get_position()
+        cur = scr.get_monitor_at_point(x, y)
+        self.window.move(HW.screens[cur]['x'],
+                         HW.screens[cur]['y'])
+        self.window.fullscreen()
+
+        crosshair_cursor = Gdk.Cursor(Gdk.CursorType.CROSSHAIR)
+        self.last_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR)
+        self.gdk_win = self.window.get_root_window()
+        self.gdk_win.set_cursor(crosshair_cursor)
+
+    def cb_draw_motion_notify_event(self, widget, event):
+        (state, x, y, mask) = event.window.get_device_position(self.pntr_device)
+        if mask & Gdk.ModifierType.BUTTON1_MASK:
+            self.endx = int(event.x)
+            self.endy = int(event.y)
+            self.width  = self.endx - self.startx
+            self.height = self.endy - self.starty
+        widget.queue_draw()
+        return True
+
+    def cb_draw_button_press_event(self, widget, event):
+        self.startx = int(event.x)
+        self.starty = int(event.y)
+        self.endx = 0
+        self.endy = 0
+        self.width  = 0
+        self.height = 0
+
+    def cb_leave_notify_event(self, widget, event):
+        (scr, x, y) = self.pntr_device.get_position()
+        cur = scr.get_monitor_at_point(x, y)
+        self.window.unfullscreen()
+        self.window.move(HW.screens[cur]['x'],
+                         HW.screens[cur]['y'])
+        self.window.fullscreen()
+        logger.debug("Move to X: {0} Y: {1}".format(HW.screens[cur]['x'], HW.screens[cur]['y']))
+        return True
+
+    def cb_keypress_event(self, widget, event):
+        (op, keycode) = event.get_keycode()
+        self.gdk_win.set_cursor(self.last_cursor)
+        if keycode == 36 or keycode == 104: # Enter
+            self.window.hide()
+            self.width = abs(self.width)
+            self.height = abs(self.height)
+            self.emit("area-selected")
+        elif keycode == 9: # ESC
+            self.window.hide()
+            self.emit("area-canceled")
+
+    def cb_draw(self, widget, cr):
+        (w, h) = self.window.get_size()
+
+        if self.compositing:
+            cr.set_source_rgba(0.0, 0.0, 0.0, 0.45)
+        else:
+            cr.set_source_rgb(0.5, 0.5, 0.5)
+
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+
+        # Draw the selection area
+        cr.move_to(self.startx, self.starty)
+        cr.set_source_rgb(1.0, 0.0, 0.0)
+        cr.rectangle(self.startx, self.starty, self.width, self.height)
+        cr.stroke()
+
+        if self.compositing:
+            cr.set_source_rgba(0.0, 0.0, 0.0, 0.0)
+        else:
+            cr.set_source_rgb(0.0, 0.0, 0.0)
+
+        cr.rectangle(self.startx, self.starty, self.width, self.height)
+        cr.fill()
+
+        cr.set_operator(cairo.OPERATOR_OVER)
+
+        self._outline_text(cr, w, h, 30, _("Select an area by clicking and dragging."))
+        self._outline_text(cr, w, h + 50, 26, _("Press ENTER to confirm or ESC to cancel"))
+
+        self._outline_text(cr, w, h + 100, 20, "({0} x {1})".format(abs(self.height), abs(self.height)))
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+
+    def _outline_text(self, cr, w, h, size, text):
+        cr.set_font_size(size)
+        try:
+            cr.select_font_face("Ubuntu", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
+        except:
+            pass
+        te = cr.text_extents(text)
+        cr.set_line_width(2.0)
+        cx = w/2 - te[2]/2
+        cy = h/2 - te[3]/2
+        if self.compositing:
+            cr.set_source_rgba(0.4, 0.4, 0.4, 1.0)
+        else:
+            cr.set_source_rgb(0.4, 0.4, 0.4)
+
+        cr.move_to(cx, cy)
+        cr.text_path(text)
+        cr.stroke()
+        if self.compositing:
+            cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        else:
+            cr.set_source_rgb(1.0, 1.0, 1.0)
+        cr.move_to(cx, cy)
+        cr.show_text(text)

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/window_countdown.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/window_countdown.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/window_countdown.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+#
+#       window_countdown.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import cairo
+
+from gettext import gettext as _
+from gi.repository import Gtk, GObject
+from kazam.backend.constants import *
+
+class CountdownWindow(GObject.GObject):
+
+    __gsignals__ = {
+        "counter-finished" : (GObject.SIGNAL_RUN_LAST,
+                                   None,
+                                   (),
+                                  ),
+    }
+
+    def __init__(self, indicator, number = 5, show_window = True):
+        super(CountdownWindow, self).__init__()
+        self.indicator = indicator
+        self.number = number
+        self.canceled = False
+        self.show_window = show_window
+
+        self.window = Gtk.Window()
+        self.window.connect("delete-event", Gtk.main_quit)
+        self.window.connect("draw", self.cb_draw)
+        self.width = 600
+        self.height = 240
+        self.window.set_default_geometry(self.height, self.width)
+        self.window.set_default_size(self.width, self.height)
+        self.window.set_position(Gtk.WindowPosition.CENTER)
+        self.window.set_app_paintable(True)
+        self.window.set_has_resize_grip(False)
+        self.window.set_resizable(True)
+
+        self.window.set_decorated(False)
+        self.window.set_property("skip-taskbar-hint", True)
+        self.window.set_keep_above(True)
+        self.screen = self.window.get_screen()
+        self.visual = self.screen.get_rgba_visual()
+
+        if self.visual is not None and self.screen.is_composited():
+            self.window.set_visual(self.visual)
+
+
+    def run(self, counter):
+        if counter > 0:
+            self.number = counter + 1
+            if self.show_window:
+                self.window.show_all()
+        else:
+            self.number = 0
+        self.countdown()
+
+    def countdown(self):
+        if not self.canceled:
+            if self.number < 5:
+                self.indicator.blink_set_state(BLINK_FAST)
+            if self.number > 1:
+                self.window.queue_draw()
+                GObject.timeout_add(1000, self.countdown)
+                self.number -= 1
+            else:
+                self.window.destroy()
+                GObject.timeout_add(400, self.counter_finished)
+
+    def cancel_countdown(self):
+        self.indicator.blink_set_state(BLINK_STOP)
+        self.canceled = True
+        self.window.destroy()
+        self.number = 0
+
+    def counter_finished(self):
+        self.emit("counter-finished")
+        return False
+
+    def cb_draw(self, widget, cr):
+        w = self.width
+        h = self.height
+        cr.set_source_rgba(1, 1, 1, 0)
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        self._draw_rounded(cr, 1, 1, w - 10, h - 10, 20)
+        cr.set_line_width(1.0)
+        cr.set_source_rgba(0.0, 0.0, 0.0, 0.4)
+        cr.stroke_preserve()
+        cr.fill()
+        cr.set_operator(cairo.OPERATOR_OVER)
+        self._outline_text(cr, w, h, 36, _("Recording will start in ..."))
+        self._outline_text(cr, w, h + 70, 36, _("{0}".format(self.number)))
+
+    def _draw_rounded(self, cr, x, y, w, h, r = 20):
+        cr.move_to(x + r, y)
+        cr.line_to(x + w - r, y)
+        cr.curve_to(x + w,y,x+w,y,x+w,y+r)
+        cr.line_to(x + w,y+h-r)
+        cr.curve_to(x + w, y + h, x + w, y + h, x + w - r, y + h)
+        cr.line_to(x + r, y + h)
+        cr.curve_to(x, y + h, x, y + h, x, y + h - r)
+        cr.line_to(x, y + r)
+        cr.curve_to(x, y, x, y, x + r, y)
+
+    def _outline_text(self, cr, w, h, size, text):
+        cr.set_font_size(size)
+        try:
+            cr.select_font_face("Ubuntu", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
+        except:
+            pass
+        te = cr.text_extents(text)
+        cr.set_source_rgba(0.4, 0.4, 0.4, 1.0)
+        cr.set_line_width(2.0)
+        cx = w/2 - te[2]/2
+        cy = h/2 - te[3]/2
+        cr.move_to(cx, cy)
+        cr.text_path(text)
+        cr.stroke()
+        cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        cr.move_to(cx, cy)
+        cr.show_text(text)

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/window_region.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/window_region.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/window_region.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+#
+#       window_region.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import cairo
+import logging
+logger = logging.getLogger("Window Region")
+
+from gettext import gettext as _
+
+from gi.repository import Gtk, GObject, Gdk
+
+class RegionWindow(GObject.GObject):
+
+    __gsignals__ = {
+        "region-selected" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+        "region-canceled" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+    }
+
+    def __init__(self, region = None):
+        super(RegionWindow, self).__init__()
+        logger.debug("Initializing region window.")
+        self.window = Gtk.Window()
+        self.window.connect("configure-event", self.cb_configure_event)
+        self.window.connect("delete-event", Gtk.main_quit)
+        self.window.connect("draw", self.cb_draw)
+        self.window.connect("key-press-event", self.cb_keypress_event)
+        self.window.connect("button-press-event", self.cb_button_press_event)
+
+        if region:
+            logger.debug("Old region defined at: X: {0}, Y: {1}, W: {2}, H: {3}".format(region[0],
+                                                                                          region[1],
+                                                                                          region[2],
+                                                                                          region[3]))
+            self.startx = region[0]
+            self.starty = region[1]
+            self.endx = region[2]
+            self.endy = region[3]
+            self.window.move(self.startx, self.starty)
+        else:
+            self.startx = 0
+            self.starty = 0
+            self.endx = 640
+            self.endy = 480
+            self.window.set_position(Gtk.WindowPosition.CENTER)
+
+        self.width = self.endx - self.startx
+        self.height = self.endy - self.starty
+        self.window.set_default_geometry(self.width, self.height)
+
+        self.window.set_border_width(30)
+        self.window.set_app_paintable(True)
+        self.window.set_has_resize_grip(False)
+        self.window.set_resizable(True)
+        self.window.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
+        self.window.set_decorated(False)
+        self.window.set_property("skip-taskbar-hint", True)
+        self.window.set_keep_above(True)
+        self.screen = self.window.get_screen()
+        self.visual = self.screen.get_rgba_visual()
+        self.recording = False
+
+        self.window.set_visual(self.visual)
+        if self.visual is not None and self.screen.is_composited():
+            self.window.show_all()
+
+    def cb_button_press_event(self, widget, event):
+        (op, button) = event.get_button()
+        if button == 1:
+            if int(event.x) in range(0, 15) and int(event.y) in range(0,15):
+                self.window.begin_resize_drag(Gdk.WindowEdge.NORTH_WEST, button,
+                                              event.x_root, event.y_root, event.time)
+
+            elif int(event.x) in range(self.width-15, self.width) and int(event.y) in range(0,15):
+                self.window.begin_resize_drag(Gdk.WindowEdge.NORTH_EAST, button,
+                                              event.x_root, event.y_root, event.time)
+
+            elif int(event.x) in range(self.width-15, self.width) and int(event.y) in range(self.height-15,self.height):
+                self.window.begin_resize_drag(Gdk.WindowEdge.SOUTH_EAST, button,
+                                              event.x_root, event.y_root, event.time)
+
+            elif int(event.x) in range(0, 15) and int(event.y) in range(self.height-15, self.height):
+                self.window.begin_resize_drag(Gdk.WindowEdge.SOUTH_WEST, button,
+                                              event.x_root, event.y_root, event.time)
+
+            else:
+                self.window.begin_move_drag(button, event.x_root, event.y_root, event.time)
+
+    def cb_keypress_event(self, widget, event):
+        (op, keycode) = event.get_keycode()
+        if keycode == 36 or keycode == 104: # Enter
+            self.window.set_default_geometry(self.width, self.height)
+            (self.startx, self.starty) = self.window.get_position()
+            self.endx = self.startx + self.width - 1
+            self.endy = self.starty + self.height - 1
+            self.recording = True
+            self.window.input_shape_combine_region(None)
+            #
+            # When support for masked input is back, remove the hide() call.
+            #
+            self.window.hide()
+            # self.window.queue_draw()
+            self.emit("region-selected")
+        elif keycode == 9: # ESC
+            self.window.hide()
+            self.emit("region-canceled")
+
+
+    def cb_configure_event(self, widget, event):
+        self.width = event.width
+        self.height = event.height
+
+    def cb_draw(self, widget, cr):
+        w = self.width
+        h = self.height
+        #
+        # Drawing a red rectangle around selected area would be extremely nice
+        # however, cairo.Region is missing from GIR and from pycairo and
+        # it is needed for input_shape_combine_region().
+        # See: https://bugs.freedesktop.org/show_bug.cgi?id=44336
+        #
+        #if self.recording:
+        #    cr.set_source_rgba(0.0, 0.0, 0.0, 0.0)
+        #    cr.set_operator(cairo.OPERATOR_SOURCE)
+        #    cr.paint()
+        #    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, w , h)
+        #    surface_ctx = cairo.Context(surface)
+        #    surface_ctx.set_source_rgba(1.0, 1.0, 1.0, 0.0)
+        #    surface_ctx.set_operator(cairo.OPERATOR_SOURCE)
+        #    surface_ctx.paint()
+        #    reg = Gdk.cairo_region_create_from_surface(surface)
+        #    widget.input_shape_combine_region(reg)
+        #    cr.move_to(0, 0)
+        #    cr.set_source_rgb(1.0, 0.0, 0.0)
+        #    cr.set_line_width(2.0)
+        #    cr.rectangle(0, 0, w, h)
+        #    cr.stroke()
+        #    cr.set_operator(cairo.OPERATOR_OVER)
+        #else:
+        cr.set_source_rgba(0.0, 0.0, 0.0, 0.4)
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        cr.set_line_width(1.0)
+        cr.move_to(0, 0)
+        cr.rectangle(0, 0, 15, 15)
+        cr.rectangle(w-15, 0, w, 15)
+        cr.rectangle(0, h-15, 15, h)
+        cr.rectangle(w-15, h-15, w, h)
+        cr.fill()
+        cr.set_source_rgb(0.0, 0.0, 0.0)
+        cr.rectangle(0, 0, w, h)
+        cr.stroke()
+        cr.set_operator(cairo.OPERATOR_OVER)
+        self._outline_text(cr, w, h, 24, _("Select region by resizing the window"))
+        self._outline_text(cr, w, h + 50, 24, _("Press ENTER to confirm or ESC to cancel."))
+        self._outline_text(cr, w, h + 80, 12, "({0} x {1})".format(w, h))
+
+
+    def _outline_text(self, cr, w, h, size, text):
+        cr.set_font_size(size)
+        try:
+            cr.select_font_face("Ubuntu", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
+        except:
+            pass
+        te = cr.text_extents(text)
+        cr.set_line_width(2.0)
+        cx = w/2 - te[2]/2
+        cy = h/2 - te[3]/2
+        cr.set_source_rgba(0.4, 0.4, 0.4, 1.0)
+        cr.move_to(cx, cy)
+        cr.text_path(text)
+        cr.stroke()
+        cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        cr.move_to(cx, cy)
+        cr.show_text(text)

=== added file 'build/lib.linux-x86_64-2.7/kazam/frontend/window_select.py'
--- build/lib.linux-x86_64-2.7/kazam/frontend/window_select.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/frontend/window_select.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+#
+#       window_select.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#       Copyright 2010 Andrew <andrew@karmic-desktop>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import time
+import cairo
+import logging
+logger = logging.getLogger("Window Select")
+
+from gettext import gettext as _
+
+from gi.repository import Gtk, GObject, Gdk, Wnck, GdkX11
+
+from kazam.backend.constants import *
+
+class SelectWindow(GObject.GObject):
+
+    __gsignals__ = {
+        "window-selected" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+        "window-canceled" : (GObject.SIGNAL_RUN_LAST,
+                             None,
+                               (),
+                                ),
+    }
+
+    def __init__(self):
+        super(SelectWindow, self).__init__()
+        logger.debug("Initializing select window.")
+
+        self.xid = None
+
+        self.window = Gtk.Window()
+        self.window.connect("delete-event", Gtk.main_quit)
+        self.window.connect("draw", self.cb_draw)
+        self.window.connect("key-press-event", self.cb_keypress_event)
+        self.window.connect("button-press-event", self.cb_button_press_event)
+        self.window.connect("leave-notify-event", self.cb_leave_notify_event)
+
+        self.window.set_border_width(30)
+        self.window.set_app_paintable(True)
+        self.window.set_has_resize_grip(False)
+        self.window.set_resizable(True)
+        self.window.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK)
+        self.window.set_decorated(False)
+        self.window.set_property("skip-taskbar-hint", True)
+        self.window.set_keep_above(True)
+        self.screen = self.window.get_screen()
+        self.visual = self.screen.get_rgba_visual()
+        self.recording = False
+
+        self.disp = GdkX11.X11Display.get_default()
+        self.dm = Gdk.Display.get_device_manager(self.disp)
+        self.pntr_device = self.dm.get_client_pointer()
+
+        if self.visual is not None and self.screen.is_composited():
+            logger.debug("Compositing window manager detected.")
+            self.window.set_visual(self.visual)
+            self.compositing = True
+        else:
+            self.compositing = False
+
+        (scr, x, y) = self.pntr_device.get_position()
+        cur = scr.get_monitor_at_point(x, y)
+        self.window.unfullscreen()
+        self.window.move(HW.screens[cur]['x'],
+                         HW.screens[cur]['y'])
+        self.window.fullscreen()
+        crosshair_cursor = Gdk.Cursor(Gdk.CursorType.CROSSHAIR)
+        self.last_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR)
+        self.gdk_win = self.window.get_root_window()
+        self.gdk_win.set_cursor(crosshair_cursor)
+
+    def cb_leave_notify_event(self, widget, event):
+        (scr, x, y) = self.pntr_device.get_position()
+        cur = scr.get_monitor_at_point(x, y)
+        self.window.unfullscreen()
+        logger.debug("Move to X: {0} Y: {1}".format(HW.screens[cur]['x'], HW.screens[cur]['y']))
+        self.window.move(HW.screens[cur]['x'],
+                         HW.screens[cur]['y'])
+        self.window.fullscreen()
+
+    def cb_button_press_event(self, widget, event):
+        self.geometry = None
+        self.win_name = None
+        self.xid = None
+        # TODO: Error handling
+        (op, button) = event.get_button()
+        if button == 1:
+            screen = Wnck.Screen.get_default()
+            screen.force_update()
+            workspace = screen.get_active_workspace()
+            wins = screen.get_windows_stacked()
+
+            for win in reversed(wins):
+                if win.is_visible_on_workspace(workspace) and win.is_in_viewport(workspace):
+                    self.win_name = win.get_name()
+                    if not (self.win_name.lower().startswith("kazam") or self.win_name.lower().startswith("desktop")):
+                        geometry = win.get_client_window_geometry()
+                        self.geometry = geometry
+                        if geometry[0] <= event.x_root <= (geometry[0] + geometry[2]) and geometry[1] <= event.y_root <= (geometry[1] + geometry[3]):
+                            self.xid = win.get_xid()
+                            break
+            self.gdk_win.set_cursor(self.last_cursor)
+            self.window.hide()
+            if self.xid:
+                self.emit("window-selected")
+            else:
+                self.emit("window-canceled")
+
+    def cb_keypress_event(self, widget, event):
+        (op, keycode) = event.get_keycode()
+        if keycode == 36 or keycode == 104 or keycode == 9: # Enter or Escape
+            self.gdk_win.set_cursor(self.last_cursor)
+            self.window.hide()
+            self.emit("window-canceled")
+
+    def cb_draw(self, widget, cr):
+        (w, h) = self.window.get_size()
+
+
+        if self.compositing:
+            cr.set_source_rgba(0.0, 0.0, 0.0, 0.45)
+        else:
+            cr.set_source_rgb(0.5, 0.5, 0.5)
+
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        if self.compositing:
+            cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        else:
+            cr.set_source_rgba(1.0, 1.0, 1.0)
+
+        cr.set_operator(cairo.OPERATOR_OVER)
+        self._outline_text(cr, w, h, 30, _("Select a window by clicking on it."))
+        self._outline_text(cr, w, h + 50, 26, _("Press ENTER or ESC to cancel"))
+
+    def _outline_text(self, cr, w, h, size, text):
+        cr.set_font_size(size)
+        try:
+            cr.select_font_face("Ubuntu", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
+        except:
+            pass
+        te = cr.text_extents(text)
+        cr.set_line_width(2.0)
+        cx = w/2 - te[2]/2
+        cy = h/2 - te[3]/2
+        if self.compositing:
+            cr.set_source_rgba(0.4, 0.4, 0.4, 1.0)
+        else:
+            cr.set_source_rgb(0.4, 0.4, 0.4)
+
+        cr.move_to(cx, cy)
+        cr.text_path(text)
+        cr.stroke()
+        if self.compositing:
+            cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
+        else:
+            cr.set_source_rgb(1.0, 1.0, 1.0)
+        cr.move_to(cx, cy)
+        cr.show_text(text)

=== added file 'build/lib.linux-x86_64-2.7/kazam/instant.py'
--- build/lib.linux-x86_64-2.7/kazam/instant.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/kazam/instant.py	2012-11-15 10:17:01 +0000
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#       instant.py
+#
+#       Copyright 2012 David Klasinc <[e-mail]>
+#
+#       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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+import sys
+import logging
+from gettext import gettext as _
+from gi.repository import Gtk, GObject
+
+from kazam.utils import *
+from kazam.backend.prefs import *
+from kazam.backend.constants import *
+from kazam.backend.grabber import Grabber
+
+logger = logging.getLogger("Instant")
+
+class InstantApp(GObject.GObject):
+
+    def __init__(self, datadir, dist, debug, mode, preferences=False):
+        GObject.GObject.__init__(self)
+        logger.debug("Setting variables.{0}".format(datadir))
+
+        self.mode = mode
+        self.take = 0
+
+        prefs.datadir = datadir
+        prefs.debug = debug
+        prefs.dist = dist
+        prefs.get_sound_files()
+
+        if preferences:
+            logger.debug("Preferences requested.")
+            from kazam.frontend.preferences import Preferences
+            from kazam.pulseaudio.pulseaudio import pulseaudio_q
+            prefs.pa_q = pulseaudio_q()
+            prefs.pa_q.start()
+            prefs.get_audio_sources()
+
+            self.preferences_window = Preferences()
+            self.preferences_window.connect("prefs-quit", self.cb_prefs_quit)
+            self.preferences_window.open()
+
+        else:
+            self.old_path = None
+
+            if HW.combined_screen:
+                self.video_source = HW.combined_screen
+            else:
+                screen = HW.get_current_screen()
+                self.video_source = HW.screens[screen]
+
+            self.grabber = Grabber()
+            self.grabber.connect("flush-done", self.cb_flush_done)
+            self.grabber.connect("save-done", self.cb_save_done)
+
+            if self.mode == MODE_AREA:
+                logger.debug("Area ON.")
+                from kazam.frontend.window_area import AreaWindow
+                self.area_window = AreaWindow()
+                self.area_window.connect("area-selected", self.cb_area_selected)
+                self.area_window.connect("area-canceled", self.cb_area_canceled)
+                self.area_window.window.show_all()
+            elif self.mode == MODE_ALL:
+                self.grabber.setup_sources(self.video_source, None, None)
+                logger.debug("Grabbing screen")
+                self.grabber.grab()
+            elif self.mode == MODE_ACTIVE:
+                self.grabber.setup_sources(self.video_source, None, None, active=True)
+                logger.debug("Grabbing screen")
+                self.grabber.grab()
+            elif self.mode == MODE_GOD:
+                logger.debug("Grabbing in god mode.")
+                self.grabber.setup_sources(self.video_source, None, None, god=True)
+                self.grabber.grab()
+                self.grabber.setup_sources(self.video_source, None, None, active=True, god=True)
+                self.grabber.grab()
+            else:
+                sys.exit(0)
+
+    def cb_area_selected(self, widget):
+        logger.debug("Area selected: SX: {0}, SY: {1}, EX: {2}, EY: {3}".format(
+            self.area_window.startx,
+            self.area_window.starty,
+            self.area_window.endx,
+            self.area_window.endy))
+        prefs.area = (self.area_window.startx,
+                      self.area_window.starty,