def __init__(self):
        Window.__init__(self, 0, getDesktop().height - 24, getDesktop().width, 24, topmost=1)
        self.setLayout(pyui.layouts.BorderLayoutManager())

        self.command = Edit("Enter commands here.", 255, self.enter)
        self.addChild(self.command, pyui.locals.CENTER)
        self.pack()

    def __init__(self):

        # create gui objects
        self.grid = None
        self.makeWindow()
	#self.dbutton = pyui.widgets.Button("Delete!", self.onDelete)
        getDesktop().registerHandler(DIALOGCLOSED, self.onDialogClosed)

 def setDirty(self, collide = 1):
     self.dirty = 1
     if self.dirty:
         return
     if collide:
         getDesktop().dirtyCollidingWindows(self.rect)
     Base.setDirty(self)

 def setShow(self,value):
     self.show = value
     self.setDirty()
     for child in self.children:
         child.setShow(value)
     if not value:
         getDesktop().getTheme().setArrowCursor()            

def init():
    pyui.init(width, height, "p3d", fullscreen=0, title="CodeWorld")
    getRenderer().setBackMethod(render)
    getDesktop().registerHandler(pyui.locals.KEYDOWN, keyDown)
    pygame.key.set_repeat(500, 30)

    initGL()

 def write(self, text):
     text = string.rstrip(text)
     if len(text) < 1:
         return
     text = string.replace(text, "\n", " ")
     text = string.replace(text, "\r", " ")      
     self.append(text)
     getDesktop().postUserEvent(pyui.dialogs.EVENT_OUTPUT)

 def close(self, value = 1):
     #print "closed - " , value
     self.modal = value
     getDesktop().setModal(None)
     self.setShow(0)
     self.loseFocus()
     self.postEvent(locals.DIALOGCLOSED)
     if self.cb:
         self.cb(value)

 def write(self, text):
     #self.oldout.write("%s" % text)
     text = string.rstrip(text)
     if len(text) < 1:
         return
     text = string.replace(text, "\n", " ")
     text = string.replace(text, "\r", " ")      
     self.lines.append(text)
     getDesktop().postUserEvent(EVENT_OUTPUT)

