GUI.py

"""
Classes to draw GUI elements on the screen like buttons, menus, textboxes etc.
"""

__version__ = "alpha"
__author__ = "Nard Janssens, Vinicius Silva, Robert Gowans, Ivan Antalec, Leonardo Marques - See Github PhotonFileUtils"

import math
import time

import pygame
from pygame.locals import *

import GUIhelpers
from GUIhelpers import *

# Common constants which make up the Theme of the GUI
defFontName="Verdana"   #Fontname None will take default system font
defFontSize=16#24
defFormBackground=(232,232,232)
defFormForeground=(0,0,0)
defMenuBackground=defFormBackground
defMenuForeground=(0,0,0)
defHighMenuForeground=(255,255,255)
defHighMenuBackground=(68,123,213)
defHighSelectForeground=defHighMenuForeground
defHighSelectBackground=defHighMenuBackground
defEditorBackground=(255,255,255)
defEditorForeground=(0,0,0)
defHighEditorBackground=(255,255,12*16)
defHighEditorForeground=(0,0,0)
defTitlebarBackground=(215,215,215)
#defButtonBackground=(68,123,213)
defButtonBackground=(205,205,205)
defBorder=(173,173,173)
defBorderHover=defHighMenuBackground


########################################################################################################################
## Class MenuBar
########################################################################################################################

class MenuBar():
    menus=[]
    margins = GRect(4, 4, 4, 4)
    height = -1
    spacing = 4
    minwidth=50
    isVisible=True
    textcolor=defMenuForeground
    backcolor=defMenuBackground
    highbackcolor=defHighMenuBackground
    highforecolor=defHighMenuForeground
    bordercolor = defBorder
    activeMenu=None

    def __init__(self, pyscreen,fontname=defFontName, fontsize=defFontSize):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.font = pygame.font.SysFont(fontname, fontsize)
        self.fontsize=fontsize #store to init menuitems
        self.fontname=fontname  #store to init menuitems

        # Enlarge menubar height if text does not fit
        height = self.font.get_linesize() * 0.5
        if (height + self.margins.y + self.margins.height) > self.height:
            self.height = height + self.margins.y + self.margins.height


    def addMenu(self, menutitle,shortcutChar):
        """ Adds new menu in the menubar (with empty menulist)."""

        # Determine left position of new menu
        prevIdx=len(self.menus)-1
        if prevIdx==-1:
            x=self.margins.x
        else:
            prevTitle = self.menus[prevIdx]["title"]
            prevLeft =self.menus[prevIdx]["left"]
            prevWidth = self.menus[prevIdx]["width"]#, height = self.font.size(prevTitle)
            #if prevWidth<self.minwidth: prevWidth=self.minwidth
            x= prevLeft+prevWidth#+ self.spacing
        scNr=0

        # Determine width of new menu
        width, height = self.font.size(menutitle)
        width=width+self.spacing
        if width<self.minwidth: width=self.minwidth+self.spacing

        # Get position of shortcutchar
        for idx,ch in enumerate(menutitle):
            if ch==shortcutChar:
                scNr=idx
        #print (scNr)

        # Make menulist
        loc=(x,self.height+self.margins.x+self.margins.height+1)
        menulist=MenuList(pyscreen=self.pyscreen,location=loc, fontname = self.fontname, fontsize = self.fontsize, title=menutitle)

        # Store (menu title, position, position of shortcutchar and menulist) in menudata
        menudata={"title":menutitle,"left":x,"width":width,"scChar":scNr, "menulist":menulist}
        self.menus.append(menudata)


    def addItem(self, menutitle, menuitem, func_on_click):
        """ Adds new item to menulist. """

        # Find menu in menus, retrieve menulist and add item
        for menu in self.menus:
            if menu["title"]==menutitle:
                menulist=menu["menulist"]
                menulist.addItem(menuitem,func_on_click)


    def redraw(self):
        """ Redraws MenuBar. """

        # If not visible, nothing to do
        if not self.isVisible: return

        # Draw menubar background and border.
        w, dummy = pygame.display.get_surface().get_size()
        h=self.height+self.margins.y+self.margins.height
        pygame.draw.rect(self.pyscreen, self.backcolor, (0,0,w,h), 0)
        pygame.draw.rect(self.pyscreen, self.bordercolor , (0, h, w, 1),1)

        for menudata in self.menus:
            menuleft = menudata["left"]
            menuwidth = menudata["width"]
            # Highlight current menu if mouse hovers and set textcolor depending if mouse hover or not.
            if menudata==self.activeMenu:
                #pygame.draw.rect(self.pyscreen, self.highbackcolor, (menuleft-self.spacing, 0,menuwidth, h), 0)
                pygame.draw.rect(self.pyscreen, self.highbackcolor, (menuleft, 0, menuwidth, h), 0)
                localtextcolor=defHighMenuForeground
            else:
                localtextcolor=defMenuForeground

            # Shortcut letter should be underlines, so we cut menu title in different parts for regular and underline
            scNr=menudata["scChar"]
            preStr=menudata["title"][:scNr]
            scStr=menudata["title"][scNr:scNr+1]
            postStr = menudata["title"][scNr + 1:]
            #print (scNr,preStr,scStr,postStr)
            wPre, dummy = self.font.size(preStr)
            wSc, dummy = self.font.size(scStr)
            wPost, dummy = self.font.size(postStr)

            # Draw text before shorcut Char
            self.font.set_underline(False)
            textsurface = self.font.render(preStr, True, localtextcolor)
            self.pyscreen.blit(textsurface, (menuleft+self.margins.x, self.margins.y))

            # Draw shorcut Char
            self.font.set_underline(True)
            textsurface = self.font.render(scStr,True, localtextcolor)
            self.pyscreen.blit(textsurface, (menuleft+self.margins.x +wPre, self.margins.y))

            # Draw text after shorcut Char
            self.font.set_underline(False)
            textsurface = self.font.render(postStr, True, localtextcolor)
            self.pyscreen.blit(textsurface, (menuleft+self.margins.x+wPre+wSc, self.margins.y))

            menudata["menulist"].redraw()


    def handleMouseDown(self, pos,button):
        """ Updates menu states if user clicked on menubar. """

        # If not clicked, nothing to do
        if not button == 1: return

        # Check if mouse clicked within menubar area
        if pos[1]<=(self.height+self.margins.y+self.margins.height):
            # We are handling this so clear queue for others
            pygame.event.clear()

            # If menu visible/active then hide menu, else show
            if self.activeMenu==None:
                for menu in self.menus:
                    if pos[0]>menu["left"] and pos[0]<(menu["left"]+menu["width"]):
                        self.activeMenu=menu
                        menulist=menu["menulist"]
                        menulist.isVisible=True
                    else:
                        menulist = menu["menulist"]
                        menulist.isVisible = False
                return True
            else:
                self.activeMenu["menulist"].isVisible=False
                self.activeMenu=None
                return

        # Call upon menulists to handle mouse (if above menulists). """
        for menu in self.menus:
            if menu["menulist"].handleMouseDown(pos,button): return True


    def handleMouseUp(self, pos,button):
        """ Updates menu states if user clicked on menubar. """
        if not button == 1: return
        # Call upon menulists to handle mouse (if above menulists). """
        for menu in self.menus:
            # If menulist accepts MouseUp we can close menulist and active item in menubar
            if menu["menulist"].handleMouseUp(pos,button):
                # We are handling this so clear queue for others
                pygame.event.clear()
                self.activeMenu["menulist"].isVisible = False
                self.activeMenu = None
                return True

        # If we are below menubar and nothing in menulists (not returned True) then user clicks on workarea of window to hide all menus
        if pos[1]>=(self.height+self.margins.y+self.margins.height):
            if self.activeMenu:
                # We are handling this so clear queue for others
                pygame.event.clear()
                self.activeMenu["menulist"].isVisible=False
                self.activeMenu=None


    def handleMouseMove(self, pos):
        """ Switch open menu if in menubar else call upon menulists to handle mouse (if above menulists). """
        # Move activemenu if mouse is moving within menubar area and menu is active
        if pos[1] <= (self.height + self.margins.y + self.margins.height):
            if not self.activeMenu == None:
                for menu in self.menus:
                    if pos[0] > menu["left"] and pos[0] < (menu["left"] + menu["width"]):
                        self.activeMenu = menu
                        menulist = menu["menulist"]
                        menulist.isVisible = True
                    else:
                        menulist = menu["menulist"]
                        menulist.isVisible = False
                # We are handling this so clear queue for others
                pygame.event.clear()
                return True

        # Let menulist check if mouse moved within their areas
        for menu in self.menus:
            if menu["menulist"].handleMouseMove(pos): return True


    def handleKeyDown(self,key,unicode):
        isAlt = (pygame.key.get_mods() & pygame.KMOD_ALT)
        if isAlt:
            for menu in self.menus:
                scNr=menu["scChar"]
                title=menu["title"]
                scChr=title[scNr]
                scNr=ord(scChr)-ord("A")
                keyNr=key-pygame.K_a
                if keyNr == scNr:
                    self.activeMenu=menu
                    menulist=menu["menulist"]
                    menulist.isVisible=True
                else:
                    menulist = menu["menulist"]
                    menulist.isVisible = False
                # We are handling this so clear queue for others
                pygame.event.clear()

    def openMenu(self,menutitle):
        """ Opens menu. """
        for idx,(title, shortcutChar, items, state) in enumerate(self.menus):
            if title == menutitle:
                self.menus[idx][3]= True
            else:
                self.menus[idx][3] = False


