mirrors/guake-guake
2
0
Fork 0
mirror of https://github.com/Guake/guake.git synced 2025-10-26 11:27:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace autopep8, yapf by black

Browse Source 
Signed-off-by: Gaetan Semet <gaetan@xeberon.net>
This commit is contained in:
Gaetan Semet 2020-02-18 22:37:46 +01:00
parent 5ac7bac4c4
commit 3ac1a69660
35 changed files with 2644 additions and 2581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.flake8
View File

@ -1,6 +1,16 @@
[flake8]
ignore = E226,E302,E41,E402,F401,F821,C901,E722
ignore =
E226,
E302,
E41,
E402,
F401,
F821,
C901,
E722,
W503, # line break before binary operator
E231, # missing whitespace after ','
max-line-length = 100
exclude = env
max-complexity = 25

19
.yapf
View File

@ -1,19 +0,0 @@
[style]
based_on_style = pep8
column_limit = 100
indent_dictionary_value = true
split_before_first_argument = false
split_penalty_after_opening_bracket = 15000
align_closing_bracket_with_visual_indent = true
blank_line_before_class_docstring = true
coalesce_brackets = true
continuation_indent_width = 4
dedent_closing_brackets = true
; each_dict_entry_on_separate_line = true
blank_line_before_nested_class_or_def = true
spaces_around_power_operator = true
spaces_before_comment = 2
split_before_logical_operator = false
split_arguments_when_comma_terminated = true
allow_split_before_dict_value = false

20
Makefile
View File

@ -180,22 +180,16 @@ compile-glib-schemas-dev: clean-schemas
clean-schemas:
rm -f $(DEV_DATA_DIR)/gschemas.compiled
style: fiximports autopep8 yapf
style: black
fiximports:
@for fil in $$(find setup.py guake -name "*.py"); do \
echo "Sorting imports from: $$fil"; \
pipenv run fiximports $$fil; \
done
autopep8:
pipenv run autopep8 --in-place --recursive setup.py $(MODULE)
yapf:
pipenv run yapf --style .yapf --recursive -i $(MODULE)
black:
pipenv run black $(MODULE)
checks: flake8 pylint reno-lint
checks: black-check flake8 pylint reno-lint
black-check:
pipenv run black --check $(MODULE)
flake8:
pipenv run python setup.py flake8

23
guake/__init__.py
View File

@ -18,31 +18,34 @@ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301 USA
"""
# pylint: disable=import-outside-toplevel
def guake_version():
# Do not import in the module root to speed up the dbus communication as much as possible
import pbr.version
return pbr.version.VersionInfo('guake').version_string()
return pbr.version.VersionInfo("guake").version_string()
def vte_version():
import gi
gi.require_version('Vte', '2.91')
gi.require_version("Vte", "2.91")
from gi.repository import Vte
s = "{}.{}.{}".format(
Vte.MAJOR_VERSION,
Vte.MINOR_VERSION,
Vte.MICRO_VERSION,
)
s = "{}.{}.{}".format(Vte.MAJOR_VERSION, Vte.MINOR_VERSION, Vte.MICRO_VERSION,)
return s
def vte_runtime_version():
import gi
gi.require_version('Vte', '2.91')
gi.require_version("Vte", "2.91")
from gi.repository import Vte
return "{}.{}.{}".format(
Vte.get_major_version(), Vte.get_minor_version(), Vte.get_micro_version()
)
@ -50,6 +53,8 @@ def vte_runtime_version():
def gtk_version():
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
return "{}.{}.{}".format(Gtk.MAJOR_VERSION, Gtk.MINOR_VERSION, Gtk.MICRO_VERSION)

13
guake/about.py
View File

@ -20,7 +20,8 @@ Boston, MA 02110-1301 USA
"""
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import GObject
from gi.repository import Gtk
@ -37,8 +38,8 @@ class AboutDialog(SimpleGladeApp):
"""
def __init__(self):
super(AboutDialog, self).__init__(gladefile('about.glade'), root='aboutdialog')
dialog = self.get_widget('aboutdialog')
super(AboutDialog, self).__init__(gladefile("about.glade"), root="aboutdialog")
dialog = self.get_widget("aboutdialog")
# images
# ipath = pixmapfile('guake-notification.png')
@ -46,11 +47,11 @@ class AboutDialog(SimpleGladeApp):
# img = pixmapfile('guake-notification.png')
image = Gtk.Image()
image.set_from_file(pixmapfile('guake-notification.png'))
image.set_from_file(pixmapfile("guake-notification.png"))
pixbuf = image.get_pixbuf()
dialog.set_property('logo', pixbuf)
dialog.set_property("logo", pixbuf)
dialog.set_name(_('Guake Terminal'))
dialog.set_name(_("Guake Terminal"))
dialog.set_version(guake_version())
dialog.connect("response", lambda x, y: dialog.destroy())

125
guake/boxes.py
View File

@ -4,8 +4,9 @@ import time
from locale import gettext as _
import gi
gi.require_version('Vte', '2.91') # vte-0.42
gi.require_version('Gtk', '3.0')
gi.require_version("Vte", "2.91") # vte-0.42
gi.require_version("Gtk", "3.0")
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Gdk
@ -29,7 +30,7 @@ log = logging.getLogger(__name__)
# TODO remove calls to guake
class TerminalHolder():
class TerminalHolder:
UP = 0
DOWN = 1
RIGHT = 2
@ -64,7 +65,6 @@ class TerminalHolder():
class RootTerminalBox(Gtk.Overlay, TerminalHolder):
def __init__(self, guake, parent_notebook):
super().__init__()
self.guake = guake
@ -89,24 +89,24 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
--------------------------------------|
"""
self.search_revealer = Gtk.Revealer()
self.search_frame = Gtk.Frame(name='search-frame')
self.search_frame = Gtk.Frame(name="search-frame")
self.search_box = Gtk.HBox()
# Search
self.search_close_btn = Gtk.Button()
self.search_close_btn.set_can_focus(False)
close_icon = Gio.ThemedIcon(name='window-close-symbolic')
close_icon = Gio.ThemedIcon(name="window-close-symbolic")
close_image = Gtk.Image.new_from_gicon(close_icon, Gtk.IconSize.BUTTON)
self.search_close_btn.set_image(close_image)
self.search_entry = Gtk.SearchEntry()
self.search_prev_btn = Gtk.Button()
self.search_prev_btn.set_can_focus(False)
prev_icon = Gio.ThemedIcon(name='go-up-symbolic')
prev_icon = Gio.ThemedIcon(name="go-up-symbolic")
prev_image = Gtk.Image.new_from_gicon(prev_icon, Gtk.IconSize.BUTTON)
self.search_prev_btn.set_image(prev_image)
self.search_next_btn = Gtk.Button()
self.search_next_btn.set_can_focus(False)
next_icon = Gio.ThemedIcon(name='go-down-symbolic')
next_icon = Gio.ThemedIcon(name="go-down-symbolic")
next_image = Gtk.Image.new_from_gicon(next_icon, Gtk.IconSize.BUTTON)
self.search_next_btn.set_image(next_image)
@ -121,16 +121,13 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
# Frame
self.search_frame.set_margin_end(12)
self.search_frame.get_style_context().add_class('background')
self.search_frame.get_style_context().add_class("background")
css_provider = Gtk.CssProvider()
css_provider.load_from_data(
b'#search-frame border {'
b' padding: 5px 5px 5px 5px;'
b' border: none;'
b'}'
b"#search-frame border {" b" padding: 5px 5px 5px 5px;" b" border: none;" b"}"
)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
Gdk.Screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
)
# Add to revealer
@ -144,14 +141,14 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
self.add_overlay(self.search_revealer)
# Events
self.search_entry.connect('key-press-event', self.on_search_entry_keypress)
self.search_entry.connect('changed', self.set_search)
self.search_entry.connect('activate', self.do_search)
self.search_entry.connect('focus-in-event', self.on_search_entry_focus_in)
self.search_entry.connect('focus-out-event', self.on_search_entry_focus_out)
self.search_next_btn.connect('clicked', self.on_search_next_clicked)
self.search_prev_btn.connect('clicked', self.on_search_prev_clicked)
self.search_close_btn.connect('clicked', self.close_search_box)
self.search_entry.connect("key-press-event", self.on_search_entry_keypress)
self.search_entry.connect("changed", self.set_search)
self.search_entry.connect("activate", self.do_search)
self.search_entry.connect("focus-in-event", self.on_search_entry_focus_in)
self.search_entry.connect("focus-out-event", self.on_search_entry_focus_out)
self.search_next_btn.connect("clicked", self.on_search_next_clicked)
self.search_prev_btn.connect("clicked", self.on_search_prev_clicked)
self.search_close_btn.connect("clicked", self.close_search_box)
self.search_prev = True
# Search revealer visible
@ -161,9 +158,9 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
self.search_revealer.hide()
self.search_revealer_show_cb_id = self.search_revealer.connect(
'show', search_revealer_show_cb
"show", search_revealer_show_cb
)
self.search_frame.connect('unmap', lambda x: self.search_revealer.hide())
self.search_frame.connect("unmap", lambda x: self.search_revealer.hide())
def get_terminals(self):
return self.get_child().get_terminals()
@ -211,21 +208,23 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
a full binary tree in list.
"""
if not box:
panes.append({'type': None, 'directory': None})
panes.append({"type": None, "directory": None})
return
if isinstance(box, DualTerminalBox):
btype = 'dual' + ('_h' if box.orient is DualTerminalBox.ORIENT_V else '_v')
panes.append({'type': btype, 'directory': None})
btype = "dual" + ("_h" if box.orient is DualTerminalBox.ORIENT_V else "_v")
panes.append({"type": btype, "directory": None})
self.save_box_layout(box.get_child1(), panes)
self.save_box_layout(box.get_child2(), panes)
elif isinstance(box, TerminalBox):
btype = 'term'
btype = "term"
directory = box.terminal.get_current_directory()
panes.append({
'type': btype,
'directory': directory,
'custom_colors': box.terminal.get_custom_colors_dict(),
})
panes.append(
{
"type": btype,
"directory": directory,
"custom_colors": box.terminal.get_custom_colors_dict(),
}
)
def restore_box_layout(self, box, panes: list):
"""Restore box layout by `panes`
@ -237,7 +236,7 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
return
cur = panes.pop(0)
if cur['type'].startswith('dual'):
if cur["type"].startswith("dual"):
while True:
if self.guake:
# If Guake are not visible, we should pending the restore, then do the
@ -246,8 +245,9 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
# Otherwise we will stuck in the infinite loop, since new DualTerminalBox
# cannot get any allocation when Guake is invisible
if (
not self.guake.window.get_property('visible') or self.get_notebook() is
not self.guake.notebook_manager.get_current_notebook()
not self.guake.window.get_property("visible")
or self.get_notebook()
is not self.guake.notebook_manager.get_current_notebook()
):
panes.insert(0, cur)
self.guake._failed_restore_page_split.append((self, box, panes))
@ -256,7 +256,7 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
# UI didn't update, wait for it
alloc = box.get_allocation()
if alloc.width == 1 and alloc.height == 1:
time.sleep(.01)
time.sleep(0.01)
else:
break
@ -264,7 +264,7 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
while Gtk.events_pending():
Gtk.main_iteration()
if cur['type'].endswith('v'):
if cur["type"].endswith("v"):
box = box.split_v()
else:
box = box.split_h()
@ -282,8 +282,8 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
box.unset_terminal()
# Replace term in the TerminalBox
term = self.get_notebook().terminal_spawn(cur['directory'])
term.set_custom_colors_from_dict(cur.get('custom_colors', None))
term = self.get_notebook().terminal_spawn(cur["directory"])
term.set_custom_colors_from_dict(cur.get("custom_colors", None))
box.set_terminal(term)
self.get_notebook().terminal_attached(term)
@ -306,14 +306,12 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
def block_notebook_on_button_press_id(self):
GObject.signal_handler_block(
self.get_notebook(),
self.get_notebook().notebook_on_button_press_id
self.get_notebook(), self.get_notebook().notebook_on_button_press_id
)
def unblock_notebook_on_button_press_id(self):
GObject.signal_handler_unblock(
self.get_notebook(),
self.get_notebook().notebook_on_button_press_id
self.get_notebook(), self.get_notebook().notebook_on_button_press_id
)
def show_search_box(self):
@ -357,9 +355,9 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
def on_search_entry_keypress(self, widget, event):
key = Gdk.keyval_name(event.keyval)
if key == 'Escape':
if key == "Escape":
self.hide_search_box()
elif key == 'Return':
elif key == "Return":
# Combine with Shift?
if event.state & Gdk.ModifierType.SHIFT_MASK:
self.search_prev = False
@ -368,7 +366,7 @@ class RootTerminalBox(Gtk.Overlay, TerminalHolder):
self.search_prev = True
def reset_term_search(self, term):
term.search_set_gregex(GLib.Regex('', 0, 0), 0)
term.search_set_gregex(GLib.Regex("", 0, 0), 0)
term.search_find_next()
def set_search(self, widget):
@ -417,7 +415,7 @@ class TerminalBox(Gtk.Box, TerminalHolder):
self.terminal.connect("button-press-event", self.on_button_press, None)
)
self.terminal.handler_ids.append(
self.terminal.connect('child-exited', self.on_terminal_exited)
self.terminal.connect("child-exited", self.on_terminal_exited)
)
self.pack_start(self.terminal, True, True, 0)
self.terminal.show()
@ -432,7 +430,7 @@ class TerminalBox(Gtk.Box, TerminalHolder):
self.pack_start(self.scroll, False, False, 0)
self.terminal.handler_ids.append(
self.terminal.connect('scroll-event', self.__scroll_event_cb)
self.terminal.connect("scroll-event", self.__scroll_event_cb)
)
def __scroll_event_cb(self, widget, event):
@ -440,8 +438,8 @@ class TerminalBox(Gtk.Box, TerminalHolder):
adj = self.scroll.get_adjustment()
page_size = adj.get_page_size()
if (
event.get_state() & Gdk.ModifierType.SHIFT_MASK and
event.get_state() & Gdk.ModifierType.CONTROL_MASK
event.get_state() & Gdk.ModifierType.SHIFT_MASK
and event.get_state() & Gdk.ModifierType.CONTROL_MASK
):
# Ctrl + Shift + Mouse Scroll (4 pages)
adj.set_page_increment(page_size * 40)
@ -516,7 +514,7 @@ class TerminalBox(Gtk.Box, TerminalHolder):
return self.get_parent().get_notebook()
def remove_dead_child(self, child):
print("Can't do, have no \"child\"")
print('Can\'t do, have no "child"')
def on_terminal_focus(self, *args):
self.get_root_box().set_last_terminal_focused(self.terminal)
@ -534,11 +532,15 @@ class TerminalBox(Gtk.Box, TerminalHolder):
return True
menu = mk_terminal_context_menu(
self.terminal, self.get_window(), self.get_settings(),
self.terminal,
self.get_window(),
self.get_settings(),
TerminalContextMenuCallbacks(
self.terminal, self.get_window(), self.get_settings(),
self.get_root_box().get_notebook()
)
self.terminal,
self.get_window(),
self.get_settings(),
self.get_root_box().get_notebook(),
),
)
menu.connect("hide", MenuHideCallback(self.get_window()).on_hide)
HidePrevention(self.get_window()).prevent()
@ -635,7 +637,6 @@ class DualTerminalBox(Gtk.Paned, TerminalHolder):
class TabLabelEventBox(Gtk.EventBox):
def __init__(self, notebook, text, settings):
super().__init__()
self.notebook = notebook
@ -643,11 +644,11 @@ class TabLabelEventBox(Gtk.EventBox):
self.label = Gtk.Label(text, visible=True)
self.close_button = Gtk.Button(
image=Gtk.Image.new_from_icon_name("window-close", Gtk.IconSize.MENU),
relief=Gtk.ReliefStyle.NONE
relief=Gtk.ReliefStyle.NONE,
)
self.close_button.connect('clicked', self.on_close)
self.close_button.connect("clicked", self.on_close)
settings.general.bind(
'tab-close-buttons', self.close_button, 'visible', Gio.SettingsBindFlags.GET
"tab-close-buttons", self.close_button, "visible", Gio.SettingsBindFlags.GET
)
self.box.pack_start(self.label, True, True, 0)
self.box.pack_end(self.close_button, False, False, 0)
@ -677,7 +678,7 @@ class TabLabelEventBox(Gtk.EventBox):
menu.popup(None, None, None, None, event.button, event.get_time())
return True
if event.button == 2:
prompt_cfg = self.notebook.guake.settings.general.get_int('prompt-on-close-tab')
prompt_cfg = self.notebook.guake.settings.general.get_int("prompt-on-close-tab")
self.notebook.delete_page_by_label(self, prompt=prompt_cfg)
return True
if event.button == 1 and event.type == Gdk.EventType._2BUTTON_PRESS:
@ -716,5 +717,5 @@ class TabLabelEventBox(Gtk.EventBox):
self.grab_focus_on_last_focused_terminal()
def on_close(self, user_data):
prompt_cfg = self.notebook.guake.settings.general.get_int('prompt-on-close-tab')
prompt_cfg = self.notebook.guake.settings.general.get_int("prompt-on-close-tab")
self.notebook.delete_page_by_label(self, prompt=prompt_cfg)

15
guake/callbacks.py
View File

@ -1,5 +1,6 @@
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gdk
from gi.repository import Gtk
from guake.about import AboutDialog
@ -13,8 +14,7 @@ from guake.utils import get_server_time
from urllib.parse import quote_plus
class TerminalContextMenuCallbacks():
class TerminalContextMenuCallbacks:
def __init__(self, terminal, window, settings, notebook):
self.terminal = terminal
self.window = window
@ -87,15 +87,13 @@ class TerminalContextMenuCallbacks():
self.terminal.kill()
class NotebookScrollCallback():
class NotebookScrollCallback:
def __init__(self, notebook):
self.notebook = notebook
def on_scroll(self, widget, event):
direction = event.get_scroll_direction().direction
if direction is Gdk.ScrollDirection.DOWN or \
direction is Gdk.ScrollDirection.RIGHT:
if direction is Gdk.ScrollDirection.DOWN or direction is Gdk.ScrollDirection.RIGHT:
self.notebook.next_page()
else:
self.notebook.prev_page()
@ -104,8 +102,7 @@ class NotebookScrollCallback():
return True
class MenuHideCallback():
class MenuHideCallback:
def __init__(self, window):
self.window = window

34
guake/common.py
View File