def update():
    getDesktop().draw()
    getDesktop().update()

    r, w, e = Network.multiplex()
    for sock in r:
        try:
            sock.handleInput()
        except Exception, exc:
            print "Unhandled exception:", exc

 def __init__(self, x = -1, y = -1, w = 300, h = 200, title = None):
     # center if position not specified
     if x < 0:
         x = (getDesktop().width - w) / 2
     if y < 0:
         y = (getDesktop().height - h) / 2
     pyui.widgets.Frame.__init__(self, x, y, w, h, title)
     self.modal = -1   # this is set to the return value of the dialog
     self.setShow(1)
     self.setDirty()
     self.cb = None

    def __init__(self):
        Window.__init__(self, 0, 0, getDesktop().width, \
                        getDesktop().height/4, topmost = 1)
        self.setLayout(pyui.layouts.BorderLayoutManager())
        self.outputBox = LineDisplay()
        self.addChild(self.outputBox, pyui.locals.CENTER)
        self.pack()

	Events.addCallbacks('keyDown', self.keyDown)
	
        self.oldout = sys.stdout
        sys.stdout = self

    def ReSizeGLScene(self, Width, Height):
        # Prevent A Divide By Zero If The Window Is Too Small     
        if Height == 0:	
            Height = 1

        # Reset The Current Viewport And Perspective Transformation
        glViewport(0, 0, Width, Height)		
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(45.0, float(Width)/float(Height), 0.1, 100.0)
        glMatrixMode(GL_MODELVIEW)
        getDesktop().width = self.width = Width
        getDesktop().height = self.height = Height

 def destroy(self):
     """Call this to remove all references to the widget from the system.
     """
     #print "destroying %s (%d)" % (self, self.id)
     self.window = None
     self.setParent(None)
     if self.popup:
         self.popup.destroy()
         self.popup = None
     if self.children:
         for child in self.children:
             child.destroy()
         self.children = []
     self.eventMap.clear()
     getDesktop().destroyWidget(self)

    def setup2D(self):
        """Setup everything on the opengl Stack to draw in 2D in a way that can be torn down later.
        """
        glMatrixMode(GL_PROJECTION)
        glPushMatrix()
        glLoadIdentity()
        glOrtho( 0, getDesktop().width, getDesktop().height, 0, -1, 1 )

        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()
        glLoadIdentity()

        glDisable(GL_DEPTH_TEST)

        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

 def __init__(self, x, y, w, h, topmost = 0):
     self._panel = Panel()
     Base.__init__(self)
     self.topMost = topmost
     self._panel.moveto(0,0)
     # the content panel is added as a child through Base::addChild to avoid recursively adding it to itself
     Base.addChild(self, self._panel)
     self._panel.setWindow(self)
     self.drawCommands = []
     # these are drawing callbacks to draw _after_ all the widgets are drawn
     self.drawLastCallbacks = [] 
     if self.__dict__.has_key("title"):
         self.handle = getRenderer().createWindow(self.title)
     else:
         self.handle = getRenderer().createWindow("")
     self.moveto(x, y)
     self.resize(w, h)
     getDesktop().addWindow(self)

    def _pyuiKeyUp(self, event):
        if getDesktop().getFocus() != self.id:
            return 0

        if event.key == pyui.locals.K_SHIFT:
            self.shifting = 0
            return 1

        return 0

 def __init__(self):
     """Initialize and register the base widget. widgets are added to the global widget list initially.
     """
     self.parent = None
     self.window = None
     self.posX = 0
     self.posY = 0
     self.width = 1
     self.height = 1
     self.show = 1
     self.dirty = 1
     self.fgColor = getDesktop().theme.getFgColor()
     self.bgColor = getTheme().getBgColor()
     self.children = []
     self.eventMap = {}
     self.calcSize()
     getDesktop().registerWidget(self)
     self.popup = None
     self.tooltipText = ""

 def runMe(self):
     if not getDesktop().running:
         sys.exit()
     pyui.update()
     pyui.draw()
     self.frame = self.frame + 1
     now = time.time()
     if now - self.last >= 1:
         self.last = now
         print "FPS: %d" % self.frame
         self.frame = 0

    def update(self):
        """PyGame event handling.
        """
        desktop = getDesktop()
        ## process all pending system events.
        event = pygame.event.poll()
        while event.type != locals.NOEVENT:

            # special case to handle multiple mouse buttons!
            if event.type == locals.MOUSEBUTTONDOWN:
                # print "Mausssssssssssssssssssssssssssssssssss"
                if event.dict["button"] == 1:
                    desktop.postUserEvent(pyui.locals.LMOUSEBUTTONDOWN, event.pos[0], event.pos[1])
                elif event.dict["button"] == 3:
                    desktop.postUserEvent(pyui.locals.RMOUSEBUTTONDOWN, event.pos[0], event.pos[1])
                elif event.dict["button"] == 4:
                    desktop.postUserEvent(pyui.locals.MOUSEWHEEL, event.pos[0], event.pos[1], "UP")
                elif event.dict["button"] == 5:
                    desktop.postUserEvent(pyui.locals.MOUSEWHEEL, event.pos[0], event.pos[1], "DOWN")

            elif event.type == locals.MOUSEBUTTONUP:
                if event.dict["button"] == 1:
                    desktop.postUserEvent(pyui.locals.LMOUSEBUTTONUP, event.pos[0], event.pos[1])
                elif event.dict["button"] == 3:
                    desktop.postUserEvent(pyui.locals.RMOUSEBUTTONUP, event.pos[0], event.pos[1])

            elif event.type == locals.MOUSEMOTION:
                desktop.postUserEvent(pyui.locals.MOUSEMOVE, event.pos[0], event.pos[1])

            elif event.type == pygame.VIDEORESIZE:
                desktop.postUserEvent(pygame.VIDEORESIZE, event.w, event.h)

            elif event.type == locals.KEYDOWN:
                character = event.unicode
                code = 0
                if len(character) > 0:
                    code = ord(character)
                else:
                    code = event.key
                    # code = event.key, code
                desktop.postUserEvent(pyui.locals.KEYDOWN, 0, 0, code, pygame.key.get_mods())
                # if code >= 32 and code < 128:
                #    desktop.postUserEvent(pyui.locals.CHAR, 0, 0, character, pygame.key.get_mods())
            elif event.type == locals.KEYUP:
                code = event.key
                desktop.postUserEvent(pyui.locals.KEYUP, 0, 0, code, pygame.key.get_mods())

            else:
                try:
                    desktop.postUserEvent(event.type)
                except:
                    print "Error handling event %s" % repr(event)
            event = pygame.event.poll()

 def onMouse(self, button, state, x, y):
     if button == 1:
         return
     if state == 0:
         # mouse button down
         if button == 0:
             getDesktop().postUserEvent(pyui.locals.LMOUSEBUTTONDOWN, x, y)
         else:
             getDesktop().postUserEvent(pyui.locals.RMOUSEBUTTONDOWN, x, y)
     else:
         # mouse button up
         if button == 0:
             getDesktop().postUserEvent(pyui.locals.LMOUSEBUTTONUP, x, y)
         else:
             getDesktop().postUserEvent(pyui.locals.RMOUSEBUTTONUP, x, y)