def __init__(self): super(Carrusel, self).__init__() self.builder = Gtk.Builder() # Cargamos el XML glade que hemos creado. self.builder.add_from_file( "/home/mrpatxi/Github/Carrusel/LaSeniaCarrusel/Glade/carrusel.glade" ) # Creamos una variable para cargar los menejadores de los eventos. self.handlers = { "on_carrusel_window_destroy": self.on_carrusel_window_destroy, "on_save_button_clicked": self.on_save_button_clicked, "on_add_button_docs_clicked": self.on_add_button_docs_clicked, "on_del_button_docs_clicked": self.on_del_button_docs_clicked, "on_icon_view_docs_item_activated": self.on_icon_view_docs_item_activated, "on_add_button_pdfs_clicked": self.on_add_button_pdfs_clicked, "on_del_button_pdfs_clicked": self.on_del_button_pdfs_clicked, "on_icon_view_pdfs_item_activated": self.on_icon_view_pdfs_item_activated, "on_add_button_photos_clicked": self.on_add_button_photos_clicked, "on_del_button_photos_clicked": self.on_del_button_photos_clicked, "on_icon_view_photos_item_activated": self.on_icon_view_photos_item_activated, "on_generate_button_clicked": self.on_generate_button_clicked, "on_label_dnd_docs_drag_data_received": self.on_label_dnd_docs_drag_data_received, "on_label_dnd_pdfs_drag_data_received": self.on_label_dnd_pdfs_drag_data_received, "on_label_dnd_photos_drag_data_received": self.on_label_dnd_photos_drag_data_received } # Conectamos los manejadores del archivo glade con las funciones que hemos declarado. self.builder.connect_signals(self.handlers) # Accedemos al objeto "Window" mediante el identifivador declarado en el XML de "Glade". self.window = self.builder.get_object("carrusel_window") # Accedemos al objeto "paginas_carrusel mediante el identifivador declarado en el XML de "Glade". self.paginas_carrusel = self.builder.get_object("paginas_carrusel") # Enlaces # Accedemos al objeto "TextView" mediante el identifivador declarado en el XML de "Glade". self.text_view_links = self.builder.get_object("text_view_links") # Creamos una variable para obtener el buffer del "TextView". self.buf = self.text_view_links.get_buffer() sw_links = self.builder.get_object("desplazamiento_links") sw_links.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw_links.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw_links.add(self.text_view_links) with open("/home/mrpatxi/senia-carrusel-workspace/enlaces.txt", 'r') as f: data = f.read() self.buf.set_text(data) self.fileIcon = self.get_icon(Gtk.STOCK_FILE) self.dirIcon = self.get_icon(Gtk.STOCK_DIRECTORY) # Documentos ################################### icon_view_docs ######################### self.icon_view_docs = self.builder.get_object("icon_view_docs") self.label_dnd_docs = self.builder.get_object("label_dnd_docs") self.label_dnd_docs.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY) self.add_text_targets_docs() self.docs_dir = os.path.expanduser( '/home/mrpatxi/senia-carrusel-workspace/docs') self.cur_dir_docs = self.docs_dir sw_docs = self.builder.get_object("desplazamiento_docs") sw_docs.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw_docs.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.store_docs = self.create_store_docs() self.fill_store_docs() self.icon_view_docs.set_model(self.store_docs) #icon_view_docs.set_selection_mode(Gtk.SelectionMode.MULTIPLE) self.icon_view_docs.set_selection_mode(Gtk.SelectionMode.SINGLE) self.icon_view_docs.set_text_column(COL_PATH) self.icon_view_docs.set_pixbuf_column(COL_PIXBUF) sw_docs.add(self.icon_view_docs) self.icon_view_docs.grab_focus() self.model_docs = self.icon_view_docs.get_model() # PDF's self.icon_view_pdfs = self.builder.get_object("icon_view_pdfs") self.label_dnd_pdfs = self.builder.get_object("label_dnd_pdfs") self.label_dnd_pdfs.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY) self.add_text_targets_pdfs() self.pdfs_dir = os.path.expanduser( '/home/mrpatxi/senia-carrusel-workspace/pdfs') self.cur_dir_pdfs = self.pdfs_dir sw_pdfs = self.builder.get_object("desplazamiento_pdfs") sw_pdfs.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw_pdfs.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.store_pdfs = self.create_store_pdfs() self.fill_store_pdfs() self.icon_view_pdfs.set_model(self.store_pdfs) self.icon_view_pdfs.set_selection_mode(Gtk.SelectionMode.SINGLE) self.icon_view_pdfs.set_text_column(COL_PATH) self.icon_view_pdfs.set_pixbuf_column(COL_PIXBUF) sw_pdfs.add(self.icon_view_pdfs) self.icon_view_pdfs.grab_focus() self.model_pdfs = self.icon_view_pdfs.get_model() # Images self.icon_view_photos = self.builder.get_object("icon_view_photos") self.label_dnd_photos = self.builder.get_object("label_dnd_photos") self.label_dnd_photos.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY) self.add_text_targets_photos() self.photos_dir = os.path.expanduser( '/home/mrpatxi/senia-carrusel-workspace/photos') self.cur_dir_photos = self.photos_dir sw_photos = self.builder.get_object("desplazamiento_photos") sw_photos.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw_photos.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.store_photos = self.create_store_photos() self.fill_store_photos() self.icon_view_photos.set_model(self.store_photos) self.icon_view_photos.set_selection_mode(Gtk.SelectionMode.SINGLE) self.icon_view_photos.set_text_column(COL_PATH) self.icon_view_photos.set_pixbuf_column(COL_PIXBUF) sw_photos.add(self.icon_view_photos) self.icon_view_photos.grab_focus() self.model_photos = self.icon_view_photos.get_model() # Creamos la visiluacización de los eventos de la ventana. self.sw_viewport = self.builder.get_object("desplazamiento_viewport") self.viewport = self.builder.get_object("viewport") # Creamos la terminal self.terminal = Vte.Terminal() self.terminal.spawn_sync( Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) self.command = "bash /usr/bin/senia-carrusel\n" self.viewport.add(self.terminal) self.sw_viewport.add(self.viewport) self.window.show_all()
def __init__(self, datadir, options, file=""): GDebiCommon.__init__(self, datadir, options, file) SimpleGtkbuilderApp.__init__(self, path=os.path.join(datadir, "gdebi.ui"), domain="gdebi") # use a nicer default icon icons = Gtk.IconTheme.get_default() try: logo = icons.load_icon("gnome-mime-application-x-deb", 48, 0) if logo != "": Gtk.Window.set_default_icon_list([logo]) except Exception as e: logging.warning("Error loading logo %s" % e) # create terminal self.vte_terminal = Vte.Terminal() # FIXME: this sucks but without it the terminal window is only # 1 line height self.vte_terminal.set_size_request(80 * 10, 25 * 10) menu = Gtk.Menu() menu_items = Gtk.MenuItem(label=_("Copy selected text")) menu.append(menu_items) menu_items.connect("activate", self.menu_action, self.vte_terminal) menu_items.show() self.vte_terminal.connect_object("event", self.vte_event, menu) self.hbox_install_terminal.pack_start(self.vte_terminal, True, True, 0) scrollbar = Gtk.VScrollbar( adjustment=self.vte_terminal.get_vadjustment()) self.hbox_install_terminal.pack_start(scrollbar, False, False, 0) # setup status self.context = self.statusbar_main.get_context_id( "context_main_window") self.statusbar_main.push(self.context, _("Loading...")) # show what we have self.window_main.realize() self.window_main.show() # setup drag'n'drop # FIXME: this seems to have no effect, droping in nautilus does nothing target_entry = Gtk.TargetEntry().new('text/uri-list', 0, 0) self.window_main.drag_dest_set(Gtk.DestDefaults.ALL, [target_entry], Gdk.DragAction.COPY) self.window_main.connect("drag_data_received", self.on_window_main_drag_data_received) # Check file with gio file = self.gio_copy_in_place(file) #self.vte_terminal.set_font_from_string("monospace 10") self.cprogress = self.CacheProgressAdapter(self.progressbar_cache) if not self.openCache(): self.show_alert(Gtk.MessageType.ERROR, self.error_header, self.error_body) sys.exit(1) self.statusbar_main.push(self.context, "") # setup the details treeview self.details_list = Gtk.ListStore(GObject.TYPE_STRING) column = Gtk.TreeViewColumn("") render = Gtk.CellRendererText() column.pack_start(render, True) column.add_attribute(render, "markup", 0) self.treeview_details.append_column(column) self.treeview_details.set_model(self.details_list) # setup the files treeview column = Gtk.TreeViewColumn("") render = Gtk.CellRendererText() column.pack_start(render, True) column.add_attribute(render, "text", 0) self.treeview_files.append_column(column) # empty config self.synaptic_config = apt_pkg.Configuration() if file != "" and os.path.exists(file): self.open(file) self.window_main.set_sensitive(True)
def __init__(self): Gtk.Window.__init__(self, title=NAME) # Attempt to use tux as the icon. If it fails, that's okay try: self.set_icon_name("{{ tux_icon_name }}") except GLib.GError as err: logging.warning("Unable to set Tux icon", exc_info=err) # Create a box to contain all elements that will be added to the window self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) self.add(self.vbox) self.create_toolbar() contents = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12) contents.set_border_width(10) instruction_text = ( "Select the course configurations to add/update" " (at this time courses cannot be removed)." ) label = Gtk.Label(label=instruction_text) label.set_xalign(0.0) label.set_yalign(0.0) contents.pack_start(label, False, False, 0) courses_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6) # This button doesn't do anything. Common is always run refresh = Gtk.CheckButton(label="Base configuration") refresh.set_tooltip_text("This option is required") refresh.set_active(True) refresh.set_sensitive(False) courses_box.pack_start(refresh, False, False, 0) # Add a checkbox for every course; sorting is necessary because # dictionaries do not guarantee that order is preserved for (course, tag) in sorted(COURSES.items()): checkbox = Gtk.CheckButton(label=course) checkbox.set_tooltip_text("Configure for %s" % course) courses_box.pack_start(checkbox, False, False, 0) if tag in USER_CONFIG['roles_this_run']: checkbox.set_active(True) checkbox.connect("toggled", self.on_course_toggled, tag) self.checkboxes.append(checkbox) contents.pack_start(courses_box, False, False, 0) # Add run and cancel buttons button_box = Gtk.Box(spacing=6) self.run_button = Gtk.Button.new_with_label("Run") self.run_button.set_tooltip_text("Configure the VM") self.run_button.connect("clicked", self.on_run_clicked) button_box.pack_start(self.run_button, True, True, 0) self.cancel_button = Gtk.Button.new_with_mnemonic("_Quit") self.cancel_button.connect("clicked", Gtk.main_quit) button_box.pack_end(self.cancel_button, True, True, 0) contents.pack_end(button_box, False, True, 0) # Add the terminal to the window self.terminal = Vte.Terminal() # Prevent the user from entering text or ^C self.terminal.set_input_enabled(False) # Ensure that if text is written, the user sees it self.terminal.set_scroll_on_output(True) # Ensure that all lines can be seen (default is only 512) self.terminal.set_scrollback_lines(-1) self.terminal.connect("child-exited", self.sub_command_exited) contents.pack_end(self.terminal, True, True, 0) self.vbox.pack_end(contents, True, True, 0)
def get_widget(self, uri, window): """Returns the widgets to display to Caja.""" #Kill old child process try: window.nt_lastpid except AttributeError: #First terminal of the window window.nt_lastpid = -1 else: #Kill old child if window.nt_lastpid > 0: try: os.kill(window.nt_lastpid, signal.SIGKILL) except: pass finally: window.nt_lastpid = -1 #Set some variables for new windows try: window.nt_termheight except AttributeError: window.nt_termheight = -1 try: window.nt_termhidden except AttributeError: window.nt_termhidden = CONF['general_starthidden'] #If it's not a local folder, directory = $HOME if uri[:7] == "file://": path = urllib.url2pathname(uri[7:]) else: path = os.environ.get("HOME") #Disable for desktop folder if uri.startswith("x-caja-desktop://"): return #White list if not CONF['folders_showinall'] and \ not match_path(path, CONF['folders_list']): return #GUI gui = Gtk.Builder() gui.set_translation_domain(__appname__) gui.add_from_file(TERMINAL_GUI_FILE) vboxMain = gui.get_object("vboxMain") #### hboxHidden #### hboxHidden = gui.get_object("hboxHidden") if window.nt_termhidden: hboxHidden.show() else: hboxHidden.hide() btnPref2 = gui.get_object("btnPref2") btnHide = gui.get_object("btnHide") btnShow = gui.get_object("btnShow") #### hboxTerm #### hboxTerm = gui.get_object("hboxTerm") if window.nt_termhidden: hboxTerm.hide() else: hboxTerm.show() btnPref = gui.get_object("btnPref") sclwinTerm = gui.get_object("sclwinTerm") #terminal terminal = Vte.Terminal() terminal.last_size = window.nt_termheight self.fork_cmd(window, terminal, sclwinTerm, path) terminal.show() sclwinTerm.add(terminal) #scrollbar terminal.set_hadjustment(gui.get_object("adjH")) terminal.set_vadjustment(gui.get_object("adjV")) if CONF['general_showscrollbar']: vpolicy = Gtk.PolicyType.ALWAYS else: vpolicy = Gtk.PolicyType.NEVER sclwinTerm.set_policy( Gtk.PolicyType.NEVER, #Horizontal vpolicy, #Vertical ) if window.nt_termheight == -1: window.nt_termheight = terminal.get_char_height( ) * CONF['general_defheight'] sclwinTerm.set_size_request(-1, window.nt_termheight) #Apply config on the terminal self._set_terminal(terminal) #### evResize #### evResize = gui.get_object("evResize") if window.nt_termhidden: evResize.hide() else: evResize.show() #### Signals #### #evResize evResize.connect("enter-notify-event", self.on_evResize_enter_notify_event, sclwinTerm) evResize.connect("leave-notify-event", self.on_evResize_leave_notify_event) evResize.connect("motion-notify-event", self.on_evResize_motion_notify_event, sclwinTerm, terminal, window) #Button preferences btnPref.connect("clicked", self.preferences, terminal) #Button preferences 2 btnPref2.connect("clicked", self.preferences, terminal) #Button Hide btnHide.connect( "clicked", self.hide, window, hboxHidden, hboxTerm, evResize, ) #Button Show btnShow.connect( "clicked", self.show, window, hboxHidden, hboxTerm, terminal, evResize, ) #Terminal terminal.connect("destroy", self.on_terminal_destroy, window) terminal.connect("child-exited", self.on_terminal_child_exited) terminal.connect( "commit", self.on_terminal_commit, window, sclwinTerm, path, ) terminal.connect( "focus", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) if Gtk.check_version(3, 0, 0) is None: terminal.connect( "draw", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) else: terminal.connect( "expose-event", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) terminal.connect( "button-press-event", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) terminal.connect( "key-press-event", self.on_terminal_key_press_event, window, sclwinTerm, path, ) terminal.connect("key-release-event", self.on_terminal_key_release_event) #DnD try: # Missing from Gtk-2.0 introspection terminal.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new('text/uri-list', 0, 80)], Gdk.DragAction.COPY, ) terminal.connect("drag_motion", self.on_terminal_drag_motion) terminal.connect("drag_drop", self.on_terminal_drag_drop) terminal.connect("drag_data_received", self.on_terminal_drag_data_received) except (AttributeError, TypeError): pass #### Accel #### accel_group = Gtk.AccelGroup() window.add_accel_group(accel_group) terminal.add_accelerator( "paste-clipboard", accel_group, ord('V'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) terminal.add_accelerator( "copy-clipboard", accel_group, ord('C'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) btnShow.add_accelerator( "clicked", accel_group, ord('T'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) btnHide.add_accelerator( "clicked", accel_group, ord('T'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) #### Return the widgets #### vboxMain.unparent() return vboxMain
def __init__(self, parent): Gtk.Dialog.__init__(self, "Backup Job", parent, 0) self.set_default_size(300, 350) now = datetime.now().strftime('%Y%m%d_%H%M%S') # Prepares timestamp # Define scrolled window and child terminal widget self.terminal = Vte.Terminal() scrolledterm = Gtk.ScrolledWindow() scrolledterm.set_min_content_height(300) scrolledterm.set_min_content_width(500) scrolledterm.add(self.terminal) scrolledterm.set_policy(hscrollbar_policy=Gtk.PolicyType.AUTOMATIC, vscrollbar_policy=Gtk.PolicyType.AUTOMATIC) self.terminal.fork_command_full(Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) self.terminal.connect("child-exited", lambda x: self.backupdone(parent.readybackup)) # Populate box (this dialog window) box = self.get_content_area() box.add(scrolledterm) self.okbutton = self.add_button("_Ok", Gtk.ResponseType.OK) self.cancelbutton = self.add_button("_Cancel", Gtk.ResponseType.CANCEL) self.cancelbutton.set_sensitive(True) self.okbutton.set_sensitive(False) # Hide until job is complete self.confirmlabel = Gtk.Label( "The backup job is complete. Hit OK to return.") box.add(self.confirmlabel) self.show_all() self.confirmlabel.hide() # Hide until job is complete # RUN Backup Job: this uses a softlink to be used as a hardlinked location path. # Term "hardlink" used below but may refer to a softlink self.hardlink = parent.readybackup["dest"] + "LatestBackup" self.newbackuppath = parent.readybackup["dest"] + now if os.path.exists( self.hardlink): # Check if softlink exists and is valid hardlinkarg = '--link-dest="' + self.hardlink + '"' else: # Softlink doesn't exist or is invalid a = re.compile("^\d{8}_\d{6}$") # Pattern to match matchlist = [] for prevbackup in sorted(os.listdir(parent.readybackup["dest"])): if a.match(prevbackup): matchlist.append(prevbackup) if matchlist: # At least one prev backup exists newlink = parent.readybackup["dest"] + matchlist[-1] hardlinkarg = '--link-dest="' + newlink + '"' else: # No previous backup exists hardlinkarg = '' # Initializes first backup without hardlinking if parent.readybackup["sudo"]: sudoarg = "sudo " else: sudoarg = "" args = [ sudoarg + "rsync", "-avWh", "--progress", "--stats", parent.readybackup["options"], hardlinkarg, '--log-file="' + parent.logspath + parent.readybackup["name"] + 'backup.txt"', '"' + parent.readybackup["source"] + '"', '"' + self.newbackuppath + '"' ] #~ print(' '.join(args)) #Comment out command = ' '.join( args) + '; exit\n' # Added 'exit' to trigger exit signal length = len(command) # Null terminates command self.terminal.feed_child(command, length) # Inputs command into terminal
def __init__(self): self.builder = Gtk.Builder() self.builder.add_from_file(UIFILE) self.builder.connect_signals(self) window = self.builder.get_object('window') #show main window window.show_all() global Uproject Uproject = None global ProjectList ProjectList = None #Init_Install___________________________________________________________________ #init Editor VTE EDITORVTE = self.builder.get_object('VTE_Editor') self.Editor_terminal = Vte.Terminal() #decide the vte version if VTEver == 290: self.Editor_terminal.fork_command_full( Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) print("old VTE used! (v 2.90) *WINDOW_INIT*") else: self.Editor_terminal.spawn_sync( Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) print("New VTE Used () v. 2.91 *WINDOW_INIT*") EDITORVTE.add(self.Editor_terminal) EDITORVTE.show_all() #HelpBrowser____________________________________________________________________ #initialise help browser if fct.readconf('stream') == '1': helpurl = fct.readconf('defurl') helpbrowser = WebKit.WebView() # To disallow editing the webpage. helpbrowser.set_editable(False) #load url and show window helpbrowser.load_uri(helpurl) sw = self.builder.get_object('Help_Browser') sw.add(helpbrowser) helpbrowser.show() print('Opened help URL') else: print('Not Loading Internet URL (Learn Tab)') #BlogBrowser____________________________________________________________________ if fct.readconf('stream') == '1': blogurl = fct.readconf('blogurl') #initialise blog browser blogbrowser = WebKit.WebView() #disable editing blogbrowser.set_editable(False) #load default URL blogbrowser.load_uri(blogurl) bsw = self.builder.get_object('Blog_Browser') bsw.add(blogbrowser) blogbrowser.show() else: print('Not Loading Internet URL (BLOG)') #Marketplace if fct.readconf('stream') == '1': mpurl = fct.readconf('mpurl') mpbrowser = WebKit.WebView() mpbrowser.set_editable(False) mpbrowser.load_uri(mpurl) mpwin = self.builder.get_object('SW_Marketplace') mpwin.add(mpbrowser) mpbrowser.show() else: print("Not Loading Internet URL (MARKETPLACE)") #MAININTERFACE__________________________________________________________________ #UpdateSymbol Symbol = self.builder.get_object('MAIN_Launcher_Symbol') Symbol.set_from_file(PIXMAP) #add text to textbuffer vTextbuffer = self.builder.get_object('VersionTextBuffer') BufferTextList = fct.get_folder_content(str(fct.readconf('defloc'))) items = len(BufferTextList) finaltext = '' for itemcount in range(items): finaltext = finaltext + str('Unreal Branch: ' + str(BufferTextList[itemcount]) + '\n') vTextbuffer.set_text(finaltext) #ShowStartup on first start if fct.readconf('firststart') == '1': startwin = self.builder.get_object('FirstStartupMessage') startwin.show_all() fct.newdi('firststart', '0') else: print('not showing firststart') #make the library list__________________________________________________________ #make the iconview plus liststore ProjectList = fct.get_folder_content(fct.readconf('proloc')) projectstore = Gtk.ListStore(GdkPixbuf.Pixbuf, str) LibraryView = self.builder.get_object('LibraryIconView') LibraryView.set_model(projectstore) LibraryView.set_pixbuf_column(0) LibraryView.set_text_column(1) #create the etrys for i in range(len(ProjectList)): try: pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( str( str( fct.readconf('proloc') + '/' + str(ProjectList[i]) + '/Saved/AutoScreenshot.png')), 64, 64) except: pixbuf = Gtk.IconTheme.get_default().load_icon( 'dialog-error', 64, 0) projectstore.append([pixbuf, ProjectList[i]])
def _build_and_inject_ui(self): # GtkPaned (vpanel) injection: # # To inject our terminal in Nautilus, we first have to empty the # NautilusWindowSlot widget (parent widget) of the current view to make # some free space to insert a GtkPaned widget. Then we will insert back # the Nautilus' widgets we removed in the bottom part of the GtkPaned. self._ui_vpanel = Gtk.VPaned(visible=True) self._ui_vpanel._nt_instance = self vbox = Gtk.VBox(visible=True) self._ui_vpanel.add2(vbox) for widget in self._parent_widget: self._parent_widget.remove(widget) expand = widget.get_name() in ["GtkOverlay", "NautilusCanvasView"] vbox.pack_start(widget, expand, expand, 0) self._parent_widget.pack_start(self._ui_vpanel, True, True, 0) # Terminal creation: # # We can now create our VteTerminal and insert it in the top part of # our GtkPaned. self._ui_terminal = Vte.Terminal() self._ui_terminal.connect("child-exited", self._on_terminal_child_existed) self._ui_vpanel.pack1(self._ui_terminal, resize=False, shrink=False) TERMINAL_CHAR_HEIGHT = self._ui_terminal.get_char_height() TERMINAL_BORDER_WIDTH = 1 TERMINAL_MIN_HEIGHT = self._settings.get_uint("min-terminal-height") self._ui_terminal.set_property( "height-request", TERMINAL_CHAR_HEIGHT * TERMINAL_MIN_HEIGHT + TERMINAL_BORDER_WIDTH * 2) # File drag & drop support self._ui_terminal.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 0)], Gdk.DragAction.COPY) self._ui_terminal.drag_dest_add_uri_targets() self._ui_terminal.connect("drag-data-received", self._on_terminal_drag_data_received) # Disabling Nautilus' accels when the terminal is focused: # # When the terminal is focused, we MUST remove ALL Nautilus accels to # be able to use properly the terminal (else we cannot type some # characters like "/", "~",... because the actions of the corresponding # accels are called). Of course we have also to restore the accels when # the terminal is no more focused. self._ui_terminal.connect("focus-in-event", self._on_terminal_focus_in_event) self._ui_terminal.connect("focus-out-event", self._on_terminal_focus_out_event) # Register the window-level action group of the currently displayed # terminal # # When the active tab changes, we have to register on the nautilus # window the corresponding action group to allow related accels to work # properly. The "map" event of the NautilusWindowSlot (our parent # widget) is called when its tab become active. self._parent_widget.connect("map", self._on_nautilus_window_slot_mapped) # Kill the shell when the tab is closed: # # Finally, we have to listen to some events of our parent widget (the # NautilusWindowSlot) to guess when the tab is closed in order to # kill the shell (else we will have plenty zombie shell running in # background). # # * When the tab (or the window) is closed, the "unrealize" event is # called so we have to kill the shell when the parent widget emit # this event... # # * BUT when the tab is drag & dropped outside of the window (to open # it in a new window), this event is also emitted... and the # "realize" event is emitted right after. So we have to spawn a new # shell if that happen... self._parent_widget.connect("unrealize", self._on_nautilus_window_slot_unrealized) self._parent_widget.connect("realize", self._on_nautilus_window_slot_realized)
def init(self): self.all_category = {} self.switchcategory = {} self.sw = Gtk.ScrolledWindow() self.maincontainer = Gtk.VBox() self.grid = Gtk.Grid() self.stack = Gtk.Stack() self.stack.set_hexpand(True) self.stack.set_vexpand(True) self.listbox_ = Gtk.ListBox() self.grid.attach(self.listbox_, 0, 0, 1, 1) self.grid.attach(self.stack, 1, 0, 1, 1) self.maincontainer.add(self.grid) self.sw.add(self.maincontainer) self.add(self.sw) self.loading_all_plugins() self.listbox_.connect("row-activated", self.on_activated_row) try: gi.require_version('Vte', '2.91') from gi.repository import Vte tscrolledwindow = Gtk.ScrolledWindow() self.terminal = Vte.Terminal() #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)) vadjustment = self.terminal.get_vadjustment() tscrolledwindow.set_vadjustment(vadjustment) _pty = Vte.Pty.new_sync(Vte.PtyFlags(0), None) _pty.child_setup() self.terminal.set_pty(_pty) self.terminal.connect("button-release-event", self.on_button_event) self.menu = Gtk.Menu() self.menu.set_screen(Gdk.Screen().get_default()) self.copytextmenuitem = Gtk.MenuItem.new_with_label("Copy") cursorcolormenuitem = Gtk.MenuItem.new_with_label("Cursor Color") backgroundmenuitem = Gtk.MenuItem.new_with_label("Backgound Color") foregroundmenuitem = Gtk.MenuItem.new_with_label( "Foreground Color") self.copytextmenuitem.connect("activate", self.copy_text) 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(self.copytextmenuitem) self.menu.append(cursorcolormenuitem) self.menu.append(backgroundmenuitem) self.menu.append(foregroundmenuitem) self.vte_format = Vte.Format(1) tscrolledwindow.add(self.terminal) self.maincontainer.pack_end(tscrolledwindow, True, True, 0) except Exception as e: print(e) self.show_all()
def __init__(self): self.terminal = Vte.Terminal() self.options = {}
def __init__(self, model, view): def show_command(): """ User clicked Show Command button. """ lines = textwrap.wrap(self.command, 60, break_long_words=False, break_on_hyphens=False) text = ' \\\n'.join(lines) self.view.show_info("mode2 command string", text) def show_log(): """ User clicked View log button. """ path = os.path.expanduser("~/.cache/mode2.log") if not os.path.exists(path) or os.stat(path)[6] < 10: self.view.show_info("No log available") return with open(path, "r") as f: log = '\n'.join(f.readlines()) self.view.show_info("mode2 logfile", log) Gtk.Window.__init__(self, title="Test device and driver setup") self.view = view self.command = model.get_mode2() + '\n' self.set_default_size(600, 300) self.terminal = Vte.Terminal() self.terminal.spawn_sync( Vte.PtyFlags.DEFAULT, os.getcwd(), ['/bin/sh'], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) self.run_btn = Gtk.Button("Run command") self.cmd_btn = Gtk.Button("Show command") self.log_btn = Gtk.Button("View log") self.run_btn.connect("clicked", self.input_to_term) self.quit_btn = Gtk.Button("Quit") self.quit_btn.connect("clicked", lambda b: self.destroy()) self.cmd_btn.connect("clicked", lambda b: show_command()) self.log_btn.connect("clicked", lambda b: show_log()) self.help_btn = Gtk.Button("Help") self.help_btn.connect( "clicked", lambda b: view.show_info("mode2 help", MODE2_HELP_MSG)) self.set_focus(self.run_btn) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) scroller = Gtk.ScrolledWindow() scroller.set_hexpand(True) scroller.set_vexpand(True) scroller.add(self.terminal) vbox.pack_start(scroller, False, True, 1) hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) hbox.set_spacing(5) hbox.pack_end(self.run_btn, False, True, 5) hbox.pack_end(self.cmd_btn, False, True, 5) hbox.pack_end(self.log_btn, False, True, 5) hbox.pack_end(self.quit_btn, False, True, 5) hbox.pack_start(self.help_btn, False, True, 5) vbox.pack_start(hbox, False, True, 2) self.add(vbox)
def __init__(self): Gtk.Window.__init__(self) self.channel = implementations.insecure_channel('localhost', 60000) self.stub = gui_pb2.beta_create_ControllerView_stub(self.channel) self.connect("delete-event", Gtk.main_quit) self.set_title("Measurement") self.resize(800, 400) self.daQubits = [self.registerSize] self.hQubits = [self.registerSize] self.eZeros = [self.registerSize] self.eOnes = [self.registerSize] self.cVquBitInfo = [self.registerSize] self.ePolarizations = [self.registerSize] self.eMeasurementAngles = [self.registerSize] self.bFindAngle = [self.registerSize] self.bMeasure = [self.registerSize] self.polarizations = [0.0, 0.0, 0.0, 0.0] self.measurementAngles = [0.0, 0.0, 0.0, 0.0] cGMain = Gtk.Grid(column_spacing=10) cGQubits = Gtk.Grid() cGUserInput = Gtk.Grid() cVRegister = Gtk.VBox() cVRegister.set_size_request(150, 400) lGQubits = Gtk.Label() lGQubits.set_text("Qubit State") lGRegister = Gtk.Label() lGRegister.set_text("Register State") lGUserInput = Gtk.Label() lGUserInput.set_text("Outcome Probability") cGMain.attach(lGUserInput, 0, 0, 1, 1) cGMain.attach(lGQubits, 1, 0, 2, 1) cGMain.attach(lGRegister, 3, 0, 1, 1) cGMain.attach(cGQubits, 0, 1, 3, 8) cGMain.attach(cVRegister, 3, 1, 1, 8) for i in range(self.registerSize): cGProbabilities = Gtk.Grid() lProbabilities = Gtk.Label() lProbabilities.set_text("Qubit " + str(i)) lProbabilities.set_size_request(80, 20) lZero = Gtk.Label() lZero.set_text("|0>") lZero.set_size_request(40, 20) self.eZeros.insert(i, Gtk.Entry()) self.eZeros[i].set_text("1.0") self.eZeros[i].set_width_chars(5) lOne = Gtk.Label() lOne.set_text("|1>") lOne.set_size_request(40, 20) self.eOnes.insert(i, Gtk.Entry()) self.eOnes[i].set_text("0.0") self.eOnes[i].set_width_chars(5) userInputOffset = 5 * i cGQubits.attach(lProbabilities, 0, userInputOffset + 0, 2, 1) cGQubits.attach(lZero, 0, userInputOffset + 1, 1, 1) cGQubits.attach(self.eZeros[i], 1, userInputOffset + 1, 1, 1) cGQubits.attach(lOne, 0, userInputOffset + 2, 1, 1) cGQubits.attach(self.eOnes[i], 1, userInputOffset + 2, 1, 1) self.daQubits.insert(i, Gtk.DrawingArea()) self.daQubits[i].set_size_request(150, 100) self.daQubits[i].connect("draw", self.expose, i) cGQubits.attach(self.daQubits[i], 2, userInputOffset, 1, 3) self.bFindAngle.insert(i, Gtk.Button()) self.bFindAngle[i].set_label("Find Angle") self.bFindAngle[i].connect("clicked", self.bFindAngle_exec, i) cGQubits.attach(self.bFindAngle[i], 3, userInputOffset, 1, 1) self.bMeasure.insert(i, Gtk.Button()) self.bMeasure[i].set_label("Measure") self.bMeasure[i].connect("clicked", self.bMeasure_exec, i) cGQubits.attach(self.bMeasure[i], 4, userInputOffset, 1, 1) lPolarization = Gtk.Label() lPolarization.set_justify(Gtk.Justification.LEFT) lPolarization.set_text("Polarization:") lPolarization.set_size_request(200, 20) self.ePolarizations.insert(i, Gtk.Entry()) self.ePolarizations[i].set_text(str(self.polarizations[i])) self.ePolarizations[i].set_width_chars(5) self.ePolarizations[i].set_editable(False) self.ePolarizations[i].set_has_frame(False) self.ePolarizations[i].set_can_focus(False) cGQubits.attach(lPolarization, 3, userInputOffset + 1, 1, 1) cGQubits.attach(self.ePolarizations[i], 4, userInputOffset + 1, 1, 1) lMeasurementAngle = Gtk.Label() lMeasurementAngle.set_justify(Gtk.Justification.LEFT) lMeasurementAngle.set_text("Detector Angle:") lMeasurementAngle.set_size_request(200, 20) self.eMeasurementAngles.insert(i, Gtk.Entry()) self.eMeasurementAngles[i].set_text(str(self.measurementAngles[i])) self.eMeasurementAngles[i].set_width_chars(5) cGQubits.attach(lMeasurementAngle, 3, userInputOffset + 2, 1, 1) cGQubits.attach(self.eMeasurementAngles[i], 4, userInputOffset + 2, 1, 1) self.daRegister = Gtk.DrawingArea() self.daRegister.set_size_request(150, 400) self.daRegister.connect("draw", self.exposeRegister) cVRegister.pack_start(self.daRegister, True, False, 0) self.vt = Vte.Terminal() self.vt.set_size_request(400, 400) self.vt.fork_command_full( Vte.PtyFlags.DEFAULT, os.environ['PWD'], ["/bin/bash"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) command = "./superpositionController\r\n" self.vt.feed_child(command, len(command)) self.vt.hide() cGMain.attach(self.vt, 4, 1, 1, 8) self.add(cGMain) self.show_all() self.vt.hide() time.sleep(1) self.initDone = 1
def __init__(self, model, view): def show_command(): """ User clicked Show Command button. """ lines = textwrap.wrap(self.command, 60, break_long_words=False, break_on_hyphens=False) text = ' \\\n'.join(lines) self.view.show_info("lircd + irw command string", text) def do_quit(): """ User clicked "Quit" button. """ cmd = self.kill + '\n' self.terminal.feed_child(cmd, len(cmd)) self.destroy() Gtk.Window.__init__(self, title="Test decoding") self.view = view ok, self.command, self.kill = model.get_irwcheck() if not ok: view.show_error("Test setup error", self.command) return self.command += '\n' self.set_default_size(600, 300) self.terminal = Vte.Terminal() self.terminal.spawn_sync( Vte.PtyFlags.DEFAULT, os.getcwd(), ['/bin/sh'], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) scroller = Gtk.ScrolledWindow() scroller.set_hexpand(True) scroller.set_vexpand(True) scroller.add(self.terminal) vbox.pack_start(scroller, False, True, 1) self.run_btn = Gtk.Button("Run command") self.quit_btn = Gtk.Button("Quit") self.cmd_btn = Gtk.Button("Show command") help_btn = Gtk.Button("Help") hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) hbox.set_spacing(10) hbox.pack_end(self.run_btn, False, True, 10) hbox.pack_end(self.quit_btn, False, True, 10) hbox.pack_end(self.cmd_btn, False, True, 10) hbox.pack_start(help_btn, False, True, 10) vbox.pack_start(hbox, False, True, 2) self.add(vbox) self.set_focus(self.run_btn) self.run_btn.connect("clicked", self.input_to_term) self.quit_btn.connect("clicked", lambda b: do_quit()) self.cmd_btn.connect("clicked", lambda b: show_command()) help_btn.connect("clicked", lambda b: view.show_info("mode2 help", IRW_HELP_MSG)) self.connect("delete-event", lambda e, v: do_quit())
def create_ui(self): self.set_border_width(5) app_vbox = Gtk.VBox(spacing=5) self.module_hbox = Gtk.HBox(spacing=5) app_vbox.pack_start(self.module_hbox, False, False, 9) label = Gtk.Label() label.set_markup('<b>%s</b>' % _('Choose Module:')) self.module_hbox.pack_start(label, False, False, 0) self.module_combo = Gtk.ComboBox.new_with_model( self.modules_list_model) cell = Gtk.CellRendererText() self.module_combo.pack_start(cell, True) self.module_combo.add_attribute(cell, 'text', 0) self.module_combo.changed_signal_id = self.module_combo.connect( 'changed', self.on_module_selection_changed_cb) self.module_combo.set_row_separator_func(lambda x, y: x.get(y, 1)[0]) self.module_hbox.pack_start(self.module_combo, False, True, 0) separator = Gtk.VSeparator() self.module_hbox.pack_start(separator, False, True, 0) preferences = Gtk.Button(stock=Gtk.STOCK_PREFERENCES) preferences.connect('clicked', self.on_preferences_cb) self.module_hbox.pack_start(preferences, False, True, 0) self.progressbar = Gtk.ProgressBar() self.progressbar.set_text(_('Build Progress')) app_vbox.pack_start(self.progressbar, False, True, 0) expander = Gtk.Expander.new(_('Terminal')) expander.set_expanded(False) app_vbox.pack_start(expander, False, False, 0) sclwin = Gtk.ScrolledWindow() sclwin.set_size_request(-1, 300) sclwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.ALWAYS) expander.add(sclwin) if Vte: self.terminal = Vte.Terminal() self.terminal.connect('child-exited', self.on_vte_child_exit_cb) else: os.environ['TERM'] = 'dumb' # avoid commands printing vt sequences self.terminal = Gtk.TextView() self.terminal.set_size_request(800, -1) textbuffer = self.terminal.get_buffer() terminal_bold_tag = textbuffer.create_tag('bold') terminal_bold_tag.set_property('weight', Pango.Weight.BOLD) terminal_mono_tag = textbuffer.create_tag('mono') terminal_mono_tag.set_property('family', 'Monospace') terminal_stdout_tag = textbuffer.create_tag('stdout') terminal_stdout_tag.set_property('family', 'Monospace') terminal_stderr_tag = textbuffer.create_tag('stderr') terminal_stderr_tag.set_property('family', 'Monospace') terminal_stderr_tag.set_property('foreground', 'red') terminal_stdin_tag = textbuffer.create_tag('stdin') terminal_stdin_tag.set_property('family', 'Monospace') terminal_stdin_tag.set_property('style', Pango.Style.ITALIC) self.terminal.set_editable(False) self.terminal.set_wrap_mode(Gtk.WrapMode.CHAR) sclwin.add(self.terminal) self.terminal_sclwin = sclwin self.error_hbox = self.create_error_hbox() app_vbox.pack_start(self.error_hbox, False, False, 0) buttonbox = Gtk.HButtonBox() buttonbox.set_layout(Gtk.ButtonBoxStyle.END) app_vbox.pack_start(buttonbox, False, False, 0) # Translators: This is a button label (to start build) self.build_button = Gtk.Button(_('Start')) self.build_button.connect('clicked', self.on_build_cb) buttonbox.add(self.build_button) button = Gtk.Button(stock=Gtk.STOCK_HELP) button.connect('clicked', self.on_help_cb) buttonbox.add(button) buttonbox.set_child_secondary(button, True) app_vbox.show_all() self.error_hbox.hide() self.add(app_vbox)
def details_enable(self): from gi.repository import Vte self._details_widget = Vte.Terminal() self.widget("details-box").add(self._details_widget) self._details_widget.set_visible(True) self.widget("details").set_visible(True)
def __init__(self, handle): super(VteActivity, self).__init__(handle) self.max_participants = 1 # no sharing toolbox = ToolbarBox() activity_button_toolbar = ActivityToolbarButton(self) toolbox.toolbar.insert(activity_button_toolbar, 0) activity_button_toolbar.show() self.set_toolbar_box(toolbox) toolbox.show() self.toolbar = toolbox.toolbar ''' # add 'copy' icon from standard toolbar. edittoolbar = activity.EditToolbar() edittoolbar.copy.set_tooltip(_('Copy selected text to clipboard')) edittoolbar.copy.connect('clicked', self._on_copy_clicked_cb) edittoolbar.paste.connect('clicked', self._on_paste_clicked_cb) # as long as nothing is selected, copy needs to be insensitive. edittoolbar.copy.set_sensitive(False) toolbox.add_toolbar(_('Edit'), edittoolbar) edittoolbar.show() self._copy_button = edittoolbar.copy ''' separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbox.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>q' toolbox.toolbar.insert(stop_button, -1) stop_button.show() toolbox.toolbar.show_all() # 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.set_colors(Gdk.color_parse('#000000'), Gdk.color_parse('#E7E7E7'), []) ''' self._vte.connect('selection-changed', self._on_selection_changed_cb) # FIXME It does not work because it expects and receives # StructMeta Gtk.TargetEntry # #self._vte.drag_dest_set(Gtk.DestDefaults.ALL, # [("text/plain", 0, TARGET_TYPE_TEXT)], # Gdk.DragAction.COPY) self._vte.connect('drag_data_received', self._on_drop_cb) ''' # ...and its scrollbar vtebox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) vtebox.pack_start(self._vte, True, True, 0) vtesb = Gtk.Scrollbar(orientation=Gtk.Orientation.VERTICAL) # vtesb.set_adjustment(self._vte.get_adjustment()) vtesb.show() vtebox.pack_start(vtesb, False, False, 0) self.set_canvas(vtebox) self.show_all() ''' # hide the buttons we don't use. toolbar.share.hide() # this should share bundle. edittoolbar.undo.hide() edittoolbar.redo.hide() edittoolbar.separator.hide() ''' # 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 logging.error(bundle_path) self._pid = self._vte.fork_command_full( Vte.PtyFlags.DEFAULT, bundle_path, ['/bin/sh', '-c', 'python %s/pippy_app.py; sleep 1' % bundle_path], ["PYTHONPATH=%s/library" % bundle_path], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None,)
def __init__(self, keep_open): self.keep_open = keep_open self.command_mode = False self.select_mode = None self.selection_start = None self.normal_cursor_position = None self.vte = Vte.Terminal() vte_style = self.vte.get_style_context() Gtk.StyleContext.add_class(vte_style, "mantid") vte_style.add_provider(app.style, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) hbox_style = self.hbox.get_style_context() Gtk.StyleContext.add_class(hbox_style, "mantid") hbox_style.add_provider(app.style, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.hint_overlay = Gtk.Overlay() self.hint_overlay.override_background_color(Gtk.StateFlags.NORMAL, transparent) self.scrollbar = Gtk.Scrollbar.new(Gtk.Orientation.VERTICAL, self.vte.get_vadjustment()) scrollbar_style = self.scrollbar.get_style_context() Gtk.StyleContext.add_class(scrollbar_style, "mantid") scrollbar_style.add_provider(app.style, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.da = Gtk.DrawingArea() self.da.override_background_color(Gtk.StateFlags.NORMAL, transparent) self.da.set_halign(Gtk.Align.FILL) self.da.set_valign(Gtk.Align.FILL) self.panel_overlay = Gtk.Overlay() self.panel_entry = Gtk.Entry() self.panel_entry.set_margin_start(5) self.panel_entry.set_margin_end(5) self.panel_entry.set_margin_top(5) self.panel_entry.set_margin_bottom(5) self.panel_entry.set_halign(Gtk.Align.START) self.panel_entry.set_valign(Gtk.Align.END) self.panel_entry.connect("key-press-event", entry_key_press_cb, self) self.panel_overlay.connect("get-child-position", get_entry_position_overlay_cb) self.vte.connect("child-exited", child_exited_cb, self) self.vte.connect("key-press-event", key_press_cb, self) #self.vte.connect("button-press-event", button_press_cb, self) self.vte.connect("window-title-changed", window_title_cb, self) self.hint_overlay.add_overlay(self.da) self.hint_overlay.add(self.vte) self.hbox.pack_start(self.hint_overlay, True, True, 0) self.hbox.pack_start(self.scrollbar, False, False, 0) self.panel_overlay.add(self.hbox) # self.panel_overlay.add_overlay(self.panel_entry) self.panel_overlay.show_all() self.apply_config() self.panel_entry.hide() self.da.hide()
def on_B_Install_clicked(self, button): instwin = self.builder.get_object('Install_Dialog') #init VTE termwin = self.builder.get_object('VTE') self.term = Vte.Terminal() #decide the vte version if VTEver == 290: self.term.fork_command_full( Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) print("old VTE used! (v 2.90) *WINDOW_INSTALLDIALOG*") else: self.term.spawn_sync( Vte.PtyFlags.DEFAULT, os.environ['HOME'], ["/bin/sh"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) print("New VTE Used (v. 2.91) *WINDOW_INSTALLDIALOG*") termwin.add(self.term) instwin.show_all() #set texts______________________________________________________________________ #default location defaultlocation = self.builder.get_object('E_Install_DefLoc') defaultlocation.set_text(fct.readconf('defloc')) #Dependecies deps = self.builder.get_object('E_Install_Dependencies') distroversion = fct.readconf('distribution') print("distro = " + str(distroversion)) if distroversion == '0': deps.set_text(str(fct.readconf('deparch'))) elif distroversion == '1': deps.set_text(str(fct.readconf('depubuntu'))) elif distroversion == '2': deps.set_text(str(fct.readconf('depmint'))) else: deps.set_text('Unknown distribution,please check settings!') #set text in "Download EditGit = self.builder.get_object('E_Install_GitHub') EditConfig = self.builder.get_object('E_Install_Config') EditSlate = self.builder.get_object('E_Install_SlateViewer') SlateCheck = self.builder.get_object('CB_SlateCheck') #set texts EditGit.set_text(str(fct.readconf('giturl'))) EditConfig.set_text(str(fct.readconf('s1'))) EditSlate.set_text(str(fct.readconf('s2'))) #set text in "Build" ES3 = self.builder.get_object('E_Install_S3') ES4 = self.builder.get_object('E_Install_S4') infolabel = self.builder.get_object('L_Install_Info') if fct.readconf('distribution') == '0': infolabel.set_text( ' Please add "export PATH=$HOME/bin:$PATH" to your \n .bashrc or .zshrc in your home folder before \n continuing.\n' ) else: print("leaving arch info out") ES3.set_text(fct.readconf('s3')) ES4.set_text(fct.readconf('s4'))
#!/usr/bin/python3 import gi, sys, os gi.require_version('Gtk', '3.0') gi.require_version('Vte', '2.91') from gi.repository import Gtk, Vte, GLib terminal = Vte.Terminal() scrolled_window = Gtk.ScrolledWindow() terminal.connect("child_exited", Gtk.main_quit) cmd = "" if len(sys.argv) > 1: if "--" not in sys.argv[1]: cmd += sys.argv[1] for i in sys.argv[2:]: cmd += "\"" + i + "\" " if cmd == "": cmd = os.environ["SHELL"] print(cmd) win = Gtk.Window() if os.path.isfile("/usr/lib/sulin/dsl/debian.svg"): win.set_icon_from_file("/usr/lib/sulin/dsl/debian.svg") win.connect('delete-event', Gtk.main_quit) win.add(scrolled_window) scrolled_window.add(terminal) if len(sys.argv) > 1 and sys.argv[1] == "--fullscreen": win.fullscreen() else: win.set_size_request(547, 352) terminal.set_font_scale(0.9) win.set_title("d-term") win.show_all() terminal.spawn_sync(Vte.PtyFlags.DEFAULT, None, ["/bin/bash", "-c", cmd], [],
`notification_received` signal to catch the OSC escape sequence in the prompt Code is adapted from https://github.com/x4lldux/terminator-long-cmd-notify Thanks to @xll4dux on Github for the code and his permission to use it """ import terminatorlib.plugin as plugin from terminatorlib.terminator import Terminator import gi gi.require_version('Notify', '0.7') from gi.repository import GObject, GLib, Notify, Vte VERSION = '0.1.0' ### Test for proper signal try: Vte.Terminal().connect('notification-received', lambda *args: None, None) AVAILABLE = ['CommandNotify'] except TypeError as e: AVAILABLE = [] pass class CommandNotify(plugin.Plugin): capabilities = ['command_watch'] watched = set() def __init__(self): self.update_watched() Notify.init('Terminator') return None
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) #Clear history & Clear Terminal self.clear_his = Gtk.MenuItem("Clear history") self.clear_his.connect("activate", self.clear_history) self.clear_ter = Gtk.MenuItem("Clear terminal") self.clear_ter.connect("activate", self.clear_terminal) self.menu.append(self.clear_his) self.menu.append(self.clear_ter) #Memory status self.memorys = Gtk.MenuItem("Memory status") self.memorys.connect("activate", self.memory) self.menu.append(self.memorys) #About Quick Terminal self.about_ter = Gtk.MenuItem("About Quick Terminal") self.about_ter.connect("activate", self.about1) self.menu.append(self.about_ter) #Toolbars self.toolbar2 = Gtk.Toolbar() #Toolbar2 buttons self.SOUND_button = Gtk.ToolButton(Gtk.STOCK_EXECUTE) self.SOUND_button.set_label("Alsa Sound Selector") self.SOUND_button.connect("clicked", self.sound) self.SOUND_button.set_tooltip_text("Alsa Sound Selector") self.toolbar2.insert(self.SOUND_button, -1) self.WLAN_button = Gtk.ToolButton(Gtk.STOCK_PROPERTIES) self.WLAN_button.set_label("Wlan setup") self.WLAN_button.connect("clicked", self.wlan) self.WLAN_button.set_tooltip_text("Wlan Setup") self.toolbar2.insert(self.WLAN_button, -1) self.NET_button = Gtk.ToolButton(Gtk.STOCK_CONNECT) self.NET_button.set_label("Network setup") self.NET_button.connect("clicked", self.net) self.NET_button.set_tooltip_text("Network Setup") self.toolbar2.insert(self.NET_button, -1) self.MOUNT_button = Gtk.ToolButton(Gtk.STOCK_HARDDISK) self.MOUNT_button.set_label("Simple Mount") self.MOUNT_button.connect("clicked", self.mount) self.MOUNT_button.set_tooltip_text("Simple Mount") self.toolbar2.insert(self.MOUNT_button, -1) self.APT_button = Gtk.ToolButton(Gtk.STOCK_GO_DOWN) self.APT_button.set_label("Apt Fetcher") self.APT_button.connect("clicked", self.apt) self.APT_button.set_tooltip_text("Apt Fetcher") self.toolbar2.insert(self.APT_button, -1) self.UPDATES_button = Gtk.ToolButton(Gtk.STOCK_REFRESH) self.UPDATES_button.set_label("Updates") self.UPDATES_button.connect("clicked", self.updates) self.UPDATES_button.set_tooltip_text("Fetch Updates") self.toolbar2.insert(self.UPDATES_button, -1) self.INI_button = Gtk.ToolButton(Gtk.STOCK_APPLY) self.INI_button.set_label("Bluetooth Initialization") self.INI_button.connect("clicked", self.blue_initial) self.INI_button.set_tooltip_text("Bluetooth Initialization") self.toolbar2.insert(self.INI_button, -1) self.BLUE_button = Gtk.ToolButton(Gtk.STOCK_PREFERENCES) self.BLUE_button.set_label("Bluetooth Setup") self.BLUE_button.connect("clicked", self.blue_connect) self.BLUE_button.set_tooltip_text("Bluetooth Setup") self.toolbar2.insert(self.BLUE_button, -1) self.MIIMO_button = Gtk.ToolButton(Gtk.STOCK_OPEN) self.MIIMO_button.set_label("Miimo Tool") self.MIIMO_button.connect("clicked", self.miimo) self.MIIMO_button.set_tooltip_text("Miimo Decompress/Compress") self.toolbar2.insert(self.MIIMO_button, -1) #Terminal self.vte = Vte.Terminal() self.vte.connect("child-exited", lambda term: 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) self.vbox.pack_start(self.toolbar2, False, False, False) #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 __init__(self, callback, terminal): """The constructor.""" self._callback = callback self._terminal = terminal self._conf = Conf(CONF_FILE) #Change current path to home dir os.chdir(os.environ.get("HOME")) #GUI self.gui = Gtk.Builder() self.gui.set_translation_domain(__appname__) self.gui.add_from_file(PREF_GUI_FILE) self.gui.connect_signals(self) #### winMain #### self.winMain = self.gui.get_object("winMain") #demoTerm self.demoTerm = Vte.Terminal() self.demoTerm.set_size(20, 3) #Display something in the terminal self.demoTerm.feed(" _\|/_ zZ ❭ ") self.demoTerm.feed(" ❭ _\|/_\n\033[1G") self.demoTerm.feed(" (- -) zZ ❭ \_°< ") self.demoTerm.feed("Coin ! ❭ (O O)\n\033[1G") self.demoTerm.feed("---oOO--(_)--OOo--- ❭ ❭ ") self.demoTerm.feed("---oOO--(_)--OOo---\n\033[2J\033[1;1f") self.demoTerm.feed("[\033[40m \033[41m \033[42m \033[43m \033[44m ") self.demoTerm.feed("\033[45m \033[46m \033[47m \033[0m] ") self.demoTerm.feed("[\033[30m#\033[31m#\033[32m#\033[33m#\033[34m#") self.demoTerm.feed("\033[35m#\033[36m#\033[37m#\033[0m] ") self.demoTerm.feed("[\033[1;30m#\033[1;31m#\033[1;32m#\033[1;33m#") self.demoTerm.feed("\033[1;34m#\033[1;35m#\033[1;36m#\033[1;37m#") self.demoTerm.feed("\033[0m] [\033[0m#\033[0m\033[1m#\033[0m\033[4m#") self.demoTerm.feed("\033[0m\033[5m#\033[0m\033[7m#\033[0m]\n\033[1G") self.demoTerm.feed("CajaTerminal@Preferences:~# ") self.demoTerm.show() #General self.cbShowScrollbar = self.gui.get_object("cbShowScrollbar") self.cbStartHidden = self.gui.get_object("cbStartHidden") self.spbtnDefHeight = self.gui.get_object("spbtnDefHeight") self.entryCmd = self.gui.get_object("entryCmd") self.comboboxCursor = self.gui.get_object("comboboxCursor") self.lsstCursor = Gtk.ListStore(str) self.comboboxCursor.set_model(self.lsstCursor) self.cellCursor = Gtk.CellRendererText() self.comboboxCursor.pack_start(self.cellCursor, True) self.comboboxCursor.add_attribute(self.cellCursor, "text", 0) for shape in CURSOR_SHAPE: self.lsstCursor.append([shape]) #Color self.comboboxPalette = self.gui.get_object("comboboxPalette") self.lsstPalette = Gtk.ListStore(str) self.comboboxPalette.set_model(self.lsstPalette) self.cellPallette = Gtk.CellRendererText() self.comboboxPalette.pack_start(self.cellPallette, True) self.comboboxPalette.add_attribute(self.cellPallette, "text", 0) self._palette_list = [] for palette in PREDEF_PALETTE: self._palette_list.append(palette) self.lsstPalette.append([palette]) self._palette_list.append("Custom") gettext.install(__appname__) #Why it does not works whereas it was #already defined at the beginning :/ ? self.lsstPalette.append([_("Custom")]) self.clbtnFg = self.gui.get_object("clbtnFg") self.clbtnBg = self.gui.get_object("clbtnBg") self.clbtnPalette = [] for i in xrange(16): self.clbtnPalette.append(self.gui.get_object("clbtnPalette%i" % i)) self.clbtnPalette[i].connect("color-set", self.on_clbtnPalette_color_set, i) #Font self.fontbtn = self.gui.get_object("fontbtn") self.cbAllowBold = self.gui.get_object("cbAllowBold") #Folders self.rbAllFolders = self.gui.get_object("rbAllFolders") self.rbFolderList = self.gui.get_object("rbFolderList") self.btnFolderRemove = self.gui.get_object("btnRemoveFolder") self.trvFolderList = self.gui.get_object("trvFolderList") self.lsstFolderList = Gtk.ListStore(str) self.trvFolderList.set_model(self.lsstFolderList) self.columnFolderList = Gtk.TreeViewColumn( "Path", Gtk.CellRendererText(), text=0, ) self.trvFolderList.append_column(self.columnFolderList) #vboxTerm self.alTerm = self.gui.get_object("alTerm") self.alTerm.add(self.demoTerm) #### winAbout #### self.winAbout = self.gui.get_object("winAbout") self.winAbout.connect("response", self.on_winAbout_response) self.winAbout.set_version(__version__) #### filechooser #### self.filechooser = self.gui.get_object("filechooser") ## self._put_opt()
def __init__(self, root_dir, filter_out_extensions=[]): self.tmpfiles = [] # files to be deleted upon quit self.root_dir = root_dir self.filter_out_ext = filter_out_extensions ## The store will contain: ## 0. filename (str) ## 1. whether it's a directory (bool) ## 2. file size (int) ## 3. last modified (str) column_mapping = [0, 2, 3] # From user columns to model columns self.file_structure = Gtk.TreeStore(str, bool) self.populate_tree(root_dir, self.file_structure.get_iter_first()) uifile = abs_path_gui("gui.ui") wTree = Gtk.Builder() wTree.add_from_file(uifile) ## Create the treeview and link it to the model # self.w_treeview = wTree.get_widget("treeview") self.w_treeview = wTree.get_object("treeview") self.w_treeview.set_model(self.file_structure) self.srcView = GtkSource.View() self.srcBfr = self.srcView.get_buffer() srcLanguage = get_language_for_mime_type("text/x-python") #self.helpBfr = Gtk.TextBuffer() self.srcScrolledWindow = wTree.get_object("srcScrolledWindow") self.srcScrolledWindow.add(self.srcView) self.srcBfr.set_language(srcLanguage) self.srcBfr.set_highlight_syntax(True) self.srcView.set_buffer(self.srcBfr) self.srcView.set_show_line_numbers(True) context = self.srcView.get_pango_context() font = context.get_font_description() font.set_size(int(font.get_size() * 1.5)) self.srcView.modify_font(font) #self.srcView.set_editable(False) self.srcView.show() self.terminalScrolledWindow = wTree.get_object( "terminalScrolledWindow") self.terminal_expander = wTree.get_object("terminalexpander") self.terminal = Vte.Terminal() self.terminalScrolledWindow.add(self.terminal) self.terminal.show() #self.helpView = wTree.get_widget("helpView") #self.helpView.set_buffer(self.helpBfr) self.srcBfr.set_text( "#Python Code Browser: Select a python program from the left panel" ) self.btnExecute = wTree.get_object("btnExecute") self.btnSaveas = wTree.get_object("btnSaveas") self.tbtnExecute = wTree.get_object("tbtnExecute") self.tbtnSaveas = wTree.get_object("tbtnSaveas") dic = { "on_frm_treeview_delete_event": self.quit, "quit_clicked": self.quit, "execute_clicked": self.open_file, "on_treeview_cursor_changed": self.disp_details, "saveas_clicked": self.save_as, "about_clicked": self.about } wTree.connect_signals(dic) ## Create the columns to view the contents self.columns = [Gtk.TreeViewColumn(title) for title in ['Filename']] self.w_cell = Gtk.CellRendererText() self.w_cell.set_property("xalign", 0) for i, column in enumerate(self.columns): self.w_treeview.append_column(column) column.set_property("resizable", True) column.pack_end(self.w_cell, True) column.add_attribute(self.w_cell, 'text', column_mapping[i]) ## Create a cell-renderer that displays a little directory or ## document icon depending on the file type self.w_cellpix = Gtk.CellRendererPixbuf() self.w_cellpix.set_property("xpad", 8) self.w_cellpix.set_property("xalign", 0) def pix_format_func(treeviewcolumn, cell, model, iter, dummyParam): if model.get(iter, 1)[0]: cell.set_property("stock-id", Gtk.STOCK_DIRECTORY) else: cell.set_property("stock-id", Gtk.STOCK_ABOUT) self.columns[0].pack_start(self.w_cellpix, expand=True) self.columns[0].set_cell_data_func(self.w_cellpix, pix_format_func)
def __init__(self, application): """ :param application: The application instance to which this window belongs. :type application: :py:class:`.KingPhisherClientApplication` """ utilities.assert_arg_type(application, Gtk.Application, arg_pos=1) self.application = application self.logger = logging.getLogger('KingPhisher.Client.' + self.__class__.__name__) if not has_vte: gui_utilities.show_dialog_error( 'RPC Terminal Is Unavailable', self.application.get_active_window(), 'VTE is not installed') return config = application.config self.terminal = Vte.Terminal() self.rpc_window = RPCTerminalAppWindow(self.terminal, self.application) rpc = self.application.rpc config = { 'campaign_id': config['campaign_id'], 'campaign_name': config['campaign_name'], 'rpc_data': { 'address': (rpc.host, rpc.port), 'use_ssl': rpc.use_ssl, 'username': rpc.username, 'uri_base': rpc.uri_base, 'headers': rpc.headers }, 'user_data_path': self.application.user_data_path, 'user_library_path': self.application.user_library_path } module_path = os.path.dirname(client_rpc.__file__) + ( (os.path.sep + '..') * client_rpc.__name__.count('.')) module_path = os.path.normpath(module_path) python_command = [ "import {0}".format(client_rpc.__name__), "{0}.vte_child_routine('{1}')".format( client_rpc.__name__, serializers.JSON.dumps(config, pretty=False)) ] python_command = '; '.join(python_command) if hasattr(self.terminal, 'pty_new_sync'): # Vte._version >= 2.91 vte_pty = self.terminal.pty_new_sync(Vte.PtyFlags.DEFAULT) self.terminal.set_pty(vte_pty) self.terminal.connect( 'child-exited', lambda vt, status: self.rpc_window.window.destroy()) else: # Vte._version <= 2.90 vte_pty = self.terminal.pty_new(Vte.PtyFlags.DEFAULT) self.terminal.set_pty_object(vte_pty) self.terminal.connect('child-exited', lambda vt: self.rpc_window.window.destroy()) child_pid, _, _, _ = GLib.spawn_async( working_directory=os.getcwd(), argv=[sys.executable, '-c', python_command], envp=[ find.ENV_VAR + '=' + os.environ[find.ENV_VAR], 'DISPLAY=' + os.environ['DISPLAY'], 'PATH=' + os.environ['PATH'], 'PYTHONDONTWRITEBYTECODE=x', 'PYTHONPATH=' + module_path, 'TERM=' + os.environ.get('TERM', 'xterm') ], flags=(GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD), child_setup=self._child_setup, user_data=vte_pty) self.logger.info( "vte spawned child process with pid: {0}".format(child_pid)) self.child_pid = child_pid self.terminal.watch_child(child_pid) GLib.spawn_close_pid(child_pid) self.rpc_window.window.show_all() self.rpc_window.child_pid = child_pid return
def __init__(self, uri, window): """The constructor.""" self._window = window self._path = self._uri_to_path(uri) #Term self.shell_pid = -1 self.term = Vte.Terminal() settings.bind("audible-bell", self.term, "audible-bell", Gio.SettingsBindFlags.GET) self.shell_pid = self.term.spawn_sync(Vte.PtyFlags.DEFAULT, self._path, [terminal_or_default()], None, GLib.SpawnFlags.SEARCH_PATH, None, None, None)[1] # Make vte.sh active #vte_current_dir_script = ". /etc/profile.d/vte.sh ; clear" #self.term.feed_child(vte_current_dir_script, len(vte_current_dir_script)) self.term.connect_after("child-exited", self._on_term_child_exited) self.term.connect_after("popup-menu", self._on_term_popup_menu) self.term.connect("button-press-event", self._on_term_popup_menu) #Accelerators accel_group = Gtk.AccelGroup() self._window.add_accel_group(accel_group) self.term.add_accelerator( "paste-clipboard", accel_group, ord("V"), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE) self.term.add_accelerator( "copy-clipboard", accel_group, ord("C"), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE) #Drag & Drop self.term.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY, ) self.term.drag_dest_add_uri_targets() self.term.connect("drag_data_received", self._on_drag_data_received) # Container self.vscrollbar = Gtk.VScrollbar.new(self.term.get_vadjustment()) self.hbox = Gtk.HBox() self.hbox.pack_start(self.term, True, True, 0) self.hbox.pack_end(self.vscrollbar, False, False, 0) self.hbox.nt = self # store a reference to this obj #Popup Menu self.menu = Gtk.Menu() #MenuItem => copy menu_item = Gtk.ImageMenuItem.new_from_stock("gtk-copy", None) menu_item.connect_after("activate", lambda w: self.term.copy_clipboard()) self.menu.add(menu_item) #MenuItem => paste menu_item = Gtk.ImageMenuItem.new_from_stock("gtk-paste", None) menu_item.connect_after("activate", lambda w: self.term.paste_clipboard()) self.menu.add(menu_item) #MenuItem => paste filenames (only added if URI types on clipboard) menu_item_pastefilenames = \ Gtk.ImageMenuItem.new_from_stock("gtk-paste", None) menu_item_pastefilenames.connect_after("activate", lambda w: self._paste_filenames_clipboard()) menu_item_pastefilenames.set_label(_("Paste Filenames")) self.menu_item_pastefilenames = menu_item_pastefilenames self.menu.add(menu_item_pastefilenames) #MenuItem => separator #TODO: Implement the preferences window #menu_item = Gtk.SeparatorMenuItem() #self.menu.add(menu_item) #MenuItem => preferences #menu_item = Gtk.ImageMenuItem.new_from_stock("gtk-preferences", None) #self.menu.add(menu_item) #MenuItem => separator #menu_item = Gtk.SeparatorMenuItem() #self.menu.add(menu_item) #MenuItem => Goto current terminal directory #menu_item = Gtk.MenuItem.new_with_label(_("Goto current terminal directory")) #menu_item.connect_after("activate", # lambda w: self._goto_current_terminal_directory()) #self.menu.add(menu_item) #MenuItem => separator menu_item = Gtk.SeparatorMenuItem() self.menu.add(menu_item) #MenuItem => About menu_item = Gtk.ImageMenuItem.new_from_stock("gtk-about", None) menu_item.connect_after("activate", lambda w: self.show_about_dialog()) self.menu.add(menu_item) self.menu.show_all() self._set_term_height(settings.get_int("default-terminal-height")) self._visible = True #Lock self._respawn_lock = False #Register the callback for show/hide if hasattr(window, "toggle_hide_cb"): window.toggle_hide_cb.append(self.set_visible)
def details_enable(self): self._details_widget = Vte.Terminal() self.widget("details-box").add(self._details_widget) self._details_widget.set_visible(True) self.widget("details").set_visible(True)
def _create_tab(self, tab_state): vt = Vte.Terminal() vt.connect("child-exited", self.__tab_child_exited_cb) vt.connect("window-title-changed", self.__tab_title_changed_cb) vt.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.DROP, [ Gtk.TargetEntry.new('text/plain', 0, 0), Gtk.TargetEntry.new('STRING', 0, 1) ], Gdk.DragAction.DEFAULT | Gdk.DragAction.COPY) vt.drag_dest_add_text_targets() vt.connect('drag_data_received', self.__drag_data_received_cb) self._configure_vt(vt) vt.show() scrollbar = Gtk.VScrollbar.new(vt.get_vadjustment()) box = Gtk.HBox() box.pack_start(vt, True, True, 0) box.pack_start(scrollbar, False, True, 0) box.vt = vt box.show() tablabel = TabLabel(box) tablabel.connect('tab-close', self.__close_tab_cb) tablabel.update_size(200) box.label = tablabel index = self._notebook.append_page(box, tablabel) tablabel.show_all() # Uncomment this to only show the tab bar when there is at least # one tab. I think it's useful to always see it, since it displays # the 'window title'. # self._notebook.props.show_tabs = self._notebook.get_n_pages() > 1 if self._notebook.get_n_pages() == 1: tablabel.hide_close_button() if self._notebook.get_n_pages() == 2: self._notebook.get_tab_label( self._notebook.get_nth_page(0)).show_close_button() self._notebook.show_all() # Launch the default shell in the HOME directory. os.chdir(os.environ["HOME"]) if tab_state: # Restore the environment. # This is currently not enabled. environment = tab_state['env'] filtered_env = [] for e in environment: var, sep, value = e.partition('=') if var not in MASKED_ENVIRONMENT: filtered_env.append(var + sep + value) # TODO: Make the shell restore these environment variables, # then clear out TERMINAL_ENV. # os.environ['TERMINAL_ENV'] = '\n'.join(filtered_env) # Restore the working directory. if 'cwd' in tab_state and os.path.exists(tab_state['cwd']): try: os.chdir(tab_state['cwd']) except: # ACLs may deny access sys.stdout.write("Could not chdir to " + tab_state['cwd']) if 'font_size' in tab_state: font_desc = vt.get_font() font_desc.set_size(tab_state['font_size']) vt.set_font(font_desc) # Restore the scrollback buffer. for l in tab_state['scrollback']: vt.feed(str(l) + '\r\n') shell_cmd = os.environ.get('SHELL') or '/bin/bash' if hasattr(vt, 'fork_command_full'): sucess_, box.pid = vt.fork_command_full( Vte.PtyFlags.DEFAULT, os.environ["HOME"], [shell_cmd], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) else: sucess_, box.pid = vt.spawn_sync(Vte.PtyFlags.DEFAULT, os.environ["HOME"], [shell_cmd], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) self._notebook.props.page = index vt.grab_focus() return index
def __init__(self, config, parent, application): """ :param dict config: The King Phisher client configuration. :param parent: The parent window for this object. :type parent: :py:class:`Gtk.Window` :param application: The application instance to which this window belongs. :type application: :py:class:`.KingPhisherClientApplication` """ assert isinstance(application, Gtk.Application) self.config = config self.parent = parent self.application = application self.logger = logging.getLogger('KingPhisher.Client.' + self.__class__.__name__) if not has_vte: gui_utilities.show_dialog_error('RPC Terminal Is Unavailable', parent, 'VTE is not installed') return self.window = Gtk.ApplicationWindow(application=application) self.window.set_property('title', 'King Phisher RPC') self.window.set_transient_for(parent) self.window.set_destroy_with_parent(True) self.window.connect('destroy', self.signal_window_destroy) self.terminal = Vte.Terminal() self.terminal.set_property('rewrap-on-resize', True) self.terminal.set_scroll_on_keystroke(True) vbox = Gtk.VBox() self.window.add(vbox) vbox.pack_end(self.terminal, True, True, 0) action_group = Gtk.ActionGroup("rpc_terminal_window_actions") self._add_menu_actions(action_group) uimanager = self._create_ui_manager() uimanager.insert_action_group(action_group) menubar = uimanager.get_widget("/MenuBar") vbox.pack_start(menubar, False, False, 0) rpc = self.parent.rpc config = {} config['campaign_id'] = self.config['campaign_id'] config['campaign_name'] = self.config['campaign_name'] config['rpc_data'] = { 'address': (rpc.host, rpc.port), 'use_ssl': rpc.use_ssl, 'username': rpc.username, 'uri_base': rpc.uri_base, 'hmac_key': rpc.hmac_key, } module_path = os.path.dirname(client_rpc.__file__) + ((os.path.sep + '..') * client_rpc.__name__.count('.')) module_path = os.path.normpath(module_path) python_command = [ "import {0}".format(client_rpc.__name__), "{0}.vte_child_routine('{1}')".format(client_rpc.__name__, json.dumps(config)) ] python_command = '; '.join(python_command) if hasattr(self.terminal, 'pty_new_sync'): # Vte._version >= 2.91 vte_pty = self.terminal.pty_new_sync(Vte.PtyFlags.DEFAULT) self.terminal.set_pty(vte_pty) self.terminal.connect('child-exited', lambda vt, status: self.window.destroy()) else: # Vte._version <= 2.90 vte_pty = self.terminal.pty_new(Vte.PtyFlags.DEFAULT) self.terminal.set_pty_object(vte_pty) self.terminal.connect('child-exited', lambda vt: self.window.destroy()) child_pid, _, _, _ = GLib.spawn_async( working_directory=os.getcwd(), argv=[utilities.which('python'), '-c', python_command], envp=['PYTHONPATH=' + module_path], flags=(GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD), child_setup=self._child_setup, user_data=vte_pty ) self.logger.info("vte spawned child process with pid: {0}".format(child_pid)) self.child_pid = child_pid self.terminal.watch_child(child_pid) GLib.spawn_close_pid(child_pid) self.window.show_all() # automatically enter the password vte_pty_fd = vte_pty.get_fd() if len(select.select([vte_pty_fd], [], [], 1)[0]): os.write(vte_pty_fd, rpc.password + '\n') return
def __init__(self): Gtk.Window.__init__(self) self.channel = implementations.insecure_channel('localhost', 60000) self.stub = gui_pb2.beta_create_ControllerView_stub(self.channel) self.connect("delete-event", Gtk.main_quit) self.set_title("Superposition 1") self.resize(800, 600) self.daQubits = [self.registerSize] self.ePolarizations = [self.registerSize] self.bPolarize = [self.registerSize] self.bMeasure = [self.registerSize] self.polarizations = [0.0, 0.0, 0.0, 0.0] self.measurementAngles = [0.0, 0.0, 0.0, 0.0] cVLauncher = Gtk.VBox() cHLauncher = Gtk.HBox() cHLauncher.set_size_request(700, 30) cHdaQubits = Gtk.HBox() cHdaQubits.set_size_request(800, 100) cVLauncher.pack_start(cHLauncher, True, False, 0) cVLauncher.pack_start(cHdaQubits, True, False, 0) for i in range(self.registerSize): self.daQubits.insert(i, Gtk.DrawingArea()) self.daQubits[i].set_size_request(200, 150) self.daQubits[i].connect("draw", self.expose, i) cHdaQubits.pack_start(self.daQubits[i], True, False, 0) for i in range(self.registerSize): self.ePolarizations.insert(i, Gtk.Entry()) self.ePolarizations[i].set_text(str(self.polarizations[i])) self.ePolarizations[i].set_width_chars(5) # self.ePolarizations[i].connect("draw", self.updateDaQubits, i) self.bPolarize.insert(i, Gtk.Button()) self.bPolarize[i].set_label("Polarize") self.bPolarize[i].connect("clicked", self.bPolarize_exec, i) self.bMeasure.insert(i, Gtk.Button()) self.bMeasure[i].set_label("Measure") self.bMeasure[i].connect("clicked", self.bMeasure_exec, i) cHLauncher.pack_start(self.ePolarizations[i], True, False, 0) cHLauncher.pack_start(self.bPolarize[i], True, False, 0) cHLauncher.pack_start(self.bMeasure[i], True, False, 0) self.daRegister = Gtk.DrawingArea() self.daRegister.set_size_request(800, 100) self.daRegister.connect("draw", self.exposeRegister) cVLauncher.pack_start(self.daRegister, True, False, 0) self.vt = Vte.Terminal() self.vt.set_size_request(800, 400) self.vt.fork_command_full( Vte.PtyFlags.DEFAULT, os.environ['PWD'], ["/bin/bash"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None, ) command = "./superpositionController\r\n" self.vt.feed_child(command, len(command)) cVLauncher.pack_start(self.vt, True, True, 0) self.add(cVLauncher) self.show_all() time.sleep(1) self.initDone = 1
def reconfigure(self): """Update configuration for the whole application""" if self.style_providers != []: for style_provider in self.style_providers: Gtk.StyleContext.remove_provider_for_screen( Gdk.Screen.get_default(), style_provider) self.style_providers = [] # Force the window background to be transparent for newer versions of # GTK3. We then have to fix all the widget backgrounds because the # widgets theming may not render it's own background. css = """ .terminator-terminal-window { background-color: alpha(@theme_bg_color,0); } .terminator-terminal-window .notebook.header, .terminator-terminal-window notebook header { background-color: @theme_bg_color; } .terminator-terminal-window .pane-separator { background-color: @theme_bg_color; } .terminator-terminal-window .terminator-terminal-searchbar { background-color: @theme_bg_color; } """ # Fix several themes that put a borders, corners, or backgrounds around # viewports, making the titlebar look bad. css += """ .terminator-terminal-window GtkViewport, .terminator-terminal-window viewport { border-width: 0px; border-radius: 0px; background-color: transparent; } """ # Add per profile snippets for setting the background of the HBox template = """ .terminator-profile-%s { background-color: alpha(%s, %s); } """ profiles = self.config.base.profiles for profile in list(profiles.keys()): if profiles[profile]['use_theme_colors']: # Create a dummy window/vte and realise it so it has correct # values to read from tmp_win = Gtk.Window() tmp_vte = Vte.Terminal() tmp_win.add(tmp_vte) tmp_win.realize() bgcolor = tmp_vte.get_style_context().get_background_color(Gtk.StateType.NORMAL) bgcolor = "#{0:02x}{1:02x}{2:02x}".format(int(bgcolor.red * 255), int(bgcolor.green * 255), int(bgcolor.blue * 255)) tmp_win.remove(tmp_vte) del(tmp_vte) del(tmp_win) else: bgcolor = Gdk.RGBA() bgcolor = profiles[profile]['background_color'] if profiles[profile]['background_type'] == 'transparent': bgalpha = profiles[profile]['background_darkness'] else: bgalpha = "1" munged_profile = "".join([c if c.isalnum() else "-" for c in profile]) css += template % (munged_profile, bgcolor, bgalpha) style_provider = Gtk.CssProvider() style_provider.load_from_data(css.encode('utf-8')) self.style_providers.append(style_provider) # Attempt to load some theme specific stylistic tweaks for appearances usr_theme_dir = os.path.expanduser('~/.local/share/themes') (head, _tail) = os.path.split(borg.__file__) app_theme_dir = os.path.join(head, 'themes') theme_name = self.gtk_settings.get_property('gtk-theme-name') theme_part_list = ['terminator.css'] if self.config['extra_styling']: # checkbox_style - needs adding to prefs theme_part_list.append('terminator_styling.css') for theme_part_file in theme_part_list: for theme_dir in [usr_theme_dir, app_theme_dir]: path_to_theme_specific_css = os.path.join(theme_dir, theme_name, 'gtk-3.0/apps', theme_part_file) if os.path.isfile(path_to_theme_specific_css): style_provider = Gtk.CssProvider() style_provider.connect('parsing-error', self.on_css_parsing_error) try: style_provider.load_from_path(path_to_theme_specific_css) except GError: # Hmmm. Should we try to provide GTK version specific files here on failure? gtk_version_string = '.'.join([str(Gtk.get_major_version()), str(Gtk.get_minor_version()), str(Gtk.get_micro_version())]) err('Error(s) loading css from %s into Gtk %s' % (path_to_theme_specific_css, gtk_version_string)) self.style_providers.append(style_provider) break # Size the GtkPaned splitter handle size. css = "" if self.config['handle_size'] in range(0, 21): css += """ .terminator-terminal-window GtkPaned, .terminator-terminal-window paned { -GtkPaned-handle-size: %s; } """ % self.config['handle_size'] style_provider = Gtk.CssProvider() style_provider.load_from_data(css.encode('utf-8')) self.style_providers.append(style_provider) # Apply the providers, incrementing priority so they don't cancel out # each other for idx in range(0, len(self.style_providers)): Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_providers[idx], Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION+idx) # Cause all the terminals to reconfigure for terminal in self.terminals: terminal.reconfigure() # Reparse our keybindings self.keybindings.configure(self.config['keybindings']) # Update tab position if appropriate maker = Factory() for window in self.windows: child = window.get_child() if maker.isinstance(child, 'Notebook'): child.configure()
def addPage(self,textBuffer,pageTitle): print "INSIDE_ADD_PAGE" caption=_("Untitled"+str(self.counter)) #add hbox self.hbox=Gtk.HBox(); self.hbox.show(); #create text_buffer self.sourceBuffer= GtkSource.Buffer() #add textview self.textview=GtkSource.View() self.textview.set_buffer(self.sourceBuffer) self.textview.set_show_line_numbers(True) self.textview.set_show_line_marks(True) self.textview.set_size_request(250,400) self.setLanguage(self.textview) #check for textBuffer passed as param if textBuffer!=None: #set the textbuffer data to editor start, end = textBuffer.get_bounds() self.sourceBuffer.set_text(textBuffer.get_text(start, end, True)) #add vpane self.vpane=Gtk.VPaned(); #add scroll to text view self.scroll=Gtk.ScrolledWindow(); self.scroll.set_policy(Gtk.PolicyType.NEVER,Gtk.PolicyType.AUTOMATIC); self.scroll.add_with_viewport(self.textview) self.scroll.set_size_request(250,400) self.scroll.show() self.vpane.add(self.scroll) #add scroll to text view self.opScroll= Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) #create Vte Terminal self.vteObject=Vte.Terminal() self.opScroll.pack_start(self.vteObject, True, True, 0) self.outsb = Gtk.Scrollbar(orientation=Gtk.Orientation.VERTICAL) self.outsb.set_adjustment(self.vteObject.get_vadjustment()) self.outsb.show() self.opScroll.pack_start(self.outsb, False, False, 0) self.vteObject.set_colors(Gdk.color_parse('#000000'),Gdk.color_parse('#E7E7E7'),[]) self.vteObject.set_size_request(200,200) self.vteObject.show() #self.opScroll.set_size_request(250,200) self.opScroll.show() print "VTE_KARTIK:",self.vteObject.get_vadjustment() self.vpane.add(self.opScroll) self.vpane.show() self.hbox.pack_start(self.vpane,True,True,0) self.textview.show() #attach text-change listener for buffer self.attachTextChangedListener(self.hbox) self.hbox.set_size_request(250, 300) #if pageTitle is none then give a Untitled caption if pageTitle==None: self.newlabel=Label(caption) else: self.newlabel=Label(pageTitle) #self.newlabel.set_size_request(75,30) self.resizeLabel(self.newlabel) self.newlabel.show() self.notebook.append_page(self.hbox,self.newlabel) #assigning notebook page for the filename #self.pageMap[self.newlabel.get_text()]=self.hbox self.addPageToPageMap(self.newlabel.get_text(),self.hbox) self.counter=self.counter+1 print "Curr :",self.pageMap self.selectFileNamePage(self.newlabel.get_text())