मैं एक के रूप में खिड़कियों को कैसे खड़ा कर सकता हूं?


10

मेरे पास दो खिड़कियां हैं, ए और बी। क्या किसी तरह दो खिड़कियों को एक साथ जोड़ना संभव है, जैसे कि ए पर स्विच करना भी बी को बढ़ाता है, या बी को स्विच करना भी ए को बढ़ाता है?

मैं समझता हूं कि कई कार्यस्थानों का उपयोग करना एक वैकल्पिक विकल्प है लेकिन सोच रहा था कि क्या यह भी संभव है?


z- आदेश सुपर महत्वपूर्ण नहीं है, लेकिन यदि संभव हो तो महान होगा
साइमन टोंग

मुझे लगता है कि कई कार्यस्थल अब तक का सबसे सरल समाधान है। आप उनके बीच स्विच करने के लिए प्रमुख संयोजनों को जानते हैं?
thomasrutter

1
आप एक त्वरित स्वीकर्ता हैं :) फिर भी, यदि आपने मेरे उत्तर पर कुछ टिप्पणी दी है, तो उसकी सराहना करेंगे।
याकूब Vlijm

जवाबों:


9

परिचय

निम्नलिखित स्क्रिप्ट दो विंडो का चयन करने की अनुमति देता है, और जब दोनों खिड़कियां खुली होती हैं, तो यह दोनों खिड़कियों को तब बढ़ाएगा जब उपयोगकर्ता किसी एक पर ध्यान केंद्रित करता है। उदाहरण के लिए, यदि कोई लिंक A और B को चौड़ा करता है, तो A या B में से दोनों को दूसरी विधवाओं से ऊपर उठाया जाएगा।

स्क्रिप्ट को बंद करने के लिए आप killall link_windows.pyटर्मिनल में उपयोग कर सकते हैं , या किसी एक विंडो को बंद करके फिर से खोल सकते हैं। आप Xविंडो-सेलेक्शन पॉपअप डायलॉग्स में से किसी पर भी क्लोज बटन दबाकर एक्जीक्यूशन रद्द कर सकते हैं ।

संभावित मोड़:

  • स्क्रिप्ट के कई उदाहरणों का उपयोग दो खिड़कियों के समूह जोड़े के लिए किया जा सकता है। उदाहरण के लिए, यदि हमारे पास ए, बी, सी और डी हैं, तो हम ए और बी को एक साथ जोड़ सकते हैं, और सी और डी को एक साथ जोड़ सकते हैं।
  • एक सिंगल विंडो के तहत कई विंडो को समूहीकृत किया जा सकता है। उदाहरण के लिए, अगर मैं विंडो B को A, C से A, और D से A से लिंक करता हूं, तो इसका मतलब है कि अगर मैं हमेशा A से स्विच करता हूं, तो मैं एक ही समय में सभी 4 विंडो उठा सकता हूं।

प्रयोग

स्क्रिप्ट को इस रूप में चलाएँ:

python link_windows.py

स्क्रिप्ट पायथन 3 के साथ संगत है, इसलिए इसे भी चला सकते हैं

python3 link_windows.py

दो कमांड लाइन विकल्प हैं:

  • --quietया -q, GUI विंडो को बंद करने की अनुमति देता है। इस विकल्प के साथ आप किसी भी दो विंडो पर माउस से क्लिक कर सकते हैं, और स्क्रिप्ट उन लोगों को जोड़ना शुरू कर देगी।
  • --helpया -h, उपयोग और विवरण की जानकारी प्रिंट करता है।

-hविकल्प निम्न जानकारी का उत्पादन:

$ python3 link_windows.py  -h                                                                                            
usage: link_windows.py [-h] [--quiet]

Linker for two X11 windows.Allows raising two user selected windows together

optional arguments:
  -h, --help  show this help message and exit
  -q, --quiet  Blocks GUI dialogs.

अतिरिक्त तकनीकी जानकारी के माध्यम से देखा जा सकता है pydoc ./link_windows.py, जहां ./यह दर्शाता है कि आपको स्क्रिप्ट के समान निर्देशिका में होना चाहिए।

