#stolen from the ChimpLineByLine example at pygame.org
 main():
   ...
    while 1:

# Апрацоўваць ўваходныя падзеі
        for event in pygame.event.get():
            if event.type == QUIT:
                return
            elif event.type == MOUSEBUTTONDOWN:
                fist.punch()
            elif event.type == MOUSEBUTTONUP:
                fist.unpunch()

       # Маляваць ўсё
        allsprites.update()
        screen.blit(background, (0, 0))
        allsprites.draw(screen)
        pygame.display.flip()

 ControllerTick():
    #Handle Input Events
    for event in pygame.event.get():
        if event.type == QUIT:
            return False
        elif event.type == MOUSEBUTTONDOWN:
            fist.punch()
        elif event.type == MOUSEBUTTONUP:
            fist.unpunch()
    return True

 ViewTick():
  # Маляваць ўсё
   ...

 main():
   ...
    while 1:

        if not ControllerTick():
            return

        ViewTick()

class Event:
   "" "Гэта сyперкласс для любога падзеі, якія могyць быць атрыманы ад аб'екта і адпраўлены ў EventManager" ""
    def __init__(self):
        self.name = "Generic Event"

class EventManager:
   "" "Гэты аб'ект адказвае за каардынацыю найбольш сyвязі паміж Мадэль, Выгляд і кантролер." ""
    def __init__(self ):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()

    #----------------------------------------------------------------------

    def RegisterListener( self, listener ):
        self.listeners[ listener ] = 1

    #----------------------------------------------------------------------
    def UnregisterListener( self, listener ):
        if listener in self.listeners.keys():
            del self.listeners[ listener ]
        
    #----------------------------------------------------------------------
    def Post( self, event ):
        """Post a new event.  It will be broadcast to all listeners"""
        for listener in self.listeners.keys():
            #NOTE: If the weakref has died, it will be 
            #automatically removed, so we don't have 

            #to worry about it.
            listener.Notify( event )

class KeyboardController:
   ...
    def Notify(self, event):
        if isinstance( event, TickEvent ):
            #Handle Input Events
           ...

class CPUSpinnerController:
   ...
    def Run(self):
        while self.keepGoing:
            event = TickEvent()
            self.evManager.Post( event )

    def Notify(self, event):
        if isinstance( event, QuitEvent ):
            self.keepGoing = False
           ...


class PygameView:
   ...
    def Notify(self, event):
        if isinstance( event, TickEvent ):
            #Draw Everything
           ...

 main():
   ...
    evManager = EventManager()

    keybd = KeyboardController()
    spinner = CPUSpinnerController()
    pygameView = PygameView()
    
    evManager.RegisterListener( keybd )
    evManager.RegisterListener( spinner )
    evManager.RegisterListener( pygameView )

    spinner.Run()

#------------------------------------------------------------------------------
class TextLogView:
        """..."""
        def __init__(self, evManager):
                self.evManager = evManager
                self.evManager.RegisterListener( self )
                                                                               
                                                                               
        #----------------------------------------------------------------------
        def Notify(self, event):
                                                                               
                if isinstance( event, CharactorPlaceEvent ):
                        print event.name, " at ", event.charactor.sector
                                                                               
                elif isinstance( event, CharactorMoveEvent ):
                        print event.name, " to ", event.charactor.sector
                                                                               
                elif not isinstance( event, TickEvent ):
                        print event.name

ад twisted.spread Pb імпартy


#------------------------------------------------------------------------------
class NetworkClientController(pb.Root):
        """..."""
        def __init__(self, evManager):
                self.evManager = evManager
                self.evManager.RegisterListener( self )

        #----------------------------------------------------------------------
        def remote_GameStartRequest(self):
                ev = GameStartRequest( )
                self.evManager.Post( ev )
                return 1

        #----------------------------------------------------------------------
        def remote_CharactorMoveRequest(self, direction):
                ev = CharactorMoveRequest( direction )
                self.evManager.Post( ev )
                return 1

        #----------------------------------------------------------------------
        def Notify(self, event):
                pass

