Como faço uma segunda janela se encaixar no lado oposto da tela?

3

Eu estou vindo do Windows 10, embora eu tenha começado (e aceito) a maneira como o Ubuntu funciona, ainda são algumas coisas que eu amo no Windows 10, o recurso em questão aqui é o jeito Se eu tirar um Windows para o lado direito da tela ocupa a metade direita da tela (que também é semelhante no Ubuntu), mas outro aplicativo em segundo plano ocupa a metade esquerda da tela e não precisa fazer isso manualmente.

Nestafoto,seeuencaixarasjanelasdoNavegadoràdireita,ajaneladoNautilusnãoafetariaaação,maseuqueroqueela(janeladonautilus)seajusteàesquerda

Detalhes

  • Ubuntu17.04
  • Saborgnomo

Atualizar

resultadodoscriptfillscreen.py

naprimeiratentativafillscreenveioanotificação(nãoconseguicapturar)eelamoveuasegundajanela(janelaàdireita)emumacaixa,eaprimeirajanelanãofoiafetada.

na segunda tentativa, esse deslocamento estava presente, mas funcionou (e funciona principalmente)

    
por Sumeet Deshmukh 22.04.2017 / 04:50

1 resposta

2

Nota importante!

O script abaixo fará exatamente como você descreve nas duas janelas mais recentes , ou seja: as duas janelas que foram criadas pela última vez.

O script, comportamento

  • O script atua em arrastando uma das duas janelas "mais recentes" para uma das duas áreas na tela, conforme mostrado na imagem.

    Aáreaédeliberadamentenãoapertadanocanto,paragarantirquenãointerfiracomajanela"normal".

  • Se a janela for arrastada para qualquer uma das áreas, o script aguarda 0,15 segundo para ver se o mouse ainda está na mesma posição, para ter certeza de não agir se o usuário estava "a caminho "para o canto da tela para encaixar janelas normais.

  • Posteriormente, a janela arrastada é encaixada na metade da tela em que a área está, a segunda janela é encaixada no lado oposto da tela

    1. arraste a janela para a área

    2.ajanelaseencaixa,aoutraseencaixanositeoposto

  • finalmente,comoconfirmação,umanotificaçãoéexibidadurantetrêssegundos:

    Veja o script em ação

O script & configuração

