Existe-t-il une commande dans Gnome-Terminal ou un shell tabable pour ouvrir un nouvel onglet?

Question

Je ne cherche pas de raccourci clavier, mais des commandes pour:

• Nouvelle fenetre
• Nouvel onglet
• Fermer l'onglet ou la fenêtre en cours
• Maximiser la fenêtre shell
• Réduire la fenêtre shell
• Déplacer Shell dans un autre espace de travail
• Changer d'onglet

Et fondamentalement quelque chose comme ça. Rappelles toi; Je ne veux pas de raccourcis, mais plutôt de commandes réelles. La raison en est que je peux utiliser la fonctionnalité de pseudonyme.

Answer 1

Vous ne pouvez pas le faire par défaut dans Gnome-Terminal, du moins avec des commandes brutes.

Toutefois, vous pouvez écrire des scripts appelant des raccourcis clavier permettant de le faire. Notez que vous avez besoin de xdotool pour ceci: Sudo apt install xdotool

• Nouvelle fenêtre: Lance une nouvelle fenêtre de terminal avec nw
  Nous pouvons faire cela avec seulement gnome-terminal.
  Ajouter à .bashrc:

  echo "alias nw=gnome-terminal" >> ~/.bashrc
  

• Nouvel onglet: Lance un nouvel onglet avec nt
  Nous pouvons le faire avec xdotool getactivewindow $(xdotool key ctrl+shift+t)
  Ajouter à .bashrc:

  echo "alias nt='xdotool getactivewindow $(xdotool key ctrl+shift+t)'" >> .bashrc
  

• Close Tab: Ferme l'onglet ou la fenêtre en cours avec ct
xdotool frappe à nouveau: xdotool getactivewindow $(xdotool key ctrl+shift+w)
  Ajouter à .bashrc:

  echo "alias ct='xdotool getactivewindow $(xdotool key ctrl+shift+w)'" >> .bashrc
  

• Agrandir la fenêtre: Agrandit la fenêtre entière avec maw
  On peut utiliser wmctrl ici: wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
  Ajouter à .bashrc:

  echo "alias maw='wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz'" >> .bashrc
  

• Minimize Window: Minimise la fenêtre entière avec miw
  On peut utiliser xdotool à nouveau: xdotool windowminimize $(xdotool getactivewindow)
  Ajouter à .bashrc:

  echo "alias miw='xdotool windowminimize $(xdotool getactivewindow)'" >> .bashrc
  

• Move to Workspace: déplace une fenêtre vers un autre espace de travail avec mtw <id>
  Cela serait juste à peine possible dans les scripts Shell, et dépasse de loin mon expérience personnelle. Je recommanderais d'utiliser le script de Serg à cette fin, car il fonctionne actuellement. Ah, les avantages de Compiz.

Answer 2

Introduction

Le script présenté dans cette réponse permet à l’utilisateur de contrôler la fenêtre de son terminal au moyen d’une seule commande et d’une liste d’options. Il est simple à utiliser et compatible avec tout émulateur de terminal ayant des liaisons de clé similaires à gnome-terminal. Les options de déplacement peuvent également être utilisées avec d'autres terminaux, mais l'ouverture des onglets n'est pas garantie pour ces terminaux.

Le script couvre l'ouverture des onglets, l'ouverture de la fenêtre, le déplacement vers l'espace de travail, l'espace de travail à droite, l'espace de travail spécifique référencé par un nombre entier, la réduction, l'optimisation et la maximisation d'une fenêtre. La seule chose que le script ne couvre pas est la fermeture de l'onglet/fenêtre simplement parce que chaque émulateur Shell/terminal a déjà une commande pour lui - exit ou alternativement via CtrlD raccourci.

!!! NOTE: vous aurez besoin de xdotool pour la commutation d'espace de travail et l'ouverture de tabulation. Installez-le via Sudo apt-get install xdotool. Si vous préférez ne pas installer de paquet supplémentaire, gardez à l'esprit que la commutation d'espace de travail et de tabulation ne fonctionnera pas , mais que d'autres options le seront.

Usage:

Tous les arguments de windowctrl.py sont facultatifs et peuvent donc être utilisés séparément ou éventuellement ensemble. Comme indiqué par l'option -h.

$ ./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

Code source du script:

Le code source du script est disponible sur GitHub et ici. Les dernières modifications sont susceptibles d'aller dans le GitHub plutôt qu'ici, donc je suggère fortement de vérifier la dernière version. Il est également suggéré de poster des rapports de bugs là aussi.

#!/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 __== '__main__':
    main()

---

Notes de côté

• Vous avez demandé "Existe-t-il une commande dans Gnome-Terminal ou un shell tabable pour ouvrir un nouvel onglet?" Le manuel du terminal Gnome ne liste pas cette option. Les shells sont des utilitaires de ligne de commande. Les onglets sont des fonctionnalités des applications graphiques. Il existe des multiplexeurs de terminaux tels que screen ou tmux qui peuvent avoir des "onglets" ou des fenêtres divisées, ce qui s'apparente en quelque sorte à "un onglet tabable", mais il ne s'agit pas du même type de comportement que vous demandez. En gros, la réponse à votre question est "Non". Il y a toujours des alternatives, et ma réponse en fournit une. Il traite la fenêtre du terminal en fonction de sa nature - Fenêtre d'interface graphique X11.

• Quel est le lien entre cette réponse et les alias? Tout d’abord, les alias peuvent être un peu compliqués, surtout quand il s’agit de citer et d’analyser plusieurs sorties à partir de plusieurs commandes. Ce script vous donne une seule commande, centralisée, avec des indicateurs/commutateurs pour effectuer une tâche discrète sur une fenêtre. Cela simplifie également les alias. Vous pouvez faire alias nw='windowctrl.py --window'. Beaucoup plus court, beaucoup plus net.