Come mostrare (sollevare) tutte le finestre di un'applicazione?

19

Ho un'applicazione che utilizza più finestre. Come posso portare rapidamente tutte le finestre di quell'applicazione in primo piano?

Quando sfoglio le applicazioni con la rotella di scorrimento, mostra solo una finestra. Quando si passa alla finestra successiva, l'ultima finestra viene nuovamente visualizzata in background.

Quando faccio clic sull'icona dell'applicazione, viene visualizzata una panoramica a schermo intero di tutte le finestre. Devo selezionare ogni finestra manualmente e spostare il mouse su metà dello schermo più volte.

La mia soluzione migliore finora è quella di minimizzare tutte le finestre ( Ctrl + Super + D ) e quindi mostrare le finestre della mia applicazione usando il scroll-wheel.

C'è una soluzione migliore?

    
posta peq 11.04.2014 - 17:43

3 risposte

20

EDIT - nuova risposta -

Le risposte qui sotto sono / sono ancora totalmente valide, e quindi le opzioni suggerite. L'intuizione continua tuttavia mi ha fatto aggiungere questa opzione per utilizzare l'indicatore sottostante, che è probabilmente la soluzione più elegante.

Come tale, dovrebbe probabilmente sostituire l'opzione 5 (usando un file .desktop).

Scegli semplicemente l'applicazione dall'elenco e tutte le finestre dell'applicazione corrispondente (presenti nella finestra corrente) genereranno:

Come usare

da ppa:

sudo add-apt-repository ppa:vlijm/upfront
sudo apt-get update
sudo apt-get install upfront

... o manualmente:

#!/usr/bin/env python3
import signal
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('AppIndicator3', '0.1')
from gi.repository import Gtk, AppIndicator3, GObject
import time
from threading import Thread
import os
import subprocess
import getpass

currpath = os.path.dirname(os.path.realpath(__file__))