########################################################################################################################
## Class MenuList
########################################################################################################################

class MenuList():
    title=""
    pos=GRect(0, 0, 0, 0)
    items=[]
    margins=GRect(4, 4, 4, 4)
    rowheight=0
    spacing=4
    activeItem=-1
    isVisible=False
    textcolor = defMenuForeground
    backcolor = defMenuBackground
    highbackcolor = defHighMenuBackground
    highforecolor = defHighMenuForeground
    bordercolor = defBorder
    activeItem=-1


    def __init__(self, pyscreen, location, margins=GRect(6, 6, 6, 6), fontname=defFontName, fontsize=defFontSize, title="unknown"):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        l_x = location[0]
        l_y = location[1]-1
        self.margins=margins
        self.font = pygame.font.SysFont(fontname, fontsize)
        self.title=title
        self.items=[]

        # Enlarge width and height if text does not fit
        width, height = self.font.size("MinimalText")
        l_width = width + self.margins.x + self.margins.width
        l_height= 1*height++ self.margins.y + self.margins.height
        self.pos=GRect(l_x,l_y,l_width,l_height)
        self.rowheight = height


    def addItem(self,menuitem,func_on_click):
        """ Add menulist item and adjust menulist height and width (if needed) """
        #Add item
        itemdata = (menuitem,func_on_click)
        self.items.append(itemdata)

        # Adjust height and width only if needed
        width, height = self.font.size(menuitem)
        if (width+self.margins.x+self.margins.width) >self.pos.width: self.pos.width=width+self.margins.x+self.margins.width
        self.pos.height= len(self.items)*(self.rowheight+self.spacing)+ self.margins.y + self.margins.height-self.spacing # extract 1x spacing at the bottom


    def redraw(self):
        """ Redraws MenuList. """

        # If not visible nothing to do
        if not self.isVisible:
            self.activeItem=-1 # so on reopening we don have floating cursor
            return

        # Draw background and border
        pygame.draw.rect(self.pyscreen, self.backcolor, self.pos.tuple (), 0)
        pygame.draw.rect(self.pyscreen, self.bordercolor, (self.pos.tuple()), 1)

        # Draw item text
        for row,(text,func_on_click) in enumerate(self.items):
            rowtop=self.pos.y+self.margins.y+row*(self.rowheight+self.spacing)
            if row==self.activeItem:
                pygame.draw.rect(self.pyscreen, self.highbackcolor,(self.pos.x+self.margins.x, rowtop-int(self.spacing/2), self.pos.width-self.margins.x-self.margins.width, self.rowheight), 0)
                localtextcolor = defHighMenuForeground
            else:
                localtextcolor = defMenuForeground
            textsurface = self.font.render(text,True, localtextcolor)
            self.pyscreen.blit(textsurface, (self.pos.x+self.margins.x, rowtop))


    def handleMouseMove(self, pos):
        """ Highlights menulist item if mouse hover above."""
        if not self.isVisible: return

        if pos[0] > self.pos.x and pos[0] < (self.pos.x+self.pos.width) and \
            pos[1] < (self.pos.y + self.pos.height):
            rely=pos[1]-self.pos.y
            self.activeItem=int((rely-self.margins.y)/(self.rowheight+self.spacing))
            # We are handling this so clear queue for others
            pygame.event.clear()
            return True


    def handleMouseDown(self, pos,button):
        return

    def handleMouseUp(self, pos,button):
        """ Calls on user function if clicked on menu item."""
        if not button == 1: return
        if not self.isVisible: return
        gpos=GPoint.fromTuple(pos)
        if gpos.inGRect(self.pos):
            # We are handling this so clear queue for others
            pygame.event.clear()
            for row, (item, func_on_click) in enumerate(self.items):
                if row == self.activeItem:
                    if not func_on_click==None:
                        func_on_click()
                        self.isVisible=False
                        return True


########################################################################################################################
## Class ImgBox
########################################################################################################################