दो खिड़कियों के लिए सरल उपयोग प्रक्रिया:

  1. एक पॉपअप आपको एक विंडो # 1 का चयन करने के लिए कहेगा, प्रेस OKया हिट Enter। माउस पॉइंटर एक क्रॉस में बदल जाएगा। उन खिड़कियों में से एक पर क्लिक करें जिन्हें आप लिंक करना चाहते हैं।

  2. एक दूसरा पॉपअप आपको विंडो # 2 का चयन करने के लिए कहेगा, प्रेस OKया हिट Enter। फिर से, माउस पॉइंटर एक क्रॉस में बदल जाएगा। उस दूसरी विंडो पर क्लिक करें जिसे आप लिंक करना चाहते हैं। उसके बाद अमल शुरू हो जाएगा।

  3. जब भी आप या तो खिड़की पर ध्यान केंद्रित करते हैं, तो स्क्रिप्ट दूसरी विंडो को ऊपर उठाएगी, लेकिन मूल रूप से चयनित (ध्यान दें - सर्वश्रेष्ठ प्रदर्शन के लिए एक सेकंड की देरी के एक चौथाई के साथ) पर ध्यान केंद्रित करें, इस प्रकार यह महसूस करते हुए कि खिड़कियां एक साथ जुड़ी हुई हैं।

यदि आप दोनों बार एक ही विंडो चुनते हैं, तो स्क्रिप्ट छोड़ देगा। यदि किसी भी समय आप पॉपअप संवाद के करीब बटन पर क्लिक करते हैं, तो स्क्रिप्ट छोड़ देगा।

लिपि स्रोत

GitHub Gist के रूप में भी उपलब्ध है

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Author: Sergiy Kolodyazhnyy
Date:  August 2nd, 2016
Written for: https://askubuntu.com/q/805515/295286
Tested on Ubuntu 16.04 LTS
"""
import gi
gi.require_version('Gdk', '3.0')
gi.require_version('Gtk', '3.0')
from gi.repository import Gdk, Gtk
import time
import subprocess
import sys
import argparse


def run_cmd(cmdlist):
    """ Reusable function for running shell commands"""
    try:
        stdout = subprocess.check_output(cmdlist)
    except subprocess.CalledProcessError:
        sys.exit(1)
    else:
        if stdout:
            return stdout


def focus_windows_in_order(first, second, scr):
    """Raise two user-defined windows above others.
       Takes two XID integers and screen object.
       Window with first XID will have the focus"""

    first_obj = None
    second_obj = None

    for window in scr.get_window_stack():
        if window.get_xid() == first:
            first_obj = window
        if window.get_xid() == second:
            second_obj = window

    # When this  function is called first_obj is alread
    # raised. Therefore we must raise second one, and switch
    # back to first
    second_obj.focus(int(time.time()))
    second_obj.get_update_area()
    # time.sleep(0.25)
    first_obj.focus(int(time.time()))
    first_obj.get_update_area()


def get_user_window():
    """Select two windows via mouse. Returns integer value of window's id"""
    window_id = None
    while not window_id:
        for line in run_cmd(['xwininfo', '-int']).decode().split('\n'):
            if 'Window id:' in line:
                window_id = line.split()[3]
    return int(window_id)


def main():
    """ Main function. This is where polling for window stack is done"""

    # Parse command line arguments
    arg_parser = argparse.ArgumentParser(
        description="""Linker for two X11 windows.Allows raising """ +
                    """two user selected windows together""")
    arg_parser.add_argument(
                '-q','--quiet', action='store_true',
                help='Blocks GUI dialogs.',
                required=False)
    args = arg_parser.parse_args()

    # Obtain list of two user windows
    user_windows = [None, None]
    if not args.quiet:
        run_cmd(['zenity', '--info', '--text="select first window"'])
    user_windows[0] = get_user_window()
    if not args.quiet:
        run_cmd(['zenity', '--info', '--text="select second window"'])
    user_windows[1] = get_user_window()

    if user_windows[0] == user_windows[1]:
        run_cmd(
            ['zenity', '--error', '--text="Same window selected. Exiting"'])
        sys.exit(1)

    screen = Gdk.Screen.get_default()
    flag = False

    # begin watching for changes in window stack
    while True:

        window_stack = [window.get_xid()
                        for window in screen.get_window_stack()]

        if user_windows[0] in window_stack and user_windows[1] in window_stack:

            active_xid = screen.get_active_window().get_xid()
            if active_xid not in user_windows:
                flag = True

            if flag and active_xid == user_windows[0]:
                focus_windows_in_order(
                    user_windows[0], user_windows[1], screen)
                flag = False

            elif flag and active_xid == user_windows[1]:
                focus_windows_in_order(
                    user_windows[1], user_windows[0], screen)
                flag = False

        else:
            break

        time.sleep(0.15)


