"""
Defines the concrete top-level Enable 'Window' class for the wxPython GUI 
toolkit, based on the kiva agg driver.
"""

import sys
import time
import wx

from enthought.traits.api import Any, Instance, Trait
from enthought.traits.ui.wx.menu import MakeMenu

# Relative imports
from enthought.enable.base import union_bounds
from enthought.enable.component  import Component
from enthought.enable.events import MouseEvent, KeyEvent, DragEvent
from enthought.enable.abstract_window import AbstractWindow
from enthought.kiva import backend

if backend() == "gl":
    import pyglet
    pyglet.options['shadow_window'] = False
    from wx.glcanvas import GLCanvas
    from enthought.enable.gl_graphics_context import GLGraphicsContextEnable
else:
    GLCanvas = object
    from enthought.enable.graphics_context import GraphicsContextEnable

try:
    from enthought.util.wx.drag_and_drop import clipboard, PythonDropTarget
except ImportError:
    clipboard = None
    PythonDropTarget = None

#-------------------------------------------------------------------------------
#  Constants:
#-------------------------------------------------------------------------------

# Number of pixels to scroll at a time:
scroll_incr = 16

# Map from pointer shape name to pointer shapes:
pointer_map = {
   'arrow':             wx.CURSOR_ARROW,
   'right arrow':       wx.CURSOR_RIGHT_ARROW,
   'blank':             wx.CURSOR_BLANK,
   'bullseye':          wx.CURSOR_BULLSEYE,
   'char':              wx.CURSOR_CHAR,
   'cross':             wx.CURSOR_CROSS,
   'hand':              wx.CURSOR_HAND,
   'ibeam':             wx.CURSOR_IBEAM,
   'left button':       wx.CURSOR_LEFT_BUTTON,
   'magnifier':         wx.CURSOR_MAGNIFIER,
   'middle button':     wx.CURSOR_MIDDLE_BUTTON,
   'no entry':          wx.CURSOR_NO_ENTRY,
   'paint brush':       wx.CURSOR_PAINT_BRUSH,
   'pencil':            wx.CURSOR_PENCIL,
   'point left':        wx.CURSOR_POINT_LEFT,
   'point right':       wx.CURSOR_POINT_RIGHT,
   'question arrow':    wx.CURSOR_QUESTION_ARROW, 
   'right button':      wx.CURSOR_RIGHT_BUTTON, 
   'size top':          wx.CURSOR_SIZENS, 
   'size bottom':       wx.CURSOR_SIZENS, 
   'size left':         wx.CURSOR_SIZEWE, 
   'size right':        wx.CURSOR_SIZEWE, 
   'size top right':    wx.CURSOR_SIZENESW, 
   'size bottom left':  wx.CURSOR_SIZENESW, 
   'size top left':     wx.CURSOR_SIZENWSE, 
   'size bottom right': wx.CURSOR_SIZENWSE, 
   'sizing':            wx.CURSOR_SIZING, 
   'spray can':         wx.CURSOR_SPRAYCAN,
   'wait':              wx.CURSOR_WAIT, 
   'watch':             wx.CURSOR_WATCH,
   'arrow wait':        wx.CURSOR_ARROWWAIT
}