class ImgBox():
    rect=GRect()
    img=None
    hoverimg=None
    hoverActive=False
    action=None
    visible=True
    drawBorder=False
    resizeto=GPoint()

    #Tooltip vars
    toolTipLabel=None
    firstHoverTime = 0
    firstHoverPos=GPoint(0,0)

    def __init__(self, pyscreen, filename,filename_hover=None, pos=(0,0),bordercolor=defBorder,borderhovercolor=defBorderHover,drawBorder=False,
                 toolTip="",
                 resizeto=None,func_on_click=None):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.bordercolor = bordercolor
        self.borderhovercolor=borderhovercolor
        self.drawBorder=drawBorder
        self.func_on_click=func_on_click

        # Load image and resize to fit
        self.img=pygame.image.load(filename)
        if not filename_hover==None:
            self.hoverimg = pygame.image.load(filename_hover)

        # If user want other size we try to resize
        try:
            if not resizeto == None:
                self.img=pygame.transform.scale(self.img, resizeto)
                if not filename_hover==None:
                    self.hoverimg = pygame.transform.scale(self.hoverimg, resizeto)
        except Exception as err:
            print(err)

        # Determine size of control based on image size
        imgrect=self.img.get_rect()
        self.rect=GRect(imgrect[0],imgrect[1],imgrect[2],imgrect[3])
        self.rect.x=pos[0]
        self.rect.y=pos[1]

        #And setup tooltip
        # We need to figure out the correct width correct width of tooltip
        if not toolTip=="":
            self.toolTipLabel = Label(pyscreen, rect=GRect(self.rect.right, self.rect.height, 1024, 20),
                                      text=toolTip, drawBorder=True, borderwidth=1, backcolor=defHighEditorBackground,
                                      fontsize=defFontSize-2,
                                      textcolor=defHighEditorForeground, autowrap=True)
            max_width=0
            for line in toolTip.split("\n"):
                text_width, text_height = self.toolTipLabel.font.size(line)  # needed for self.autoheight
                if text_width>max_width: max_width=text_width
            self.toolTipLabel.rect.width=max_width+self.toolTipLabel.margin.x+self.toolTipLabel.margin.width
            self.toolTipLabel.visible=False


    def redraw(self):
        """ Redraws ImgBox. """

        # If not visible nothing to do.
        if not self.visible: return

        # Draw Image to screen
        self.pyscreen.blit(self.img,self.rect.tuple())

        # On hover draw hover image available
        if self.hoverActive and not self.hoverimg==None:
            self.pyscreen.blit(self.hoverimg, self.rect.tuple())
        else:
            self.pyscreen.blit(self.img, self.rect.tuple())

        # On hover drawborder if drawBorder is True
        if self.drawBorder:
            if self.hoverActive:
                pygame.draw.rect(self.pyscreen,self.borderhovercolor, self.rect.tuple(), 1)
            else:
                pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(), 1)

    def handleMouseMove(self, pos):
        """ Updates state of ImgBox on hover. """
        gpos=GPoint(pos[0],pos[1])
        if gpos.inGRect(self.rect):
            self.hoverActive=True
            # We are handling this so clear queue for others
            pygame.event.clear()
        else:
            self.hoverActive=False

    def handleMouseUp(self, pos,button):
        """ Calls on user function if clicked."""
        if not button==1: return
        gpos = GPoint(pos[0], pos[1])
        if gpos.inGRect(self.rect):
            # We are handling this so clear queue for others
            pygame.event.clear()
            if not self.func_on_click==None:
                self.func_on_click()

    def handleMouseDown(self,pos,button):
        return

    def handleKeyDown(self,key,unicode):
        return


    def handleToolTips(self,pos):
        """ Returns label control with tooltip if hovered long enough. """
        # if user did not set a tooltip nothing to do
        if self.toolTipLabel==None: return None

        #Check if mouse above control, if not exit
        gpos=GPoint.fromTuple(pos)
        if not gpos.inGRect(self.rect):
            self.firstHoverTime=0
            self.firstHoverPos=GPoint(0,0)
            self.toolTipLabel.visible = False
            return None

        #Check if first time hovering, if so set timer
        if self.firstHoverTime==0:
            self.firstHoverPos=gpos
            self.firstHoverTime=time.time()

        #Check if moved since hovering, if so reset counter and exit
        dif=self.firstHoverPos-gpos
        if math.sqrt(dif.x*dif.x+dif.y*dif.y)>5:
            self.firstHoverPos=GPoint(0,0)
            self.firstHoverTime=0
            self.toolTipLabel.visible = False
            return None

        #Check if hovered enough time and return tooltip
        timeHovered=time.time()-self.firstHoverTime
        if timeHovered>1.5 and not self.toolTipLabel.text=="" :
            self.toolTipLabel.visible=True
            self.toolTipLabel.rect.x = gpos.x
            self.toolTipLabel.rect.y = gpos.y
            #check if tooltip overflow right edge of pyscreen
            if self.toolTipLabel.rect.right>self.pyscreen.get_size()[0]:
                self.toolTipLabel.rect.x=gpos.x-self.toolTipLabel.rect.width
            return self.toolTipLabel


########################################################################################################################
## Class Button
########################################################################################################################

