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