def add_window(self, view):
view = get_view(view)
parent = wlc.view_get_parent(view.handle)
debug('parent is {}'.format(parent))
self.current_workspace.add_window(view)
def pointer_motion(handle, time, position):
debug('pointer_motion: {} at {} to {}'.format(handle, time, position))
state.pointer_motion(handle, time, position)
wlc.pointer_set_position(position)
return 0
def view_created(view):
debug('view_created: {}'.format(view))
global state
state.add_window(view)
return 1
def pointer_button(view, time, modifiers, button, state, position):
debug(
'pointer_button: view {} at {}, modifiers {}, button {}, state {}, position {}'
.format(view, time, modifiers, button, state, position))
if state == lib.WLC_BUTTON_STATE_PRESSED:
wlc.view_focus(view)
return 0
def to_workspace(self, identifier):
debug('state.to_workspace {}: options are {}'.format(
identifier, [w.identifier for w in self.workspaces]))
matching = [w for w in self.workspaces if w.identifier == identifier]
if not matching:
error('Could not switch to workspace "{}", it does not '
'exist'.format(identifier))
self.current_workspace = matching[0]
self.current_workspace.focus()
def set(self, size=None, pos=None):
g = wlc.WlcGeometry()
debug('asked to set size {} pos {}'.format(size, pos))
if size is not None:
g.size.w = size[0]
g.size.h = size[1]
self._size = size
else:
g.size.w = self.size[0]
g.size.h = self.size[1]
if pos is not None:
g.origin.x = pos[0]
g.origin.y = pos[1]
self._pos = pos
else:
g.origin.x = self.pos[0]
g.origin.y = self.pos[1]
wlc.view_set_geometry(self.handle, 0, g)
def do_layout(self, windows):
debug('TwoColumnLayout.do_layout: {} windows'.format(len(windows)))
width_frac = self.separator_frac if len(windows) > 1 else 1
if not windows:
return
window = windows[0]
output_size = window.output.virtual_resolution
output_size = (output_size.w, output_size.h)
debug('output_size is {}'.format(output_size))
window.set(pos=(self.border, self.border),
size=(int(width_frac * output_size[0] - 2 * self.border),
output_size[1] - 2 * self.border))
if len(windows) <= 1:
return
height = output_size[1] / (len(windows) - 1)
width = (1 - width_frac) * output_size[0]
debug('width is {}, height is {}'.format(width, height))
for i, window in enumerate(windows[1:]):
size = (int(width - 2 * self.border),
int(height - 2 * self.border))
if size[0] < 0:
error('Tried to set window width to {}'.format(size[0]))
continue
if size[1] < 0:
error('Tried to set window height to {}'.format(size[1]))
continue
pos = (int(output_size[0] * width_frac + self.border),
int(height * i + self.border))
window.set(size=size, pos=pos)
def left(self):
from vivarium.objects import state
self.separator_frac -= state.layout_step
debug('left: {}.separator_frac = {}'.format(self, self.separator_frac))
self.separator_frac = max(0, self.separator_frac)
def view_focus(view, focus):
debug('view_focus: {} {}'.format(view, focus))
wlc.view_set_state(view, lib.WLC_BIT_ACTIVATED, focus)
def down(self):
debug('state.down')
self.current_workspace.down()
return 1
def up(self):
debug('state.up')
self.current_workspace.up()
return 1
def right(self):
debug('state.right')
self.current_workspace.right()
return 1
def left(self):
debug('state.left')
self.current_workspace.left()
return 1
def keyboard_key(view, time, modifiers, key, key_state):
debug('keyboard_key: view {} at {}, modifiers {}, key {}, key_state {}'.
format(view, time, modifiers, key, key_state))
return state.keyboard_key(view, time, modifiers, key, key_state)
def right(self):
from vivarium.objects import state
self.separator_frac += state.layout_step
debug('right: {}.separator_frac = {}'.format(self,
self.separator_frac))
self.separator_frac = min(1, self.separator_frac)
def view_destroyed(view):
debug('view_destroyed: {}'.format(view))
state.destroy_view(view)
state.current_workspace.do_layout()
def output_resolution(output, from_size, to_size):
debug('output_resolution: {} from {} -> {}'.format(output, from_size,
to_size))
state.current_workspace.do_layout()