def xmonify(): # get currently focused windows current = i3.filter(nodes=[], focused=True) # get unfocused windows other = i3.filter(nodes=[], focused=False) # focus each previously unfocused window for 0.5 seconds # The following is done in a hackish way as there is no way to wait for a # successfull ending of previous command for window in other: status = i3.focus(con_id=window['id']) status = i3.move('workspace temp') for window in current: status = i3.focus(con_id=window['id']) status = i3.move('workspace 1') counter = 0 for window in other: status = i3.focus(con_id=window['id']) status = i3.move('workspace 1') if counter==0: status = i3.command("split", "v") counter += 1 for window in current: i3.focus(con_id=window['id'])
def dispatch_i3msg_com( command: str, data: Location = Location(1189, 652)) -> list: """Internal function used to dispatch specific command strings to i3-ipc. Data may also be a string.""" dispatcher = { # Dictionary of commands to execute with i3 comx "resize": lambda *d: i3.resize("set", d[0], d[1]), "move": lambda *d: i3.move("window", "position", d[0], d[1]), "float": lambda *d: i3.floating("enable"), "reset": lambda *d: (i3.resize("set", f"{d[0]}ppt", f"{d[0]}ppt") and i3.move( "window", " position", "center")), "custom": (lambda *d: i3.resize("set", d[0], d[0]) and i3.move( "window", "position", "center")), } if isinstance(data, str): return dispatcher[command](data) elif isinstance(data, Location): w = str(data.width) if data.width > 0 else "0" h = str(data.height) if data.height > 0 else "0" return dispatcher[command](w, h)
def xmonify(): # get currently focused windows current = i3.filter(nodes=[], focused=True) # get unfocused windows other = i3.filter(nodes=[], focused=False) # focus each previously unfocused window for 0.5 seconds # The following is done in a hackish way as there is no way to wait for a # successfull ending of previous command for window in other: status = i3.focus(con_id=window['id']) status = i3.move('workspace temp') for window in current: status = i3.focus(con_id=window['id']) status = i3.move('workspace 1') counter = 0 for window in other: status = i3.focus(con_id=window['id']) status = i3.move('workspace 1') if counter == 0: status = i3.command("split", "v") counter += 1 for window in current: i3.focus(con_id=window['id'])
def main(): windows = scratchpad_windows() # search for focused window among scratchpad windows if i3.filter(windows, focused=True): # move that window back to scratchpad i3.move('scratchpad') # show the next scratchpad window i3.scratchpad('show')
def moveto_ws(): direction = sys.argv[2] if direction == 'prev': i3.move('container to workspace' + prev_ws()) elif direction == 'next': i3.move('container to workspace' + next_ws()) else: print("unsupported second parameters")
def main(): active_screens = get_active_screens() current_workspace = get_focused_workspace() other_screen = next( filter(lambda x: x['current_workspace'] != current_workspace['name'], active_screens)) i3.move("workspace to output", other_screen['name'])
def make_focused(current_id): """Make the focused window floating, set its dimensions and position. """ i3.focus(con_id=current_id) i3.floating('enable') i3.resize(f'set {WIDTH} {HEIGHT}') i3.move('position center')
def cmd_move_group_output(output): ws = i3.get_workspaces() group, current_wnum = get_wgroup(ws) wids = wids_by_furthest(ws, group, current_wnum) print 'move_group_output', output, '->', wids i3_move_args = ['workspace', 'to', output] for wid in wids: i3.workspace(str(wid)) i3.move(*i3_move_args)
def apply_output_order(order=list(range(5))): # The length changes in the loop due to pop() so we need to save it iters = len(order) while len(order) > 0: idx = order.pop() for i in range(iters): i3.workspace('10') i3.focus(title=str(idx)) result = i3.move('left')
def main(): # workspaces workspaces = i3.get_workspaces() workints = list() # get currently focused windows current = i3.filter(nodes=[], focused=True) # find a free one for w in workspaces: workints.append(w['num']) for i in range(1, 11): if i not in workints: break print(i) for window in current: i3.move("container", "to", "workspace", str(i))
def main(argv1): currentLang = os.popen( "~/softwares/xkblayout-state/xkblayout-state print %n").read() if currentLang == "Hebrew": if argv1 == "whats-app": argv1 = "slack" else: argv1 = "whats-app" os.system("setxkbmap us") apps = ["slack", "whats-app"] if isAppInFocus(argv1): i3.focus(instance=argv1) i3.move('scratchpad') for app in apps: if isAppInFocus(app): i3.move('scratchpad') else: if argv1 == "whats-app": os.system("setxkbmap il") i3.scratchpad('show', instance=argv1 + ".*")
def main(): # The color count should correspond to the output count color_count = 5 # Spread color_count hues evenly in HSV space hues = np.linspace(0, 1, num=color_count + 1)[:-1] rgbs = [] # Convert each hue to RGB for hue in hues: rgbs.append(colorsys.hsv_to_rgb(hue, 1, 1)) rgbs = list(zip(np.arange(len(rgbs)), rgbs)) print("indexes: %s" % [idx for idx, rgb in rgbs]) for idx, color in rgbs: display_rect(color, idx) plt.show(False) i3.focus(title=str(idx)) i3.move('workspace 10') input()
'-nf', '#00C1FF', '-sb', '#00A0DD', '-sf', '#FFFFFF'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) menu_str = '\n'.join(sorted(clients.keys())) # Popen.communicate returns a tuple stdout, stderr win_str = dmenu.communicate(menu_str.encode('utf-8'))[0].decode().rstrip() return win_str if __name__ == '__main__': clients = i3clients() win_str = win_menu(clients) try: clients[win_str] except: i3.mark(win_str) raise SystemExit con_id = clients[win_str]['con_id'] i3.focus(con_id=con_id) workspaces = i3.get_workspaces() for w in workspaces: if w["focused"]: goto = w["num"] break i3.move("container", "to", "workspace", str(goto)) i3.workspace(str(goto))
#!/usr/bin/env python3 import i3 scratch = i3.filter(name="__i3_scratch")[0] if scratch["floating_nodes"]: i3.scratchpad("show") else: i3.move("scratchpad")
workspaces = i3.get_workspaces() currentnum = i3.filter(workspaces, focused=True)[0]['num'] if sys.argv[1] == 'next': workspace_next = i3.filter(workspaces, num=currentnum+1) if len(workspace_next) == 0: workspace_next = workspaces[0] else: workspace_next = workspace_next[0] else: workspace_next = i3.filter(workspaces, num=currentnum-1) if len(workspace_next) == 0: workspace_next = workspaces[-1] else: workspace_next = workspace_next[0] print workspace_next ws_nodes = i3.filter(num=currentnum)[0]['nodes'] ws_nodes = ws_nodes + i3.filter(num=currentnum)[0]['floating_nodes'] curr = i3.filter(ws_nodes, focused=True)[0] i3.move('container to workspace number %s' % workspace_next['num']) i3.workspace('number %s' % workspace_next['num']) # ids = [win['id'] for win in i3.filter(ws_nodes, nodes=[])] # if sys.argv[0] == 'next': # next_idx = (ids.index(curr['id']) + 1) % len(ids) # else: # next_idx = (ids.index(curr['id']) - 1) % len(ids) # next_id = ids[next_idx] # i3.focus(con_id=next_id)
def cmd_move_and_focus(wmove): wid = dest_wid(wmove) print 'move & focus', wmove, '->', wid wid = str(wid) i3.move('workspace', wid) i3.workspace(wid)
TEMP_WORKSPACE = "swap_outputs.py" active_outputs = [out for out in i3.get_outputs() if out['active']] # Do nothing if there aren't more than one active ouput if len(active_outputs) < 2: sys.exit() a, b = active_outputs[:2] print("{} <-> {}".format(a['current_workspace'], b['current_workspace'])) a_workspace = a['current_workspace'] i3.workspace(a_workspace) time.sleep(0.025) i3.move('workspace to output right') time.sleep(0.025) i3.workspace(a_workspace) time.sleep(0.025) i3.rename('workspace to', TEMP_WORKSPACE) time.sleep(0.025) b_workspace = b['current_workspace'] i3.workspace(b_workspace) time.sleep(0.025) i3.move('workspace to output right') time.sleep(0.025) i3.workspace(b_workspace) time.sleep(0.025) i3.rename('workspace to', a_workspace) time.sleep(0.025)
def make_float(current_id): i3.focus(con_id=current_id) i3.floating('enable') i3.resize('set 1000 1000') i3.move('position center')
def revisualize(node, workspace_name): i3.focus(con_id=node['id']) i3.move('to workspace ' + workspace_name) i3.floating('disable')
def make_float(current_id): size = get_size() i3.focus(con_id=current_id) i3.floating('enable') i3.resize('set {} {}'.format((size + int(size*.56)), size)) i3.move('position center')
def make_float(current_id): size = get_size() i3.focus(con_id=current_id) i3.floating('enable') i3.resize('set {} {}'.format((size + int(size * .56)), size)) i3.move('position center')
#!/usr/bin/env python import i3 import time currentWindow = i3.filter(focused=True)[0] this_id = currentWindow['id'] i3.focus(con_id=this_id) i3.move('scratchpad') i3.focus(con_id=this_id) i3.move('to workspace 10') i3.floating('disable') #parentContainer = i3.parent(currentWindow['id']) #print(parentContainer) #nodes = parentContainer['nodes'] #print([node['name'] for node in nodes]) #for node in nodes: # i3.focus(con_id=node['id']) # i3.move('scratchpad') # #i3.focus(parentContainer['id']) #i3.focus(con_id=node['id']) #i3.move('to workspace 10') ##if parentContainer['layout'] in ['splitv', 'stacked']: ## direction = 'down' ##else: ## direction = 'right' # #nodes = parentContainer['nodes']
import sys import i3 outputs = i3.get_outputs() outputs = i3.filter(outputs, active=True) workspaces = i3.get_workspaces() currentfocus = i3.filter(workspaces, focused=True)[0]['output'] current = 0 for i, workspace in enumerate(outputs): if workspace['name'] == currentfocus: current = i next_workspace = current + 1 if outputs[next_workspace % len(outputs)]['name'] == 'xroot-0': next_workspace += 1 i3.move('workspace to output %s' % outputs[next_workspace % len(outputs)]['name'])
import i3 import sys outputs = i3.get_outputs() outputs = i3.filter(outputs, active=True) outputs = [o["name"] for o in outputs] if len(outputs) == 1: sys.exit(0) workspaces = i3.get_workspaces() candidates = [1, 2, 3] other_workspace = [o for o in outputs if o not in ["eDP1", "xroot-0"]][0] for w in workspaces: if w["num"] not in candidates: continue if w["output"] == "eDP1": i3.move("workspace to output %s" % (other_workspace), workspace=w["name"]) # for workspace in workspaces: # if workspace['output']
#!/usr/bin/env python # https://faq.i3wm.org/question/3189/how-can-i-sort-windows-inside-a-container-automatically/ import i3 currentWindow = i3.filter(focused=True)[0] parentContainer = i3.parent(currentWindow['id']) if parentContainer['layout'] in ['splitv', 'stacked']: direction = 'down' else: direction = 'right' nodes = parentContainer['nodes'] snodes = sorted(nodes, key=lambda n:n['name']) for node in snodes[1:]: i3.focus(con_id=node['id']) i3.move('scratchpad') i3.focus(con_id=nodes[0]['id']) for node in snodes[1:]: i3.focus(con_id=node['id']) i3.floating('disable') i3.focus(con_id=currentWindow['id'])
def get_workspace(container): if container['type'] == 'workspace': return container return get_workspace(i3.parent(container['id'])) def get_leaves(node): if len(node['nodes']) == 0: return [node] children = [] for child in node['nodes']: children.extend(get_leaves(child)) return children currentWindow = i3.filter(focused=True)[0] workspace = get_workspace(currentWindow) workspace_name = workspace['name'] leaves = get_leaves(workspace) for leaf in leaves: i3.focus(con_id=leaf['id']) i3.move('scratchpad') for leaf in leaves: i3.focus(con_id=leaf['id']) i3.move('to workspace ' + workspace_name) i3.floating('disable')
menu = subprocess.Popen( ["rofi", "-dmenu", "-width", "33", "-p", "window: "], stdin=subprocess.PIPE, stdout=subprocess.PIPE) menu_str = "\n".join(sorted(clients.keys())) # Popen.communicate returns a tuple stdout, stderr win_bytes = menu.communicate(menu_str.encode("utf-8"))[0] win_str = win_bytes.decode().rstrip("\n") return win_str if __name__ == "__main__": # Remember current workspace name for ws in i3.get_workspaces(): if ws["focused"]: wsname = ws["name"] break # Get ID and string of the window to focus clients = i3clients() win_str = win_menu(clients) con_id = clients[win_str] if win_str in clients else 0 # No window selected if not con_id: sys.exit(0) # Focus the window i3.focus(con_id=con_id) # If "--get", move the window to the remembered workspace if "--get" in sys.argv: i3.move("container", "to", "workspace", wsname) i3.workspace(wsname)
extra.append(leaf) left.sort(key=lambda n:n['name']) right.sort(key=lambda n:n['name']) extra.sort(key=lambda n:n['name']) print("left") print([node['name'] for node in left]) print("right") print([node['name'] for node in right]) print("extra") print([node['name'] for node in extra]) for leaf in leaves: i3.focus(con_id=leaf['id']) i3.move('scratchpad') i3.focus(con_id=workspace['id']) i3.layout('splitv') for leaf in left: revisualize(leaf, workspace['name']) first_right = right.pop(0) revisualize(first_right, workspace['name']) i3.move('right') i3.split('v') i3.focus(con_id=first_right['id']) for leaf in right: revisualize(leaf, workspace['name'])
#!/usr/bin/env python3 import i3 # Unfortunatelly this doesn't seem to be reliable outputs = sorted((out for out in i3.get_outputs() if out["active"]), key=lambda o: o["rect"]["x"]) outputs.append(outputs[0]) for left, right in zip(outputs, outputs[1:]): i3.workspace(left["current_workspace"]) i3.move("workspace to output {}".format(right["name"]))
workspaces = i3.get_workspaces() currentnum = i3.filter(workspaces, focused=True)[0]['num'] if sys.argv[1] == 'next': workspace_next = i3.filter(workspaces, num=currentnum + 1) if len(workspace_next) == 0: workspace_next = workspaces[0] else: workspace_next = workspace_next[0] else: workspace_next = i3.filter(workspaces, num=currentnum - 1) if len(workspace_next) == 0: workspace_next = workspaces[-1] else: workspace_next = workspace_next[0] print(workspace_next) ws_nodes = i3.filter(num=currentnum)[0]['nodes'] ws_nodes = ws_nodes + i3.filter(num=currentnum)[0]['floating_nodes'] curr = i3.filter(ws_nodes, focused=True)[0] i3.move('container to workspace number %s' % workspace_next['num']) i3.workspace('number %s' % workspace_next['num']) # ids = [win['id'] for win in i3.filter(ws_nodes, nodes=[])] # if sys.argv[0] == 'next': # next_idx = (ids.index(curr['id']) + 1) % len(ids) # else: # next_idx = (ids.index(curr['id']) - 1) % len(ids) # next_id = ids[next_idx] # i3.focus(con_id=next_id)
def cmd_move(wmove): wid = dest_wid(wmove) print 'move', wmove, '->', wid i3.move('workspace', str(wid))
#!/usr/bin/python3 import i3 current_output_name = [ws for ws in i3.get_workspaces() if ws["focused"]][0]["output"] output_names = [ output["name"] for output in i3.get_outputs() if output["current_workspace"] != None ] index = output_names.index(current_output_name) next_output_index = (index + 1) % len(output_names) next_output_name = output_names[next_output_index] i3.move(f"workspace to {next_output_name}")
The formatted string of the window to focus. """ menu = subprocess.Popen(["rofi", "-dmenu", "-width", "33", "-p", "window: "], stdin=subprocess.PIPE, stdout=subprocess.PIPE) menu_str = "\n".join(sorted(clients.keys())) # Popen.communicate returns a tuple stdout, stderr win_bytes = menu.communicate(menu_str.encode("utf-8"))[0] win_str = win_bytes.decode().rstrip("\n") return win_str if __name__ == "__main__": # Remember current workspace name for ws in i3.get_workspaces(): if ws["focused"]: wsname = ws["name"] break # Get ID and string of the window to focus clients = i3clients() win_str = win_menu(clients) con_id = clients[win_str] if win_str in clients else 0 # No window selected if not con_id: sys.exit(0) # Focus the window i3.focus(con_id=con_id) # If "--get", move the window to the remembered workspace if "--get" in sys.argv: i3.move("container", "to", "workspace", wsname) i3.workspace(wsname)
if not os.path.exists(configfile): return default with open(configfile) as f: for line in f: if line.startswith("set $ws"): line_content = line.rstrip("\n") ws_start = " ".join(line_content.split()[0:2]) ws_name = line_content.replace(ws_start, "").strip() ws_names.append(ws_name) return ws_names if ws_names else default if __name__ == '__main__': ws_names = get_workspace_names() ws_nums = [] for w in i3.get_workspaces(): ws_nums.append(w['num']) i = 1 while i in ws_nums: i += 1 first_free = ws_names[i-1] if "--move-to" in sys.argv: i3.move("container", "to", "workspace", first_free) elif "--take-with" in sys.argv: i3.move("container", "to", "workspace", first_free) i3.workspace(first_free) else: i3.workspace(first_free)
import i3 import sys from utils import find_matching, workspace # This script asumes that workspace names are numbers DEFAULT_NAMES = set(range(1,11)) def first_free(occupied): free = DEFAULT_NAMES - set(occupied) return str(min(free)) if free else None if __name__ == "__main__": if len(sys.argv) != 2: print("{} focus|move".format(sys.argv[0]), file=sys.stderr) sys.exit(1) first = first_free((int(w["name"]) for w in find_matching(workspace()))) if not first: print("All workspaces are occupied") sys.exit(3) action = sys.argv[1] if action == "focus": i3.workspace(first) elif action == "move": i3.move("container to workspace {}".format(first)) else: print("Unknown action", file=sys.stderr) sys.exit(2)
#!/usr/bin/python2.7 import i3 outputs = i3.get_outputs() # set current workspace to output 0 i3.workspace(outputs[0]['current_workspace']) # ..and move it to the other output. # outputs wrap, so the right of the right is left ;) i3.move("workspace", "to", "output", "right") # rinse and repeat i3.workspace(outputs[1]['current_workspace']) i3.move("workspace", "to", "output", "right")
#!/usr/bin/env python3 import i3 from utils import find_matching, window, focused_tree, focused_window from uuid import uuid4 as uuid if __name__ == "__main__": mark = str(uuid()) workspace = focused_tree() focused = focused_window() i3.focus(con_id=workspace["id"]) i3.mark(mark) windows = find_matching(window, workspace) for w in windows: i3.focus(con_id=w["id"]) i3.move("window to mark {}".format(mark)) i3.focus(con_id=workspace["id"]) i3.unmark(mark) i3.focus(con_id=focused["id"])