it-swarm.com.de

Gibt es in Gnome-Terminal einen Befehl oder eine tabulierbare Shell, um einen neuen Tab zu öffnen?

Ich suche keine Tastenkombination, sondern möchte Befehle für:

  • Neues Fenster
  • Neue Registerkarte
  • Schließen Sie die aktuelle Registerkarte oder das aktuelle Fenster
  • Shell-Fenster maximieren
  • Shell-Fenster minimieren
  • Verschieben Sie Shell in einen anderen Arbeitsbereich
  • Tab wechseln

Und im Grunde genommen so etwas. Merken; Ich möchte keine Verknüpfungen, sondern tatsächliche Befehle. Der Grund dafür ist, dass ich die Alias-Funktionalität nutzen kann.

11
Akiva

Dies ist in Gnome-Terminal standardmäßig nicht möglich, zumindest nicht mit unformatierten Befehlen.

Sie können jedoch Skripts schreiben, die Tastenkombinationen aufrufen, die dies ermöglichen. Beachten Sie, dass Sie hierfür xdotool benötigen: Sudo apt install xdotool

  • Neues Fenster: Startet ein neues Terminalfenster mit nw
    Wir können dies mit nur gnome-terminal tun.
    Zu .bashrc hinzufügen :

    echo "alias nw=gnome-terminal" >> ~/.bashrc
    
  • Neuer Tab: Startet einen neuen Tab mit nt
    Das schaffen wir mit xdotool getactivewindow $(xdotool key ctrl+shift+t)
    Zu .bashrc hinzufügen :

    echo "alias nt='xdotool getactivewindow $(xdotool key ctrl+shift+t)'" >> .bashrc
    
  • Tab schließen: Schließt den aktuellen Tab oder das aktuelle Fenster mit ct
    xdotool schlägt erneut zu: xdotool getactivewindow $(xdotool key ctrl+shift+w)
    Zu .bashrc hinzufügen :

    echo "alias ct='xdotool getactivewindow $(xdotool key ctrl+shift+w)'" >> .bashrc
    
  • Fenster maximieren: Maximiere das gesamte Fenster mit maw
    Wir können wmctrl hier verwenden: wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
    Zu .bashrc hinzufügen :

    echo "alias maw='wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz'" >> .bashrc
    
  • Fenster minimieren: Minimiert das gesamte Fenster mit miw
    Wir können xdotool erneut verwenden: xdotool windowminimize $(xdotool getactivewindow)
    Zu .bashrc hinzufügen :

    echo "alias miw='xdotool windowminimize $(xdotool getactivewindow)'" >> .bashrc
    
  • Move to Workspace: Verschiebt ein Fenster mit mtw <id> in einen anderen Arbeitsbereich
    Dies wäre in Shell-Skripten gerade kaum möglich und würde meine persönliche Erfahrung sprengen. Ich würde Sergs Skript für diesen Zweck empfehlen, da es ab sofort funktioniert. Ah, die Vorteile von Compiz.

14
Kaz Wolfe

Einführung

Das in dieser Antwort vorgestellte Skript ermöglicht es dem Benutzer, sein Terminalfenster über einen einzigen Befehl und eine Liste von Optionen zu steuern. Es ist einfach zu bedienen und mit jedem Terminalemulator kompatibel, dessen Tastaturbelegung der von gnome-terminal ähnelt. Verschiebungsoptionen können auch mit anderen Terminals verwendet werden, das Öffnen von Registerkarten ist jedoch für diese Terminals nicht garantiert.

Das Skript behandelt das Öffnen von Registerkarten, das Öffnen von Fenstern, das Verschieben in den unteren Arbeitsbereich, den rechten Arbeitsbereich und einen bestimmten Arbeitsbereich, auf den sich eine Ganzzahl bezieht, sowie das Minimieren, Maximieren und Aufheben der Maximierung eines Fensters. Das einzige, was das Skript nicht behandelt, ist das Schließen von Tabs/Fenstern, einfach weil jeder Shell-/Terminal-Emulator bereits einen Befehl dafür hat - exit oder alternativ über CtrlD Abkürzung.

!!! HINWEIS: Sie benötigen xdotool zum Wechseln des Arbeitsbereichs und Öffnen von Registerkarten. Installiere es über Sudo apt-get install xdotool. Wenn Sie keine zusätzlichen Pakete installieren möchten, beachten Sie, dass das Wechseln des Arbeitsbereichs und der Tabulatoren nicht funktioniert , andere Optionen jedoch.

Verwendungszweck:

Alle Argumente für windowctrl.py sind optional, sodass sie separat oder möglicherweise zusammen verwendet werden können. Wie durch die Option -h gezeigt.

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

Skript Quellcode:

Der Skript-Quellcode ist sowohl auf GitHub als auch hier verfügbar. Die neuesten Änderungen werden wahrscheinlich eher im GitHub als hier vorgenommen. Ich empfehle daher dringend, dort nach der neuesten Version zu suchen. Es wird auch empfohlen, dort Fehlerberichte zu veröffentlichen.

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

Randnotizen

  • Sie haben gefragt, ob in Gnome-Terminal ein Befehl oder eine tabulierbare Shell zum Öffnen eines neuen Tabs vorhanden ist. Das Gnome Terminal Handbuch listet diese Option nicht auf. Die Shells sind Befehlszeilenprogramme. Registerkarten sind eine Funktion von GUI-Anwendungen. Es gibt Terminal-Multiplexer wie screen oder tmux, die "Tabs" oder geteilte Fenster haben können, was der "tabbable Shell" sehr nahe kommt, aber dies ist nicht dieselbe Art von Verhalten, das Sie verlangen. Grundsätzlich lautet die Antwort auf Ihre Frage "Nein". Es gibt immer Alternativen, und meine Antwort liefert eine davon. Es behandelt Terminalfenster entsprechend seiner Art - X11-GUI-Fenster.

  • Wie bezieht sich diese Antwort auf Aliase? Zunächst einmal können Aliase etwas unübersichtlich sein, insbesondere wenn es darum geht, mehrere Ausgaben aus mehreren Befehlen in Anführungszeichen zu setzen und zu analysieren. Dieses Skript bietet Ihnen einen zentralen Befehl mit Flags/Schaltern, mit denen Sie eine diskrete Aufgabe für ein Fenster ausführen können. Es macht auch Aliase einfacher. Du könntest alias nw='windowctrl.py --window' machen. Viel kürzer, viel ordentlicher.

7