# Map from wxPython special key names into Enable key names:
key_map = {
    wx.WXK_BACK:      'Backspace',
    wx.WXK_TAB:       'Tab',
    wx.WXK_RETURN:    'Enter',
    wx.WXK_ESCAPE:    'Esc',
    wx.WXK_DELETE:    'Delete',
    wx.WXK_START:     'Start',
    wx.WXK_LBUTTON:   'Left Button',
    wx.WXK_RBUTTON:   'Right Button',
    wx.WXK_CANCEL:    'Cancel',
    wx.WXK_MBUTTON:   'Middle Button',
    wx.WXK_CLEAR:     'Clear',
    wx.WXK_SHIFT:     'Shift',
    wx.WXK_CONTROL:   'Control',
    wx.WXK_MENU:      'Menu',
    wx.WXK_PAUSE:     'Pause',
    wx.WXK_CAPITAL:   'Capital',
    wx.WXK_PRIOR:     'Page Up',
    wx.WXK_NEXT:      'Page Down',
    wx.WXK_END:       'End',
    wx.WXK_HOME:      'Home',
    wx.WXK_LEFT:      'Left',
    wx.WXK_UP:        'Up',
    wx.WXK_RIGHT:     'Right',
    wx.WXK_DOWN:      'Down',
    wx.WXK_SELECT:    'Select',
    wx.WXK_PRINT:     'Print',
    wx.WXK_EXECUTE:   'Execute',
    wx.WXK_SNAPSHOT:  'Snapshot',
    wx.WXK_INSERT:    'Insert',
    wx.WXK_HELP:      'Help',
    wx.WXK_NUMPAD0:   'Numpad 0',
    wx.WXK_NUMPAD1:   'Numpad 1',
    wx.WXK_NUMPAD2:   'Numpad 2',
    wx.WXK_NUMPAD3:   'Numpad 3',
    wx.WXK_NUMPAD4:   'Numpad 4',
    wx.WXK_NUMPAD5:   'Numpad 5',
    wx.WXK_NUMPAD6:   'Numpad 6',
    wx.WXK_NUMPAD7:   'Numpad 7',
    wx.WXK_NUMPAD8:   'Numpad 8',
    wx.WXK_NUMPAD9:   'Numpad 9',
    wx.WXK_MULTIPLY:  'Multiply',
    wx.WXK_ADD:       'Add',
    wx.WXK_SEPARATOR: 'Separator',
    wx.WXK_SUBTRACT:  'Subtract',
    wx.WXK_DECIMAL:   'Decimal',
    wx.WXK_DIVIDE:    'Divide',
    wx.WXK_F1:        'F1',
    wx.WXK_F2:        'F2',
    wx.WXK_F3:        'F3',
    wx.WXK_F4:        'F4',
    wx.WXK_F5:        'F5',
    wx.WXK_F6:        'F6',
    wx.WXK_F7:        'F7',
    wx.WXK_F8:        'F8',
    wx.WXK_F9:        'F9',
    wx.WXK_F10:       'F10',
    wx.WXK_F11:       'F11',
    wx.WXK_F12:       'F12',
    wx.WXK_F13:       'F13',
    wx.WXK_F14:       'F14',
    wx.WXK_F15:       'F15',
    wx.WXK_F16:       'F16',
    wx.WXK_F17:       'F17',
    wx.WXK_F18:       'F18',
    wx.WXK_F19:       'F19',
    wx.WXK_F20:       'F20',
    wx.WXK_F21:       'F21',
    wx.WXK_F22:       'F22',
    wx.WXK_F23:       'F23',
    wx.WXK_F24:       'F24',
    wx.WXK_NUMLOCK:   'Num Lock',
    wx.WXK_SCROLL:    'Scroll Lock'
}

drag_results_map = { "error": wx.DragError,
                     "none": wx.DragNone,
                     "copy": wx.DragCopy,
                     "move": wx.DragMove,
                     "link": wx.DragLink,
                     "cancel": wx.DragCancel }



# Reusable instance to avoid constructor/destructor overhead:
wx_rect = wx.Rect( 0, 0, 0, 0 )

# Default 'fake' start event for wxPython based drag operations:
default_start_event = MouseEvent()


# To conserve system resources, there is only one 'timer' per program:
system_timer = None
 