class Button():
    # We need 3 buttonstates so boolean var does not suffice
    normal=0
    hover=1
    down=2
    state= False

    rect=None
    img=None
    hoverimg=None
    downimg = None
    action=None
    borderwidth=1
    visible=True

    def __init__(self, pyscreen, rect=GRect(0,0,60,40),text="Button",  textcolor=(0,0,0),fontname=defFontName, fontsize=defFontSize, backcolor=defButtonBackground,filename=None,filename_hover=None,filename_down=None, bordercolor=defBorder, borderhovercolor=defBorderHover,func_on_click=None):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.text=text
        self.textcolor=textcolor
        self.font = pygame.font.SysFont(fontname, fontsize)
        text_width, text_height = self.font.size(text)
        self.twidth=text_width
        self.theight=text_height
        self.bordercolor = bordercolor
        self.borderhovercolor=borderhovercolor
        self.backcolor=backcolor
        self.func_on_click=func_on_click
        if func_on_click==None: print ("None")

        if not filename_hover==None:
            self.hoverimg = pygame.image.load(filename_hover)
        if not filename_down==None:
            self.downimg = pygame.image.load(filename_down)

        # If button is image than dimensions are determined by image size
        if not filename == None:
            self.img = pygame.image.load(filename)
            imgrect = self.img.get_rect()
            self.rect=GRect(rect.x,rect.y,imgrect[2],imgrect[3])
        # Otherwise we listen to the dimensions the user gave us
        else:
            self.rect=rect


    def redraw(self):
        """ Redraws Button. """

        # If not visible nothing to do.
        if not self.visible: return

        # Draw image (if available) corresponding to button state
        if self.state==self.hover and not self.hoverimg==None:
            self.pyscreen.blit(self.hoverimg, self.rect.tuple())
        elif self.state==self.down and not self.downimg==None:
            self.pyscreen.blit(self.downimg, self.rect.tuple())
        elif not self.img==None:
            if self.state==self.down:#shift image if down
                self.pyscreen.blit(self.img, (self.rect.x + self.borderwidth, self.rect.y + self.borderwidth))
            else:
                self.pyscreen.blit(self.img, self.rect.tuple())
        else:
            pygame.draw.rect(self.pyscreen, self.backcolor,self.rect.tuple(), 0)

        # Draw border (if available) corresponding to button state
        if self.borderwidth>0:
            if self.borderwidth == 1:
                if self.state==self.down or self.state==self.hover:
                    pygame.draw.rect(self.pyscreen, self.borderhovercolor, self.rect.tuple(), 1)
                else:
                    pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(), 1)
            else:#make 3d border
                if self.state==self.down:
                    topleftcolor=(64,64,64)
                    bottomrightcolor=(192,192,192)
                else:
                    topleftcolor = (192, 192, 192)
                    bottomrightcolor = (64, 64, 64)
                for inset in range (0,self.borderwidth):
                    #top and left border
                    pygame.draw.rect(self.pyscreen, topleftcolor, (self.rect.x,self.rect.y+inset,self.rect.width-inset,1), 1)
                    pygame.draw.rect(self.pyscreen, topleftcolor, (self.rect.x+inset, self.rect.y, 1, self.rect.height-inset), 1)
                    #bottom en right border
                    pygame.draw.rect(self.pyscreen, bottomrightcolor, (self.rect.x+inset,self.rect.y+self.rect.height-inset,self.rect.width-inset,1), 1)
                    pygame.draw.rect(self.pyscreen, bottomrightcolor, (self.rect.x+self.rect.width-inset, self.rect.y+inset, 1, self.rect.height-inset), 1)

        # Draw text (if available) and shift text if down
        if not self.text=="":
            textsurface = self.font.render(self.text, True,self.textcolor)
            dx=int(self.rect.width-self.twidth)/2
            dy=int(self.rect.height-self.theight)/2
            if self.state == self.down:  # shift text if down
                dx=dx+self.borderwidth
                dy=dy+self.borderwidth
            self.pyscreen.blit(textsurface, (self.rect.x + dx, self.rect.y+dy))

    def handleMouseMove(self, pos):
        """ Updates state of Button on hover. """
        gpos=GPoint(pos[0],pos[1])
        if gpos.inGRect(self.rect):
            self.state=self.hover
            # We are handling this so clear queue for others
            pygame.event.clear()
        else:
            self.state=self.normal
        #print (self.state)

    def handleMouseUp(self, pos,button):
        """ Calls on user function if clicked."""
        if not button == 1: return
        gpos=GPoint(pos[0],pos[1])
        if gpos.inGRect(self.rect):
            self.state=self.normal
            # We are handling this so clear queue for others
            pygame.event.clear()
            if not self.func_on_click==None:
                self.func_on_click()

    def handleMouseDown(self,pos,button):
        """ Updates state of Button on down. """
        if not button == 1: return
        gpos=GPoint(pos[0],pos[1])
        if gpos.inGRect(self.rect):
            # We are handling this so clear queue for others
            pygame.event.clear()
            self.state=self.down

    def handleKeyDown(self,key,unicode):
        return


########################################################################################################################
## Class ScrollBarV
########################################################################################################################

class ScrollBarV():
    # We need 3 buttonstates so boolean var does not suffice
    normal=0
    hover=1
    down=2
    state= False

    rect = None
    action = None
    borderwidth = 1
    visible = True

    #todo: replace forecolor with def constant
    def __init__(self, pyscreen, rect=GRect(0, 0, 60, 40), forecolor=(0,0,0), sfontsize=defFontSize, sbackcolor=defButtonBackground, sbordercolor=defBorder, sborderhovercolor=defBorderHover, func_on_click=None,minScroll=0, maxScroll=128,curScroll=0,smallScroll=1, largeScroll=8):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.rect=rect
        self.bordercolor = sbordercolor
        self.borderhovercolor = sborderhovercolor
        self.backcolor = sbackcolor
        self.forecolor=forecolor
        self.func_on_click = func_on_click
        self.minScroll=minScroll
        self.maxScroll=maxScroll
        self.curScroll = curScroll
        self.smallScroll=smallScroll
        self.largeScroll=largeScroll

        # Add up and down button
        self.btnUp = Button(pyscreen, text="^", bordercolor=sbordercolor, borderhovercolor=sborderhovercolor,
                            textcolor=forecolor, func_on_click=self.scrollUp)
        self.btnDown = Button(pyscreen, text="v", bordercolor=sbordercolor, borderhovercolor=sborderhovercolor,
                              textcolor=forecolor, func_on_click=self.scrollDown)


    def scrollDown(self,isLargeScroll=False):
        """ Decreases current scroll value. """

        # Check if we have to take a small step or a large step
        if not isLargeScroll:
            self.curScroll=self.curScroll+self.smallScroll
        else:
            self.curScroll = self.curScroll + self.largeScroll
        if self.curScroll>self.maxScroll: self.curScroll=self.maxScroll

        # Send curScroll to parent
        if not self.func_on_click ==None: self.func_on_click(self.curScroll)
        #print("scroll Up: ",self.curScroll)


    def scrollUp(self,isLargeScroll=False):
        """ Inreases current scroll value. """

        # Check if we have to take a small step or a large step
        if not isLargeScroll:
            self.curScroll = self.curScroll - self.smallScroll
        else:
            self.curScroll=self.curScroll - self.largeScroll
        if self.curScroll < self.minScroll: self.curScroll = self.minScroll

        # Send curScroll to parent
        if not self.func_on_click==None: self.func_on_click(self.curScroll)
        #print("scroll Down: ", self.curScroll, isLargeScroll, self.smallScroll)


    def redraw(self):
        """ Redraws ScrollBarV. """

        # If not visible nothing to do.
        if not self.visible: return

        # Position up and down buttons
        self.btnUp.rect= GRect(self.rect.x, self.rect.y, self.rect.width, self.rect.width)
        self.btnDown.rect = GRect(self.rect.x, self.rect.y + self.rect.height - self.rect.width, self.rect.width, self.rect.width)

        # Draw background
        pygame.draw.rect(self.pyscreen, self.backcolor, self.rect.tuple(), 0)

        # Determine scroll area between up and down buttons
        innerRect=self.rect.copy()
        innerRect.y=self.rect.y+self.btnUp.rect.height
        innerRect.height=self.rect.height-self.btnUp.rect.height-self.btnDown.rect.height

        # Determine at what percentage of this area we clicked
        indYrel=(self.curScroll-self.minScroll)/(self.maxScroll-self.minScroll)
        #indY=innerRect.bottom-indYrel*innerRect.height
        indY=innerRect.top+indYrel*innerRect.height

        # Draw indicator at the height we clicked.
        indRect=self.rect.copy()
        indRect.y=indY-1
        indRect.height=3
        pygame.draw.rect(self.pyscreen, self.forecolor, indRect.tuple(), 0)

        # Draw border depending on state of ScrollbarV.
        if self.borderwidth == 1:
            if self.state == self.down or self.state == self.hover:
                pygame.draw.rect(self.pyscreen, self.borderhovercolor, self.rect.tuple(), 1)
            else:
                pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(), 1)

        # Call upon up and down buttons to redraw themselves
        self.btnDown.redraw()
        self.btnUp.redraw()


    def handleMouseMove(self, pos):
        """ Updates state of Scroll Area and Up and Down buttons on hover. """
        gpos=GPoint(pos[0],pos[1])
        if gpos.inGRect(self.rect):
            # We are handling this so clear queue for others
            pygame.event.clear()
            self.state=self.hover
        else:
            self.state=self.normal

        # Call upon buttons to check if MouseMove (hover) above them
        self.btnUp.handleMouseMove(pos)
        self.btnDown.handleMouseMove(pos)

    def handleMouseUp(self, pos,button):
        """ Transmits MouseUp to up and down button. """

        #If not left mousebutton then nothing to do
        if not button == 1: return

        # Call upon buttons to check for MouseUp above them
        self.btnUp.handleMouseUp(pos,button)
        self.btnDown.handleMouseUp(pos, button)

    def handleMouseDown(self,pos,button):
        """ Updates state of Scroll Area and Up and Down buttons on mousedown. """

        #If not left mousebutton then nothing to do
        if not button == 1: return

        #Check if in rect
        gpos=GPoint(pos[0],pos[1])
        if not gpos.inGRect(self.rect): return

        # We are handling this so clear queue for others
        pygame.event.clear()

        # Set state if clicked within area
        self.state=self.down

        # Determine scroll area between up and down buttons
        innerRect = self.rect.copy()
        innerRect.y = self.rect.y + self.btnUp.rect.height
        innerRect.height = self.rect.height - self.btnUp.rect.height - self.btnDown.rect.height

        # Check if mouseclick inside scroll area
        if gpos.inGRect(innerRect):
            # Determine at what screen position the scroll indicator is.
            indYrel = (self.curScroll - self.minScroll) / (self.maxScroll - self.minScroll)
            indY = innerRect.top + indYrel * innerRect.height
            # If clicked above indicator we scroll up and vice versa
            if gpos.y > indY: self.scrollDown(True)
            if gpos.y < indY: self.scrollUp(True)

        # Call upon buttons to check for MouseDown above them
        self.btnUp.handleMouseDown(pos, button)
        self.btnDown.handleMouseDown(pos, button)

    def handleKeyDown(self,key,unicode):
        return


