Esiste un comando in Gnome-Terminal o una shell tabbable per aprire una nuova scheda?


11

Non sto cercando una scorciatoia da tastiera, piuttosto voglio un comando per:

  • Nuova finestra
  • Nuova scheda
  • Chiudi la scheda o la finestra corrente
  • Massimizza la finestra della shell
  • Riduci a icona la finestra Shell
  • Sposta Shell in un diverso spazio di lavoro
  • Cambia scheda

E praticamente niente del genere. Ricorda; Non voglio scorciatoie, ma piuttosto comandi reali. Il motivo è che posso utilizzare la funzionalità alias.


1
Python ti sta bene?
Sergiy Kolodyazhnyy,

4
"Chiudi la scheda corrente": questo comando si chiama "exit": D
egmont,

"Non voglio scorciatoie [...] per poter utilizzare la funzionalità alias" - potresti approfondire per favore? Qual è il vantaggio esatto che speri invece delle note scorciatoie? Qual è il problema o la funzionalità mancante nelle scorciatoie? Penso che siano l'approccio giusto per quello che stai cercando.
egmont,

@egmont Sono un drogato di Vim, se questo ha un senso.
Akiva,

Quindi, diciamo, ad esempio, per Maximize, invece di avere un tasto di scelta rapida per il gestore delle finestre che funziona per tutti i tipi di finestre (browser, editor di immagini, elaboratore di testi, ecc.) In tutti gli stati (vale a dire qualunque cosa tu stia facendo al loro interno), " preferirei avere un comando che funziona solo per il terminale e nessun'altra app, e solo se al suo interno non è in esecuzione alcun comando (a parte la shell predefinita, ovviamente). No, scusa, questa idea non ha ancora molto senso per me :(
egmont,

Risposte:


14

Non puoi farlo di default in Gnome-Terminal, almeno con comandi non elaborati.

Tuttavia, è possibile scrivere script che richiamano le scorciatoie da tastiera che possono eseguire questa operazione. Si noti che è necessario xdotoolper questo:sudo apt install xdotool

  • Nuova finestra : avvia una nuova finestra del terminale con nw
    Possiamo farlo solo con gnome-terminal.
    Aggiungi a.bashrc :

    echo "alias nw=gnome-terminal" >> ~/.bashrc
  • Nuova scheda : avvia una nuova scheda con nt
    Possiamo farlo con xdotool getactivewindow $(xdotool key ctrl+shift+t)
    Aggiungi a.bashrc :

    echo "alias nt='xdotool getactivewindow $(xdotool key ctrl+shift+t)'" >> .bashrc
  • Chiudi scheda : consente di chiudere ct
    xdotoolnuovamente la scheda o la finestra corrente con gli avvertimenti: xdotool getactivewindow $(xdotool key ctrl+shift+w)
    Aggiungi a.bashrc :

    echo "alias ct='xdotool getactivewindow $(xdotool key ctrl+shift+w)'" >> .bashrc
  • Massimizza finestra : Massimizza l'intera finestra con maw
    Possiamo usare wmctrlqui: wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
    Aggiungi a.bashrc :

    echo "alias maw='wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz'" >> .bashrc
  • Riduci a icona la finestra : Riduci a icona l'intera finestra con miw
    Possiamo usare di xdotoolnuovo: xdotool windowminimize $(xdotool getactivewindow)
    Aggiungi a.bashrc :

    echo "alias miw='xdotool windowminimize $(xdotool getactivewindow)'" >> .bashrc
  • Sposta nell'area di lavoro : sposta una finestra in un'altra area di lavoro con mtw <id>
    Questo sarebbe appena possibile nello scripting della shell ed è ben oltre la mia esperienza personale. Consiglierei di usare la sceneggiatura di Serg per questo scopo, perché attualmente funziona davvero. Ah, i vantaggi di Compiz.


7

introduzione