class EnableTimer ( wx.Timer ):
    """
    This class maintains a 'work list' of scheduled components, where 
    each item in the list has the form: [ component, interval, timer_pop_time ]
    """
    
    def __init__ ( self ):
        wx.Timer.__init__( self )
        self._work_list = []
        return
    
    def schedule ( self, component, interval ):
        "Schedule a timer event for a specified component"
        work_list = self._work_list
        if len( work_list ) == 0:
            self.Start( 5, oneShot=False )
        for i, item in enumerate( work_list ):
            if component is item[0]:
                del work_list[i]
                break
        self.reschedule( component, interval )
        return

    def reschedule ( self, component, interval ):
        "Reshedule a recurring timer event for a component"
        pop_time  = time.time() + interval
        new_item  = [ component, interval, pop_time ]
        work_list = self._work_list
        for i, item in enumerate( work_list ):
            if pop_time < item[2]:
                work_list.insert( i, new_item )
                break
        else:
            work_list.append( new_item )
        return
    
    def cancel ( self, component ):
        "Cancel any pending timer events for a component"
        work_list = self._work_list
        for i, item in enumerate( work_list ):
            if component is item[0]:
                del work_list[i]
                if len( work_list ) == 0:
                    self.Stop()
                break
        return (len( work_list ) != 0)        
        
    def Notify ( self ):
        "Handle a timer 'pop' event; used for performance testing purposes"
        now       = time.time()
        work_list = self._work_list
        n         = len( work_list )
        i         = 0
        while (i < n) and (now >= work_list[i][2]):
            i += 1
        if i > 0:
            reschedule = work_list[:i]
            del work_list[:i]
            for component, interval, ignore in reschedule:
                self.reschedule( component, interval )
                component.timer = True
        return


class LessSuckyDropTarget(PythonDropTarget):
    """ The sole purpose of this class is to override the implementation
    of OnDragOver() in the parent class to NOT short-circuit return the
    'default_drag_result' if the drop_source is None.  (The parent class
    implementation basically means that everything looks like it's OK to
    drop, and the DnD handler doesn't ever get a chance to intercept or
    veto.)
    """
    
    def OnDragOver(self, x, y, default_drag_result):
        # This is a cut-and-paste job of the parent class implementation.
        # Please refer to its comments.
        
        if clipboard.drop_source is not None and \
           not clipboard.drop_source.allow_move:
            default_drag_result = wx.DragCopy

        if hasattr(self.handler, 'wx_drag_over'):
            drag_result = self.handler.wx_drag_over(
                x, y, clipboard.data, default_drag_result
            )
        else:
            drag_result = default_drag_result

        return drag_result