def main():
    evManager = EventManager()

    log = TextLogView( evManager )
    clientController = NetworkClientController( evManager )
    game = Game( evManager )
    
    from twisted.internet import reactor

    reactor.listenTCP( 8000, pb.PBServerFactory(clientController) )

    reactor.run()

class GameStartRequest(Event):
        def __init__(self):
        self.name = "Game Start Request"

# Прыклад класа, помпы Twisted рэактара



class ReactorSlaveController(object):
    def __init__(self):
       ...
        factory = pb.PBClientFactory()
        self.reactor = SelectReactor()
        installReactor(self.reactor)
        connection = self.reactor.connectTCP('localhost', 8000, factory)
        self.reactor.startRunning()
       ...

    def PumpReactor(self):
        self.reactor.runUntilCurrent()
        self.reactor.doIteration(0)

    def Stop(self):
        self.reactor.addSystemEventTrigger('after', 'shutdown',
                                            self.onReactorStop)
        self.reactor.stop()
        self.reactor.run() #excrete anything left in the reactor

    def onReactorStop(self):
        '''This gets called when the reactor is absolutely finished'''

        self.reactor = None

# Прыклад выкарыстання LoopingCall звольніць падзеі Tick


from twisted.internet.task import LoopingCall

...

def FireTick(evManager):
    evManager.Post( TickEvent() )

loopingCall = LoopingCall(FireTick, evManager)
interval = 1.0 / FRAMES_PER_SECOND
loopingCall.start(interval)

# from network.py

#------------------------------------------------------------------------------

# GameStartRequest
# Direction: Client to Server only
MixInCopyClasses( GameStartRequest )
pb.setUnjellyableForClass(GameStartRequest, GameStartRequest)
clientToServerEvents.append( GameStartRequest )

#------------------------------------------------------------------------------
# CharactorMoveRequest
# Direction: Client to Server only
# this has an additional attribute, direction.  it is an int, so it's safe
MixInCopyClasses( CharactorMoveRequest )
pb.setUnjellyableForClass(CharactorMoveRequest, CharactorMoveRequest)
clientToServerEvents.append( CharactorMoveRequest )

# from network.py

#------------------------------------------------------------------------------
# GameStartedEvent
# Direction: Server to Client only
class CopyableGameStartedEvent(pb.Copyable, pb.RemoteCopy):
        def __init__(self, event, registry):
                self.name = "Game Started Event"
                self.gameID =  id(event.game)
                registry[self.gameID] = event.game

pb.setUnjellyableForClass(CopyableGameStartedEvent, CopyableGameStartedEvent)
serverToClientEvents.append( CopyableGameStartedEvent )

#------------------------------------------------------------------------------
# CharactorMoveEvent

# Direction: Server to Client only
class CopyableCharactorMoveEvent( pb.Copyable, pb.RemoteCopy):
        def __init__(self, event, registry ):
                self.name = "Charactor Move Event"
                self.charactorID = id( event.charactor )
                registry[self.charactorID] = event.charactor

pb.setUnjellyableForClass(CopyableCharactorMoveEvent, CopyableCharactorMoveEvent)
serverToClientEvents.append( CopyableCharactorMoveEvent )

# from server.py

#------------------------------------------------------------------------------

class NetworkClientView(object):
	"""We SEND events to the CLIENT through this object"""
	def __init__(self, evManager, sharedObjectRegistry):
		self.evManager = evManager
		self.evManager.RegisterListener( self )

		self.clients = []
		self.sharedObjs = sharedObjectRegistry


	#----------------------------------------------------------------------
	def Notify(self, event):
		if isinstance( event, ClientConnectEvent ):
			self.clients.append( event.client )

		ev = event

		#don't broadcast events that aren't Copyable
		if not isinstance( ev, pb.Copyable ):
			evName = ev.__class__.__name__
			copyableClsName = "Copyable"+evName
			if not hasattr( network, copyableClsName ):
				return
			copyableClass = getattr( network, copyableClsName )
			ev = copyableClass( ev, self.sharedObjs )

		if ev.__class__ not in network.serverToClientEvents:
			#print "SERVER NOT SENDING: " +str(ev)
			return

		#NOTE: this is very "chatty".  We could restrict 
		#      the number of clients notified in the future

		for client in self.clients:
			print "=====server sending: ", str(ev)
			remoteCall = client.callRemote("ServerEvent", ev)