A configuração envolve dois itens:

  • o script:

    #!/usr/bin/env python3
    import sys
    import os
    import subprocess
    import time
    from operator import itemgetter
    from itertools import groupby
    import math
    
    #--- set your preferences below: padding between windows, margin(s)
    cols = 2; rows = 1; padding = 20; left_margin = 0; top_margin = 30
    #---
    
    fpath = os.path.dirname(os.path.abspath(__file__))
    n_wins = cols*rows
    
    
    def get_spot(pos):
        # get the resolution
        scrdata = get("xrandr").split(); resindex = scrdata.index("connected")+2
        res = [int(n) for n in scrdata[resindex].split("+")[0].split("x")]
        # list the corners, could be more elegant no doubt
        corners = [[0, res[1]], [res[0], res[1]]]
        diff = [int(math.sqrt(sum([(c[i]-pos[i])**2 for i, n in enumerate(res)])))\
                for c in corners]
        return diff
    
    def get(cmd):
        try:
            return subprocess.check_output(cmd).decode("utf-8")
        except subprocess.CalledProcessError:
            pass
    
    def get_res():
        xr = get("xrandr").split(); pos = xr.index("current")
        return [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]
    
    def get_pos():
        return [int(s.split(":")[1]) for s in get(["xdotool", "getmouselocation"]).split()[:2]]
    
    
    def check_window(w_id):
        w_type = get(["xprop", "-id", w_id])
        if " _NET_WM_WINDOW_TYPE_NORMAL" in w_type:
            return True
        else:
            return False
    
    def confirm():
        val = False
        mouseloc = get_spot(get_pos())
        match = [mouseloc.index(n) for n in mouseloc if 50 < n < 400]
        if match:
            time.sleep(0.15)
            val = True if get_spot(get_pos()) == mouseloc else False
        return val, match
    
    def arrange_wins(active, side):
        # get resolution
        res = get_res()
        # define (calculate) the area to divide
        area_h = res[0] - left_margin; area_v = res[1] - top_margin
        # create a list of calculated coordinates
        x_coords = [int(left_margin+area_h/cols*n) for n in range(cols)]
        y_coords = [int(top_margin+area_v/rows*n) for n in range(rows)]
        coords = sum([[(cx, cy) for cx in x_coords] for cy in y_coords], [])
        # calculate the corresponding window size, given the padding, margins, columns and rows
        w_size = [str(int(area_h/cols - padding)), str(int(area_v/rows - padding))]
        # find windows of the application, identified by their pid
        active = hex(int(get(["xdotool", "getactivewindow"])))
        active = active[:2]+(10-len(active))*"0"+active[2:]
        wlist = [w.split()[0] for w in get(["wmctrl", "-l"]).splitlines()]
        w_list = [w for w in wlist if check_window(w) == True][-n_wins:]
        try:
            w_list = w_list[::-1] if w_list.index(active) != side else w_list
        except ValueError:
            pass
        else: 
            print(w_list)
            # remove possibly maximization, move the windows
            for n, w in enumerate(w_list):
                data = (",").join([str(item) for item in coords[n]])+","+(",").join(w_size)
                cmd1 = "wmctrl -ir "+w+" -b remove,maximized_horz"
                cmd2 = "wmctrl -ir "+w+" -b remove,maximized_vert"
                cmd3 = "wmctrl -ir "+w+" -e 0,"+data
                for cmd in [cmd1, cmd2, cmd3]:
                    subprocess.Popen(["/bin/bash", "-c", cmd])
    
    wins1 = []
    
    while True:
        time.sleep(0.5)
        windata = get(["wmctrl", "-lG"])
        if windata:
            wins2 = [[l[0], l[2]] for l in [
                ln.split() for ln in windata.splitlines()]
                       ]
            # combined window locations old/new, grouped to see if moved
            winlocs = sorted(wins1 + wins2, key = itemgetter(0))
            test = [[item, [item[1] for item in list(occ)]] \
                    for item, occ in groupby(winlocs, itemgetter(0))]
            for item in test:
                # old loc, new loc of window
                locs = item[1]
                # window moves?
                if locs.count(locs[0]) != len(locs):
                    args = confirm()
                    if args[0]:
                        arrange_wins(item[0], args[1][0])
                        subprocess.Popen([
                            "notify-send", "-i", os.path.join(
                                fpath, "left.png"), "Fill screen"
                            ])
                        time.sleep(3)
                        subprocess.Popen(["pkill", "notify-osd"])
            wins1 = wins2
    
  • um ícone para mostrar na notificação

Configuração

  1. Instaleosdoisxdotoolewmctrl
  2. Copieoscriptemumarquivovazio,salve-ocomofillscreen.pyemumapastadedicadaemalgumlugar.
  3. Cliquecomobotãodireitodomousenoíconeacima,salve-ocomo(exatamente)left.pngemumaúnicaemesmapastaqueoscript.
  4. Agoraabraumterminal,executeocomando:

    python3/path/to/fillscreen.py

    Notequeestajaneladeterminaléumadasduasjanelasqueoscriptiráajustar.Elaboraroterminalparaqualquerumadasáreasàesquerdaouàdireita.Asduasjanelasmaisrecentesdevemseencaixar.

  5. Setudofuncionarbem,adicioneoscriptaosaplicativosdeinicialização:Dash>Aplicativosdeinicialização>Adicionar.Adicioneocomando:

    /bin/bash-c"sleep 10 && python3 /path/to/fillscreen.py"
    

Nota

Devido ao fato de que o script age apenas no movimento da janela e, subsequentemente, todas as ações posteriores dependem da situação, o script está com pouco suco. Muito mais baixo do que eu esperava que fosse quando comecei a trabalhar nele.

    
por Jacob Vlijm 23.04.2017 / 20:35