class _Window(AbstractWindow):

    # Screen scroll increment amount:
    scroll_incr = ( wx.SystemSettings_GetMetric( wx.SYS_SCREEN_Y )
                    or 768 ) / 20

    # Width/Height of standard scrollbars:
    scrollbar_dx = wx.SystemSettings_GetMetric( wx.SYS_VSCROLL_X )
    scrollbar_dy = wx.SystemSettings_GetMetric( wx.SYS_HSCROLL_Y )

    _cursor_color = Any  # PZW: figure out the correct type for this...

    # Reference to the actual wxPython window:
    control      = Instance(wx.Window)
    
    # This is set by downstream components to notify us of whether or not
    # the current drag operation should return DragCopy, DragMove, or DragNone.
    _drag_result = Any
    
    def __init__(self, parent, wid = -1, pos = wx.DefaultPosition,
                   size = wx.DefaultSize, **traits):
        AbstractWindow.__init__(self, **traits)
        self._timer          = None
        self._mouse_captured = False

        # Due to wx wonkiness, we don't reliably get cursor position from
        # a wx KeyEvent.  Thus, we manually keep track of when we last saw
        # the mouse and use that information instead.  These coordinates are
        # in the wx coordinate space, i.e. pre-self._flip_y().
        self._last_mouse_pos = (0, 0)
        
        # Create the delegate: 
        self.control = control = self._create_control(parent, wid, pos, size)
        
        # Set up the 'erase background' event handler:
        wx.EVT_ERASE_BACKGROUND( control, self._on_erase_background )
 
        # Set up the 'paint' event handler:
        wx.EVT_PAINT( control, self._paint )
        wx.EVT_SIZE(  control, self._on_size )

        # Set up mouse event handlers:
        wx.EVT_LEFT_DOWN(     control, self._on_left_down )
        wx.EVT_LEFT_UP(       control, self._on_left_up )
        wx.EVT_LEFT_DCLICK(   control, self._on_left_dclick )
        wx.EVT_MIDDLE_DOWN(   control, self._on_middle_down )
        wx.EVT_MIDDLE_UP(     control, self._on_middle_up )
        wx.EVT_MIDDLE_DCLICK( control, self._on_middle_dclick )
        wx.EVT_RIGHT_DOWN(    control, self._on_right_down )
        wx.EVT_RIGHT_UP(      control, self._on_right_up )
        wx.EVT_RIGHT_DCLICK(  control, self._on_right_dclick )
        wx.EVT_MOTION(        control, self._on_mouse_move )
        wx.EVT_ENTER_WINDOW(  control, self._on_window_enter )
        wx.EVT_LEAVE_WINDOW(  control, self._on_window_leave )
        wx.EVT_MOUSEWHEEL(    control, self._on_mouse_wheel )
        
        # Handle key up/down events:
        wx.EVT_KEY_DOWN( control, self._on_key_updown )
        wx.EVT_KEY_UP(   control, self._on_key_updown )
        wx.EVT_CHAR(     control, self._on_char )
            
        # Attempt to allow wxPython drag and drop events to be mapped to
        # Enable drag events:
        
        # Handle window close and cleanup
        wx.EVT_WINDOW_DESTROY(control, self._on_close)

        if PythonDropTarget is not None:
            control.SetDropTarget( LessSuckyDropTarget( self ) ) 
            self._drag_over = []

        # In some cases, on the Mac at least, we never get an initial EVT_SIZE
        # since the initial size is correct. Because of this we call _on_size
        # here to initialize our bounds.
        self._on_size(None)

        return
    
    def _create_control(self, parent, wid, pos = wx.DefaultPosition, 
                        size = wx.DefaultSize):
        return wx.Window(parent, wid, pos, size, style = wx.CLIP_CHILDREN |
                           wx.WANTS_CHARS)

           
    def _on_close(self, event):
        # Might be scrollbars or other native components under
        # us that are generating this event
        if event.GetWindow() == self.control:
            self._gc = None
            wx.EVT_ERASE_BACKGROUND(self.control, None)
            wx.EVT_PAINT(self.control, None)
            wx.EVT_SIZE(self.control, None)
            wx.EVT_LEFT_DOWN(self.control, None)
            wx.EVT_LEFT_UP(self.control, None)
            wx.EVT_LEFT_DCLICK(self.control, None)
            wx.EVT_MIDDLE_DOWN(self.control, None)
            wx.EVT_MIDDLE_UP(self.control, None)
            wx.EVT_MIDDLE_DCLICK(self.control, None)
            wx.EVT_RIGHT_DOWN(self.control, None)
            wx.EVT_RIGHT_UP(self.control, None)
            wx.EVT_RIGHT_DCLICK(self.control, None)
            wx.EVT_MOTION(self.control, None)
            wx.EVT_ENTER_WINDOW(self.control, None)
            wx.EVT_LEAVE_WINDOW(self.control, None)
            wx.EVT_MOUSEWHEEL(self.control, None)
            wx.EVT_KEY_DOWN(self.control, None)
            wx.EVT_KEY_UP(self.control, None)
            wx.EVT_CHAR(self.control, None)
            wx.EVT_WINDOW_DESTROY(self.control, None)
            self.control.SetDropTarget(None)
            self.control = None
            self.component.cleanup(self)
            self.component.parent = None
            self.component.window = None
            self.component = None
        return
        
    def _on_key_updown ( self, event ):
        "Handle keyboard keys changing their up/down state"
        k = event.GetKeyCode()
        t = event.GetEventType()

        if k == wx.WXK_SHIFT:
            self.shift_pressed = (t == wx.wxEVT_KEY_DOWN)
        elif k == wx.WXK_ALT:
            self.alt_pressed   = (t == wx.wxEVT_KEY_DOWN)
        elif k == wx.WXK_CONTROL:
            self.ctrl_pressed  = (t == wx.wxEVT_KEY_DOWN)

        event.Skip()
        return

    def _on_char ( self, event ):
        "Handle keyboard keys being pressed"

        if self.focus_owner is None:
            focus_owner = self.component
        else:
            focus_owner = self.focus_owner
        
        if focus_owner is not None:
            control_down = event.ControlDown()
            key_code     = event.GetKeyCode()
            key = None

            if control_down and (1 <= key_code <= 26):
                # Shift Ctrl-A through Ctrl-Z so that the 'key' value of
                # this event is the ASCII character
                key = chr(key_code + 96)
            elif key_map.has_key(key_code):
                key = key_map.get(key_code)
            if key is None:
                if key_code >= 0 and key_code < 256:
                    key = chr(key_code)

            # Use the last-seen mouse coordinates instead of GetX/GetY due
            # to wx bug.
            x, y = self._last_mouse_pos

            # Someday when wx does this properly, we can use these instead:
            # x = event.GetX()
            # y = event.GetY()
            
            enable_event = KeyEvent( character = key,
                                     alt_down = event.AltDown(),
                                     control_down = control_down,
                                     shift_down = event.ShiftDown(),
                                     x = x,
                                     y = self._flip_y(y),
                                     event = event,
                                     window = self )
            focus_owner.dispatch(enable_event, "key_pressed")
        else:
            event.Skip()
        return
    
    def _flip_y ( self, y ):
        "Convert from a Kiva to a wxPython y coordinate"
        return int( self._size[1] - 1 - y )
   
    def _on_erase_background ( self, event ):
        pass

    def _on_size ( self, event ):
        dx, dy = self.control.GetSizeTuple()

        # do nothing if the new and old sizes are the same
        if (self.component.outer_width, self.component.outer_height) == (dx, dy):
            return
        
        self.resized = (dx, dy)
        
        if getattr(self.component, "fit_window", False):
            self.component.outer_position = [0,0]
            self.component.outer_bounds = [dx, dy]
        elif hasattr(self.component, "resizable"):
            if "h" in self.component.resizable:
                self.component.outer_x = 0
                self.component.outer_width = dx
            if "v" in self.component.resizable:
                self.component.outer_y = 0
                self.component.outer_height = dy
        
        self.control.Refresh()
        return
    
    def _capture_mouse ( self ):
        "Capture all future mouse events"
        if not self._mouse_captured:
            self._mouse_captured = True
            self.control.CaptureMouse()    
        return
    
    def _release_mouse ( self ):
        "Release the mouse capture"
        if self._mouse_captured:
            self._mouse_captured = False
            self.control.ReleaseMouse()
        return
    
    def _create_mouse_event ( self, event ):
        "Convert a GUI toolkit mouse event into a MouseEvent"
        if event is not None:
            x           = event.GetX()
            y           = event.GetY()
            self._last_mouse_pos = (x, y)
            mouse_wheel = ((event.GetLinesPerAction() * 
                            event.GetWheelRotation()) / 
                            (event.GetWheelDelta() or 1))
            
            # Note: The following code fixes a bug in wxPython that returns
            # 'mouse_wheel' events in screen coordinates, rather than window
            # coordinates:
            if float(wx.VERSION_STRING[:3]) < 2.8:
                if mouse_wheel != 0 and sys.platform == "win32":
                    x, y = self.control.ScreenToClientXY( x, y )
            return MouseEvent( x            = x,
                               y            = self._flip_y( y ),
                               alt_down     = event.AltDown(),    
                               control_down = event.ControlDown(),
                               shift_down   = event.ShiftDown(),
                               left_down    = event.LeftIsDown(),
                               middle_down  = event.MiddleIsDown(),
                               right_down   = event.RightIsDown(),
                               mouse_wheel  = mouse_wheel,
                               window = self )
                               
        # If no event specified, make one up:
        x, y = wx.GetMousePosition()
        x, y = self.control.ScreenToClientXY( x, y )
        self._last_mouse_pos = (x, y)
        return MouseEvent( x            = x,
                           y            = self._flip_y( y ),
                           alt_down     = self.alt_pressed,    
                           control_down = self.ctrl_pressed,
                           shift_down   = self.shift_pressed,
                           left_down    = False,
                           middle_down  = False,
                           right_down   = False,
                           mouse_wheel  = 0,
                           window = self)
    
    def _create_gc(self, size, pix_format = "bgra32"):
        "Create a Kiva graphics context of a specified size"
        gc = GraphicsContextEnable((size[0]+1, size[1]+1), pix_format = pix_format, window=self )
        gc.translate_ctm(0.5, 0.5)
        return gc
    
    def _redraw(self, coordinates=None):
        "Request a redraw of the window"
        if coordinates is None:
            if self.control:
                self.control.Refresh(False)
        else:
            xl, yb, xr, yt = coordinates
            rect = wx_rect
            rect.SetX( int( xl ) )
            rect.SetY( int( self._flip_y( yt - 1 ) ) )
            rect.SetWidth(  int( xr - xl ) )
            rect.SetHeight( int( yt - yb ) )
            if self.control:
                self.control.Refresh(False, rect)
        return
    
    def _get_control_size ( self ):
        "Get the size of the underlying toolkit control"
        result = None
        if self.control:
            result = self.control.GetSizeTuple()
        return result

    def _window_paint ( self, event):
        "Do a GUI toolkit specific screen update"
        control = self.control
        wdc = control._dc = wx.PaintDC(control)
        self._update_region = None
        if self._update_region is not None:
            update_bounds = reduce(union_bounds, self._update_region)
            self._gc.pixel_map.draw_to_wxwindow( control, int(update_bounds[0]), int(update_bounds[1]),
                                                 width=int(update_bounds[2]), height=int(update_bounds[3]))
        else:
            self._gc.pixel_map.draw_to_wxwindow( control, 0, 0 )
        control._dc = None
        return
        
    def set_pointer ( self, pointer ):
        "Set the current pointer (i.e. cursor) shape"
        ptr = pointer_map[ pointer ]
        if type( ptr ) is int:
            pointer_map[ pointer ] = ptr = wx.StockCursor( ptr )
        self.control.SetCursor( ptr )
        return
        
    def set_tooltip ( self, tooltip ):
        "Set the current tooltip for the window"
        wx.ToolTip_Enable( False )
        self.control.SetToolTip( wx.ToolTip( tooltip ) )
        wx.ToolTip_Enable( True )
        return

    def set_timer_interval ( self, component, interval ):
        """ Set up or cancel a timer for a specified component.  To cancel the
        timer, set interval=None """
        global system_timer
        if interval is None:
            if ((system_timer is not None) and 
                (not system_timer.cancel( component ))):
                system_timer = None
        else:
            if system_timer is None:
                system_timer = EnableTimer()
            system_timer.schedule( component, interval )
        return
    
    def _set_focus ( self ):
        "Sets the keyboard focus to this window"
        self.control.SetFocus()
        return

    def screen_to_window(self, x, y):
        pt = wx.Point(x,y)
        x,y = self.control.ScreenToClient(pt)
        y = self._flip_y(y)
        return x,y
    
    def set_drag_result(self, result):
        if result not in drag_results_map:
            raise RuntimeError, "Unknown drag result '%s'" % result
        self._drag_result = drag_results_map[result]
        return

    def wx_dropped_on ( self, x, y, drag_object, drop_result ):
        "Handle wxPython drag and drop events"
        # Process the 'dropped_on' event for the object(s) it was dropped on:
        y = self._flip_y(y)
        drag_event = DragEvent(x=x, y=y, obj=drag_object, window=self)
        self._drag_result = wx.DragNone
        if self.component.is_in(x, y):
            self.component.dispatch(drag_event, "dropped_on")
        
        # If a downstream component wants to express that it handled the 
        return self._drag_result

    def wx_drag_over ( self, x, y, drag_object, drag_result ):
        y = self._flip_y( y )
        drag_over_event = DragEvent( x    = x,
                                     y    = y,
                                     x0   = 0.0,
                                     y0   = 0.0,
                                     copy = drag_result != wx.DragMove,
                                     obj = drag_object,
                                     start_event = default_start_event,
                                     window = self )
        
        # By default, don't indicate that we can be dropped on.  It is up
        # to the component to set this correctly.
        self._drag_result = wx.DragNone
        if self.component.is_in(x, y):
            self.component.dispatch(drag_over_event, "drag_over")
        
        return self._drag_result
        
    def wx_drag_leave ( self, drag_object ):
        drag_leave_event = DragEvent( x    = 0.0,
                                     y    = 0.0,
                                     x0   = 0.0,
                                     y0   = 0.0,
                                     copy = False,
                                     obj = drag_object,
                                     start_event = default_start_event,
                                     window = self )
        self.component.dispatch(drag_leave_event, "drag_leave")
        return
    
    def create_menu ( self, menu_definition, owner ):
        "Create a wxMenu from a string description"
        return MakeMenu( menu_definition, owner, True, self.control )
    
    def popup_menu ( self, menu, x, y ):
        "Pop-up a wxMenu at a specified location"
        self.control.PopupMenuXY( menu.menu, int(x), int( self._flip_y(y) ) ) 
        return