# from client.py

#------------------------------------------------------------------------------
class NetworkServerView(pb.Root):
        """We SEND events to the server through this object"""

       ...

        #----------------------------------------------------------------------
        def Connected(self, server):
                self.server = server
                self.state = NetworkServerView.STATE_CONNECTED
                ev = ServerConnectEvent( server )
                self.evManager.Post( ev )

       ...

        #----------------------------------------------------------------------
        def AttemptConnection(self):
               ...
                connection = self.reactor.connectTCP(serverHost, serverPort,
                                                     self.pbClientFactory)
                deferred = self.pbClientFactory.getRootObject()
                deferred.addCallback(self.Connected)
                deferred.addErrback(self.ConnectFailed)
                self.reactor.startRunning()

       ...

        #----------------------------------------------------------------------
        def Notify(self, event):
                ev = event

                if isinstance( event, TickEvent ):
                        if self.state == NetworkServerView.STATE_PREPARING:
                                self.AttemptConnection()
                       ...

# from client.py

#------------------------------------------------------------------------------
class NetworkServerController(pb.Referenceable):
        """We RECEIVE events from the server through this object"""
        def __init__(self, evManager, twistedReactor):
                self.evManager = evManager
                self.evManager.RegisterListener( self )

        #----------------------------------------------------------------------
        def remote_ServerEvent(self, event):
                self.evManager.Post( event )
                return 1

        #----------------------------------------------------------------------

        def Notify(self, event):
                if isinstance( event, ServerConnectEvent ):
                        #tell the server that we're listening to it and
                        #it can access this object
                        event.server.callRemote("ClientConnect", self)

# from server.py

class NetworkClientView:
       ...

        def Notify(self, event):
               ...

                ev = event

                if not isinstance( ev, pb.Copyable ):
                        evName = ev.__class__.__name__
                        copyableClsName = "Copyable"+evName
                        if not hasattr( network, copyableClsName )
                                return
                        copyableClass = getattr( network, copyableClsName )
                        #It is here that serialization starts
                        ev = copyableClass( ev, self.sharedObjs )

                elif ev.__class__ not in serverToClientEvents:
                        return 

                for client in self.clients:
                        self.RemoteCall( client, "ServerEvent", ev )

# from network.py

class CopyableCharactorMoveEvent( pb.Copyable, pb.RemoteCopy):
        def __init__( self, event, registry ):
                self.name = "Copyable " + event.name
                self.charactorID = id( event.charactor )
                registry[self.charactorID] = event.charactor

#from client.py

class PhonyModel
       ...

        #----------------------------------------------------------------------
        def Notify(self, event):
               ...

                if isinstance( event, CopyableCharactorMoveEvent ):
                        charactorID = event.charactorID
                        if not self.sharedObjs.has_key(charactorID):
                                charactor = self.game.players[0].charactors[0]
                                self.sharedObjs[charactorID] = charactor
                        remoteResponse = self.server.callRemote("GetObjectState", charactorID)
                        remoteResponse.addCallback(self.StateReturned)
                        remoteResponse.addCallback(self.CharactorMoveCallback, charactorID)

# from network.py

