def __init__(self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
noord_cmds = []
for part in sections:
s = sections[part]
if not ('name' in s and 'command' in s):
print(f'CustomCommandsMenu: Ignoring section {s}')
continue
name = s['name']
command = s['command']
enabled = s['enabled'] and s['enabled'] or False
if 'position' in s:
self.cmd_list[int(s['position'])] = {
'enabled': enabled,
'name': name,
'command': command
}
else:
noord_cmds.append({
'enabled': enabled,
'name': name,
'command': command
})
for cmd in noord_cmds:
self.cmd_list[len(self.cmd_list)] = cmd
def __init__( self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
noord_cmds = []
for part in sections:
s = sections[part]
if not ("name" in s and "command" in s):
print("CustomCommandsMenu: Ignoring section %s" % s)
continue
name = s["name"]
command = s["command"]
enabled = s["enabled"] and s["enabled"] or False
if "position" in s:
self.cmd_list[int(s["position"])] = {'enabled' : enabled,
'name' : name,
'command' : command
}
else:
noord_cmds.append(
{'enabled' : enabled,
'name' : name,
'command' : command
}
)
for cmd in noord_cmds:
self.cmd_list[len(self.cmd_list)] = cmd
def __init__(self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
noord_cmds = []
for part in sections:
s = sections[part]
if not (s.has_key("name") and s.has_key("command")):
print "CustomCommandsMenu: Ignoring section %s" % s
continue
name = s["name"]
command = s["command"]
enabled = s["enabled"] and s["enabled"] or False
if s.has_key("position"):
self.cmd_list[int(s["position"])] = {
'enabled': enabled,
'name': name,
'command': command
}
else:
noord_cmds.append({
'enabled': enabled,
'name': name,
'command': command
})
for cmd in noord_cmds:
self.cmd_list[len(self.cmd_list)] = cmd
def __init__(self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
noord_cmds = []
for part in sections:
s = sections[part]
if not ("regexp" in s and "command" in s):
dbg("Ignoring section %s" % s)
continue
regexp = s["regexp"]
command = s["command"]
enabled = s["enabled"] and s["enabled"] or False
if "position" in s:
self.cmd_list[int(s["position"])] = {
'enabled': enabled,
'regexp': regexp,
'command': command
}
else:
noord_cmds.append({
'enabled': enabled,
'regexp': regexp,
'command': command
})
for cmd in noord_cmds:
self.cmd_list[len(self.cmd_list)] = cmd
self._load_configured_handlers()
def __init__(self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
for part in sections:
s = sections[part]
if not (s.has_key("name") and s.has_key("command")):
print "SSHMenu: Ignoring section %s" % s
continue
name = s["name"]
command = s["command"]
self.cmd_list.append({'name': name, 'command': command})
def __init__( self):
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
for part in sections:
s = sections[part]
if not (s.has_key("name") and s.has_key("command")):
print "CustomCommandsMenu: Ignoring section %s" % s
continue
name = s["name"]
command = s["command"]
enabled = s["enabled"] and s["enabled"] or False
self.cmd_list.append(
{'enabled' : enabled,
'name' : name,
'command' : command
}
)
def __init__( self):
self.cmd_list = []
self.cur_input = ''
config = Config()
sections = config.plugin_get_config(self.__class__.__name__)
if not isinstance(sections, dict):
return
for part in sections:
s = sections[part]
if not (s.has_key("ip") and s.has_key("user")):
print "SSH Configuration: Ignoring section %s" % s
continue
ip = s["ip"]
user = s["user"]
port = s["port"]
last_time = s["last_time"]
passwd = s["passwd"]
self.cmd_list.append({ 'ip' : ip, 'user' : user,
'port' : port,'last_time':last_time ,'passwd':passwd
})
class JiraUrlPlugin(plugin.URLHandler):
capabilties = ["url_handler"]
handler_name = "jira_ticket"
config = None
plugin_name = "JiraUrlPlugin"
def __init__(self):
self.config = Config()
if self.config.plugin_get_config(self.plugin_name) is None:
for key, value in CONFIG_DEFAULTS.iteritems():
self.config.plugin_set(self.plugin_name, key, value)
self.config.save()
self.match = self.config.plugin_get(self.plugin_name, "match")
self.jira_url = self.config.plugin_get(self.plugin_name, "jira_url")
def callback(self, url):
if not (self.match or self.jira_url):
return
for item in re.findall(self.match, url):
return("%s/%s" % (self.jira_url, item))
class Online_Servers(plugin.MenuItem):
capabilities = ['terminal_menu']
config_file = os.path.join(get_config_dir(), 'online_Servers')
def __init__(self):
self.config = Config()
if not isinstance(
self.config.plugin_get_config(
self.__class__.__name__), dict):
self.config.plugin_set_config(self.__class__.__name__, {})
self.config.save()
self._authorization = dict(Authorization='Bearer ' + TOKEN)
self._base_api_url = 'https://api.online.net/api/v1'
self._servers_infos_file_name = '/tmp/online_servers_infos'
def callback(self, menuitems, menu, terminal):
item = gtk.MenuItem('Serveurs online.net')
menuitems.append(item)
submenu = gtk.Menu()
item.set_submenu(submenu)
menuitem = gtk.MenuItem('Préferences')
menuitem.connect('activate', self.settings)
submenu.append(menuitem)
submenu.append(gtk.SeparatorMenuItem())
for server in self._load_servers_infos():
config = self.config.plugin_get_config(self.__class__.__name__)
if server['hostname'] in config:
port = config[server['hostname']]['port'] if config[server['hostname']]['port'] != '' else '22'
user = config[server['hostname']]['user'] + '@' if config[server['hostname']]['user'] != '' else ''
if config[server['hostname']]['iface'] == 'private':
ip = server['ippriv']
else:
ip = server['ippub']
else:
port = 22
user = ''
ip = server['ippub']
menuitem = gtk.MenuItem(server['hostname'])
menuitem.connect(
'activate', self._execute,
{'terminal' : terminal, 'command' : 'ssh -p {} {}{}'.format(
port, user, ip)})
submenu.append(menuitem)
menuitems.append(submenu)
def settings(self, widget):
dbox = gtk.Dialog(
'Configuration', None, gtk.DIALOG_MODAL,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
servers_list = gtk.ListStore(str)
def serverList(widget=None, overwrite=False):
servers_list.clear()
for server in self._load_servers_infos(overwrite=overwrite):
servers_list.append([server['hostname']])
serverList()
tree = gtk.TreeView(servers_list)
selection = tree.get_selection()
selection.set_mode(gtk.SELECTION_SINGLE)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Serveurs", renderer, text=0)
tree.append_column(column)
button_box = gtk.VBox()
button_edit = gtk.Button('Modifier', stock=gtk.STOCK_EDIT)
button_edit.set_sensitive(False)
button_edit.connect('clicked', self._edit, tree)
selection.connect("changed", self._on_selection_changed, button_edit)
button_refresh = gtk.Button('Rafraichir')
button_refresh.connect('clicked', serverList, True)
HBox = gtk.HBox()
HBox.pack_start(tree)
button_box.pack_start(button_edit, False, False)
button_box.pack_start(button_refresh, False, False)
HBox.pack_start(button_box)
dbox.vbox.pack_start(HBox)
dbox.show_all()
if dbox.run() == gtk.RESPONSE_REJECT:
dbox.destroy()
return
def _on_selection_changed(self, selection, data=None):
data.set_sensitive(True)
return
def _edit(self, button, treeview):
selection = treeview.get_selection()
(store, iter) = selection.get_selected()
selected_value = store.get_value(iter, 0)
config = self.config.plugin_get_config(
self.__class__.__name__)
in_config = False if selected_value not in config else True
dialog = gtk.Dialog(
'Paramètres liés au serveur', None, gtk.DIALOG_MODAL,
(
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT
)
)
table = gtk.Table(1, 3)
label = gtk.Label('Interface:')
table.attach(label, 0, 1, 0, 1)
r1 = gtk.RadioButton(None, label='Privée')
r2 = gtk.RadioButton(r1, label='Publique')
if in_config:
if config[selected_value]['iface'] == 'private':
r1.set_active(1)
else:
r2.set_active(1)
else:
r2.set_active(1)
table.attach(r1, 1, 2, 0, 1)
table.attach(r2, 2, 3, 0, 1)
dialog.vbox.pack_start(table)
table = gtk.Table(1, 2)
label = gtk.Label('Utilisateur:')
table.attach(label, 0, 1, 1, 2)
user = gtk.Entry()
if in_config:
user.set_text(config[selected_value]['user'])
else:
user.set_text('')
table.attach(user, 1, 2, 1, 2)
label = gtk.Label('Port:')
table.attach(label, 0, 1, 2, 3)
port = gtk.Entry()
if in_config:
port.set_text(config[selected_value]['port'])
else:
port.set_text('')
table.attach(port, 1, 2, 2, 3)
dialog.vbox.pack_start(table)
dialog.show_all()
data = dict()
run = dialog.run()
if run == gtk.RESPONSE_REJECT:
dialog.destroy()
if run == gtk.RESPONSE_ACCEPT:
if r1.get_active():
data['iface'] = 'private'
else:
data['iface'] = 'public'
data['user'] = user.get_text()
data['port'] = port.get_text()
if in_config:
self.config.plugin_set_config(
self.__class__.__name__, {})
self.config.save()
config[selected_value] = data
else:
config.update({selected_value: data})
self.config.plugin_set_config(
self.__class__.__name__, config)
self.config.save()
dialog.destroy()
def _execute(self, widget, data):
data['terminal'].vte.feed_child(data['command'] + '\n')
@property
def _servers_list(self):
url = self._base_api_url + '/server'
servers = requests.get(
url, headers=self._authorization)
servers = [server.strip(url) for server in loads(servers.text)]
return servers
@property
def _servers_infos(self):
servers = list()
servers_list = self._servers_list
for i, server in enumerate(servers_list):
request = requests.get(
self._base_api_url + '/server/' + server,
headers=self._authorization)
servers.append(loads(request.text))
for i, server in enumerate(list(servers)):
servers[i] = dict(
hostname=server['hostname'], ippub=server['network']['ip'][0] if server['network']['ip'] != [] else '',
ippriv=server['network']['private'][0] if server['network']['private'] != [] else '')
return servers
def _save_servers_infos(self):
infos = self._servers_infos
pickle.dump(infos, open(self._servers_infos_file_name, 'wb+'))
return infos
def _load_servers_infos(self, overwrite=False):
if os.path.isfile(self._servers_infos_file_name) and not overwrite:
servers = pickle.load(open(self._servers_infos_file_name, 'rb'))
else:
servers = self._save_servers_infos()
return servers
class Colorize(plugin.MenuItem):
""" Add custom command to the terminal menu"""
capabilities = ['terminal_menu']
config = None
color_set = None
ratio = 0.7
bg_ratio = 0.09
presets = {
'color0': {
'name': ' blue',
'title_transmit_bg_color': '#0076C9'
},
'color1': {
'name': 'purple',
'title_transmit_bg_color': '#B20DAC'
},
'color2': {
'name': 'yellow',
'title_transmit_bg_color': '#EAF12A'
},
'color3': {
'name': 'green',
'title_transmit_bg_color': '#50B20D'
},
'color4': {
'name': 'cyan',
'title_transmit_bg_color': '#2DF2C1'
}
}
def __init__(self):
plugin.MenuItem.__init__(self)
self.config = Config()
colorize_config = self.config.plugin_get_config(
self.__class__.__name__)
if not colorize_config:
colorize_config = self.presets
self.color_set = []
counter = 0
if colorize_config:
while colorize_config.get('color' + str(counter)):
self.color_set.append(
colorize_config.get('color' + str(counter)))
counter += 1
dbg(self.color_set)
def callback(self, menuitems, menu, terminal):
""" Add save menu item to the menu"""
vte_terminal = terminal.get_vte()
if self.is_terminal_default_bg(terminal):
change_bgcolor_item = Gtk.MenuItem.new_with_mnemonic(
_('Colorize background'))
change_bgcolor_item.connect("activate",
self.colorize_terminal_bg_color,
terminal)
change_bgcolor_item.set_tooltip_text(
"Change background color of this terminal")
else:
change_bgcolor_item = Gtk.MenuItem.new_with_mnemonic(
_('Restore background'))
change_bgcolor_item.connect("activate",
self.reset_terminal_bg_color, terminal)
change_bgcolor_item.set_tooltip_text(
"Change background color of this terminal back")
change_bgcolor_item.set_has_tooltip(True)
menuitems.append(change_bgcolor_item)
change_color_item = Gtk.MenuItem.new_with_mnemonic(_('Choose color'))
change_color_item.connect("activate", self.change_color, terminal)
change_color_item.set_has_tooltip(True)
change_color_item.set_tooltip_text(
"Change titlebar color of this terminal")
menuitems.append(change_color_item)
# sub menu
pick_color_menu = Gtk.Menu.new()
counter = 1
for color in self.color_set:
if color.get('name'):
suffix = color['name']
else:
suffix = str(counter)
color_item = Gtk.MenuItem.new_with_mnemonic(
_('Color') + ' ' + suffix)
color_item.connect("activate", self.pick_color, terminal,
counter - 1)
color_item.set_has_tooltip(True)
color_item.set_tooltip_text("Set this color for current terminal")
accel_group = Gtk.AccelGroup.new()
color_item.add_accelerator(
"activate", accel_group, ord(str(counter)),
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE)
pick_color_menu.append(color_item)
counter += 1
item = Gtk.MenuItem.new_with_mnemonic(_('Pick color'))
item.set_submenu(pick_color_menu)
menuitems.append(item)
def is_terminal_default_bg(self, terminal):
bg_color = Gdk.RGBA()
bg_color.parse(terminal.config['background_color'])
return terminal.bgcolor.equal(bg_color)
def get_terminal_container(self, terminal, container=None):
terminator = Terminator()
if not container:
for window in terminator.windows:
owner = self.get_terminal_container(terminal, window)
if owner:
return owner
else:
for child in container.get_children():
if isinstance(child, Terminal) and child == terminal:
return container
if isinstance(child, Container):
owner = self.get_terminal_container(terminal, child)
if owner:
return owner
def register_signals(self, container, terminal):
container.signals.append({
'name': 'pick-first-color',
'flags': GObject.SignalFlags.RUN_LAST,
'return_type': GObject.GType.NONE,
'param_types': None
})
# container.signals.append({
# 'name': 'split-vert-clone',
# 'flags': gobject.SIGNAL_RUN_LAST,
# 'return_type': gobject.TYPE_NONE,
# 'param_types': None
# })
container.register_signals(terminal)
container.connect_child(terminal, 'pick-first-color',
self.pick_first_color)
# container.connect_child(terminal, 'split-vert-clone', self.split_vert)
def pick_first_color(self, terminal):
self.pick_color(None, terminal, 1)
def pick_color(self, _widget, terminal, index):
dbg([
'picking color', 'index', index,
self.color_set[index]['title_transmit_bg_color']
])
self.set_titlebar_color(
terminal,
Gdk.Color.parse(
self.color_set[index]['title_transmit_bg_color']).color)
def change_color(self, _widget, terminal):
""" Handle menu item callback by saving text to a file"""
color_dialog = Gtk.ColorSelectionDialog(
"Pick new terminal's titlebar color")
color_sel = color_dialog.get_color_selection()
# set previous colors
previous_color = Gdk.color_parse(
terminal.config['title_transmit_bg_color'])
color_sel.set_previous_color(previous_color)
color_sel.set_current_color(previous_color)
color_sel.set_has_palette(True)
response = color_dialog.run()
if response == Gtk.ResponseType.OK:
self.set_titlebar_color(terminal, color_sel.get_current_color())
color_dialog.destroy()
def get_inactive_color(self, transmit_color):
return Gdk.Color(transmit_color.red * self.ratio,
transmit_color.green * self.ratio,
transmit_color.blue * self.ratio)
def get_font_color(self, bg_color):
lightness = (((bg_color.red * 299) + (bg_color.green * 587) +
(bg_color.blue * 114)) / 1000)
new_fg_color = Gdk.Color(0, 0, 0)
if lightness < 0.5:
new_fg_color = Gdk.Color(65535, 65535, 65535)
return new_fg_color
def set_titlebar_color(self, terminal, color):
dbg(['setting titlebar color', color])
new_transmit_bg_color = color
new_inactive_bg_color = self.get_inactive_color(new_transmit_bg_color)
new_transmit_fg_color = self.get_font_color(new_transmit_bg_color)
new_inactive_fg_color = self.get_font_color(new_inactive_bg_color)
new_color_config = {
'title_transmit_bg_color': new_transmit_bg_color.to_string(),
'title_inactive_bg_color': new_inactive_bg_color.to_string(),
'title_transmit_fg_color': new_transmit_fg_color.to_string(),
'title_inactive_fg_color': new_inactive_fg_color.to_string()
}
new_config = ColorizeConfig(terminal.titlebar.config, new_color_config)
terminal.titlebar.config = new_config
if not self.is_terminal_default_bg(terminal):
self.colorize_terminal_bg_color(None, terminal)
def colorize_terminal_bg_color(self, _widget, terminal):
bg_color = Gdk.RGBA()
bg_color.parse(terminal.titlebar.config['title_transmit_bg_color'])
bg_color.red *= self.bg_ratio
bg_color.green *= self.bg_ratio
bg_color.blue *= self.bg_ratio
terminal.bgcolor = bg_color
def reset_terminal_bg_color(self, _widget, terminal):
bg_color = Gdk.RGBA()
bg_color.parse(terminal.config['background_color'])
terminal.bgcolor = bg_color
class Colorize(plugin.MenuItem):
""" Add custom command to the terminal menu"""
capabilities = ['terminal_menu']
config = None
color_set = None
ratio = 0.7
presets = {
'color0' : {
'name' : ' blue',
'title_transmit_bg_color': '#0076C9'
},
'color1' : {
'name' : 'purple',
'title_transmit_bg_color': '#B20DAC'
},
'color2' : {
'name' : 'yellow',
'title_transmit_bg_color': '#EAF12A'
},
'color3' : {
'name' : 'green',
'title_transmit_bg_color': '#50B20D'
},
'color4' : {
'name' : 'cyan',
'title_transmit_bg_color': '#2DF2C1'
}
}
def __init__(self):
plugin.MenuItem.__init__(self)
self.config = Config()
colorize_config = self.config.plugin_get_config(self.__class__.__name__)
if not colorize_config:
colorize_config = self.presets
self.color_set = []
counter = 0
if colorize_config:
while colorize_config.get('color' + str(counter)):
self.color_set.append(colorize_config.get('color' + str(counter)))
counter += 1
print self.color_set
def callback(self, menuitems, menu, terminal):
""" Add save menu item to log 'content'the menu"""
vte_terminal = terminal.get_vte()
change_color_item = gtk.MenuItem(_('Change color'))
change_color_item.connect("activate", self.change_color, terminal)
change_color_item.set_has_tooltip(True)
change_color_item.set_tooltip_text("Change titlebar color of this terminal")
menuitems.append(change_color_item)
# sub menu
pick_color_menu = gtk.Menu()
counter = 1
for color in self.color_set:
if color.get('name'):
suffix = color['name']
else:
suffix = str(counter)
color_item = gtk.MenuItem(_('Color') + ' ' + suffix)
color_item.connect("activate", self.pick_color, terminal, counter - 1)
color_item.set_has_tooltip(True)
color_item.set_tooltip_text("Set this color for current terminal")
accel_group = gtk.AccelGroup()
color_item.add_accelerator("activate", accel_group,
ord(str(counter)), gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK, gtk.ACCEL_VISIBLE)
pick_color_menu.append(color_item)
counter += 1
item = gtk.MenuItem(_('Pick color'))
item.set_submenu(pick_color_menu)
menuitems.append(item)
def get_terminal_container(self, terminal, container=None):
terminator = Terminator()
if not container:
for window in terminator.windows:
owner = self.get_terminal_container(terminal, window)
if owner:
return owner
else:
for child in container.get_children():
if isinstance(child, Terminal) and child == terminal:
return container
if isinstance(child, Container):
owner = self.get_terminal_container(terminal, child)
if owner:
return owner
def register_signals(self, container, terminal):
container.signals.append({
'name': 'pick-first-color',
'flags': gobject.SIGNAL_RUN_LAST,
'return_type': gobject.TYPE_NONE,
'param_types': None
})
# container.signals.append({
# 'name': 'split-vert-clone',
# 'flags': gobject.SIGNAL_RUN_LAST,
# 'return_type': gobject.TYPE_NONE,
# 'param_types': None
# })
container.register_signals(terminal)
container.connect_child(terminal, 'pick-first-color', self.pick_first_color)
# container.connect_child(terminal, 'split-vert-clone', self.split_vert)
def pick_first_color(self, terminal):
self.pick_color(None, terminal, 1)
def pick_color(self, _widget, terminal, index):
print 'index', index
self.set_titlebar_color(terminal, gtk.gdk.Color(self.color_set[index]['title_transmit_bg_color']))
def change_color(self, _widget, Terminal):
""" Handle menu item callback by saving text to a file"""
color_dialog = gtk.ColorSelectionDialog("Pick new terminal's titlebar color")
color_sel = color_dialog.colorsel
# set previous colors
previous_color = gtk.gdk.color_parse(Terminal.config['title_transmit_bg_color'])
color_sel.set_previous_color(previous_color)
color_sel.set_current_color(previous_color)
color_sel.set_has_palette(True)
response = color_dialog.run()
if response == gtk.RESPONSE_OK:
self.set_titlebar_color(Terminal, color_sel.get_current_color())
color_dialog.destroy()
def get_inactive_color(self, transmit_color):
return gtk.gdk.Color(transmit_color.red_float * self.ratio,
transmit_color.green_float * self.ratio,
transmit_color.blue_float * self.ratio)
def get_font_color(self, bg_color):
lightness = (((bg_color.red_float * 299) +
(bg_color.green_float * 587) +
(bg_color.blue_float * 114)) /1000)
new_fg_color = gtk.gdk.Color(0, 0, 0)
if lightness < 0.5:
new_fg_color = gtk.gdk.Color(65535, 65535, 65535)
return new_fg_color
def set_titlebar_color(self, Terminal, color):
new_transmit_bg_color = color
new_inactive_bg_color = self.get_inactive_color(new_transmit_bg_color)
new_transmit_fg_color = self.get_font_color(new_transmit_bg_color)
new_inactive_fg_color = self.get_font_color(new_inactive_bg_color)
new_color_config = {
'title_transmit_bg_color': new_transmit_bg_color.to_string(),
'title_inactive_bg_color': new_inactive_bg_color.to_string(),
'title_transmit_fg_color': new_transmit_fg_color.to_string(),
'title_inactive_fg_color': new_inactive_fg_color.to_string()
}
new_config = ColorizeConfig(Terminal.titlebar.config, new_color_config)
Terminal.titlebar.config = new_config