class Indicator():
    def __init__(self):
        self.app = 'raise_apps'
        iconpath = os.path.join(currpath, "raise.png")
        self.indicator = AppIndicator3.Indicator.new(
            self.app, iconpath,
            AppIndicator3.IndicatorCategory.OTHER)
        self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)       
        self.indicator.set_menu(self.create_menu())
        # the thread:
        self.update = Thread(target=self.check_recent)
        # daemonize the thread to make the indicator stopable
        self.update.setDaemon(True)
        self.update.start()

    def create_menu(self):
        # creates the (initial) menu
        self.menu = Gtk.Menu()
        # separator
        initial = Gtk.MenuItem("Fetching list...")
        menu_sep = Gtk.SeparatorMenuItem()
        self.menu.append(initial)
        self.menu.append(menu_sep)
        # item_quit.show() 
        self.menu.show_all()
        return self.menu

    def raise_wins(self, *args):
        index = self.menu.get_children().index(self.menu.get_active())
        selection = self.menu_items2[index][1]
        for w in selection:
            execute(["wmctrl", "-ia", w])

    def set_new(self):
        # update the list, appearing in the menu
        for i in self.menu.get_children():
            self.menu.remove(i)
        for app in self.menu_items2:

            sub = Gtk.MenuItem(app[0])
            self.menu.append(sub)
            sub.connect('activate', self.raise_wins)
        # separator
        menu_sep = Gtk.SeparatorMenuItem()
        self.menu.append(menu_sep)
        # quit
        item_quit = Gtk.MenuItem('Quit')
        item_quit.connect('activate', self.stop)
        self.menu.append(item_quit)
        self.menu.show_all()

    def get_apps(self):
        # calculate screen resolution
        res_output = get("xrandr").split(); idf = res_output.index("current")
        res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
        # creating window list on current viewport / id's / application names
        w_data = [l.split() for l in get(["wmctrl", "-lpG"]).splitlines()]
        # windows on current viewport
        relevant = [w for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
        # pids
        pids = [l.split() for l in get(["ps", "-u", getpass.getuser()]).splitlines()]
        matches = [[p[-1], [w[0] for w in relevant if w[2] == p[0]]] for p in pids]
        return [m for m in matches if m[1]]

    def check_recent(self):
        self.menu_items1 = []
        while True:
            time.sleep(4)
            self.menu_items2 = self.get_apps()
            for app in self.menu_items2:
                app[0] = "gnome-terminal" if "gnome-terminal" in app[0] else app[0]
            if self.menu_items2 != self.menu_items1:
                GObject.idle_add(
                    self.set_new, 
                    priority=GObject.PRIORITY_DEFAULT
                    )
            self.menu_items1 = self.menu_items2

    def stop(self, source):
        Gtk.main_quit()

def get(command):
    return subprocess.check_output(command).decode("utf-8")

def execute(command):
    subprocess.Popen(command)

Indicator()
GObject.threads_init()
signal.signal(signal.SIGINT, signal.SIG_DFL)
Gtk.main()
  • L'indicatore ha bisogno di wmctrl

    sudo apt-get wmctrl
    
  • Copia l'indicatore in un file vuoto, salvalo come raise_apps.py

  • Copia l'immagine qui sotto, salvala esattamente denominata raise.png in una e la stessa directory come l'indicatore.

  • Quindi eseguilo semplicemente con il comando:

    python3 /path/to/raise_apps.py

  • Aggiungi se vuoi avviare le applicazioni:

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

VECCHIA RISPOSTA:

Informazioni sulla domanda

Con gli strumenti giusti, non è molto complicato "solo" aumentare tutte le finestre di un'applicazione. È un po 'più complicato fare in modo che solo le finestre della finestra corrente vengano sollevate. La vera sfida è comunque trovare un modo conveniente per rendere l'azione disponibile all'utente.

Di seguito cinque opzioni per occuparsene, per mostrare come può essere fatto. Tutte le opzioni sono pronte per essere utilizzate. L'ultima opzione tuttavia è di tipo sperimentale; Funziona bene, ma ha alcuni piccoli svantaggi cosmetici, come spiegato nella descrizione dell'opzione. L'ho aggiunto tuttavia come concetto .

La diffusione automatica delle finestre in modo non sovrapponibile, come suggerito in un commento, non mi sembra un'idea pratica; se lavori in una configurazione di finestre raggruppate (a livello di applicazione), lo script potrebbe riorganizzare involontariamente le finestre.

Come usare

Per tutte le opzioni necessarie:

  • installa wmctrl se non è ancora sul tuo sistema:

    sudo apt-get install wmctrl
    
  • crea, se non esiste ancora, la directory:

    ~/bin
    

    (spiegazione: la directory ~/bin è in $ PATH, quindi puoi eseguire gli eseguibili con il loro nome)

  • Copia lo script, corrispondente all'opzione, incollalo in un file vuoto, salvalo come raise_app (senza estensione) in ~/bin e rendilo eseguibile

Nelle opzioni separate, saranno spiegati eventuali passi aggiuntivi.

Opzione 1: scegli l'applicazione inserendo uno o più caratteri

  • Premi una combinazione di tasti, verrà visualizzata una finestra zenity
  • Inserisci uno o più caratteri del nome dell'applicazione nella casella di testo
  • premi invio

Questo farà apparire tutte le finestre dell'applicazione corrispondente (nella vista attuale ).

alza tutte le finestre gnome-terminal nella finestra corrente:

Come usare:

  • Fai la configurazione come descritto in "Come usare"
  • Prova-eseguilo con il comando:

    raise_app
    
  • Se tutto funziona correttamente, aggiungilo a una combinazione di tasti scelta rapida: Scegli: Impostazioni di sistema & gt; "Tastiera" & gt; "Scorciatoie" & gt; "Scorciatoie personalizzate". Fai clic su "+" e aggiungi il comando

Lo script:

#!/usr/bin/env python3
import subprocess
import getpass

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])
# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# creating window list on current viewport / id's / application names
w_data = [l.split()[0:7] for l in get("wmctrl -lpG").splitlines()]
windows = [[get("ps -u "+getpass.getuser()+" | grep "+w[2]).split()[-1], w[0]]
           for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
# ask user for first characters
try:
    arg = get('zenity --entry --text "first characters" --title "application"').strip()
except subprocess.CalledProcessError:
    pass
# raise matching windows
try:
    [execute("wmctrl -ia "+item[1]) for item in windows if item[0].startswith(arg)]
except (subprocess.CalledProcessError, NameError):
    pass

Opzione 2: scorrere le applicazioni e alzare le finestre con una combinazione di tasti:

Diciamo che ho lo script sotto una combinazione di tasti Alt + 1 . Ho diverse finestre aperte di:

  • firefox
  • gnome-terminal
  • Nautilus

Lo stato corrente:

Premendo una volta Alt + 1 , vengono visualizzate tutte le nautilus di windows:

Premendo di nuovo Alt + 1 , vengono visualizzate tutte le firefox di windows:

Premendo di nuovo Alt + 1 , tutte le finestre gnome-terminal vengono nuovamente sollevate, il ciclo ricomincia:

Come usare

  • Fai la configurazione come descritto in "Come usare"
  • Aggiungilo a una combinazione di tasti scelta rapida: Scegli: Impostazioni di sistema & gt; "Tastiera" & gt; "Scorciatoie" & gt; "Scorciatoie personalizzate". Fai clic su "+" e aggiungi il comando

    raise_app
    

Quindi passa in rassegna le applicazioni con finestre di applicazioni raggruppate con la combinazione di tasti.

Lo script:

#!/usr/bin/env python3
import subprocess
import getpass

include_single = True # set to False if you only want to cycle through apps with multiple windows

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])