########################################################################################################################
## Class ListBox
########################################################################################################################

class ListBox():
    items=[]
    rect = GRect(0, 0, 80, 32)
    margins = GRect(4, 4, 4, 4)
    bordercolor = (128, 128, 128)
    backcolor = defEditorBackground
    textcolor = defEditorForeground
    highbackcolor = defHighSelectBackground
    hightextcolor = defHighSelectForeground
    font=None
    fontname = "Consolas"
    fontsize = 16
    activeItem=-1
    rowheight=0
    spacing=4
    offset=0
    visible=True

    def __init__(self, pyscreen, rect=GRect(100, 40, 80, 80), items=None,fontname=defFontName, fontsize=defFontSize,func_on_click=None):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.rect=rect
        self.items=items
        self.font = pygame.font.SysFont(fontname, fontsize)
        text_width, text_height = self.font.size("M[].j")
        self.rowheight=text_height
        self.items=items
        if not func_on_click==None: self.func_on_click=func_on_click

        # Resize ListBox so the height is a full number of rows
        self.nritems = int(self.rect.height / (self.rowheight + self.spacing))
        self.rect.height=self.nritems*(self.rowheight + self.spacing)

        # Add scrollbar
        self.scrollbarV=ScrollBarV(pyscreen,func_on_click=self.scrollItems)


    def setItems(self, items):
        """ Update items in ListBox """
        self.items=items
        self.offset=0
        self.activeItem=-1


    def items(self):
        """ Return items in ListBox """
        return self.items


    def scrollItems(self,curScroll):
        """ Sets first listitem to show ListBox to curScroll"""
        self.offset=curScroll


    def redraw(self):
        """ Redraws ListBox. """

        # If not visible nothing to do.
        if not self.visible: return

        # Draw background and border
        pygame.draw.rect(self.pyscreen, self.backcolor, self.rect.tuple(), 0)
        pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(),1)

        # If no items to display nothing to do.
        if self.items==None: return

        #set Scrollbar so if listbox is moved or listitems are added/removed, the scrollbar is still correct.

        # Resize ListBox so the height is a full number of rows
        self.nritems = int(self.rect.height / (self.rowheight + self.spacing))
        self.rect.height = self.nritems * (self.rowheight + self.spacing)

        # Draw all items beginning with with offset determined by curScroll of scrollbarV
        for row in range(0,self.nritems):
            idx=row+self.offset
            if idx<len(self.items):
                item=self.items[idx]
                rowtop = self.rect.y + self.margins.y + row * (self.rowheight + self.spacing)
                if idx==self.activeItem:
                    pygame.draw.rect(self.pyscreen, self.highbackcolor,(self.rect.x+self.margins.x, rowtop-int(self.spacing/2), self.rect.width-self.margins.x-self.margins.width, self.rowheight), 0)
                    textsurface = self.font.render(item, True, self.hightextcolor)
                else:
                    textsurface = self.font.render(item, True, self.textcolor)
                self.pyscreen.blit(textsurface, (self.rect.x + self.margins.x, self.rect.y + self.margins.y+row*(self.rowheight+self.spacing)),(0,0,self.rect.width,self.rowheight+self.spacing))

        # Position scrollbar and call upon scrollbarV to redraw itself
        scrollRect = self.rect.copy()
        scrollRect.width = self.fontsize
        scrollRect.x = self.rect.right - scrollRect.width
        self.scrollbarV.rect=scrollRect
        self.scrollbarV.maxScroll = len(self.items)-self.nritems
        self.scrollbarV.largeScroll = self.nritems
        self.scrollbarV.visible = True if (len(self.items) > self.nritems) else False
        self.scrollbarV.redraw()


    def activeText(self):
        """ Returns the selected item in ListBox. """
        try:
            return self.items[self.activeItem]
        except:
            print ("Error from ListBox.activeText()")
            return ""


    def handleMouseDown(self,pos,button):
        """ Handles scroll with mousewheel and mousedown on item in ListBox. """

        # Check if we clicked inside the area where the items are displayed
        gpos=GPoint.fromTuple(pos)
        innerRect=self.rect.copy()
        if self.scrollbarV.visible: innerRect.width=innerRect.width-self.scrollbarV.rect.width
        if gpos.inGRect(innerRect):
            # Mousedown on item, store it in activeItem
            if button == 1:
                rely=pos[1]-self.rect.y
                self.activeItem=self.offset+ int((rely-self.margins.y)/(self.rowheight+self.spacing))
                #print ("down on: ", self.activeItem,self.activeText())
            # Mousewheel UP, so scroll up by setting offset (first item to be displayed)
            if button==4: # mousewheel up
                self.offset=self.offset-1
                if self.offset<0: self.offset=0
                self.scrollbarV.curScroll = self.offset # Tell scrollBarV our new position.
            # Mousewheel Down, so scroll down by setting offset (first item to be displayed)
            if button==5:
                self.offset = self.offset + 1
                if self.offset>(len(self.items)-self.nritems): self.offset=len(self.items)-self.nritems
                self.scrollbarV.curScroll = self.offset # Tell scrollBarV our new position.
            # We are handling this so clear queue for others
            pygame.event.clear()
        # Else ask to check if clicked on scrollbarV
        else:
            self.scrollbarV.handleMouseDown(pos,button)


    def handleMouseUp(self,pos,button):
        """ Calls on user function if clicked."""

        # Check if we clicked with left mouse button
        if not button == 1: return

        # Check if we clicked inside the area where the items are displayed
        gpos=GPoint.fromTuple(pos)
        innerRect=self.rect.copy()
        if self.scrollbarV.visible: innerRect.width=innerRect.width-self.scrollbarV.rect.width
        if gpos.inGRect(innerRect):
            # We are handling this so clear queue for others
            pygame.event.clear()
            if not self.func_on_click==None: self.func_on_click(self.activeText())
        else:
            # Else ask to check if clicked on scrollbarV
            self.scrollbarV.handleMouseUp(pos,button)

    def handleMouseMove(self,pos):
        """ Calls upon scrollbarV to handle MouseMove if needed """
        self.scrollbarV.handleMouseMove(pos)
        return

    def handleKeyDown(self,key,unicode):
        return