class GLWindow(_Window):
    
    control = Instance(GLCanvas)

    def __init__(self, *args, **kw):
        super(GLWindow, self).__init__(*args, **kw)

        # If we are using the GL backend, we will need to have a pyglet
        # GL context
        self._pyglet_gl_context = None

        self._gc = None

    def _create_control(self, parent, wid, pos = wx.DefaultPosition, 
                        size = wx.DefaultSize):
        return GLCanvas(parent, wid, pos, size, style = wx.CLIP_CHILDREN | wx.WANTS_CHARS)

    def _on_erase_background(self, event):
        #if self._gc is not None:
        #    self._paint(event)
        pass

    def _create_gc(self, size, pix_format="bgra32"):
        gc = GLGraphicsContextEnable(self._size, window=self)
        if self._pyglet_gl_context is None:
            from pyglet.gl import Context
            self._pyglet_gl_context = Context()
        gc.gl_init()
        return gc

    def _init_gc(self):
        """ Gives the GC a chance to initialize itself before components perform layout
        and draw.  This is called every time through the paint loop.
        """
        dc = wx.PaintDC(self.control)
        self._pyglet_gl_context.set_current()
        self.control.SetCurrent()
        super(GLWindow, self)._init_gc()

    def _paint(self, event=None):
        # Override the base class _paint() method because we need to call
        # _create_gc() each time *before* self.component draws.

        size = self._get_control_size()
        self._size = tuple(size)
        self._gc = self._create_gc(size)
        self._init_gc()
        if hasattr(self.component, "do_layout"):
            self.component.do_layout()
        self._gc.clear(self.bgcolor_)
        self.component.draw(self._gc, view_bounds=(0, 0, size[0], size[1]))
        self._update_region = []
        #self.control.flip()
        self.control.SwapBuffers()

