def __init__(self, x=0, y=0, z=0, width=100, height=100,
                 anchor_x='left', anchor_y='bottom', *args, **kwargs):
        ''' Create a displayable widget.

        :Parameters:
            `x` : float
                X coordinate of the widget relative to anchor_x.
            `y` : float
                Y coordinate of the widget relative to anchor_y.
            `z` : float
                Z coordinate of the widget plane.
            `width` : int
                Width of the widget.
            `height` : int
                Height of the widget.
            `anchor_x` : str
                Horizontal alignment of the widget.
                See `Widget.anchor_x` for details.
            `anchor_y` : str
                Vertical alignment of the widget.
                See `Widget.anchor_y` for details.
        '''
        EventDispatcher.__init__(self)
        self._x, self._y, self._z = x, y, z
        self._root_x, self._root_y, self._root_z = 0,0,0
        self._width = width
        self._height = height
        self.anchor_x = anchor_x
        self.anchor_y = anchor_y
        self._children = []
        self._elements = {}
        self._moveable = True
        self._focusable = True
        self._sizeable = True
        self._hidden = False

    def dispatch_events(self):
        self._allow_dispatch_event = True
        while self._event_queue:
            EventDispatcher.dispatch_event(self, *self._event_queue.pop(0))

        e = EventRef()
        result = carbon.ReceiveNextEvent(0, c_void_p(), 0, True, byref(e))
        while result == noErr:
            carbon.SendEventToEventTarget(e, self._event_dispatcher)
            carbon.ReleaseEvent(e)

            if self._recreate_deferred:
                self._recreate_immediate()
            result = carbon.ReceiveNextEvent(0, c_void_p(), 0, True, byref(e))

        self._allow_dispatch_event = False

        # Return value from ReceiveNextEvent can be ignored if not
        # noErr; we check here only to look for new bugs.
        # eventLoopQuitErr: the inner event loop was quit, see
        # http://lists.apple.com/archives/Carbon-dev/2006/Jun/msg00850.html
        # Can occur when mixing with other toolkits, e.g. Tk.
        # Fixes issue 180.
        if result not in (eventLoopTimedOutErr, eventLoopQuitErr):
            raise 'Error %d' % result

    def __init__(self):
        EventDispatcher.__init__(self)
        assert isinstance(self._event_stack, tuple)
        self._event_stack = [self.default_event_handlers]

        # list of elements that have responded to an on_element_enter event
        self.entered_elements = list()

    def __init__(self, client):
        EventDispatcher.__init__(self)
        self.client = client

        # We need to keep track of which block we are pressing (if any). This
        # way we can have it so you have to press on and let up on a block
        # before it registers. (which is important as that's how people's
        # software works and how they expect the game to work)
        self.pressed_block = None

 def dispatch_pending_events(self):
     while self._event_queue:
         event = self._event_queue.pop(0)
         if type(event[0]) is str:
             # pyglet event
             EventDispatcher.dispatch_event(self, *event)
         else:
             # win32 event
             event[0](*event[1:])

    def __init__(self, image=None):
        if image is None:
            image = ResourceManager.get_player_image()

        ShootingSprite.__init__(self, image, rotation=90, bound_to_window=True)
        EventDispatcher.__init__(self)

        self.health = 100
        self.max_health = 100
        self.armor = None
        self.missle_damage = 10
        self.hit_damage = 100
        self.score = 0
        self.detonate = True

    def __init__(self):
        Layer.__init__(self)
        EventDispatcher.__init__(self)

        self.waves = []
        self.current_wave = None
        self.wave_delay = 3
        self.countdown_label = None
        self.countdown_texts = []
        self.is_started = False
        self.is_next_wave_notified = False
        self.is_enemies_deployed = False
        self.next_level_notified = False
        self.bonuses = []

    def dispatch_events(self):
        self._allow_dispatch_event = True
        while self._event_queue:
            event = self._event_queue.pop(0)
            if type(event[0]) is str:
                # pyglet event
                EventDispatcher.dispatch_event(self, *event)
            else:
                # win32 event
                event[0](*event[1:])

        msg = MSG()
        while _user32.PeekMessageW(byref(msg), self._hwnd, 0, 0, PM_REMOVE):
            _user32.TranslateMessage(byref(msg))
            _user32.DispatchMessageW(byref(msg))
        self._allow_dispatch_event = False

    def dispatch_pending_events(self):
        while self._event_queue:
            EventDispatcher.dispatch_event(self, *self._event_queue.pop(0))

        # Dispatch any context-related events
        if self._lost_context:
            self._lost_context = False
            EventDispatcher.dispatch_event(self, 'on_context_lost')
        if self._lost_context_state:
            self._lost_context_state = False
            EventDispatcher.dispatch_event(self, 'on_context_state_lost')

    def dispatch_events(self):
        while self._event_queue:
            EventDispatcher.dispatch_event(self, *self._event_queue.pop(0))

        # Dispatch any context-related events
        if self._lost_context:
            self._lost_context = False
            EventDispatcher.dispatch_event(self, 'on_context_lost')
        if self._lost_context_state:
            self._lost_context_state = False
            EventDispatcher.dispatch_event(self, 'on_context_state_lost')

        self._allow_dispatch_event = True

        e = xlib.XEvent()

        # Cache these in case window is closed from an event handler
        _x_display = self._x_display
        _window = self._window

        # Check for the events specific to this window
        while xlib.XCheckWindowEvent(_x_display, _window,
                0x1ffffff, byref(e)):
            if xlib.XFilterEvent(e, 0):
                continue
            event_handler = self._event_handlers.get(e.type)
            if event_handler:
                event_handler(e)

        # Generic events for this window (the window close event).
        while xlib.XCheckTypedWindowEvent(_x_display, _window, 
                xlib.ClientMessage, byref(e)):
            event_handler = self._event_handlers.get(e.type)
            if event_handler:
                event_handler(e)
        
        self._allow_dispatch_event = False

 def dispatch_pending_events(self):
     while self._event_queue:
         event = self._event_queue.pop(0)
         EventDispatcher.dispatch_event(self, *event)

    def dispatch_pending_events(self):
        while self._event_queue:
            EventDispatcher.dispatch_event(self, *self._event_queue.pop(0))

        if self._recreate_deferred:
            self._recreate_immediate()

 def __init__(self, **kwargs):
     Widget.__init__(self, **kwargs)
     EventDispatcher.__init__(self)
     if not self.bounds:
         self.bounds = "always"
     self.is_focused = True

 def __init__( self, client ):
     EventDispatcher.__init__(self)
     self.client 	= client
     self.setStart 	= False
     self.setEnd 	= False
     self.erase		= False

 def __init__(self, x=0, y=0):
     EventDispatcher.__init__(self)
     self.pos = Vec(x, y)

 def __init__(self, master):
     EventDispatcher.__init__(self)
     self.master = master
     self.owner = master