Существует ли команда в Терминале Gnome или какая-либо tabbable оболочка для открытия новой вкладки?

Вы не можете сделать этого по умолчанию в Терминале Gnome, по крайней мере, с необработанными командами.

Однако можно записать сценарии, которые называют сочетания клавиш, которые могут сделать это. Обратите внимание, что Вам нужно xdotool для этого: sudo apt install xdotool

• Новое Окно: Запустите новое окно терминала с nw
  Мы можем сделать это только с gnome-terminal.
  Добавьте к .bashrc:

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

• Новая вкладка: Запустите новую вкладку с nt
  Мы можем сделать это с xdotool getactivewindow $(xdotool key ctrl+shift+t)
  Добавьте к .bashrc:

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

• Близкая Вкладка: Закройте текущую вкладку или окно с ct
xdotool забастовки снова: xdotool getactivewindow $(xdotool key ctrl+shift+w)
  Добавьте к .bashrc:

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

• Максимизируйте Окно: Максимизируйте все окно с maw
  Мы можем использовать wmctrl здесь: wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
  Добавьте к .bashrc:

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

• Минимизируйте Окно: Минимизируйте все окно с miw
  Мы можем использовать xdotool снова: xdotool windowminimize $(xdotool getactivewindow)
  Добавьте к .bashrc:

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

• Перемещение к Рабочей области: Переместите окно в другую рабочую область с mtw <id>
  Это было бы едва-едва возможно в сценариях оболочки и является путем вне моего личного опыта. Я рекомендовал бы использовать сценарий Serg с этой целью, потому что он на самом деле работает на данный момент. А-ч, преимущества Compiz.

Введение

Сценарий, представленный в этом ответе, позволяет пользователю управлять их окном терминала через одну единственную команду и список опций. Это просто в использовании и совместимо с любым эмулятором терминала, который имеет привязки клавиш, подобные gnome-terminal. Движущиеся опции могут использоваться с другими терминалами также, но открытие вкладки не гарантируется для тех терминалов.

Сценарий касается открытия вкладки, открытия окна, перемещения в рабочую область вниз, рабочая область правильная, определенная рабочая область, рецензируемая к целым числом, уменьшением, максимизацией и немаксимизацией окна. Единственная вещь, которую не касается сценарий, закрывает вкладку/окно просто, потому что каждая оболочка/эмулятор терминала уже имеет команду для него - exit или альтернативно через ярлык CtrlD.

!!! ПРИМЕЧАНИЕ: Вам будет нужно xdotool для переключения рабочей области и открытия вкладки. Установите его через sudo apt-get install xdotool. Если Вы предпочитаете не устанавливать дополнительные пакеты, иметь в виду, что рабочая область и переключение вкладки не будут работать, но другие опции будут.

Использование:

Все аргументы windowctrl.py являются дополнительными, таким образом, они могут использоваться отдельно, или потенциально вместе. Как показано -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

Исходный код сценария:

Исходный код сценария доступен на GitHub, а также здесь. Последние изменения, вероятно, войдут в GitHub, а не здесь, таким образом, я настоятельно рекомендую проверить на последнюю версию там. Также предлагается отправить отчеты об ошибках там также.

#!/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()

Сторона отмечает

• Вы спросили, "Там команда в Терминале Gnome или какая-либо tabbable оболочка для открытия новой вкладки?" Руководство Терминала Gnome не перечисляет такую опцию. Оболочки являются утилитами командной строки. Вкладки являются функцией приложений GUI. Существуют оконечные мультиплексоры как screen или tmux который может иметь "вкладки" или окна с несколькими панелями, какой вид близко подходит "к tabbable оболочке", но это не тот же тип поведения, Вы спрашиваете. В основном ответьте на свой вопрос, "Нет". Всегда существуют альтернативы, и мой ответ обеспечивает одного из них. Это рассматривает окно терминала согласно своему характеру - окно X11 GUI.

• Как этот ответ касается псевдонимов? Ну, в первую очередь, искажает, может быть немного грязным, особенно когда дело доходит до заключения в кавычки и парсинга нескольких выводов от нескольких команд. Этот сценарий дает Вам один, централизованная команда, с флагами/переключателями, чтобы сделать дискретную задачу на окно. Это также делает псевдонимы более простыми. Вы могли сделать alias nw='windowctrl.py --window'. Намного короче, намного более опрятный.