def get_frontmost():
    cmd = "xprop -root"
    frontmost = [l for l in get(cmd).splitlines() if\
                 "ACTIVE_WINDOW(WINDOW)" in l][0].split()[-1]
    return frontmost[:2]+"0"+frontmost[2:]
# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# creating window list on current viewport / id's / application names
w_data = [l.split()[0:7] for l in get("wmctrl -lpG").splitlines()]
windows = [[get("ps -u "+getpass.getuser()+" | grep "+w[2]).split()[-1], w[0]]
           for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
# create application list to cycle through
if include_single == False:
    pre = [it[0] for it in windows]
    apps = sorted(list(set([it for it in pre if pre.count(it) > 1])))
else:
    apps = sorted(list(set([it[0] for it in windows])))
if len(apps) == 0:
    pass
else:
    # get the frontmost window as a last itm in the cycle
    front = get_frontmost()
    front_pid = [l.split()[2] for l in get("wmctrl -lp").splitlines() if front in l][0]
    last_infront = get("ps -u "+getpass.getuser()+" | grep "+front_pid).split()[-1]
    # determine next apllication to raise
    if not last_infront in apps or last_infront == apps[-1]:
        arg = apps[0]
        print(arg)
    else:
        arg = apps[apps.index(last_infront)+1]
    # raise matching windows
    try:
        [execute("wmctrl -ia "+item[1]) for item in windows if item[0] == arg]
    except (subprocess.CalledProcessError, NameError):
        pass

Opzione 3: premere combinazione di tasti + clic sull'icona di avvio -or - finestra dell'applicazione per aumentare tutte le finestre nella finestra corrente

Questa è probabilmente l'opzione più vicina a quanto descritto nella domanda / commento.

Diciamo che ho un desktop disordinato con tre% di% di finestre di protezione seppellite sotto altre finestre.

Per aumentare tutte le finestre di nautilus (scorciatoia di esempio: Alt + 1 ):

  • Premi Alt + 1 , versione (!)
  • Entro 3 secondi:

    fai clic sull'icona dell'applicazione nel launcher

    o

    fai clic su una delle finestre dell'applicazione

    Risultati:


Come usare:

  • Fai la configurazione come descritto in "Come usare"
  • Prova-eseguilo con il comando:

    raise_app
    
  • Se tutto funziona correttamente, aggiungilo a una combinazione di tasti scelta rapida: Scegli: Impostazioni di sistema & gt; "Tastiera" & gt; "Scorciatoie" & gt; "Scorciatoie personalizzate". Fai clic su "+" e aggiungi il comando

Quindi:

  • Premi la combinazione di tasti e entro 3 secondi:

    • fai clic sull'icona dell'applicazione nel launcher
    • fai clic su una delle finestre dell'applicazione

Lo script

#!/usr/bin/env python3
import subprocess
import getpass
import time

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])

