Pozițiile implicite ale terminalului Ubuntu

Mulțumesc Nate. Am folosit ideea pe care mi-ai dat-o și am venit cu acel script care îmi rezolvă problema. Este un script python care este conceput special pentru rezoluția mea, care este 1920x1080. Depinde și de un instrument numit wmctrl. Iată scenariul:

#!/usr/bin/python3

import os


def elimina(iter):
    res = []
    pentru eu in iter:
        dacă eu:
            res.apend(i)
    returnare res


spațiu de lucru = "wmctrl -d | grep '*' | cut -d ' ' -f1 > /tmp/curr_ws"

os.system (spațiu de lucru)
out_workspace = ""
cu open("/tmp/curr_ws","r") ca f:
    out_workspace = f.read()
out_workspace = int(out_workspace)
print("DEBUG: Spațiu de lucru curent:", out_workspace)

poziții = 'wmctrl -lG | grep "kali:" | grep „^........... {0}” | tr -s " " | cut -d " " -f 3,4 > /tmp/positions'.format(out_workspace)
dimensiuni = 'wmctrl -lG | grep "kali:" | grep „^........... {0}” | tr -s " " | cut -d " " -f 5,6 > /tmp/sizes'.format(out_workspace)

os.system(poziții)
out_positions = ""
cu open("/tmp/positions","r") ca f:
    out_positions = f.read()
out_positions = eliminare(out_positions.split("\n"))

sistem(dimensiuni) os.system
out_sizes = ""
cu open("/tmp/sizes","r") ca f:
    out_sizes = f.read()
out_sizes = eliminare(out_sizes.split("\n"))

poziții_terminale = [[110, 101, 854, 479], [973, 101, 854, 479], [110, 611, 854, 479], [973, 611, 854, 479]]
terminal_strings = ["gnome-terminal --geometry 105x25+100+45", "gnome-terminal --geometry 105x25+963+45",
                    "gnome-terminal --geometry 105x25+100+555", "gnome-terminal --geometry 105x25+963+555"]

parsed_positions = []
pentru i în interval (0,len(out_positions)):
    parsed_positions.append([ int(out_positions[i].split(" ")[0]),int(out_positions[i].split(" ")[1]),int(out_sizes[i].split(" " )[0]),int(out_sizes[i].split(" ")[1]) ])
print("DEBUG: Poziții:", poziții_parsed)

def check(term_pos, parsed_pos):
    indice = 0
    suprapunere = Fals
    pentru i în pozițiile_terminale:
        suprapunere = Fals
        pentru j în parsed_positions:
            ax0 = term_left_start = i[0]
            ay0 = term_up_start = i[1]
            ax1 = term_left_end = i[0] + i[2]
            ay1 = term_up_end = i[1] + i[3]
            
            bx0 = pars_left_start = j[0]
            by0 = pars_up_start = j[1]
            bx1 = pars_left_end = j[0] + j[2]
            by1 = pars_up_end = j[1] + j[3]

            # dacă term_left_start >= pars_left_end sau term_left_end <= pars_left_start sau term_up_end <= pars_up_start sau term_up_start >= pars_up_end:
            # overlap = Adevărat

            dacă ((bx0 <= ax0) și (ax1 <= bx1)) sau ((ax0 <= bx0 <= ax1) și (ax1 <= bx1)) sau ((ax0 >= bx0) și (ax1 >= bx1 > = ax0)) sau ((ax0 <= bx0 <= ax1) și (ax1 >= bx1 >= ax0)):
                dacă ((by0 <= ay0) și (ay1 <= by1)) sau ((ay0 <= by0 <= ay1) și (ay1 <= by1)) sau ((ay0 >= by0) și (ay1 >= by1 > = ay0)) sau ((ay0 <= by0 <= ay1) și (ay1 >= by1 >= ay0)):
                    suprapunere = Adevărat

        dacă se suprapun:
            indice += 1
        altceva:
            indice de returnare


    întoarce -1


loc = verificare (poziții_terminale, poziții_parse)

dacă locul == -1:
    os.system("gnome-terminal")
altceva:
    os.system(terminal_strings[loc])

Trebuie să includeți locația scriptului în variabila PATH, apoi să atribuiți o comandă rapidă unei comenzi care execută scriptul