EDIT -new जवाब-
नीचे दिया गया उत्तर अभी भी पूरी तरह से मान्य है, और इसलिए सुझाए गए विकल्प। चल रही अंतर्दृष्टि ने हालांकि मुझे नीचे दिए गए संकेतक का उपयोग करने के लिए इस विकल्प को जोड़ा, जो शायद सबसे सुरुचिपूर्ण समाधान है।
जैसे, इसे शायद विकल्प 5 (एक .desktop फ़ाइल का उपयोग करके) को बदलना चाहिए।
बस सूची से एप्लिकेशन चुनें, और संबंधित एप्लिकेशन की सभी विंडो (वर्तमान व्यूपोर्ट पर मौजूद) उठाएगी:
कैसे इस्तेमाल करे
ppa से:
sudo add-apt-repository ppa:vlijm/upfront
sudo apt-get update
sudo apt-get install upfront
... या मैन्युअल:
#!/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()
सूचक को चाहिए wmctrl
sudo apt-get wmctrl
एक खाली फ़ाइल में संकेतक को कॉपी करें, इसे इस रूप में सहेजें raise_apps.py
नीचे दी गई छवि को कॉपी करें, इसे सूचक के रूप में बिल्कुल एक और उसी निर्देशिकाraise.png में नाम दें ।
तो बस इसे कमांड द्वारा चलाएं:
python3 /path/to/raise_apps.py
यदि आप स्टार्टअप एप्लिकेशन को जोड़ना चाहते हैं:
/bin/bash -c "sleep 10 && python3 /path/to/raise_apps.py"
पुराने उत्तर:
सवाल के बारे में
सही टूल के साथ, किसी एप्लिकेशन की सभी विंडो को "बस" करना बहुत जटिल नहीं है। यह सुनिश्चित करने के लिए थोड़ा और अधिक जटिल है कि केवल वर्तमान व्यूपोर्ट की खिड़कियां खड़ी की गई हैं। हालांकि वास्तविक चुनौती उपयोगकर्ता को कार्रवाई उपलब्ध कराने का एक सुविधाजनक तरीका खोजना है।
यह कैसे किया जा सकता है, यह दर्शाने के लिए पांच विकल्पों के नीचे । सभी विकल्पों का उपयोग करने के लिए तैयार हैं। अंतिम विकल्प हालांकि प्रयोगात्मक की तरह है; यह ठीक काम करता है लेकिन विकल्प के विवरण में बताया गया है कि कुछ मामूली कॉस्मेटिक downsides है। मैंने इसे एक अवधारणा के रूप में जोड़ा ।
गैर-अतिव्यापी तरीके से खिड़कियों को स्वचालित रूप से फैलाना, जैसा कि एक टिप्पणी में सुझाया गया है, मुझे एक व्यावहारिक विचार नहीं लगता है; यदि आप (एप्लिकेशन-वार) समूहीकृत विंडो सेटअप में काम करते हैं, तो स्क्रिप्ट संभवतः अवांछित रूप से खिड़कियों को पुनर्व्यवस्थित करेगी।
कैसे इस्तेमाल करे
आपके लिए आवश्यक सभी विकल्पों के लिए:
स्थापित करें wmctrlयदि यह अभी तक आपके सिस्टम पर नहीं है:
sudo apt-get install wmctrl
बनाएँ, अगर यह अभी तक मौजूद नहीं है, तो निर्देशिका:
~/bin
(स्पष्टीकरण: निर्देशिका ~/bin$ PATH में है, इसलिए आप उनके नाम से निष्पादक चला सकते हैं)
विकल्प के अनुरूप स्क्रिप्ट को कॉपी करें, इसे एक खाली फ़ाइल में पेस्ट करें, इसे raise_app(कोई विस्तार नहीं) के रूप में सहेजें ~/binऔर इसे निष्पादन योग्य बनाएं
अलग-अलग विकल्पों में, संभावित अतिरिक्त चरणों को समझाया जाएगा।
विकल्प 1: एक या अधिक वर्ण दर्ज करके एप्लिकेशन चुनें
- एक कुंजी संयोजन दबाएं, एक
zenityविंडो दिखाई देगी
- प्रवेश बॉक्स में एप्लिकेशन के नाम के एक या अधिक वर्ण दर्ज करें
- एंटर दबाए
इससे मेल खाते के सभी विंडो ( वर्तमान व्यूपोर्ट पर) सामने आ जाएंगे ।
gnome-terminalवर्तमान व्यूपोर्ट पर सभी विंडो बढ़ाएँ:
कैसे इस्तेमाल करे:
- "उपयोग कैसे करें" में वर्णित अनुसार सेट अप करें
कमांड द्वारा इसे टेस्ट करें:
raise_app
यदि सभी ठीक काम करते हैं, तो इसे अपनी पसंद के शॉर्टकट कुंजी संयोजन में जोड़ें: चुनें: सिस्टम सेटिंग्स> "कीबोर्ड"> "शॉर्टकट"> "कस्टम शॉर्टकट"। "+" पर क्लिक करें और कमांड जोड़ें
लिपी:
#!/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
विकल्प 2: अनुप्रयोगों के माध्यम से चक्र करें और एक महत्वपूर्ण संयोजन के साथ अपनी खिड़कियां बढ़ाएं:
मान लीजिए कि मेरे पास कुंजी संयोजन Alt+ के तहत नीचे दी गई स्क्रिप्ट है 1। मेरे पास कई खिड़कियां खुली हैं:
- फ़ायरफ़ॉक्स
- GNOME टर्मिनल
- नॉटिलस
वर्तमान राज्य:
मैं एक बार Alt+ दबाता हूं 1, सभी nautilusविंडो उठाई जाती हैं:
मैं फिर से Alt+ दबाता हूं 1, सभी firefoxखिड़कियां खड़ी हो जाती हैं:
मैं फिर से Alt+ दबाता हूं 1, सभी gnome-terminalखिड़कियां फिर से उठाई जाती हैं, चक्र शुरू होता है:
कैसे इस्तेमाल करे
फिर अपने कुंजी संयोजन के साथ समूहीकृत अनुप्रयोग विंडो के साथ अपने अनुप्रयोगों के माध्यम से चक्र।
लिपी:
#!/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
विकल्प 3: प्रेस कुंजी संयोजन + लांचर आइकन पर क्लिक करें -या- वर्तमान व्यूपोर्ट पर सभी खिड़कियों को बढ़ाने के लिए आवेदन खिड़की
यह संभवतः वह विकल्प है जो प्रश्न / टिप्पणी में वर्णित के निकटतम है।
मान लीजिए कि मेरे पास एक गड़बड़ डेस्कटॉप है जिसमें तीन nautilusखिड़कियां हैं जो अन्य खिड़कियों के नीचे दफन हैं।
सभी नॉटिलस खिड़कियां बढ़ाने के लिए (उदाहरण शॉर्टकट: Alt+ 1):
कैसे इस्तेमाल करे:
- "उपयोग कैसे करें" में वर्णित अनुसार सेट अप करें
कमांड द्वारा इसे टेस्ट करें:
raise_app
यदि सभी ठीक काम करते हैं, तो इसे अपनी पसंद के शॉर्टकट कुंजी संयोजन में जोड़ें: चुनें: सिस्टम सेटिंग्स> "कीबोर्ड"> "शॉर्टकट"> "कस्टम शॉर्टकट"। "+" पर क्लिक करें और कमांड जोड़ें
फिर:
लिपी
#!/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
विकल्प 4: एक कुंजी संयोजन एक विकल्प सूची को कॉल करता है, जो वर्तमान व्यूपोर्ट पर प्रति एप्लिकेशन विंडोज़ की संख्या दिखा रहा है
यह एक और अधिक सुविधाजनक निकला तो मैंने मान लिया:
वर्तमान संयोजन पर सभी अनुप्रयोगों और उनकी खिड़कियों की संख्या को सूचीबद्ध करते हुए (फिर से उदाहरण-) कुंजी संयोजन Alt+ 1एक zenityविंडो को दबाता है:
बस ▴या ▾तीर दबाने से आपको सही विकल्प मिलेगा। प्रेस Enterऔर चुने हुए आवेदन की सभी खिड़कियां उठाई जाती हैं।
कैसे इस्तेमाल करे:
- "उपयोग कैसे करें" में वर्णित अनुसार सेट अप करें
कमांड द्वारा इसे टेस्ट करें:
raise_app
यदि सभी ठीक काम करते हैं, तो इसे अपनी पसंद के शॉर्टकट कुंजी संयोजन में जोड़ें: चुनें: सिस्टम सेटिंग्स> "कीबोर्ड"> "शॉर्टकट"> "कस्टम शॉर्टकट"। "+" पर क्लिक करें और कमांड जोड़ें
लिपी
#!/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"')
विकल्प 5: लॉन्चर आइकन से चल रहे अनुप्रयोगों की खिड़कियां बढ़ाएं
यह विकल्प लॉन्चर आइकन में मौजूद है, जिसमें वर्तमान में चल रहे अनुप्रयोगों में क्विकलिस्ट है। एक चुनें, और अनुप्रयोगों की सभी विंडो उठाई जाएंगी।
लॉन्चर को स्वचालित रूप से अपडेट किया जाता है जब रनिंग एप्लिकेशन (वर्तमान व्यूपोर्ट पर) की सूची बदल जाती है। क्विकलिस्ट अन्य व्यूपोर्ट पर एक अलग सूची दिखाती है, जहां अन्य एप्लिकेशन की विंडो खोली जाती हैं (अनुकूलन के लिए 1-2 सेकंड का समय लगेगा)।
जैसा कि उल्लेख किया गया है, हालांकि पूरी तरह कार्यात्मक है, यह विकल्प एक अवधारणा के रूप में है । यह है के रूप में यह कुछ मामूली कॉस्मेटिक downsides है। सबसे महत्वपूर्ण:
- कर्सर "पहिया" एक कार्रवाई के बाद कुछ सेकंड के लिए घूमता रहता है। यद्यपि यह कार्यक्षमता को प्रभावित नहीं करता है, यह एक कॉस्मेटिक नकारात्मक पक्ष है।
- लांचर आइकन में एप्लिकेशनलिस्ट के लिए 1-2 सेकंड लगते हैं, जो चल रहे एप्लिकेशन परिवर्तनों की सूची के बाद अपडेट किए जाते हैं।
इसके अलावा सेटअप थोड़ा और अधिक जटिल है (हालांकि नीचे विस्तार से समझाया गया है):
कैसे इस्तेमाल करे
नीचे आप पाएंगे:
दो स्क्रिप्ट / एक आइकन / एक .desktopफ़ाइल
- सेटअप को "कैसे उपयोग करें" के रूप में तैयार करें, पहले (मुख्य-) स्क्रिप्ट को इस रूप
raise_appमें सहेजें~/bin
नीचे दिए गए आइकन को सहेजें (राइट-क्लिक करें, इस रूप में सहेजें) raise.png
.desktopफाइल को एक खाली फाइल में कॉपी करें, लाइन को एडिट करें
Icon=/path/to/raise.png
आइकन के लिए वास्तविक पथ (उद्धरण के बीच रिक्त स्थान के साथ पथ)
इसे इस रूप raise.desktopमें सहेजें~/.local/share/applications
.desktopइसे जोड़ने के लिए फ़ाइल को लॉन्चर में खींचें
- दूसरी स्क्रिप्ट को कॉपी करें, इसे एक खाली फाइल में पेस्ट करें, इसे इस रूप
update_appsमें सहेजें ~/bin, इसे निष्पादन योग्य बनाएं।
अपने स्टार्टअप एप्लिकेशन में निम्नलिखित कमांड जोड़ें (डैश> स्टार्टअप एप्लिकेशन> जोड़ें):
update_apps
- इसे काम करने के लिए लॉग आउट और बैक करें।
पहली स्क्रिप्ट
#!/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
दूसरी लिपि
#!/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)
.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=
संक्षिप्त विवरण
ऊपर दिए गए सभी समाधान कमांड wmctrlका उपयोग करते हुए, एक विंडो सूची बनाने के लिए उपयोग करते हैं wmctrl -lpG। यह कमांड लाइन बनाती है, जैसे कि:
0x044000b3 0 3429 65 24 1615 1026 jacob-System-Product-Name unity - How to show all windows of an application? - Ask Ubuntu - Mozilla Firefox
इन पंक्तियों में शामिल हैं:
- पहला कॉलम: विंडो की आईडी (जिसे हम इसे बढ़ाने के लिए उपयोग कर सकते हैं)
- तीसरा स्तंभ: खिड़की का मालिक है।
- 4th / 5th कॉलम: विंडो की ज्यामिति xy (जिसका उपयोग हम यह देखने के लिए करते हैं कि विंडो वर्तमान व्यूपोर्ट, icw पर है
xrandr)
ps -u <username>एप्लिकेशन के "उपयोगकर्ता-पढ़ने योग्य" पहचान (नाम) प्राप्त करने के लिए आउटपुट में pid को देखा गया है ।
इस प्रकार हम अनुप्रयोगों के लिए विंडो आवंटित कर सकते हैं। बाद में हम forकमांड के साथ लूप में दिए गए एप्लिकेशन की विंडो बढ़ा सकते हैं wmctrl -ia।
विकल्प 3
में स्क्रिप्ट 3- सेकंड "प्रतीक्षा" लूप शुरू करती है, xprop -rootकमांड का उपयोग करके बार-बार यह देखने के लिए कि क्या सबसे सामने वाली खिड़की है; यह तब होगा जब उपयोगकर्ता किसी एप्लिकेशन की विंडो बढ़ाने के लिए लॉन्चर आइकन पर क्लिक करता है, या सीधे विंडो पर क्लिक करता है। यदि हां, तो लूप टूट जाता है और "नया" सबसे आगे का एप्लिकेशन दिखता है, और बाद में उस एप्लिकेशन की अन्य सभी विंडो उठाता है।