@ -23,8 +23,9 @@ import os
import sys
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Vte', '2.91') # vte-0.38
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91") # vte-0.38
from gi.repository import Gtk
from guake.paths import GLADE_DIR
@ -33,20 +34,22 @@ from guake.paths import IMAGE_DIR
log = logging.getLogger(__name__)
__all__ = [
'get_binaries_from_path',
'gladefile',
'hexify_color',
'pixmapfile',
'ShowableError',
"get_binaries_from_path",
"gladefile",
"hexify_color",
"pixmapfile",
"ShowableError",
]
def ShowableError(parent, title, msg, exit_code=1):
d = Gtk.MessageDialog(
parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.WARNING, Gtk.ButtonsType.CLOSE
parent,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.WARNING,
Gtk.ButtonsType.CLOSE,
)
d.set_markup('<b><big>%s</big></b>' % title)
d.set_markup("<b><big>%s</big></b>" % title)
d.format_secondary_markup(msg)
d.run()
d.destroy()
@ -55,28 +58,27 @@ def ShowableError(parent, title, msg, exit_code=1):
def pixmapfile(x):
f = os.path.join(IMAGE_DIR, x)
if not os.path.exists(f):
raise IOError('No such file or directory: %s' % f)
raise IOError("No such file or directory: %s" % f)
return os.path.abspath(f)
def gladefile(x):
f = os.path.join(GLADE_DIR, x)
if not os.path.exists(f):
raise IOError('No such file or directory: %s' % f)
raise IOError("No such file or directory: %s" % f)
return os.path.abspath(f)
def hexify_color(c):
def h(x):
return hex(x).replace('0x', '').zfill(4)
return hex(x).replace("0x", "").zfill(4)
return '#%s%s%s' % (h(c.red), h(c.green), h(c.blue))
return "#%s%s%s" % (h(c.red), h(c.green), h(c.blue))
def get_binaries_from_path(compiled_re):
ret = []
for i in os.environ.get('PATH', '').split(os.pathsep):
for i in os.environ.get("PATH", "").split(os.pathsep):
if os.path.isdir(i):
for j in os.listdir(i):
if compiled_re.match(j):

21
guake/customcommands.py
View File

@ -5,13 +5,14 @@ import gi
import logging
from locale import gettext as _
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
log = logging.getLogger(__name__)
class CustomCommands():
class CustomCommands:
"""
Example for a custom commands file
@ -42,11 +43,11 @@ class CustomCommands():
self.callback = callback
def should_load(self):
file_path = self.settings.general.get_string('custom-command-file')
file_path = self.settings.general.get_string("custom-command-file")
return file_path is not None
def get_file_path(self):
return os.path.expanduser(self.settings.general.get_string('custom-command-file'))
return os.path.expanduser(self.settings.general.get_string("custom-command-file"))
def _load_json(self, file_name):
if not os.path.exists(file_name):
@ -71,20 +72,20 @@ class CustomCommands():
return menu
def _parse_custom_commands(self, json_object, menu):
if json_object.get('type') == "menu":
if json_object.get("type") == "menu":
newmenu = Gtk.Menu()
newmenuitem = Gtk.MenuItem(json_object['description'])
newmenuitem = Gtk.MenuItem(json_object["description"])
newmenuitem.set_submenu(newmenu)
newmenuitem.show()
menu.append(newmenuitem)
for item in json_object['items']:
for item in json_object["items"]:
self._parse_custom_commands(item, newmenu)
else:
menu_item = Gtk.MenuItem(json_object['description'])
menu_item = Gtk.MenuItem(json_object["description"])
custom_command = ""
space = ""
for command in json_object['cmd']:
custom_command += (space + command)
for command in json_object["cmd"]:
custom_command += space + command
space = " "
menu_item.connect("activate", self.on_menu_item_activated, custom_command)
menu.append(menu_item)

56
guake/dbusiface.py
View File

@ -28,12 +28,11 @@ log = logging.getLogger(__name__)
dbus.glib.threads_init()
DBUS_PATH = '/org/guake3/RemoteControl'
DBUS_NAME = 'org.guake3.RemoteControl'
DBUS_PATH = "/org/guake3/RemoteControl"
DBUS_NAME = "org.guake3.RemoteControl"
class DbusManager(dbus.service.Object):
def __init__(self, guakeinstance):
self.guake = guakeinstance
self.bus = dbus.SessionBus()
@ -70,35 +69,36 @@ class DbusManager(dbus.service.Object):
def unfullscreen(self):
self.guake.unfullscreen()
@dbus.service.method(DBUS_NAME, in_signature='s')
def add_tab(self, directory=''):
@dbus.service.method(DBUS_NAME, in_signature="s")
def add_tab(self, directory=""):
return self.guake.add_tab(directory)
@dbus.service.method(DBUS_NAME, in_signature='i')
@dbus.service.method(DBUS_NAME, in_signature="i")
def select_tab(self, tab_index=0):
return self.guake.get_notebook().set_current_page(int(tab_index))
@dbus.service.method(DBUS_NAME, out_signature='i')
@dbus.service.method(DBUS_NAME, out_signature="i")
def get_selected_tab(self):
return self.guake.get_notebook().get_current_page()
@dbus.service.method(DBUS_NAME, out_signature='s')
@dbus.service.method(DBUS_NAME, out_signature="s")
def get_selected_tablabel(self):
return self.guake.get_notebook(
).get_tab_text_index(self.guake.get_notebook().get_current_page())
return self.guake.get_notebook().get_tab_text_index(
self.guake.get_notebook().get_current_page()
)
@dbus.service.method(DBUS_NAME, out_signature='i')
@dbus.service.method(DBUS_NAME, out_signature="i")
def get_tab_count(self):
return len(self.guake.notebook_manager.get_terminals())
@dbus.service.method(DBUS_NAME, in_signature='i')
@dbus.service.method(DBUS_NAME, in_signature="i")
def select_terminal(self, term_index=0):
notebook = self.guake.get_notebook()
current_page_index = notebook.get_current_page()
terminals = notebook.get_terminals_for_page(current_page_index)
return terminals[term_index].grab_focus()
@dbus.service.method(DBUS_NAME, out_signature='i')
@dbus.service.method(DBUS_NAME, out_signature="i")
def get_selected_terminal(self):
notebook = self.guake.get_notebook()
current_page_index = notebook.get_current_page()
@ -108,30 +108,30 @@ class DbusManager(dbus.service.Object):
return i
return -1
@dbus.service.method(DBUS_NAME, out_signature='i')
@dbus.service.method(DBUS_NAME, out_signature="i")
def get_term_count(self):
notebook = self.guake.get_notebook()
current_page_index = notebook.get_current_page()
terminals = notebook.get_terminals_for_page(current_page_index)
return len(terminals)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def set_bgcolor(self, bgcolor):
return self.guake.set_bgcolor(bgcolor)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def set_fgcolor(self, fgcolor):
return self.guake.set_fgcolor(fgcolor)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def set_bgcolor_current_terminal(self, bgcolor):
return self.guake.set_bgcolor(bgcolor, current_terminal_only=True)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def set_fgcolor_current_terminal(self, fgcolor):
return self.guake.set_fgcolor(fgcolor, current_terminal_only=True)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def change_palette_name(self, palette_name):
self.guake.change_palette_name(palette_name)
@ -145,23 +145,23 @@ class DbusManager(dbus.service.Object):
self.guake.reset_terminal_custom_colors(current_terminal=True)
self.guake.set_colors_from_settings_on_page(current_terminal_only=True)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def execute_command(self, command):
self.guake.execute_command(command)
@dbus.service.method(DBUS_NAME, in_signature='i', out_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="i", out_signature="s")
def get_tab_name(self, tab_index=0):
return self.guake.get_notebook().get_tab_text_index(tab_index)
@dbus.service.method(DBUS_NAME, in_signature='ss')
@dbus.service.method(DBUS_NAME, in_signature="ss")
def rename_tab_uuid(self, tab_uuid, new_text):
self.guake.rename_tab_uuid(tab_uuid, new_text, True)
@dbus.service.method(DBUS_NAME, in_signature='is')
@dbus.service.method(DBUS_NAME, in_signature="is")
def rename_tab(self, tab_index, new_text):
self.guake.get_notebook().rename_page(tab_index, new_text, True)
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def rename_current_tab(self, new_text):
self.guake.rename_current_tab(new_text, True)
@ -177,15 +177,15 @@ class DbusManager(dbus.service.Object):
def quit(self):
self.guake.quit()
@dbus.service.method(DBUS_NAME, in_signature='i', out_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="i", out_signature="s")
def get_gtktab_name(self, tab_index=0):
return self.guake.get_notebook().get_tab_text_index(tab_index)
@dbus.service.method(DBUS_NAME, out_signature='s')
@dbus.service.method(DBUS_NAME, out_signature="s")
def get_selected_uuidtab(self):
return self.guake.get_selected_uuidtab()
@dbus.service.method(DBUS_NAME, in_signature='ss')
@dbus.service.method(DBUS_NAME, in_signature="ss")
def execute_command_by_uuid(self, tab_uuid, command):
self.guake.execute_command_by_uuid(tab_uuid, command)
@ -197,6 +197,6 @@ class DbusManager(dbus.service.Object):
def h_split_current_terminal(self):
self.guake.get_notebook().get_current_terminal().get_parent().split_h()
@dbus.service.method(DBUS_NAME, in_signature='s')
@dbus.service.method(DBUS_NAME, in_signature="s")
def execute_command_current_termbox(self, command):
self.guake.get_notebook().get_current_terminal().execute_command(command)

39
guake/dialogs.py
View File

@ -1,19 +1,21 @@
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from locale import gettext as _
class RenameDialog(Gtk.Dialog):
def __init__(self, window, current_name):
super().__init__(
_("Rename tab"), window, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT)
_("Rename tab"),
window,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT,),
)
self.entry = Gtk.Entry()
self.entry.set_text(current_name)
self.entry.set_property('can-default', True)
self.entry.set_property("can-default", True)
self.entry.show()
vbox = Gtk.VBox()
@ -38,14 +40,16 @@ class PromptQuitDialog(Gtk.MessageDialog):
def __init__(self, parent, procs, tabs, notebooks):
super(PromptQuitDialog, self).__init__(
parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO
parent,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.QUESTION,
Gtk.ButtonsType.YES_NO,
)
if tabs == -1:
primary_msg = _("Do you want to close the tab?")
tab_str = ''
notebooks_str = ''
tab_str = ""
notebooks_str = ""
else:
primary_msg = _("Do you really want to quit Guake?")
if tabs == 1:
@ -53,9 +57,9 @@ class PromptQuitDialog(Gtk.MessageDialog):
else:
tab_str = _(" and {0} tabs open").format(tabs)
if notebooks > 1:
notebooks_str = _(' on {0} workspaces').format(notebooks)
notebooks_str = _(" on {0} workspaces").format(notebooks)
else:
notebooks_str = ''
notebooks_str = ""
if procs == 0:
proc_str = _("There are no processes running")
@ -94,8 +98,10 @@ class PromptResetColorsDialog(Gtk.MessageDialog):
def __init__(self, parent):
super(PromptResetColorsDialog, self).__init__(
parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO
parent,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.QUESTION,
Gtk.ButtonsType.YES_NO,
)
primary_msg = _("Do you want to reset custom colors for this tab?")
@ -115,11 +121,12 @@ class PromptResetColorsDialog(Gtk.MessageDialog):
class SaveTerminalDialog(Gtk.FileChooserDialog):
def __init__(self, terminal, window):
super().__init__(
_("Save to..."), window, Gtk.FileChooserAction.SAVE,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK)
_("Save to..."),
window,
Gtk.FileChooserAction.SAVE,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.OK,),
)
self.set_default_response(Gtk.ResponseType.OK)
self.terminal = terminal

42
guake/globals.py
View File

@ -23,13 +23,13 @@ import logging
import os
__all__ = [
'ALIGN_BOTTOM',
'ALIGN_CENTER',
'ALIGN_LEFT',
'ALIGN_RIGHT',
'ALIGN_TOP',
'ALWAYS_ON_PRIMARY',
'NAME',
"ALIGN_BOTTOM",
"ALIGN_CENTER",
"ALIGN_LEFT",
"ALIGN_RIGHT",
"ALIGN_TOP",
"ALWAYS_ON_PRIMARY",
"NAME",
]
log = logging.getLogger(__name__)
@ -49,9 +49,12 @@ def bindtextdomain(app_name, locale_dir=None):
If omitted or None, then the current binding for app_name is used.
"""
# pylint: disable=import-outside-toplevel
import locale
from locale import gettext as _
# pylint: enable=import-outside-toplevel
log.info("Local binding for app '%s', local dir: %s", app_name, locale_dir)
locale.bindtextdomain(app_name, locale_dir)
@ -60,10 +63,10 @@ def bindtextdomain(app_name, locale_dir=None):
def is_run_from_git_workdir():
self_path = os.path.abspath(inspect.getfile(inspect.currentframe()))
return os.path.exists('%s.in' % self_path)
return os.path.exists("%s.in" % self_path)
NAME = 'guake'
NAME = "guake"
ALIGN_CENTER, ALIGN_LEFT, ALIGN_RIGHT = range(3)
ALIGN_TOP, ALIGN_BOTTOM = range(2)
@ -71,16 +74,16 @@ ALWAYS_ON_PRIMARY = -1
# TODO this is not as fancy as as it could be
# pylint: disable=anomalous-backslash-in-string
TERMINAL_MATCH_TAGS = ('schema', 'http', 'https', 'email', 'ftp')
TERMINAL_MATCH_TAGS = ("schema", "http", "https", "email", "ftp")
# Beware this is a PRCE (Perl) regular expression, not a Python one!
# Edit: use regex101.com with PCRE syntax
TERMINAL_MATCH_EXPRS = [
"(news:|telnet:|nntp:|file:\/|https?:|ftps?:|webcal:)\/\/([-[:alnum:]]+"
"(:[-[:alnum:],?;.:\/!%$^\*&~\"#']+)?\@)?[-[:alnum:]]+(\.[-[:alnum:]]+)*"
"(:[0-9]{1,5})?(\/[-[:alnum:]_$.+!*(),;:@&=?\/~#'%]*[^].> \t\r\n,\\\"])?",
"(www|ftp)[-[:alnum:]]*\.[-[:alnum:]]+(\.[-[:alnum:]]+)*(:[0-9]{1,5})?"
"(\/[-[:alnum:]_$.+!*(),;:@&=?\/~#%]*[^]'.>) \t\r\n,\\\"])?",
"(mailto:)?[-[:alnum:]][-[:alnum:].]*@[-[:alnum:]]+\.[-[:alnum:]]+(\\.[-[:alnum:]]+)*"
r"(news:|telnet:|nntp:|file:\/|https?:|ftps?:|webcal:)\/\/([-[:alnum:]]+"
r"(:[-[:alnum:],?;.:\/!%$^\*&~\"#']+)?\@)?[-[:alnum:]]+(\.[-[:alnum:]]+)*"
r"(:[0-9]{1,5})?(\/[-[:alnum:]_$.+!*(),;:@&=?\/~#'%]*[^].> \t\r\n,\\\"])?",
r"(www|ftp)[-[:alnum:]]*\.[-[:alnum:]]+(\.[-[:alnum:]]+)*(:[0-9]{1,5})?"
r"(\/[-[:alnum:]_$.+!*(),;:@&=?\/~#%]*[^]'.>) \t\r\n,\\\"])?",
r"(mailto:)?[-[:alnum:]][-[:alnum:].]*@[-[:alnum:]]+\.[-[:alnum:]]+(\\.[-[:alnum:]]+)*",
]
# tuple (title/quick matcher/filename and line number extractor)
QUICK_OPEN_MATCHERS = [
@ -88,16 +91,13 @@ QUICK_OPEN_MATCHERS = [
"Python traceback",
r"^\s*File\s\".*\",\sline\s[0-9]+",
r"^\s*File\s\"(.*)\",\sline\s([0-9]+)",
), (
"Python pytest report",
r"^\s.*\:\:[a-zA-Z0-9\_]+\s",
r"^\s*(.*\:\:[a-zA-Z0-9\_]+)\s",
),
("Python pytest report", r"^\s.*\:\:[a-zA-Z0-9\_]+\s", r"^\s*(.*\:\:[a-zA-Z0-9\_]+)\s",),
(
"line starts by 'Filename:line' pattern (GCC/make). File path should exists.",
r"^\s*[a-zA-Z0-9\/\_\-\.\ ]+\.?[a-zA-Z0-9]+\:[0-9]+",
r"^\s*(.*)\:([0-9]+)",
)
),
]
# Transparency max level (should be always 100)

196
guake/gsettings.py
View File