def get_frontmost():
    cmd = "xprop -root"
    frontmost = [l for l in get(cmd).splitlines() if\
                 "ACTIVE_WINDOW(WINDOW)" in l][0].split()[-1]
    return frontmost[:2]+"0"+frontmost[2:]

# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# get window data for various purposes
w_data = get("wmctrl -lpG").splitlines()
non_windows = sum([[l.split()[0] for l in w_data if it in l]\
               for it in ("unity-launcher", "unity-panel", "unity-dash", "Hud")], [])
# get id of current window
curr_window = get_frontmost()
# user gets 3 seconds to pick an application window (or launcher icon)
t = 0
while t < 4:
    w_id1 = get_frontmost()
    time.sleep(1)
    w_id2 = get_frontmost()
    if w_id1 == w_id2 or w_id2 in non_windows+[curr_window]:
        t = t+1
    else:
        new_frontmost = w_id2
        break
# raise
try:
    pid = [l.split()[2] for l in w_data if new_frontmost in l]
    wl_data = [l.split() for l in w_data]
    raise_windows = [l[0] for l in wl_data if pid[0] == l[2] and\
                     0 < int(l[3]) < res[0] and 0 < int(l[4]) < res[1]]
    [execute("wmctrl -ia "+item) for item in raise_windows]
except NameError:
    pass


Opzione 4: una combinazione di tasti chiama un elenco di opzioni, che mostra il numero di finestre per applicazione nella finestra corrente

Questo risultò essere più conveniente di quanto supponevo:

Premendo la combinazione di tasti (di nuovo esempio) Alt + 1 richiama una finestra nautilus , elencando tutte le applicazioni e il numero delle loro finestre nella vista corrente:

La semplice pressione delle frecce o ti porterà all'opzione giusta. Premi Invio e tutte le finestre dell'applicazione selezionata vengono sollevate.

Come usare:

  • Fai la configurazione come descritto in "Come usare"
  • Prova-eseguilo con il comando:

    raise_app
    
  • Se tutto funziona correttamente, aggiungilo a una combinazione di tasti scelta rapida: Scegli: Impostazioni di sistema & gt; "Tastiera" & gt; "Scorciatoie" & gt; "Scorciatoie personalizzate". Fai clic su "+" e aggiungi il comando

Lo script

