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 destroy(self):
     if self.handle:
         getRenderer().destroyWindow(self.handle)
     self._panel = None            
     self.handle = 0
     self.drawList = []
     Base.destroy(self)

    def __init__(self, title, text, DialogType): #DialogType 0: Ok - Cancel || 1: Ok

        size = getRenderer().getTextSize(title)
        Dialog.__init__(self, title = title)
        self.setLayout(pyui.layouts.BorderLayoutManager())
        self.textLabel = pyui.widgets.Label(text)
        self.textLabel.setText(text)
        self.buttonPanel = pyui.widgets.Panel()
        self.buttonPanel.setLayout(pyui.layouts.BorderLayoutManager())
        if DialogType == 0:
            self.okButton = pyui.widgets.Button("OK", self._pyuiOK)
            self.okButton.resize(self.innerWidth/2, self.okButton.height)
            self.cancelButton = pyui.widgets.Button("Cancel", self._pyuiCancel)
            self.cancelButton.resize(self.innerWidth/2, self.cancelButton.height)     
            self.buttonPanel.addChild(self.okButton, locals.WEST)
            self.buttonPanel.addChild(self.cancelButton, locals.EAST)
            self.buttonPanel.pack()
        if DialogType == 1:
            self.okButton = pyui.widgets.Button("OK", self._pyuiOK)     
            self.buttonPanel.addChild(self.okButton, locals.SOUTH)
            self.buttonPanel.pack()            
        
        self.addChild(self.textLabel, locals.CENTER)
        self.addChild(self.buttonPanel, locals.SOUTH)

        self.pack()

 def resize(self, w, h):
     pyui.widgets.Base.resize(self, w,h)
     self.vscroll.resize(getTheme().getScrollerSize(), h)
     self.vscroll.moveto(w-getTheme().getScrollerSize(), 0)
     self.textWidth = self.width - self.vscroll.width
     self.numVisible = self.height / getRenderer().getTextSize("x")[1]
     self.rewrap = 1

    def scrollToCursor(self):
        (x,y,w,h) = self.windowRect

        font_width, font_heigth = getRenderer().getTextSize( ' ', self.font )
        grid_width, grid_height = self.getGrid()

        caretPos = self.caretPos + ( 7 * self.text.count( '\t', 0, self.caretPos ) )
        text = self.text.expandtabs( 8 )
        
        row = text.count( '\n', 0, caretPos )
        if row > 0: col = caretPos - text.rfind( '\n', 0, caretPos ) -1
        else: col = caretPos
        
        adj = (caretPos == len( text ) or text[caretPos] == '\n') and 1 or 0
        
        if col - adj < self.scroll[0]:
            self.scroll = max( col - adj, 0 ), self.scroll[1]
        elif col > self.scroll[0] + grid_width:
            self.scroll = col - grid_width, self.scroll[1]
        
        if row < self.scroll[1]:
            self.scroll = self.scroll[0], row
        elif row >= self.scroll[1] + grid_height:
            self.scroll = self.scroll[0], row - grid_height + 1
        
        self.updateScrollBars()

 def clear(self):
     self.lines = []
     self.displayLines = []
     self.numVisible = self.height / getRenderer().getTextSize("x")[1]
     self.numItems = 0
     self.topItem = 0
     self.rewrap = 0

    def findMousePos(self, pos):
        # put hit position in window relative coords
        x = pos[0] - self.rect[0] - 2
        y = pos[1] - self.rect[1] - 5
        
        font_width, font_heigth = getRenderer().getTextSize( ' ', self.font )
        
        col = max( math.floor( (float(x) / float(font_width)) ) + self.scroll[0], 0 )
        row = max( math.floor( (float(y) / float(font_heigth)) ) + self.scroll[1], 0 )
        
        r, c, i = 0, 0, 0
        while r != row:
            try: i = self.text.index( '\n', i ) + 1
            except: break
            r += 1
        
        while c < col:
            if i >= len( self.text) or self.text[i] == '\n':
                break
            elif self.text[i] == '\t':
                if ( c + 4 > col ): break
                c += 8
            else:
                c += 1
            i += 1

        return min( max( i, 0 ), len( self.text ) )

    def __init__( self, text = '' ):
        pyui.widgets.Base.__init__(self)
        self.text = text
        self.caretPos = 0
        self.selectPos = 0
        self.dragging = 0
        self.readonly = 0

        self.font = getRenderer().createFont("courier", 12, 0)
        
        self.scroll = 0, 0
        self.vscroll = pyui.widgets.VScroll()
        self.addChild( self.vscroll )
        self.hscroll = pyui.widgets.HScroll()
        self.addChild( self.hscroll )
        self.registerEvent(pyui.locals.SCROLLPOS, self._pyuiScrollPos)
        
        self.registerEvent(pyui.locals.KEYDOWN, self._pyuiKeyDown)
        self.registerEvent(pyui.locals.KEYUP, self._pyuiKeyUp)
        self.registerEvent(pyui.locals.CHAR, self._pyuiChar)
        self.registerEvent(pyui.locals.LMOUSEBUTTONDOWN, self._pyuiMouseDown)
        self.registerEvent(pyui.locals.LMOUSEBUTTONUP, self._pyuiMouseUp)
        self.registerEvent(pyui.locals.MOUSEMOVE, self._pyuiMouseMotion)
        self.registerEvent(pyui.locals.CLICKED, self._pyuiClicked)
        self.resize( 100, 100 )

    def __init__(self, x, y, handler, game):
        pyui.widgets.Button.__init__(self,"",  handler)
        self.registerEvent(RMOUSEBUTTONDOWN, self.onMined)        
        self.x = x
        self.y = y
        self.game = game
        self.reset()
	self.grey = getRenderer().packColor( 150, 150, 50 )

 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 __init__(self, handler, text, subMenu):
     self.handler = handler
     self.text = text
     (width, height) = getRenderer().getTextSize(text, getTheme().defaultFont)
     self.width = width
     self.subMenu = subMenu
     self.icon = None
     self.rect = (0,0,0,0)
     self.canActivate = handler or subMenu

    def _pyuiMouseMotion(self, event):
        if self.moving:
            mouseX = event.pos[0] - self.posX
            mouseY = event.pos[1] - self.posY
            self.frameMove( mouseX - self.startX, mouseY - self.startY)
            getRenderer().moveWindow(self.handle, self.posX, self.posY)
            return 1
        if self.resizing:
            mouseX = event.pos[0] - self.posX
            mouseY = event.pos[1] - self.posY
            if mouseX < 64:
                mouseX = 64
            if mouseY < 64:
                mouseY = 64
            self.frameResize( self.width + mouseX - self.startX, self.height + mouseY - self.startY)
            (self.startX, self.startY) = (mouseX, mouseY)
            return 1

        # set the proper cursor
        regionId = self.hitFrameRegion(event.pos)
        if regionId == pyui.locals.HIT_FRAME_RESIZE_BOTTOM_RIGHT:        
            self.resizingCursor=1
            self.theme.setResizeCursor()
        elif self.resizingCursor:
            self.resizingCursor=0
            self.theme.setArrowCursor()

        if regionId == pyui.locals.HIT_FRAME_MOVE:            
            self.movingCursor = 1
            self.theme.setMovingCursor()
        elif self.movingCursor:
            self.movingCursor = 0
            self.theme.setArrowCursor()
            
        if not self.hit(event.pos):
            if self.resizingCursor and not self.resizing:
                self.resizingCursor=0
                self.theme.setArrowCursor()
            if self.movingCursor and not self.moving:
                self.movingCursor=0
                self.theme.setArrowCursor()
            return 0
        else:
            return 1

 def drawMenuBarItem(self, rect, title, selected):
     title = "   " + title + "   "
     (w,h) = getRenderer().getTextSize(title, self.defaultFont)
     if selected:
         getRenderer().drawRect(self.bgColor3, (rect[0], rect[1], w, rect[3]))
         getRenderer().drawText(title, (rect[0], rect[1]), self.fgColor, self.defaultFont)
     else:
         getRenderer().drawText(title, (rect[0], rect[1]), self.fgColor, self.defaultFont)
     return (rect[0], rect[1], w, rect[3])

 def drawListBoxItem(self, rect, title, selected, color):
     if selected:
         getRenderer().drawRect(self.bgColor3, (rect[0] +2, rect[1] - 1, rect[2]- 1 - 3, rect[3] ))
         getRenderer().drawText(title, (rect[0]+2, rect[1]), self.fgColor, self.defaultFont)
     else:
         getRenderer().drawText(title, (rect[0]+2, rect[1]), color, self.defaultFont)
     return rect

 def __init__(self):
     pyui.widgets.Base.__init__(self)
     #self.bgColor = (0,0,49, 255)
     self.lines = []
     self.displayLines = []
     self.numVisible = self.height / getRenderer().getTextSize("x")[1]
     self.numItems = 0
     self.topItem = 0
     self.rewrap = 0
     self.textWidth = 0
     self.vscroll = pyui.widgets.VScroll()
     self.addChild(self.vscroll)
     self.registerEvent(locals.SCROLLPOS, self._pyuiScrollPos)

 def draw(self, renderer):
     #renderer.drawRect(getTheme().bgColor2, self.windowRect)
     if self.rewrap:
         self.rewrapAll()
         self.rewrap = 0
         
     i = 0
     h = getRenderer().getTextSize("x")[1]
     for (line, color) in self.displayLines:
         if i >= self.topItem and i < (self.topItem + self.numVisible):
             renderer.drawText(line, (self.windowRect[0]+2, self.windowRect[1]+2+((i-self.topItem)*h)), color )
         i += 1
     self.vscroll.draw(renderer)
     self.clearDirty()

    def drawButton(self, rect, title, hasFocus, status, enabled, font=None, shadow=2, fgColor=0, bgColor=0, roColor=0):
        """Options are:  button title and the up/down status.
        status == 0: normal
        status == 1: rollover
        status == 2: down
        """
        (x,y,w,h) = rect
        if shadow < 2:
            shadow = 2
            
        if not fgColor:
            fgColor = self.buttonTextColor
            
        if not bgColor:
            bgColor = self.buttonUpB

        if not roColor:
            roColor = self.buttonRoA
            
        if status == 0:
            self.draw3DRect(rect, bgColor, 0)
        elif status == 1:
            self.draw3DRect(rect, roColor, 0)
        elif status == 2:
            self.draw3DRect(rect, roColor, 1)
            x += 1
            y += 1

        if not font:
            font=self.defaultFont

        size = getRenderer().getTextSize(title, font)
        
        if shadow:
            getRenderer().drawText( title, (x + (w-size[0])/2+shadow, y + (h-size[1])/2+shadow), self.fgColor, font)            
        getRenderer().drawText( title, (x + (w-size[0])/2, y + (h-size[1])/2), fgColor, font)
        return rect

    def drawLabel(self, rect, title, color = None, font = None, shadow=0, align=0 ):
        getRenderer().drawRect(self.fgColor, rect)
        getRenderer().drawRect(self.bgColor3, (rect[0]+2, rect[1]+2, rect[2]-4, rect[3]-4) )
        #(title, color) = options
        if not color:
            color = self.fgColor

        if not font:
            font = self.defaultFont
            
        (w,h) = getRenderer().getTextSize(title, font)
        if align == 2:
            posX = rect[0] + rect[2]/2 - w/2
        else:
            posX = rect[0]

        if shadow:
            getRenderer().drawText(title, (posX+shadow, rect[1]+shadow), pyui.colors.black, font)
        getRenderer().drawText(title, (posX, rect[1]), color, font)            
        return (rect[0], rect[1], w, h)

    def wrapLine(self, line, color):
        """Add a line of text to the display lines list with wrapping."""
        (words, spaces) = self.splitLine(line)

        displayLine = ""
        width = 0
        space = ""
        spaceWidth = 0
        while words:
            word = words.pop(0)
            wordWidth = getRenderer().getTextSize(word)[0]

            if width + spaceWidth + wordWidth <= self.textWidth:
                displayLine = displayLine + space + word
                width += spaceWidth + wordWidth
            else:
                self.addDisplayLine(displayLine, color)
                displayLine = word
                width = wordWidth
            space = spaces.pop(0)
            spaceWidth = getRenderer().getTextSize(space)[0]
                
        if displayLine:
            self.addDisplayLine(displayLine, color)

    def drawSliderBar(self, rect, range, position, BARWIDTH=8):
        interval = rect[2] / float(range)
        half = rect[1] + rect[3]/2
        getRenderer().drawRect(self.bgColor3, rect)
        ## could draw little lines here....
        getRenderer().drawLine( rect[0] + 1, half, rect[0] + rect[2] -2, half, pyui.colors.white)
        getRenderer().drawLine( rect[0] + 1, half + 2, rect[0] + rect[2] -2, half + 2, self.fgColor)
        diff = rect[2] - BARWIDTH
        xpos = float(diff) / range * position
        barHeight = rect[3] - 4
        if barHeight > 20:
            barHeight = 20
            
        self.draw3DRect((rect[0] + xpos, rect[1] + (rect[3]/2) - (barHeight/2), BARWIDTH, barHeight), self.bgColor2, 0)

        getRenderer().drawText("%s/%s" % (position,range), (rect[0] + rect[2] - 40, rect[1]), pyui.colors.red)
        return rect