Lo script presentato in questa risposta consente all'utente di controllare la finestra del terminale tramite un singolo comando e un elenco di opzioni. È semplice da usare e compatibile con qualsiasi emulatore di terminale che abbia combinazioni di tasti simili a gnome-terminal. Le opzioni di spostamento possono essere utilizzate anche con altri terminali, ma l'apertura di schede non è garantita per tali terminali.

Lo script copre l'apertura della scheda, l'apertura della finestra, lo spostamento verso l'area di lavoro verso il basso, l'area di lavoro verso destra, l'area di lavoro specifica a cui si riferisce il numero intero, minimizzando, massimizzando e non ingrandendo una finestra. L'unica cosa che lo script non copre è la chiusura di tab / window semplicemente perché ogni emulatore di shell / terminale ha già un comando per esso - exito in alternativa tramite CtrlDcollegamento.

!!! NOTA: sarà necessario xdotoolcambiare area di lavoro e aprire le schede. Installalo tramite sudo apt-get install xdotool. Se preferisci non installare pacchetti extra, tieni presente che l'area di lavoro e il cambio di tab non funzioneranno , ma altre opzioni lo faranno.

Uso:

Tutti gli argomenti windowctrl.pysono facoltativi, quindi possono essere utilizzati separatamente o potenzialmente insieme. Come mostrato -hdall'opzione.

$ ./windowctrl.py -h                                                                               
usage: windowctrl.py [-h] [-w] [-t] [-m] [-M] [-u] [-v VIEWPORT] [-r] [-d]

Copyright 2016. Sergiy Kolodyazhnyy.

    Window control for terminal emulators. Originally written
    for gnome-terminal under Ubuntu with Unity desktop but can 
    be used with any other terminal emulator that conforms to 
    gnome-terminal keybindings. It can potentially be used for 
    controlling other windows as well via binding this script
    to a keyboard shortcut.

    Note that --viewport and --tab options require xdotool to be
    installed on the system. If you don't have it installed, you 
    can still use the other options. xdotool can be installed via
    sudo apt-get install xdotool.


optional arguments:
  -h, --help            show this help message and exit
  -w, --window          spawns new window
  -t, --tab             spawns new tab
  -m, --minimize        minimizes current window
  -M, --maximize        maximizes window
  -u, --unmaximize      unmaximizes window
  -v VIEWPORT, --viewport VIEWPORT
                        send window to workspace number
  -r, --right           send window to workspace right
  -d, --down            send window to workspace down

Codice sorgente dello script:

