예제 #1
0
파일: instant.py 프로젝트: zxalif/kazam
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_WIN:
                logger.debug("Window Selection ON.")
                from kazam.frontend.window_select import SelectWindow
                self.select_window = SelectWindow()
                self.select_window.connect("window-selected",
                                           self.cb_window_selected)
                self.select_window.connect("window-canceled",
                                           self.cb_window_canceled)
                self.select_window.window.show_all()
            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,
                      self.area_window.endx, self.area_window.endy,
                      self.area_window.width, self.area_window.height)
        self.grabber.setup_sources(self.video_source, prefs.area, None)
        logger.debug("Grabbing screen")
        self.grabber.grab()

    def cb_area_canceled(self, widget):
        Gtk.main_quit()
        sys.exit(0)

    def cb_window_selected(self, widget):
        xid = self.select_window.xid
        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.grabber.setup_sources(self.video_source, None, xid)
        logger.debug("Grabbing screen")
        self.grabber.grab()

    def cb_window_canceled(self, widget):
        Gtk.main_quit()
        sys.exit(0)

    def cb_flush_done(self, widget):
        if prefs.autosave_picture or self.mode == MODE_GOD:
            fname = get_next_filename(prefs.picture_dest,
                                      prefs.autosave_picture_file, ".png")
            self.grabber.autosave(fname)
        else:
            self.grabber.save_capture(None)

    def cb_save_done(self, widget, result):
        logger.debug("Save Done, result: {0}".format(result))
        self.old_path = result

        if self.take == 1 or self.mode != MODE_GOD:
            Gtk.main_quit()
            sys.exit(0)

        self.take = +1

    def cb_prefs_quit(self, widget):
        logger.debug("Saving settings.")
        prefs.pa_q.end()
        prefs.save_config()
        Gtk.main_quit()
        sys.exit(0)
예제 #2
0
파일: instant.py 프로젝트: zxalif/kazam
    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_WIN:
                logger.debug("Window Selection ON.")
                from kazam.frontend.window_select import SelectWindow
                self.select_window = SelectWindow()
                self.select_window.connect("window-selected",
                                           self.cb_window_selected)
                self.select_window.connect("window-canceled",
                                           self.cb_window_canceled)
                self.select_window.window.show_all()
            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)
예제 #3
0
파일: app.py 프로젝트: hardyoyo/kazam
 def cb_preferences_request(self, indicator):
     logger.debug("Preferences requested.")
     self.preferences_window = Preferences()
     self.preferences_window.open()