#------------------------------------------------------------------------------
class CopyableCharactor:
        def getStateToCopy(self, registry):
                d = self.__dict__.copy()
                del d['evManager']
                sID = id( self.sector )
                d['sector'] = sID
                registry[sID] = self.sector
                return d

        def setCopyableState(self, stateDict, registry):
                neededObjIDs = []
                success = 1
                if stateDict['sector'] not in registry:
                        registry[stateDict['sector']] = Sector(self.evManager)
                        neededObjIDs.append( stateDict['sector'] )
                        success = 0
                else:
                        self.sector = registry[stateDict['sector']]

                return [success, neededObjIDs]

# from client.py

        def Notify(self, event):
               ...

                        remoteResponse = self.server.callRemote("GetObjectState", charactorID)
                        remoteResponse.addCallback(self.StateReturned)
                        remoteResponse.addCallback(self.CharactorMoveCallback)

# from server.py

        def remote_GetObjectState(self, objectID):
               ...

                return [objectID, objDict]

# from client.py

        #----------------------------------------------------------------------
        def StateReturned(self, response):
                """this is a callback that is called in response to 
                invoking GetObjectState on the server"""

                objID, objDict = response
                if objID == 0:
                        print "GOT ZERO -- better error handler here"
                        return None
                obj = self.sharedObjs[objID]

                success, neededObjIDs =\
                                 obj.setCopyableState(objDict, self.sharedObjs)
                if success:
                        #we successfully set the state and no further objects

                        #are needed to complete the current object
                        if objID in self.neededObjects:
                                self.neededObjects.remove(objID)

                else:
                  # Для завяршэння бягyчага аб'екта, мы павінны захапіць # дзяржава ад яшчэ некалькі аб'ектаў на сэрвэры. Ідэнтыфікатары # для тых, неабходныя аб'екты былі перададзены назад # y neededObjIDs
                        for neededObjID in neededObjIDs:
                                if neededObjID not in self.neededObjects:
                                        self.neededObjects.append(neededObjID)
        
                self.waitingObjectStack.append( (obj, objDict) )

                retval = self.GetAllNeededObjects()
                if retval:
                  # RETVAL з'яўляецца Адкладзены - вяртанне гэта выклікае ланцyг #, які бyдзе сфармаваны RETVAL. Вяртанне 

# from client.py

        #----------------------------------------------------------------------
        def GetAllNeededObjects(self):
                if len(self.neededObjects) == 0:
                        # Гэта рэкyрсіі бясконцай стане. Калі Ёсць # не больш аб'ектаў неабходна схапіў з сервера #, то мы можам паспрабаваць setCopyableState на іх зноў і # мы павінны зараз мець yсе неабходныя аб'екты, гарантyючы, што # setCopyableState паспяхова
						
                        return self.ConsumeWaitingObjectStack()

       # Яшчэ ў крокy рэкyрсіі. Пастарайцеся, каб атрымаць стан аб'екта для # ObjectID на вяршыню стэка. Звярніце ўвагy, што рэкyрсіі # ажыццяўляецца праз адкладзенае, якія могyць yвесці ў зман
                nextID = self.neededObjects[-1]
                remoteResponse = self.server.callRemote("GetObjectState",nextID)
                remoteResponse.addCallback(self.StateReturned)
                return remoteResponse

#------------------------------------------------------------------------------
class Weapon:
    def __init__( self, evManager, name )
        self.evManager = evManager
        self.name = name

#------------------------------------------------------------------------------
class CopyablePenguin:
    def getStateToCopy(self, registry):
        d = self.__dict__.copy()
        del d['evManager']

        wID = id( self.weapon )
        registry[wID] = self.weapon
        d['weapon'] = wID
                                                                                
        return d

    def setCopyableState(self, stateDict, registry):
        neededObjIDs = []
        success = 1

        wID = stateDict['weapon']
        if not registry.has_key( wID ):