########################################################################################################################
## Class Combobox
########################################################################################################################

class Combobox():
    items=[]
    rect = GRect(0, 0, 80, 32)
    margins = GRect(4, 4, 4, 4)
    font=None
    fontname = "Consolas"
    fontsize = 16
    activeItem=-1
    rowheight=0
    spacing=4
    offset=0
    visible=True
    text="" #stores text if clicked
    func_on_click=None

    def __init__(self, pyscreen, rect=GRect(100, 40, 80, 80), items=None,defitemnr=0,fontname=defFontName, fontsize=defFontSize,func_on_click=None):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.rect=rect
        self.items=items
        self.font = pygame.font.SysFont(fontname, fontsize)
        text_width, text_height = self.font.size("M[].j")
        self.rowheight=text_height
        self.items=items
        if not func_on_click==None: self.func_on_click=func_on_click

        #Combobox is made up of Label, Button to show Listbox and Listbox itself
        fname=fontname
        fsize=fontsize

        # Calc positions
        labelRect=GRect(rect.left,rect.top,rect.width-rect.height,rect.height)
        buttonRect=GRect(rect.right-rect.height,rect.top,rect.height,rect.height)
        listboxRect=GRect(rect.left,rect.bottom,rect.width,120)
        # Add Label
        defitem=items[defitemnr]
        self.label=Label(pyscreen,rect=labelRect,text=defitem,fontname=fname,fontsize=fsize,autowrap=False)
        self.label.backcolor=defEditorBackground
        self.label.textcolor=defEditorForeground
        self.label.bordercolor=defBorder
        self.label.borderwidt=1
        self.label.drawBorder=True
        labelRect=self.label.rect
        # Label will resize itself in height
        self.label.rect.width=rect.width-self.label.rect.height
        buttonRect.height=self.label.rect.height
        buttonRect.left=self.label.rect.right
        buttonRect.width=self.label.rect.height
        listboxRect.top=labelRect.bottom
        # Add Button
        self.button=Button(pyscreen,rect=buttonRect,text="V",fontname=fname,fontsize=fsize,func_on_click=self.buttonClick)
        # Add Listbox
        self.listbox=ListBox(pyscreen,rect=listboxRect,items=items,fontname=fname,fontsize=fsize,func_on_click=self.listClick)

        # Initially combobox is not expanded / listbox is not visible
        self.listbox.visible=False

    """ 
    def reposControls(self): #called after winrect is moved
        # Recalculates all positions after moving dialog box. 
        rect=self.rect
        #buttons is as wide as height
        labelRect=GRect(rect.left,rect.top,rect.width-rect.height,rect.height)
        buttonRect=GRect(rect.right-rect.height,rect.top,rect.height,rect.height)
        listboxRect=GRect(rect.left,rect.bottom,rect.width,40)
        self.button.rect=buttonRect
        self.label.rect=labelRect
        #todo: listbox below label, but this should depend on room
        self.listbox.rect=listboxRect
    """

    def redraw(self):
        self.label.redraw()
        self.button.redraw()
        self.listbox.redraw()


    def listClick(self,clickedtext):
        print (clickedtext,self.listbox.activeText())
        self.label.setText(clickedtext)
        self.listbox.visible=False
        self.text=clickedtext
        if not self.func_on_click==None: self.func_on_click(clickedtext)

    def buttonClick(self):
        self.listbox.visible= not self.listbox.visible


    def handleMouseUp(self,pos,button):
        """ Passes event to children. """
        if not self.visible: return
        # Pass event to children
        self.listbox.handleMouseUp(pos,button)
        self.button.handleMouseUp(pos,button)
        self.label.handleMouseUp(pos,button)


    def handleMouseDown(self,pos,button):
        """ Passes event to children. """
        if not self.visible: return
        # Pass event to children
        self.listbox.handleMouseDown(pos,button)
        self.button.handleMouseDown(pos,button)
        self.label.handleMouseDown(pos,button)


    def handleMouseMove(self,pos):
        """ Passes event to children. """
        if not self.visible: return
        # Pass event to children
        self.listbox.handleMouseMove(pos)
        self.button.handleMouseMove(pos)
        self.label.handleMouseMove(pos)

    def handleKeyDown(self,key,unicode):
        """ Passes event to children. """
        if not self.visible: return
        # Pass event to children
        self.listbox.handleKeyDown(key,unicode)
        self.button.handleKeyDown(key,unicode)
        self.label.handleKeyDown(key,unicode)

########################################################################################################################
## Class Label
########################################################################################################################