@ -23,8 +23,9 @@ import subprocess
from xml.sax.saxutils import escape as xml_escape
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Vte', '2.91') # vte-0.38
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91") # vte-0.38
from gi.repository import Gdk
from gi.repository import Gio
from gi.repository import Gtk
@ -38,7 +39,7 @@ from locale import gettext as _
log = logging.getLogger(__name__)
class GSettingHandler():
class GSettingHandler:
"""Handles gconf changes, if any gconf variable is changed, a
different method is called to handle this change.
@ -56,40 +57,40 @@ class GSettingHandler():
# set_final_window_rect polls gconf and is called whenever Guake is
# shown or resized
settings.general.onChangedValue('use-trayicon', self.trayicon_toggled)
settings.general.onChangedValue('window-ontop', self.ontop_toggled)
settings.general.onChangedValue('tab-ontop', self.tab_ontop_toggled)
settings.general.onChangedValue('window-tabbar', self.tabbar_toggled)
settings.general.onChangedValue("use-trayicon", self.trayicon_toggled)
settings.general.onChangedValue("window-ontop", self.ontop_toggled)
settings.general.onChangedValue("tab-ontop", self.tab_ontop_toggled)
settings.general.onChangedValue("window-tabbar", self.tabbar_toggled)
settings.general.onChangedValue(
'fullscreen-hide-tabbar', self.fullscreen_hide_tabbar_toggled
"fullscreen-hide-tabbar", self.fullscreen_hide_tabbar_toggled
)
settings.general.onChangedValue('window-height', self.size_changed)
settings.general.onChangedValue('window-width', self.size_changed)
settings.general.onChangedValue('window-valignment', self.alignment_changed)
settings.general.onChangedValue('window-halignment', self.alignment_changed)
settings.general.onChangedValue('window-vertical-displacement', self.alignment_changed)
settings.general.onChangedValue('window-horizontal-displacement', self.alignment_changed)
settings.style.onChangedValue('cursor-blink-mode', self.cursor_blink_mode_changed)
settings.style.onChangedValue('cursor-shape', self.cursor_shape_changed)
settings.general.onChangedValue("window-height", self.size_changed)
settings.general.onChangedValue("window-width", self.size_changed)
settings.general.onChangedValue("window-valignment", self.alignment_changed)
settings.general.onChangedValue("window-halignment", self.alignment_changed)
settings.general.onChangedValue("window-vertical-displacement", self.alignment_changed)
settings.general.onChangedValue("window-horizontal-displacement", self.alignment_changed)
settings.style.onChangedValue("cursor-blink-mode", self.cursor_blink_mode_changed)
settings.style.onChangedValue("cursor-shape", self.cursor_shape_changed)
settings.general.onChangedValue('use-scrollbar', self.scrollbar_toggled)
settings.general.onChangedValue('history-size', self.history_size_changed)
settings.general.onChangedValue('infinite-history', self.infinite_history_changed)
settings.general.onChangedValue('scroll-output', self.keystroke_output)
settings.general.onChangedValue('scroll-keystroke', self.keystroke_toggled)
settings.general.onChangedValue("use-scrollbar", self.scrollbar_toggled)
settings.general.onChangedValue("history-size", self.history_size_changed)
settings.general.onChangedValue("infinite-history", self.infinite_history_changed)
settings.general.onChangedValue("scroll-output", self.keystroke_output)
settings.general.onChangedValue("scroll-keystroke", self.keystroke_toggled)
settings.general.onChangedValue('use-default-font', self.default_font_toggled)
settings.styleFont.onChangedValue('style', self.fstyle_changed)
settings.styleFont.onChangedValue('palette', self.fpalette_changed)
settings.styleFont.onChangedValue('allow-bold', self.allow_bold_toggled)
settings.styleFont.onChangedValue('bold-is-bright', self.bold_is_bright_toggled)
settings.styleBackground.onChangedValue('transparency', self.bgtransparency_changed)
settings.general.onChangedValue("use-default-font", self.default_font_toggled)
settings.styleFont.onChangedValue("style", self.fstyle_changed)
settings.styleFont.onChangedValue("palette", self.fpalette_changed)
settings.styleFont.onChangedValue("allow-bold", self.allow_bold_toggled)
settings.styleFont.onChangedValue("bold-is-bright", self.bold_is_bright_toggled)
settings.styleBackground.onChangedValue("transparency", self.bgtransparency_changed)
settings.general.onChangedValue('compat-backspace', self.backspace_changed)
settings.general.onChangedValue('compat-delete', self.delete_changed)
settings.general.onChangedValue('custom-command_file', self.custom_command_file_changed)
settings.general.onChangedValue('max-tab-name-length', self.max_tab_name_length_changed)
settings.general.onChangedValue('display-tab-names', self.display_tab_names_changed)
settings.general.onChangedValue("compat-backspace", self.backspace_changed)
settings.general.onChangedValue("compat-delete", self.delete_changed)
settings.general.onChangedValue("custom-command_file", self.custom_command_file_changed)
settings.general.onChangedValue("max-tab-name-length", self.max_tab_name_length_changed)
settings.general.onChangedValue("display-tab-names", self.display_tab_names_changed)
def custom_command_file_changed(self, settings, key, user_data):
self.guake.load_custom_commands()
@ -98,7 +99,7 @@ class GSettingHandler():
"""If the gconf var use_trayicon be changed, this method will
be called and will show/hide the trayicon.
"""
if hasattr(self.guake.tray_icon, 'set_status'):
if hasattr(self.guake.tray_icon, "set_status"):
self.guake.tray_icon.set_status(settings.get_boolean(key))
else:
self.guake.tray_icon.set_visible(settings.get_boolean(key))
@ -154,18 +155,24 @@ class GSettingHandler():
def cursor_blink_mode_changed(self, settings, key, user_data):
"""Called when cursor blink mode settings has been changed
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for term in terminals:
term.set_property("cursor-blink-mode", settings.get_int(key))
def cursor_shape_changed(self, settings, key, user_data):
"""Called when the cursor shape settings has been changed
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for term in terminals:
term.set_property("cursor-shape", settings.get_int(key))
@ -173,9 +180,12 @@ class GSettingHandler():
"""If the gconf var use_scrollbar be changed, this method will
be called and will show/hide scrollbars of all terminals open.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for term in terminals:
# There is an hbox in each tab of the main notebook and it
# contains a Terminal and a Scrollbar. Since only have the
@ -196,9 +206,12 @@ class GSettingHandler():
terminals open.
"""
lines = settings.get_int(key)
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_scrollback_lines(lines)
@ -207,9 +220,12 @@ class GSettingHandler():
lines = -1
else:
lines = self.settings.general.get_int("history-size")
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_scrollback_lines(lines)
@ -218,9 +234,12 @@ class GSettingHandler():
be called and will set the scroll_on_output in all terminals
open.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_scroll_on_output(settings.get_boolean(key))
@ -229,9 +248,12 @@ class GSettingHandler():
will be called and will set the scroll_on_keystroke in all
terminals open.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_scroll_on_keystroke(settings.get_boolean(key))
@ -243,10 +265,10 @@ class GSettingHandler():
"""
font_name = None
if settings.get_boolean(key):
gio_settings = Gio.Settings('org.gnome.desktop.interface')
font_name = gio_settings.get_string('monospace-font-name')
gio_settings = Gio.Settings("org.gnome.desktop.interface")
font_name = gio_settings.get_string("monospace-font-name")
else:
font_name = self.settings.styleFont.get_string('style')
font_name = self.settings.styleFont.get_string("style")
if not font_name:
log.error("Error: unable to find font name (%s)", font_name)
return
@ -254,9 +276,12 @@ class GSettingHandler():
if not font:
log.error("Error: unable to load font (%s)", font_name)
return
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_font(font)
@ -265,9 +290,12 @@ class GSettingHandler():
and will change the VTE terminal o.
displaying characters in bold font.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for term in terminals:
term.set_allow_bold(settings.get_boolean(key))
@ -277,9 +305,9 @@ class GSettingHandler():
"""
try:
terminal = self.guake.notebook_manager.get_terminal_by_uuid(
user_data.get('terminal_uuid') if user_data else None
user_data.get("terminal_uuid") if user_data else None
)
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for term in terminals:
term.set_bold_is_bright(settings.get_boolean(key))
except: # pylint: disable=bare-except
@ -290,18 +318,18 @@ class GSettingHandler():
will be called and will change the font color and the background color to the color
defined in the palette.
"""
self.settings.styleFont.triggerOnChangedValue(self.settings.styleFont, 'palette')
self.settings.styleFont.triggerOnChangedValue(self.settings.styleFont, "palette")
def fstyle_changed(self, settings, key, user_data):
"""If the gconf var style/font/style be changed, this method
will be called and will change the font style in all terminals
open.
"""
terminal_uuid = user_data.get('terminal_uuid') if user_data else None
terminal_uuid = user_data.get("terminal_uuid") if user_data else None
if terminal_uuid:
terminal = self.guake.notebook_manager.get_terminal_by_uuid(terminal_uuid)
terminals = (terminal, ) if terminal else tuple()
terminals = (terminal,) if terminal else tuple()
else:
terminals = self.guake.notebook_manager.iter_terminals()
@ -315,7 +343,7 @@ class GSettingHandler():
open.
"""
self.guake.set_colors_from_settings(
terminal_uuid=user_data.get('terminal_uuid') if user_data else None
terminal_uuid=user_data.get("terminal_uuid") if user_data else None
)
def bgtransparency_changed(self, settings, key, user_data):
@ -324,7 +352,7 @@ class GSettingHandler():
properties in all terminals open.
"""
self.guake.set_background_color_from_settings(
terminal_uuid=user_data.get('terminal_uuid') if user_data else None
terminal_uuid=user_data.get("terminal_uuid") if user_data else None
)
def getEraseBinding(self, str):
@ -344,9 +372,12 @@ class GSettingHandler():
will be called and will change the binding configuration in
all terminals open.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_backspace_binding(self.getEraseBinding(settings.get_string(key)))
@ -355,9 +386,12 @@ class GSettingHandler():
will be called and will change the binding configuration in
all terminals open.
"""
terminal = self.guake.notebook_manager.get_terminal_by_uuid(user_data.get('terminal_uuid'))\
if user_data else None
terminals = (terminal, ) if terminal else self.guake.notebook_manager.iter_terminals()
terminal = (
self.guake.notebook_manager.get_terminal_by_uuid(user_data.get("terminal_uuid"))
if user_data
else None
)
terminals = (terminal,) if terminal else self.guake.notebook_manager.iter_terminals()
for i in terminals:
i.set_delete_binding(self.getEraseBinding(settings.get_string(key)))
@ -370,8 +404,12 @@ class GSettingHandler():
if self.guake.notebook_manager.get_current_notebook().get_current_terminal() is None:
return
# avoid get window title before terminal is ready
if self.guake.notebook_manager.get_current_notebook().get_current_terminal(
).get_window_title() is None:
if (
self.guake.notebook_manager.get_current_notebook()
.get_current_terminal()
.get_window_title()
is None
):
return
self.guake.recompute_tabs_titles()
@ -380,5 +418,5 @@ class GSettingHandler():
"""If the gconf var display-tab-names was changed, this method will
be called and will update tab names.
"""
self.guake.display_tab_names = settings.get_int('display-tab-names')
self.guake.display_tab_names = settings.get_int("display-tab-names")
self.guake.recompute_tabs_titles()

425
guake/guake_app.py
View File

@ -34,10 +34,11 @@ from urllib.parse import quote_plus
from xml.sax.saxutils import escape as xml_escape
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version('Vte', '2.91') # vte-0.42
gi.require_version('Keybinder', '3.0')
gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
gi.require_version("Vte", "2.91") # vte-0.42
gi.require_version("Keybinder", "3.0")
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Gdk
@ -117,7 +118,6 @@ class Guake(SimpleGladeApp):
"""
def __init__(self):
def load_schema():
log.info("Loading Gnome schema from: %s", SCHEMA_DIR)
return Gio.SettingsSchemaSource.new_from_directory(
@ -134,15 +134,15 @@ class Guake(SimpleGladeApp):
log.info("Language previously loaded from: %s", LOCALE_DIR)
super(Guake, self).__init__(gladefile('guake.glade'))
super(Guake, self).__init__(gladefile("guake.glade"))
select_gtk_theme(self.settings)
patch_gtk_theme(self.get_widget("window-root").get_style_context(), self.settings)
self.add_callbacks(self)
log.info('Guake Terminal %s', guake_version())
log.info('VTE %s', vte_version())
log.info('Gtk %s', gtk_version())
log.info("Guake Terminal %s", guake_version())
log.info("VTE %s", vte_version())
log.info("Gtk %s", gtk_version())
self.hidden = True
self.forceHide = False
@ -150,15 +150,15 @@ class Guake(SimpleGladeApp):
# trayicon! Using SVG handles better different OS trays
# img = pixmapfile('guake-tray.svg')
# trayicon!
img = pixmapfile('guake-tray.png')
img = pixmapfile("guake-tray.png")
try:
import appindicator
import appindicator # pylint: disable=import-outside-toplevel
except ImportError:
self.tray_icon = Gtk.StatusIcon()
self.tray_icon.set_from_file(img)
self.tray_icon.set_tooltip_text(_("Guake Terminal"))
self.tray_icon.connect('popup-menu', self.show_menu)
self.tray_icon.connect('activate', self.show_hide)
self.tray_icon.connect("popup-menu", self.show_menu)
self.tray_icon.connect("activate", self.show_hide)
else:
# TODO PORT test this on a system with app indicator
self.tray_icon = appindicator.Indicator(
@ -166,20 +166,20 @@ class Guake(SimpleGladeApp):
)
self.tray_icon.set_icon(img)
self.tray_icon.set_status(appindicator.STATUS_ACTIVE)
menu = self.get_widget('tray-menu')
show = Gtk.MenuItem(_('Show'))
menu = self.get_widget("tray-menu")
show = Gtk.MenuItem(_("Show"))
show.set_sensitive(True)
show.connect('activate', self.show_hide)
show.connect("activate", self.show_hide)
show.show()
menu.prepend(show)
self.tray_icon.set_menu(menu)
# important widgets
self.window = self.get_widget('window-root')
self.window.set_name('guake-terminal')
self.window = self.get_widget("window-root")
self.window.set_name("guake-terminal")
self.window.set_keep_above(True)
self.mainframe = self.get_widget('mainframe')
self.mainframe.remove(self.get_widget('notebook-teminals'))
self.mainframe = self.get_widget("mainframe")
self.mainframe.remove(self.get_widget("notebook-teminals"))
# Pending restore for terminal split after show-up
# [(RootTerminalBox, TerminaBox, panes), ...]
@ -191,17 +191,19 @@ class Guake(SimpleGladeApp):
# Workspace tracking
self.notebook_manager = NotebookManager(
self.window, self.mainframe,
self.settings.general.get_boolean('workspace-specific-tab-sets'), self.terminal_spawned,
self.page_deleted
self.window,
self.mainframe,
self.settings.general.get_boolean("workspace-specific-tab-sets"),
self.terminal_spawned,
self.page_deleted,
)
self.notebook_manager.connect('notebook-created', self.notebook_created)
self.notebook_manager.connect("notebook-created", self.notebook_created)
self.notebook_manager.set_workspace(0)
self.set_tab_position()
# check and set ARGB for real transparency
self.update_visual()
self.window.get_screen().connect('composited-changed', self.update_visual)
self.window.get_screen().connect("composited-changed", self.update_visual)
# Debounce accel_search_terminal
self.prev_accel_search_terminal_time = 0.0
@ -220,7 +222,7 @@ class Guake(SimpleGladeApp):
self.display_tab_names = 0
self.window.connect('focus-out-event', self.on_window_losefocus)
self.window.connect("focus-out-event", self.on_window_losefocus)
# Handling the delete-event of the main window to avoid
# problems when closing it.
@ -231,8 +233,8 @@ class Guake(SimpleGladeApp):
def window_event(*args):
return self.window_event(*args)
self.window.connect('delete-event', destroy)
self.window.connect('window-state-event', window_event)
self.window.connect("delete-event", destroy)
self.window.connect("window-state-event", window_event)
# this line is important to resize the main window and make it
# smaller.
@ -253,26 +255,28 @@ class Guake(SimpleGladeApp):
Keybindings(self)
self.load_config()
if self.settings.general.get_boolean('start-fullscreen'):
if self.settings.general.get_boolean("start-fullscreen"):
self.fullscreen()
refresh_user_start(self.settings)
# Restore tabs when startup
if self.settings.general.get_boolean('restore-tabs-startup'):
if self.settings.general.get_boolean("restore-tabs-startup"):
self.restore_tabs(suppress_notify=True)
# Pop-up that shows that guake is working properly (if not
# unset in the preferences windows)
if self.settings.general.get_boolean('use-popup'):
key = self.settings.keybindingsGlobal.get_string('show-hide')
if self.settings.general.get_boolean("use-popup"):
key = self.settings.keybindingsGlobal.get_string("show-hide")
keyval, mask = Gtk.accelerator_parse(key)
label = Gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_("Guake Terminal"),
_("Guake is now running,\n"
"press <b>{!s}</b> to use it.").format(xml_escape(label)), filename
_("Guake is now running,\n" "press <b>{!s}</b> to use it.").format(
xml_escape(label)
),
filename,
)
log.info("Guake initialized")
@ -284,7 +288,7 @@ class Guake(SimpleGladeApp):
notebook.attach_guake(self)
# Tracking when reorder page
notebook.connect('page-reordered', self.on_page_reorder)
notebook.connect("page-reordered", self.on_page_reorder)
def update_visual(self, user_data=None):
screen = self.window.get_screen()
@ -297,11 +301,11 @@ class Guake(SimpleGladeApp):
self.window.set_app_paintable(True)
self.window.transparency = True
self.window.realize()
if self.window.get_property('visible'):
if self.window.get_property("visible"):
self.hide()
self.show()
else:
log.warn('System doesn\'t support transparency')
log.warn("System doesn't support transparency")
self.window.transparency = False
self.window.set_visual(screen.get_system_visual())
@ -310,7 +314,7 @@ class Guake(SimpleGladeApp):
def _load_palette(self):
colorRGBA = Gdk.RGBA(0, 0, 0, 0)
paletteList = list()
for color in self.settings.styleFont.get_string("palette").split(':'):
for color in self.settings.styleFont.get_string("palette").split(":"):
colorRGBA.parse(color)
paletteList.append(colorRGBA.copy())
return paletteList
@ -324,7 +328,7 @@ class Guake(SimpleGladeApp):
return self._apply_transparency_to_color(bg_color)
def _apply_transparency_to_color(self, bg_color):
transparency = self.settings.styleBackground.get_int('transparency')
transparency = self.settings.styleBackground.get_int("transparency")
if not self.transparency_toggled:
bg_color.alpha = 1 / 100 * transparency
else:
@ -445,8 +449,8 @@ class Guake(SimpleGladeApp):
log.info("Palette name %s not found", palette_name)
return
log.debug("Settings palette name to %s", palette_name)
self.settings.styleFont.set_string('palette', PALETTES[palette_name])
self.settings.styleFont.set_string('palette-name', palette_name)
self.settings.styleFont.set_string("palette", PALETTES[palette_name])
self.settings.styleFont.set_string("palette-name", palette_name)
self.set_colors_from_settings()
def execute_command(self, command, tab=None):
@ -461,8 +465,8 @@ class Guake(SimpleGladeApp):
if not self.get_notebook().has_page():
self.add_tab()
if command[-1] != '\n':
command += '\n'
if command[-1] != "\n":
command += "\n"
terminal = self.get_notebook().get_current_terminal()
terminal.feed_child(command)
@ -471,12 +475,13 @@ class Guake(SimpleGladeApp):
# TODO DBUS_ONLY
"""Execute the `command' in the tab whose terminal has the `tab_uuid' uuid
"""
if command[-1] != '\n':
command += '\n'
if command[-1] != "\n":
command += "\n"
try:
tab_uuid = uuid.UUID(tab_uuid)
page_index, = (
index for index, t in enumerate(self.get_notebook().iter_terminals())
(page_index,) = (
index
for index, t in enumerate(self.get_notebook().iter_terminals())
if t.get_uuid() == tab_uuid
)
except ValueError:
@ -493,8 +498,8 @@ class Guake(SimpleGladeApp):
if not HidePrevention(self.window).may_hide():
return
value = self.settings.general.get_boolean('window-losefocus')
visible = window.get_property('visible')
value = self.settings.general.get_boolean("window-losefocus")
visible = window.get_property("visible")
self.losefocus_time = get_server_time(self.window)
if visible and value:
log.info("Hiding on focus lose")
@ -503,7 +508,7 @@ class Guake(SimpleGladeApp):
def show_menu(self, status_icon, button, activate_time):
"""Show the tray icon menu.
"""
menu = self.get_widget('tray-menu')
menu = self.get_widget("tray-menu")
menu.popup(None, None, None, Gtk.StatusIcon.position_menu, button, activate_time)
def show_about(self, *args):
@ -550,7 +555,7 @@ class Guake(SimpleGladeApp):
if not self.win_prepare():
return
if not self.window.get_property('visible'):
if not self.window.get_property("visible"):
log.info("Showing the terminal")
self.show()
self.set_terminal_focus()
@ -591,27 +596,31 @@ class Guake(SimpleGladeApp):
def win_prepare(self, *args):
event_time = self.hotkeys.get_current_event_time()
if not self.settings.general.get_boolean('window-refocus') and \
self.window.get_window() and self.window.get_property('visible'):
if (
not self.settings.general.get_boolean("window-refocus")
and self.window.get_window()
and self.window.get_property("visible")
):
pass
elif not self.settings.general.get_boolean('window-losefocus'):
elif not self.settings.general.get_boolean("window-losefocus"):
if self.losefocus_time and self.losefocus_time < event_time:
if self.window.get_window() and self.window.get_property('visible') and \
not self.window.get_window().get_state() & Gdk.WindowState.FOCUSED:
if (
self.window.get_window()
and self.window.get_property("visible")
and not self.window.get_window().get_state() & Gdk.WindowState.FOCUSED
):
log.debug("DBG: Restoring the focus to the terminal")
self.window.get_window().focus(event_time)
self.set_terminal_focus()
self.losefocus_time = 0
return False
elif self.losefocus_time and self.settings.general.get_boolean('window-losefocus'):
if self.losefocus_time >= event_time and \
(self.losefocus_time - event_time) < 10:
elif self.losefocus_time and self.settings.general.get_boolean("window-losefocus"):
if self.losefocus_time >= event_time and (self.losefocus_time - event_time) < 10:
self.losefocus_time = 0
return False
# limit rate at which the visibility can be toggled.
if self.prev_showhide_time and event_time and \
(event_time - self.prev_showhide_time) < 65:
if self.prev_showhide_time and event_time and (event_time - self.prev_showhide_time) < 65:
return False
self.prev_showhide_time = event_time
@ -639,8 +648,8 @@ class Guake(SimpleGladeApp):
self._failed_restore_page_split = []
for root, box, panes in self.pending_restore_page_split:
if (
self.window.get_property('visible') and
root.get_notebook() == self.notebook_manager.get_current_notebook()
self.window.get_property("visible")
and root.get_notebook() == self.notebook_manager.get_current_notebook()
):
root.restore_box_layout(box, panes)
else:
@ -675,7 +684,7 @@ class Guake(SimpleGladeApp):
# this works around an issue in fluxbox
if not self.fullscreen_manager.is_fullscreen():
self.settings.general.triggerOnChangedValue(self.settings.general, 'window-height')
self.settings.general.triggerOnChangedValue(self.settings.general, "window-height")
time = get_server_time(self.window)
@ -716,12 +725,12 @@ class Guake(SimpleGladeApp):
# This is here because vte color configuration works only after the
# widget is shown.
self.settings.styleFont.triggerOnChangedValue(self.settings.styleFont, 'color')
self.settings.styleBackground.triggerOnChangedValue(self.settings.styleBackground, 'color')
self.settings.styleFont.triggerOnChangedValue(self.settings.styleFont, "color")
self.settings.styleBackground.triggerOnChangedValue(self.settings.styleBackground, "color")
log.debug("Current window position: %r", self.window.get_position())
self.restore_pending_terminal_split()
self.execute_hook('show')
self.execute_hook("show")
def hide_from_remote(self):
"""
@ -747,7 +756,7 @@ class Guake(SimpleGladeApp):
if not HidePrevention(self.window).may_hide():
return
self.hidden = True
self.get_widget('window-root').unstick()
self.get_widget("window-root").unstick()
self.window.hide() # Don't use hide_all here!
# Hide popover
@ -769,92 +778,92 @@ class Guake(SimpleGladeApp):
"""
user_data = {}
if terminal_uuid:
user_data['terminal_uuid'] = terminal_uuid
user_data["terminal_uuid"] = terminal_uuid
self.settings.general.triggerOnChangedValue(
self.settings.general, 'use-trayicon', user_data=user_data
self.settings.general, "use-trayicon", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'prompt-on-quit', user_data=user_data
self.settings.general, "prompt-on-quit", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'prompt-on-close-tab', user_data=user_data
self.settings.general, "prompt-on-close-tab", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'window-tabbar', user_data=user_data
self.settings.general, "window-tabbar", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'fullscreen-hide-tabbar', user_data=user_data
self.settings.general, "fullscreen-hide-tabbar", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'mouse-display', user_data=user_data
self.settings.general, "mouse-display", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'display-n', user_data=user_data
self.settings.general, "display-n", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'window-ontop', user_data=user_data
self.settings.general, "window-ontop", user_data=user_data
)
if not self.fullscreen_manager.is_fullscreen():
self.settings.general.triggerOnChangedValue(
self.settings.general, 'window-height', user_data=user_data
self.settings.general, "window-height", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'window-width', user_data=user_data
self.settings.general, "window-width", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'use-scrollbar', user_data=user_data
self.settings.general, "use-scrollbar", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'history-size', user_data=user_data
self.settings.general, "history-size", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'infinite-history', user_data=user_data
self.settings.general, "infinite-history", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'use-vte-titles', user_data=user_data
self.settings.general, "use-vte-titles", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'set-window-title', user_data=user_data
self.settings.general, "set-window-title", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'display-tab-names', user_data=user_data
self.settings.general, "display-tab-names", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'max-tab-name-length', user_data=user_data
self.settings.general, "max-tab-name-length", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'quick-open-enable', user_data=user_data
self.settings.general, "quick-open-enable", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'quick-open-command-line', user_data=user_data
self.settings.general, "quick-open-command-line", user_data=user_data
)
self.settings.style.triggerOnChangedValue(
self.settings.style, 'cursor-shape', user_data=user_data
self.settings.style, "cursor-shape", user_data=user_data
)
self.settings.styleFont.triggerOnChangedValue(
self.settings.styleFont, 'style', user_data=user_data
self.settings.styleFont, "style", user_data=user_data
)
self.settings.styleFont.triggerOnChangedValue(
self.settings.styleFont, 'palette', user_data=user_data
self.settings.styleFont, "palette", user_data=user_data
)
self.settings.styleFont.triggerOnChangedValue(
self.settings.styleFont, 'palette-name', user_data=user_data
self.settings.styleFont, "palette-name", user_data=user_data
)
self.settings.styleFont.triggerOnChangedValue(
self.settings.styleFont, 'allow-bold', user_data=user_data
self.settings.styleFont, "allow-bold", user_data=user_data
)
self.settings.styleBackground.triggerOnChangedValue(
self.settings.styleBackground, 'transparency', user_data=user_data
self.settings.styleBackground, "transparency", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'use-default-font', user_data=user_data
self.settings.general, "use-default-font", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'compat-backspace', user_data=user_data
self.settings.general, "compat-backspace", user_data=user_data
)
self.settings.general.triggerOnChangedValue(
self.settings.general, 'compat-delete', user_data=user_data
self.settings.general, "compat-delete", user_data=user_data
)
def accel_search_terminal(self, *args):
@ -884,8 +893,8 @@ class Guake(SimpleGladeApp):
procs = self.notebook_manager.get_running_fg_processes_count()
tabs = self.notebook_manager.get_n_pages()
notebooks = self.notebook_manager.get_n_notebooks()
prompt_cfg = self.settings.general.get_boolean('prompt-on-quit')
prompt_tab_cfg = self.settings.general.get_int('prompt-on-close-tab')
prompt_cfg = self.settings.general.get_boolean("prompt-on-quit")
prompt_tab_cfg = self.settings.general.get_int("prompt-on-close-tab")
# "Prompt on tab close" config overrides "prompt on quit" config
if prompt_cfg or (prompt_tab_cfg == 1 and procs > 0) or (prompt_tab_cfg == 2):
log.debug("Remaining procs=%r", procs)
@ -922,31 +931,31 @@ class Guake(SimpleGladeApp):
def accel_increase_height(self, *args):
"""Callback to increase height.
"""
height = self.settings.general.get_int('window-height')
self.settings.general.set_int('window-height', min(height + 2, 100))
height = self.settings.general.get_int("window-height")
self.settings.general.set_int("window-height", min(height + 2, 100))
return True
def accel_decrease_height(self, *args):
"""Callback to decrease height.
"""
height = self.settings.general.get_int('window-height')
self.settings.general.set_int('window-height', max(height - 2, 0))
height = self.settings.general.get_int("window-height")
self.settings.general.set_int("window-height", max(height - 2, 0))
return True
def accel_increase_transparency(self, *args):
"""Callback to increase transparency.
"""
transparency = self.settings.styleBackground.get_int('transparency')
transparency = self.settings.styleBackground.get_int("transparency")
if int(transparency) > 0:
self.settings.styleBackground.set_int('transparency', int(transparency) - 2)
self.settings.styleBackground.set_int("transparency", int(transparency) - 2)
return True
def accel_decrease_transparency(self, *args):
"""Callback to decrease transparency.
"""
transparency = self.settings.styleBackground.get_int('transparency')
transparency = self.settings.styleBackground.get_int("transparency")
if int(transparency) < MAX_TRANSPARENCY:
self.settings.styleBackground.set_int('transparency', int(transparency) + 2)
self.settings.styleBackground.set_int("transparency", int(transparency) + 2)
return True
def accel_toggle_transparency(self, *args):
@ -954,7 +963,7 @@ class Guake(SimpleGladeApp):
"""
self.transparency_toggled = not self.transparency_toggled
self.settings.styleBackground.triggerOnChangedValue(
self.settings.styleBackground, 'transparency'
self.settings.styleBackground, "transparency"
)
return True
@ -967,7 +976,7 @@ class Guake(SimpleGladeApp):
def accel_add_home(self, *args):
"""Callback to add a new tab in home directory. Called by the accel key.
"""
self.add_tab(os.environ['HOME'])
self.add_tab(os.environ["HOME"])
return True
def accel_prev(self, *args):
@ -1005,8 +1014,9 @@ class Guake(SimpleGladeApp):
return True
def move_tab(self, old_tab_pos, new_tab_pos):
self.get_notebook(
).reorder_child(self.get_notebook().get_nth_page(old_tab_pos), new_tab_pos)
self.get_notebook().reorder_child(
self.get_notebook().get_nth_page(old_tab_pos), new_tab_pos
)
self.get_notebook().set_current_page(new_tab_pos)
def gen_accel_switch_tabN(self, N):
@ -1054,10 +1064,10 @@ class Guake(SimpleGladeApp):
"""Callback toggle whether the window should hide when it loses
focus. Called by the accel key.
"""
if self.settings.general.get_boolean('window-losefocus'):
self.settings.general.set_boolean('window-losefocus', False)
if self.settings.general.get_boolean("window-losefocus"):
self.settings.general.set_boolean("window-losefocus", False)
else:
self.settings.general.set_boolean('window-losefocus', True)
self.settings.general.set_boolean("window-losefocus", True)
return True
def accel_toggle_fullscreen(self, *args):
@ -1093,11 +1103,11 @@ class Guake(SimpleGladeApp):
try:
current_directory = vte.get_current_directory()
if self.display_tab_names == 1 and vte_title.endswith(current_directory):
parts = current_directory.split('/')
parts = current_directory.split("/")
parts = [s[:1] for s in parts[:-1]] + [parts[-1]]
vte_title = vte_title[:len(vte_title) - len(current_directory)] + '/'.join(parts)
vte_title = vte_title[: len(vte_title) - len(current_directory)] + "/".join(parts)
if self.display_tab_names == 2:
vte_title = current_directory.split('/')[-1]
vte_title = current_directory.split("/")[-1]
if not vte_title:
vte_title = "(root)"
except OSError:
@ -1110,7 +1120,7 @@ class Guake(SimpleGladeApp):
if not term.get_parent():
return
box = term.get_parent().get_root_box()
use_vte_titles = self.settings.general.get_boolean('use-vte-titles')
use_vte_titles = self.settings.general.get_boolean("use-vte-titles")
if not use_vte_titles:
return
@ -1123,7 +1133,7 @@ class Guake(SimpleGladeApp):
if page_num != -1:
break
# if tab has been renamed by user, don't override.
if not getattr(box, 'custom_label_set', False):
if not getattr(box, "custom_label_set", False):
title = self.compute_tab_title(vte)
nb.rename_page(page_num, title, False)
self.update_window_title(title)
@ -1133,7 +1143,7 @@ class Guake(SimpleGladeApp):
self.update_window_title(text)
def update_window_title(self, title):
if self.settings.general.get_boolean('set-window-title') is True:
if self.settings.general.get_boolean("set-window-title") is True:
self.window.set_title(title)
else:
self.window.set_title(self.default_window_title)
@ -1145,15 +1155,16 @@ class Guake(SimpleGladeApp):
def close_tab(self, *args):
"""Closes the current tab.
"""
prompt_cfg = self.settings.general.get_int('prompt-on-close-tab')
prompt_cfg = self.settings.general.get_int("prompt-on-close-tab")
self.get_notebook().delete_page_current(prompt=prompt_cfg)
def rename_tab_uuid(self, term_uuid, new_text, user_set=True):
"""Rename an already added tab by its UUID
"""
term_uuid = uuid.UUID(term_uuid)
page_index, = (
index for index, t in enumerate(self.get_notebook().iter_terminals())
(page_index,) = (
index
for index, t in enumerate(self.get_notebook().iter_terminals())
if t.get_uuid() == term_uuid
)
self.get_notebook().rename_page(page_index, new_text, user_set)
@ -1165,7 +1176,7 @@ class Guake(SimpleGladeApp):
def terminal_spawned(self, notebook, terminal, pid):
self.load_config(terminal_uuid=terminal.uuid)
terminal.handler_ids.append(
terminal.connect('window-title-changed', self.on_terminal_title_changed, terminal)
terminal.connect("window-title-changed", self.on_terminal_title_changed, terminal)
)
@save_tabs_when_changed
@ -1173,7 +1184,7 @@ class Guake(SimpleGladeApp):
"""Adds a new tab to the terminal notebook.
"""
position = None
if self.settings.general.get_boolean('new-tab-after'):
if self.settings.general.get_boolean("new-tab-after"):
position = 1 + self.get_notebook().get_current_page()
self.get_notebook().new_page_with_focus(directory, position=position)
@ -1184,10 +1195,17 @@ class Guake(SimpleGladeApp):
search_text = Gtk.TextView()
dialog = Gtk.Dialog(
_("Find"), self.window, Gtk.DialogFlags.DESTROY_WITH_PARENT, (
_("Forward"), RESPONSE_FORWARD, _("Backward"), RESPONSE_BACKWARD, Gtk.STOCK_CANCEL,
Gtk.ResponseType.NONE
)
_("Find"),
self.window,
Gtk.DialogFlags.DESTROY_WITH_PARENT,
(
_("Forward"),
RESPONSE_FORWARD,
_("Backward"),
RESPONSE_BACKWARD,
Gtk.STOCK_CANCEL,
Gtk.ResponseType.NONE,
),
)
dialog.vbox.pack_end(search_text, True, True, 0)
dialog.buffer = search_text.get_buffer()
@ -1208,8 +1226,9 @@ class Guake(SimpleGladeApp):
search_string = start.get_text(end)
log.debug(
"Searching for %r %s\n", search_string,
"forward" if response_id == RESPONSE_FORWARD else "backward"
"Searching for %r %s\n",
search_string,
"forward" if response_id == RESPONSE_FORWARD else "backward",
)
current_term = self.get_notebook().get_current_terminal()
@ -1233,7 +1252,7 @@ class Guake(SimpleGladeApp):
self.set_terminal_focus()
self.was_deleted_tab = True
self.display_tab_names = self.settings.general.get_int('display-tab-names')
self.display_tab_names = self.settings.general.get_int("display-tab-names")
self.recompute_tabs_titles()
def set_terminal_focus(self):
@ -1263,26 +1282,28 @@ class Guake(SimpleGladeApp):
if search_query:
# TODO search provider should be selectable (someone might
# prefer bing.com, the internet is a strange place ¯\_(ツ)_/¯ )
search_url = "https://www.google.com/#q={!s}&safe=off".format(search_query, )
search_url = "https://www.google.com/#q={!s}&safe=off".format(search_query,)
Gtk.show_uri(self.window.get_screen(), search_url, get_server_time(self.window))
return True
def set_tab_position(self, *args):
if self.settings.general.get_boolean('tab-ontop'):
if self.settings.general.get_boolean("tab-ontop"):
self.get_notebook().set_tab_pos(Gtk.PositionType.TOP)
else:
self.get_notebook().set_tab_pos(Gtk.PositionType.BOTTOM)
def execute_hook(self, event_name):
"""Execute shell commands related to current event_name"""
hook = self.settings.hooks.get_string('{!s}'.format(event_name))
hook = self.settings.hooks.get_string("{!s}".format(event_name))
if hook is not None and hook != "":
hook = hook.split()
try:
subprocess.Popen(hook)
except OSError as oserr:
if oserr.errno == 8:
log.error("Hook execution failed! Check shebang at first line of %s!", hook)
log.error(
"Hook execution failed! Check shebang at first line of %s!", hook,
)
log.debug(traceback.format_exc())
else:
log.error(str(oserr))
@ -1298,14 +1319,14 @@ class Guake(SimpleGladeApp):
pass
def get_xdg_config_directory(self):
xdg_config_home = os.environ.get('XDG_CONFIG_HOME', '~/.config')
return Path(xdg_config_home, 'guake').expanduser()
xdg_config_home = os.environ.get("XDG_CONFIG_HOME", "~/.config")
return Path(xdg_config_home, "guake").expanduser()
def save_tabs(self, filename='session.json'):
def save_tabs(self, filename="session.json"):
config = {
'schema_version': TABS_SESSION_SCHEMA_VERSION,
'timestamp': int(pytime.time()),
'workspace': {}
"schema_version": TABS_SESSION_SCHEMA_VERSION,
"timestamp": int(pytime.time()),
"workspace": {},
}
for key, nb in self.notebook_manager.get_notebooks().items():
@ -1316,84 +1337,89 @@ class Guake(SimpleGladeApp):
if page.child:
panes = []
page.save_box_layout(page.child, panes)
tabs.append({
'panes': panes,
'label': nb.get_tab_text_index(index),
'custom_label_set': getattr(page, 'custom_label_set', False)
})
tabs.append(
{
"panes": panes,
"label": nb.get_tab_text_index(index),
"custom_label_set": getattr(page, "custom_label_set", False),
}
)
except FileNotFoundError:
# discard same broken tabs
pass
# NOTE: Maybe we will have frame inside the workspace in future
# So lets use list to store the tabs (as for each frame)
config['workspace'][key] = [tabs]
config["workspace"][key] = [tabs]
if not self.get_xdg_config_directory().exists():
self.get_xdg_config_directory().mkdir(parents=True)
session_file = self.get_xdg_config_directory() / filename
with session_file.open('w') as f:
with session_file.open("w") as f:
json.dump(config, f, ensure_ascii=False, indent=4)
log.info('Guake tabs saved to %s', session_file)
log.info("Guake tabs saved to %s", session_file)
def restore_tabs(self, filename='session.json', suppress_notify=False):
def restore_tabs(self, filename="session.json", suppress_notify=False):
session_file = self.get_xdg_config_directory() / filename
if not session_file.exists():
log.info('Cannot find session.json file')
log.info("Cannot find session.json file")
return
with session_file.open() as f:
try:
config = json.load(f)
except Exception:
log.warning('%s is broken', session_file)
log.warning("%s is broken", session_file)
shutil.copy(
session_file,
self.get_xdg_config_directory() / '{0}.bak'.format(filename)
session_file, self.get_xdg_config_directory() / "{0}.bak".format(filename),
)
img_filename = pixmapfile('guake-notification.png')
img_filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_('Guake Terminal'),
_('Your {session_filename} file is broken, backup to {session_filename}.bak'
).format(session_filename=filename), img_filename
_("Guake Terminal"),
_(
"Your {session_filename} file is broken, backup to {session_filename}.bak"
).format(session_filename=filename),
img_filename,
)
return
# Check schema_version exist
if 'schema_version' not in config:
img_filename = pixmapfile('guake-notification.png')
if "schema_version" not in config:
img_filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_('Guake Terminal'),
_("Guake Terminal"),
_(
'Tabs session restore abort.\n'
'Your session file ({session_filename}) missing schema_version as key'
).format(session_filename=session_file), img_filename
"Tabs session restore abort.\n"
"Your session file ({session_filename}) missing schema_version as key"
).format(session_filename=session_file),
img_filename,
)
return
# Check schema version is not higher than current version
if config['schema_version'] > TABS_SESSION_SCHEMA_VERSION:
img_filename = pixmapfile('guake-notification.png')
if config["schema_version"] > TABS_SESSION_SCHEMA_VERSION:
img_filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_('Guake Terminal'),
_("Guake Terminal"),
_(
'Tabs session restore abort.\n'
'Your session file schema version is higher than current version '
'({session_file_schema_version} > {current_schema_version}).'
"Tabs session restore abort.\n"
"Your session file schema version is higher than current version "
"({session_file_schema_version} > {current_schema_version})."
).format(
session_file_schema_version=config['schema_version'],
current_schema_version=TABS_SESSION_SCHEMA_VERSION
), img_filename
session_file_schema_version=config["schema_version"],
current_schema_version=TABS_SESSION_SCHEMA_VERSION,
),
img_filename,
)
return
# Disable auto save tabs
v = self.settings.general.get_boolean('save-tabs-when-changed')
self.settings.general.set_boolean('save-tabs-when-changed', False)
v = self.settings.general.get_boolean("save-tabs-when-changed")
self.settings.general.set_boolean("save-tabs-when-changed", False)
# Restore all tabs for all workspaces
self.pending_restore_page_split = []
self._failed_restore_page_split = []
try:
for key, frames in config['workspace'].items():
for key, frames in config["workspace"].items():
nb = self.notebook_manager.get_notebook(int(key))
current_pages = nb.get_n_pages()
@ -1401,42 +1427,47 @@ class Guake(SimpleGladeApp):
# NOTE: If frame implement in future, we will need to update this code
for tabs in frames:
for index, tab in enumerate(tabs):
directory = tab['panes'][0]['directory'] if len(
tab.get('panes', [])
) == 1 else tab.get('directory', None)
box, page_num, term = nb.new_page_with_focus(
directory, tab['label'], tab['custom_label_set']
directory = (
tab["panes"][0]["directory"]
if len(tab.get("panes", [])) == 1
else tab.get("directory", None)
)
if tab.get('panes', False):
box, page_num, term = nb.new_page_with_focus(
directory, tab["label"], tab["custom_label_set"]
)
if tab.get("panes", False):
# if directory:
# continue
box.restore_box_layout(box.child, tab['panes'])
box.restore_box_layout(box.child, tab["panes"])
# Remove original pages in notebook
for i in range(current_pages):
nb.delete_page(0)
except KeyError:
log.warning('%s schema is broken', session_file)
shutil.copy(session_file, self.get_xdg_config_directory() / '{}.bak'.format(filename))
with (self.get_xdg_config_directory() / '{}.log.err'.format(filename)).open('w') as f:
log.warning("%s schema is broken", session_file)
shutil.copy(
session_file, self.get_xdg_config_directory() / "{}.bak".format(filename),
)
with (self.get_xdg_config_directory() / "{}.log.err".format(filename)).open("w") as f:
traceback.print_exc(file=f)
img_filename = pixmapfile('guake-notification.png')
img_filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_('Guake Terminal'),
_("Guake Terminal"),
_(
'Your {session_filename} schema is broken, backup to {session_filename}.bak, '
'and error message has been saved to {session_filename}.log.err.'.format(
"Your {session_filename} schema is broken, backup to {session_filename}.bak, "
"and error message has been saved to {session_filename}.log.err.".format(
session_filename=filename
)
), img_filename
),
img_filename,
)
# Reset auto save tabs
self.settings.general.set_boolean('save-tabs-when-changed', v)
self.settings.general.set_boolean("save-tabs-when-changed", v)
# Notify the user
if (self.settings.general.get_boolean('restore-tabs-notify') and not suppress_notify):
filename = pixmapfile('guake-notification.png')
if self.settings.general.get_boolean("restore-tabs-notify") and not suppress_notify:
filename = pixmapfile("guake-notification.png")
notifier.showMessage(_("Guake Terminal"), _("Your tabs has been restored!"), filename)
log.info('Guake tabs restored from %s', session_file)
log.info("Guake tabs restored from %s", session_file)

58
guake/guake_logging.py
View File

@ -23,7 +23,7 @@ import logging.config
try:
from colorlog import ColoredFormatter
except ImportError as ie:
except ImportError:
ColoredFormatter = None
log = logging.getLogger(__name__)
@ -37,37 +37,33 @@ def setupLogging(debug_mode):
if ColoredFormatter:
level_str = logging.getLevelName(base_logging_level)
logging.config.dictConfig({
'version': 1,
'disable_existing_loggers': False,
'loggers': {
'': {
'handlers': ['default'],
'level': level_str,
'propagate': True
},
},
'handlers': {
'default': {
'level': level_str,
'class': 'logging.StreamHandler',
'formatter': "default",
},
},
'formatters': {
'default': {
'()': 'colorlog.ColoredFormatter',
'format': "%(log_color)s%(levelname)-8s%(reset)s %(message)s",
'log_colors': {
'DEBUG': 'cyan',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white',
logging.config.dictConfig(
{
"version": 1,
"disable_existing_loggers": False,
"loggers": {"": {"handlers": ["default"], "level": level_str, "propagate": True,},},
"handlers": {
"default": {
"level": level_str,
"class": "logging.StreamHandler",
"formatter": "default",
},
}
},
})
},
"formatters": {
"default": {
"()": "colorlog.ColoredFormatter",
"format": "%(log_color)s%(levelname)-8s%(reset)s %(message)s",
"log_colors": {
"DEBUG": "cyan",
"INFO": "green",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "red,bg_white",
},
}
},
}
)
else:
logging.basicConfig(level=base_logging_level, format="%(message)s")
log.setLevel(base_logging_level)

4
guake/guake_toggle.py
View File

@ -1,9 +1,9 @@
def toggle_guake_by_dbus():
import dbus
import dbus # pylint: disable=import-outside-toplevel
try:
bus = dbus.SessionBus()
remote_object = bus.get_object('org.guake3.RemoteControl', '/org/guake3/RemoteControl')
remote_object = bus.get_object("org.guake3.RemoteControl", "/org/guake3/RemoteControl")
print("Sending 'toggle' message to Guake3")
remote_object.show_hide()
except dbus.DBusException:

296
guake/keybindings.py
View File

@ -20,7 +20,8 @@ Boston, MA 02110-1301 USA
import logging
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from guake import notifier
@ -32,7 +33,7 @@ from locale import gettext as _
log = logging.getLogger(__name__)
class Keybindings():
class Keybindings:
"""Handles changes in keyboard shortcuts.
"""
@ -46,7 +47,7 @@ class Keybindings():
# Setup global keys
self.globalhotkeys = {}
globalkeys = ['show-hide', 'show-focus']
globalkeys = ["show-hide", "show-focus"]
for key in globalkeys:
guake.settings.keybindingsGlobal.onChangedValue(key, self.reload_global)
guake.settings.keybindingsGlobal.triggerOnChangedValue(
@ -55,17 +56,50 @@ class Keybindings():
# Setup local keys
keys = [
'toggle-fullscreen', 'new-tab', 'new-tab-home', 'close-tab', 'rename-current-tab',
'previous-tab', 'next-tab', 'clipboard-copy', 'clipboard-paste', 'quit', 'zoom-in',
'zoom-out', 'increase-height', 'decrease-height', 'increase-transparency',
'decrease-transparency', 'toggle-transparency', "search-on-web", 'move-tab-left',
'move-tab-right', 'switch-tab1', 'switch-tab2', 'switch-tab3', 'switch-tab4',
'switch-tab5', 'switch-tab6', 'switch-tab7', 'switch-tab8', 'switch-tab9',
'switch-tab10', 'switch-tab-last', 'reset-terminal', 'split-tab-vertical',
'split-tab-horizontal', 'close-terminal', 'focus-terminal-up', 'focus-terminal-down',
'focus-terminal-right', 'focus-terminal-left', 'move-terminal-split-up',
'move-terminal-split-down', 'move-terminal-split-left', 'move-terminal-split-right',
'search-terminal'
"toggle-fullscreen",
"new-tab",
"new-tab-home",
"close-tab",
"rename-current-tab",
"previous-tab",
"next-tab",
"clipboard-copy",
"clipboard-paste",
"quit",
"zoom-in",
"zoom-out",
"increase-height",
"decrease-height",
"increase-transparency",
"decrease-transparency",
"toggle-transparency",
"search-on-web",
"move-tab-left",
"move-tab-right",
"switch-tab1",
"switch-tab2",
"switch-tab3",
"switch-tab4",
"switch-tab5",
"switch-tab6",
"switch-tab7",
"switch-tab8",
"switch-tab9",
"switch-tab10",
"switch-tab-last",
"reset-terminal",
"split-tab-vertical",
"split-tab-horizontal",
"close-terminal",
"focus-terminal-up",
"focus-terminal-down",
"focus-terminal-right",
"focus-terminal-left",
"move-terminal-split-up",
"move-terminal-split-down",
"move-terminal-split-left",
"move-terminal-split-right",
"search-terminal",
]
for key in keys:
guake.settings.keybindingsLocal.onChangedValue(key, self.reload_accelerators)
@ -73,12 +107,12 @@ class Keybindings():
def reload_global(self, settings, key, user_data):
value = settings.get_string(key)
if value == 'disabled':
if value == "disabled":
return
try:
self.guake.hotkeys.unbind(self.globalhotkeys[key])
except Exception as e:
except BaseException:
pass
self.globalhotkeys[key] = value
@ -87,14 +121,16 @@ class Keybindings():
if not self.guake.hotkeys.bind(value, self.guake.show_hide):
keyval, mask = Gtk.accelerator_parse(value)
label = Gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
filename = pixmapfile("guake-notification.png")
notifier.showMessage(
_('Guake Terminal'),
_("Guake Terminal"),
_(
'A problem happened when binding <b>%s</b> key.\n'
'Please use Guake Preferences dialog to choose another '
'key'
) % label, filename
"A problem happened when binding <b>%s</b> key.\n"
"Please use Guake Preferences dialog to choose another "
"key"
)
% label,
filename,
)
elif key == "show-focus":
if not self.guake.hotkeys.bind(value, self.guake.show_focus):
@ -119,141 +155,141 @@ class Keybindings():
def getk(x):
return self.guake.settings.keybindingsLocal.get_string(x)
key, mask = Gtk.accelerator_parse(getk('reset-terminal'))
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'))
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'))
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'))
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'))
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')
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'))
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'))
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'))
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'))
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'))
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'))
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'))
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'))
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'))
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.AccelFlags.VISIBLE, self.guake.accel_toggle_hide_on_lose_focus,
)
key, mask = Gtk.accelerator_parse(getk('zoom-in'))
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'))
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'))
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'))
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'))
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'))
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.AccelFlags.VISIBLE, self.guake.accel_increase_transparency,
)
key, mask = Gtk.accelerator_parse(getk('decrease-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.AccelFlags.VISIBLE, self.guake.accel_decrease_transparency,
)
key, mask = Gtk.accelerator_parse(getk('toggle-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))
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.AccelFlags.VISIBLE, self.guake.gen_accel_switch_tabN(tab - 1),
)
key, mask = Gtk.accelerator_parse(getk('switch-tab-last'))
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'))
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
@ -261,112 +297,148 @@ class Keybindings():
except Exception:
log.exception("Exception occured")
key, mask = Gtk.accelerator_parse(getk('split-tab-vertical'))
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
)
lambda *args: self.guake.get_notebook()
.get_current_terminal()
.get_parent()
.split_v()
or True
),
)
key, mask = Gtk.accelerator_parse(getk('split-tab-horizontal'))
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
)
lambda *args: self.guake.get_notebook()
.get_current_terminal()
.get_parent()
.split_h()
or True
),
)
key, mask = Gtk.accelerator_parse(getk('close-terminal'))
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.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'))
key, mask = Gtk.accelerator_parse(getk("focus-terminal-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
)
lambda *args: FocusMover(self.guake.window).move_up(
self.guake.get_notebook().get_current_terminal()
)
or True
),
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-down'))
key, mask = Gtk.accelerator_parse(getk("focus-terminal-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
)
lambda *args: FocusMover(self.guake.window).move_down(
self.guake.get_notebook().get_current_terminal()
)
or True
),
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-left'))
key, mask = Gtk.accelerator_parse(getk("focus-terminal-right"))
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
)
lambda *args: FocusMover(self.guake.window).move_right(
self.guake.get_notebook().get_current_terminal()
)
or True
),
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-right'))
key, mask = Gtk.accelerator_parse(getk("focus-terminal-left"))
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
)
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: SplitMover.move_up( # keep make style from concat this lines
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: SplitMover.move_down( # keep make style from concat this lines
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: SplitMover.move_left( # keep make style from concat this lines
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: SplitMover.move_right( # keep make style from concat this lines
self.guake.get_notebook().get_current_terminal()
)
or True
),
)
key, mask = Gtk.accelerator_parse(getk('search-terminal'))
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

394
guake/main.py
View File

@ -42,13 +42,17 @@ from guake.support import print_support
from guake.utils import restore_preferences
from guake.utils import save_preferences
# When we are in the document generation on readthedocs, we do not have paths.py generated
# When we are in the document generation on readthedocs,
# we do not have paths.py generated
try:
from guake.paths import LOCALE_DIR
bindtextdomain(NAME, LOCALE_DIR)
except: # pylint: disable=bare-except
pass
# pylint: disable=import-outside-toplevel
def main():
"""Parses the command line parameters and decide if dbus methods
@ -65,297 +69,292 @@ def main():
# do not use version keywords here, pbr might be slow to find the version of Guake module
parser = OptionParser()
parser.add_option(
'-V',
'--version',
dest='version',
action='store_true',
"-V",
"--version",
dest="version",
action="store_true",
default=False,
help=_('Show Guake version number and exit')
help=_("Show Guake version number and exit"),
)
parser.add_option(
'-v',
'--verbose',
dest='verbose',
action='store_true',
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help=_('Enable verbose logging')
help=_("Enable verbose logging"),
)
parser.add_option(
'-f',
'--fullscreen',
dest='fullscreen',
action='store_true',
"-f",
"--fullscreen",
dest="fullscreen",
action="store_true",
default=False,
help=_('Put Guake in fullscreen mode')
help=_("Put Guake in fullscreen mode"),
)
parser.add_option(
'--unfullscreen',
dest='unfullscreen',
action='store_true',
"--unfullscreen",
dest="unfullscreen",
action="store_true",
default=False,
help=_('Put Guake out from fullscreen mode')
help=_("Put Guake out from fullscreen mode"),
)
parser.add_option(
'-t',
'--toggle-visibility',
dest='show_hide',
action='store_true',
"-t",
"--toggle-visibility",
dest="show_hide",
action="store_true",
default=False,
help=_('Toggles the visibility of the terminal window')
help=_("Toggles the visibility of the terminal window"),
)
parser.add_option(
'--show',
"--show",
dest="show",
action='store_true',
action="store_true",
default=False,
help=_('Shows Guake main window')
help=_("Shows Guake main window"),
)
parser.add_option(
'--hide',
dest='hide',
action='store_true',
"--hide",
dest="hide",
action="store_true",
default=False,
help=_('Hides Guake main window')
help=_("Hides Guake main window"),
)
parser.add_option(
'-p',
'--preferences',
dest='show_preferences',
action='store_true',
"-p",
"--preferences",
dest="show_preferences",
action="store_true",
default=False,
help=_('Shows Guake preference window')
help=_("Shows Guake preference window"),
)
parser.add_option(
'-a',
'--about',
dest='show_about',
action='store_true',
"-a",
"--about",
dest="show_about",
action="store_true",
default=False,
help=_('Shows Guake\'s about info')
help=_("Shows Guake's about info"),
)
parser.add_option(
'-n',
'--new-tab',
dest='new_tab',
action='store',
default='',
help=_('Add a new tab (with current directory set to NEW_TAB)')
"-n",
"--new-tab",
dest="new_tab",
action="store",
default="",
help=_("Add a new tab (with current directory set to NEW_TAB)"),
)
parser.add_option(
'-s',
'--select-tab',
dest='select_tab',
action='store',
default='',
help=_('Select a tab (SELECT_TAB is the index of the tab)')
"-s",
"--select-tab",
dest="select_tab",
action="store",
default="",
help=_("Select a tab (SELECT_TAB is the index of the tab)"),
)
parser.add_option(
'-g',
'--selected-tab',
dest='selected_tab',
action='store_true',
"-g",
"--selected-tab",
dest="selected_tab",
action="store_true",
default=False,
help=_('Return the selected tab index.')
help=_("Return the selected tab index."),
)
parser.add_option(
'-l',
'--selected-tablabel',
dest='selected_tablabel',
action='store_true',
"-l",
"--selected-tablabel",
dest="selected_tablabel",
action="store_true",
default=False,
help=_('Return the selected tab label.')
help=_("Return the selected tab label."),
)
parser.add_option(
'-S',
'--select-terminal',
dest='select_terminal',
metavar='TERMINAL_INDEX',
action='store',
default='',
"-S",
"--select-terminal",
dest="select_terminal",
metavar="TERMINAL_INDEX",
action="store",
default="",
help=_(
'Select a specific terminal in a split tab. ' +
'Only useful with split terminals (TERMINAL_INDEX is the index of the tab)'
)
"Select a specific terminal in a split tab. "
+ "Only useful with split terminals (TERMINAL_INDEX is the index of the tab)"
),
)
parser.add_option(
'--selected-terminal',
dest='selected_terminal',
action='store_true',
"--selected-terminal",
dest="selected_terminal",
action="store_true",
default=False,
help=_('Return the selected terminal index.')
help=_("Return the selected terminal index."),
)
parser.add_option(
'--split-vertical',
dest='split_vertical',
action='store_true',
"--split-vertical",
dest="split_vertical",
action="store_true",
default=False,
help=_('Split the selected tab vertically.')
help=_("Split the selected tab vertically."),
)
parser.add_option(
'--split-horizontal',
dest='split_horizontal',
action='store_true',
"--split-horizontal",
dest="split_horizontal",
action="store_true",
default=False,
help=_('Split the selected tab horizontally.')
help=_("Split the selected tab horizontally."),
)
parser.add_option(
'-e',
'--execute-command',
dest='command',
action='store',
default='',
help=_('Execute an arbitrary command in the selected tab.')
"-e",
"--execute-command",
dest="command",
action="store",
default="",
help=_("Execute an arbitrary command in the selected tab."),
)
parser.add_option(
'-i',
'--tab-index',
dest='tab_index',
action='store',
default='0',
help=_('Specify the tab to rename. Default is 0. Can be used to select tab by UUID.')
"-i",
"--tab-index",
dest="tab_index",
action="store",
default="0",
help=_("Specify the tab to rename. Default is 0. Can be used to select tab by UUID."),
)
parser.add_option(
'--bgcolor',
dest='bgcolor',
action='store',
default='',
help=_('Set the hexadecimal (#rrggbb) background color of '
'the selected tab.')
"--bgcolor",
dest="bgcolor",
action="store",
default="",
help=_("Set the hexadecimal (#rrggbb) background color of " "the selected tab."),
)
parser.add_option(
'--fgcolor',
dest='fgcolor',
action='store',
default='',
help=_('Set the hexadecimal (#rrggbb) foreground color of the '
'selected tab.')
"--fgcolor",
dest="fgcolor",
action="store",
default="",
help=_("Set the hexadecimal (#rrggbb) foreground color of the " "selected tab."),
)
parser.add_option(
'--bgcolor-current',
dest='bgcolor_current',
action='store',
default='',
help=_('Set the hexadecimal (#rrggbb) background color of '
'the current terminal.')
"--bgcolor-current",
dest="bgcolor_current",
action="store",
default="",
help=_("Set the hexadecimal (#rrggbb) background color of " "the current terminal."),
)
parser.add_option(
'--fgcolor-current',
dest='fgcolor_current',
action='store',
default='',
help=_('Set the hexadecimal (#rrggbb) foreground color of '
'the current terminal.')
"--fgcolor-current",
dest="fgcolor_current",
action="store",
default="",
help=_("Set the hexadecimal (#rrggbb) foreground color of " "the current terminal."),
)
parser.add_option(
'--change-palette',
dest='palette_name',
action='store',
default='',
help=_('Change Guake palette scheme')
"--change-palette",
dest="palette_name",
action="store",
default="",
help=_("Change Guake palette scheme"),
)
parser.add_option(
'--reset-colors',
dest='reset_colors',
action='store_true',
"--reset-colors",
dest="reset_colors",
action="store_true",
default=False,
help=_('Set colors from settings.')
help=_("Set colors from settings."),
)
parser.add_option(
'--reset-colors-current',
dest='reset_colors_current',
action='store_true',
"--reset-colors-current",
dest="reset_colors_current",
action="store_true",
default=False,
help=_('Set colors of the current terminal from settings.')
help=_("Set colors of the current terminal from settings."),
)
parser.add_option(
'--rename-tab',
dest='rename_tab',
metavar='TITLE',
action='store',
default='',
"--rename-tab",
dest="rename_tab",
metavar="TITLE",
action="store",
default="",
help=_(
'Rename the specified tab by --tab-index. Reset to default if TITLE is '
"Rename the specified tab by --tab-index. Reset to default if TITLE is "
'a single dash "-".'
)
),
)
parser.add_option(
'-r',
'--rename-current-tab',
dest='rename_current_tab',
metavar='TITLE',
action='store',
default='',
help=_('Rename the current tab. Reset to default if TITLE is a '
'single dash "-".')
"-r",
"--rename-current-tab",
dest="rename_current_tab",
metavar="TITLE",
action="store",
default="",
help=_("Rename the current tab. Reset to default if TITLE is a " 'single dash "-".'),
)
parser.add_option(
'-q',
'--quit',
dest='quit',
action='store_true',
"-q",
"--quit",
dest="quit",
action="store_true",
default=False,
help=_('Says to Guake go away =(')
help=_("Says to Guake go away =("),
)
parser.add_option(
'-u',
'--no-startup-script',
dest='execute_startup_script',
action='store_false',
"-u",
"--no-startup-script",
dest="execute_startup_script",
action="store_false",
default=True,
help=_('Do not execute the start up script')
help=_("Do not execute the start up script"),
)
parser.add_option(
'--save-preferences',
dest='save_preferences',
action='store',
"--save-preferences",
dest="save_preferences",
action="store",
default=None,
help=_('Save Guake preferences to this filename')
help=_("Save Guake preferences to this filename"),
)
parser.add_option(
'--restore-preferences',
dest='restore_preferences',
action='store',
"--restore-preferences",
dest="restore_preferences",
action="store",
default=None,
help=_('Restore Guake preferences from this file')
help=_("Restore Guake preferences from this file"),
)
parser.add_option(
'--support',
dest='support',
action='store_true',
"--support",
dest="support",
action="store_true",
default=False,
help=_('Show support infomation')
help=_("Show support infomation"),
)
# checking mandatory dependencies
@ -363,20 +362,21 @@ def main():
missing_deps = False
try:
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
except ValueError:
print("[ERROR] missing mandatory dependency: GtK 3.0")
missing_deps = True
try:
gi.require_version('Vte', '2.91') # vte-0.42
gi.require_version("Vte", "2.91") # vte-0.42
except ValueError:
print("[ERROR] missing mandatory dependency: Vte >= 0.42")
missing_deps = True
try:
gi.require_version('Keybinder', '3.0')
gi.require_version("Keybinder", "3.0")
except ValueError:
print("[ERROR] missing mandatory dependency: Keybinder 3")
missing_deps = True
@ -416,14 +416,15 @@ def main():
from guake import guake_version
from guake import vte_version
from guake import vte_runtime_version
print('Guake Terminal: {}'.format(guake_version()))
print('VTE: {}'.format(vte_version()))
print('VTE runtime: {}'.format(vte_runtime_version()))
print('Gtk: {}'.format(gtk_version()))
print("Guake Terminal: {}".format(guake_version()))
print("VTE: {}".format(vte_version()))
print("VTE runtime: {}".format(vte_runtime_version()))
print("Gtk: {}".format(gtk_version()))
sys.exit(0)
if options.save_preferences and options.restore_preferences:
parser.error('options --save-preferences and --restore-preferences are mutually exclusive')
parser.error("options --save-preferences and --restore-preferences are mutually exclusive")
if options.save_preferences:
save_preferences(options.save_preferences)
sys.exit(0)
@ -459,11 +460,12 @@ def main():
# gnome-terminal.
# To avoid confusing applications running inside Guake, clean up COLORTERM at startup.
if "COLORTERM" in os.environ:
del os.environ['COLORTERM']
del os.environ["COLORTERM"]
log.info("Guake not running, starting it")
# late loading of the Guake object, to speed up dbus comm
from guake.guake_app import Guake
instance = Guake()
remote_object = DbusManager(instance)
already_running = False
@ -496,17 +498,17 @@ def main():
if 0 <= selected < tab_count:
remote_object.select_tab(selected)
else:
sys.stderr.write('invalid index: %d\n' % selected)
sys.stderr.write("invalid index: %d\n" % selected)
only_show_hide = options.show
if options.selected_tab:
selected = remote_object.get_selected_tab()
sys.stdout.write('%d\n' % selected)
sys.stdout.write("%d\n" % selected)
only_show_hide = options.show
if options.selected_tablabel:
selectedlabel = remote_object.get_selected_tablabel()
sys.stdout.write('%s\n' % selectedlabel)
sys.stdout.write("%s\n" % selectedlabel)
only_show_hide = options.show
if options.split_vertical:
@ -519,7 +521,7 @@ def main():
if options.selected_terminal:
selected = remote_object.get_selected_terminal()
sys.stdout.write('%d\n' % selected)
sys.stdout.write("%d\n" % selected)
only_show_hide = options.show
if options.select_terminal:
@ -528,7 +530,7 @@ def main():
if 0 <= selected < term_count:
remote_object.select_terminal(selected)
else:
sys.stderr.write('invalid index: %d\n' % selected)
sys.stderr.write("invalid index: %d\n" % selected)
only_show_hide = options.show
if options.command:
@ -595,12 +597,14 @@ def main():
startup_script = instance.settings.general.get_string("startup-script")
if startup_script:
log.info("Calling startup script: %s", startup_script)
pid = subprocess.Popen([startup_script],
shell=True,
stdin=None,
stdout=None,
stderr=None,
close_fds=True)
pid = subprocess.Popen(
[startup_script],
shell=True,
stdin=None,
stdout=None,
stderr=None,
close_fds=True,
)
log.info("Startup script started with pid: %s", pid)
# Please ensure this is the last line !!!!
else:
@ -617,10 +621,12 @@ def exec_main():
# Load gi pretty late, to speed up as much as possible the parsing of the option for DBus
# comm through command line
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
Gtk.main()
if __name__ == '__main__':
if __name__ == "__main__":
exec_main()