예제 #4
0
파일: app.py 프로젝트: hardyoyo/kazam
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 = sound

        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.default_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR)

        # 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.select_window = None
        self.outline_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)

        # Retrieve gdk_win for the root window
        self.gdk_win = self.window.get_root_window()

        #
        # Attach main menu, so that
        #
        self.MainGrid.attach(self.mainmenu.menubar, 0, 0, 1, 1)

        self.main_context = self.toolbar_main.get_style_context()
        self.main_context.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        self.main_context.connect("changed", self.cb_main_context_change)
        self.main_fg_color = self.main_context.get_color(Gtk.StateFlags.ACTIVE)

        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."))
        cast_icon = self.icons.lookup_icon("kazam-screencast-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if cast_icon:
            cast_icon_pixbuf, was_sym = cast_icon.load_symbolic(self.main_fg_color, None, None, None)
            cast_img  = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
            self.btn_cast.set_icon_widget(cast_img)
        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."))
        shot_icon = self.icons.lookup_icon("kazam-screenshot-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if shot_icon:
            shot_icon_pixbuf, was_sym = shot_icon.load_symbolic(self.main_fg_color, None, None, None)
            shot_img  = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
            self.btn_shot.set_icon_widget(shot_img)
        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.aux_context = self.toolbar_aux.get_style_context()
        self.aux_context.add_class(Gtk.STYLE_CLASS_TOOLBAR)
        self.aux_fg_color = self.aux_context.get_color(Gtk.StateFlags.ACTIVE)

        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."))
        full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if full_icon:
            full_icon_pixbuf, was_sym = full_icon.load_symbolic(self.aux_fg_color, None, None, None)
            full_img  = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
            self.btn_full.set_icon_widget(full_img)
        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."))
        allscreens_icon = self.icons.lookup_icon("kazam-all-screens-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if allscreens_icon:
            allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(self.aux_fg_color, None, None, None)
            allscreens_img  = Gtk.Image.new_from_pixbuf(allscreens_icon_pixbuf)
            self.btn_allscreens.set_icon_widget(allscreens_img)
        self.btn_allscreens.set_name("MODE_ALL")
        self.btn_allscreens.connect("toggled", self.cb_record_mode_toggled)
        if HW.combined_screen is None:
            self.btn_allscreens.set_sensitive(False)

        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."))
        window_icon = self.icons.lookup_icon("kazam-window-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if window_icon:
            window_icon_pixbuf, was_sym = window_icon.load_symbolic(self.aux_fg_color, None, None, None)
            window_img  = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
            self.btn_window.set_icon_widget(window_img)
        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."))
        area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if area_icon:
            area_icon_pixbuf, was_sym = area_icon.load_symbolic(self.aux_fg_color, None, None, None)
            area_img  = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
            self.btn_area.set_icon_widget(area_img)
        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)
        self.btn_record.grab_focus()

        #
        # 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()

        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"))
            if self.record_mode == "MODE_WIN":
                self.chk_borders_pic.set_sensitive(True)
            else:
                self.chk_borders_pic.set_sensitive(False)

    #
    # 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
            self.chk_borders_pic.set_sensitive(True)

        if widget.get_name() == "MODE_WIN" and not widget.get_active():
            logger.debug("Window capture OFF.")
            self.chk_borders_pic.set_sensitive(False)
            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

    def cb_main_context_change(self, widget):
        #
        # If this is the only way on how to deal with symbolic icons, then someone needs spanking ...
        #
        if widget.get_state() == Gtk.StateFlags.BACKDROP:
            self.main_fg_color = self.main_context.get_color(Gtk.StateFlags.ACTIVE)
            self.aux_fg_color = self.aux_context.get_color(Gtk.StateFlags.ACTIVE)

            #
            # Update icons on the main toolbar
            #
            cast_icon = self.icons.lookup_icon("kazam-screencast-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if cast_icon:
                cast_icon_pixbuf, was_sym = cast_icon.load_symbolic(self.main_fg_color, None, None, None)
                cast_img = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
                self.btn_cast.set_icon_widget(cast_img)
                cast_img.show_all()

            shot_icon = self.icons.lookup_icon("kazam-screenshot-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if shot_icon:
                shot_icon_pixbuf, was_sym = shot_icon.load_symbolic(self.main_fg_color, None, None, None)
                shot_img = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
                self.btn_shot.set_icon_widget(shot_img)
                shot_img.show_all()

            #
            # Update icons on the aux toolbar
            #
            full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if full_icon:
                full_icon_pixbuf, was_sym = full_icon.load_symbolic(self.aux_fg_color, None, None, None)
                full_img = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
                self.btn_full.set_icon_widget(full_img)
                full_img.show_all()

            allscreens_icon = self.icons.lookup_icon("kazam-all-screens-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if allscreens_icon:
                allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(self.aux_fg_color, None, None, None)
                allscreens_img = Gtk.Image.new_from_pixbuf(allscreens_icon_pixbuf)
                self.btn_allscreens.set_icon_widget(allscreens_img)
                allscreens_img.show_all()

            window_icon = self.icons.lookup_icon("kazam-window-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if window_icon:
                window_icon_pixbuf, was_sym = window_icon.load_symbolic(self.aux_fg_color, None, None, None)
                window_img = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
                self.btn_window.set_icon_widget(window_img)
                window_img.show_all()

            area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if area_icon:
                area_icon_pixbuf, was_sym = area_icon.load_symbolic(self.aux_fg_color, None, None, None)
                area_img = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
                self.btn_area.set_icon_widget(area_img)
                area_img.show_all()

    #
    # 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_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))
        logger.debug("Area selected: GX: {0}, GY: {1}, GX: {2}, GY: {3}".format(
            self.area_window.g_startx,
            self.area_window.g_starty,
            self.area_window.g_endx,
            self.area_window.g_endy))
        prefs.area = (self.area_window.g_startx,
                      self.area_window.g_starty,
                      self.area_window.g_endx,
                      self.area_window.g_endy,
                      self.area_window.width,
                      self.area_window.height)
        self.window.set_sensitive(True)

    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()
        #
        # If 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.")
        # Restore cursor, just in case if by some chance stays set to cross-hairs
        self.gdk_win.set_cursor(self.default_cursor)
        (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.outline_window:
            self.outline_window.hide()
            self.outline_window.window.destroy()
            self.outline_window = None

        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.autosave_video_dir,
                                      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:
            if self.outline_window:
                self.outline_window.hide()
                self.outline_window.window.destroy()
                self.outline_window = None

            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_quit.set_sensitive(True)

            if prefs.autosave_picture:
                fname = get_next_filename(prefs.autosave_picture_dir,
                                          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)
        #
        # Use the current autosave filename for edit file.
        #
        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.")
        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_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:
                try:
                    audio_source = prefs.speaker_sources[prefs.audio_source][1]
                except  IndexError:
                    logger.warning("It appears that speakers audio source isn't set up correctly.")
                    audio_source = None
            else:
                audio_source = None

            if prefs.capture_microphone:
                try:
                    audio2_source = prefs.mic_sources[prefs.audio2_source][1]
                except IndexError:
                    logger.warning("It appears that microphone audio source isn't set up correctly.")
                    audio2_source = None
            else:
                audio2_source = None

        else:
            audio_source = None
            audio2_source = None

        #
        # Get appropriate coordinates for recording
        #

        video_source = None

        if self.record_mode == MODE_ALL:
            video_source = HW.combined_screen
        else:
            screen = HW.get_current_screen(self.window)
            video_source = HW.screens[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()
        try:
            if self.record_mode == MODE_AREA and prefs.area:
                if prefs.dist[0] == 'Ubuntu' and int(prefs.dist[1].split(".")[0]) > 12:
                    logger.debug("Showing recording outline.")
                    self.outline_window = OutlineWindow(prefs.area[0],
                                                        prefs.area[1],
                                                        prefs.area[4],
                                                        prefs.area[5])
                    self.outline_window.show()
                else:
                    logger.debug("Ubuntu 13.04 or higher not detected, recording outline not shown.")
        except:
                logger.debug("Unable to show recording outline.")

    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)
예제 #5
0
    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()

        # configure the reference
        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()

        # do a screen grab
        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_WIN:
                logger.debug("Window Selection ON.")
                from kazam.frontend.window_select import SelectWindow
                self.select_window = SelectWindow()
                self.select_window.connect("window-selected", self.cb_window_selected)
                self.select_window.connect("window-canceled", self.cb_window_canceled)
                self.select_window.window.show_all()
            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)
예제 #6
0
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()

        # configure the reference
        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()

        # do a screen grab
        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_WIN:
                logger.debug("Window Selection ON.")
                from kazam.frontend.window_select import SelectWindow
                self.select_window = SelectWindow()
                self.select_window.connect("window-selected", self.cb_window_selected)
                self.select_window.connect("window-canceled", self.cb_window_canceled)
                self.select_window.window.show_all()
            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,
                      self.area_window.endx,
                      self.area_window.endy,
                      self.area_window.width,
                      self.area_window.height)
        self.grabber.setup_sources(self.video_source, prefs.area, None)
        logger.debug("Grabbing screen")
        self.grabber.grab()

    def cb_area_canceled(self, widget):
        Gtk.main_quit()
        sys.exit(0)

    def cb_window_selected(self, widget):
        xid = self.select_window.xid
        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.grabber.setup_sources(self.video_source, None, xid)
        logger.debug("Grabbing screen")
        self.grabber.grab()

    def cb_window_canceled(self, widget):
        Gtk.main_quit()
        sys.exit(0)

    def cb_flush_done(self, widget):
        if prefs.autosave_picture or self.mode == MODE_GOD:
            fname = get_next_filename(prefs.picture_dest, prefs.autosave_picture_file, ".png")
            self.grabber.autosave(fname)
        else:
            self.grabber.save_capture(None)

    def cb_save_done(self, widget, result):
        logger.debug("Save Done, result: {0}".format(result))
        self.old_path = result

        if self.take == 1 or self.mode != MODE_GOD:
            Gtk.main_quit()
            sys.exit(0)

        self.take =+ 1


    def cb_prefs_quit(self, widget):
        logger.debug("Saving settings.")
        prefs.pa_q.end()
        prefs.save_config()
        Gtk.main_quit()
        sys.exit(0)
예제 #7
0
 def cb_preferences_request(self, indicator):
     logger.debug("Preferences requested.")
     self.preferences_window = Preferences()
     self.preferences_window.open()
예제 #8
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 = sound

        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(datadir)
        self.default_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR)

        # 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.select_window = None
        self.outline_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
        self.keypress_detect = False
        self.keypress_viewer = None
        self.cam = None

        if prefs.sound:
            try:
                prefs.pa_q = pulseaudio_q()
                prefs.pa_q.start()
            except:
                logger.warning(
                    "Pulse Audio Failed to load. Sound recording disabled.")
                prefs.sound = False

        prefs.get_webcam_sources()

        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-help-request", self.cb_help_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-help", self.cb_help_request)
        self.mainmenu.connect("help-about", self.cb_help_about)
        self.webcam = HW.webcam
        self.webcam.connect("webcam-change", self.cb_webcam_change)

        #
        # Detect Xlib, if there's no Xlib, there's no KeyViewer
        #

        try:
            imp.find_module('Xlib')
            self.keypress_viewer = KeypressViewer()
            self.keypress_viewer.connect("keypress", self.cb_got_keypress)
            self.keypress_detect = True
        except ImportError:
            logger.warning(
                _("No Xlib support in python3, unable to capture key and mouse clicks."
                  ))
            self.keypress_detect = False

        #
        # 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)

        # Retrieve gdk_win for the root window
        self.gdk_win = self.window.get_root_window()

        #
        # Attach main menu, so that
        #
        self.MainGrid.attach(self.mainmenu.menubar, 0, 0, 1, 1)

        self.main_context = self.toolbar_main.get_style_context()
        self.main_context.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        self.main_context.connect("changed", self.cb_main_context_change)
        self.main_fg_color = self.main_context.get_color(Gtk.StateFlags.ACTIVE)

        #
        # Screen cast mode
        #
        self.btn_screencast = Gtk.RadioToolButton(group=None)
        self.btn_screencast.set_label(_("Screencast"))
        self.btn_screencast.set_tooltip_text(
            _("Record a video of your desktop."))
        screencast_icon = self.icons.lookup_icon(
            "kazam-screencast-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if screencast_icon:
            cast_icon_pixbuf, was_sym = screencast_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            cast_img = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
            self.btn_screencast.set_icon_widget(cast_img)
        self.btn_screencast.set_active(True)
        self.btn_screencast.set_name("MAIN_SCREENCAST")
        self.btn_screencast.connect("toggled", self.cb_main_toggled)

        #
        # Screen shot mode
        #
        self.btn_screenshot = Gtk.RadioToolButton(group=self.btn_screencast)
        self.btn_screenshot.set_label(_("Screenshot"))
        self.btn_screenshot.set_tooltip_text(
            _("Record a picture of your desktop."))
        screenshot_icon = self.icons.lookup_icon(
            "kazam-screenshot-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if screenshot_icon:
            shot_icon_pixbuf, was_sym = screenshot_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            shot_img = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
            self.btn_screenshot.set_icon_widget(shot_img)
        self.btn_screenshot.set_name("MAIN_SCREENSHOT")
        self.btn_screenshot.connect("toggled", self.cb_main_toggled)

        #
        # Broadcast mode
        #
        self.btn_broadcast = Gtk.RadioToolButton(group=self.btn_screencast)
        self.btn_broadcast.set_label(_("Broadcast"))
        self.btn_broadcast.set_tooltip_text(_("Broadcast your desktop."))
        broadcast_icon = self.icons.lookup_icon("kazam-broadcast-symbolic", 24,
                                                Gtk.IconLookupFlags.FORCE_SIZE)
        if broadcast_icon:
            cam_icon_pixbuf, was_sym = broadcast_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            cam_img = Gtk.Image.new_from_pixbuf(cam_icon_pixbuf)
            self.btn_broadcast.set_icon_widget(cam_img)
        self.btn_broadcast.set_name("MAIN_BROADCAST")
        self.btn_broadcast.connect("toggled", self.cb_main_toggled)

        #
        # Webcam mode
        #
        self.btn_webcam = Gtk.RadioToolButton(group=self.btn_screencast)
        self.btn_webcam.set_label(_("Webcam"))
        self.btn_webcam.set_tooltip_text(_("Capture form your webcam."))
        webcam_icon = self.icons.lookup_icon("kazam-webcam-symbolic", 24,
                                             Gtk.IconLookupFlags.FORCE_SIZE)
        if webcam_icon:
            cam_icon_pixbuf, was_sym = webcam_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            cam_img = Gtk.Image.new_from_pixbuf(cam_icon_pixbuf)
            self.btn_webcam.set_icon_widget(cam_img)
        self.btn_webcam.set_name("MAIN_WEBCAM")
        self.btn_webcam.connect("toggled", self.cb_main_toggled)

        self.sep_1 = Gtk.SeparatorToolItem()
        self.sep_1.set_draw(False)
        self.sep_1.set_expand(True)
        self.sep_1a = Gtk.SeparatorToolItem()
        self.sep_1a.set_draw(False)
        self.sep_1a.set_expand(True)
        self.toolbar_main.insert(self.sep_1, -1)
        self.toolbar_main.insert(self.btn_screencast, -1)
        self.toolbar_main.insert(self.btn_screenshot, -1)
        self.toolbar_main.insert(self.btn_broadcast, -1)
        if prefs.webcam_sources:
            self.toolbar_main.insert(self.btn_webcam, -1)
        else:
            self.chk_webcam.set_sensitive(False)
            self.chk_webcam_broadcast.set_sensitive(False)
        self.toolbar_main.insert(self.sep_1a, -1)

        # Auxiliary toolbar
        self.aux_context = self.toolbar_aux.get_style_context()
        self.aux_context.add_class(Gtk.STYLE_CLASS_TOOLBAR)
        self.aux_fg_color = self.aux_context.get_color(Gtk.StateFlags.ACTIVE)

        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."))
        full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if full_icon:
            full_icon_pixbuf, was_sym = full_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            full_img = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
            self.btn_full.set_icon_widget(full_img)
        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."))
        allscreens_icon = self.icons.lookup_icon(
            "kazam-all-screens-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if allscreens_icon:
            allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            allscreens_img = Gtk.Image.new_from_pixbuf(allscreens_icon_pixbuf)
            self.btn_allscreens.set_icon_widget(allscreens_img)
        self.btn_allscreens.set_name("MODE_ALL")
        self.btn_allscreens.connect("toggled", self.cb_record_mode_toggled)
        if HW.combined_screen is None:
            self.btn_allscreens.set_sensitive(False)

        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."))
        window_icon = self.icons.lookup_icon("kazam-window-symbolic", 24,
                                             Gtk.IconLookupFlags.FORCE_SIZE)
        if window_icon:
            window_icon_pixbuf, was_sym = window_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            window_img = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
            self.btn_window.set_icon_widget(window_img)
        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."))
        area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if area_icon:
            area_icon_pixbuf, was_sym = area_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            area_img = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
            self.btn_area.set_icon_widget(area_img)
        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.sep_2a = Gtk.SeparatorToolItem()
        self.sep_2a.set_draw(False)
        self.sep_2a.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_2a, -1)
        self.ntb_main.set_current_page(0)
        self.btn_record.grab_focus()

        #
        # 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)
        #        self.window.connect("delete-event", self.cb_delete_event)

        # Fetch sources info, take care of all the widgets and saved settings and show main window
        if prefs.sound:
            prefs.get_audio_sources()

        self.instructions = ("""  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""")

        if not prefs.silent:
            self.window.show_all()
        else:
            logger.info("""Starting in silent mode:\n""" + self.instructions)

        self.restore_UI()

        if not self.keypress_detect:
            self.chk_keypresses.set_sensitive(False)
            self.chk_keypresses.set_active(False)

        #HW.get_current_screen(self.window)
        self.startup = False
        self.noSelectNextModeActive = False

        screen = HW.get_current_screen(self.window)
        prefs.current_screen = screen

        #
        # For debugging purposes only ...
        #
        # self.keypress_viewer.start()
        # self.keypress_window = KeypressWindow()

    #
    # Callbacks, go down here ...
    #
    def cb_got_keypress(self, kv, ev_type, action, value):
        """ev_type: 'KeySym', 'KeyStr', 'MouseButton'
           action: 'Press' or 'Release'
           value: A key name ('Control_L' or 'd' or 'backslash' or 1,2,3 for
                              mouse buttons.)
        """
        logger.info("GOT EVENT: {}, {}, {}".format(ev_type, action, value))
        if self.keypress_window:
            self.keypress_window.show(ev_type, value, action)

    #
    # Mode of operation toggles
    #

    def cb_main_toggled(self, widget):
        # Here be defaults
        self.toolbar_aux.set_sensitive(True)
        self.chk_borders_pic.set_sensitive(True)

        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"))
            self.btn_record.set_label(_("Capture"))

        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"))
            if self.record_mode != "MODE_WIN":
                self.chk_borders_pic.set_sensitive(False)
            self.btn_record.set_label(_("Capture"))

        elif name == "MAIN_BROADCAST" and widget.get_active():
            logger.debug("Main toggled: {0}".format(name))
            self.main_mode = MODE_BROADCAST
            self.ntb_main.set_current_page(2)
            self.indicator.menuitem_start.set_label(_("Start broadcasting"))
            self.btn_record.set_label(_("Broadcast"))
            self.toolbar_aux.set_sensitive(False)

        elif name == "MAIN_WEBCAM" and widget.get_active():
            logger.debug("Main toggled: {0}".format(name))
            self.ntb_main.set_current_page(3)
            self.main_mode = MODE_WEBCAM
            self.toolbar_aux.set_sensitive(False)
            self.indicator.menuitem_start.set_label(_("Start recording"))
            self.btn_record.set_label(_("Capture"))

    #
    # Record mode toggles
    #
    def cb_record_mode_toggled(self, widget):
        noSelection = False
        if widget.get_active():
            self.current_mode = widget
            if self.noSelectNextModeActive == True:
                self.noSelectNextModeActive = False
                noSelection = True
        else:
            self.last_mode = widget

        if widget.get_name() == "MODE_AREA" and widget.get_active():
            logger.debug("Area ON.")
            if noSelection != True:
                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.")
            if noSelection != True:
                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.chk_borders_pic.set_sensitive(True)
            self.record_mode = MODE_WIN

        if widget.get_name() == "MODE_WIN" and not widget.get_active():
            logger.debug("Window capture OFF.")
            self.chk_borders_pic.set_sensitive(False)
            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

    def cb_main_context_change(self, widget):
        #
        # If this is the only way on how to deal with symbolic icons, then someone needs spanking ...
        #
        if widget.get_state() == Gtk.StateFlags.BACKDROP:
            self.main_fg_color = self.main_context.get_color(
                Gtk.StateFlags.ACTIVE)
            self.aux_fg_color = self.aux_context.get_color(
                Gtk.StateFlags.ACTIVE)

            #
            # Update icons on the main toolbar
            #
            cast_icon = self.icons.lookup_icon("kazam-screencast-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if cast_icon:
                cast_icon_pixbuf, was_sym = cast_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                cast_img = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
                self.btn_screencast.set_icon_widget(cast_img)
                cast_img.show_all()

            shot_icon = self.icons.lookup_icon("kazam-screenshot-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if shot_icon:
                shot_icon_pixbuf, was_sym = shot_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                shot_img = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
                self.btn_screenshot.set_icon_widget(shot_img)
                shot_img.show_all()

            webcam_icon = self.icons.lookup_icon(
                "kazam-webcam-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if webcam_icon:
                webcam_icon_pixbuf, was_sym = webcam_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                webcam_img = Gtk.Image.new_from_pixbuf(webcam_icon_pixbuf)
                self.btn_screencast.set_icon_widget(webcam_img)
                webcam_img.show_all()

            broadcast_icon = self.icons.lookup_icon(
                "kazam-broadcast-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if broadcast_icon:
                broadcast_icon_pixbuf, was_sym = broadcast_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                broadcast_img = Gtk.Image.new_from_pixbuf(
                    broadcast_icon_pixbuf)
                self.btn_screenshot.set_icon_widget(broadcast_img)
                broadcast_img.show_all()

            #
            # Update icons on the aux toolbar
            #
            full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if full_icon:
                full_icon_pixbuf, was_sym = full_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                full_img = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
                self.btn_full.set_icon_widget(full_img)
                full_img.show_all()

            allscreens_icon = self.icons.lookup_icon(
                "kazam-all-screens-symbolic", 24,
                Gtk.IconLookupFlags.FORCE_SIZE)
            if allscreens_icon:
                allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                allscreens_img = Gtk.Image.new_from_pixbuf(
                    allscreens_icon_pixbuf)
                self.btn_allscreens.set_icon_widget(allscreens_img)
                allscreens_img.show_all()

            window_icon = self.icons.lookup_icon(
                "kazam-window-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if window_icon:
                window_icon_pixbuf, was_sym = window_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                window_img = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
                self.btn_window.set_icon_widget(window_img)
                window_img.show_all()

            area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if area_icon:
                area_icon_pixbuf, was_sym = area_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                area_img = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
                self.btn_area.set_icon_widget(area_img)
                area_img.show_all()

    #
    # Unity quick list callbacks
    #

    def cb_ql_screencast(self, menu, data):
        logger.debug("Screencast quicklist activated.")
        self.btn_screencast.set_active(True)
        self.run_counter()

    def cb_ql_screenshot(self, menu, data):
        logger.debug("Screenshot quicklist activated.")
        self.btn_screenshot.set_active(True)
        self.run_counter()

    def cb_record_area_clicked(self, widget):
        if self.area_window:
            logger.debug("Area mode clicked.")
            self.area_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.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))
        logger.debug(
            "Area selected: GX: {0}, GY: {1}, GX: {2}, GY: {3}".format(
                self.area_window.g_startx, self.area_window.g_starty,
                self.area_window.g_endx, self.area_window.g_endy))
        prefs.area = (self.area_window.g_startx, self.area_window.g_starty,
                      self.area_window.g_endx, self.area_window.g_endy,
                      self.area_window.width, self.area_window.height)
        self.window.set_sensitive(True)

    def cb_area_canceled(self, widget):
        logger.debug("Area selection canceled.")
        self.window.set_sensitive(True)
        self.noSelectNextModeActive = 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.noSelectNextModeActive = True
        self.last_mode.set_active(True)

    def cb_screen_size_changed(self, screen):
        logger.debug("Screen size changed.")
        HW.get_screens()
        #
        # If 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.")
        # Restore cursor, just in case if by some chance stays set to cross-hairs
        self.gdk_win.set_cursor(self.default_cursor)
        (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 and prefs.pa_q != None:
            prefs.pa_q.end()
            prefs.pa_q = None

        #
        # Just in case, try to shutdown keylogger
        #
        if self.keypress_viewer:
            self.keypress_viewer.stop()
        Gtk.main_quit()

    def cb_preferences_request(self, indicator):
        logger.debug("Preferences requested.")
        self.preferences_window = Preferences()
        self.preferences_window.open()

    def cb_help_request(self, indicator):
        messagedialog = Gtk.MessageDialog(parent=self.window,
                                          flags=Gtk.DialogFlags.MODAL,
                                          type=Gtk.MessageType.WARNING,
                                          buttons=Gtk.ButtonsType.OK,
                                          message_format=self.instructions)
        messagedialog.run()
        messagedialog.destroy()

    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 in [MODE_SCREENCAST, MODE_WEBCAM, MODE_BROADCAST]:
            if self.main_mode == MODE_BROADCAST:
                self.indicator.menuitem_finish.set_label(
                    _("Finish broadcasting"))
            else:
                self.indicator.menuitem_finish.set_label(_("Finish recording"))
            self.indicator.menuitem_pause.set_sensitive(True)
            self.indicator.start_recording()
            self.recorder.start_recording()
            if (self.main_mode == MODE_SCREENCAST and
                    prefs.capture_keys) or (self.main_mode == MODE_BROADCAST
                                            and prefs.capture_keys_broadcast):
                self.keypress_window = KeypressWindow()
                if self.keypress_viewer:
                    self.keypress_viewer.start()
        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.outline_window:
            self.outline_window.hide()
            self.outline_window.window.destroy()
            self.outline_window = None

        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()
            if (self.main_mode == MODE_SCREENCAST and
                    prefs.capture_keys) or (self.main_mode == MODE_BROADCAST
                                            and prefs.capture_keys_broadcast):
                if self.keypress_viewer:
                    self.keypress_viewer.stop()
                self.keypress_window.window.destroy()
                self.keypress_window = None
                self.keypress_viewer = None

            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.autosave_video_dir,
                                      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 or self.main_mode == MODE_WEBCAM:
            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_BROADCAST:
            self.window.set_sensitive(True)
            self.window.show_all()
            self.window.present()
            self.window.move(prefs.main_x, prefs.main_y)

        elif self.main_mode == MODE_SCREENSHOT:
            if self.outline_window:
                self.outline_window.hide()
                self.outline_window.window.destroy()
                self.outline_window = None

            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_quit.set_sensitive(True)

            if prefs.autosave_picture:
                fname = get_next_filename(prefs.autosave_picture_dir,
                                          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)
        #
        # Use the current autosave filename for edit file.
        #
        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.")
        self.window.set_sensitive(True)
        self.window.show_all()

    def cb_check_cursor(self, widget):
        name = Gtk.Buildable.get_name(widget)
        if name == "chk_cursor":
            prefs.capture_cursor = widget.get_active()
        elif name == "chk_cursor_pic":
            prefs.capture_cursor_pic = widget.get_active()
        elif name == "chk_cursor_broadcast":
            prefs.capture_cursor_broadcast = widget.get_active()
        logger.debug("Toggled {}: {}.".format(name, widget.get_active()))

    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):
        name = Gtk.Buildable.get_name(widget)
        if name == "chk_speakers":
            prefs.capture_speakers = widget.get_active()
        elif name == "chk_speakers_webcam":
            prefs.capture_speakers_webcam = widget.get_active()
        elif name == "chk_speakers_broadcast":
            prefs.capture_speakers_broadcast = widget.get_active()
        logger.debug("Toggled {}: {}.".format(name, widget.get_active()))

    def cb_check_microphone(self, widget):
        name = Gtk.Buildable.get_name(widget)
        if name == "chk_microphone":
            prefs.capture_microphone = widget.get_active()
        elif name == "chk_microphone_webcam":
            prefs.capture_microphone_webcam = widget.get_active()
        elif name == "chk_microphone_broadcast":
            prefs.capture_microphone_broadcast = widget.get_active()
        logger.debug("Toggled {}: {}.".format(name, widget.get_active()))

    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))

    def cb_check_webcam(self, widget):
        name = Gtk.Buildable.get_name(widget)
        if widget.get_active() is True:
            if self.cam is None:
                logger.debug("Turning ON webcam window.")
                self.cam = GWebcam()
                self.cam.start()
                if name == "chk_webcam_broadcast":
                    self.chk_webcam.set_active(True)
                else:
                    self.chk_webcam_broadcast.set_active(True)
        else:
            if self.cam is not None:
                logger.debug("Turning OFF webcam window.")
                self.cam.close()
                self.cam = None
                if name == "chk_webcam_broadcast":
                    self.chk_webcam.set_active(False)
                else:
                    self.chk_webcam_broadcast.set_active(False)

    def cb_check_keypresses(self, widget):
        name = Gtk.Buildable.get_name(widget)
        if name == "chk_keypresses":
            prefs.capture_keys = widget.get_active()
        elif name == "chk_keypresses_broadcast":
            prefs.capture_keys_broadcast = widget.get_active()
        logger.debug("Toggled {}: {}.".format(name, widget.get_active()))

    #
    # Other somewhat useful stuff ...
    #

    def run_counter(self):
        if self.recording:
            logger.debug("Already recording, not starting again.")
            return
        #
        # Annoyances with the menus
        #
        logger.debug("Running Counter.")
        (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_quit.set_sensitive(False)
        self.indicator.menuitem_finish.set_label(_("Cancel countdown"))
        self.in_countdown = True

        self.indicator.blink_set_state(BLINK_START)

        if prefs.sound:
            if (self.main_mode == MODE_SCREENCAST and prefs.capture_speakers) or \
               (self.main_mode == MODE_BROADCAST and prefs.capture_speakers_broadcast) or \
               (self.main_mode == MODE_WEBCAM and prefs.capture_speakers_webcam):
                try:
                    audio_source = prefs.speaker_sources[prefs.audio_source][1]
                    try:
                        audio_channels = prefs.pa_q.get_source_info_by_index(
                            prefs.speaker_sources[
                                prefs.audio_source][0])[2].channels
                    except:
                        audio_channels = 1
                    logger.debug(
                        "Detected audio channels: {}".format(audio_channels))
                except IndexError:
                    logger.warning(
                        "It appears that speakers audio source isn't set up correctly."
                    )
                    audio_source = None
            else:
                audio_source = None
                audio_channels = 1

            if (self.main_mode == MODE_SCREENCAST and prefs.capture_microphone) or \
               (self.main_mode == MODE_BROADCAST and prefs.capture_microphone_broadcast) or \
               (self.main_mode == MODE_WEBCAM and prefs.capture_microphone_webcam):
                try:
                    audio2_source = prefs.mic_sources[prefs.audio2_source][1]
                    try:
                        audio2_channels = prefs.pa_q.get_source_info_by_index(
                            prefs.speaker_sources[
                                prefs.audio2_source][0])[2].channels
                    except:
                        audio2_channels = 1
                    logger.debug(
                        "Detected audio2 channels: {}".format(audio2_channels))
                except IndexError:
                    logger.warning(
                        "It appears that microphone audio source isn't set up correctly."
                    )
                    audio2_source = None
            else:
                audio2_source = None
                audio2_channels = 1
        else:
            audio_source = None
            audio_channels = 1
            audio2_source = None
            audio2_channels = 1

        #
        # Get appropriate coordinates for recording
        #

        video_source = None

        screen = HW.get_current_screen(self.window)
        prefs.current_screen = screen

        if self.main_mode == MODE_WEBCAM:
            video_source = CAM_RESOLUTIONS[prefs.webcam_source]
        elif self.record_mode == MODE_ALL:
            video_source = HW.combined_screen
        else:
            video_source = HW.screens[screen]

        if self.main_mode in [MODE_SCREENCAST, MODE_WEBCAM, MODE_BROADCAST]:
            self.recorder = Screencast(self.main_mode)
            self.recorder.setup_sources(
                video_source, audio_source, audio2_source,
                prefs.area if self.record_mode == MODE_AREA
                and self.main_mode not in [MODE_WEBCAM, MODE_BROADCAST] else
                None, prefs.xid if self.record_mode == MODE_WIN
                and self.main_mode not in [MODE_WEBCAM, MODE_BROADCAST] else
                None, audio_channels, audio2_channels)

            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)
        logger.debug("Starting counter.")
        self.countdown.run(prefs.countdown_timer)
        self.recording = True
        logger.debug("Hiding main window.")
        self.window.hide()
        if self.main_mode == MODE_SCREENCAST or self.main_mode == MODE_SCREENSHOT:
            try:
                if self.record_mode == MODE_AREA and prefs.area:
                    logger.debug("Showing recording outline.")
                    self.outline_window = OutlineWindow(
                        prefs.area[0], prefs.area[1], prefs.area[4],
                        prefs.area[5])
                    self.outline_window.show()
                else:
                    logger.debug(
                        "Ubuntu 13.04 or higher not detected, recording outline not shown."
                    )
            except:
                logger.debug("Unable to show recording outline.")

    def setup_translations(self):
        gettext.bindtextdomain("kazam", "/usr/share/locale")
        gettext.textdomain("kazam")
        locale.bindtextdomain("kazam", "/usr/share/locale")
        locale.textdomain("kazam")
        currentLocale = locale.getlocale()
        try:
            locale.setlocale(locale.LC_ALL, currentLocale)
        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_keypresses.set_active(prefs.capture_keys)

        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)

        self.chk_speakers_webcam.set_active(prefs.capture_speakers_webcam)
        self.chk_microphone_webcam.set_active(prefs.capture_microphone_webcam)

        self.chk_cursor_broadcast.set_active(prefs.capture_cursor_broadcast)
        self.chk_speakers_broadcast.set_active(
            prefs.capture_speakers_broadcast)
        self.chk_microphone_broadcast.set_active(
            prefs.capture_microphone_broadcast)
        self.chk_keypresses_broadcast.set_active(prefs.capture_keys_broadcast)

        #
        # 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)

    def cb_webcam_change(self, widget):
        prefs.get_webcam_sources()
        logger.debug("Webcams: {}".format(prefs.webcam_sources))
        if prefs.webcam_sources:
            logger.debug("Adding Webcam UI items.")
            self.toolbar_main.insert(self.btn_webcam, -1)
            self.toolbar_main.show_all()
            self.chk_webcam.set_active(False)
            self.chk_webcam.set_sensitive(True)
        else:
            logger.debug("Removing Webcam UI items.")
            self.toolbar_main.remove(self.btn_webcam)
            self.chk_webcam.set_sensitive(False)
            self.chk_webcam.set_active(False)
            if self.btn_webcam.get_active():
                self.btn_screencast.set_active(True)
예제 #9
0
파일: app.py 프로젝트: cutephoton/kazam
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 = sound

        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.default_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR)

        # 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.select_window = None
        self.outline_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)

        # Retrieve gdk_win for the root window
        self.gdk_win = self.window.get_root_window()

        #
        # Attach main menu, so that
        #
        self.MainGrid.attach(self.mainmenu.menubar, 0, 0, 1, 1)

        self.main_context = self.toolbar_main.get_style_context()
        self.main_context.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        self.main_context.connect("changed", self.cb_main_context_change)
        self.main_fg_color = self.main_context.get_color(Gtk.StateFlags.ACTIVE)

        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."))
        cast_icon = self.icons.lookup_icon("kazam-screencast-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if cast_icon:
            cast_icon_pixbuf, was_sym = cast_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            cast_img = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
            self.btn_cast.set_icon_widget(cast_img)
        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."))
        shot_icon = self.icons.lookup_icon("kazam-screenshot-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if shot_icon:
            shot_icon_pixbuf, was_sym = shot_icon.load_symbolic(
                self.main_fg_color, None, None, None)
            shot_img = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
            self.btn_shot.set_icon_widget(shot_img)
        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.aux_context = self.toolbar_aux.get_style_context()
        self.aux_context.add_class(Gtk.STYLE_CLASS_TOOLBAR)
        self.aux_fg_color = self.aux_context.get_color(Gtk.StateFlags.ACTIVE)

        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."))
        full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if full_icon:
            full_icon_pixbuf, was_sym = full_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            full_img = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
            self.btn_full.set_icon_widget(full_img)
        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."))
        allscreens_icon = self.icons.lookup_icon(
            "kazam-all-screens-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
        if allscreens_icon:
            allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            allscreens_img = Gtk.Image.new_from_pixbuf(allscreens_icon_pixbuf)
            self.btn_allscreens.set_icon_widget(allscreens_img)
        self.btn_allscreens.set_name("MODE_ALL")
        self.btn_allscreens.connect("toggled", self.cb_record_mode_toggled)
        if HW.combined_screen is None:
            self.btn_allscreens.set_sensitive(False)

        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."))
        window_icon = self.icons.lookup_icon("kazam-window-symbolic", 24,
                                             Gtk.IconLookupFlags.FORCE_SIZE)
        if window_icon:
            window_icon_pixbuf, was_sym = window_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            window_img = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
            self.btn_window.set_icon_widget(window_img)
        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."))
        area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24,
                                           Gtk.IconLookupFlags.FORCE_SIZE)
        if area_icon:
            area_icon_pixbuf, was_sym = area_icon.load_symbolic(
                self.aux_fg_color, None, None, None)
            area_img = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
            self.btn_area.set_icon_widget(area_img)
        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)
        self.btn_record.grab_focus()

        #
        # 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()

        HW.get_current_screen(self.window)
        #self.set_mode(prefs.last_mode)
        self.set_default_mode()
        self.startup = False

    #
    # Callbacks, go down here ...
    #

    #
    # Mode of operation toggles
    #

    def cb_main_toggled(self, widget):
        name = widget.get_name()
        if widget.get_active():
            self.set_mode(name)

    def set_mode(self, mode, setToggle=False):
        logger.debug("Mode toggled: {0}".format(mode))

        if mode == "MAIN_SCREENCAST":
            self.main_mode = MODE_SCREENCAST
            self.ntb_main.set_current_page(0)
            self.indicator.menuitem_start.set_label(_("Start recording"))
        elif mode == "MAIN_SCREENSHOT":
            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"))
            if self.record_mode == "MODE_WIN":
                self.chk_borders_pic.set_sensitive(True)
            else:
                self.chk_borders_pic.set_sensitive(False)
        prefs.last_mode = mode

    def set_default_mode(self):
        if prefs.last_mode == "MAIN_SCREENCAST":
            self.btn_shot.set_active(False)
            self.btn_cast.set_active(True)
        elif prefs.last_mode == "MAIN_SCREENSHOT":
            self.btn_cast.set_active(False)
            self.btn_shot.set_active(True)

    #
    # 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
            self.chk_borders_pic.set_sensitive(True)

        if widget.get_name() == "MODE_WIN" and not widget.get_active():
            logger.debug("Window capture OFF.")
            self.chk_borders_pic.set_sensitive(False)
            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

    def cb_main_context_change(self, widget):
        #
        # If this is the only way on how to deal with symbolic icons, then someone needs spanking ...
        #
        if widget.get_state() == Gtk.StateFlags.BACKDROP:
            self.main_fg_color = self.main_context.get_color(
                Gtk.StateFlags.ACTIVE)
            self.aux_fg_color = self.aux_context.get_color(
                Gtk.StateFlags.ACTIVE)

            #
            # Update icons on the main toolbar
            #
            cast_icon = self.icons.lookup_icon("kazam-screencast-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if cast_icon:
                cast_icon_pixbuf, was_sym = cast_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                cast_img = Gtk.Image.new_from_pixbuf(cast_icon_pixbuf)
                self.btn_cast.set_icon_widget(cast_img)
                cast_img.show_all()

            shot_icon = self.icons.lookup_icon("kazam-screenshot-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if shot_icon:
                shot_icon_pixbuf, was_sym = shot_icon.load_symbolic(
                    self.main_fg_color, None, None, None)
                shot_img = Gtk.Image.new_from_pixbuf(shot_icon_pixbuf)
                self.btn_shot.set_icon_widget(shot_img)
                shot_img.show_all()

            #
            # Update icons on the aux toolbar
            #
            full_icon = self.icons.lookup_icon("kazam-fullscreen-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if full_icon:
                full_icon_pixbuf, was_sym = full_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                full_img = Gtk.Image.new_from_pixbuf(full_icon_pixbuf)
                self.btn_full.set_icon_widget(full_img)
                full_img.show_all()

            allscreens_icon = self.icons.lookup_icon(
                "kazam-all-screens-symbolic", 24,
                Gtk.IconLookupFlags.FORCE_SIZE)
            if allscreens_icon:
                allscreens_icon_pixbuf, was_sym = allscreens_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                allscreens_img = Gtk.Image.new_from_pixbuf(
                    allscreens_icon_pixbuf)
                self.btn_allscreens.set_icon_widget(allscreens_img)
                allscreens_img.show_all()

            window_icon = self.icons.lookup_icon(
                "kazam-window-symbolic", 24, Gtk.IconLookupFlags.FORCE_SIZE)
            if window_icon:
                window_icon_pixbuf, was_sym = window_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                window_img = Gtk.Image.new_from_pixbuf(window_icon_pixbuf)
                self.btn_window.set_icon_widget(window_img)
                window_img.show_all()

            area_icon = self.icons.lookup_icon("kazam-area-symbolic", 24,
                                               Gtk.IconLookupFlags.FORCE_SIZE)
            if area_icon:
                area_icon_pixbuf, was_sym = area_icon.load_symbolic(
                    self.aux_fg_color, None, None, None)
                area_img = Gtk.Image.new_from_pixbuf(area_icon_pixbuf)
                self.btn_area.set_icon_widget(area_img)
                area_img.show_all()

    #
    # 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_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))
        logger.debug(
            "Area selected: GX: {0}, GY: {1}, GX: {2}, GY: {3}".format(
                self.area_window.g_startx, self.area_window.g_starty,
                self.area_window.g_endx, self.area_window.g_endy))
        prefs.area = (self.area_window.g_startx, self.area_window.g_starty,
                      self.area_window.g_endx, self.area_window.g_endy,
                      self.area_window.width, self.area_window.height)
        self.window.set_sensitive(True)

    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()
        #
        # If 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.")
        # Restore cursor, just in case if by some chance stays set to cross-hairs
        self.gdk_win.set_cursor(self.default_cursor)
        (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.outline_window:
            self.outline_window.hide()
            self.outline_window.window.destroy()
            self.outline_window = None

        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.autosave_video_dir,
                                      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:
            if self.outline_window:
                self.outline_window.hide()
                self.outline_window.window.destroy()
                self.outline_window = None

            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_quit.set_sensitive(True)

            flags = self.grabber.SAVE_FLAGS_FILE
            filename = self.old_pic_path

            if prefs.capture_editor:
                flags |= self.grabber.SAVE_FLAGS_EDIT_FIRST

            if prefs.autosave_picture:
                flags |= self.grabber.SAVE_FLAGS_FILE_AUTO
                filename = get_next_filename(prefs.autosave_picture_dir,
                                             prefs.autosave_picture_file,
                                             ".png")
            if prefs.capture_clipboard_pic:
                flags |= self.grabber.SAVE_FLAGS_CLIPBOARD
                if prefs.capture_clipboard_only:
                    flags &= ~self.grabber.SAVE_FLAGS_FILE

            self.grabber.save_capture(filename, flags)

    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 result is not None else "<no file>"))
        if self.main_mode == MODE_SCREENCAST:
            self.old_vid_path = result
        else:
            if result is not None:
                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)
        #
        # Use the current autosave filename for edit file.
        #
        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.")
        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_editor(self, widget):
        prefs.capture_editor = widget.get_active()
        logger.debug("Capture editor: {0}.".format(prefs.capture_editor))

    def cb_check_clipboard(self, widget):
        prefs.capture_clipboard_pic = widget.get_active()
        logger.debug("Capture to clipboard: {0}.".format(
            prefs.capture_clipboard_pic))
        self.chk_clipboard_skipsave.set_sensitive(prefs.capture_clipboard_pic)

    def cb_check_clipboard_skipsave(self, widget):
        prefs.capture_clipboard_only = widget.get_active()
        logger.debug(
            "Capture to clipboard only (skip save option): {0}.".format(
                prefs.capture_clipboard_only))

    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_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:
                try:
                    audio_source = prefs.speaker_sources[prefs.audio_source][1]
                except IndexError:
                    logger.warning(
                        "It appears that speakers audio source isn't set up correctly."
                    )
                    audio_source = None
            else:
                audio_source = None

            if prefs.capture_microphone:
                try:
                    audio2_source = prefs.mic_sources[prefs.audio2_source][1]
                except IndexError:
                    logger.warning(
                        "It appears that microphone audio source isn't set up correctly."
                    )
                    audio2_source = None
            else:
                audio2_source = None

        else:
            audio_source = None
            audio2_source = None

        #
        # Get appropriate coordinates for recording
        #

        video_source = None

        if self.record_mode == MODE_ALL:
            video_source = HW.combined_screen
        else:
            screen = HW.get_current_screen(self.window)
            video_source = HW.screens[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()
        try:
            if self.record_mode == MODE_AREA and prefs.area:
                if prefs.dist[0] == 'Ubuntu' and int(
                        prefs.dist[1].split(".")[0]) > 12:
                    logger.debug("Showing recording outline.")
                    self.outline_window = OutlineWindow(
                        prefs.area[0], prefs.area[1], prefs.area[4],
                        prefs.area[5])
                    self.outline_window.show()
                else:
                    logger.debug(
                        "Ubuntu 13.04 or higher not detected, recording outline not shown."
                    )
        except:
            logger.debug("Unable to show recording outline.")

    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_clipboard.set_active(prefs.capture_clipboard_pic)
        self.chk_clipboard_skipsave.set_active(prefs.capture_clipboard_only)
        self.chk_clipboard_skipsave.set_sensitive(prefs.capture_clipboard_pic)
        self.chk_borders_pic.set_active(prefs.capture_borders_pic)
        self.spinbutton_delay.set_value(prefs.countdown_timer)
        self.chk_editor.set_active(prefs.capture_editor)

        #
        # 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)