if backend() == "gl":
    Window = GLWindow
else:
    Window = _Window


if wx.__version__.startswith("2.6"):
    WxWindowTrait = Trait(None, wx.WindowPtr)
elif wx.__version__.startswith("2.8"):
    WxWindowTrait = Trait(None, wx.Window)
else:
    raise RuntimeError("Unsupported wxPython version.")

class WindowComponent ( Component ):
    
    component = WxWindowTrait
    
    def __init__ ( self, component = None, **traits ):
        Component.__init__( self, **traits )
        if component is not None:
            self.component  = component
            size            = component.GetAdjustedBestSize()
            self.min_width  = size.GetWidth()
            self.min_height = size.GetHeight()
            self._container_changed( self.container )
            
    def _is_valid ( self ):
        "Determine if it is valid to manipulate the wxWindow component"
        return ((self.component is not None) and 
                isinstance( self.container.window, Window ))
                
    def _set_visibility ( self ):
        "Set the correct visibility for the wxWindows component"
        self.component.Show( 
                 isinstance( self.container.window, Window ) and self.visible )
        return
        
    def _container_changed ( self, container ):
        "Handle the container being changed"
        if self.component is not None:
            self._set_visibility()
            self._bounds_changed( self.bounds )
        return
    
    def _bounds_changed ( self, bounds ):
        "Handle the bounds of the component being changed"
        if self.component is not None:
            x, y, dx, dy = bounds
            comp = self.component
            comp.SetDimensions( 
                 int( x ), int( comp.GetParent()._flip_y( y + dy - 1.0 ) ), 
                 int( dx ), int( dy ) )
            comp.Refresh()
        return
       
    def _components_at ( self, x, y ):
        "Generate any additional components that contain a specified (x,y) point"
        return [ self ]
        
    def draw ( self, gc ):
        "Draw the component in a specified graphics context if it needs it"
        if self._drawable and self.window._needs_redraw( self.bounds ):
            comp = self.component
            if comp is not None:
                comp.Show( self.visible )
                comp.Refresh()
        return
    
# EOF