class Label():
    rect=GRect(0, 0, 80, 32)
    margin = GRect(4, 4, 4, 4)
    innerRect=GRect()
    bordercolor = (128, 128, 128)
    backcolor = defFormBackground
    textcolor = defFormForeground
    borderwidth = 1
    autoheight=True
    text = ["text"]
    font=None
    fontname = "Consolas"
    fontsize = 16
    drawBorder=False
    visible=True
    center=False
    autowrap=False
    istransparent=False


    def __init__(self, pyscreen, rect=GRect(0, 0, 80, 32), margin=GRect(4, 4, 4, 4),
                 bordercolor=defBorder, backcolor=defFormBackground, textcolor=defFormForeground,
                 borderwidth=1, drawBorder=False,center=False,istransparent=False,
                 text="text", fontname=defFontName, fontsize=defFontSize, autoheight=True, autowrap=False):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.rect = rect
        self.margin=margin
        self.center=center
        self.bordercolor=bordercolor
        self.backcolor=backcolor
        self.istransparent=istransparent
        self.textcolor=textcolor
        self.borderwidth=borderwidth
        self.autoheight=autoheight
        self.autowrap = autowrap
        self.font = pygame.font.SysFont(fontname, fontsize)
        self.setText(text)
        self.drawBorder=drawBorder

        # Make innerRect (available room for text itself) accounting for margins
        self.innerRect=rect.copy()
        self.innerRect.shrink(self.margin)


    def setText(self,text):
        """ Wraps received text if needed (autowrap=True. """

        # We want to make sure the text fully fits in the TextBox
        self.innerRect = self.rect.copy()
        self.innerRect.shrink(self.margin)

        if self.autowrap:
            # Split sentences on boundaries user inserted a.k.a. newline code '\n\
            lines=text.split("\n")
            # Make room for all the sentences
            newlines=[]
            # For each sentences check if it fits in text area width (innerRect.width)
            for line in lines:
                newline=""
                words=line.split(" ")
                # print ("["+line+"]")
                lastIdx=len(words)-1
                # print("------")
                # Add word for word until it overflows innerRect.width
                for idx,word in enumerate(words):
                    oldline=newline
                    newline=newline+word+" "
                    # Determine width of sentence with new word
                    text_width, text_height = self.font.size(newline)
                    # On overflow, we save current build sentence (oldLine) and begin a new sentence with current word (newLine)
                    if text_width>self.innerRect.width:
                        #todo: check for words which are longer than width, in which case oldline is empty
                        text_width > self.innerRect.width
                        newlines.append(oldline.strip())
                        newline = word + " "
                        # print("|"+ oldline.strip()+ "|")
                # Add newline to newlines array
                newlines.append(newline.strip())
            #print("|" + newline.strip() + "|")
            #print("------")
            #print ("Total result:")
            #print (newlines)
            self.text=newlines
        else:
            #If user doesn't want autowrap we just store his/her new text
            newlines = [text]
            self.text = newlines
            text_width, text_height = self.font.size(text) #needed for self.autoheight

        # If autoheight is set, we recalculate height of label depending on line height and number of sentences
        if self.autoheight:
            self.rect.height=len(self.text)*text_height+self.margin.y+self.margin.height


    def redraw(self):
        """ Redraws Label. """

        # If not visible nothing to do.
        if not self.visible: return

        # Determine area the text can be drawn accounting for margins
        self.innerRect=self.rect.copy()
        self.innerRect.shrink(self.margin)

        # If label is not transparent then we draw background
        if not self.istransparent:
            pygame.draw.rect(self.pyscreen, self.backcolor, self.rect.tuple(), 0)
            if self.drawBorder: pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(), self.borderwidth)

        # If user want vertical center we determine the offset (dY) the text should be drawn in the label area
        dummy, lineHeight = self.font.size(self.text[0])
        if self.center:
            dY=int((self.innerRect.height-len(self.text)*lineHeight)/2)
        else: dY=0

        # Draw line by line and center if use set this to True
        for row,line in enumerate(self.text):
            if len(line)>255: line=line[0:255] # really a debug statement
            textsurface = self.font.render(line, True, self.textcolor)
            lineWidth, dummy= self.font.size(line)
            if self.center:
                dX = int((self.innerRect.width - lineWidth)/ 2)
            else: dX=0
            self.pyscreen.blit(textsurface, (self.innerRect.x+dX, self.innerRect.y + dY+row*lineHeight))

    def handleMouseMove(self, pos):
        return
    def handleMouseUp(self, pos,button):
        return
    def handleMouseDown(self,pos,button):
        return
    def handleKeyDown(self,key,unicode):
        return


########################################################################################################################
## Class TextBox
########################################################################################################################