13
guake/menus.py
View File

@ -1,12 +1,15 @@
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from locale import gettext as _
gi.require_version('Vte', '2.91') # vte-0.42
gi.require_version("Vte", "2.91") # vte-0.42
from gi.repository import Vte
from guake.customcommands import CustomCommands
import logging
log = logging.getLogger(__name__)
@ -123,7 +126,7 @@ def mk_terminal_context_menu(terminal, window, settings, callback_object):
# implementation does not support this at the moment
if link:
if len(link) >= FILE_SELECTION_LENGTH:
mi.set_label(_("Open Link: {!s}...").format(link[:FILE_SELECTION_LENGTH - 3]))
mi.set_label(_("Open Link: {!s}...").format(link[: FILE_SELECTION_LENGTH - 3]))
else:
mi.set_label(_("Open Link: {!s}").format(link))
mi.set_sensitive(True)
@ -136,7 +139,7 @@ def mk_terminal_context_menu(terminal, window, settings, callback_object):
if selection:
search_text = selection.rstrip()
if len(search_text) > SEARCH_SELECTION_LENGTH:
search_text = search_text[:SEARCH_SELECTION_LENGTH - 3] + "..."
search_text = search_text[: SEARCH_SELECTION_LENGTH - 3] + "..."
mi.set_label(_("Search on Web: '%s'") % search_text)
mi.set_sensitive(True)
else:
@ -150,7 +153,7 @@ def mk_terminal_context_menu(terminal, window, settings, callback_object):
filename_str = str(filename)
if len(filename_str) > FILE_SELECTION_LENGTH:
mi.set_label(
_("Quick Open: {!s}...").format(filename_str[:FILE_SELECTION_LENGTH - 3])
_("Quick Open: {!s}...").format(filename_str[: FILE_SELECTION_LENGTH - 3])
)
else:
mi.set_label(_("Quick Open: {!s}").format(filename_str))

