Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

310 lines (250 sloc) 12.397 kb
""" Defines a Viewport which renders sub-areas of components """
from __future__ import with_statement
# Standard library imports
from numpy import array, dot
# Enthought library traits
from import ViewportZoomTool
from enable.simple_layout import simple_container_get_preferred_size, \
from traits.api import (Bool, Delegate, Float, Instance, Enum, List,
Any, on_trait_change)
from kiva import affine
# Local relative imports
from enable_traits import bounds_trait, coordinate_trait
from base import empty_rectangle, intersect_bounds
from component import Component
from container import Container
from canvas import Canvas
class Viewport(Component):
A "window" or "view" into a sub-region of another component.
# The component we are viewing
component = Instance(Component)
# The position of our viewport into our component (in the component's
# coordinate space)
view_position = coordinate_trait
# The bounds of our viewport in the space of our component
view_bounds = bounds_trait
# Whether or not this viewport should stay constrained to the bounds
# of the viewed component
# TODO: Implement this
stay_inside = Bool(False)
# Enable Zoom interaction
enable_zoom = Bool(False)
# The zoom tool
zoom_tool = Instance(ViewportZoomTool)
# Zoom scaling factor for this viewport - Ratio of old bounds to new bounds.
# Zoom less than 1.0 means we are zoomed out, and more than 1.0 means
# we are zoomed in. Zoom should always be positive and nonzero.
zoom = Float(1.0)
# Whether to initiate layout on the viewed component. This is necessary
# if the component is only viewed through viewports, in which case one
# of the viewports must lay it out or bounds must be set explicitly
# on the component.
initiate_layout = Bool(False)
min_zoom = Delegate('zoom_tool', modify=True)
max_zoom = Delegate('zoom_tool', modify=True)
_component_preferred_size = Any(None)
# Public methods
def __init__(self, **traits):
Component.__init__(self, **traits)
if 'zoom_tool' not in traits:
self.zoom_tool = ViewportZoomTool(self)
if self.enable_zoom:
self._enable_zoom_changed(False, True)
def components_at(self, x, y, add_containers = False):
Returns the list of components inside the viewport at the given (x,y)
in the viewport's native coordinate space (not in the space of the
component it is viewing).
Although Viewports are not containers, they support this method.
if self.is_in(x, y):
if self.component is not None:
# Transform (scale + translate) the incoming X and Y
# coordinates from our coordinate system into the coordinate
# system of the component we are viewing.
x_trans, y_trans = self.viewport_to_component(x, y)
if isinstance(self.component, Container):
return self.component.components_at(x_trans, y_trans)
elif self.component.is_in(x_trans, y_trans):
return [self.component]
return []
return []
def invalidate_draw(self, damaged_regions=None, self_relative=False,
if view_relative and damaged_regions:
damaged_regions = [[region[0] - self.view_position[0],
region[1] - self.view_position[1],
region[2], region[3]] for region in damaged_regions]
super(Viewport, self).invalidate_draw(damaged_regions=damaged_regions,
def cleanup(self, window):
"""When a window viewing or containing a component is destroyed,
cleanup is called on the component to give it the opportunity to
delete any transient state it may have (such as backbuffers)."""
if self.component:
def get_preferred_size(self):
"""If we're initiating layout, act like an OverlayPlotContainer,
otherwise do the normal component action"""
if self.initiate_layout:
self._component_preferred_size = simple_container_get_preferred_size(self, components=[container])
return self._component_preferred_size
return super(Viewport, self).get_preferred_size()
def viewport_to_component(self, x, y):
""" Given a coordinate X and Y in the viewport's coordinate system,
returns and X and Y in the coordinate system of the viewed
transform = self.get_event_transform()
return dot(array([x,y,1]), transform)[:2]
def component_to_viewport(self, x, y):
""" Given a coordinate X and Y in the viewed component's coordinate
system, returns a coordinate in the coordinate system of the
vx, vy = self.view_position
ox, oy = self.outer_position
newx = (x - vx) * self.zoom + ox
newy = (y - vx) * self.zoom + oy
return (newx, newy)
def get_event_transform(self, event=None, suffix=""):
transform = affine.affine_identity()
if isinstance(self.component, Component):
# If we have zoom enabled, scale events. Since affine transforms
# multiply from the left, we build up the transform from the
# inside of the viewport outwards.
if self.enable_zoom and self.zoom != 1.0:
transform = affine.translate(transform, *self.view_position)
transform = affine.scale(transform, 1/self.zoom, 1/self.zoom)
transform = affine.translate(transform, -self.outer_position[0],
x_offset = self.view_position[0] - self.outer_position[0]
y_offset = self.view_position[1] - self.outer_position[1]
transform = affine.translate(transform, x_offset, y_offset)
return transform
# Component interface
def _draw_mainlayer(self, gc, view_bounds=None, mode="normal"):
# For now, ViewPort ignores the view_bounds that are passed in...
# Long term, it should be intersected with the view_position to
# compute a new view_bounds to pass in to our component.
if self.component is not None:
x, y = self.position
view_x, view_y = self.view_position
with gc:
# Clip in the viewport's space (screen space). This ensures
# that the half-pixel offsets we us are actually screen pixels,
# and it's easier/more accurate than transforming the clip
# rectangle down into the component's space (especially if zoom
# is involved).
gc.clip_to_rect(x-0.5, y-0.5,
# There is a two-step transformation from the viewport's "outer"
# coordinates into the coordinates space of the viewed component:
# scaling, followed by a translation.
if self.enable_zoom:
if self.zoom != 0:
gc.scale_ctm(self.zoom, self.zoom)
gc.translate_ctm(x/self.zoom - view_x, y/self.zoom - view_y)
raise RuntimeError("Viewport zoomed out too far.")
gc.translate_ctm(x - view_x, y - view_y)
# Now transform the passed-in view_bounds; this is not the same thing as
# self.view_bounds!
if view_bounds:
# Find the intersection rectangle of the viewport with the view_bounds,
# and transform this into the component's space.
clipped_view = intersect_bounds(self.position + self.bounds, view_bounds)
if clipped_view != empty_rectangle:
# clipped_view and self.position are in the space of our parent
# container. we know that self.position -> view_x,view_y
# in the coordinate space of our component. So, find the
# vector from self.position to clipped_view, then add this to
# view_x and view_y to generate the transformed coordinates
# of clipped_view in our component's space.
offset = array(clipped_view[:2]) - array(self.position)
new_bounds = ((offset[0]/self.zoom + view_x),
(offset[1]/self.zoom + view_y),
clipped_view[2] / self.zoom, clipped_view[3] / self.zoom)
self.component.draw(gc, new_bounds, mode=mode)
def _do_layout(self):
if self.initiate_layout:
self.component.bounds = list(self.component.get_preferred_size())
super(Viewport, self)._do_layout()
def _dispatch_stateful_event(self, event, suffix):
if isinstance(self.component, Component):
transform = self.get_event_transform(event, suffix)
event.push_transform(transform, caller=self)
self.component.dispatch(event, suffix)
# Event handlers
def _enable_zoom_changed(self, old, new):
Add or remove the zoom tool overlay depending whether
or not zoom is enabled.
if self.zoom_tool is None:
if self.enable_zoom:
if not self.zoom_tool in
if self.zoom_tool in
def _update_component_view_bounds(self):
""" Updates the optional .view_bounds trait on our component;
mostly used for Canvas objects.
if isinstance(self.component, Canvas):
llx, lly = self.view_position
self.component.view_bounds = (llx, lly,
llx + self.view_bounds[0]-1,
lly + self.view_bounds[1]-1)
def _component_changed(self, old, new):
if (old is not None) and (self in old.viewports):
if (new is not None) and (self not in new.viewports):
def _bounds_changed(self, old, new):
Component._bounds_changed(self, old, new)
self.set(view_bounds = [new[0]/self.zoom, new[1]/self.zoom],
def _bounds_items_changed(self, event):
return self._bounds_changed(None, self.bounds)
def _handle_view_box_changed(self):
def _get_position(self):
return self.view_position
def _get_bounds(self):
return self.view_bounds
Jump to Line
Something went wrong with that request. Please try again.