def __init__(self):
Gtk.Box.__init__(self)
self.profile_settings = self.get_profile_settings()
self.profile_settings.connect("changed",
self.on_profile_settings_changed)
self.system_settings = Gio.Settings.new("org.gnome.desktop.interface")
self.system_settings.connect("changed::monospace-font-name",
self.font_changed)
self._vte = Vte.Terminal()
self.reconfigure_vte()
self._vte.set_size(self._vte.get_column_count(), 5)
self._vte.set_size_request(200, 50)
self._vte.show()
self.pack_start(self._vte, True, True, 0)
scrollbar = Gtk.Scrollbar.new(Gtk.Orientation.VERTICAL,
self._vte.get_vadjustment())
scrollbar.show()
self.pack_start(scrollbar, False, False, 0)
# we need to reconf colors if the style changes
#FIXME: why?
#self._vte.connect("style-update", lambda term, oldstyle: self.reconfigure_vte())
self._vte.connect("key-press-event", self.on_vte_key_press)
self._vte.connect("button-press-event", self.on_vte_button_press)
self._vte.connect("popup-menu", self.on_vte_popup_menu)
self._vte.connect("child-exited", self.on_child_exited)
#: FIXME: TypeError: on_child_exited() takes exactly 1 argument (2 given)
#: self._vte.connect("child-exited", lambda (self2, term2): self2.on_child_exited() )
#: print "Connecting child-exited to _vte, with :"
#: print "lambda self2,term2: self2.on_child_exited()"
self._accel_base = '<gedit>/plugins/terminal'
self._accels = {
'copy-clipboard': [
Gdk.KEY_C,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
self.copy_clipboard
],
'paste-clipboard': [
Gdk.KEY_V,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
self.paste_clipboard
]
}
for name in self._accels:
path = self._accel_base + '/' + name
accel = Gtk.AccelMap.lookup_entry(path)
if not accel[0]:
Gtk.AccelMap.add_entry(path, self._accels[name][0],
self._accels[name][1])
self._vte.fork_command_full(Vte.PtyFlags.DEFAULT, None,
[Vte.get_user_shell()], None,
GLib.SpawnFlags.SEARCH_PATH, None, None)
def vte_runtime_version():
import gi
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()
)
def getEraseBinding(self, str):
if str == "auto":
return Vte.EraseBinding(0)
if str == "ascii-backspace":
return Vte.EraseBinding(1)
if str == "ascii-delete":
return Vte.EraseBinding(2)
if str == "delete-sequence":
return Vte.EraseBinding(3)
if str == "tty":
return Vte.EraseBinding(4)
def vte_version():
import gi
gi.require_version('Vte', '2.91')
from gi.repository import Vte
s = "{}.{}.{}".format(
Vte.MAJOR_VERSION,
Vte.MINOR_VERSION,
Vte.MICRO_VERSION,
)
if (Vte.MAJOR_VERSION, Vte.MINOR_VERSION) >= (0, 40):
s += " (runtime: {}.{}.{})".format(
Vte.get_major_version(), Vte.get_minor_version(), Vte.get_micro_version()
)
return s
def __reset(self, archivo=None):
"""
Reseteo de la Terminal.
"""
if archivo:
interprete = "/bin/bash"
try:
import mimetypes
if "python" in mimetypes.guess_type(archivo)[0]:
interprete = "python"
if os.path.exists(os.path.join("/bin", interprete)):
interprete = os.path.join("/bin", interprete)
elif os.path.exists(os.path.join("/usr/bin", interprete)):
interprete = os.path.join("/usr/bin", interprete)
elif os.path.exists(os.path.join("/sbin", interprete)):
interprete = os.path.join("/sbin", interprete)
elif os.path.exists(os.path.join("/usr/local",
interprete)):
interprete = os.path.join("/usr/local", interprete)
except:
### Cuando se intenta ejecutar un archivo no ejecutable.
return self.set_interprete()
path = os.path.dirname(archivo)
pty_flags = Vte.PtyFlags(0)
self.fork_command_full(pty_flags, path, (interprete, archivo), "",
0, None, None)
else:
interprete = self.interprete
path = self.path
pty_flags = Vte.PtyFlags(0)
self.fork_command_full(pty_flags, path, (interprete, ), "", 0,
None, None)
self.child_focus(True)
def launchterm(self, widget):
windowvte = Gtk.Window()
v = Vte.Terminal()
windowvte.add(v)
termdir = execdir + "/programs"
try:
v.spawn_sync(
Vte.PtyFlags.DEFAULT,
termdir,
["/bin/bash"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
except:
v.fork_command_full(
Vte.PtyFlags.DEFAULT,
termdir,
["/bin/sh"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
windowvte.connect('delete-event',
lambda window, event: windowvte.hide() or True)
windowvte.show_all()
def __init__(self):
Vte.Terminal.__init__(self)
self.set_background_image(None)
self.set_background_transparent(False)
self.set_size(self.get_column_count(), 5)
self.set_size_request(200, 50)
tl = Gtk.TargetList.new([])
tl.add_uri_targets(self.TARGET_URI_LIST)
self.drag_dest_set(Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
[], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
self.drag_dest_set_target_list(tl)
self.profile_settings = self.get_profile_settings()
self.profile_settings.connect("changed",
self.on_profile_settings_changed)
self.system_settings = Gio.Settings.new("org.gnome.desktop.interface")
self.system_settings.connect("changed::monospace-font-name",
self.font_changed)
self.reconfigure_vte()
self.fork_command_full(Vte.PtyFlags.DEFAULT, None,
[Vte.get_user_shell()], None,
GLib.SpawnFlags.SEARCH_PATH, None, None)
def create_certificate(self,event):
self.terminal3 = Vte.Terminal()
self.terminal3.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ[HOME],
SHELLS,
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,)
self.generate_ssh_cert = "ssh-keygen\n"
self.cert_name = self.home + "/.ssh/" + self.cert_name_entry.get_text() + "\n"
self.cert_name_none = "\n"
self.passphrase = self.cert_pass_entry.get_text()+ "\n"
self.terminal3.feed_child(self.generate_ssh_cert.encode("utf-8"))
time.sleep(0.5)
if self.cert_name_entry.get_text() == '':
if 'id_rsa.pub\n' in self.certificates:
self.cert_yes_no()
time.sleep(0.5)
else:
self.terminal3.feed_child(self.cert_name_none.encode("utf-8"))
time.sleep(0.5)
else:
self.terminal3.feed_child(self.cert_name.encode("utf-8"))
time.sleep(0.5)
self.terminal3.feed_child(self.passphrase.encode("utf-8"))
time.sleep(0.5)
self.terminal3.feed_child(self.passphrase.encode("utf-8"))
self.cert_name_win.hide()
def __init__(self,parent):
self.parent = parent
self.glade_file = parent.props.UiPath + "main/terminal.glade"
self.builder = Gtk.Builder()
self.builder.add_from_file(self.glade_file)
self.main_box = self.builder.get_object("main_box") # makes the main window
self.builder.connect_signals(self) # connects rest of the signals from glade file to their handlers
self.terminal = Vte.Terminal()
self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, os.getcwd(),
["/bin/bash"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None,)
self.terminal.set_size(100,10)
self.terminal_box = self.builder.get_object("terminal_box")
self.terminal_box.pack_start(self.terminal, True, True, 0)
self.terminal_box = self.builder.get_object("scrollbar_box")
self.scrollbar = Gtk.Scrollbar(orientation=Gtk.Orientation.VERTICAL,adjustment = Gtk.Scrollable.get_vadjustment(self.terminal))
self.terminal_box.pack_start(self.scrollbar, True, True, 0)
self.terminal_box.show()
self.startup_cmds=["PS1='sudoSU@$PWD $: '\n","clear\n"]
for i in self.startup_cmds:
self.run_command(i)
self.menu = self.builder.get_object("menu")
self.main_box.connect_object("event", self.button_press, self.menu)
def do_activate(self):
if not self.window:
# load glade layout
builder = Gtk.Builder()
builder.add_from_file("./window.glade")
# attach window to application
self.window = builder.get_object("window")
self.add_window(self.window)
# set signal handler
builder.connect_signals(AppSignalHandlers())
# create terminal window
self.term = Vte.Terminal()
self.term.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ['HOME'],
["/bin/bash"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
# add terminal to box for layout
self.box = builder.get_object("Box")
self.box.pack_end(self.term, False, False, 5)
# show
self.window.show_all()
def install(self, button):
foreign_packages = []
iter = self.model.get_iter_first()
while (iter != None):
if (self.model.get_value(iter, PKG_CHECKED)):
foreign_packages.append(self.model.get_value(iter, PKG_ID))
iter = self.model.iter_next(iter)
if self.downgrade_mode:
self.builder.get_object("stack1").set_visible_child_name("vte")
terminal = Vte.Terminal()
terminal.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ['HOME'],
["/bin/dash"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
cmd = "apt-get install %s\n" % " ".join(foreign_packages)
# try/catch VTE call due to regressions and obscure documentation
try:
# Mint 19.x
terminal.feed_child(cmd, -1)
except:
# LMDE 4
terminal.feed_child(cmd.encode("UTF-8"))
terminal.show()
self.builder.get_object("box_vte").add(terminal)
self.builder.get_object("box_vte").show_all()
else:
self.apt.set_finished_callback(self.exit)
self.apt.remove_packages(foreign_packages)
def __init__(self, db_name, parent):
Gtk.Builder.__init__(self)
self.add_from_file(UI_FILE)
self.connect_signals(self)
self.parent = parent
self.db_name = db_name
self.bin_path = get_postgres_bin_path()
self.terminal = Vte.Terminal()
self.terminal.set_scroll_on_output(True)
self.terminal.set_scrollback_lines(-1)
self.get_object('restore_scrolled_window').add(self.terminal)
self.dialog = self.get_object('restore_dialog')
sqlite = get_apsw_connection()
cursor = sqlite.cursor()
cursor.execute("SELECT value FROM settings "
"WHERE setting = 'backup_path' AND setting != ''")
for row in cursor.fetchall():
backup_path = row[0]
self.dialog.set_current_folder(backup_path)
sqlite.close()
result = self.dialog.run()
if result == Gtk.ResponseType.APPLY:
self.dialog.hide()
self.restore_database()
self.dialog.destroy()
def __init__(self, handle):
super(VteActivity, self).__init__(handle)
toolbox = ToolbarBox()
self.set_toolbar_box(toolbox)
toolbox.show()
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
# creates vte widget
self._vte = Vte.Terminal()
self._vte.set_size(30, 5)
self._vte.set_size_request(200, 300)
font = 'Monospace 10'
self._vte.set_font(Pango.FontDescription(font))
self._vte.connect('selection-changed', self._on_selection_changed_cb)
self._vte.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
self._vte.connect('drag_data_received', self._on_drop_cb)
# ...and its scrollbar
vtebox = Gtk.HBox()
vtebox.pack_start(self._vte, True, True, 0)
vtesb = Gtk.VScrollbar()
vtesb.show()
vtebox.pack_start(vtesb, False, False, 0)
self.set_canvas(vtebox)
self.show_all()
# now start subprocess.
self._vte.connect("child-exited", self.on_child_exit)
self._vte.grab_focus()
bundle_path = activity.get_bundle_path()
# the 'sleep 1' works around a bug with the command dying before
# the vte widget manages to snarf the last bits of its output
self._pid = self._vte.spawn_sync(
Vte.PtyFlags.DEFAULT, bundle_path,
['/bin/sh', '-c',
'python %s/show.py; sleep 1' % bundle_path],
["PYTHONPATH=%s/library" % bundle_path],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
def install(self, button):
foreign_packages = []
iter = self.model.get_iter_first()
while (iter != None):
if (self.model.get_value(iter, PKG_CHECKED)):
foreign_packages.append(self.model.get_value(iter, PKG_ID))
iter = self.model.iter_next(iter)
if self.downgrade_mode:
self.builder.get_object("stack1").set_visible_child_name("vte")
terminal = Vte.Terminal()
terminal.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ['HOME'],
["/bin/dash"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
terminal.feed_child(
"apt-get install %s\n" % " ".join(foreign_packages), -1)
terminal.show()
self.builder.get_object("box_vte").add(terminal)
self.builder.get_object("box_vte").show_all()
else:
self.apt.set_finished_callback(self.exit)
self.apt.remove_packages(foreign_packages)
def add_editor_window(self):
self.terminal = Vte.Terminal()
self.terminal.set_color_background(Gdk.RGBA(0, 43 / 256, 54 / 256, 1))
if isfile(SOCKET):
remove(SOCKET)
self.terminal.spawn_sync(
Vte.PtyFlags.DEFAULT,
environ['HOME'],
[
"/usr/bin/nvim", "-u",
join(INSTALLDIR, "init.vim"), "--listen", SOCKET
],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
def do_exit(*args, **kwargs):
self.quit()
self.terminal.connect("child-exited", do_exit)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
scroller = Gtk.ScrolledWindow()
scroller.set_hexpand(True)
scroller.set_vexpand(True)
scroller.add(self.terminal)
box.pack_start(scroller, False, True, 2)
self.pane.pack1(box)
def __init__(self):
super(Gtk.HBox, self).__init__()
ConfigManager.add_callback(self.update_ui)
self.vte = Vte.Terminal()
self.pack_start(self.vte, True, True, 0)
if ConfigManager.get_conf('show-scrollbar'):
self.vscroll = Gtk.VScrollbar()
self.vscroll.set_adjustment(self.vte.get_vadjustment())
self.pack_end(self.vscroll, False, True, 0)
dir_conf = ConfigManager.get_conf('dir')
if dir_conf == '$home$':
run_dir = os.environ['HOME']
elif dir_conf == '$pwd$':
run_dir = os.getcwd()
else:
run_dir = dir_conf
self.vte.fork_command_full(Vte.PtyFlags.DEFAULT, run_dir,
ConfigManager.get_conf('shell').split(), [],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None,
None)
self.vte.connect('button-release-event', self.on_button_release)
self.update_ui()
def __init__(self, automatic=False):
Gtk.Builder.__init__(self)
self.add_from_file(UI_FILE)
self.connect_signals(self)
self.bin_path = get_postgres_bin_path()
self.terminal = Vte.Terminal()
self.terminal.set_scroll_on_output(True)
self.terminal.set_scrollback_lines(-1)
self.automatic = automatic
self.get_object('backup_scrolled_window').add(self.terminal)
day = time.strftime("%Y-%m-%d-%H:%M")
name = DB_NAME + "_" + day + ".pbk"
dialog = self.get_object('backup_dialog')
dialog.set_current_name(name)
sqlite = get_apsw_connection()
cursor = sqlite.cursor()
cursor.execute("SELECT value FROM settings "
"WHERE setting = 'backup_path'")
for row in cursor.fetchall():
backup_path = row[0]
dialog.set_current_folder(backup_path)
sqlite.close()
if automatic and os.path.exists(backup_path):
full_filepath = backup_path + "/" + name
self.get_object('status_label').set_label(full_filepath)
self.backup_database(full_filepath)
else:
result = dialog.run()
if result == Gtk.ResponseType.APPLY:
filename = dialog.get_filename()
dialog.hide()
self.backup_database(filename)
dialog.destroy()
def __init__(self):
Vte.Terminal.__init__(self)
self.set_size(self.get_column_count(), 7)
self.set_size_request(200, 130)
tl = Gtk.TargetList.new([])
tl.add_uri_targets(self.TARGET_URI_LIST)
self.drag_dest_set(Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
[], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
self.drag_dest_set_target_list(tl)
self.profile_settings = self.get_profile_settings()
self.profile_settings.connect("changed",
self.on_profile_settings_changed)
self.system_settings = Gio.Settings.new("org.gnome.desktop.interface")
self.system_settings.connect("changed::monospace-font-name",
self.font_changed)
self.reconfigure_vte()
result, pid = self.spawn_sync(Vte.PtyFlags.DEFAULT, None,
[Vte.get_user_shell()], None,
GLib.SpawnFlags.SEARCH_PATH, None, None,
None)
self.child_pid = pid
self.match_add_regex(self.HIGHLIGHT_VREGEX, 0)
self.connect("button-press-event", self.on_button_press)
self.connect('text-scrolled', self.on_text_scroll)
def __init__(self):
Gtk.HBox.__init__(self, homogeneous=False, spacing=0)
self.command = "python manage.py runserver"
self.cwd = None
self._pid = None
self._vte = Vte.Terminal()
self._vte.set_size(self._vte.get_column_count(), 5)
self._vte.set_size_request(200, 50)
self._vte.set_font_from_string("monospace 10")
self._vte.connect("child-exited", self.on_child_exited)
self.pack_start(self._vte, True, True, 0)
scrollbar = Gtk.Scrollbar.new(Gtk.Orientation.VERTICAL,
self._vte.get_vadjustment())
self.pack_start(scrollbar, False, False, 0)
self._button = Gtk.Button()
self._button.connect("clicked", self.on_button_clicked)
box = Gtk.VButtonBox()
box.set_border_width(5)
box.set_layout(Gtk.ButtonBoxStyle.START)
box.add(self._button)
self.pack_start(box, False, False, 0)
self._start_icon = Gtk.Image.new_from_stock(Gtk.STOCK_EXECUTE,
Gtk.IconSize.BUTTON)
self._stop_icon = Gtk.Image.new_from_stock(Gtk.STOCK_STOP,
Gtk.IconSize.BUTTON)
self.refresh_ui()
self.show_all()
def __init__(self):
Gtk.Window.__init__(self, title="ArFedora Terminal")
self.resize(800, 400)
scrolledwindow = Gtk.ScrolledWindow()
self.add(scrolledwindow)
self.terminal = Vte.Terminal()
self.terminal.connect("eof", self.quit_)
self.terminal.set_color_background(
Gdk.RGBA(red=0.180392,
green=0.203922,
blue=0.211765,
alpha=1.000000))
self.terminal.set_color_foreground(
Gdk.RGBA(red=0.988235,
green=0.913725,
blue=0.309804,
alpha=1.000000))
self.terminal.set_allow_hyperlink(True)
vadjustment = self.terminal.get_vadjustment()
scrolledwindow.set_vadjustment(vadjustment)
user_info = pwd.getpwuid(os.geteuid())
self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, user_info.pw_dir,
[user_info.pw_shell], [],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
self.terminal.connect("button-release-event", self.on_button_event)
self.menu = Gtk.Menu()
self.menu.set_screen(Gdk.Screen().get_default())
copytextmenuitem = Gtk.MenuItem("Copy")
pastetextmenuitem = Gtk.MenuItem("Paste")
fontsizemenuitem = Gtk.MenuItem("Font")
cursorshapemenuitem = Gtk.MenuItem("Cursor Shape")
cursorcolormenuitem = Gtk.MenuItem("Cursor Color")
backgroundmenuitem = Gtk.MenuItem("Backgound Color")
foregroundmenuitem = Gtk.MenuItem("Foreground Color")
copytextmenuitem.connect("activate", self.copy_text)
pastetextmenuitem.connect("activate", self.paste_text)
fontsizemenuitem.connect("activate", self.font_change)
cursorshapemenuitem.connect("activate", self.cursor_shape)
cursorcolormenuitem.connect("activate",
self.on_cursor_menuitem_activated)
backgroundmenuitem.connect("activate",
self.on_background_menuitem_activated)
foregroundmenuitem.connect("activate",
self.on_foreground_menuitem_activated)
self.menu.append(copytextmenuitem)
self.menu.append(pastetextmenuitem)
self.menu.append(fontsizemenuitem)
self.menu.append(cursorshapemenuitem)
self.menu.append(cursorcolormenuitem)
self.menu.append(backgroundmenuitem)
self.menu.append(foregroundmenuitem)
scrolledwindow.add(self.terminal)
def __init__(self,message, cmd):
cmd = "{} && exit 0 || exit 1\n".format(cmd)
self.window = Gtk.Window(title=message)
self.window.set_border_width(10)
self.window.connect("delete-event", Gtk.main_quit)
self.window.set_icon_name("package")
self.window.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
self.window.set_default_size(400, -1)
self.box = Gtk.VBox(spacing=2) #conteneur principal
self.window.add(self.box)
self.titlelabel = Gtk.Label()
self.titlelabel.set_text("{}".format(message))
self.box.pack_start(self.titlelabel, True, True, 2)
# barre de progression
self.progressbar = Gtk.ProgressBar()
GObject.timeout_add(250,self.pulsate)
self.box.pack_start(self.progressbar, True, True, 2)
# le VTE
self.terminal = Vte.Terminal()
self.terminal.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ['HOME'],
["/bin/bash" ],
["PS1=\n"],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
None,
)
self.terminal.connect("child-exited", self.end)
self.terminal.set_size_request(500,250)
#terminal.connect("child-exited", Gtk.main_quit)
self.terminal.set_size_request(500,250)
buttonbox = Gtk.HBox()
copybtn = Gtk.Button(stock = Gtk.STOCK_COPY)
copybtn.connect("key_press_event", lambda x,y:self.copyterminal())
copybtn.connect("button_release_event", lambda x,y:self.copyterminal())
buttonbox.pack_start(copybtn, True, True, 5)
hiddenbox = Gtk.VBox()
hiddenbox.pack_start(self.terminal,True, True, 0)
hiddenbox.pack_start(buttonbox,True, False, 5)
expander = Gtk.Expander(label="Details")
expander.set_resize_toplevel(True)
expander.add(hiddenbox)
self.box.pack_start(expander, True, True, 2)
self.window.show_all()
self.terminal.feed_child(cmd, len(cmd))
self.terminal.set_property("input-enabled", False)
def init_terminal(self):
self.terminal = Vte.Terminal()
self.terminal.set_scrollback_lines(1000)
self.terminal.set_audible_bell(False)
self.terminal.connect("button-press-event", self.show_serial_rcpopup)
self.terminal.connect("commit", self.console.send_data, self.terminal)
self.terminal.show()
def reset(self, path=os.environ["HOME"], interprete="/bin/bash"):
pty_flags = Vte.PtyFlags(0)
try:
self.fork_command_full(pty_flags, path, (interprete, ), "", 0,
None, None)
except:
self.spawn_sync(pty_flags, path, (interprete, ), "", 0, None, None)
self.child_focus(True)
def init_components(self):
self.box = self.get_content_area()
self.terminal = Vte.Terminal()
self.close_button = Gtk.Button('Close')
self.close_button.set_hexpand(False)
self.close_button.set_halign(Gtk.Align.END)
self.close_button.connect('clicked', self.on_click)
self.box.set_border_width(5)
def create_term(shell=Vte.get_user_shell(), emulation="xterm", pwd=os.environ['HOME']): term = Vte.Terminal() pid = term.fork_command_full(Vte.PtyFlags.DEFAULT, pwd, [shell], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) term.set_emulation(emulation) term.watch_child(pid[1]) return term,pid
def construct_terminals(self):
"""
Construct six terminals that will be attached to the grid.
"""
terminals = {}
for key in range(6):
terminals[key] = Vte.Terminal()
return terminals
def dos_fsck(target):
_logger.error('Using VTE to dosfsck -a %s' % target)
vt = Vte.Terminal()
success_, pid = vt.fork_command_full(
Vte.PtyFlags.DEFAULT, os.environ["HOME"],
['/usr/bin/sudo', '/usr/sbin/dosfsck', '-a', target], [],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
_logger.error('VTE %s %s' % (str(success_), str(pid)))
def __init__(self):
# Create THE WINDOW
self.window1 = Gtk.Window()
self.window1.set_position(Gtk.WindowPosition.CENTER)
self.window1.set_title("Quick Terminal-GTK3")
self.window1.connect("button_press_event", self.right_click)
#Menu
self.menu = Gtk.Menu()
#Menu buttons
#Copy&Paste
self.copy_it = Gtk.MenuItem("Copy")
self.copy_it.connect("activate", self.copy)
self.paste_it = Gtk.MenuItem("Paste")
self.paste_it.connect("activate", self.paste)
self.menu.append(self.copy_it)
self.menu.append(self.paste_it)
#About Quick Terminal
self.about_ter = Gtk.MenuItem("About Quick Terminal")
self.about_ter.connect("activate", self.about1)
self.menu.append(self.about_ter)
#Terminal
self.vte = Vte.Terminal()
self.vte.connect("child-exited", Gtk.main_quit)
#Fork
self.vte.spawn_sync(
Vte.PtyFlags.DEFAULT,
os.environ['HOME'],
["/bin/bash"],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
#Make a clipboard for copy and paste
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
#Scrolled window
self.scroll = Gtk.ScrolledWindow()
self.scroll.set_min_content_height(350)
self.scroll.set_min_content_width(640)
self.scroll.add(self.vte)
#Vertical box/buttons container
self.vbox = Gtk.VBox(False)
self.vbox.pack_start(self.scroll, True, True, True)
#Show everything
self.window1.add(self.vbox)
self.window1.show_all()
#Making window resizable and enabling the close window connector
self.window1.set_resizable(True)
self.window1.connect("destroy", Gtk.main_quit)
def terminal_gui(self, current=None):
self.scrolledwindow = Gtk.ScrolledWindow()
self.terminal = Vte.Terminal()
#self.terminal.set_sensitive(False)
self.tbox.pack_start(self.scrolledwindow, True, True, 0)
self.terminal.connect("eof", self.quit_)
self.terminal.connect("current-directory-uri-changed",
self.on_current_directory_uri_changed)
self.terminal.set_cursor_shape(Vte.CursorShape(self.cursorshape[0]))
self.terminal.set_color_background(self.bg_color)
self.terminal.set_color_cursor(self.cursorcolor)
#self.terminal.set_color_foreground(self.foreground)
if self.fontsize:
self.terminal.set_font(self.fontsize[0])
self.terminal.set_allow_hyperlink(True)
vadjustment = self.terminal.get_vadjustment()
self.scrolledwindow.set_vadjustment(vadjustment)
self.user_info = pwd.getpwuid(os.geteuid())
text = self.entry.props.text
if current:
current_dir = current
else:
current_dir = self.user_info.pw_dir
if text:
t = subprocess.check_output(
"export PS1=\"{}\";echo $PS1".format(text),
shell=True).decode("utf-8")[:-1]
self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, current_dir,
["/usr/bin/bash"],
["export", "PS1={}".format(t)],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None,
None)
else:
self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, current_dir,
["/usr/bin/bash"], [],
GLib.SpawnFlags.DO_NOT_REAP_CHILD, None,
None)
self.scrolledwindow.add(self.terminal)
self.terminal.connect("button-release-event", self.on_button_event)
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
vt = Vte.Terminal()
vt.connect("child-exited", self.exit)
vt.spawn_sync(Vte.PtyFlags.DEFAULT, os.environ["HOME"], ["/bin/bash"],
[], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
if not os.path.exists(os.environ["SUGAR_ACTIVITIES_PATH"] +
"/Java.activity"):
label = Gtk.Label("Please install Java activity")
self.set_canvas(label)
label.show()
return
self.set_canvas(vt)
vt.show()
vt.feed_child("cd $SUGAR_BUNDLE_PATH\n", -1)
if platform.machine().startswith('arm'):
vt.feed_child(
"export JAVA_HOME=$SUGAR_ACTIVITIES_PATH/Java.activity/jre_arm\n",
-1)
else:
if platform.architecture()[0] == '64bit':
vt.feed_child(
"export JAVA_HOME=$SUGAR_ACTIVITIES_PATH/Java.activity/jre_64\n",
-1)
else:
vt.feed_child(
"export JAVA_HOME=$SUGAR_ACTIVITIES_PATH/Java.activity/jre_32\n",
-1)
vt.feed_child("export PATH=$JAVA_HOME/bin:$PATH\n", -1)
vt.feed_child("java -jar jclic.jar; exit\n", -1)
def init_terminal(self):
"""Initialise and add new Vte Terminal to Window"""
self.term = Vte.Terminal()
self.term.set_scrollback_lines(-1)
self.term.connect('child-exited', Gtk.main_quit)
self.term.fork_command_full(Vte.PtyFlags.DEFAULT, os.environ['HOME'], ['/usr/bin/bash'], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None)
self.add(self.term)
self.connect('delete-event', Gtk.main_quit)
def __init__(self):
Vte.Terminal.__init__(self)
self.set_size(self.get_column_count(), 5)
self.set_size_request(200, 50)
tl = Gtk.TargetList.new([])
tl.add_uri_targets(self.TARGET_URI_LIST)
self.drag_dest_set(Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
[], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY)
self.drag_dest_set_target_list(tl)
self.profile_settings = self.get_profile_settings()
self.profile_settings.connect("changed", self.on_profile_settings_changed)
self.system_settings = Gio.Settings.new("org.gnome.desktop.interface")
self.system_settings.connect("changed::monospace-font-name", self.font_changed)
self.reconfigure_vte()
self.fork_command_full(Vte.PtyFlags.DEFAULT, None, [Vte.get_user_shell()], None, GLib.SpawnFlags.SEARCH_PATH, None, None)
def do_child_exited(self):
Vte.Terminal.do_child_exited(self)
self._vte.fork_command_full(Vte.PtyFlags.DEFAULT, None, [Vte.get_user_shell()], None, GLib.SpawnFlags.SEARCH_PATH, None, None)
def terminal_or_default():
"""Enforce a default value for terminal from GSettings"""
terminalcmd = settings.get_string("terminal-shell")
if (terminalcmd == "") or (terminalcmd is None):
terminalcmd = Vte.get_user_shell()
return terminalcmd
#Specific imports for Python 2 and 3
if sys.version_info < (3, 0):
from urllib import url2pathname
from ConfigParser import RawConfigParser
else:
from urllib.request import url2pathname
from configparser import RawConfigParser
from gi.repository import GObject, Nautilus, Gtk, Gdk, Vte, GLib
DEFAULT_CONF = {
'general/def_term_height': 5, #lines
'general/def_visible': True,
'general/term_on_top': True,
'terminal/shell': Vte.get_user_shell(),
}
class Config(object):
"""Handles the configuration of Nautilus Terminal."""
def __init__(self):
"""The constructor."""
self._default = DEFAULT_CONF
self._confp = RawConfigParser()
self.read()
def read(self):
"""Read the configuration from a file."""
#Determine where is stored the configuration
def get_terminal_cmd():
"""Enforce a default value for terminal from GSettings."""
terminal_cmd = settings.get_string("terminal-shell")
if not terminal_cmd:
terminal_cmd = Vte.get_user_shell()
return terminal_cmd