# Рэестра не было аб'екта, такім чынам, стварыць новyю
            self.weapon = Weapon( self.evManager,
           # WELL дзярмо! Я яшчэ не ведаю, што яго імя, так як я збіраюся яго ініцыялізаваць? 

       ...
        wID = stateDict['weapon']
        if not registry.has_key( wID ):
      # Рэестра не было аб'екта, такім чынам, стварыць новyю
            self.weapon = ???
           
# Дадатковая дзярмо! Я нават не ведаю, што клас аб'екта павінна быць! 

# from server.py

class NetworkClientController(pb.Avatar):
        """We RECEIVE events from the CLIENT through this object
        There is an instance of NetworkClientController for each connected
        client.
        """
        def __init__(self, evManager, avatarID, realm):
                self.evManager = evManager
                self.evManager.RegisterListener( self )
                self.avatarID = avatarID
                self.realm = realm

       ...

        #----------------------------------------------------------------------
        def perspective_GetGameSync(self):
               ...

        #----------------------------------------------------------------------
        def perspective_GetObjectState(self, objectID):
               ...

        #----------------------------------------------------------------------
        def perspective_EventOverNetwork(self, event):
               ...

# from server.py

class MyRealm:
        implements(portal.IRealm)
        def __init__(self, evManager):
                self.evManager = evManager
                # keep track of avatars that have been given out
                self.claimedAvatarIDs = []
                # we need to hold onto views so they don't get garbage collected
                self.clientViews = []
                # maps avatars to player(s) they control

                self.playersControlledByAvatar = {}

        #----------------------------------------------------------------------
        def requestAvatar(self, avatarID, mind, *interfaces):
                if pb.IPerspective not in interfaces:
                        raise NotImplementedError
                if avatarID in self.claimedAvatarIDs:
                        # someone already has this avatar.
                        raise Exception( 'Another client is already connected'
                                         ' to this avatar' )

                self.claimedAvatarIDs.append(avatarID)
                ev = ClientConnectEvent( mind, avatarID )
                self.evManager.Post( ev )

                self.playersControlledByAvatar[avatarID] = []
                view = NetworkClientView( self.evManager, avatarID, mind )
                controller = NetworkClientController(self.evManager,
                                                     avatarID,
                                                     self)
                self.clientViews.append(view)
                return pb.IPerspective, controller, controller.clientDisconnect

        #----------------------------------------------------------------------
        def knownPlayers(self):
               ...

        #----------------------------------------------------------------------
        def Notify(self, event):
                if isinstance(event, ClientDisconnectEvent):
                        self.claimedAvatarIDs.remove(event.avatarID)
                        removee = None
                        for view in self.clientViews:
                                if view.avatarID == event.avatarID:
                                        removee = view
                        if removee:
                                self.clientViews.remove(removee)

# from client.py

avatarID = None

def main():
    global avatarID
    if len(sys.argv) > 1:
        avatarID = sys.argv[1]
    else:
        avatarID = 'user1'


class NetworkServerView(pb.Root):
    """We SEND events to the server through this object"""
   ...
    #----------------------------------------------------------------------

    def __init__(self, evManager, sharedObjectRegistry):
            self.evManager = evManager
            self.evManager.RegisterListener( self )

            self.pbClientFactory = pb.PBClientFactory()
            self.state = NetworkServerView.STATE_PREPARING
            self.reactor = None
            self.server = None

            self.sharedObjs = sharedObjectRegistry

    #----------------------------------------------------------------------
    def AttemptConnection(self):
            self.state = NetworkServerView.STATE_CONNECTING
            if self.reactor:
                    self.reactor.stop()
                    self.PumpReactor()
            else:
                    self.reactor = SelectReactor()
                    installReactor(self.reactor)
            connection = self.reactor.connectTCP(serverHost, serverPort,
                                                 self.pbClientFactory)
            userCred = credentials.UsernamePassword(avatarID, 'pass1')
            controller = NetworkServerController( self.evManager )
            deferred = self.pbClientFactory.login(userCred, client=controller)
            deferred.addCallback(self.Connected)
            deferred.addErrback(self.ConnectFailed)
            self.reactor.startRunning()

    #----------------------------------------------------------------------
    def Disconnect(self):
            if not self.reactor:
                    return
            self.reactor.stop()
            self.PumpReactor()
            self.state = NetworkServerView.STATE_DISCONNECTING

    #----------------------------------------------------------------------
    def Connected(self, server):
            self.server = server
            self.state = NetworkServerView.STATE_CONNECTED
            ev = ServerConnectEvent( server )
            self.evManager.Post( ev )

    #----------------------------------------------------------------------
    def ConnectFailed(self, server):
            self.state = NetworkServerView.STATE_DISCONNECTED

# from events.py

class GameSyncEvent(Event):
    def __init__(self, game):
        self.name = "Game Synched to Authoritative State"
        self.game = game

# from server.py

class NetworkClientController(pb.Avatar):

   ...

    def perspective_GetGameSync(self):
     "" "Звычайна гэта завецца, калі кліент першым падключэнні ці калі яны аднавіць пасля падзення" ""
        game = sharedObjectRegistry.getGame()
        if game == None:
            raise Exception('Game should be set by this point')
        gameID = id( game )
        gameDict = game.getStateToCopy( sharedObjectRegistry )

        return [gameID, gameDict]

# from client.py

class PhonyModel:

   ...

    def Notify(self, event):
        if isinstance( event, ServerConnectEvent ):
            self.server = event.server
            #when we reconnect to the server, we should get the
            #entire game state.
            if not self.game:
                self.game = Game( self.phonyEvManager )
                gameID = id(self.game)
                self.sharedObjs[gameID] = self.game
            remoteResponse = self.server.callRemote("GetGameSync")
            remoteResponse.addCallback(self.GameSyncReturned)
            remoteResponse.addCallback(self.GameSyncCallback, gameID)
            remoteResponse.addErrback(self.ServerErrorHandler, 'ServerConnect')

       ...

# from client.py

class PhonyModel:

   ...

    def GameSyncReturned(self, response):
        gameID, gameDict = response
        print "GameSyncReturned : ", gameID
        self.sharedObjs[gameID] = self.game
        # StateReturned returns a deferred, pass it on to keep the
        # chain going.
        return self.StateReturned( response )

   ...

    def GameSyncCallback(self, deferredResult, gameID):
        game = self.sharedObjs[gameID]
        ev = GameSyncEvent( game )
        self.realEvManager.Post( ev )

# from example.py

class KeyboardController:

   ...

    def Notify(self, event):

       ...

        if isinstance( event, GameSyncEvent ):
            game = event.game
            self.players = game.players[:] # copy the list

            if self.playerName and self.players:
                self.activePlayer = [p for p in self.players
                                     if p.name == self.playerName][0]
       ...

#------------------------------------------------------------------------------
class Widget(pygame.sprite.Sprite):
    def __init__(self, evManager, container=None):
        pygame.sprite.Sprite.__init__(self)

        self.evManager = evManager
        self.evManager.RegisterListener( self )

        self.container = container
        self.focused = 0
        self.dirty = 1

    #----------------------------------------------------------------------

    def SetFocus(self, val):
        self.focused = val
        self.dirty = 1

    #----------------------------------------------------------------------
    def kill(self):
        self.container = None
        del self.container
        pygame.sprite.Sprite.kill(self)

    #----------------------------------------------------------------------
    def Notify(self, event):
        if isinstance( event, GUIFocusThisWidgetEvent ) \
           and event.widget is self:
            self.SetFocus(1)

        elif isinstance( event, GUIFocusThisWidgetEvent ) \
             and self.focused:
            self.SetFocus(0)

#------------------------------------------------------------------------------

class LabelSprite(Widget):
    def __init__(self, evManager, text, container=None):
        Widget.__init__( self, evManager, container)

        self.color = (200,200,200)
        self.font = pygame.font.Font(None, 30)
        self.__text = text
        self.image = self.font.render( self.__text, 1, self.color)
        self.rect  = self.image.get_rect()

    #----------------------------------------------------------------------
    def SetText(self, text):
        self.__text = text
        self.dirty = 1

    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return

        self.image = self.font.render( self.__text, 1, self.color )
        self.dirty = 0

#------------------------------------------------------------------------------

class ButtonSprite(Widget):
    def __init__(self, evManager, text, container=None, onClickEvent=None ):
        Widget.__init__( self, evManager, container)

        self.font = pygame.font.Font(None, 30)
        self.text = text
        self.image = self.font.render( self.text, 1, (255,0,0))
        self.rect  = self.image.get_rect()

        self.onClickEvent = onClickEvent

    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return

        if self.focused:
            color = (255,255,0)
        else:
            color = (255,0,0)
        self.image = self.font.render( self.text, 1, color)
        #self.rect  = self.image.get_rect()

        self.dirty = 0

    #----------------------------------------------------------------------
    def Connect(self, eventDict):
        for key,event in eventDict.iteritems():
            try:
                self.__setattr__( key, event )
            except AttributeError:
                print "Couldn't connect the ", key
                pass


    #----------------------------------------------------------------------
    def Click(self):
        self.dirty = 1
        if self.onClickEvent:
            self.evManager.Post( self.onClickEvent )

    #----------------------------------------------------------------------

    def Notify(self, event):
        if isinstance( event, GUIPressEvent ) and self.focused:
            self.Click()

        elif isinstance( event, GUIClickEvent ) \
             and self.rect.collidepoint( event.pos ):
            self.Click()

        elif isinstance( event, GUIMouseMoveEvent ) \
             and self.rect.collidepoint( event.pos ):
            ev = GUIFocusThisWidgetEvent(self)
            self.evManager.Post( ev )

        Widget.Notify(self,event)

#------------------------------------------------------------------------------
class TextBoxSprite(Widget):
    def __init__(self, evManager, width, container=None ):
        Widget.__init__( self, evManager, container)

        self.font = pygame.font.Font(None, 30)
        linesize = self.font.get_linesize()

        self.rect = pygame.Rect( (0,0,width, linesize +4) )
        boxImg = pygame.Surface( self.rect.size ).convert_alpha()
        color = (0,0,100)
        pygame.draw.rect( boxImg, color, self.rect, 4 )

        self.emptyImg = boxImg.convert_alpha()
        self.image = boxImg

        self.text = ''
        self.textPos = (22, 2)

    #----------------------------------------------------------------------
    def update(self):
        if not self.dirty:
            return

        text = self.text
        if self.focused:
            text += '|'

        textColor = (255,0,0)
        textImg = self.font.render( text, 1, textColor )
        self.image.blit( self.emptyImg, (0,0) )
        self.image.blit( textImg, self.textPos )

        self.dirty = 0

    #----------------------------------------------------------------------

    def Click(self):
        self.focused = 1
        self.dirty = 1

    #----------------------------------------------------------------------
    def SetText(self, newText):
        self.text = newText
        self.dirty = 1

    #----------------------------------------------------------------------
    def Notify(self, event):

        if isinstance( event, GUIPressEvent ) and self.focused:
            self.Click()

        elif isinstance( event, GUIClickEvent ) \
             and self.rect.collidepoint( event.pos ):
            self.Click()

        elif isinstance( event, GUIClickEvent ) \
             and self.focused:
            self.SetFocus(0)

        elif isinstance( event, GUIMouseMoveEvent ) \
             and self.rect.collidepoint( event.pos ):
            ev = GUIFocusThisWidgetEvent(self)
            self.evManager.Post( ev )

        elif isinstance( event, GUIKeyEvent ) \
             and self.focused:
            newText = self.text + event.key
            self.SetText( newText )

        elif isinstance( event, GUIControlKeyEvent ) \
          and self.focused and event.key == K_BACKSPACE:
            #strip of last character
            newText = self.text[:( len(self.text) - 1 )]
            self.SetText( newText )

        Widget.Notify(self,event)