#!/usr/bin/env python3
import subprocess
import getpass

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])
# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# creating window list on current viewport / id's / application names
w_data = [l.split()[0:7] for l in get("wmctrl -lpG").splitlines()]
windows = [[get("ps -u "+getpass.getuser()+" | grep "+w[2]).split()[-1], w[0]]
           for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
# preparing zenity optionlist
apps = [item[0] for item in windows]
# prevent multiple zenity windows
if apps.count("zenity") > 1:
    pass
elif apps.count("zenity") > 0:
    execute('zenity --info --text "Another Zenity window is open already"')
# preventing empty windowlist
elif len(apps) > 0:
    applist = [[app, str(apps.count(app))] for app in set(apps)]
    applist.sort(key=lambda x: x[1])
    # calling zenity window
    try:
        arg = get('zenity  --list  --text "Choose an application" '+\
               '--title "Current windows" '+\
               '--column "application" '+\
               '--column "windows" '+\
               '--height 250 '+\
               '--width 250 '+\
               (" ").join(sum(applist, [])))
    except subprocess.CalledProcessError:
        pass
    # raise matching windows
    try:
        [execute("wmctrl -ia "+item[1]) \
         for item in windows if arg.startswith(item[0])]
    except (subprocess.CalledProcessError, NameError):
        pass
else:
    execute('zenity --info --text "No windows to list"')

Opzione 5: genera finestre di applicazioni in esecuzione dall'icona di avvio

Questa opzione esiste di un'icona di avvio, con le applicazioni attualmente in esecuzione in una lista rapida. Scegline uno e verranno visualizzate tutte le finestre delle applicazioni.

Il programma di avvio viene aggiornato automaticamente quando cambia l'elenco delle applicazioni in esecuzione (nella finestra corrente). L'elenco rapido mostra un elenco diverso su altre finestre, in cui vengono aperte le finestre di altre applicazioni (saranno necessari 1-2 secondi per adattarsi).

Come già detto, sebbene sia completamente funzionale, questa opzione è intesa come un concetto . Ha alcuni piccoli svantaggi cosmetici così com'è. Il più importante:

  • Il cursore "wheel" continua a ruotare per alcuni secondi dopo un'azione. Anche se non influisce sulla funzionalità, è uno svantaggio cosmetico.
  • Sono necessari 1-2 secondi affinché l'elenco delle applicazioni nell'icona di avvio venga aggiornato dopo che l'elenco delle applicazioni in esecuzione cambia.

Inoltre, l'installazione è leggermente più complicata (anche se spiegata in dettaglio di seguito):

Come usare

Qui sotto troverai:

due script / un file icon / a zenity

  1. Prepara la configurazione come in "Come usare", salva il primo (principale) script come .desktop in raise_app
  2. Salva l'icona in basso (fai clic con il pulsante destro del mouse, salva con nome) come ~/bin

  3. Copia il file raise.png in un file vuoto, modifica la riga

        Icon=/path/to/raise.png
    

    al percorso reale dell'icona (percorsi con spazi tra virgolette)
     Salvalo come .desktop in raise.desktop

  4. Trascina il file ~/.local/share/applications nel programma di avvio per aggiungerlo

  5. copia il secondo script, incollalo in un file vuoto, salvalo come .desktop in update_apps , rendilo eseguibile.
  6. Aggiungi il seguente comando alle applicazioni di avvio (Dash & gt; Applicazioni di avvio & gt; Aggiungi):

    update_apps
    
  7. Esci e torna indietro per farlo funzionare.

Il primo script

#!/usr/bin/env python3
import subprocess
import getpass
import sys

arg = sys.argv[1]

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])
# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# creating window list on current viewport / id's / application names
w_data = [l.split()[0:7] for l in get("wmctrl -lpG").splitlines()]
windows = [[get("ps -u "+getpass.getuser()+" | grep "+w[2]).split()[-1], w[0]]
           for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
try:
    [execute("wmctrl -ia "+item[1]) for item in windows if item[0].startswith(arg)]
except (subprocess.CalledProcessError, NameError):
    pass

Il secondo script

#!/usr/bin/env python3
import subprocess
import getpass
import time
import os

dtfile = os.environ["HOME"]+"/.local/share/applications/raise.desktop"

def get(command):
    return subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8")

def execute(command):
    subprocess.Popen(["/bin/bash", "-c", command])
# calculate screen resolution
res_output = get("xrandr").split(); idf = res_output.index("current")
res = (int(res_output[idf+1]), int(res_output[idf+3].replace(",", "")))
# creating window list on current viewport / id's / application names
def applist():
    try:
        w_data = [l.split()[0:7] for l in get("wmctrl -lpG").splitlines()]
        windows = [[get("ps -u "+getpass.getuser()+" | grep "+w[2]).split()[-1], w[0]]
                   for w in w_data if 0 < int(w[3]) < res[0] and 0 < int(w[4]) < res[1]]
    except subprocess.CalledProcessError:
        return []
    else:
        return set([app[0] for app in windows])

def update_dtfile(applications, text):
    actionline = "Actions="+(";").join(applications)+";\n"
    with open(dtfile) as src:
        lines = src.readlines()
    lines = lines[:[i for i in range(len(lines)) \
                 if lines[i].startswith("Actions=")][0]]+[actionline]
    for item in text:
        for it in item:
            lines.append(it)
    with open(dtfile, "wt") as out:
        for line in lines:
            out.write(line)

while True:
    apps1 = applist()
    time.sleep(1)
    apps2 = applist()
    if apps1 != apps2: 
        text = [["[Desktop Action "+it+"]\n", "Name="+it+"\n",
            "Exec=raise_app "+it+"\n", "OnlyShowIn=Unity;\n\n",
            ]for it in apps2]
        update_dtfile(apps2, text)

Il file .desktop

[Desktop Entry]
Name=Raise application windows
Comment=Raise groups of windows
Icon=/path/to/raise.png
Terminal=false
Type=Application
Version=1.0

Actions=

Breve spiegazione

Tutte le soluzioni sopra usano ~/bin per creare un elenco di finestre, usando il comando wmctrl .Questo comando produce linee, che assomigliano a:

0x044000b3  0 3429   65   24   1615 1026 jacob-System-Product-Name unity - How to show all windows of an application? - Ask Ubuntu - Mozilla Firefox

Queste linee includono:

  • 1a colonna: l'id della finestra (che possiamo usare per aumentarla)
  • 3a colonna: il pid che possiede la finestra.
  • 4th / 5th column: la geometria della finestra x-y (che usiamo per vedere se la finestra si trova nella finestra corrente, i.c.w wmctrl -lpG )

Il pid viene cercato nell'output di xrandr per ottenere un'identificazione "user-readable" (nome) dell'applicazione.
Quindi possiamo allocare finestre alle applicazioni. Successivamente possiamo aumentare le finestre di una determinata applicazione in un ciclo ps -u <username> con il comando for .

Nell'opzione 3
lo script avvia un ciclo di "attesa" di 3 secondi, usando ripetutamente il comando wmctrl -ia per vedere se c'è qualche cambiamento in quella che è la finestra in primo piano; questo accadrà se l'utente fa clic su un'icona di avvio per sollevare la finestra di un'applicazione o fa clic direttamente su una finestra. In tal caso, il ciclo while si interrompe e cerca la "nuova" applicazione in primo piano e successivamente solleva tutte le altre finestre di quella applicazione.

    
risposta data Jacob Vlijm 06.01.2015 - 10:59
1

C'è una scorciatoia Super + W che mostrerà l'expo di tutte le finestre attualmente aperte, sebbene includa altre applicazioni. Viene fornito per impostazione predefinita e non richiede alcuna modifica, quindi forse è l'opzione più semplice disponibile.

Tra le altre cose, puoi posizionare le finestre sulle metà destra e sinistra dello schermo con Ctrl + Super + Sinistra / Destra e passa da uno all'altro con Alt + ~ (tilde, quello accanto al tasto numero uno).

    
risposta data Sergiy Kolodyazhnyy 07.01.2015 - 00:41
1

Se premi Alt + Tab per scorrere le applicazioni e ne ottieni una con più finestre, tieni premuto il tasto alt e dopo circa 1 secondo l'icona verrà sostituita con una vista di tutte le finestre per quella applicazione.

Potrebbe essere o non essere quello che stai cercando, ma funziona per me ed è molto più semplice, quindi ho pensato di condividere l'opzione!

    
risposta data Sean Colombo 11.09.2015 - 02:48

Leggi altre domande sui tag