98
guake/notebook.py
View File

@ -33,8 +33,9 @@ from guake.utils import save_tabs_when_changed
import gi
import os
gi.require_version('Gtk', '3.0')
gi.require_version('Wnck', '3.0')
gi.require_version("Gtk", "3.0")
gi.require_version("Wnck", "3.0")
from gi.repository import GObject
from gi.repository import Gdk
from gi.repository import Gtk
@ -49,7 +50,6 @@ log = logging.getLogger(__name__)
class TerminalNotebook(Gtk.Notebook):
def __init__(self, *args, **kwargs):
Gtk.Notebook.__init__(self, *args, **kwargs)
self.last_terminal_focused = None
@ -66,35 +66,38 @@ class TerminalNotebook(Gtk.Notebook):
self.set_property("is-focus", True)
self.set_property("expand", True)
if GObject.signal_lookup('terminal-spawned', TerminalNotebook) == 0:
if GObject.signal_lookup("terminal-spawned", TerminalNotebook) == 0:
GObject.signal_new(
'terminal-spawned', TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT, GObject.TYPE_INT)
"terminal-spawned",
TerminalNotebook,
GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT, GObject.TYPE_INT),
)
GObject.signal_new(
'page-deleted', TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, ()
"page-deleted", TerminalNotebook, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (),
)
self.scroll_callback = NotebookScrollCallback(self)
self.add_events(Gdk.EventMask.SCROLL_MASK)
self.connect('scroll-event', self.scroll_callback.on_scroll)
self.connect("scroll-event", self.scroll_callback.on_scroll)
self.notebook_on_button_press_id = self.connect(
"button-press-event", self.on_button_press, None
)
# Action box
self.new_page_button = Gtk.Button(
image=Gtk.Image.new_from_icon_name("tab-new", Gtk.IconSize.MENU), visible=True
image=Gtk.Image.new_from_icon_name("tab-new", Gtk.IconSize.MENU), visible=True,
)
self.new_page_button.connect("clicked", self.on_new_tab)
self.tab_selection_button = Gtk.Button(
image=Gtk.Image.new_from_icon_name('pan-down-symbolic', Gtk.IconSize.MENU),
visible=True
image=Gtk.Image.new_from_icon_name("pan-down-symbolic", Gtk.IconSize.MENU),
visible=True,
)
self.popover = Gtk.Popover()
self.popover_window = None
self.tab_selection_button.connect('clicked', self.on_tab_selection)
self.tab_selection_button.connect("clicked", self.on_tab_selection)
self.action_box = Gtk.Box(visible=True)
self.action_box.pack_start(self.new_page_button, 0, 0, 0)
@ -136,22 +139,25 @@ class TerminalNotebook(Gtk.Notebook):
# ref: epiphany
css_provider = Gtk.CssProvider()
css_provider.load_from_data(
b'#popover-window list { border-style: none; background-color: transparent; }'
b"#popover-window list { border-style: none; background-color: transparent; }"
)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
Gdk.Screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
)
# Construct popover properties
BOX_HEIGHT = 30
LISTBOX_MARGIN = 12
self.popover_window = Gtk.ScrolledWindow(name='popover-window')
self.popover_window = Gtk.ScrolledWindow(name="popover-window")
self.popover_listbox = Gtk.ListBox()
self.popover_listbox.set_property('margin', LISTBOX_MARGIN)
self.popover_listbox.set_property("margin", LISTBOX_MARGIN)
self.popover_window.add_with_viewport(self.popover_listbox)
max_height = self.guake.window.get_allocation().height - BOX_HEIGHT if \
self.guake else BOX_HEIGHT * 10
max_height = (
self.guake.window.get_allocation().height - BOX_HEIGHT
if self.guake
else BOX_HEIGHT * 10
)
height = BOX_HEIGHT * self.get_n_pages() + LISTBOX_MARGIN * 4
self.popover_window.set_min_content_height(min(max_height, height))
self.popover_window.set_min_content_width(325)
@ -168,14 +174,14 @@ class TerminalNotebook(Gtk.Notebook):
label.set_xalign(0.0)
box.pack_start(label, 0, 0, 5)
row.add(box)
setattr(row, 'page_index', i)
setattr(row, "page_index", i)
self.popover_listbox.add(row)
if current_term in self.get_terminals_for_page(i):
self.popover_listbox.select_row(row)
selected_row = i
# Signal
self.popover_listbox.connect('row-activated', self.on_popover_tab_select)
self.popover_listbox.connect("row-activated", self.on_popover_tab_select)
# Show popup
self.popover.set_position(Gtk.PositionType.TOP)
@ -198,13 +204,13 @@ class TerminalNotebook(Gtk.Notebook):
adj.set_value(part * (selected_row + 1))
def on_popover_tab_select(self, list_box, row):
page_index = getattr(row, 'page_index', -1)
page_index = getattr(row, "page_index", -1)
if page_index != -1:
self.set_current_page(page_index)
self.get_terminals_for_page(page_index)[0].grab_focus()
def set_tabbar_visible(self, v):
self.set_property('show-tabs', v)
self.set_property("show-tabs", v)
def set_last_terminal_focused(self, terminal):
self.last_terminal_focused = terminal
@ -250,7 +256,8 @@ class TerminalNotebook(Gtk.Notebook):
total_procs += 1
except OSError:
log.debug(
"Cannot retrieve any pid from terminal %s, looks like it is already dead", index
"Cannot retrieve any pid from terminal %s, looks like it is already dead",
index,
)
return 0
return total_procs
@ -311,7 +318,7 @@ class TerminalNotebook(Gtk.Notebook):
page = self.get_nth_page(self.get_current_page())
if page.get_terminals():
page.get_terminals()[0].grab_focus()
self.emit('page-deleted')
self.emit("page-deleted")
def delete_page_by_label(self, label, kill=True, prompt=0):
self.delete_page(self.find_tab_index_by_label(label), kill, prompt)
@ -344,19 +351,19 @@ class TerminalNotebook(Gtk.Notebook):
terminal = GuakeTerminal(self.guake)
terminal.grab_focus()
if not isinstance(directory, str):
directory = os.environ['HOME']
directory = os.environ["HOME"]
try:
if self.guake.settings.general.get_boolean('open-tab-cwd'):
if self.guake.settings.general.get_boolean("open-tab-cwd"):
# Do last focused terminal still alive?
active_terminal = self.get_current_terminal()
if not active_terminal:
# If not alive, can we get any focused terminal?
active_terminal = self.get_focused_terminal()
directory = os.path.expanduser('~')
directory = os.path.expanduser("~")
if active_terminal:
# If found, we will use its directory as new terminal's directory
directory = active_terminal.get_current_directory()
except Exception as e:
except BaseException:
pass
log.info("Spawning new terminal at %s", directory)
terminal.spawn_sync_pid(directory)
@ -364,7 +371,7 @@ class TerminalNotebook(Gtk.Notebook):
def terminal_attached(self, terminal):
terminal.emit("focus", Gtk.DirectionType.TAB_FORWARD)
self.emit('terminal-spawned', terminal, terminal.pid)
self.emit("terminal-spawned", terminal, terminal.pid)
def new_page_with_focus(self, directory=None, label=None, user_set=False, position=None):
box, page_num, terminal = self.new_page(directory, position=position)
@ -389,7 +396,7 @@ class TerminalNotebook(Gtk.Notebook):
else:
label = TabLabelEventBox(self, new_text, self.guake.settings)
label.add_events(Gdk.EventMask.SCROLL_MASK)
label.connect('scroll-event', self.scroll_callback.on_scroll)
label.connect("scroll-event", self.scroll_callback.on_scroll)
self.set_tab_label(page, label)
if user_set:
@ -437,12 +444,12 @@ class TerminalNotebook(Gtk.Notebook):
flags=Gtk.DialogFlags.MODAL,
buttons=Gtk.ButtonsType.OK_CANCEL,
message_format=_(
'You are going to restore *all* the tabs!\n'
'which means all your terminals & pages '
'will be replaced.\n\nDo you want to continue?'
)
"You are going to restore *all* the tabs!\n"
"which means all your terminals & pages "
"will be replaced.\n\nDo you want to continue?"
),
)
dialog.connect('response', self.restore_tabs_dialog_response)
dialog.connect("response", self.restore_tabs_dialog_response)
dialog.show()
def restore_tabs_dialog_response(self, widget, response_id):
@ -452,15 +459,17 @@ class TerminalNotebook(Gtk.Notebook):
class NotebookManager(GObject.Object):
def __init__(
self, window, notebook_parent, workspaces_enabled, terminal_spawned_cb, page_deleted_cb
self, window, notebook_parent, workspaces_enabled, terminal_spawned_cb, page_deleted_cb,
):
GObject.Object.__init__(self)
if not GObject.signal_lookup('notebook-created', self):
if not GObject.signal_lookup("notebook-created", self):
GObject.signal_new(
'notebook-created', self, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT, GObject.TYPE_INT)
"notebook-created",
self,
GObject.SIGNAL_RUN_LAST,
GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT, GObject.TYPE_INT),
)
self.current_notebook = 0
self.notebooks = {}
@ -482,9 +491,9 @@ class NotebookManager(GObject.Object):
def get_notebook(self, workspace_index: int):
if not self.has_notebook_for_workspace(workspace_index):
self.notebooks[workspace_index] = TerminalNotebook()
self.emit('notebook-created', self.notebooks[workspace_index], workspace_index)
self.notebooks[workspace_index].connect('terminal-spawned', self.terminal_spawned_cb)
self.notebooks[workspace_index].connect('page-deleted', self.page_deleted_cb)
self.emit("notebook-created", self.notebooks[workspace_index], workspace_index)
self.notebooks[workspace_index].connect("terminal-spawned", self.terminal_spawned_cb)
self.notebooks[workspace_index].connect("page-deleted", self.page_deleted_cb)
log.info("created fresh notebook for workspace %d", self.current_notebook)
# add a tab if there is none
@ -505,8 +514,7 @@ class NotebookManager(GObject.Object):
log.info("current workspace is %d", self.current_notebook)
notebook = self.get_current_notebook()
self.notebook_parent.add(notebook)
if self.window.get_property('visible') and \
notebook.last_terminal_focused is not None:
if self.window.get_property("visible") and notebook.last_terminal_focused is not None:
notebook.last_terminal_focused.grab_focus()
# Restore pending page terminal split

