def gravity_adjust(self, x, y, options):
#if the window size has changed,
#adjust the coordinates honouring the window gravity:
window_size = options.inttupleget("window-size", None)
g = self.gravity
log("gravity_adjust%s window_size=%s, size=%s, gravity=%s",
(x, y, options), window_size, self.size, GRAVITY_STR.get(g, "unknown"))
if not window_size:
return x, y
window_size = tuple(window_size)
if window_size==self.size:
return x, y
if g==0 or self.gravity==NorthWestGravity:
return x, y
oldw, oldh = window_size
bw, bh = self.size
def center_y():
if bh>=oldh:
return y + (bh-oldh)//2
return y - (oldh-bh)//2
def center_x():
if bw>=oldw:
return x + (bw-oldw)//2
return x - (oldw-bw)//2
def east_x():
if bw>=oldw:
return x + (bw-oldw)
return x - (oldw-bw)
def west_x():
return x
def north_y():
return y
def south_y():
if bh>=oldh:
return y + (bh-oldh)
return y - (oldh-bh)
if g==NorthGravity:
return center_x(), north_y()
if g==NorthEastGravity:
return east_x(), north_y()
if g==WestGravity:
return west_x(), center_y()
if g==CenterGravity:
return center_x(), center_y()
if g==EastGravity:
return east_x(), center_y()
if g==SouthWestGravity:
return west_x(), south_y()
if g==SouthGravity:
return center_x(), south_y()
if g==SouthEastGravity:
return east_x(), south_y()
#if self.gravity==StaticGravity:
# pass
return x, y
def get_info(self):
attributes = []
if self._fullscreen:
attributes.append("fullscreen")
if self._maximized:
attributes.append("maximized")
if self._above:
attributes.append("above")
if self._below:
attributes.append("below")
if self._shaded:
attributes.append("shaded")
if self._sticky:
attributes.append("sticky")
if self._skip_pager:
attributes.append("skip-pager")
if self._skip_taskbar:
attributes.append("skip-taskbar")
if self._iconified:
attributes.append("iconified")
if self._focused:
attributes.append("focused")
info = super().get_info()
info.update({
"override-redirect":
self._override_redirect,
#"group-leader" : self.group_leader,
"position":
self._pos,
"size":
self._size,
"client-properties":
self._client_properties,
"set-initial-position":
self._set_initial_position,
"size-constraints":
dict(self.size_constraints),
"geometry-hints":
dict(self.geometry_hints),
"content-type":
self.content_type,
"attributes":
attributes,
"gravity":
GRAVITY_STR.get(self.window_gravity, self.window_gravity),
#"border" : self.border or "",
#cursor_data
"max-size":
self.max_window_size,
"button-state":
self.button_state,
"offset":
self.window_offset or (0, 0),
})
return info
def do_populate(self):
w = self._window
if not w:
return
self.wid_label.set_text(str(w._id))
self.title_label.set_text(w.get_title())
self.bool_icon(self.or_image, w._override_redirect)
self.state_label.set_text(get_window_state(w))
self.attributes_label.set_text(get_window_attributes(w))
self.bool_icon(self.focus_image, w._focused)
self.button_state_label.set_text(csv(b for b,s in w.button_state.items() if s) or "none")
#self.group_leader_label.set_text(str(w.group_leader))
self.gravity_label.set_text(GRAVITY_STR.get(w.window_gravity, "invalid"))
self.content_type_label.set_text(w.content_type or "unknown")
#geometry:
self.pixel_depth_label.set_text(str(w.pixel_depth or 24))
self.bool_icon(self.alpha_image, w._window_alpha)
self.bool_icon(self.opengl_image, w.is_GL())
#tells us if this window instance can paint with alpha
geom = list(w._pos)+list(w._size)
self.geometry_label.set_text(geom_str(geom))
geom = list(w.get_position()) + list(w.get_size())
self.outer_geometry_label.set_text(geom_str(geom))
self.inner_geometry_label.set_text(geom_str(w.get_drawing_area_geometry()))
self.offsets_label.set_text(csv(str(x) for x in (w.window_offset or ())) or "none")
self.frame_extents_label.set_text(csv(w._current_frame_extents or []) or "none")
self.max_size_label.set_text(csv(w.max_window_size))
self.size_constraints_label.set_text(hsc(w.size_constraints))
#backing:
b = w._backing
if b:
self.backing_properties.show()
def pv(value):
if isinstance(value, (tuple, list)):
return csv(value)
if isinstance(value, dict):
return dict_to_str(dict((k,v) for k,v in value.items() if k in ("type", "encoding", )), ", ", ":")
return str(value)
def dict_to_str(d, sep="\n", eq="="):
strdict = dict((k,pv(v)) for k,v in d.items())
return sep.join("%s%s%s" % (k, eq, v) for k,v in strdict.items() if v)
self.backing_properties.set_text(dict_to_str(b.get_info()))
else:
self.backing_properties.hide()
self.backing_properties.set_text("")
def copy_to_clipboard(self, *_args):
w = self._window
if not w:
return
info = {
"wid": w._id,
"title": w.get_title(),
"override-redirect": w._override_redirect,
"state": get_window_state(w),
"attributes": get_window_attributes(w),
"focused": w._focused,
"buttons": csv(b for b, s in w.button_state.items() if s)
or "none",
"gravity": GRAVITY_STR.get(w.window_gravity, "invalid"),
"content-type": w.content_type or "unknown",
"pixel-depth": w.pixel_depth or 24,
"alpha": w._window_alpha,
"opengl": w.is_GL(),
"geometry": geom_str(list(w._pos) + list(w._size)),
"outer-geometry":
geom_str(list(w.get_position()) + list(w.get_size())),
"inner-geometry": geom_str(w.get_drawing_area_geometry()),
"offsets": csv(str(x) for x in (w.window_offset or ())) or "none",
"frame-extents": csv(w._current_frame_extents or []) or "none",
"max-size": csv(w.max_window_size),
"size-constraints": hsc(w.size_constraints),
}
#backing:
b = w._backing
if b:
info.update({
"size": csv(b.size),
"render-size": csv(b.render_size),
"backing-offsets": csv(b.offsets),
})
text = "\n".join("%s=%s" % (k, v) for k, v in info.items())
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
clipboard.set_text(text, len(text))
def sc_str(k, v):
k = bytestostr(k)
if k == "gravity":
v = GRAVITY_STR.get(v, v)
return "%s=%s" % (k, str(v))