Il codice sorgente dello script è disponibile su GitHub e anche qui. È probabile che le ultime modifiche vadano nel GitHub piuttosto che qui, quindi consiglio vivamente di controllare l'ultima versione lì. Si suggerisce inoltre di pubblicare anche segnalazioni di bug.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Program name: windowctrl.py
Author: Sergiy Kolodyazhnyy
Date:  Sept 18, 2016
Written for: http://askubuntu.com/q/826310/295286
Tested on Ubuntu 16.04 LTS
"""
from __future__ import print_function
import gi
gi.require_version('Gdk', '3.0')
from gi.repository import Gio,Gdk
import sys
import dbus
import subprocess
import argparse

def gsettings_get(schema,path,key):
    """Get value of gsettings schema"""
    if path is None:
        gsettings = Gio.Settings.new(schema)
    else:
        gsettings = Gio.Settings.new_with_path(schema,path)
    return gsettings.get_value(key)

def run_cmd(cmdlist):
    """ Reusable function for running shell commands"""
    try:
        stdout = subprocess.check_output(cmdlist)
    except subprocess.CalledProcessError:
        print(">>> subprocess:",cmdlist)
        sys.exit(1)
    else:
        if stdout:
            return stdout

def get_dbus(bus_type,obj,path,interface,method,arg):
    # Reusable function for accessing dbus
    # This basically works the same as 
    # dbus-send or qdbus. Just give it
    # all the info, and it will spit out output
    if bus_type == "session":
        bus = dbus.SessionBus() 
    if bus_type == "system":
        bus = dbus.SystemBus()
    proxy = bus.get_object(obj,path)
    method = proxy.get_dbus_method(method,interface)
    if arg:
        return method(arg)
    else:
        return method() 

def new_window():
    screen = Gdk.Screen.get_default()
    active_xid = int(screen.get_active_window().get_xid())
    app_path = get_dbus( 'session',
                         'org.ayatana.bamf',
                         '/org/ayatana/bamf/matcher',
                         'org.ayatana.bamf.matcher',
                         'ApplicationForXid',
                         active_xid
                         )

    desk_file  = get_dbus('session',
                          'org.ayatana.bamf',
                          str(app_path),
                          'org.ayatana.bamf.application',
                          'DesktopFile',
                          None
                          )

    # Big credit to Six: http://askubuntu.com/a/664272/295286
    Gio.DesktopAppInfo.new_from_filename(desk_file).launch_uris(None)



def enumerate_viewports():
    """ generates enumerated dictionary of viewports and their
        indexes, counting left to right """
    schema="org.compiz.core"
    path="/org/compiz/profiles/unity/plugins/core/"
    keys=['hsize','vsize']
    screen = Gdk.Screen.get_default()
    screen_size=[ screen.get_width(),screen.get_height()]
    grid=[ int(str(gsettings_get(schema,path,key))) for key in keys]
    x_vals=[ screen_size[0]*x for x in range(0,grid[0]) ]
    y_vals=[screen_size[1]*x for x in range(0,grid[1]) ]

    viewports=[(x,y)  for y in y_vals for x in x_vals ]

    return {vp:ix for ix,vp in enumerate(viewports,1)}


def get_current_viewport():
    """returns tuple representing current viewport, 
       in format (width,height)"""
    vp_string = run_cmd(['xprop', '-root', 
                         '-notype', '_NET_DESKTOP_VIEWPORT'])
    vp_list=vp_string.decode().strip().split('=')[1].split(',')
    return tuple( int(i)  for i in vp_list )

def maximize():

    screen = Gdk.Screen.get_default()
    window = screen.get_active_window()
    window.maximize()
    screen.get_active_window()
    window.process_all_updates()

def unmaximize():

    screen = Gdk.Screen.get_default()
    window = screen.get_active_window()
    window.unmaximize()
    screen.get_active_window()
    window.process_all_updates()

def minimize():

    screen = Gdk.Screen.get_default()
    window = screen.get_active_window()
    window.iconify()
    window.process_all_updates()

def window_move(viewport):

    # 1. grab window object
    # 2. jump viewport 0 0 so we can move only
    #    in positive plane
    # 3. move the window.
    # 4. set viewport back to what it was

    # Step 1
    screen = Gdk.Screen.get_default()
    screen_size=[ screen.get_width(),screen.get_height()]
    window = screen.get_active_window()

    viewports = enumerate_viewports()
    current = get_current_viewport()
    current_num = viewports[current]
    destination = [ 
                   key for  key,val in viewports.items() 
                   if val == int(viewport)
                   ][0]
    # Step 2.
    run_cmd([
            'xdotool',
            'set_desktop_viewport',
            '0','0'
            ]) 
    # Step 3.
    window.move(destination[0],destination[1])
    window.process_all_updates()

    run_cmd([
            'xdotool',
            'set_desktop_viewport',
            str(current[0]),
            str(current[1])
            ]) 

def move_right():
    sc = Gdk.Screen.get_default()
    width = sc.get_width()
    win = sc.get_active_window()
    pos = win.get_origin()
    win.move(width,pos.y)
    win.process_all_updates()

def move_down():
    sc = Gdk.Screen.get_default()
    height = sc.get_height()
    win = sc.get_active_window()
    pos = win.get_origin()
    win.move(pos.x,height)
    win.process_all_updates()

def new_tab():
    run_cmd(['xdotool','key','ctrl+shift+t'])

def parse_args():
    """ Parse command line arguments"""

    info="""Copyright 2016. Sergiy Kolodyazhnyy.

    Window control for terminal emulators. Originally written
    for gnome-terminal under Ubuntu with Unity desktop but can 
    be used with any other terminal emulator that conforms to 
    gnome-terminal keybindings. It can potentially be used for 
    controlling other windows as well via binding this script
    to a keyboard shortcut.

    Note that --viewport and --tab options require xdotool to be
    installed on the system. If you don't have it installed, you 
    can still use the other options. xdotool can be installed via
    sudo apt-get install xdotool.
    """
    arg_parser = argparse.ArgumentParser(
                 description=info,
                 formatter_class=argparse.RawTextHelpFormatter)
    arg_parser.add_argument(
                '-w','--window', action='store_true',
                help='spawns new window',
                required=False)
    arg_parser.add_argument(
                '-t','--tab',action='store_true',
                help='spawns new tab',
                required=False)
    arg_parser.add_argument(
                '-m','--minimize',action='store_true',
                help='minimizes current window',
                required=False)
    arg_parser.add_argument(
                '-M','--maximize',action='store_true',
                help='maximizes window',
                required=False)
    arg_parser.add_argument(
                '-u','--unmaximize',action='store_true',
                help='unmaximizes window',
                required=False)
    arg_parser.add_argument(
               '-v','--viewport',action='store',
               type=int, help='send window to workspace number',
               required=False)
    arg_parser.add_argument(
               '-r','--right',action='store_true',
               help='send window to workspace right',
               required=False)
    arg_parser.add_argument(
               '-d','--down',action='store_true',
               help='send window to workspace down',
               required=False)
    return arg_parser.parse_args()

def main():

    args = parse_args()

    if args.window:
       new_window()
    if args.tab:
       new_tab()
    if args.down:
       move_down()
    if args.right:
       move_right()       
    if args.viewport:
       window_move(args.viewport)
    if args.minimize:
       minimize()
    if args.maximize:
       maximize()
    if args.unmaximize:
       unmaximize()

if __name__ == '__main__':
    main()

Note a margine

  • Hai chiesto "Esiste un comando in Gnome-Terminal o una shell tabbable per aprire una nuova scheda?" Il manuale di Gnome Terminal non elenca tale opzione. Le shell sono utility da riga di comando. Le schede sono caratteristiche delle applicazioni della GUI. Esistono multiplexer terminali come screeno tmuxche possono avere "tab" o finestre divise, che in qualche modo si avvicinano alla "shell tabbable" ma questo non è lo stesso tipo di comportamento che chiedi. Fondamentalmente, la risposta alla tua domanda è "No". Ci sono sempre alternative e la mia risposta fornisce una di queste. Tratta la finestra del terminale in base alla sua natura: la finestra della GUI X11.

  • In che modo questa risposta si riferisce agli alias? Bene, prima di tutto gli alias possono essere un po 'disordinati, specialmente quando si tratta di quotare e analizzare più output da più comandi. Questo script fornisce un comando centralizzato con flag / switch per eseguire un'attività discreta su una finestra. Inoltre semplifica gli alias. Si potrebbe fare alias nw='windowctrl.py --window'. Molto più corto, molto più ordinato.


Sono contento dei terminali divisi
Akiva,

1
@Akiva vuoi che colleghi una domanda relativa alla divisione del terminale? hai provato questo script tra l'altro? cosa ne pensi ?
Sergiy Kolodyazhnyy,

Proverò la tua sceneggiatura, perché la risposta sopra mi sta dando problemi. Tuttavia, potrei non avere molta fortuna, a causa del problema principalmente con xdotool.
Akiva,

@Akiva e qual è il problema xdotool? Forse potrei ripararlo?
Sergiy Kolodyazhnyy,

Dovrò tornare da te su questo. Potrei avere a che fare con il mio layout di tastiera personalizzato, o con il fatto che sono al 16.10 o che lo sto provando in modo falso.
Akiva,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.