5
guake/notifier.py
View File

@ -19,13 +19,14 @@ Boston, MA 02110-1301 USA
"""
import gi
gi.require_version('Notify', '0.7')
gi.require_version("Notify", "0.7")
from gi.repository import GLib
from gi.repository import Notify
Notify.init("Guake")
__all__ = ['showMessage']
__all__ = ["showMessage"]
def showMessage(brief, body=None, icon=None):

1990
guake/palettes.py
View File

File diff suppressed because it is too large Load Diff

858
guake/prefs.py
View File

File diff suppressed because it is too large Load Diff

32
guake/settings.py
View File

@ -21,14 +21,14 @@ Boston, MA 02110-1301 USA
import logging
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gio
log = logging.getLogger(__name__)
class Settings():
class Settings:
def __init__(self, schema_source):
Settings.enhanceSetting()
@ -39,58 +39,60 @@ class Settings():
self.guake.connect("changed", self.guake.triggerOnChangedValue)
self.general = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.general", False), None, None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.general", False), None, None,
)
self.general.initEnhancements()
self.general.connect("changed", self.general.triggerOnChangedValue)
self.keybindings = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings", False), None, None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings", False), None, None,
)
self.keybindings.initEnhancements()
self.keybindings.connect("changed", self.keybindings.triggerOnChangedValue)
self.keybindingsGlobal = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings.global", False), None,
None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings.global", False),
None,
None,
)
self.keybindingsGlobal.initEnhancements()
self.keybindingsGlobal.connect("changed", self.keybindingsGlobal.triggerOnChangedValue)
self.keybindingsLocal = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings.local", False), None,
None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.keybindings.local", False),
None,
None,
)
self.keybindingsLocal.initEnhancements()
self.keybindingsLocal.connect("changed", self.keybindingsLocal.triggerOnChangedValue)
self.styleBackground = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style.background", False), None,
None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style.background", False),
None,
None,
)
self.styleBackground.initEnhancements()
self.styleBackground.connect("changed", self.styleBackground.triggerOnChangedValue)
self.styleFont = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style.font", False), None, None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style.font", False), None, None,
)
self.styleFont.initEnhancements()
self.styleFont.connect("changed", self.styleFont.triggerOnChangedValue)
self.style = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style", False), None, None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.style", False), None, None,
)
self.style.initEnhancements()
self.style.connect("changed", self.style.triggerOnChangedValue)
self.hooks = Gio.Settings.new_full(
Gio.SettingsSchemaSource.lookup(schema_source, "guake.hooks", False), None, None
Gio.SettingsSchemaSource.lookup(schema_source, "guake.hooks", False), None, None,
)
self.hooks.initEnhancements()
self.hooks.connect("changed", self.hooks.triggerOnChangedValue)
def enhanceSetting():
def initEnhancements(self):
self.listeners = dict()

15
guake/simplegladeapp.py
View File

@ -22,14 +22,14 @@ import re
import sys
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
import tokenize
class SimpleGladeApp():
class SimpleGladeApp:
def __init__(self, path, root=None, domain=None, **kwargs):
"""
Load a glade file specified by glade_filename, using root as
@ -138,11 +138,10 @@ class SimpleGladeApp():
raise AttributeError(
"instance %s already has an attribute %s" % (self, widget_api_name)
)
else:
setattr(self, widget_api_name, widget)
if prefixes:
# TODO is is a guess
Gtk.Buildable.set_data(widget, "prefixes", prefixes)
setattr(self, widget_api_name, widget)
if prefixes:
# TODO is is a guess
Gtk.Buildable.set_data(widget, "prefixes", prefixes)
def add_prefix_actions(self, prefix_actions_proxy):
"""

7
guake/split_utils.py
View File

@ -18,14 +18,15 @@ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301 USA
"""
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from guake.boxes import DualTerminalBox
from guake.boxes import RootTerminalBox
class FocusMover():
class FocusMover:
THRESHOLD = 10
BORDER_THICKNESS = 2
@ -94,7 +95,7 @@ class FocusMover():
return x, y, terminal_rect.width, terminal_rect.height
class SplitMover():
class SplitMover:
THRESHOLD = 35
STEP = 10