class TextBox():
    rect=GRect(0, 0, 80, 32)
    margin = GRect(4, 4, 4, 4)
    bordercolor = defBorder
    backcolor = defEditorBackground
    textcolor = defEditorForeground
    borderwidth = 1
    text = "text"
    maxlength=10
    font=None
    fontname = defFontName
    fontsize = defFontSize
    editable=True
    cursorActive=False
    cursorChar=0
    drawBorder=True
    visible=True
    allSelected=False

    #Tooltip vars
    toolTipLabel=None
    firstHoverTime = 0
    firstHoverPos=GPoint(0,0)

    # We need constants which dictate what the allowes userinput is
    TEXT = 0
    INT=1
    FLOAT=2
    HEX=3
    inputType=TEXT

    def __init__(self, pyscreen, rect=GRect(0, 0, 80, 32), margin=GRect(4, 4, 4, 4),
                 bordercolor=defBorder, backcolor=defEditorBackground, textcolor=defEditorForeground,
                 borderwidth=1, drawBorder=True,
                 text="text", maxlength=-1, fontname=defFontName, fontsize=defFontSize, editable=True,
                 inputType=TEXT,
                 toolTip="",
                 onEnter=None, linkedData=None):
        """ Saves all values to internal variables. """
        self.pyscreen = pyscreen
        self.rect = rect
        self.margin=margin
        self.bordercolor=bordercolor
        self.backcolor=backcolor
        self.textcolor=textcolor
        self.borderwidth=borderwidth
        self.text = text
        if not maxlength==-1:
            self.maxlength = maxlength
        else:
            self.maxlength = 99
        self.font = pygame.font.SysFont(fontname, fontsize)
        self.editable=editable
        self.inputType=inputType
        self.drawBorder=drawBorder
        self.onEnter=onEnter
        self.linkedData=linkedData

        # We truncate text if larger than allowed maximum length given by user
        if len(self.text)>self.maxlength: self.text=self.text[0:self.maxlength]

        #And that the textbox has enough height to show each letter
        text_width, text_height = self.font.size("M[].j")
        if self.rect.height<(text_height+2*self.margin.y): self.rect.height=text_height+2*self.margin.y

        #And setup tooltip
        # We need to figure out the correct width correct width of tooltip
        if not toolTip=="":
            self.toolTipLabel = Label(pyscreen, rect=GRect(self.rect.right, self.rect.height, 1024, 20),
                                      text=toolTip, drawBorder=True, borderwidth=1, backcolor=defHighEditorBackground,
                                      fontsize=defFontSize - 2,
                                      textcolor=defHighEditorForeground, autowrap=True)
            max_width=0
            for line in toolTip.split("\n"):
                text_width, text_height = self.toolTipLabel.font.size(line)  # needed for self.autoheight
                if text_width>max_width: max_width=text_width
            self.toolTipLabel.rect.width=max_width+self.toolTipLabel.margin.x+self.toolTipLabel.margin.width
            self.toolTipLabel.visible=False


    def setText(self,text):
        """ Truncates text if larger than allowed maximum length given by user. """
        self.text = text
        if len(self.text)>self.maxlength: self.text=self.text[0:self.maxlength]


    def redraw(self):
        """ Redraws TextBox. """

        # If not visible nothing to do.
        if not self.visible: return

        # Draw background and border if needed
        pygame.draw.rect(self.pyscreen, self.backcolor, self.rect.tuple(), 0)
        if self.drawBorder: pygame.draw.rect(self.pyscreen, self.bordercolor, self.rect.tuple(), self.borderwidth)

        # Draw text
        # If all selected we need to draw with hightlighted background
        if self.allSelected:
            textsurface = self.font.render(self.text, True, defHighEditorForeground)
            hrect=GRect(self.rect.x + self.margin.x-1, self.rect.y + self.margin.y, textsurface.get_rect()[2]+1,textsurface.get_rect()[3])
            if self.rect.x+self.margin.x+hrect.width>self.rect.right-1:
                hrect.width=hrect.width-(self.rect.x+self.margin.x+hrect.width-self.rect.right)-1
            pygame.draw.rect(self.pyscreen, defHighEditorBackground, hrect.tuple(), 0)
        # Else with normal background
        else:
            textsurface = self.font.render(self.text, True, self.textcolor)
        # And the text
        self.pyscreen.blit(textsurface, (self.rect.x + self.margin.x, self.rect.y + self.margin.y),(0,0,self.rect.width-2*self.margin.x,self.rect.height-2*self.margin.y))

        # If editing also draw the cursor
        if self.cursorActive:
            text_width, text_height = self.font.size(self.text[0:self.cursorChar])
            if self.rect.x+self.margin.x+text_width<self.rect.x+self.rect.width: # we don't want to put cursor outside box
                pygame.draw.rect(self.pyscreen,
                                 self.textcolor,
                                 (self.rect.x+self.margin.x+text_width,self.rect.y+self.margin.y,2,self.rect.height-2*self.margin.y-1),
                                 0)

    prevClick=0
    def handleMouseUp(self,pos,button):
        """ Set cursor / edit of TextBox """

        # If not left button nothing to do
        if not button == 1: return

        # If not left button nothing to do
        if not self.editable: return

        # Check if clicked within textbox
        gpos=GPoint.fromTuple(pos)
        if gpos.inGRect(self.rect):
            # Register if we doubleclick and if so set allSelected to True (we want to select all the text)
            if (time.time()-self.prevClick)<0.3:
                #print ("Double click")
                self.allSelected=True
            else:
                self.allSelected=False
                #print("Single click")
                self.prevClick = time.time()

            # We are handling this so clear queue for others
            pygame.event.clear()

            # Set cursorActive for redraw and handleKeydown
            self.cursorActive=True

            # determine where we need to put cursor by iterating over each char
            relx=pos[0]-self.rect.x
            rely = pos[1] - self.rect.y
            self.cursorChar=0
            for i in range(0,len(self.text)):
                text_width, text_height = self.font.size(self.text[0:i])
                if relx>(text_width+self.margin.x):
                    self.cursorChar=self.cursorChar+1
        else:
            self.cursorActive = False
            self.allSelected=False


    def handleMouseDown(self,pos,button):
        return


    def handleMouseMove(self,pos):
        return


    def handleToolTips(self,pos):
        """ Returns label control with tooltip if hovered long enough. """
        # if user did not set a tooltip nothing to do
        if self.toolTipLabel==None: return None

        #Check if mouse above control, if not exit
        gpos=GPoint.fromTuple(pos)
        if not gpos.inGRect(self.rect):
            self.firstHoverTime=0
            self.firstHoverPos=GPoint(0,0)
            self.toolTipLabel.visible = False
            return None

        #Check if first time hovering, if so set timer
        if self.firstHoverTime==0:
            self.firstHoverPos=gpos
            self.firstHoverTime=time.time()

        #Check if moved since hovering, if so reset counter and exit
        dif=self.firstHoverPos-gpos
        if math.sqrt(dif.x*dif.x+dif.y*dif.y)>5:
            self.firstHoverPos=GPoint(0,0)
            self.firstHoverTime=0
            self.toolTipLabel.visible = False
            return None

        #Check if hovered enough time and return tooltip
        timeHovered=time.time()-self.firstHoverTime
        if timeHovered>1.5 and not self.toolTipLabel.text=="" :
            self.toolTipLabel.visible=True
            self.toolTipLabel.rect.x = gpos.x
            self.toolTipLabel.rect.y = gpos.y
            #check if tooltip overflow right edge of pyscreen
            if self.toolTipLabel.rect.right>self.pyscreen.get_size()[0]:
                self.toolTipLabel.rect.x=gpos.x-self.toolTipLabel.rect.width
            return self.toolTipLabel


    def handleKeyDown(self,key,unicode):
        """ Handles keypresses and determine which keys are valid for TextBox input type """

        # If not editable nothing to do
        if not self.editable: return

        # Check if textbox was clicked and in editmode
        if self.cursorActive:
            # We are handling this so clear queue for others
            pygame.event.clear()
            # If all is selected each key will clear textbox
            if self.allSelected:
                self.text = ""
                self.allSelected = False
            # Process navigation (left,right) and modify (del, backspace) keys
            if key == K_BACKSPACE:
                if self.cursorChar == 0: return
                self.text = self.text[0:self.cursorChar - 1] + self.text[self.cursorChar:]
                self.cursorChar = self.cursorChar - 1
                if self.cursorChar < 0: self.cursorChar = 0
                return
            if key == K_DELETE:
                if self.cursorChar==len(self.text): return
                self.text = self.text[0:self.cursorChar] + self.text[self.cursorChar + 1:]
                return
            if key == K_LEFT:
                self.cursorChar = self.cursorChar - 1
                if self.cursorChar < 0: self.cursorChar = 0
                return
            if key == K_RIGHT:
                self.cursorChar = self.cursorChar + 1
                if self.cursorChar > len(self.text): self.cursorChar = len(self.text)
                return

            # On enter/return call use function with current text and the (unmodified) metadata we received when initialized
            if key == K_KP_ENTER or key == K_RETURN:
                if not self.onEnter == None: self.onEnter(self, self.text,self.linkedData)
                return# we don't want to add return char (chr 13) to text string

            # Remap keys of numpad to numerical keys
            isNumlockOn=(pygame.key.get_mods() & pygame.KMOD_NUM) ==4096
            #print ("isNumlockOn: ",isNumlockOn)
            if isNumlockOn:
                if key in range(K_KP0,K_KP9+1):
                    key=K_0+(key-K_KP0)
                if key == K_KP_PERIOD: key = K_PERIOD

            # Check for valid input depending on input type the user selected when initialized
            if not self.inputType==self.TEXT and (pygame.key.get_mods() & pygame.KMOD_SHIFT): return #shift (uppercase and specials chars only allowed in text
            if self.inputType==self.INT and key==K_PERIOD: return                                    #float/period not allowed if int
            if self.inputType==self.INT or self.inputType==self.FLOAT:
                if key not in range(K_0,K_COLON) and not key==K_PERIOD: return                           #only numbers/period allowed for int/float
            if self.inputType==self.HEX and (key not in range (K_0,K_9) and key not in range(K_a,K_f)): return
            if self.inputType==self.FLOAT and (key==K_KP_PERIOD or key==K_PERIOD) and "." in self.text:return # only allow one . in a float

            # Process the input which made it through the validation block above
            if len(self.text)<self.maxlength:
                if self.inputType==self.HEX: unicode=unicode.upper() #if hex we want uppercase characters
                self.text=self.text[0:self.cursorChar]+unicode+self.text[self.cursorChar:]
                self.cursorChar=self.cursorChar+1