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 cycle():
"""
Cycles the windows in an i3 workspace.
"""
last_focused_id = _load()
# Get focused workspace name
wksp_name = _get_focused_workspace()['name']
# Get actual workspace tree object
wksp = i3.filter(type='workspace', name=wksp_name)[0]
# Get list of all windows in workspace
wksp_windows = _leaves(wksp['nodes'])
window_ids = map(lambda n: n['id'], wksp_windows)
# Go to next window if saved state exists
if last_focused_id in window_ids:
next_idx = window_ids.index(last_focused_id) + 1
if next_idx >= len(wksp_windows):
next_idx = 0
next_focus_id = wksp_windows[next_idx]['id']
# Set default state, first unfocused
else:
unfocused = filter(lambda n: not n['focused'], wksp_windows)
next_focus_id = unfocused[0]['id']
_write(next_focus_id)
i3.focus(con_id=next_focus_id)
def cycle(window_exe, window_title, window_class):
current = i3.filter(nodes=[], focused=True)
try:
current_title = current[0]["window_properties"]["title"]
current_class = current[0]["window_properties"]["class"]
# There are not this parameters in current
# That happens when trying to run a program in a empty workspace
except:
i3.command('exec', window_exe)
return
if current_class == window_class or current_title == window_title:
return
else:
other = i3.filter(nodes=[], focused=False)
for window in other:
try:
this_window_title = window['window_properties']['title']
this_window_class = window['window_properties']['class']
if this_window_class == window_class or this_window_title == window_title:
i3.focus(con_id=window['id'])
return
except:
pass
i3.command('exec', window_exe)
def focus_next_on_any_output():
# Get all visible workspace(s) - the workspace(s) currently visible on output(s)
workspaces = i3.filter(i3.get_workspaces(), visible=True)
# Get list containing num of the visible workspaces
workspaces_num = [ ws['num'] for ws in workspaces ]
# Get visible nodes
nodes = [ i3.filter(num=ws_num)[0]['nodes'] for ws_num in workspaces_num ]
# Get focused node
curr = i3.filter(nodes, focused=True)[0]
# Get ids of all nodes
ids = [win['id'] for win in i3.filter(nodes, nodes=[])]
# Get index of next node
next_idx = (ids.index(curr['id']) + 1) % len(ids)
# Set id of next node
next_id = ids[next_idx]
# Focus next node
i3.focus(con_id=next_id)
def cycle():
"""
Cycles the windows in an i3 workspace.
"""
last_focused_id = _load()
# Get focused workspace name
wksp_name = _get_focused_workspace()['name']
# Get actual workspace tree object
wksp = i3.filter(type='workspace', name=wksp_name)[0]
# Get list of all windows in workspace
wksp_windows = _leaves(wksp['nodes'])
window_ids = map(lambda n: n['id'], wksp_windows)
# Go to next window if saved state exists
if last_focused_id in window_ids:
next_idx = window_ids.index(last_focused_id) + 1
if next_idx >= len(wksp_windows):
next_idx = 0
next_focus_id = wksp_windows[next_idx]['id']
# Set default state, first unfocused
else:
unfocused = filter(lambda n: not n['focused'], wksp_windows)
next_focus_id = unfocused[0]['id']
_write(next_focus_id)
i3.focus(con_id=next_focus_id)
def main():
tree = i3.get_tree()
result = {}
win_map = {}
focused_window = None
for output in tree['nodes']:
if output['name'].startswith('__'):
continue
result.update(handle_output(output['nodes']))
text_list = []
for workspace in result:
for win in result[workspace]:
text_list.append(u"{kind} [{workspace}] -> {name} #{wid}".format(wid=win['id'],
workspace=workspace,
kind=win['class'],
name=win['name']))
win_map[win['id']] = win
if win['focused']:
focused_window = win
old_output = get_active_output_name(focused_window)
answer = dmenu(sorted(text_list), dmenu_cmd('select window: ', ))
if answer:
wid = answer.split('#')[-1]
i3.focus(id=wid)
if old_output != get_active_output_name(win_map[int(wid)]):
os.system("i3-msg 'move workspace to output left'")
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 make_unfocused(current_id):
"""Reset the window's property to non-floating.
This automatically resets size and position as well.
"""
i3.focus(con_id=current_id)
i3.floating('disable')
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 focus_num(switch_to_num):
parent = i3.parent(i3.filter(focused=True)[0]['id'])
print(parent)
if len(parent['nodes']) >= switch_to_num:
switch_to_cont = parent['nodes'][switch_to_num]
i3.focus(con_id=switch_to_cont['id'])
while i3.focus('child')[0]:
pass
def focus_num(switch_to_num):
parent = i3.parent(i3.filter(focused=True)[0]['id'])
print(parent)
if len(parent['nodes']) >= switch_to_num:
switch_to_cont = parent['nodes'][switch_to_num]
i3.focus(con_id=switch_to_cont['id'])
while i3.focus('child')[0]:
pass
def focus_num(idx):
focused_container = i3.filter(focused=True)[0]
top_container = get_top_parent_of(focused_container)
if top_container is not None and len(top_container['nodes']) > idx:
target_container_id = top_container['nodes'][idx]['id']
i3.focus(con_id=target_container_id)
while i3.focus('child')[0]:
pass
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 create_tmp(current_id):
"""Create a temporary window"""
i3.focus(con_id=current_id, title="tmp_window")
i3.split('vertical')
# we don't want the tmp window to have a border
opts = ["border none"]
i3.open(*opts)
def focus_next():
num = i3.filter(i3.get_workspaces(), focused=True)[0]['num']
ws_nodes = i3.filter(num=num)[0]['nodes']
curr = i3.filter(ws_nodes, focused=True)[0]
ids = [win['id'] for win in i3.filter(ws_nodes, nodes=[])]
next_idx = (ids.index(curr['id']) + 1) % len(ids)
next_id = ids[next_idx]
i3.focus(con_id=next_id)
def cycle():
# 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
for window in other:
i3.focus(con_id=window['id'])
time.sleep(0.5)
# focus the original windows
for window in current:
i3.focus(con_id=window['id'])
def cycle():
# 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
for window in other:
i3.focus(con_id=window['id'])
time.sleep(0.5)
# focus the original windows
for window in current:
i3.focus(con_id=window['id'])
def main():
i3.workspace(str(first_free()))
i3.layout('default')
i3.exec(browser)
time.sleep(1) # give browser window time to spawn
i3.exec(term)
time.sleep(0.5) # give terminal window time to spawn
i3.split('v')
i3.layout('stacking')
i3.focus('left')
i3.split('v')
i3.layout('stacking')
def fibonacci(num):
i3.exec(term)
time.sleep(0.5)
if num % 2 == 0:
if num % 4 == 0:
i3.focus("up")
i3.split("h")
else:
if num % 4 == 1:
i3.focus("left")
i3.split("v")
if num > 1:
fibonacci(num - 1)
def fibonacci(num):
i3.exec(term)
time.sleep(0.5)
if num % 2 == 0:
if num % 4 == 0:
i3.focus('up')
i3.split('h')
else:
if num % 4 == 1:
i3.focus('left')
i3.split('v')
if num > 1:
fibonacci(num - 1)
def fibonacci(num):
i3.exec(term)
time.sleep(0.5)
if num % 2 == 0:
if num % 4 == 0:
i3.focus('up')
i3.split('h')
else:
if num % 4 == 1:
i3.focus('left')
i3.split('v')
if num > 1:
fibonacci(num - 1)
def copied_alt_tab():
num = i3.filter(i3.get_workspaces(), focused=True)[0]['num']
all_nodes = flatten_lists(list(map(get_nodes, i3.filter())))
curr = i3.filter(all_nodes, focused=True)[0]
print(get_id(curr))
ids = list(map(get_id, all_nodes)) + [get_id(curr)]
print(ids)
next_id = ids[(ids.index(curr['id']) + 2) % len(ids)]
print(next_id)
i3.focus(con_id=next_id)
def main():
tree = check_output(['i3-msg', '-t', 'get_tree']).decode('UTF-8').strip()
root = json.loads(tree)
current = findWindow(root)
current_id = current['id']
if "on" in current['floating']:
tmp_id = find_tmp(root)
if tmp_id != None:
i3.focus(con_id=tmp_id)
make_unfloat(current_id)
destroy_tmp(tmp_id)
else:
if find_tmp(root) == None:
create_tmp(current_id)
make_float(current_id)
def main():
current = i3.filter(nodes=[], focused=True)[0]
current_id = current['id']
if "on" in current['floating']:
tmp_id = find_tmp()
if tmp_id != None:
i3.focus(con_id=tmp_id)
make_unfloat(current_id)
destroy_tmp(tmp_id)
else:
make_unfloat()
else:
if find_tmp() == None:
create_tmp(current_id)
make_float(current_id)
def main():
current = i3.filter(nodes=[], focused=True)[0]
current_id = current['id']
if "on" in current['floating']:
tmp_id = find_tmp()
if tmp_id != None:
i3.focus(con_id=tmp_id)
make_unfloat(current_id)
destroy_tmp(tmp_id)
else:
make_unfloat()
else:
if find_tmp() == None:
create_tmp(current_id)
make_float(current_id)
def cycle():
# get workspace focused on each screen
workspace_per_screen = i3.get_outputs()
# 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
for window in other:
i3.focus(con_id=window['id'])
time.sleep(0.5)
# focus the old workspace on each screen
for wks in workspace_per_screen:
i3.workspace(wks['current_workspace'])
# focus the original windows
for window in current:
i3.focus(con_id=window['id'])
def cycle():
# get workspace focused on each screen
workspace_per_screen = i3.get_outputs()
# 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
for window in other:
i3.focus(con_id=window['id'])
time.sleep(0.5)
# focus the old workspace on each screen
for wks in workspace_per_screen:
i3.workspace(wks['current_workspace'])
# focus the original windows
for window in current:
i3.focus(con_id=window['id'])
def fibonacci(num):
i3.exec(prog)
i3.border('1pixel')
time.sleep(0.5)
if num % 2 == 0:
i3.border('1pixel')
if num % 4 == 0:
i3.focus('up')
i3.border('1pixel')
i3.split('h')
i3.border('1pixel')
else:
i3.border('1pixel')
if num % 4 == 1:
i3.focus('left')
i3.split('v')
if num > 1:
fibonacci(num - 1)
def fibonacci(num):
i3.exec(prog)
i3.border('none')
i3.gaps('inner', 'all', 'set', '15')
time.sleep(0.5)
if num % 2 == 0:
i3.border('none')
if num % 4 == 0:
i3.focus('up')
i3.border('none')
i3.split('h')
i3.border('none')
else:
i3.border('none')
if num % 4 == 1:
i3.focus('left')
i3.split('v')
if num > 1:
fibonacci(num - 1)
def focus_next(): # get the workspaces num = i3.filter(i3.get_workspaces(), focused=True)[0]['num'] # get all windows all_nodes = i3.filter(num=num)[0]['nodes'] #for node in i3.filter(num=num)[0]['floating_nodes']: # if not node['window'] == None: # all_nodes = all_nodes + node #all_nodes = all_nodes + i3.filter(num=num)[0]['floating_nodes'] # find the currently focused window current_win = i3.filter(all_nodes, focused=True)[0] # find all id's all_ids = [win['id'] for win in i3.filter(all_nodes, nodes=[])] # get the next one next_idx = (all_ids.index(current_win['id']) + 1) % len(all_ids) next_win = all_ids[next_idx] # fokus i3.focus(con_id=next_win)
def main():
"""
Entry point
"""
parser = ArgumentParser()
parser.add_argument("direction",
choices=("up", "down", "left", "right", "next",
"prev"),
help="Direction to put the focus on")
args = parser.parse_args()
tree = i3Tree()
con = None
if args.direction in ("next", "prev"):
con = cycle_outputs(tree, args.direction)
else:
con = cycle_windows(tree, args.direction)
if con:
i3.focus(con_id=con.id)
def flip(single_column=False):
focused_workspace = get_focused_workspace()
focused_output = xinerama_number(focused_workspace)
queue = []
for workspace in workspaces:
workspace_output = xinerama_number(workspace)
should_flip = (not single_column
or focused_output % 2 == workspace_output % 2)
if (should_flip):
add_to_queue(workspace, queue)
for command in queue:
i3.command(command)
# Restore focus to originally focused workspace
# Race conditions apply where focus is lost on movement, so sleep!
time.sleep(0.25)
i3.focus("output " + get_target_output(focused_workspace))
def focus_next_on_output():
# Get num of the focused workspace
ws_num = i3.filter(i3.get_workspaces(), focused=True)[0]['num']
# Get nodes on workspace
ws_nodes = i3.filter(num=ws_num)[0]['nodes']
# Get focused node
curr = i3.filter(ws_nodes, focused=True)[0]
# Get ids of all nodes
ids = [win['id'] for win in i3.filter(ws_nodes, nodes=[])]
# Get index of next node
next_idx = (ids.index(curr['id']) + 1) % len(ids)
# Set id of next node
next_id = ids[next_idx]
# Focus next node
i3.focus(con_id=next_id)
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():
"""Grab the current window, and, if it's not floating,
replace it with an empty window and make it floating,
thus giving it focus among the other windows.
"""
current = i3.filter(nodes=[], focused=True)[0]
current_id = current['id']
if "on" in current['floating']:
tmp_id = find_tmp()
if tmp_id is not None:
i3.focus(con_id=tmp_id)
make_unfocused(current_id)
destroy_tmp(tmp_id)
else:
make_unfocused(current_id)
else:
# only focus a window if no other is already focused
if find_tmp() is None:
create_tmp(current_id)
make_focused(current_id)
def main():
"""
Entry point
"""
parser = ArgumentParser()
parser.add_argument("direction",
choices=(
"up", "down", "left", "right",
"next", "prev"
),
help="Direction to put the focus on")
args = parser.parse_args()
tree = i3Tree()
con = None
if args.direction in ("next", "prev"):
con = cycle_outputs(tree, args.direction)
else:
con = cycle_windows(tree, args.direction)
if con:
i3.focus(con_id=con.id)
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()
def jump_next_tab(n_tab=1):
focused_container = i3.filter(focused=True)[0]
tab_container = get_tab_parent(focused_container)
all_tab_ids = [node['id'] for node in tab_container['nodes']]
focus_tab_idx = get_container_idx_in_parent(
tab_container,
focused_container,
)
i3.focus(con_id=all_tab_ids[(focus_tab_idx + n_tab) % len(all_tab_ids)])
i3.focus('child')
i3.focus('child')
def make_unfloat(current_id):
i3.focus(con_id=current_id)
i3.floating('disable')
def enable_focus(self):
id, child = self.get_current_i3_container()
i3.focus(con_id=id)
def focus(window):
'''Focuses the given window.'''
return i3.focus(id=window)
import sys
current_node = i3.filter(focused=True)[0]
node = current_node
while node.get('type') != 4:
node = i3.parent(node['id'])
all_windows = i3.filter(type=2, tree=node, nodes=[])
if not all_windows:
sys.exit(0)
for num, window in enumerate(all_windows):
if window['id'] == current_node['id']:
break
if sys.argv[1] == 'next':
try:
new_focus = all_windows[num + 1]
except IndexError:
new_focus = all_windows[0]
elif sys.argv[1] == 'prev':
try:
new_focus = all_windows[num - 1]
except IndexError:
new_focus = all_windows[-1]
else:
sys.exit(1)
i3.focus(con_id=new_focus['id'])
#!/usr/bin/env python
import io
import i3
UNREAD_FILE = "/tmp/unread_notifications"
def reset_counter_file():
try:
fp = io.open(UNREAD_FILE, "w")
fp.write(u"0")
fp.close()
except:
pass
if __name__=="__main__":
reset_counter_file()
i3.focus(title="Devecoop Slack")
def focus(window):
"""Focuses the given window."""
return i3.focus(id=window)
#!/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']
def make_float(current_id):
i3.focus(con_id=current_id)
i3.floating('enable')
i3.resize('set 1000 1000')
i3.move('position center')
def make_unfloat(current_id):
i3.focus(con_id=current_id)
i3.floating('disable')
def create_tmp(current_id):
i3.focus(con_id=current_id)
i3.split('vertical')
i3.open()
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
from utils import workspaces, dmenu
from utils.children import get_scratchpad_children
from pprint import pprint
reverse_dict = {}
l = []
i = 0
for id, child in get_scratchpad_children().iteritems():
name, mark = child["name"], child["mark"]
if mark:
str = "{} - {} - {}".format(i, name, mark)
else:
str = "{} - {}".format(i, name)
i = i + 1
l.append(str)
reverse_dict[str] = id
str = dmenu.dmenu(l).strip()
id = reverse_dict[str]
i3.focus(con_id=id)
def focus(window):
"""Focuses the given window."""
return i3.focus(id=window)
def test_criteria(self):
self.assertTrue(i3.focus(clasS='xterm'))
def create_tmp(current_id):
i3.focus(con_id=current_id)
i3.split('vertical')
i3.open()
#!/usr/bin/python
import i3
import subprocess
import sys
if __name__ == '__main__':
direction = str(sys.argv[1])
xdo_cmd_dict = {
'left': 'control+h',
'down': 'control+j',
'up': 'control+k',
'right': 'control+l'
}
current = i3.filter(nodes=[], focused=True)[0]
if 'GVIM' in current['name']:
wid = current['window']
xdotool_call = ["xdotool", "key", "--window", str(wid), xdo_cmd_dict[direction]]
subprocess.call(xdotool_call)
else:
i3.focus(direction)
else:
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'])
if win_str in instances:
instances[win_str] += 1
win_str = '%s (%d)' % (win_str, instances[win_str])
else:
instances[win_str] = 1
clients[win_str] = window['id']
return clients
def win_menu(clients, l=10):
"""
Displays a window menu using dmenu. Returns window id.
"""
dmenu = subprocess.Popen(['/usr/bin/dmenu', '-i', '-l', str(l),
'-fn', '"-*-cure-medium-*-*-*-11-*-*-*-*-*-*-*"',
'-nb', '#101010', '-nf', '#5f5f5f', '-sb', '#191919',
'-sf', '#b72f62'],
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('utf-8')\
.rstrip()
return clients.get(win_str, None)
if __name__ == '__main__':
clients = i3clients()
win_id = win_menu(clients)
if win_id:
i3.focus(con_id=win_id)
def focus(window):
'''Focuses the given window.'''
return i3.focus(id=window)
def revisualize(node, workspace_name):
i3.focus(con_id=node['id'])
i3.move('to workspace ' + workspace_name)
i3.floating('disable')