58
guake/support.py
View File

@ -3,8 +3,9 @@
import os
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk
from gi.repository import GdkX11
@ -17,17 +18,17 @@ from guake import vte_version
def horizonal_line():
print('-' * 50)
print("-" * 50)
def populate_display(display):
screen = display.get_default_screen()
print('Display: {}'.format(display.get_name()))
print("Display: {}".format(display.get_name()))
print()
# pylint: disable=R1719
print('RGBA visual: {}'.format(True if screen.get_rgba_visual() else False))
print("RGBA visual: {}".format(True if screen.get_rgba_visual() else False))
print()
print('Composited: {}'.format(screen.is_composited()))
print("Composited: {}".format(screen.is_composited()))
print()
n_monitors = display.get_n_monitors()
@ -35,57 +36,62 @@ def populate_display(display):
monitor = display.get_monitor(i)
manufacturer = monitor.get_manufacturer()
model = monitor.get_model()
v = '%s%s%s' % (
manufacturer if manufacturer else '', ' ' if manufacturer or model else '',
model if model else ''
v = "%s%s%s" % (
manufacturer if manufacturer else "",
" " if manufacturer or model else "",
model if model else "",
)
print('* Monitor: {} - {}'.format(i, v))
print("* Monitor: {} - {}".format(i, v))
# Geometry
rect = monitor.get_geometry()
scale = monitor.get_scale_factor()
v = '%d x %d%s at %d, %d' % (
rect.width, rect.height, ' % 2' if scale == 2 else '', rect.x, rect.y
v = "%d x %d%s at %d, %d" % (
rect.width,
rect.height,
" % 2" if scale == 2 else "",
rect.x,
rect.y,
)
print(' * Geometry:\t\t{}'.format(v))
print(" * Geometry:\t\t{}".format(v))
# Size
v = '%d x %d mm²' % (monitor.get_width_mm(), monitor.get_height_mm())
print(' * Size:\t\t{}'.format(v))
v = "%d x %d mm²" % (monitor.get_width_mm(), monitor.get_height_mm())
print(" * Size:\t\t{}".format(v))
# Primary
print(' * Primary:\t\t{}'.format(monitor.is_primary()))
print(" * Primary:\t\t{}".format(monitor.is_primary()))
# Refresh rate
if monitor.get_refresh_rate():
v = '%.2f Hz' % (0.001 * monitor.get_refresh_rate())
v = "%.2f Hz" % (0.001 * monitor.get_refresh_rate())
else:
v = 'unknown'
print(' * Refresh rate:\t{}'.format(v))
v = "unknown"
print(" * Refresh rate:\t{}".format(v))
# Subpixel layout
print(' * Subpixel layout:\t{}'.format(monitor.get_subpixel_layout().value_nick))
print(" * Subpixel layout:\t{}".format(monitor.get_subpixel_layout().value_nick))
def get_version():
display = Gdk.Display.get_default()
print('Guake Version:\t\t{}'.format(guake_version()))
print("Guake Version:\t\t{}".format(guake_version()))
print()
print('Vte Version:\t\t{}'.format(vte_version()))
print("Vte Version:\t\t{}".format(vte_version()))
print()
print('Vte Runtime Version:\t{}'.format(vte_runtime_version()))
print("Vte Runtime Version:\t{}".format(vte_runtime_version()))
print()
horizonal_line()
print('GTK+ Version:\t\t{}'.format(gtk_version()))
print("GTK+ Version:\t\t{}".format(gtk_version()))
print()
print('GDK Backend:\t\t{}'.format(str(display).split(' ')[0][1:]))
print("GDK Backend:\t\t{}".format(str(display).split(" ")[0][1:]))
print()
horizonal_line()
def get_desktop_session():
print('Desktop Session: {}'.format(os.environ.get('DESKTOP_SESSION')))
print("Desktop Session: {}".format(os.environ.get("DESKTOP_SESSION")))
print()
horizonal_line()

118
guake/terminal.py
View File

@ -38,8 +38,9 @@ from urllib.parse import urlparse
from time import sleep
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Vte', '2.91') # vte-0.38
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91") # vte-0.38
from gi.repository import GLib
from gi.repository import Gdk
@ -61,7 +62,8 @@ try:
# be injected in current process, as: wall
from atexit import register as at_exit_call
from ctypes import cdll
libutempter = cdll.LoadLibrary('libutempter.so.0')
libutempter = cdll.LoadLibrary("libutempter.so.0")
if libutempter is not None:
# We absolutely need to remove the old tty from the utmp !!!
at_exit_call(libutempter.utempter_remove_added_record)
@ -74,7 +76,7 @@ except Exception as e:
"[WARN] - 'exit' command might freeze the terminal instead of closing the tab\n"
"[WARN] - the 'wall' command is known to work badly\n"
)
sys.stderr.write("[WARN] Error: " + str(e) + '\n')
sys.stderr.write("[WARN] Error: " + str(e) + "\n")
sys.stderr.write(
"[WARN] ===================================================================²\n"
)
@ -84,7 +86,7 @@ def halt(loc):
code.interact(local=loc)
__all__ = ['GuakeTerminal']
__all__ = ["GuakeTerminal"]
# pylint: enable=anomalous-backslash-in-string
@ -105,9 +107,9 @@ class GuakeTerminal(Vte.Terminal):
self.configure_terminal()
self.add_matches()
self.handler_ids = []
self.handler_ids.append(self.connect('button-press-event', self.button_press))
self.connect('child-exited', self.on_child_exited) # Call on_child_exited, don't remove it
self.matched_value = ''
self.handler_ids.append(self.connect("button-press-event", self.button_press))
self.connect("child-exited", self.on_child_exited) # Call on_child_exited, don't remove it
self.matched_value = ""
self.font_scale_index = 0
self._pid = None
# self.custom_bgcolor = None
@ -128,7 +130,7 @@ class GuakeTerminal(Vte.Terminal):
self.targets.add_text_targets(DropTargets.TEXT)
self.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
self.drag_dest_set_target_list(self.targets)
self.connect('drag-data-received', self.on_drag_data_received)
self.connect("drag-data-received", self.on_drag_data_received)
def get_uuid(self):
return self.uuid
@ -154,7 +156,7 @@ class GuakeTerminal(Vte.Terminal):
super().feed_child(resolved_cmdline, len(resolved_cmdline))
def execute_command(self, command):
if command[-1] != '\n':
if command[-1] != "\n":
command += "\n"
self.feed_child(command)
@ -169,21 +171,21 @@ class GuakeTerminal(Vte.Terminal):
"""Sets all customized properties on the terminal
"""
client = self.guake.settings.general
word_chars = client.get_string('word-chars')
word_chars = client.get_string("word-chars")
if word_chars:
self.set_word_char_exceptions(word_chars)
self.set_audible_bell(client.get_boolean('use-audible-bell'))
self.set_audible_bell(client.get_boolean("use-audible-bell"))
self.set_sensitive(True)
cursor_blink_mode = self.guake.settings.style.get_int('cursor-blink-mode')
self.set_property('cursor-blink-mode', cursor_blink_mode)
cursor_blink_mode = self.guake.settings.style.get_int("cursor-blink-mode")
self.set_property("cursor-blink-mode", cursor_blink_mode)
if (Vte.MAJOR_VERSION, Vte.MINOR_VERSION) >= (0, 50):
self.set_allow_hyperlink(True)
if (Vte.MAJOR_VERSION, Vte.MINOR_VERSION) >= (0, 56):
try:
self.set_bold_is_bright(self.guake.settings.styleFont.get_boolean('bold-is-bright'))
self.set_bold_is_bright(self.guake.settings.styleFont.get_boolean("bold-is-bright"))
except: # pylint: disable=bare-except
log.error("set_bold_is_bright not supported by your version of VTE")
@ -217,7 +219,10 @@ class GuakeTerminal(Vte.Terminal):
Vte.Regex.new_for_match(match, len(match), VTE_REGEX_FLAGS), 0
)
self.match_set_cursor_type(tag, Gdk.CursorType.HAND2)
except (GLib.Error, AttributeError) as e: # pylint: disable=catching-non-exception
except (
GLib.Error,
AttributeError,
): # pylint: disable=catching-non-exception
try:
compile_flag = 0
if (Vte.MAJOR_VERSION, Vte.MINOR_VERSION) >= (0, 44):
@ -234,15 +239,16 @@ class GuakeTerminal(Vte.Terminal):
"ERROR: PCRE2 does not seems to be enabled on your system. "
"Quick Edit and other Ctrl+click features are disabled. "
"Please update your VTE package or contact your distribution to ask "
"to enable regular expression support in VTE. Exception: '%s'", str(e)
"to enable regular expression support in VTE. Exception: '%s'",
str(e),
)
def get_current_directory(self):
directory = os.path.expanduser('~')
directory = os.path.expanduser("~")
if self.pid is not None:
try:
cwd = os.readlink("/proc/{}/cwd".format(self.pid))
except Exception as e:
except Exception:
return directory
if os.path.exists(cwd):
directory = cwd
@ -326,12 +332,12 @@ class GuakeTerminal(Vte.Terminal):
any match string is caught, another application is open to
handle the matched resource uri.
"""
self.matched_value = ''
self.matched_value = ""
if (Vte.MAJOR_VERSION, Vte.MINOR_VERSION) >= (0, 46):
matched_string = self.match_check_event(event)
else:
matched_string = self.match_check(
int(event.x / self.get_char_width()), int(event.y / self.get_char_height())
int(event.x / self.get_char_width()), int(event.y / self.get_char_height()),
)
self.found_link = None
@ -361,7 +367,7 @@ class GuakeTerminal(Vte.Terminal):
uris = data.get_uris()
for uri in uris:
path = Path(unquote(urlparse(uri).path))
self.feed_child(shlex.quote(str(path.absolute())) + ' ')
self.feed_child(shlex.quote(str(path.absolute())) + " ")
elif info == DropTargets.TEXT:
text = data.get_text()
if text:
@ -426,8 +432,8 @@ class GuakeTerminal(Vte.Terminal):
)
if quick_open_in_current_terminal:
logging.debug("Executing it in current tab")
if resolved_cmdline[-1] != '\n':
resolved_cmdline += '\n'
if resolved_cmdline[-1] != "\n":
resolved_cmdline += "\n"
self.feed_child(resolved_cmdline)
else:
resolved_cmdline += " &"
@ -438,18 +444,18 @@ class GuakeTerminal(Vte.Terminal):
value, tag = matched_string
log.debug("found tag: %r, item: %r", tag, value)
if tag in TERMINAL_MATCH_TAGS:
if TERMINAL_MATCH_TAGS[tag] == 'schema':
if TERMINAL_MATCH_TAGS[tag] == "schema":
# value here should not be changed, it is right and
# ready to be used.
pass
elif TERMINAL_MATCH_TAGS[tag] == 'http':
value = 'http://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'https':
value = 'https://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'ftp':
value = 'ftp://%s' % value
elif TERMINAL_MATCH_TAGS[tag] == 'email':
value = 'mailto:%s' % value
elif TERMINAL_MATCH_TAGS[tag] == "http":
value = "http://%s" % value
elif TERMINAL_MATCH_TAGS[tag] == "https":
value = "https://%s" % value
elif TERMINAL_MATCH_TAGS[tag] == "ftp":
value = "ftp://%s" % value
elif TERMINAL_MATCH_TAGS[tag] == "email":
value = "mailto:%s" % value
if value:
return value
@ -493,7 +499,7 @@ class GuakeTerminal(Vte.Terminal):
def kill(self):
pid = self.pid
threading.Thread(target=self.delete_shell, args=(pid, )).start()
threading.Thread(target=self.delete_shell, args=(pid,)).start()
# start_new_thread(self.delete_shell, (pid,))
def delete_shell(self, pid):
@ -524,21 +530,27 @@ class GuakeTerminal(Vte.Terminal):
def spawn_sync_pid(self, directory):
argv = list()
user_shell = self.guake.settings.general.get_string('default-shell')
user_shell = self.guake.settings.general.get_string("default-shell")
if user_shell and os.path.exists(user_shell):
argv.append(user_shell)
else:
argv.append(os.environ['SHELL'])
argv.append(os.environ["SHELL"])
login_shell = self.guake.settings.general.get_boolean('use-login-shell')
login_shell = self.guake.settings.general.get_boolean("use-login-shell")
if login_shell:
argv.append('--login')
argv.append("--login")
log.debug("Spawn command: \"%s\"", " ".join(argv))
log.debug('Spawn command: "%s"', " ".join(argv))
pid = self.spawn_sync(
Vte.PtyFlags.DEFAULT, directory, argv, [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None,
None, None
Vte.PtyFlags.DEFAULT,
directory,
argv,
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
None,
)
try:
tuple_type = gi._gi.ResultTuple # pylint: disable=c-extension-no-member
@ -571,12 +583,13 @@ class GuakeTerminal(Vte.Terminal):
real_bgcolor = self.custom_bgcolor if self.custom_bgcolor else bg_color
real_fgcolor = self.custom_fgcolor if self.custom_fgcolor else font_color
real_palette = self.custom_palette if self.custom_palette else palette_list
super(GuakeTerminal,
self).set_colors(real_fgcolor, real_bgcolor, real_palette, *args, **kwargs)
super(GuakeTerminal, self).set_colors(
real_fgcolor, real_bgcolor, real_palette, *args, **kwargs
)
def set_color_foreground_custom(self, fgcolor, *args, **kwargs):
"""Sets custom foreground color for this terminal"""
print('set_color_foreground_custom: %s' % self.uuid)
print("set_color_foreground_custom: %s" % self.uuid)
self.custom_fgcolor = fgcolor
super(GuakeTerminal, self).set_color_foreground(self.custom_fgcolor, *args, **kwargs)
@ -601,35 +614,36 @@ class GuakeTerminal(Vte.Terminal):
def _color_from_list(color_list):
"""This method is used for deserialization."""
return Gdk.RGBA(
red=color_list[0], green=color_list[1], blue=color_list[2], alpha=color_list[3]
red=color_list[0], green=color_list[1], blue=color_list[2], alpha=color_list[3],
)
def get_custom_colors_dict(self):
"""Returns dictionary of custom colors."""
return {
'fg_color': self._color_to_list(self.custom_fgcolor),
'bg_color': self._color_to_list(self.custom_bgcolor),
'palette': [self._color_to_list(col)
for col in self.custom_palette] if self.custom_palette else None,
"fg_color": self._color_to_list(self.custom_fgcolor),
"bg_color": self._color_to_list(self.custom_bgcolor),
"palette": [self._color_to_list(col) for col in self.custom_palette]
if self.custom_palette
else None,
}
def set_custom_colors_from_dict(self, colors_dict):
if not isinstance(colors_dict, dict):
return
bg_color = colors_dict.get('bg_color', None)
bg_color = colors_dict.get("bg_color", None)
if isinstance(bg_color, list):
self.custom_bgcolor = self._color_from_list(bg_color)
else:
self.custom_bgcolor = None
fg_color = colors_dict.get('fg_color', None)
fg_color = colors_dict.get("fg_color", None)
if isinstance(fg_color, list):
self.custom_fgcolor = self._color_from_list(fg_color)
else:
self.custom_fgcolor = None
palette = colors_dict.get('palette', None)
palette = colors_dict.get("palette", None)
if isinstance(palette, list):
self.custom_palette = [self._color_from_list(col) for col in palette]
else:

6
guake/tests/test_about.py
View File

@ -10,7 +10,7 @@ from guake.about import AboutDialog
@pytest.fixture
def dialog(mocker):
mocker.patch('guake.simplegladeapp.Gtk.Widget.show_all')
mocker.patch("guake.simplegladeapp.Gtk.Widget.show_all")
try:
old_os_environ = os.environ
os.environ["LANGUAGE"] = "en_US.UTF-8"
@ -21,8 +21,8 @@ def dialog(mocker):
def test_version_test(dialog):
assert dialog.get_widget('aboutdialog').get_version() == guake_version()
assert dialog.get_widget("aboutdialog").get_version() == guake_version()
def test_title(dialog):
assert dialog.get_widget('aboutdialog').get_title() == 'About Guake'
assert dialog.get_widget("aboutdialog").get_title() == "About Guake"

104
guake/tests/test_guake.py
View File

@ -18,13 +18,13 @@ from guake.guake_app import Guake
@pytest.fixture
def g(mocker, fs):
mocker.patch('guake.guake_app.Guake.get_xdg_config_directory', return_value=Path('/foobar'))
mocker.patch('guake.guake_app.shutil.copy', create=True)
mocker.patch('guake.guake_app.notifier.showMessage', create=True)
mocker.patch('guake.guake_app.traceback.print_exc', create=True)
mocker.patch("guake.guake_app.Guake.get_xdg_config_directory", return_value=Path("/foobar"))
mocker.patch("guake.guake_app.shutil.copy", create=True)
mocker.patch("guake.guake_app.notifier.showMessage", create=True)
mocker.patch("guake.guake_app.traceback.print_exc", create=True)
fs.pause()
g = Guake()
fs.add_real_file(pixmapfile('guake-notification.png'))
fs.add_real_file(pixmapfile("guake-notification.png"))
fs.resume()
return g
@ -53,8 +53,8 @@ def test_accel_search_terminal_debounce(g):
def test_accel_quit_without_prompt(mocker, g):
# Disable quit prompt
mocker.patch.object(g.settings.general, 'get_boolean', return_value=False)
mocker.patch('guake.guake_app.Gtk.main_quit')
mocker.patch.object(g.settings.general, "get_boolean", return_value=False)
mocker.patch("guake.guake_app.Gtk.main_quit")
g.accel_quit()
assert guake.guake_app.Gtk.main_quit.call_count == 1
@ -62,9 +62,9 @@ def test_accel_quit_without_prompt(mocker, g):
def test_accel_quit_with_prompt(mocker, g):
# Enable quit prompt
mocker.patch.object(g.settings.general, 'get_boolean', return_value=True)
mocker.patch('guake.guake_app.PromptQuitDialog')
mocker.patch('guake.guake_app.Gtk.main_quit')
mocker.patch.object(g.settings.general, "get_boolean", return_value=True)
mocker.patch("guake.guake_app.PromptQuitDialog")
mocker.patch("guake.guake_app.Gtk.main_quit")
g.accel_quit()
assert guake.guake_app.Gtk.main_quit.call_count == 1
@ -74,56 +74,46 @@ def test_accel_quit_with_prompt(mocker, g):
def test_guake_restore_tabs(g, fs):
d1 = fs.create_dir('/foobar/foo')
d2 = fs.create_dir('/foobar/bar')
d3 = fs.create_dir('/foobar/foo/foo')
d4 = fs.create_dir('/foobar/foo/bar')
d1 = fs.create_dir("/foobar/foo")
d2 = fs.create_dir("/foobar/bar")
d3 = fs.create_dir("/foobar/foo/foo")
d4 = fs.create_dir("/foobar/foo/bar")
session = {
"schema_version": 1,
"timestamp": 1556092197,
"workspace": {
"0": [[{
"directory": d1.path,
"label": "1",
"custom_label_set": True
}, {
"directory": d2.path,
"label": "2",
"custom_label_set": True
}, {
"directory": d3.path,
"label": d3.path,
"custom_label_set": False
}]],
"1": [[{
"directory": d4.path,
"label": "4",
"custom_label_set": True
}]]
}
"0": [
[
{"directory": d1.path, "label": "1", "custom_label_set": True},
{"directory": d2.path, "label": "2", "custom_label_set": True},
{"directory": d3.path, "label": d3.path, "custom_label_set": False},
]
],
"1": [[{"directory": d4.path, "label": "4", "custom_label_set": True}]],
},
}
fn = fs.create_file('/foobar/session.json')
with open(fn.path, 'w') as f:
fn = fs.create_file("/foobar/session.json")
with open(fn.path, "w") as f:
f.write(json.dumps(session))
g.restore_tabs(fn.name)
nb = g.notebook_manager.get_notebook(0)
assert nb.get_n_pages() == 3
assert nb.get_tab_text_index(0) == '1'
assert nb.get_tab_text_index(1) == '2'
assert nb.get_tab_text_index(0) == "1"
assert nb.get_tab_text_index(1) == "2"
nb = g.notebook_manager.get_notebook(1)
assert nb.get_n_pages() == 1
assert nb.get_tab_text_index(0) == '4'
assert nb.get_tab_text_index(0) == "4"
def test_guake_restore_tabs_json_without_schema_version(g, fs):
guake.guake_app.notifier.showMessage.reset_mock()
fn = fs.create_file('/foobar/bar.json')
with open(fn.path, 'w') as f:
f.write('{}')
fn = fs.create_file("/foobar/bar.json")
with open(fn.path, "w") as f:
f.write("{}")
g.restore_tabs(fn.name)
assert guake.guake_app.notifier.showMessage.call_count == 1
@ -132,8 +122,8 @@ def test_guake_restore_tabs_json_without_schema_version(g, fs):
def test_guake_restore_tabs_with_higher_schema_version(g, fs):
guake.guake_app.notifier.showMessage.reset_mock()
fn = fs.create_file('/foobar/bar.json')
with open(fn.path, 'w') as f:
fn = fs.create_file("/foobar/bar.json")
with open(fn.path, "w") as f:
f.write('{"schema_version": 2147483647}')
g.restore_tabs(fn.name)
@ -142,9 +132,9 @@ def test_guake_restore_tabs_with_higher_schema_version(g, fs):
def test_guake_restore_tabs_json_broken_session_file(g, fs):
guake.guake_app.notifier.showMessage.reset_mock()
fn = fs.create_file('/foobar/foobar.json')
with open(fn.path, 'w') as f:
f.write('{')
fn = fs.create_file("/foobar/foobar.json")
with open(fn.path, "w") as f:
f.write("{")
g.restore_tabs(fn.name)
assert guake.guake_app.shutil.copy.call_count == 1
@ -154,9 +144,9 @@ def test_guake_restore_tabs_json_broken_session_file(g, fs):
def test_guake_restore_tabs_schema_broken_session_file(g, fs):
guake.guake_app.notifier.showMessage.reset_mock()
fn = fs.create_file('/foobar/bar.json')
d = fs.create_dir('/foobar/foo')
with open(fn.path, 'w') as f:
fn = fs.create_file("/foobar/bar.json")
d = fs.create_dir("/foobar/foo")
with open(fn.path, "w") as f:
f.write('{"schema_version": 1, "workspace": {"0": [[{"directory": "%s"}]]}}' % (d.path))
g.restore_tabs(fn.name)
@ -166,19 +156,19 @@ def test_guake_restore_tabs_schema_broken_session_file(g, fs):
def test_guake_save_tabs_and_restore(mocker, g, fs):
# Disable auto save
mocker.patch.object(g.settings.general, 'get_boolean', return_value=False)
mocker.patch.object(g.settings.general, "get_boolean", return_value=False)
# Save
assert not os.path.exists('/foobar/session.json')
assert not os.path.exists("/foobar/session.json")
g.add_tab()
g.rename_current_tab('foobar', True)
g.rename_current_tab("foobar", True)
g.add_tab()
g.rename_current_tab('python', True)
g.rename_current_tab("python", True)
assert g.get_notebook().get_n_pages() == 3
g.save_tabs()
assert os.path.exists('/foobar')
assert os.path.exists('/foobar/session.json')
assert os.path.exists("/foobar")
assert os.path.exists("/foobar/session.json")
# Restore prepare
g.close_tab()
@ -189,5 +179,5 @@ def test_guake_save_tabs_and_restore(mocker, g, fs):
g.restore_tabs()
nb = g.get_notebook()
assert nb.get_n_pages() == 3
assert nb.get_tab_text_index(1) == 'foobar'
assert nb.get_tab_text_index(2) == 'python'
assert nb.get_tab_text_index(1) == "foobar"
assert nb.get_tab_text_index(2) == "python"

13
guake/tests/test_notebook.py
View File

@ -9,9 +9,10 @@ from guake.notebook import TerminalNotebook
@pytest.fixture
def nb(mocker):
targets = [
'guake.notebook.TerminalNotebook.terminal_spawn',
'guake.notebook.TerminalNotebook.terminal_attached',
'guake.notebook.TerminalNotebook.guake', 'guake.notebook.TerminalBox.set_terminal'
"guake.notebook.TerminalNotebook.terminal_spawn",
"guake.notebook.TerminalNotebook.terminal_attached",
"guake.notebook.TerminalNotebook.guake",
"guake.notebook.TerminalBox.set_terminal",
]
for target in targets:
mocker.patch(target, create=True)
@ -44,8 +45,8 @@ def test_remove_page_in_notebook(nb):
def test_rename_page(nb):
t1 = 'foo'
t2 = 'bar'
t1 = "foo"
t2 = "bar"
nb.new_page()
nb.rename_page(0, t1, True)
assert nb.get_tab_text_index(0) == t1
@ -56,7 +57,7 @@ def test_rename_page(nb):
def test_add_new_page_with_focus_with_label(nb):
t = 'test_this_label'
t = "test_this_label"
nb.new_page_with_focus(label=t)
assert nb.get_n_pages() == 1
assert nb.get_tab_text_index(0) == t

4
guake/tests/test_quick_open.py
View File

@ -16,13 +16,13 @@ def test_quick_open():
)
found = _execute_quick_open(chunk)
assert found == [('./test.py', '5')]
assert found == [("./test.py", "5")]
def _execute_quick_open(chunk):
found = []
for line in chunk.split('\n'):
for line in chunk.split("\n"):
for _1, _2, r in QUICK_OPEN_MATCHERS:
g = re.compile(r).match(line)
if g:

34
guake/theme.py
View File

@ -5,7 +5,8 @@ import os
from pathlib import Path
import gi
gi.require_version('Gtk', '3.0')
gi.require_version("Gtk", "3.0")
from gi.repository import GLib
from gi.repository import Gdk
from gi.repository import Gtk
@ -28,8 +29,10 @@ def get_resource_dirs(resource):
A list of resource dirs
"""
dirs = [
os.path.join(dir, resource) for dir in
itertools.chain(GLib.get_system_data_dirs(), GUAKE_THEME_DIR, GLib.get_user_data_dir())
os.path.join(dir, resource)
for dir in itertools.chain(
GLib.get_system_data_dirs(), GUAKE_THEME_DIR, GLib.get_user_data_dir()
)
]
dirs += [os.path.join(os.path.expanduser("~"), ".{}".format(resource))]
@ -39,26 +42,28 @@ def get_resource_dirs(resource):
def list_all_themes():
return sorted(
set(
x.name for theme_dir in get_resource_dirs("themes") for x in theme_dir.iterdir()
x.name
for theme_dir in get_resource_dirs("themes")
for x in theme_dir.iterdir()
if x.is_dir()
)
)
def select_gtk_theme(settings):
gtk_theme_name = settings.general.get_string('gtk-theme-name')
gtk_theme_name = settings.general.get_string("gtk-theme-name")
log.debug("Wanted GTK theme: %r", gtk_theme_name)
gtk_settings = Gtk.Settings.get_default()
gtk_settings.set_property("gtk-theme-name", gtk_theme_name)
prefer_dark_theme = settings.general.get_boolean('gtk-prefer-dark-theme')
prefer_dark_theme = settings.general.get_boolean("gtk-prefer-dark-theme")
log.debug("Prefer dark theme: %r", prefer_dark_theme)
gtk_settings.set_property("gtk-application-prefer-dark-theme", prefer_dark_theme)
def get_gtk_theme(settings):
gtk_theme_name = settings.general.get_string('gtk-theme-name')
prefer_dark_theme = settings.general.get_boolean('gtk-prefer-dark-theme')
gtk_theme_name = settings.general.get_string("gtk-theme-name")
prefer_dark_theme = settings.general.get_boolean("gtk-prefer-dark-theme")
return (gtk_theme_name, "dark" if prefer_dark_theme else None)
@ -86,8 +91,11 @@ def patch_gtk_theme(style_context, settings):
selected_bg_color = rgba_to_hex(style_context.lookup_color("theme_selected_bg_color")[1])
log.debug(
"Patching theme '%s' (prefer dark = '%r'), overriding tab 'checked' state': "
"foreground: %r, background: %r", theme_name, "yes" if variant == "dark" else "no",
selected_fg_color, selected_bg_color
"foreground: %r, background: %r",
theme_name,
"yes" if variant == "dark" else "no",
selected_fg_color,
selected_bg_color,
)
css_data = dedent(
"""
@ -95,10 +103,12 @@ def patch_gtk_theme(style_context, settings):
color: {selected_fg_color};
background: {selected_bg_color};
}}
""".format(selected_bg_color=selected_bg_color, selected_fg_color=selected_fg_color)
""".format(
selected_bg_color=selected_bg_color, selected_fg_color=selected_fg_color
)
).encode()
style_provider = Gtk.CssProvider()
style_provider.load_from_data(css_data)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
)

74
guake/utils.py
View File

@ -27,8 +27,9 @@ import subprocess
import time
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk
from gi.repository import Gtk
@ -76,19 +77,19 @@ def save_tabs_when_changed(func):
# Find me the Guake!
clsname = args[0].__class__.__name__
g = None
if clsname == 'Guake':
if clsname == "Guake":
g = args[0]
elif getattr(args[0], 'get_guake', None):
elif getattr(args[0], "get_guake", None):
g = args[0].get_guake()
elif getattr(args[0], 'get_notebook', None):
elif getattr(args[0], "get_notebook", None):
g = args[0].get_notebook().guake
elif getattr(args[0], 'guake', None):
elif getattr(args[0], "guake", None):
g = args[0].guake
elif getattr(args[0], 'notebook', None):
elif getattr(args[0], "notebook", None):
g = args[0].notebook.guake
# Tada!
if g and g.settings.general.get_boolean('save-tabs-when-changed'):
if g and g.settings.general.get_boolean("save-tabs-when-changed"):
g.save_tabs()
return wrapper
@ -96,24 +97,23 @@ def save_tabs_when_changed(func):
def save_preferences(filename):
# XXX: Hardcode?
prefs = subprocess.check_output(['dconf', 'dump', '/apps/guake/'])
with open(filename, 'wb') as f:
prefs = subprocess.check_output(["dconf", "dump", "/apps/guake/"])
with open(filename, "wb") as f:
f.write(prefs)
def restore_preferences(filename):
# XXX: Hardcode?
with open(filename, 'rb') as f:
with open(filename, "rb") as f:
prefs = f.read()
p = subprocess.Popen(['dconf', 'load', '/apps/guake/'], stdin=subprocess.PIPE)
p = subprocess.Popen(["dconf", "load", "/apps/guake/"], stdin=subprocess.PIPE)
p.communicate(input=prefs)
class TabNameUtils():
class TabNameUtils:
@classmethod
def shorten(cls, text, settings):
use_vte_titles = settings.general.get_boolean('use-vte-titles')
use_vte_titles = settings.general.get_boolean("use-vte-titles")
if not use_vte_titles:
return text
max_name_length = settings.general.get_int("max-tab-name-length")
@ -122,8 +122,7 @@ class TabNameUtils():
return text
class HidePrevention():
class HidePrevention:
def __init__(self, window):
"""Create a new HidePrevention object like `HidePrevention(window)`
"""
@ -135,22 +134,22 @@ class HidePrevention():
"""returns True if the window is allowed to hide and
False if `prevent()` is called from some where
"""
return getattr(self.window, 'can_hide', True)
return getattr(self.window, "can_hide", True)
def prevent(self):
"""sets a flag on the window object which indicates to
may_hide that the window is NOT allowed to be hidden.
"""
setattr(self.window, 'can_hide', False)
setattr(self.window, "can_hide", False)
def allow(self):
"""sets the flag so that it indicates to may_hide that the window is allowed to be hidden
"""
setattr(self.window, 'can_hide', True)
setattr(self.window, "can_hide", True)
class FullscreenManager():
FULLSCREEN_ATTR = 'is_fullscreen'
class FullscreenManager:
FULLSCREEN_ATTR = "is_fullscreen"
def __init__(self, settings, window, guake=None):
self.settings = settings
@ -163,7 +162,9 @@ class FullscreenManager():
def set_window_state(self, window_state):
self.window_state = window_state
setattr(self.window, self.FULLSCREEN_ATTR, bool(window_state & Gdk.WindowState.FULLSCREEN))
setattr(
self.window, self.FULLSCREEN_ATTR, bool(window_state & Gdk.WindowState.FULLSCREEN),
)
if not window_state & Gdk.WindowState.WITHDRAWN:
if self.is_fullscreen():
@ -193,17 +194,16 @@ class FullscreenManager():
def toggle_fullscreen_hide_tabbar(self):
if self.is_fullscreen():
if self.settings.general.get_boolean('fullscreen-hide-tabbar'):
if self.settings.general.get_boolean("fullscreen-hide-tabbar"):
if self.guake and self.guake.notebook_manager:
self.guake.notebook_manager.set_notebooks_tabbar_visible(False)
else:
if self.guake and self.guake.notebook_manager:
v = self.settings.general.get_boolean('window-tabbar')
v = self.settings.general.get_boolean("window-tabbar")
self.guake.notebook_manager.set_notebooks_tabbar_visible(v)
class RectCalculator():
class RectCalculator:
@classmethod
def set_final_window_rect(cls, settings, window):
"""Sets the final size and location of the main window of guake. The height
@ -211,12 +211,12 @@ class RectCalculator():
horizontal alignment is given by window_alignment.
"""
# fetch settings
height_percents = settings.general.get_int('window-height')
width_percents = settings.general.get_int('window-width')
halignment = settings.general.get_int('window-halignment')
valignment = settings.general.get_int('window-valignment')
vdisplacement = settings.general.get_int('window-vertical-displacement')
hdisplacement = settings.general.get_int('window-horizontal-displacement')
height_percents = settings.general.get_int("window-height")
width_percents = settings.general.get_int("window-width")
halignment = settings.general.get_int("window-halignment")
valignment = settings.general.get_int("window-valignment")
vdisplacement = settings.general.get_int("window-vertical-displacement")
hdisplacement = settings.general.get_int("window-horizontal-displacement")
log.debug("set_final_window_rect")
log.debug(" height_percents = %s", height_percents)
@ -287,8 +287,8 @@ class RectCalculator():
screen = window.get_screen()
# fetch settings
use_mouse = settings.general.get_boolean('mouse-display')
dest_screen = settings.general.get_int('display-n')
use_mouse = settings.general.get_boolean("mouse-display")
dest_screen = settings.general.get_int("display-n")
if use_mouse:
@ -301,8 +301,8 @@ class RectCalculator():
# default to 'primary display' option.
n_screens = screen.get_n_monitors()
if dest_screen > n_screens - 1:
settings.general.set_boolean('mouse-display', False)
settings.general.set_int('display-n', dest_screen)
settings.general.set_boolean("mouse-display", False)
settings.general.set_int("display-n", dest_screen)
dest_screen = screen.get_primary_monitor()
# Use primary display if configured

4
pyproject.toml Normal file
View File

@ -0,0 +1,4 @@
[tool.black]
line-length = 100
target-version = ['py36']
include = '\.pyi?$'