if __name__ == "__main__":
    main()

टिप्पणियाँ:


चीयर्स मैं वास्तव में प्रभावित हूं। time.sleepस्विचन के बीच का बिट, क्या मैं इसे शून्य करने में सक्षम हूं? क्या देरी का कारण है?
साइमन टोंग

1
@simontong आप उस लाइन की तरह टिप्पणी करने की कोशिश कर सकते हैं # time.sleep(0.25)और यह निष्पादित नहीं करेगा। इसका कारण यह सुनिश्चित करना है कि प्रत्येक विंडो को ठीक से उठाया जाए। अतीत में मेरे अनुभव में, मुझे खिड़कियों पर संचालन के लिए देरी की आवश्यकता थी। मुझे लगता है कि तिमाही-दूसरा विलंब इतना नहीं है। दरअसल, मुझे स्क्रिप्ट में सिर्फ एक और लाइन जोड़ने की जरूरत है, जिससे इसे गति मिल सके। ठीक है ?
सर्गी कोलोडियाज़नी

@simontong ठीक है, मैंने स्क्रिप्ट को अपडेट किया है। अब इसे आजमाओ। तेजी से स्विचिंग होनी चाहिए
सर्गी कोलोडाज़नी

@simontong मैं कुछ अतिरिक्त सुविधाओं को जोड़ने के लिए कुछ मामूली परिवर्धन के साथ स्क्रिप्ट को अपडेट कर रहा हूं। एक बार तैयार होने के बाद मैं आपको बता दूंगा, कृपया मुझे बताएं कि आप क्या सोचते हैं
सर्गी कोलोडियाज़नी

@simontong ने स्क्रिप्ट में अतिरिक्त विकल्प जोड़े, कृपया समीक्षा करें
Sergiy Kolodyazhnyy

6

एक के रूप में खिड़कियों की एक मनमानी संख्या उठाएँ

नीचे दिए गए समाधान से आप दो, तीन या अधिक विंडो के किसी भी संयोजन को चुन सकते हैं और एक कीबोर्ड शॉर्टकट के साथ जोड़ सकते हैं।

स्क्रिप्ट तीन तर्कों के साथ अपना काम करती है:

add

समूह में सक्रिय विंडो जोड़ने के लिए

raise

सेट समूह को बढ़ाने के लिए

clear

समूह को खाली करने के लिए, एक नए समूह को परिभाषित करने के लिए तैयार

लिपी

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

wlist = os.path.join(os.environ["HOME"], ".windowlist")

arg = sys.argv[1]

if arg == "add":
    active = subprocess.check_output([
        "xdotool", "getactivewindow"
        ]).decode("utf-8").strip()
    try:
        currlist = open(wlist).read()
    except FileNotFoundError:
        currlist = []
    if not active in currlist:
        open(wlist, "a").write(active + "\n")
elif arg == "raise":
    group = [w.strip() for w in open(wlist).readlines()]
    [subprocess.call(["wmctrl", "-ia", w]) for w in group]
elif arg == "clear":
    os.remove(wlist)

