#------------------------------------------------------------------------------ # Copyright (c) 2005, Enthought, Inc. # some parts copyright 2002 by Space Telescope Science Institute # All rights reserved. # # This software is provided without warranty under the terms of the BSD # license included in enthought/LICENSE.txt and may be redistributed only # under the conditions described in the aforementioned license. The license # is also available online at http://www.enthought.com/licenses/BSD.txt # Thanks for using Enthought open source! #------------------------------------------------------------------------------ """ This is the WX backend that draws into a normal WX graphics context using the Image backend. It detects the OS type and creates the appropriate low-level support classes to enable Agg to draw into a WX memory buffer. """ # This automatically determines which platform-dependent WX backend should be # loaded and exports the appropriate Canvas and CanvasWindow. __all__ = ["GraphicsContext", "Canvas", "CanvasWindow", "CompiledPath", "font_metrics_provider"] # Standard library imports. import sys from time import clock as now # Major library imports. import wx # Local imports from fonttools import Font WidgetClass = wx.Window class BaseWxCanvas(object): """ All the WX backends ultimately use the Agg backend to do the actual drawing. However, they all differ in how they construct a memory buffer to hand to Agg. This class defines the basic functionality expected of a Kiva Wx backend canvas. Its concrete methods handle some of the interaction with wx, but it needs to be mixed in with an actual Wx drawable (e.g Window, Frame, GLCanvas, etc.). Subclasses must implement _create_kiva_gc and blit, and they will most likely provide their own __init__ that calls the Wx drawable-specific base constructor as well as this class's. """ def __init__(self): wx.EVT_PAINT(self, self.OnPaint) wx.EVT_SIZE(self, self.OnSize) wx.EVT_ERASE_BACKGROUND(self, self.OnErase) self.gc = None self.new_gc() self.blit_time = 0.01 # a decent guess for first call self.total_paint_time = 0.0 self.clear_color = (1,1,1) self._do_draw = 0 self._win_id = None self._dc = None return def _create_kiva_gc(self, size): """ Returns a new backend-dependent GraphicsContext* instance of the given size. """ raise NotImplementedError def blit(self, event): """ The actual drawing call. event is the wxEvent that triggered the paint/referesh call that resulted in blit being called. """ raise NotImplementedError def size(self): return self.GetSizeTuple() def paint(self, event): tt1 = now() if self.dirty: self.clear() self.draw() self.blit(event) tt2 = now() self.total_paint_time = tt2 - tt1 return def new_gc(self, sz = None): if sz is None: sz = self.GetClientSizeTuple() if (sz[0] <= 0) or (sz[1] <= 0): sz = (100, 100) t1 = now() if self.gc is not None: del self.gc self.gc = None # make sure self.gc is defined self.gc = self._create_kiva_gc(sz) t2 = now() self.new_gc_time = t2-t1 self.dirty = 1 return def clear(self): t1 = now() self.gc.clear(self.clear_color) t2 = now() self.clear_time = t2-t1 return def draw(self): t1 = now() self.do_draw(self.gc) t2 = now() self.draw_time = t2-t1 return def OnErase(self,event): pass def OnSize(self,event): # resize buffer bitmap and repaint. sz = self.GetClientSizeTuple() if sz != (self.gc.width(),self.gc.height()): self.new_gc(sz) event.Skip() return def OnPaint(self,event): self.paint(event) return def OnIdle(self, event): self.paint(event) self._do_draw = 0 return # Define a different base class depending on the platform. if sys.platform == 'darwin': from mac import get_macport, ABCGI from mac.ABCGI import CGBitmapContext, CGImage, CGImageFile, \ CGLayerContext, CGMutablePath # The Mac backend only supports numpy. import numpy as np if wx.VERSION[:2] == (2, 6): def gc_for_dc(dc): """ Return the CGContext corresponding to the given wx.DC. """ port = get_macport(dc) return ABCGI.CGContextForPort(port) elif wx.VERSION[:2] == (2, 8): class UnflippingCGContext(ABCGI.CGContextInABox): """ Vertically flip the context to undo wx's flipping. """ def __init__(self, *args, **kwds): ABCGI.CGContextInABox.__init__(self, *args, **kwds) self._begun = False def begin(self): if self._begun: return self.save_state() self.translate_ctm(0, self.height()) self.scale_ctm(1.0, -1.0) self._begun = True def end(self): if self._begun: self.restore_state() self._begun = False def gc_for_dc(dc): """ Return the CGContext corresponding to the given wx.DC. """ pointer = get_macport(dc) gc = UnflippingCGContext(pointer, dc.GetSizeTuple()) return gc CompiledPath = CGMutablePath Image = CGImageFile class GraphicsContext(CGLayerContext): def __init__(self, size_or_array, window_gc=None, *args, **kwds): gc = window_gc if not gc: # Create a tiny base context to spawn the CGLayerContext from. # We are better off making our Layer from the window gc since # the data formats will match and so it will be faster to draw the # layer. gc = CGBitmapContext((1,1)) if isinstance(size_or_array, np.ndarray): # Initialize the layer with an image. image = CGImage(size_or_array) width = image.width height = image.height else: # No initialization. image = None width, height = size_or_array CGLayerContext.__init__(self, gc, (width, height)) if image is not None: self.draw_image(image) @classmethod def create_from_gc(klass, gc, size_or_array, *args, **kwds): return klass(size_or_array, gc, *args, **kwds) class Canvas(BaseWxCanvas, WidgetClass): """ Mac wx Kiva canvas. """ def __init__(self, parent, id = 01, size = wx.DefaultSize): # need to init self.memDC before calling BaseWxCanvas.__init__ self.memDC = wx.MemoryDC() self.size = (size.GetWidth(), size.GetHeight()) WidgetClass.__init__(self, parent, id, wx.Point(0, 0), size, wx.SUNKEN_BORDER | wx.WANTS_CHARS | \ wx.FULL_REPAINT_ON_RESIZE ) BaseWxCanvas.__init__(self) return def _create_kiva_gc(self, size): self.size = size self.bitmap = wx.EmptyBitmap(size[0], size[1]) self.memDC.SelectObject(self.bitmap) gc = gc_for_dc(self.memDC) #gc.begin() #print " **** gc is:", gc return gc def blit(self, event): t1 = now() paintdc = wx.PaintDC(self) paintdc.Blit(0, 0, self.size[0], self.size[1], self.memDC, 0, 0) t2 = now() self.blit_time = t2 - t1 self.dirty = 0 return def draw(self): t1 = now() self.gc.begin() self.do_draw(self.gc) self.gc.end() t2 = now() self.draw_time = t2-t1 return else: # the GraphicsContextSystem stuff should eventually be moved out of the # image backend. from backend_image import GraphicsContextSystem as GraphicsContext from agg import CompiledPath class Canvas(BaseWxCanvas, WidgetClass): "The basic wx Kiva canvas." def __init__(self, parent, id = -1, size = wx.DefaultSize): WidgetClass.__init__(self, parent, id, wx.Point(0, 0), size, wx.SUNKEN_BORDER | wx.WANTS_CHARS | \ wx.FULL_REPAINT_ON_RESIZE ) BaseWxCanvas.__init__(self) return def _create_kiva_gc(self, size): return GraphicsContext(size) def blit(self, event): t1 = now() if self._dc is None: self._dc = wx.PaintDC(self) self.gc.pixel_map.draw_to_wxwindow(self, 0, 0) self._dc = None t2 = now() self.blit_time = t2-t1 self.dirty = 0 return def font_metrics_provider(): gc = GraphicsContext((1, 1)) gc.set_font(Font()) return gc class _CanvasWindow(wx.Frame): def __init__(self, id=-1, title='Kiva Canvas', size=(600,800), canvas_class=Canvas): parent = None wx.Frame.__init__(self, parent, id, title, size=size) self.canvas = canvas_class(self) self.Show(1) return CanvasWindow = _CanvasWindow try: from numpy import which if which[0]!='numpy': import gui_thread CanvasWindow = gui_thread.register(_CanvasWindow) except ImportError: pass