Reads all gconf paths under /apps/guake/keybindings/local
        and adds to the main accel_group.

def load_accelerators(self):
        """Reads all gconf paths under /apps/guake/keybindings/local
        and adds to the main accel_group.
        """

        def getk(x):
            return self.guake.settings.keybindingsLocal.get_string(x)

        key, mask = Gtk.accelerator_parse(getk('reset-terminal'))

        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_reset_terminal
            )

        key, mask = Gtk.accelerator_parse(getk('quit'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_quit)

        key, mask = Gtk.accelerator_parse(getk('new-tab'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_add)

        key, mask = Gtk.accelerator_parse(getk('new-tab-home'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_add_home)

        key, mask = Gtk.accelerator_parse(getk('close-tab'))
        if key > 0:

            def x(*args):
                prompt_cfg = self.guake.settings.general.get_int('prompt-on-close-tab')
                self.guake.get_notebook().delete_page_current(prompt=prompt_cfg)

            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, x)

        key, mask = Gtk.accelerator_parse(getk('previous-tab'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_prev)

        key, mask = Gtk.accelerator_parse(getk('next-tab'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_next)

        key, mask = Gtk.accelerator_parse(getk('move-tab-left'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_move_tab_left
            )

        key, mask = Gtk.accelerator_parse(getk('move-tab-right'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_move_tab_right
            )

        key, mask = Gtk.accelerator_parse(getk('rename-current-tab'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_rename_current_tab
            )

        key, mask = Gtk.accelerator_parse(getk('clipboard-copy'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_copy_clipboard
            )

        key, mask = Gtk.accelerator_parse(getk('clipboard-paste'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_paste_clipboard
            )

        key, mask = Gtk.accelerator_parse(getk('toggle-fullscreen'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_fullscreen
            )

        key, mask = Gtk.accelerator_parse(getk('toggle-hide-on-lose-focus'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_hide_on_lose_focus
            )

        key, mask = Gtk.accelerator_parse(getk('zoom-in'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_in)

        key, mask = Gtk.accelerator_parse(getk('zoom-in-alt'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_in)

        key, mask = Gtk.accelerator_parse(getk('zoom-out'))
        if key > 0:
            self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_out)

        key, mask = Gtk.accelerator_parse(getk('increase-height'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_increase_height
            )

        key, mask = Gtk.accelerator_parse(getk('decrease-height'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_decrease_height
            )

        key, mask = Gtk.accelerator_parse(getk('increase-transparency'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_increase_transparency
            )

        key, mask = Gtk.accelerator_parse(getk('decrease-transparency'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_decrease_transparency
            )

        key, mask = Gtk.accelerator_parse(getk('toggle-transparency'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_transparency
            )

        for tab in range(1, 11):
            key, mask = Gtk.accelerator_parse(getk('switch-tab%d' % tab))
            if key > 0:
                self.accel_group.connect(
                    key, mask, Gtk.AccelFlags.VISIBLE, self.guake.gen_accel_switch_tabN(tab - 1)
                )

        key, mask = Gtk.accelerator_parse(getk('switch-tab-last'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_switch_tab_last
            )

        try:
            key, mask = Gtk.accelerator_parse(getk('search-on-web'))
            if key > 0:
                self.accel_group.connect(
                    key, mask, Gtk.AccelFlags.VISIBLE, self.guake.search_on_web
                )
        except Exception:
            log.exception("Exception occured")

        key, mask = Gtk.accelerator_parse(getk('split-tab-vertical'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    self.guake.get_notebook().get_current_terminal().get_parent().split_v() or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('split-tab-horizontal'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    self.guake.get_notebook().get_current_terminal().get_parent().split_h() or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('close-terminal'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE,
                (lambda *args: self.guake.get_notebook().get_current_terminal().kill() or True)
            )
        key, mask = Gtk.accelerator_parse(getk('focus-terminal-up'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, (
                    lambda *args: FocusMover(self.guake.window).
                    move_up(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('focus-terminal-down'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, (
                    lambda *args: FocusMover(self.guake.window).
                    move_down(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('focus-terminal-right'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, (
                    lambda *args: FocusMover(self.guake.window).
                    move_right(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('focus-terminal-left'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, (
                    lambda *args: FocusMover(self.guake.window).
                    move_left(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('move-terminal-split-up'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    SplitMover.move_up(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('move-terminal-split-down'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    SplitMover.move_down(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('move-terminal-split-left'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    SplitMover.move_left(self.guake.get_notebook().get_current_terminal()) or True
                )
            )
        key, mask = Gtk.accelerator_parse(getk('move-terminal-split-right'))
        if key > 0:
            self.accel_group.connect(
                key,
                mask,
                Gtk.AccelFlags.VISIBLE,
                (
                    lambda *args:  # keep make style from concat this lines
                    SplitMover.move_right(self.guake.get_notebook().get_current_terminal()) or True
                )
            )

        key, mask = Gtk.accelerator_parse(getk('search-terminal'))
        if key > 0:
            self.accel_group.connect(
                key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_search_terminal
            )