कैसे इस्तेमाल करे

  1. स्क्रिप्ट की जरूरत है wmctrlऔर xdotool:

    sudo apt-get install wmctrl xdotool
  2. एक खाली फ़ाइल में ऊपर स्क्रिप्ट कॉपी करें, इसे सहेजें groupwindows.py
  3. टेस्ट- स्क्रिप्ट चलाएँ: दो टर्मिनल विंडो खोलें, कमांड चलाएँ:

    python3 /absolute/path/to/groupwindows.py add

    उन दोनों में। उन्हें अन्य खिड़कियों के साथ कवर करें (या उन्हें कम से कम)। तीसरा टर्मिनल विंडो खोलें, कमांड चलाएँ:

    python3 /absolute/path/to/groupwindows.py raise

    पहले दो खिड़कियों को एक के रूप में उठाया जाएगा।

  4. यदि सभी ठीक काम करते हैं, तो तीन कस्टम शॉर्टकट कुंजियाँ बनाएँ: चुनें: सिस्टम सेटिंग्स> "कीबोर्ड"> "शॉर्टकट"> "कस्टम शॉर्टकट"। "+" पर क्लिक करें और नीचे दिए गए आदेशों को तीन अलग-अलग शॉर्टकट में जोड़ें:

    मेरे सिस्टम पर, मैंने उपयोग किया:

    Alt+ A, कमांड चलाना:

    python3 /absolute/path/to/groupwindows.py add

    ... समूह में एक विंडो जोड़ने के लिए।

    Alt+ R, कमांड चलाना:

    python3 /absolute/path/to/groupwindows.py raise

    ... समूह को बढ़ाने के लिए।

    Alt+ C, कमांड चलाना:

    python3 /absolute/path/to/groupwindows.py clear

    ... समूह को साफ करने के लिए

व्याख्या

स्क्रिप्ट काफी सरलता से काम करती है:

  • जब तर्क के साथ चलाया जाता है add, तो स्क्रिप्ट एक छिपी हुई फ़ाइल में सक्रिय विंडो की आईडी को स्टोर / जोड़ देती है~/.windowlist
  • जब तर्क के साथ चलाया जाता है raise, तो स्क्रिप्ट फ़ाइल पढ़ती है, कमांड के साथ सूची में विंडो उठाती है:

    wmctrl -ia <window_id>
  • जब तर्क के साथ चलाया जाता है clear, तो स्क्रिप्ट छिपी हुई फ़ाइल को हटा देती है ~/.windowlist

टिप्पणियाँ

  • स्क्रिप्ट न्यूनतम विंडो पर भी काम करेगी, यह अन-मिनिमाइज संभवतया न्यूनतम विंडो होगी
  • यदि विंडो का सेट दूसरे व्यूपोर्ट पर है, तो स्क्रिप्ट संबंधित व्यूपोर्ट पर स्विच हो जाएगी
  • सेट फ्लेक्सिबेल है, आप हमेशा वर्तमान सेट में अन्य विंडो जोड़ सकते हैं।

अधिक लचीलापन?

जैसा कि उल्लेख किया गया है, ऊपर दी गई स्क्रिप्ट किसी भी समय समूहीकृत खिड़कियों में खिड़कियां जोड़ने की अनुमति देती है। नीचे दिया गया संस्करण भी समूहीकृत सूची से किसी भी विंडो (किसी भी समय) को हटाने की अनुमति देता है :

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

wlist = os.path.join(os.environ["HOME"], ".windowlist")
arg = sys.argv[1]
# add windows to the group
if arg == "add":
    active = subprocess.check_output([
        "xdotool", "getactivewindow"
        ]).decode("utf-8").strip()
    try:
        currlist = open(wlist).read()
    except FileNotFoundError:
        currlist = []
    if not active in currlist:
        open(wlist, "a").write(active + "\n")
# delete window from the group
if arg == "delete":
    try:
        currlist = [w.strip() for w in open(wlist).readlines()]
    except FileNotFoundError:
        pass
    else:
        currlist.remove(subprocess.check_output([
            "xdotool", "getactivewindow"]).decode("utf-8").strip())      
        open(wlist, "w").write("\n".join(currlist)+"\n")
# raise the grouped windows
elif arg == "raise":
    group = [w.strip() for w in open(wlist).readlines()]
    [subprocess.call(["wmctrl", "-ia", w]) for w in group]
# clear the grouped window list
elif arg == "clear":
    os.remove(wlist)

स्क्रिप्ट को चलाने के लिए अतिरिक्त तर्क है delete, इसलिए:

python3 /absolute/path/to/groupwindows.py delete

समूहित खिड़कियों से सक्रिय विंडो को हटाता है। इस कमांड को चलाने के लिए, अपने सिस्टम पर, मैंने शॉर्टकट के रूप में Alt+ सेट किया D

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.