import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import localeinfo
import petskill
import uishop
import dbg
# MARK_BUG_FIX
import guild
# END_OF_MARK_BUG_FIX

from _weakref import proxy

BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
DARK_COLOR = grp.GenerateColor(0.2, 0.2, 0.2, 1.0)
BRIGHT_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)

SELECT_COLOR = grp.GenerateColor(0.0, 0.0, 0.5, 0.3)

WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.5)
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)

createToolTipWindowDict = {}
def RegisterCandidateWindowClass(codePage, candidateWindowClass):
    EditLine.candidateWindowClassDict[codePage]=candidateWindowClass
def RegisterToolTipWindow(type, createToolTipWindow):
    createToolTipWindowDict[type]=createToolTipWindow

app.SetDefaultFontName(localeinfo.UI_DEF_FONT)

class __mem_func__:
    class __noarg_call__:
        def __init__(self, cls, obj, func):
            self.cls=cls
            self.obj=proxy(obj)
            self.func=proxy(func)

        def __call__(self, *arg):
            return self.func(self.obj)

    class __arg_call__:
        def __init__(self, cls, obj, func):
            self.cls=cls
            self.obj=proxy(obj)
            self.func=proxy(func)

        def __call__(self, *arg):
            return self.func(self.obj, *arg)

    def __init__(self, mfunc):
        if mfunc.im_func.func_code.co_argcount>1:
            self.call=__mem_func__.__arg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
        else:
            self.call=__mem_func__.__noarg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)

    def __call__(self, *arg):
        return self.call(*arg)


class Window(object):
    def NoneMethod(cls):
        pass

    NoneMethod = classmethod(NoneMethod)

    def __init__(self, layer = "UI"):
        self.hWnd = None
        self.parentWindow = 0
        self.RegisterWindow(layer)
        self.Hide()

    def __del__(self):
        wndMgr.Destroy(self.hWnd)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.Register(self, layer)

    def Destroy(self):
        pass

    def GetWindowHandle(self):
        return self.hWnd

    def AddFlag(self, style):
        wndMgr.AddFlag(self.hWnd, style)

    def IsRTL(self):
        return wndMgr.IsRTL(self.hWnd)

    def SetWindowName(self, Name):
        wndMgr.SetName(self.hWnd, Name)

    def SetParent(self, parent):
        wndMgr.SetParent(self.hWnd, parent.hWnd)

    def SetParentProxy(self, parent):
        self.parentWindow=proxy(parent)
        wndMgr.SetParent(self.hWnd, parent.hWnd)


    def GetParentProxy(self):
        return self.parentWindow

    def SetPickAlways(self):
        wndMgr.SetPickAlways(self.hWnd)

    def SetWindowHorizontalAlignLeft(self):
        wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_LEFT)

    def SetWindowHorizontalAlignCenter(self):
        wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_CENTER)

    def SetWindowHorizontalAlignRight(self):
        wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_RIGHT)

    def SetWindowVerticalAlignTop(self):
        wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_TOP)

    def SetWindowVerticalAlignCenter(self):
        wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_CENTER)

    def SetWindowVerticalAlignBottom(self):
        wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_BOTTOM)

    def SetTop(self):
        wndMgr.SetTop(self.hWnd)

    def Show(self):
        wndMgr.Show(self.hWnd)

    def Hide(self):
        wndMgr.Hide(self.hWnd)

    def Lock(self):
        wndMgr.Lock(self.hWnd)

    def Unlock(self):
        wndMgr.Unlock(self.hWnd)

    def IsShow(self):
        return wndMgr.IsShow(self.hWnd)

    def UpdateRect(self):
        wndMgr.UpdateRect(self.hWnd)

    def SetSize(self, width, height):
        wndMgr.SetWindowSize(self.hWnd, width, height)

    def GetWidth(self):
        return wndMgr.GetWindowWidth(self.hWnd)

    def GetHeight(self):
        return wndMgr.GetWindowHeight(self.hWnd)

    def GetLocalPosition(self):
        return wndMgr.GetWindowLocalPosition(self.hWnd)

    def GetGlobalPosition(self):
        return wndMgr.GetWindowGlobalPosition(self.hWnd)

    def GetMouseLocalPosition(self):
        return wndMgr.GetMouseLocalPosition(self.hWnd)

    def GetRect(self):
        return wndMgr.GetWindowRect(self.hWnd)

    def SetPosition(self, x, y):
        wndMgr.SetWindowPosition(self.hWnd, x, y)

    def SetYPosition(self, y):
        wndMgr.SetWindowPosition(self.hWnd, y)

    def SetXPosition(self, x):
        wndMgr.SetWindowPosition(self.hWnd, x)

    def SetCenterPosition(self, x = 0, y = 0):
        self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)

    def IsFocus(self):
        return wndMgr.IsFocus(self.hWnd)

    def SetFocus(self):
        wndMgr.SetFocus(self.hWnd)

    def KillFocus(self):
        wndMgr.KillFocus(self.hWnd)

    def GetChildCount(self):
        return wndMgr.GetChildCount(self.hWnd)

    def IsIn(self):
        return wndMgr.IsIn(self.hWnd)


class ListBoxEx(Window):

    class Item(Window):
        def __init__(self):
            Window.__init__(self)

        def __del__(self):
            Window.__del__(self)

        def SetParent(self, parent):
            Window.SetParent(self, parent)
            self.parent=proxy(parent)

        def OnMouseLeftButtonDown(self):
            self.parent.SelectItem(self)

        def OnRender(self):
            if self.parent.GetSelectedItem()==self:
                self.OnSelectedRender()

        def OnSelectedRender(self):
            x, y = self.GetGlobalPosition()
            grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
            grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())

    def __init__(self):
        Window.__init__(self)

        self.viewItemCount=10
        self.basePos=0
        self.itemHeight=16
        self.itemStep=20
        self.selItem=0
        self.itemList=[]
        self.onSelectItemEvent = lambda *arg: None

        self.itemWidth=100

        self.scrollBar=None
        self.__UpdateSize()

    def __del__(self):
        Window.__del__(self)

    def __UpdateSize(self):
        height=self.itemStep*self.__GetViewItemCount()

        self.SetSize(self.itemWidth, height)

    def IsEmpty(self):
        if len(self.itemList)==0:
            return 1
        return 0

    def SetItemStep(self, itemStep):
        self.itemStep=itemStep
        self.__UpdateSize()

    def SetItemSize(self, itemWidth, itemHeight):
        self.itemWidth=itemWidth
        self.itemHeight=itemHeight
        self.__UpdateSize()

    def SetViewItemCount(self, viewItemCount):
        self.viewItemCount=viewItemCount

    def SetSelectEvent(self, event):
        self.onSelectItemEvent = event

    def SetBasePos(self, basePos):
        for oldItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
            oldItem.Hide()

        self.basePos=basePos

        pos=basePos
        for newItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
            (x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
            newItem.SetPosition(x, y)
            newItem.Show()
            pos+=1

    def GetItemIndex(self, argItem):
        return self.itemList.index(argItem)

    def GetSelectedItem(self):
        return self.selItem

    def SelectIndex(self, index):

        if index >= len(self.itemList) or index < 0:
            self.selItem = None
            return

        try:
            self.selItem=self.itemList[index]
        except:
            pass

    def SelectItem(self, selItem):
        self.selItem=selItem
        self.onSelectItemEvent(selItem)

    def RemoveAllItems(self):
        self.selItem=None
        self.itemList=[]

        if self.scrollBar:
            self.scrollBar.SetPos(0)

    def RemoveItem(self, delItem):
        if delItem==self.selItem:
            self.selItem=None

        self.itemList.remove(delItem)

    def AppendItem(self, newItem):
        newItem.SetParent(self)
        newItem.SetSize(self.itemWidth, self.itemHeight)

        pos=len(self.itemList)
        if self.__IsInViewRange(pos):
            (x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
            newItem.SetPosition(x, y)
            newItem.Show()
        else:
            newItem.Hide()

        self.itemList.append(newItem)

    def SetScrollBar(self, scrollBar):
        scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
        self.scrollBar=scrollBar

    def __OnScroll(self):
        self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))

    def __GetScrollLen(self):
        scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
        if scrollLen<0:
            return 0

        return scrollLen

    def __GetViewItemCount(self):
        return self.viewItemCount

    def __GetItemCount(self):
        return len(self.itemList)

    def GetItemViewCoord(self, pos, itemWidth):
        return (0, (pos-self.basePos)*self.itemStep)

    def __IsInViewRange(self, pos):
        if pos<self.basePos:
            return 0
        if pos>=self.basePos+self.viewItemCount:
            return 0
        return 1

class CandidateListBox(ListBoxEx):

    HORIZONTAL_MODE = 0
    VERTICAL_MODE = 1

    class Item(ListBoxEx.Item):
        def __init__(self, text):
            ListBoxEx.Item.__init__(self)

            self.textBox=TextLine()
            self.textBox.SetParent(self)
            self.textBox.SetText(text)
            self.textBox.Show()

        def __del__(self):
            ListBoxEx.Item.__del__(self)

    def __init__(self, mode = HORIZONTAL_MODE):
        ListBoxEx.__init__(self)
        self.itemWidth=32
        self.itemHeight=32
        self.mode = mode

    def __del__(self):
        ListBoxEx.__del__(self)

    def SetMode(self, mode):
        self.mode = mode

    def AppendItem(self, newItem):
        ListBoxEx.AppendItem(self, newItem)

    def GetItemViewCoord(self, pos):
        if self.mode == self.HORIZONTAL_MODE:
            return ((pos-self.basePos)*self.itemStep, 0)
        elif self.mode == self.VERTICAL_MODE:
            return (0, (pos-self.basePos)*self.itemStep)


class TextLine(Window):
    def __init__(self):
        Window.__init__(self)
        self.max = 0
        self.SetFontName(localeinfo.UI_DEF_FONT)

    def __del__(self):
        Window.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterTextLine(self, layer)

    def SetMax(self, max):
        wndMgr.SetMax(self.hWnd, max)

    def SetLimitWidth(self, width):
        wndMgr.SetLimitWidth(self.hWnd, width)

    def SetMultiLine(self):
        wndMgr.SetMultiLine(self.hWnd, TRUE)

    def SetHorizontalAlignArabic(self):
        wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_ARABIC)

    def SetHorizontalAlignLeft(self):
        wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_LEFT)

    def SetHorizontalAlignRight(self):
        wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_RIGHT)

    def SetHorizontalAlignCenter(self):
        wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_CENTER)

    def SetVerticalAlignTop(self):
        wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_TOP)

    def SetVerticalAlignBottom(self):
        wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_BOTTOM)

    def SetVerticalAlignCenter(self):
        wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_CENTER)

    def SetSecret(self, Value=TRUE):
        wndMgr.SetSecret(self.hWnd, Value)

    def SetOutline(self, Value=TRUE):
        wndMgr.SetOutline(self.hWnd, Value)

    def SetFeather(self, value=TRUE):
        wndMgr.SetFeather(self.hWnd, value)

    def SetFontName(self, fontName):
        wndMgr.SetFontName(self.hWnd, fontName)

    def SetDefaultFontName(self):
        wndMgr.SetFontName(self.hWnd, localeinfo.UI_DEF_FONT)

    def SetFontColor(self, red, green, blue):
        wndMgr.SetFontColor(self.hWnd, red, green, blue)

    def SetPackedFontColor(self, color):
        wndMgr.SetFontColor(self.hWnd, color)

    def SetText(self, text):
        wndMgr.SetText(self.hWnd, text)

    def GetText(self):
        return wndMgr.GetText(self.hWnd)

    def GetTextSize(self):
        return wndMgr.GetTextSize(self.hWnd)

class EmptyCandidateWindow(Window):
    def __init__(self):
        Window.__init__(self)

    def __del__(self):
        Window.__init__(self)

    def Load(self):
        pass

    def SetCandidatePosition(self, x, y, textCount):
        pass

    def Clear(self):
        pass

    def Append(self, text):
        pass

    def Refresh(self):
        pass

    def Select(self):
        pass

class EditLine(TextLine):
    candidateWindowClassDict = {}

    def __init__(self):
        TextLine.__init__(self)

        self.eventReturn = Window.NoneMethod
        self.eventEscape = Window.NoneMethod
        self.eventTab = None
        self.numberMode = FALSE
        self.useIME = TRUE

        self.bCodePage = FALSE

        self.candidateWindowClass = None
        self.candidateWindow = None
        self.SetCodePage(app.GetDefaultCodePage())

        self.readingWnd = ReadingWnd()
        self.readingWnd.Hide()

    def __del__(self):
        TextLine.__del__(self)

        self.eventReturn = Window.NoneMethod
        self.eventEscape = Window.NoneMethod
        self.eventTab = None


    def SetCodePage(self, codePage):
        candidateWindowClass=EditLine.candidateWindowClassDict.get(codePage, EmptyCandidateWindow)
        self.__SetCandidateClass(candidateWindowClass)

    def __SetCandidateClass(self, candidateWindowClass):
        if self.candidateWindowClass==candidateWindowClass:
            return

        self.candidateWindowClass = candidateWindowClass
        self.candidateWindow = self.candidateWindowClass()
        self.candidateWindow.Load()
        self.candidateWindow.Hide()

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterTextLine(self, layer)

    def SAFE_SetReturnEvent(self, event):
        self.eventReturn = __mem_func__(event)

    def SetReturnEvent(self, event):
        self.eventReturn = event

    def SetEscapeEvent(self, event):
        self.eventEscape = event

    def SetTabEvent(self, event):
        self.eventTab = event

    def SetMax(self, max):
        self.max = max
        wndMgr.SetMax(self.hWnd, self.max)
        ime.SetMax(self.max)
        self.SetUserMax(self.max)

    def SetUserMax(self, max):
        self.userMax = max
        ime.SetUserMax(self.userMax)

    def SetNumberMode(self):
        self.numberMode = TRUE

    #def AddExceptKey(self, key):
    #   ime.AddExceptKey(key)

    #def ClearExceptKey(self):
    #   ime.ClearExceptKey()

    def SetIMEFlag(self, flag):
        self.useIME = flag

    def SetText(self, text):
        wndMgr.SetText(self.hWnd, text)

        if self.IsFocus():
            ime.SetText(text)

    def Enable(self):
        wndMgr.ShowCursor(self.hWnd)

    def Disable(self):
        wndMgr.HideCursor(self.hWnd)

    def SetEndPosition(self):
        ime.MoveEnd()

    def OnSetFocus(self):
        Text = self.GetText()
        ime.SetText(Text)
        ime.SetMax(self.max)
        ime.SetUserMax(self.userMax)
        ime.SetCursorPosition(-1)
        if self.numberMode:
            ime.SetNumberMode()
        else:
            ime.SetStringMode()
        ime.EnableCaptureInput()
        if self.useIME:
            ime.EnableIME()
        else:
            ime.DisableIME()
        wndMgr.ShowCursor(self.hWnd, TRUE)

    def OnKillFocus(self):
        self.SetText(ime.GetText(self.bCodePage))
        self.OnIMECloseCandidateList()
        self.OnIMECloseReadingWnd()
        ime.DisableIME()
        ime.DisableCaptureInput()
        wndMgr.HideCursor(self.hWnd)

    def OnIMEChangeCodePage(self):
        self.SetCodePage(ime.GetCodePage())

    def OnIMEOpenCandidateList(self):
        self.candidateWindow.Show()
        self.candidateWindow.Clear()
        self.candidateWindow.Refresh()

        gx, gy = self.GetGlobalPosition()
        self.candidateWindow.SetCandidatePosition(gx, gy, len(self.GetText()))

        return TRUE

    def OnIMECloseCandidateList(self):
        self.candidateWindow.Hide()
        return TRUE

    def OnIMEOpenReadingWnd(self):
        gx, gy = self.GetGlobalPosition()
        textlen = len(self.GetText())-2
        reading = ime.GetReading()
        readinglen = len(reading)
        self.readingWnd.SetReadingPosition( gx + textlen*6-24-readinglen*6, gy )
        self.readingWnd.SetText(reading)
        if ime.GetReadingError() == 0:
            self.readingWnd.SetTextColor(0xffffffff)
        else:
            self.readingWnd.SetTextColor(0xffff0000)
        self.readingWnd.SetSize(readinglen * 6 + 4, 19)
        self.readingWnd.Show()
        return TRUE

    def OnIMECloseReadingWnd(self):
        self.readingWnd.Hide()
        return TRUE

    def OnIMEUpdate(self):
        snd.PlaySound("sound/ui/type.wav")
        TextLine.SetText(self, ime.GetText(self.bCodePage))

    def OnIMETab(self):
        if self.eventTab:
            self.eventTab()
            return TRUE

        return FALSE

    def OnIMEReturn(self):
        snd.PlaySound("sound/ui/click.wav")
        self.eventReturn()

        return TRUE

    def OnPressEscapeKey(self):
        self.eventEscape()
        return TRUE

    def OnKeyDown(self, key):
        if app.DIK_F1 == key:
            return FALSE
        if app.DIK_F2 == key:
            return FALSE
        if app.DIK_F3 == key:
            return FALSE
        if app.DIK_F4 == key:
            return FALSE
        if app.DIK_LALT == key:
            return FALSE
        if app.DIK_SYSRQ == key:
            return FALSE
        if app.DIK_LCONTROL == key:
            return FALSE
        if app.DIK_V == key:
            if app.IsPressed(app.DIK_LCONTROL):
                ime.PasteTextFromClipBoard()

        return TRUE

    def OnKeyUp(self, key):
        if app.DIK_F1 == key:
            return FALSE
        if app.DIK_F2 == key:
            return FALSE
        if app.DIK_F3 == key:
            return FALSE
        if app.DIK_F4 == key:
            return FALSE
        if app.DIK_LALT == key:
            return FALSE
        if app.DIK_SYSRQ == key:
            return FALSE
        if app.DIK_LCONTROL == key:
            return FALSE

        return TRUE

    def OnIMEKeyDown(self, key):
        # Left
        if app.VK_LEFT == key:
            ime.MoveLeft()
            return TRUE
        # Right
        if app.VK_RIGHT == key:
            ime.MoveRight()
            return TRUE

        # Home
        if app.VK_HOME == key:
            ime.MoveHome()
            return TRUE
        # End
        if app.VK_END == key:
            ime.MoveEnd()
            return TRUE

        # Delete
        if app.VK_DELETE == key:
            ime.Delete()
            TextLine.SetText(self, ime.GetText(self.bCodePage))
            return TRUE

        return TRUE

    #def OnMouseLeftButtonDown(self):
    #   self.SetFocus()
    def OnMouseLeftButtonDown(self):
        if FALSE == self.IsIn():
            return FALSE

        self.SetFocus()
        PixelPosition = wndMgr.GetCursorPosition(self.hWnd)
        ime.SetCursorPosition(PixelPosition)



class VerticalSeparator(Window):
    BASE_PATH = "illumina/controls/common/separator"

    HEIGHTS = {
        'TOP' : 6,
        'CENTER' : 1,
        'BOTTOM' : 6
    }

    WIDTH = 11

    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

        self.__CreateUI()
        self.SetHeight(0)

    def __del__(self):
        Window.__del__(self)

    def __CreateUI(self):
        self.__dictImages = {
            'TOP' : ImageBox(),
            'CENTER' : ExpandedImageBox(),
            'BOTTOM' : ImageBox()
        }

        for image in self.__dictImages.itervalues():
            image.SetParent(self)
            image.Show()

        self.__dictImages['TOP'].LoadImage("%s/vertical_top.tga" % VerticalSeparator.BASE_PATH)
        self.__dictImages['CENTER'].LoadImage("%s/vertical_center.tga" % VerticalSeparator.BASE_PATH)
        self.__dictImages['BOTTOM'].LoadImage("%s/vertical_bottom.tga" % VerticalSeparator.BASE_PATH)

        self.__dictImages['TOP'].SetPosition(0, 0)
        self.__dictImages['CENTER'].SetPosition(0, VerticalSeparator.HEIGHTS['TOP'])

    def SetHeight(self, height):
        height = max(VerticalSeparator.HEIGHTS['TOP'] + VerticalSeparator.HEIGHTS['BOTTOM'], height)

        self.SetSize(VerticalSeparator.WIDTH, height)

        self.__dictImages['CENTER'].SetScale(1.0, float(height - (VerticalSeparator.HEIGHTS['TOP'] + VerticalSeparator.HEIGHTS['BOTTOM'])) / float(VerticalSeparator.HEIGHTS['CENTER']))
        self.__dictImages['BOTTOM'].SetPosition(0, height - VerticalSeparator.HEIGHTS['BOTTOM'])

## ILLUMINA ##

class HorizontalSeparator(Window):
    BASE_PATH = "illumina/controls/common/separator"

    WIDTHS = {
        'LEFT' : 6,
        'CENTER' : 1,
        'RIGHT' : 6
    }

    HEIGHT = 11

    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

        self.__CreateUI()
        self.SetWidth(0)

    def __del__(self):
        Window.__del__(self)

    def __CreateUI(self):
        self.__dictImages = {
            'LEFT' : ImageBox(),
            'CENTER' : ExpandedImageBox(),
            'RIGHT' : ImageBox()
        }

        for image in self.__dictImages.itervalues():
            image.SetParent(self)
            image.Show()

        self.__dictImages['LEFT'].LoadImage("%s/horizontal_left.tga" % HorizontalSeparator.BASE_PATH)
        self.__dictImages['CENTER'].LoadImage("%s/horizontal_center.tga" % HorizontalSeparator.BASE_PATH)
        self.__dictImages['RIGHT'].LoadImage("%s/horizontal_right.tga" % HorizontalSeparator.BASE_PATH)

        self.__dictImages['LEFT'].SetPosition(0, 0)
        self.__dictImages['CENTER'].SetPosition(HorizontalSeparator.WIDTHS['LEFT'], 0)

    def SetWidth(self, width):
        width = max(HorizontalSeparator.WIDTHS['LEFT'] + HorizontalSeparator.WIDTHS['RIGHT'], width)

        self.SetSize(width, HorizontalSeparator.HEIGHT)

        self.__dictImages['CENTER'].SetScale(float(width - (HorizontalSeparator.WIDTHS['LEFT'] + HorizontalSeparator.WIDTHS['RIGHT'])) / float(HorizontalSeparator.WIDTHS['CENTER']), 1.0)
        self.__dictImages['RIGHT'].SetPosition(width - HorizontalSeparator.WIDTHS['RIGHT'], 0)

## ILLUMINA ##

class MarkBox(Window):
    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

    def __del__(self):
        Window.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterMarkBox(self, layer)

    def Load(self):
        wndMgr.MarkBox_Load(self.hWnd)

    def SetScale(self, scale):
        wndMgr.MarkBox_SetScale(self.hWnd, scale)

    def SetIndex(self, guildID):
        MarkID = guild.GuildIDToMarkID(guildID)
        wndMgr.MarkBox_SetImageFilename(self.hWnd, guild.GetMarkImageFilenameByMarkID(MarkID))
        wndMgr.MarkBox_SetIndex(self.hWnd, guild.GetMarkIndexByMarkID(MarkID))

    def SetAlpha(self, alpha):
        wndMgr.MarkBox_SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)

class ImageBox(Window):
    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

        self.eventDict={}

    def __del__(self):
        Window.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterImageBox(self, layer)

    def LoadImage(self, imageName):
        self.name=imageName
        wndMgr.LoadImage(self.hWnd, imageName)

        if len(self.eventDict)!=0:
            print "LOAD IMAGE", self, self.eventDict

    def SetAlpha(self, alpha):
        wndMgr.SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)

    def GetWidth(self):
        return wndMgr.GetWidth(self.hWnd)

    def GetHeight(self):
        return wndMgr.GetHeight(self.hWnd)

    def OnMouseOverIn(self):
        try:
            self.eventDict["MOUSE_OVER_IN"]()
        except KeyError:
            pass

    def OnMouseOverOut(self):
        try:
            self.eventDict["MOUSE_OVER_OUT"]()
        except KeyError:
            pass

    def SAFE_SetStringEvent(self, event, func):
        self.eventDict[event]=__mem_func__(func)


class ExpandedImageBox(ImageBox):
    def __init__(self, layer = "UI"):
        ImageBox.__init__(self, layer)
        self.Rot = 0

    def __del__(self):
        ImageBox.__del__(self)

    def SetAlpha(self, alpha):
        wndMgr.SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterExpandedImageBox(self, layer)

    def SetScale(self, xScale, yScale):
        wndMgr.SetScale(self.hWnd, xScale, yScale)

    def SetOrigin(self, x, y):
        wndMgr.SetOrigin(self.hWnd, x, y)

    def SetRotation(self, rotation):
        self.Rot = rotation
        wndMgr.SetRotation(self.hWnd, rotation)

    def GetRotation(self):
        return self.Rot

    def SetRenderingMode(self, mode):
        wndMgr.SetRenderingMode(self.hWnd, mode)

    # [0.0, 1.0] 사이의 값만큼 퍼센트로 그리지 않는다.
    def SetRenderingRect(self, left, top, right, bottom):
        wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)

    def SetPercentage(self, curValue, maxValue):
        if maxValue:
            self.SetRenderingRect(0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
        else:
            self.SetRenderingRect(0.0, 0.0, 0.0, 0.0)

    def GetWidth(self):
        return wndMgr.GetWindowWidth(self.hWnd)

    def GetHeight(self):
        return wndMgr.GetWindowHeight(self.hWnd)

    def SetTextPosition(self, x, y):
        self.tx = x
        self.ty = y
        self.SetPosition(x, y)

    def GetTextPosition(self):
        return self.tx, self.ty

class AniImageBox(Window):
    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

    def __del__(self):
        Window.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterAniImageBox(self, layer)

    def SetDelay(self, delay):
        wndMgr.SetDelay(self.hWnd, delay)

    def AppendImage(self, filename):
        wndMgr.AppendImage(self.hWnd, filename)

    def AppendImageScale(self, filename, scale_x, scale_y):
        wndMgr.AppendImageScale(self.hWnd, filename, scale_x, scale_y)

    def SetPercentage(self, curValue, maxValue):
        wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)

    def OnEndFrame(self):
        pass

class Button(Window):
    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

        self.eventFunc = None
        self.eventArgs = None

        self.ButtonText = None
        self.ToolTipText = None

    def __del__(self):
        Window.__del__(self)

        self.eventFunc = None
        self.eventArgs = None

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterButton(self, layer)

    def SetUpVisual(self, filename):
        wndMgr.SetUpVisual(self.hWnd, filename)

    def SetOverVisual(self, filename):
        wndMgr.SetOverVisual(self.hWnd, filename)

##Bonus
    def GetText(self):
        if not self.ButtonText:
            return# ""
        return self.ButtonText.GetText()

    def SetDownVisual(self, filename):
        wndMgr.SetDownVisual(self.hWnd, filename)

    def SetDisableVisual(self, filename):
        wndMgr.SetDisableVisual(self.hWnd, filename)

    def GetUpVisualFileName(self):
        return wndMgr.GetUpVisualFileName(self.hWnd)

    def GetOverVisualFileName(self):
        return wndMgr.GetOverVisualFileName(self.hWnd)

    def GetDownVisualFileName(self):
        return wndMgr.GetDownVisualFileName(self.hWnd)

    def Flash(self):
        wndMgr.Flash(self.hWnd)

    def Enable(self):
        wndMgr.Enable(self.hWnd)

    def Disable(self):
        wndMgr.Disable(self.hWnd)

    def Down(self):
        wndMgr.Down(self.hWnd)

    def SetUp(self):
        wndMgr.SetUp(self.hWnd)

    def SAFE_SetEvent(self, func, *args):
        self.eventFunc = __mem_func__(func)
        self.eventArgs = args

    def SetEvent(self, func, *args):
        self.eventFunc = func
        self.eventArgs = args

    def SetTextColor(self, color):
        if not self.ButtonText:
            return
        self.ButtonText.SetPackedFontColor(color)

    def SetText(self, text, height = 4):

        if not self.ButtonText:
            textLine = TextLine()
            textLine.SetParent(self)
            textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2)
            textLine.SetVerticalAlignCenter()
            textLine.SetHorizontalAlignCenter()
            textLine.Show()
            self.ButtonText = textLine

        self.ButtonText.SetText(text)

    def SetFormToolTipText(self, type, text, x, y):
        if not self.ToolTipText:
            toolTip=createToolTipWindowDict[type]()
            toolTip.SetParent(self)
            toolTip.SetSize(0, 0)
            toolTip.SetHorizontalAlignCenter()
            toolTip.SetOutline()
            toolTip.Hide()
            toolTip.SetPosition(x + self.GetWidth()/2, y)
            self.ToolTipText=toolTip

        self.ToolTipText.SetText(text)

    def SetToolTipWindow(self, toolTip):
        self.ToolTipText=toolTip
        self.ToolTipText.SetParentProxy(self)

    def SetToolTipText(self, text, x=0, y = -19):
        self.SetFormToolTipText("TEXT", text, x, y)

    def CallEvent(self):
        snd.PlaySound("sound/ui/click.wav")

        if self.eventFunc:
            apply(self.eventFunc, self.eventArgs)

    def ShowToolTip(self):
        if self.ToolTipText:
            self.ToolTipText.Show()

    def HideToolTip(self):
        if self.ToolTipText:
            self.ToolTipText.Hide()

    def IsDown(self):
        return wndMgr.IsDown(self.hWnd)

class RadioButton(Button):
    def __init__(self):
        Button.__init__(self)

    def __del__(self):
        Button.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterRadioButton(self, layer)

class ToggleButton(Button):
    def __init__(self):
        Button.__init__(self)

        self.eventUp = None
        self.eventDown = None

    def __del__(self):
        Button.__del__(self)

        self.eventUp = None
        self.eventDown = None

    def SetToggleUpEvent(self, event):
        self.eventUp = event

    def SetToggleDownEvent(self, event):
        self.eventDown = event

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterToggleButton(self, layer)

    def OnToggleUp(self):
        if self.eventUp:
            self.eventUp()

    def OnToggleDown(self):
        if self.eventDown:
            self.eventDown()

class DragButton(Button):
    def __init__(self):
        Button.__init__(self)
        self.AddFlag("movable")

        self.callbackEnable = TRUE
        self.eventMove = lambda: None

    def __del__(self):
        Button.__del__(self)

        self.eventMove = lambda: None

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterDragButton(self, layer)

    def SetMoveEvent(self, event):
        self.eventMove = event

    def SetRestrictMovementArea(self, x, y, width, height):
        wndMgr.SetRestrictMovementArea(self.hWnd, x, y, width, height)

    def TurnOnCallBack(self):
        self.callbackEnable = TRUE

    def TurnOffCallBack(self):
        self.callbackEnable = FALSE

    def OnMove(self):
        if self.callbackEnable:
            self.eventMove()

class NumberLine(Window):

    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

    def __del__(self):
        Window.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterNumberLine(self, layer)

    def SetHorizontalAlignCenter(self):
        wndMgr.SetNumberHorizontalAlignCenter(self.hWnd)

    def SetHorizontalAlignRight(self):
        wndMgr.SetNumberHorizontalAlignRight(self.hWnd)

    def SetPath(self, path):
        wndMgr.SetPath(self.hWnd, path)

    def SetNumber(self, number):
        wndMgr.SetNumber(self.hWnd, number)

###################################################################################################
## PythonScript Element
###################################################################################################

class Box(Window):

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterBox(self, layer)

    def SetColor(self, color):
        wndMgr.SetColor(self.hWnd, color)

class Bar(Window):

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterBar(self, layer)

    def SetColor(self, color):
        wndMgr.SetColor(self.hWnd, color)

class Line(Window):

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterLine(self, layer)

    def SetColor(self, color):
        wndMgr.SetColor(self.hWnd, color)

class SlotBar(Window):

    def __init__(self):
        Window.__init__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterBar3D(self, layer)

## Same with SlotBar
class Bar3D(Window):

    def __init__(self):
        Window.__init__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterBar3D(self, layer)

    def SetColor(self, left, right, center):
        wndMgr.SetColor(self.hWnd, left, right, center)

class SlotWindow(Window):

    def __init__(self):
        Window.__init__(self)

        self.StartIndex = 0

        self.eventSelectEmptySlot = None
        self.eventSelectItemSlot = None
        self.eventUnselectEmptySlot = None
        self.eventUnselectItemSlot = None
        self.eventUseSlot = None
        self.eventOverInItem = None
        self.eventOverOutItem = None
        self.eventPressedSlotButton = None

    def __del__(self):
        Window.__del__(self)

        self.eventSelectEmptySlot = None
        self.eventSelectItemSlot = None
        self.eventUnselectEmptySlot = None
        self.eventUnselectItemSlot = None
        self.eventUseSlot = None
        self.eventOverInItem = None
        self.eventOverOutItem = None
        self.eventPressedSlotButton = None

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterSlotWindow(self, layer)

    def SetSlotStyle(self, style):
        wndMgr.SetSlotStyle(self.hWnd, style)

    def HasSlot(self, slotIndex):
        return wndMgr.HasSlot(self.hWnd, slotIndex)

    def SetSlotBaseImage(self, imageFileName, r, g, b, a):
        wndMgr.SetSlotBaseImage(self.hWnd, imageFileName, r, g, b, a)

    def SetSlotBaseImageScale(self, imageFileName, r, g, b, a, sx, sy):
        wndMgr.SetSlotBaseImageScale(self.hWnd, imageFileName, r, g, b, a, sx, sy)

    def SetCoverButton(self,\
                        slotIndex,\
                        upName="illumina/slot1.tga",\
                        overName="illumina/slot2.tga",\
                        downName="illumina/slot.tga",\
                        disableName="illumina/slot.tga",\
                        LeftButtonEnable = FALSE,\
                        RightButtonEnable = TRUE):
        wndMgr.SetCoverButton(self.hWnd, slotIndex, upName, overName, downName, disableName, LeftButtonEnable, RightButtonEnable)

    def EnableCoverButton(self, slotIndex):
        wndMgr.EnableCoverButton(self.hWnd, slotIndex)

    def DisableCoverButton(self, slotIndex):
        wndMgr.DisableCoverButton(self.hWnd, slotIndex)

    def SetAlwaysRenderCoverButton(self, slotIndex, bAlwaysRender = TRUE):
        wndMgr.SetAlwaysRenderCoverButton(self.hWnd, slotIndex, bAlwaysRender)

    def AppendSlotButton(self, upName, overName, downName):
        wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)

    def ShowSlotButton(self, slotNumber):
        wndMgr.ShowSlotButton(self.hWnd, slotNumber)

    def HideAllSlotButton(self):
        wndMgr.HideAllSlotButton(self.hWnd)

    def AppendRequirementSignImage(self, filename):
        wndMgr.AppendRequirementSignImage(self.hWnd, filename)

    def ShowRequirementSign(self, slotNumber):
        wndMgr.ShowRequirementSign(self.hWnd, slotNumber)

    def HideRequirementSign(self, slotNumber):
        wndMgr.HideRequirementSign(self.hWnd, slotNumber)

    def ActivateSlot(self, slotNumber):
        wndMgr.ActivateSlot(self.hWnd, slotNumber)

    def DeactivateSlot(self, slotNumber):
        wndMgr.DeactivateSlot(self.hWnd, slotNumber)

    def ShowSlotBaseImage(self, slotNumber):
        wndMgr.ShowSlotBaseImage(self.hWnd, slotNumber)

    def HideSlotBaseImage(self, slotNumber):
        wndMgr.HideSlotBaseImage(self.hWnd, slotNumber)

    def SAFE_SetButtonEvent(self, button, state, event):
        if "LEFT"==button:
            if "EMPTY"==state:
                self.eventSelectEmptySlot=__mem_func__(event)
            elif "EXIST"==state:
                self.eventSelectItemSlot=__mem_func__(event)
            elif "ALWAYS"==state:
                self.eventSelectEmptySlot=__mem_func__(event)
                self.eventSelectItemSlot=__mem_func__(event)
        elif "RIGHT"==button:
            if "EMPTY"==state:
                self.eventUnselectEmptySlot=__mem_func__(event)
            elif "EXIST"==state:
                self.eventUnselectItemSlot=__mem_func__(event)
            elif "ALWAYS"==state:
                self.eventUnselectEmptySlot=__mem_func__(event)
                self.eventUnselectItemSlot=__mem_func__(event)

    def SetSelectEmptySlotEvent(self, empty):
        self.eventSelectEmptySlot = empty

    def SetSelectItemSlotEvent(self, item):
        self.eventSelectItemSlot = item

    def SetUnselectEmptySlotEvent(self, empty):
        self.eventUnselectEmptySlot = empty

    def SetUnselectItemSlotEvent(self, item):
        self.eventUnselectItemSlot = item

    def SetUseSlotEvent(self, use):
        self.eventUseSlot = use

    def SetOverInItemEvent(self, event):
        self.eventOverInItem = event

    def SetOverOutItemEvent(self, event):
        self.eventOverOutItem = event

    def SetPressedSlotButtonEvent(self, event):
        self.eventPressedSlotButton = event

    def GetSlotCount(self):
        return wndMgr.GetSlotCount(self.hWnd)

    def SetUseMode(self, flag):
        "TRUE일때만 ItemToItem 이 가능한지 보여준다"
        wndMgr.SetUseMode(self.hWnd, flag)

    def SetUsableItem(self, flag):
        "TRUE면 현재 가리킨 아이템이 ItemToItem 적용 가능하다"
        wndMgr.SetUsableItem(self.hWnd, flag)

    ## Slot
    def SetSlotCoolTime(self, slotIndex, coolTime, elapsedTime = 0.0):
        wndMgr.SetSlotCoolTime(self.hWnd, slotIndex, coolTime, elapsedTime)

    def LockSlot(self, slotIndex):
        wndMgr.LockSlot(self.hWnd, slotIndex)

    def UnlockSlot(self, slotIndex):
        wndMgr.UnlockSlot(self.hWnd, slotIndex)

    def RefreshSlot(self):
        wndMgr.RefreshSlot(self.hWnd)

    def ClearSlot(self, slotNumber):
        wndMgr.ClearSlot(self.hWnd, slotNumber)

    def ClearAllSlot(self):
        wndMgr.ClearAllSlot(self.hWnd)

    def AppendSlot(self, index, x, y, width, height):
        wndMgr.AppendSlot(self.hWnd, index, x, y, width, height)

    def SetSlot(self, slotIndex, itemIndex, width, height, icon):
        wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon)

    def SetSlotScale(self, slotIndex, itemIndex, width, height, icon, sx, sy, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
        wndMgr.SetSlotScale(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor, sx, sy)

    def SetSlotCount(self, slotNumber, count):
        wndMgr.SetSlotCount(self.hWnd, slotNumber, count)

    def SetSlotCountNew(self, slotNumber, grade, count):
        wndMgr.SetSlotCountNew(self.hWnd, slotNumber, grade, count)

    def SetItemSlot(self, renderingSlotNumber, ItemIndex, ItemCount = 0):

        if 0 == ItemIndex or None == ItemIndex:
            wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
            return

        item.SelectItem(ItemIndex)
        itemIcon = item.GetIconImage()

        item.SelectItem(ItemIndex)
        (width, height) = item.GetItemSize()

        wndMgr.SetSlot(self.hWnd, renderingSlotNumber, ItemIndex, width, height, itemIcon)
        wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)

    def SetPetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel, sx = 1.0, sy = 1.0):

        skillIcon = petskill.GetIconImage(skillIndex)

        if 0 == skillIcon:
            wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
            return
        petskill.SetSkillSlot(renderingSlotNumber, skillIndex)
        if sx != 1.0:
            wndMgr.SetSlotScale(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon, (1.0, 1.0, 1.0, 1.0), sx, sy)
        else:
            wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
            wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)

    def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):

        skillIcon = skill.GetIconImage(skillIndex)

        if 0 == skillIcon:
            wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
            return

        wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
        wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)

    def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):

        skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)

        if 0 == skillIcon:
            wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
            return

        wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)

    def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
        import player
        icon = player.GetEmotionIconImage(emotionIndex)

        if 0 == icon:
            wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
            return

        wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)

    ## Event
    def OnSelectEmptySlot(self, slotNumber):
        if self.eventSelectEmptySlot:
            self.eventSelectEmptySlot(slotNumber)

    def OnSelectItemSlot(self, slotNumber):
        if self.eventSelectItemSlot:
            self.eventSelectItemSlot(slotNumber)

    def OnUnselectEmptySlot(self, slotNumber):
        if self.eventUnselectEmptySlot:
            self.eventUnselectEmptySlot(slotNumber)

    def OnUnselectItemSlot(self, slotNumber):
        if self.eventUnselectItemSlot:
            self.eventUnselectItemSlot(slotNumber)

    def OnUseSlot(self, slotNumber):
        if self.eventUseSlot:
            self.eventUseSlot(slotNumber)

    def OnOverInItem(self, slotNumber):
        if self.eventOverInItem:
            self.eventOverInItem(slotNumber)

    def OnOverOutItem(self):
        if self.eventOverOutItem:
            self.eventOverOutItem()

    def OnPressedSlotButton(self, slotNumber):
        if self.eventPressedSlotButton:
            self.eventPressedSlotButton(slotNumber)

    def GetStartIndex(self):
        return 0

class GridSlotWindow(SlotWindow):

    def __init__(self):
        SlotWindow.__init__(self)

        self.startIndex = 0

    def __del__(self):
        SlotWindow.__del__(self)

    def RegisterWindow(self, layer):
        self.hWnd = wndMgr.RegisterGridSlotWindow(self, layer)

    def ArrangeSlot(self, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank):

        self.startIndex = StartIndex

        wndMgr.ArrangeSlot(self.hWnd, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank)
        self.startIndex = StartIndex

    def GetStartIndex(self):
        return self.startIndex

class TitleBar(Window):

    BLOCK_WIDTH = 35
    BLOCK_HEIGHT = 28

    def __init__(self):
        Window.__init__(self)
        self.AddFlag("attach")

    def __del__(self):
        Window.__del__(self)

    def MakeTitleBar(self, width, color):

        ## 현재 Color는 사용하고 있지 않음

        width = max(64, width)

        imgLeft = ImageBox()
        imgCenter = ExpandedImageBox()
        imgRight = ImageBox()
        imgRight2 = ImageBox()
        imgLeft.AddFlag("not_pick")
        imgCenter.AddFlag("not_pick")
        imgRight2.AddFlag("not_pick")
        imgRight.AddFlag("not_pick")
        imgLeft.SetParent(self)
        imgCenter.SetParent(self)
        imgRight2.SetParent(imgRight)
        imgRight.SetParent(self)

        imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_left.tga")
        imgCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
        imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
        imgRight2.LoadImage("d:/ymir work/ui/pattern/decoration_right.tga")

        imgLeft.Show()
        imgCenter.Show()
        imgRight.Show()
        imgRight2.Show()

        btnClose = Button()
        btnClose.SetParent(self)
        btnClose.SetUpVisual("d:/ymir work/ui/pattern/board_close_normal.tga")
        btnClose.SetOverVisual("d:/ymir work/ui/pattern/board_close_hover.tga")
        btnClose.SetDownVisual("d:/ymir work/ui/pattern/board_close_active.tga")
        btnClose.SetToolTipText(localeinfo.UI_CLOSE, 0, -24)
        btnClose.Show()

        self.imgLeft = imgLeft
        self.imgCenter = imgCenter
        self.imgRight = imgRight
        self.imgRight2 = imgRight2
        self.btnClose = btnClose

        self.SetWidth(width)

    def SetWidth(self, width):
        self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - 151) / 151, 0.0)
        self.imgLeft.SetPosition(0,3)
        self.imgCenter.SetPosition(self.BLOCK_WIDTH, 3)
        self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 3)
        self.imgRight2.SetPosition(-13,-17)

        self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 1, 1)

        self.SetSize(width, self.BLOCK_HEIGHT)

    def SetCloseEvent(self, event):
        self.btnClose.SetEvent(event)

    def Refresh(self):
        pass

class HorizontalBar(Window):

    BLOCK_WIDTH = 32
    BLOCK_HEIGHT = 17

    def __init__(self):
        Window.__init__(self)
        self.AddFlag("attach")

    def __del__(self):
        Window.__del__(self)

    def Create(self, width):

        width = max(96, width)

        imgLeft = ImageBox()
        imgLeft.SetParent(self)
        imgLeft.AddFlag("not_pick")
        imgLeft.LoadImage("d:/ymir work/ui/pattern/horizontalbar_left.tga")
        imgLeft.Show()

        imgCenter = ExpandedImageBox()
        imgCenter.SetParent(self)
        imgCenter.AddFlag("not_pick")
        imgCenter.LoadImage("d:/ymir work/ui/pattern/horizontalbar_center.tga")
        imgCenter.Show()

        imgRight = ImageBox()
        imgRight.SetParent(self)
        imgRight.AddFlag("not_pick")
        imgRight.LoadImage("d:/ymir work/ui/pattern/horizontalbar_right.tga")
        imgRight.Show()

        self.imgLeft = imgLeft
        self.imgCenter = imgCenter
        self.imgRight = imgRight
        self.SetWidth(width)

    def SetWidth(self, width):
        self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
        self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
        self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
        self.SetSize(width, self.BLOCK_HEIGHT)

class Gauge(Window):

    SLOT_WIDTH = 16
    SLOT_HEIGHT = 7

    GAUGE_TEMPORARY_PLACE = 12
    GAUGE_WIDTH = 16

    def __init__(self):
        Window.__init__(self)
        self.width = 0
    def __del__(self):
        Window.__del__(self)

    def MakeGauge(self, width, color):

        self.width = max(48, width)

        imgSlotLeft = ImageBox()
        imgSlotLeft.SetParent(self)
        imgSlotLeft.LoadImage("d:/ymir work/ui/pattern/gauge_slot_left.tga")
        imgSlotLeft.Show()

        imgSlotRight = ImageBox()
        imgSlotRight.SetParent(self)
        imgSlotRight.LoadImage("d:/ymir work/ui/pattern/gauge_slot_right.tga")
        imgSlotRight.Show()
        imgSlotRight.SetPosition(width - self.SLOT_WIDTH, 0)

        imgSlotCenter = ExpandedImageBox()
        imgSlotCenter.SetParent(self)
        imgSlotCenter.LoadImage("d:/ymir work/ui/pattern/gauge_slot_center.tga")
        imgSlotCenter.Show()
        imgSlotCenter.SetRenderingRect(0.0, 0.0, float((width - self.SLOT_WIDTH*2) - self.SLOT_WIDTH) / self.SLOT_WIDTH, 0.0)
        imgSlotCenter.SetPosition(self.SLOT_WIDTH, 0)

        imgGauge = ExpandedImageBox()
        imgGauge.SetParent(self)
        imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga")
        imgGauge.Show()
        imgGauge.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
        imgGauge.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0)

        imgSlotLeft.AddFlag("attach")
        imgSlotCenter.AddFlag("attach")
        imgSlotRight.AddFlag("attach")

        self.imgLeft = imgSlotLeft
        self.imgCenter = imgSlotCenter
        self.imgRight = imgSlotRight
        self.imgGauge = imgGauge

        self.SetSize(width, self.SLOT_HEIGHT)

    def SetPercentage(self, curValue, maxValue):

        # PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
        if maxValue > 0.0:
            percentage = min(1.0, float(curValue)/float(maxValue))
        else:
            percentage = 0.0
        # END_OF_PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR

        gaugeSize = -1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE*2) * percentage / self.GAUGE_WIDTH
        self.imgGauge.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0)

class Board(Window):

    CORNER_WIDTH = 55
    CORNER_HEIGHT = 55
    LINE_WIDTH = 128
    LINE_HEIGHT = 128

    LT = 0
    LB = 1
    RT = 2
    RB = 3
    L = 0
    R = 1
    T = 2
    B = 3

    def __init__(self):
        Window.__init__(self)

        self.MakeBoard("d:/ymir work/ui/pattern/Board_Corner_", "d:/ymir work/ui/pattern/Board_Line_")
        self.MakeBase()

    def MakeBoard(self, cornerPath, linePath):

        CornerFileNames = [ cornerPath+dir+".tga" for dir in ("LeftTop", "LeftBottom", "RightTop", "RightBottom", ) ]
        LineFileNames = [ linePath+dir+".tga" for dir in ("Left", "Right", "Top", "Bottom", ) ]
        """
        CornerFileNames = (
                            "d:/ymir work/ui/pattern/Board_Corner_LeftTop.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_LeftBottom.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_RightTop.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_RightBottom.tga",
                            )
        LineFileNames = (
                            "d:/ymir work/ui/pattern/Board_Line_Left.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Right.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Top.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Bottom.tga",
                            )
        """

        self.Corners = []
        for fileName in CornerFileNames:
            Corner = ExpandedImageBox()
            Corner.AddFlag("not_pick")
            Corner.LoadImage(fileName)
            Corner.SetParent(self)
            Corner.SetPosition(0, 0)
            Corner.Show()
            self.Corners.append(Corner)

        self.Lines = []
        for fileName in LineFileNames:
            Line = ExpandedImageBox()
            Line.AddFlag("not_pick")
            Line.LoadImage(fileName)
            Line.SetParent(self)
            Line.SetPosition(0, 0)
            Line.Show()
            self.Lines.append(Line)

        self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
        self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)

    def MakeBase(self):
        self.Base = ExpandedImageBox()
        self.Base.AddFlag("not_pick")
        self.Base.LoadImage("d:/ymir work/ui/pattern/Board_Base.tga")
        self.Base.SetParent(self)
        self.Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Base.Show()

        self.Decoration = ExpandedImageBox()
        self.Decoration.AddFlag("not_pick")
        self.Decoration.LoadImage("d:/ymir work/ui/pattern/decoration_leftbottom.tga")
        self.Decoration.SetParent(self)
        self.Decoration.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Decoration.Show()

    def __del__(self):
        Window.__del__(self)

    def SetSize(self, width, height):

        width = max(self.CORNER_WIDTH*2, width)
        height = max(self.CORNER_HEIGHT*2, height)
        Window.SetSize(self, width, height)

        self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
        self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
        self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
        self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)

        self.Decoration.SetPosition(-5,height-57)

        verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
        horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
        self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
        self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)

        if self.Base:
            self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)

class BoardWithTitleBar(Board):
    def __init__(self):
        Board.__init__(self)

        titleBar = TitleBar()
        titleBar.SetParent(self)
        titleBar.MakeTitleBar(0, "red")
        titleBar.SetPosition(8, 7)
        titleBar.Show()

        titleName = TextLine()
        titleName.SetParent(titleBar)
        titleName.SetPosition(0, 7)
        titleName.SetWindowHorizontalAlignCenter()
        titleName.SetHorizontalAlignCenter()
        titleName.Show()

        self.titleBar = titleBar
        self.titleName = titleName

        self.SetCloseEvent(self.Hide)

    def __del__(self):
        Board.__del__(self)
        self.titleBar = None
        self.titleName = None

    def SetSize(self, width, height):
        self.titleBar.SetWidth(width - 15)
        #self.pickRestrictWindow.SetSize(width, height - 30)
        Board.SetSize(self, width, height)
        self.titleName.UpdateRect()

    def SetTitleColor(self, color):
        self.titleName.SetPackedFontColor(color)

    def SetTitleName(self, name):
        self.titleName.SetText(name)

    def SetCloseEvent(self, event):
        self.titleBar.SetCloseEvent(event)

class ThinBoard(Window):

    CORNER_WIDTH = 21
    CORNER_HEIGHT = 21
    LINE_WIDTH = 20
    LINE_HEIGHT = 20
    BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.6)

    LT = 0
    LB = 1
    RT = 2
    RB = 3
    L = 0
    R = 1
    T = 2
    B = 3

    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)

        CornerFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ]
        LineFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Line_"+dir+".tga" for dir in ["Left","Right","Top","Bottom"] ]

        self.Corners = []
        for fileName in CornerFileNames:
            Corner = ExpandedImageBox()
            Corner.AddFlag("attach")
            Corner.AddFlag("not_pick")
            Corner.LoadImage(fileName)
            Corner.SetParent(self)
            Corner.SetPosition(0, 0)
            Corner.Show()
            self.Corners.append(Corner)

        self.Lines = []
        for fileName in LineFileNames:
            Line = ExpandedImageBox()
            Line.AddFlag("attach")
            Line.AddFlag("not_pick")
            Line.LoadImage(fileName)
            Line.SetParent(self)
            Line.SetPosition(0, 0)
            Line.Show()
            self.Lines.append(Line)

        Base = Bar()
        Base.SetParent(self)
        Base.AddFlag("attach")
        Base.AddFlag("not_pick")
        Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
        Base.SetColor(self.BOARD_COLOR)
        Base.Show()
        self.Base = Base

        self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
        self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)

    def __del__(self):
        Window.__del__(self)

    def SetSize(self, width, height):

        width = max(self.CORNER_WIDTH*2, width)
        height = max(self.CORNER_HEIGHT*2, height)
        Window.SetSize(self, width, height)

        self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
        self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
        self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
        self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)

        verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
        horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
        self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
        self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
        self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)

    def ShowInternal(self):
        self.Base.Show()
        for wnd in self.Lines:
            wnd.Show()
        for wnd in self.Corners:
            wnd.Show()

    def HideInternal(self):
        self.Base.Hide()
        for wnd in self.Lines:
            wnd.Hide()
        for wnd in self.Corners:
            wnd.Hide()

############## NOWE OKNO ###############



class ThinBoardNew(Window):

    CORNER_WIDTH = 16
    CORNER_HEIGHT = 16
    LINE_WIDTH = 1
    LINE_HEIGHT = 1

    LT = 0
    LB = 1
    RT = 2
    RB = 3
    L = 0
    R = 1
    T = 2
    B = 3

    def __init__(self):
        Window.__init__(self)

        self.MakeBoard("d:/ymir work/ui/pattern/newbar/bar_corner_", "d:/ymir work/ui/pattern/newbar/bar_")
        self.MakeBase()

    def MakeBoard(self, cornerPath, linePath):

        CornerFileNames = [ cornerPath+dir+".tga" for dir in ("LeftTop", "LeftBottom", "RightTop", "RightBottom", ) ]
        LineFileNames = [ linePath+dir+".tga" for dir in ("Left", "Right", "Top", "Bottom", ) ]
        """
        CornerFileNames = (
                            "d:/ymir work/ui/pattern/Board_Corner_LeftTop.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_LeftBottom.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_RightTop.tga",
                            "d:/ymir work/ui/pattern/Board_Corner_RightBottom.tga",
                            )
        LineFileNames = (
                            "d:/ymir work/ui/pattern/Board_Line_Left.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Right.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Top.tga",
                            "d:/ymir work/ui/pattern/Board_Line_Bottom.tga",
                            )
        """

        self.Corners = []
        for fileName in CornerFileNames:
            Corner = ExpandedImageBox()
            Corner.AddFlag("not_pick")
            Corner.LoadImage(fileName)
            Corner.SetParent(self)
            Corner.SetPosition(0, 0)
            Corner.Show()
            self.Corners.append(Corner)

        self.Lines = []
        for fileName in LineFileNames:
            Line = ExpandedImageBox()
            Line.AddFlag("not_pick")
            Line.LoadImage(fileName)
            Line.SetParent(self)
            Line.SetPosition(0, 0)
            Line.Show()
            self.Lines.append(Line)

        self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
        self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)

    def MakeBase(self):
        self.Base = ExpandedImageBox()
        self.Base.AddFlag("not_pick")
        self.Base.LoadImage("d:/ymir work/ui/pattern/newbar/bar_fill.tga")
        self.Base.SetParent(self)
        self.Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Base.Show()

    def __del__(self):
        Window.__del__(self)

    def SetSize(self, width, height):

        width = max(self.CORNER_WIDTH*2, width)
        height = max(self.CORNER_HEIGHT*2, height)
        Window.SetSize(self, width, height)

        self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
        self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
        self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
        self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
        self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)

        verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
        horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
        self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
        self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
        self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)

        if self.Base:
            self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)

############## NOWE OKNO #############

class ScrollBar(Window):

    SCROLLBAR_WIDTH = 17
    SCROLLBAR_MIDDLE_HEIGHT = 1
    SCROLLBAR_BUTTON_WIDTH = 17
    SCROLLBAR_BUTTON_HEIGHT = 17
    MIDDLE_BAR_POS = 5
    MIDDLE_BAR_UPPER_PLACE = 3
    MIDDLE_BAR_DOWNER_PLACE = 4
    TEMP_SPACE = MIDDLE_BAR_UPPER_PLACE + MIDDLE_BAR_DOWNER_PLACE

    class MiddleBar(DragButton):
        def __init__(self):
            DragButton.__init__(self)
            self.AddFlag("movable")
            #self.AddFlag("restrict_x")

        def MakeImage(self):
            top = ImageBox()
            top.SetParent(self)
            top.LoadImage("illumina/scrollbar/scroll_top.tga")
            top.SetPosition(0, 0)
            top.AddFlag("not_pick")
            top.Show()
            bottom = ImageBox()
            bottom.SetParent(self)
            bottom.LoadImage("illumina/scrollbar/scroll_bottom.tga")
            bottom.AddFlag("not_pick")
            bottom.Show()

            middle = ExpandedImageBox()
            middle.SetParent(self)
            middle.LoadImage("illumina/scrollbar/scroll_middle.tga")
            middle.SetPosition(0, 4)
            middle.AddFlag("not_pick")
            middle.Show()

            self.top = top
            self.bottom = bottom
            self.middle = middle

        def SetSize(self, height):
            height = max(12, height)
            DragButton.SetSize(self, 10, height)
            self.bottom.SetPosition(0, height-4)

            height -= 4*2
            self.middle.SetRenderingRect(0, 0, 0, float(height)/1.0)

    def __init__(self):
        Window.__init__(self)

        self.pageSize = 1
        self.curPos = 0.0
        self.eventScroll = lambda *arg: None
        self.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None
        self.lockFlag = FALSE

        self.CreateScrollBar()

    def __del__(self):
        Window.__del__(self)

    def CreateScrollBar(self):
        barSlot = Bar3D()
        barSlot.SetParent(self)
        barSlot.AddFlag("not_pick")
        barSlot.Show()

        middleBar = self.MiddleBar()
        middleBar.SetParent(self)
        middleBar.SetMoveEvent(__mem_func__(self.OnMove))
        middleBar.Show()
        middleBar.MakeImage()
        middleBar.SetSize(12)

        upButton = Button()
        upButton.SetParent(self)
        upButton.SetEvent(__mem_func__(self.OnUp))
        upButton.SetUpVisual("illumina/buttons/btn_up_n.tga")
        upButton.SetOverVisual("illumina/buttons/btn_up_h.tga")
        upButton.SetDownVisual("illumina/buttons/btn_up_a.tga")
        upButton.Show()

        downButton = Button()
        downButton.SetParent(self)
        downButton.SetEvent(__mem_func__(self.OnDown))
        downButton.SetUpVisual("illumina/buttons/btn_down_n.tga")
        downButton.SetOverVisual("illumina/buttons/btn_down_h.tga")
        downButton.SetDownVisual("illumina/buttons/btn_down_a.tga")
        downButton.Show()

        self.upButton = upButton
        self.downButton = downButton
        self.middleBar = middleBar
        self.barSlot = barSlot

        self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
        self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()

    def Destroy(self):
        self.middleBar = None
        self.upButton = None
        self.downButton = None
        self.eventScroll = lambda *arg: None
        self.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None

    def SetScrollEvent(self, event):
        self.eventScroll = event
        self.eventScrollUp = event
        self.eventScrollDown = event

    def SetUpEvent(self, event):
        self.eventScrollUp = event

    def SetDownEvent(self, event):
        self.eventScrollDown = event

    def SetMiddleBarSize(self, pageScale):
        realHeight = self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2
        self.SCROLLBAR_MIDDLE_HEIGHT = int(pageScale * float(realHeight))
        self.middleBar.SetSize(self.SCROLLBAR_MIDDLE_HEIGHT)
        self.pageSize = (self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)

    def SetScrollBarSize(self, height):
        self.pageSize = (height - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
        self.SetSize(self.SCROLLBAR_WIDTH, height)
        self.upButton.SetPosition(0, 0)
        self.downButton.SetPosition(0, height - self.SCROLLBAR_BUTTON_HEIGHT)
        self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE, self.MIDDLE_BAR_POS+2, height - self.SCROLLBAR_BUTTON_HEIGHT*2 - self.TEMP_SPACE)
        self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)

        self.UpdateBarSlot()

    def UpdateBarSlot(self):
        self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
        self.barSlot.SetSize(self.GetWidth() - 2, self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2)

    def GetPos(self):
        return self.curPos

    def SetPos(self, pos, event=TRUE):
        pos = max(0.0, pos)
        pos = min(1.0, pos)

        newPos = float(self.pageSize) * pos
        self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos) + self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE)

        self.OnMove(event)

    def SetScrollStep(self, step):
        self.scrollStep = step

    def OnUp(self):
        self.SetPos(self.curPos-self.scrollStep, FALSE)
        self.eventScrollUp()

    def OnDown(self):
        self.SetPos(self.curPos+self.scrollStep, FALSE)
        self.eventScrollDown()

    def OnMove(self, event=TRUE):

        if self.lockFlag:
            return

        if 0 == self.pageSize:
            return

        (xLocal, yLocal) = self.middleBar.GetLocalPosition()
        self.curPos = float(yLocal - self.SCROLLBAR_BUTTON_HEIGHT - self.MIDDLE_BAR_UPPER_PLACE) / float(self.pageSize)
        if event == TRUE:
            self.eventScroll()

    def OnMouseLeftButtonDown(self):
        (xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
        pickedPos = yMouseLocalPosition - self.SCROLLBAR_BUTTON_HEIGHT - self.SCROLLBAR_MIDDLE_HEIGHT/2
        newPos = float(pickedPos) / float(self.pageSize)
        self.SetPos(newPos)

    def LockScroll(self):
        self.lockFlag = TRUE

    def UnlockScroll(self):
        self.lockFlag = FALSE

class ThinScrollBar(ScrollBar):

    def CreateScrollBar(self):
        middleBar = self.MiddleBar()
        middleBar.SetParent(self)
        middleBar.SetMoveEvent(__mem_func__(self.OnMove))
        middleBar.Show()
        middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_01.sub")
        middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_02.sub")
        middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_03.sub")

        upButton = Button()
        upButton.SetParent(self)
        upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_01.sub")
        upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_02.sub")
        upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_03.sub")
        upButton.SetEvent(__mem_func__(self.OnUp))
        upButton.Show()

        downButton = Button()
        downButton.SetParent(self)
        downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_01.sub")
        downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_02.sub")
        downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_03.sub")
        downButton.SetEvent(__mem_func__(self.OnDown))
        downButton.Show()

        self.middleBar = middleBar
        self.upButton = upButton
        self.downButton = downButton

        self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
        self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
        self.MIDDLE_BAR_POS = 0
        self.MIDDLE_BAR_UPPER_PLACE = 0
        self.MIDDLE_BAR_DOWNER_PLACE = 0
        self.TEMP_SPACE = 0

    def UpdateBarSlot(self):
        pass

class SmallThinScrollBar(ScrollBar):

    def CreateScrollBar(self):
        middleBar = self.MiddleBar()
        middleBar.SetParent(self)
        middleBar.SetMoveEvent(__mem_func__(self.OnMove))
        middleBar.Show()
        middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
        middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
        middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")

        upButton = Button()
        upButton.SetParent(self)
        upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_01.sub")
        upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_02.sub")
        upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_03.sub")
        upButton.SetEvent(__mem_func__(self.OnUp))
        upButton.Show()

        downButton = Button()
        downButton.SetParent(self)
        downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_01.sub")
        downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_02.sub")
        downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_03.sub")
        downButton.SetEvent(__mem_func__(self.OnDown))
        downButton.Show()

        self.middleBar = middleBar
        self.upButton = upButton
        self.downButton = downButton

        self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
        self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
        self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
        self.MIDDLE_BAR_POS = 0
        self.MIDDLE_BAR_UPPER_PLACE = 0
        self.MIDDLE_BAR_DOWNER_PLACE = 0
        self.TEMP_SPACE = 0

    def UpdateBarSlot(self):
        pass

class SliderBar(Window):

    def __init__(self):
        Window.__init__(self)

        self.curPos = 1.0
        self.pageSize = 1.0
        self.eventChange = None

        self.__CreateBackGroundImage()
        self.__CreateCursor()

    def __del__(self):
        Window.__del__(self)

    def __CreateBackGroundImage(self):
        img = ImageBox()
        img.SetParent(self)
        img.LoadImage("d:/ymir work/ui/game/windows/sliderbar.sub")
        img.Show()
        self.backGroundImage = img

        ##
        self.SetSize(self.backGroundImage.GetWidth(), self.backGroundImage.GetHeight())

    def __CreateCursor(self):
        cursor = DragButton()
        cursor.AddFlag("movable")
        cursor.AddFlag("restrict_y")
        cursor.SetParent(self)
        cursor.SetMoveEvent(__mem_func__(self.__OnMove))
        cursor.SetUpVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
        cursor.SetOverVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
        cursor.SetDownVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
        cursor.Show()
        self.cursor = cursor

        ##
        self.cursor.SetRestrictMovementArea(0, 0, self.backGroundImage.GetWidth(), 0)
        self.pageSize = self.backGroundImage.GetWidth() - self.cursor.GetWidth()

    def __OnMove(self):
        (xLocal, yLocal) = self.cursor.GetLocalPosition()
        self.curPos = float(xLocal) / float(self.pageSize)

        if self.eventChange:
            self.eventChange()

    def SetSliderPos(self, pos):
        self.curPos = pos
        self.cursor.SetPosition(int(self.pageSize * pos), 0)

    def GetSliderPos(self):
        return self.curPos

    def SetEvent(self, event):
        self.eventChange = event

    def Enable(self):
        self.cursor.Show()

    def Disable(self):
        self.cursor.Hide()

class ListBox(Window):

    TEMPORARY_PLACE = 3

    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)
        self.overLine = -1
        self.selectedLine = -1
        self.width = 0
        self.height = 0
        self.stepSize = 17
        self.basePos = 0
        self.showLineCount = 0
        self.itemCenterAlign = TRUE
        self.itemList = []
        self.keyDict = {}
        self.textDict = {}
        self.event = lambda *arg: None
    def __del__(self):
        Window.__del__(self)

    def SetWidth(self, width):
        self.SetSize(width, self.height)

    def SetSize(self, width, height):
        Window.SetSize(self, width, height)
        self.width = width
        self.height = height

    def SetTextCenterAlign(self, flag):
        self.itemCenterAlign = flag

    def SetBasePos(self, pos):
        self.basePos = pos
        self._LocateItem()

    def ClearItem(self):
        self.keyDict = {}
        self.textDict = {}
        self.itemList = []
        self.overLine = -1
        self.selectedLine = -1

    def InsertItem(self, number, text):
        self.keyDict[len(self.itemList)] = number
        self.textDict[len(self.itemList)] = text

        textLine = TextLine()
        textLine.SetParent(self)
        textLine.SetText(text)
        textLine.Show()

        if self.itemCenterAlign:
            textLine.SetWindowHorizontalAlignCenter()
            textLine.SetHorizontalAlignCenter()

        self.itemList.append(textLine)

        self._LocateItem()

    def ChangeItem(self, number, text):
        for key, value in self.keyDict.items():
            if value == number:
                self.textDict[key] = text

                if number < len(self.itemList):
                    self.itemList[key].SetText(text)

                return

    def LocateItem(self):
        self._LocateItem()

    def _LocateItem(self):

        skipCount = self.basePos
        yPos = 0
        self.showLineCount = 0

        for textLine in self.itemList:
            textLine.Hide()

            if skipCount > 0:
                skipCount -= 1
                continue

            textLine.SetPosition(0, yPos + 3)

            yPos += self.stepSize

            if yPos <= self.GetHeight():
                self.showLineCount += 1
                textLine.Show()

    def ArrangeItem(self):
        self.SetSize(self.width, len(self.itemList) * self.stepSize)
        self._LocateItem()

    def GetViewItemCount(self):
        return int(self.GetHeight() / self.stepSize)

    def GetItemCount(self):
        return len(self.itemList)

    def SetEvent(self, event):
        self.event = event

    def SelectItem(self, line):

        if not self.keyDict.has_key(line):
            return

        if line == self.selectedLine:
            return

        self.selectedLine = line
        self.event(self.keyDict.get(line, 0), self.textDict.get(line, "None"))

    def GetSelectedItem(self):
        return self.keyDict.get(self.selectedLine, 0)

    def OnMouseLeftButtonDown(self):
        if self.overLine < 0:
            return

    def OnMouseLeftButtonUp(self):
        if self.overLine >= 0:
            self.SelectItem(self.overLine+self.basePos)

    def OnUpdate(self):

        self.overLine = -1

        if self.IsIn():
            x, y = self.GetGlobalPosition()
            height = self.GetHeight()
            xMouse, yMouse = wndMgr.GetMousePosition()

            if yMouse - y < height - 1:
                self.overLine = (yMouse - y) / self.stepSize

                if self.overLine < 0:
                    self.overLine = -1
                if self.overLine >= len(self.itemList):
                    self.overLine = -1

    def OnRender(self):
        xRender, yRender = self.GetGlobalPosition()
        yRender -= self.TEMPORARY_PLACE
        widthRender = self.width
        heightRender = self.height + self.TEMPORARY_PLACE*2

        if localeinfo.IsCIBN10:
            if -1 != self.overLine and self.keyDict[self.overLine] != -1:
                grp.SetColor(HALF_WHITE_COLOR)
                grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)

            if -1 != self.selectedLine and self.keyDict[self.selectedLine] != -1:
                if self.selectedLine >= self.basePos:
                    if self.selectedLine - self.basePos < self.showLineCount:
                        grp.SetColor(SELECT_COLOR)
                        grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)

        else:
            if -1 != self.overLine:
                grp.SetColor(HALF_WHITE_COLOR)
                grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)

            if -1 != self.selectedLine:
                if self.selectedLine >= self.basePos:
                    if self.selectedLine - self.basePos < self.showLineCount:
                        grp.SetColor(SELECT_COLOR)
                        grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)



class ListBox2(ListBox):
    def __init__(self, *args, **kwargs):
        ListBox.__init__(self, *args, **kwargs)
        self.rowCount = 10
        self.barWidth = 0
        self.colCount = 0

    def SetRowCount(self, rowCount):
        self.rowCount = rowCount

    def SetSize(self, width, height):
        ListBox.SetSize(self, width, height)
        self._RefreshForm()

    def ClearItem(self):
        ListBox.ClearItem(self)
        self._RefreshForm()

    def InsertItem(self, *args, **kwargs):
        ListBox.InsertItem(self, *args, **kwargs)
        self._RefreshForm()

    def OnUpdate(self):
        mpos = wndMgr.GetMousePosition()
        self.overLine = self._CalcPointIndex(mpos)

    def OnRender(self):
        x, y = self.GetGlobalPosition()
        pos = (x + 2, y)

        if -1 != self.overLine:
            grp.SetColor(HALF_WHITE_COLOR)
            self._RenderBar(pos, self.overLine)

        if -1 != self.selectedLine:
            if self.selectedLine >= self.basePos:
                if self.selectedLine - self.basePos < self.showLineCount:
                    grp.SetColor(SELECT_COLOR)
                    self._RenderBar(pos, self.selectedLine-self.basePos)



    def _CalcPointIndex(self, mpos):
        if self.IsIn():
            px, py = mpos
            gx, gy = self.GetGlobalPosition()
            lx, ly = px - gx, py - gy

            col = lx / self.barWidth
            row = ly / self.stepSize
            idx = col * self.rowCount + row
            if col >= 0 and col < self.colCount:
                if row >= 0 and row < self.rowCount:
                    if idx >= 0 and idx < len(self.itemList):
                        return idx

        return -1

    def _CalcRenderPos(self, pos, idx):
        x, y = pos
        row = idx % self.rowCount
        col = idx / self.rowCount
        return (x + col * self.barWidth, y + row * self.stepSize)

    def _RenderBar(self, basePos, idx):
        x, y = self._CalcRenderPos(basePos, idx)
        grp.RenderBar(x, y, self.barWidth - 3, self.stepSize)

    def _LocateItem(self):
        pos = (0, self.TEMPORARY_PLACE)

        self.showLineCount = 0
        for textLine in self.itemList:
            x, y = self._CalcRenderPos(pos, self.showLineCount)
            textLine.SetPosition(x, y)
            textLine.Show()

            self.showLineCount += 1

    def _RefreshForm(self):
        if len(self.itemList) % self.rowCount:
            self.colCount = len(self.itemList) / self.rowCount + 1
        else:
            self.colCount = len(self.itemList) / self.rowCount

        if self.colCount:
            self.barWidth = self.width / self.colCount
        else:
            self.barWidth = self.width


class ComboBox(Window):

    class ListBoxWithBoard(ListBox):

        def __init__(self, layer):
            ListBox.__init__(self, layer)

        def OnRender(self):
            xRender, yRender = self.GetGlobalPosition()
            yRender -= self.TEMPORARY_PLACE
            widthRender = self.width
            heightRender = self.height + self.TEMPORARY_PLACE*2
            grp.SetColor(BACKGROUND_COLOR)
            grp.RenderBar(xRender, yRender, widthRender, heightRender)
            grp.SetColor(DARK_COLOR)
            grp.RenderLine(xRender, yRender, widthRender, 0)
            grp.RenderLine(xRender, yRender, 0, heightRender)
            grp.SetColor(BRIGHT_COLOR)
            grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
            grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)

            ListBox.OnRender(self)

    def __init__(self):
        Window.__init__(self)
        self.x = 0
        self.y = 0
        self.width = 0
        self.height = 0
        self.isSelected = FALSE
        self.isOver = FALSE
        self.isListOpened = FALSE
        self.event = lambda *arg: None
        self.enable = TRUE

        self.textLine = MakeTextLine(self)
        self.textLine.SetText(localeinfo.UI_ITEM)

        self.listBox = self.ListBoxWithBoard("TOP_MOST")
        self.listBox.SetPickAlways()
        self.listBox.SetParent(self)
        self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
        self.listBox.Hide()

    def __del__(self):
        Window.__del__(self)

    def Destroy(self):
        self.textLine = None
        self.listBox = None

    def SetPosition(self, x, y):
        Window.SetPosition(self, x, y)
        self.x = x
        self.y = y
        self.__ArrangeListBox()

    def SetSize(self, width, height):
        Window.SetSize(self, width, height)
        self.width = width
        self.height = height
        self.textLine.UpdateRect()
        self.__ArrangeListBox()

    def __ArrangeListBox(self):
        self.listBox.SetPosition(0, self.height + 5)
        self.listBox.SetWidth(self.width)

    def Enable(self):
        self.enable = TRUE

    def Disable(self):
        self.enable = FALSE
        self.textLine.SetText("")
        self.CloseListBox()

    def SetEvent(self, event):
        self.event = event

    def ClearItem(self):
        self.CloseListBox()
        self.listBox.ClearItem()

    def InsertItem(self, index, name):
        self.listBox.InsertItem(index, name)
        self.listBox.ArrangeItem()

    def SetCurrentItem(self, text):
        self.textLine.SetText(text)

    def SelectItem(self, key):
        self.listBox.SelectItem(key)

    def OnSelectItem(self, index, name):

        self.CloseListBox()
        self.event(index)

    def CloseListBox(self):
        self.isListOpened = FALSE
        self.listBox.Hide()

    def OnMouseLeftButtonDown(self):

        if not self.enable:
            return

        self.isSelected = TRUE

    def OnMouseLeftButtonUp(self):

        if not self.enable:
            return

        self.isSelected = FALSE

        if self.isListOpened:
            self.CloseListBox()
        else:
            if self.listBox.GetItemCount() > 0:
                self.isListOpened = TRUE
                self.listBox.Show()
                self.__ArrangeListBox()

    def OnUpdate(self):

        if not self.enable:
            return

        if self.IsIn():
            self.isOver = TRUE
        else:
            self.isOver = FALSE

    def OnRender(self):
        self.x, self.y = self.GetGlobalPosition()
        xRender = self.x
        yRender = self.y
        widthRender = self.width
        heightRender = self.height
        grp.SetColor(BACKGROUND_COLOR)
        grp.RenderBar(xRender, yRender, widthRender, heightRender)
        grp.SetColor(DARK_COLOR)
        grp.RenderLine(xRender, yRender, widthRender, 0)
        grp.RenderLine(xRender, yRender, 0, heightRender)
        grp.SetColor(BRIGHT_COLOR)
        grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
        grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)

        if self.isOver:
            grp.SetColor(HALF_WHITE_COLOR)
            grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)

            if self.isSelected:
                grp.SetColor(WHITE_COLOR)
                grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)

###################################################################################################
## Python Script Loader
###################################################################################################

class ScriptWindow(Window):
    def __init__(self, layer = "UI"):
        Window.__init__(self, layer)
        self.Children = []
        self.ElementDictionary = {}
    def __del__(self):
        Window.__del__(self)

    def ClearDictionary(self):
        self.Children = []
        self.ElementDictionary = {}
    def InsertChild(self, name, child):
        self.ElementDictionary[name] = child

    def IsChild(self, name):
        return self.ElementDictionary.has_key(name)
    def GetChild(self, name):
        return self.ElementDictionary[name]

    def GetChild2(self, name):
        return self.ElementDictionary.get(name, None)

class PythonScriptLoader(object):

    BODY_KEY_LIST = ( "x", "y", "width", "height" )

    VERTICAL_SEPARATOR_KEY_LIST = ("height", )
    HORIZONTAL_SEPARATOR_KEY_LIST = ("width", )

    #####

    DEFAULT_KEY_LIST = ( "type", "x", "y", )
    WINDOW_KEY_LIST = ( "width", "height", )
    IMAGE_KEY_LIST = ( "image", )
    EXPANDED_IMAGE_KEY_LIST = ( "image", )
    ANI_IMAGE_KEY_LIST = ( "images", )
    SLOT_KEY_LIST = ( "width", "height", "slot", )
    CANDIDATE_LIST_KEY_LIST = ( "item_step", "item_xsize", "item_ysize", )
    GRID_TABLE_KEY_LIST = ( "start_index", "x_count", "y_count", "x_step", "y_step", )
    EDIT_LINE_KEY_LIST = ( "width", "height", "input_limit", )
    COMBO_BOX_KEY_LIST = ( "width", "height", "item", )
    TITLE_BAR_KEY_LIST = ( "width", )
    HORIZONTAL_BAR_KEY_LIST = ( "width", )
    BOARD_KEY_LIST = ( "width", "height", )
    BOARD_WITH_TITLEBAR_KEY_LIST = ( "width", "height", "title", )
    BOX_KEY_LIST = ( "width", "height", )
    BAR_KEY_LIST = ( "width", "height", )
    LINE_KEY_LIST = ( "width", "height", )
    SLOTBAR_KEY_LIST = ( "width", "height", )
    GAUGE_KEY_LIST = ( "width", "color", )
    SCROLLBAR_KEY_LIST = ( "size", )
    LIST_BOX_KEY_LIST = ( "width", "height", )

    def __init__(self):
        self.Clear()

    def Clear(self):
        self.ScriptDictionary = { "SCREEN_WIDTH" : wndMgr.GetScreenWidth(), "SCREEN_HEIGHT" : wndMgr.GetScreenHeight() }
        self.InsertFunction = 0

    def LoadScriptFile(self, window, FileName):

        self.Clear()

        print "===== Load Script File : %s" % (FileName)

        try:
            execfile(FileName, self.ScriptDictionary)
        except:
            import dbg
            import exception
            dbg.TraceError("Failed to load script file : %s" % (FileName))
            exception.Abort("LoadScriptFile")

        #####

        Body = self.ScriptDictionary["window"]
        self.CheckKeyList("window", Body, self.BODY_KEY_LIST)

        window.ClearDictionary()
        self.InsertFunction = window.InsertChild

        window.SetPosition(int(Body["x"]), int(Body["y"]))

        window.SetSize(int(Body["width"]), int(Body["height"]))
        if TRUE == Body.has_key("style"):
            for StyleList in Body["style"]:
                window.AddFlag(StyleList)


        self.LoadChildren(window, Body)

    def LoadChildren(self, parent, dicChildren):

        if TRUE == dicChildren.has_key("style"):
            for style in dicChildren["style"]:
                parent.AddFlag(style)

        if FALSE == dicChildren.has_key("children"):
            return FALSE

        Index = 0

        ChildrenList = dicChildren["children"]
        parent.Children = range(len(ChildrenList))
        for ElementValue in ChildrenList:
            try:
                Name = ElementValue["name"]
            except KeyError:
                Name = ElementValue["name"] = "NONAME"

            try:
                Type = ElementValue["type"]
            except KeyError:
                Type = ElementValue["type"] = "window"

            if FALSE == self.CheckKeyList(Name, ElementValue, self.DEFAULT_KEY_LIST):
                del parent.Children[Index]
                continue

            elif Type == "verticalseparator":
                parent.Children[Index] = VerticalSeparator()
                parent.Children[Index].SetParent(parent)
                self.LoadElementVerticalSeparator(parent.Children[Index], ElementValue, parent)

            elif Type == "horizontalseparator":
                parent.Children[Index] = HorizontalSeparator()
                parent.Children[Index].SetParent(parent)
                self.LoadElementHorizontalSeparator(parent.Children[Index], ElementValue, parent)

            if Type == "window":
                parent.Children[Index] = ScriptWindow()
                parent.Children[Index].SetParent(parent)
                self.LoadElementWindow(parent.Children[Index], ElementValue, parent)

            elif Type == "button":
                parent.Children[Index] = Button()
                parent.Children[Index].SetParent(parent)
                self.LoadElementButton(parent.Children[Index], ElementValue, parent)

            elif Type == "radio_button":
                parent.Children[Index] = RadioButton()
                parent.Children[Index].SetParent(parent)
                self.LoadElementButton(parent.Children[Index], ElementValue, parent)

            elif Type == "toggle_button":
                parent.Children[Index] = ToggleButton()
                parent.Children[Index].SetParent(parent)
                self.LoadElementButton(parent.Children[Index], ElementValue, parent)

            elif Type == "mark":
                parent.Children[Index] = MarkBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementMark(parent.Children[Index], ElementValue, parent)

            elif Type == "image":
                parent.Children[Index] = ImageBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementImage(parent.Children[Index], ElementValue, parent)

            elif Type == "expanded_image":
                parent.Children[Index] = ExpandedImageBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementExpandedImage(parent.Children[Index], ElementValue, parent)

            elif Type == "ani_image":
                parent.Children[Index] = AniImageBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementAniImage(parent.Children[Index], ElementValue, parent)

            elif Type == "slot":
                parent.Children[Index] = SlotWindow()
                parent.Children[Index].SetParent(parent)
                self.LoadElementSlot(parent.Children[Index], ElementValue, parent)

            elif Type == "candidate_list":
                parent.Children[Index] = CandidateListBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementCandidateList(parent.Children[Index], ElementValue, parent)

            elif Type == "grid_table":
                parent.Children[Index] = GridSlotWindow()
                parent.Children[Index].SetParent(parent)
                self.LoadElementGridTable(parent.Children[Index], ElementValue, parent)

            elif Type == "text":
                parent.Children[Index] = TextLine()
                parent.Children[Index].SetParent(parent)
                self.LoadElementText(parent.Children[Index], ElementValue, parent)

            elif Type == "editline":
                parent.Children[Index] = EditLine()
                parent.Children[Index].SetParent(parent)
                self.LoadElementEditLine(parent.Children[Index], ElementValue, parent)

            elif Type == "titlebar":
                parent.Children[Index] = TitleBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementTitleBar(parent.Children[Index], ElementValue, parent)

            elif Type == "horizontalbar":
                parent.Children[Index] = HorizontalBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementHorizontalBar(parent.Children[Index], ElementValue, parent)

            elif Type == "board":
                parent.Children[Index] = Board()
                parent.Children[Index].SetParent(parent)
                self.LoadElementBoard(parent.Children[Index], ElementValue, parent)

            elif Type == "board_with_titlebar":
                parent.Children[Index] = BoardWithTitleBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementBoardWithTitleBar(parent.Children[Index], ElementValue, parent)

            elif Type == "thinboard":
                parent.Children[Index] = ThinBoard()
                parent.Children[Index].SetParent(parent)
                self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)

            elif Type == "thinboardnew":
                parent.Children[Index] = ThinBoardNew()
                parent.Children[Index].SetParent(parent)
                self.LoadElementThinBoardNew(parent.Children[Index], ElementValue, parent)

            elif Type == "box":
                parent.Children[Index] = Box()
                parent.Children[Index].SetParent(parent)
                self.LoadElementBox(parent.Children[Index], ElementValue, parent)

            elif Type == "bar":
                parent.Children[Index] = Bar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementBar(parent.Children[Index], ElementValue, parent)

            elif Type == "line":
                parent.Children[Index] = Line()
                parent.Children[Index].SetParent(parent)
                self.LoadElementLine(parent.Children[Index], ElementValue, parent)

            elif Type == "slotbar":
                parent.Children[Index] = SlotBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementSlotBar(parent.Children[Index], ElementValue, parent)

            elif Type == "gauge":
                parent.Children[Index] = Gauge()
                parent.Children[Index].SetParent(parent)
                self.LoadElementGauge(parent.Children[Index], ElementValue, parent)

            elif Type == "scrollbar":
                parent.Children[Index] = ScrollBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)

            elif Type == "thin_scrollbar":
                parent.Children[Index] = ThinScrollBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)

            elif Type == "small_thin_scrollbar":
                parent.Children[Index] = SmallThinScrollBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)

            elif Type == "sliderbar":
                parent.Children[Index] = SliderBar()
                parent.Children[Index].SetParent(parent)
                self.LoadElementSliderBar(parent.Children[Index], ElementValue, parent)

            elif Type == "listbox":
                parent.Children[Index] = ListBox()
                parent.Children[Index].SetParent(parent)
                self.LoadElementListBox(parent.Children[Index], ElementValue, parent)

            elif Type == "listbox2":
                parent.Children[Index] = ListBox2()
                parent.Children[Index].SetParent(parent)
                self.LoadElementListBox2(parent.Children[Index], ElementValue, parent)
            elif Type == "listboxex":
                parent.Children[Index] = ListBoxEx()
                parent.Children[Index].SetParent(parent)
                self.LoadElementListBoxEx(parent.Children[Index], ElementValue, parent)

            else:
                Index += 1
                continue

            parent.Children[Index].SetWindowName(Name)
            if 0 != self.InsertFunction:
                self.InsertFunction(Name, parent.Children[Index])

            self.LoadChildren(parent.Children[Index], ElementValue)
            Index += 1

    def CheckKeyList(self, name, value, key_list):

        for DataKey in key_list:
            if FALSE == value.has_key(DataKey):
                print "Failed to find data key", "[" + name + "/" + DataKey + "]"
                return FALSE

        return TRUE

    def LoadDefaultData(self, window, value, parentWindow):
        loc_x = int(value["x"])
        loc_y = int(value["y"])
        if value.has_key("vertical_align"):
            if "center" == value["vertical_align"]:
                window.SetWindowVerticalAlignCenter()
            elif "bottom" == value["vertical_align"]:
                window.SetWindowVerticalAlignBottom()

        if parentWindow.IsRTL():
            loc_x = int(value["x"]) + window.GetWidth()
            if value.has_key("horizontal_align"):
                if "center" == value["horizontal_align"]:
                    window.SetWindowHorizontalAlignCenter()
                    loc_x = - int(value["x"])
                elif "right" == value["horizontal_align"]:
                    window.SetWindowHorizontalAlignLeft()
                    loc_x = int(value["x"]) - window.GetWidth()
                    ## loc_x = parentWindow.GetWidth() - int(value["x"]) + window.GetWidth()
            else:
                window.SetWindowHorizontalAlignRight()

            if value.has_key("all_align"):
                window.SetWindowVerticalAlignCenter()
                window.SetWindowHorizontalAlignCenter()
                loc_x = - int(value["x"])
        else:
            if value.has_key("horizontal_align"):
                if "center" == value["horizontal_align"]:
                    window.SetWindowHorizontalAlignCenter()
                elif "right" == value["horizontal_align"]:
                    window.SetWindowHorizontalAlignRight()

        window.SetPosition(loc_x, loc_y)
        window.Show()

    ## Window
    def LoadElementWindow(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.WINDOW_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Button
    def LoadElementButton(self, window, value, parentWindow):

        if value.has_key("width") and value.has_key("height"):
            window.SetSize(int(value["width"]), int(value["height"]))

        if TRUE == value.has_key("default_image"):
            window.SetUpVisual(value["default_image"])
        if TRUE == value.has_key("over_image"):
            window.SetOverVisual(value["over_image"])
        if TRUE == value.has_key("down_image"):
            window.SetDownVisual(value["down_image"])
        if TRUE == value.has_key("disable_image"):
            window.SetDisableVisual(value["disable_image"])

        if TRUE == value.has_key("text"):
            if TRUE == value.has_key("text_height"):
                window.SetText(value["text"], value["text_height"])
            else:
                window.SetText(value["text"])

            if value.has_key("text_color"):
                window.SetTextColor(value["text_color"])

        if TRUE == value.has_key("tooltip_text"):
            if TRUE == value.has_key("tooltip_x") and TRUE == value.has_key("tooltip_y"):
                window.SetToolTipText(value["tooltip_text"], int(value["tooltip_x"]), int(value["tooltip_y"]))
            else:
                window.SetToolTipText(value["tooltip_text"])

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE


    def LoadElementVerticalSeparator(self, window, value, parentWindow):
        if FALSE == self.CheckKeyList(value["name"], value, self.VERTICAL_SEPARATOR_KEY_LIST):
            return FALSE

        window.SetHeight(int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    def LoadElementHorizontalSeparator(self, window, value, parentWindow):
        if FALSE == self.CheckKeyList(value["name"], value, self.HORIZONTAL_SEPARATOR_KEY_LIST):
            return FALSE

        window.SetWidth(int(value["width"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Mark
    def LoadElementMark(self, window, value, parentWindow):

        #if FALSE == self.CheckKeyList(value["name"], value, self.MARK_KEY_LIST):
        #   return FALSE

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Image
    def LoadElementImage(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.IMAGE_KEY_LIST):
            return FALSE

        window.LoadImage(value["image"])
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## AniImage
    def LoadElementAniImage(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.ANI_IMAGE_KEY_LIST):
            return FALSE

        if TRUE == value.has_key("delay"):
            window.SetDelay(value["delay"])

        if TRUE == value.has_key("x_scale") and TRUE == value.has_key("y_scale"):
            for image in value["images"]:
                window.AppendImageScale(image, float(value["x_scale"]), float(value["y_scale"]))
        else:
            for image in value["images"]:
                window.AppendImage(image)

        if value.has_key("width") and value.has_key("height"):
            window.SetSize(value["width"], value["height"])

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Expanded Image
    def LoadElementExpandedImage(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.EXPANDED_IMAGE_KEY_LIST):
            return FALSE

        window.LoadImage(value["image"])

        if TRUE == value.has_key("x_origin") and TRUE == value.has_key("y_origin"):
            window.SetOrigin(float(value["x_origin"]), float(value["y_origin"]))

        if TRUE == value.has_key("x_scale") and TRUE == value.has_key("y_scale"):
            window.SetScale(float(value["x_scale"]), float(value["y_scale"]))

        if TRUE == value.has_key("rect"):
            RenderingRect = value["rect"]
            window.SetRenderingRect(RenderingRect[0], RenderingRect[1], RenderingRect[2], RenderingRect[3])

        if TRUE == value.has_key("mode"):
            mode = value["mode"]
            if "MODULATE" == mode:
                window.SetRenderingMode(wndMgr.RENDERING_MODE_MODULATE)

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Slot
    def LoadElementSlot(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.SLOT_KEY_LIST):
            return FALSE

        global_x = int(value["x"])
        global_y = int(value["y"])
        global_width = int(value["width"])
        global_height = int(value["height"])

        window.SetPosition(global_x, global_y)
        window.SetSize(global_width, global_height)
        window.Show()

        r = 1.0
        g = 1.0
        b = 1.0
        a = 1.0

        if TRUE == value.has_key("image_r") and \
            TRUE == value.has_key("image_g") and \
            TRUE == value.has_key("image_b") and \
            TRUE == value.has_key("image_a"):
            r = float(value["image_r"])
            g = float(value["image_g"])
            b = float(value["image_b"])
            a = float(value["image_a"])

        SLOT_ONE_KEY_LIST = ("index", "x", "y", "width", "height")

        for slot in value["slot"]:
            if TRUE == self.CheckKeyList(value["name"] + " - one", slot, SLOT_ONE_KEY_LIST):
                wndMgr.AppendSlot(window.hWnd,
                                    int(slot["index"]),
                                    int(slot["x"]),
                                    int(slot["y"]),
                                    int(slot["width"]),
                                    int(slot["height"]))

        if TRUE == value.has_key("image"):
            if TRUE == value.has_key("x_scale") and TRUE == value.has_key("y_scale"):
                wndMgr.SetSlotBaseImageScale(window.hWnd,
                                        value["image"],
                                        r, g, b, a, float(value["x_scale"]), float(value["y_scale"]))
            else:
                wndMgr.SetSlotBaseImage(window.hWnd,
                                        value["image"],
                                        r, g, b, a)

        return TRUE

    def LoadElementCandidateList(self, window, value, parentWindow):
        if FALSE == self.CheckKeyList(value["name"], value, self.CANDIDATE_LIST_KEY_LIST):
            return FALSE

        window.SetPosition(int(value["x"]), int(value["y"]))
        window.SetItemSize(int(value["item_xsize"]), int(value["item_ysize"]))
        window.SetItemStep(int(value["item_step"]))
        window.Show()

        return TRUE

    ## Table
    def LoadElementGridTable(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.GRID_TABLE_KEY_LIST):
            return FALSE

        xBlank = 0
        yBlank = 0
        if TRUE == value.has_key("x_blank"):
            xBlank = int(value["x_blank"])
        if TRUE == value.has_key("y_blank"):
            yBlank = int(value["y_blank"])

        window.SetPosition(int(value["x"]), int(value["y"]))

        window.ArrangeSlot( int(value["start_index"]),
                            int(value["x_count"]),
                            int(value["y_count"]),
                            int(value["x_step"]),
                            int(value["y_step"]),
                            xBlank,
                            yBlank)
        if TRUE == value.has_key("image"):
            r = 1.0
            g = 1.0
            b = 1.0
            a = 1.0
            if TRUE == value.has_key("image_r") and \
                TRUE == value.has_key("image_g") and \
                TRUE == value.has_key("image_b") and \
                TRUE == value.has_key("image_a"):
                r = float(value["image_r"])
                g = float(value["image_g"])
                b = float(value["image_b"])
                a = float(value["image_a"])
            wndMgr.SetSlotBaseImage(window.hWnd, value["image"], r, g, b, a)

        if TRUE == value.has_key("style"):
            if "select" == value["style"]:
                wndMgr.SetSlotStyle(window.hWnd, wndMgr.SLOT_STYLE_SELECT)
        window.Show()

        return TRUE

    ## Text
    def LoadElementText(self, window, value, parentWindow):

        if value.has_key("fontsize"):
            fontSize = value["fontsize"]

            if "LARGE" == fontSize:
                window.SetFontName(localeinfo.UI_DEF_FONT_LARGE)

        elif value.has_key("fontname"):
            fontName = value["fontname"]
            window.SetFontName(fontName)

        if value.has_key("text_horizontal_align"):
            if "left" == value["text_horizontal_align"]:
                window.SetHorizontalAlignLeft()
            elif "center" == value["text_horizontal_align"]:
                window.SetHorizontalAlignCenter()
            elif "right" == value["text_horizontal_align"]:
                window.SetHorizontalAlignRight()

        if value.has_key("text_vertical_align"):
            if "top" == value["text_vertical_align"]:
                window.SetVerticalAlignTop()
            elif "center" == value["text_vertical_align"]:
                window.SetVerticalAlignCenter()
            elif "bottom" == value["text_vertical_align"]:
                window.SetVerticalAlignBottom()

        if value.has_key("all_align"):
            window.SetHorizontalAlignCenter()
            window.SetVerticalAlignCenter()
            window.SetWindowHorizontalAlignCenter()
            window.SetWindowVerticalAlignCenter()

        if value.has_key("r") and value.has_key("g") and value.has_key("b"):
            window.SetFontColor(float(value["r"]), float(value["g"]), float(value["b"]))
        elif value.has_key("color"):
            window.SetPackedFontColor(value["color"])
        else:
            window.SetFontColor(0.8549, 0.8549, 0.8549)

        if value.has_key("outline"):
            if value["outline"]:
                window.SetOutline()
        if TRUE == value.has_key("text"):
            window.SetText(value["text"])

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## EditLine
    def LoadElementEditLine(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.EDIT_LINE_KEY_LIST):
            return FALSE


        if value.has_key("secret_flag"):
            window.SetSecret(value["secret_flag"])
        if value.has_key("with_codepage"):
            if value["with_codepage"]:
                window.bCodePage = TRUE
        if value.has_key("only_number"):
            if value["only_number"]:
                window.SetNumberMode()
        if value.has_key("enable_codepage"):
            window.SetIMEFlag(value["enable_codepage"])
        if value.has_key("enable_ime"):
            window.SetIMEFlag(value["enable_ime"])
        if value.has_key("limit_width"):
            window.SetLimitWidth(value["limit_width"])
        if value.has_key("multi_line"):
            if value["multi_line"]:
                window.SetMultiLine()

        window.SetMax(int(value["input_limit"]))
        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadElementText(window, value, parentWindow)

        return TRUE

    ## TitleBar
    def LoadElementTitleBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.TITLE_BAR_KEY_LIST):
            return FALSE

        window.MakeTitleBar(int(value["width"]), value.get("color", "red"))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## HorizontalBar
    def LoadElementHorizontalBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.HORIZONTAL_BAR_KEY_LIST):
            return FALSE

        window.Create(int(value["width"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Board
    def LoadElementBoard(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Board With TitleBar
    def LoadElementBoardWithTitleBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_WITH_TITLEBAR_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        window.SetTitleName(value["title"])
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## ThinBoard
    def LoadElementThinBoard(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## ThinBoardNew
    def LoadElementThinBoardNew(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Box
    def LoadElementBox(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BOX_KEY_LIST):
            return FALSE

        if TRUE == value.has_key("color"):
            window.SetColor(value["color"])

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Bar
    def LoadElementBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.BAR_KEY_LIST):
            return FALSE

        if TRUE == value.has_key("color"):
            window.SetColor(value["color"])

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Line
    def LoadElementLine(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.LINE_KEY_LIST):
            return FALSE

        if TRUE == value.has_key("color"):
            window.SetColor(value["color"])

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Slot
    def LoadElementSlotBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.SLOTBAR_KEY_LIST):
            return FALSE

        window.SetSize(int(value["width"]), int(value["height"]))
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## Gauge
    def LoadElementGauge(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.GAUGE_KEY_LIST):
            return FALSE

        window.MakeGauge(value["width"], value["color"])
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## ScrollBar
    def LoadElementScrollBar(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.SCROLLBAR_KEY_LIST):
            return FALSE

        window.SetScrollBarSize(value["size"])
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## SliderBar
    def LoadElementSliderBar(self, window, value, parentWindow):

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## ListBox
    def LoadElementListBox(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
            return FALSE

        if value.has_key("item_align"):
            window.SetTextCenterAlign(value["item_align"])

        window.SetSize(value["width"], value["height"])
        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

    ## ListBox2
    def LoadElementListBox2(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
            return FALSE

        window.SetRowCount(value.get("row_count", 10)) # 기본 세로 개수 10개
        window.SetSize(value["width"], value["height"])
        self.LoadDefaultData(window, value, parentWindow)

        if value.has_key("item_align"):
            window.SetTextCenterAlign(value["item_align"])

        return TRUE
    def LoadElementListBoxEx(self, window, value, parentWindow):

        if FALSE == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
            return FALSE

        window.SetSize(value["width"], value["height"])
        self.LoadDefaultData(window, value, parentWindow)

        if value.has_key("itemsize_x") and value.has_key("itemsize_y"):
            window.SetItemSize(int(value["itemsize_x"]), int(value["itemsize_y"]))

        if value.has_key("itemstep"):
            window.SetItemStep(int(value["itemstep"]))

        if value.has_key("viewcount"):
            window.SetViewItemCount(int(value["viewcount"]))

        return TRUE

class ReadingWnd(Bar):

    def __init__(self):
        Bar.__init__(self,"TOP_MOST")

        self.__BuildText()
        self.SetSize(80, 19)
        self.Show()

    def __del__(self):
        Bar.__del__(self)

    def __BuildText(self):
        self.text = TextLine()
        self.text.SetParent(self)
        self.text.SetPosition(4, 3)
        self.text.Show()

    def SetText(self, text):
        self.text.SetText(text)

    def SetReadingPosition(self, x, y):
        xPos = x + 2
        yPos = y  - self.GetHeight() - 2
        self.SetPosition(xPos, yPos)

    def SetTextColor(self, color):
        self.text.SetPackedFontColor(color)


def MakeSlotBar(parent, x, y, width, height):
    slotBar = SlotBar()
    slotBar.SetParent(parent)
    slotBar.SetSize(width, height)
    slotBar.SetPosition(x, y)
    slotBar.Show()
    return slotBar

def MakeImageBox(parent, name, x, y):
    image = ImageBox()
    image.SetParent(parent)
    image.LoadImage(name)
    image.SetPosition(x, y)
    image.Show()
    return image

def MakeTextLine(parent):
    textLine = TextLine()
    textLine.SetParent(parent)
    textLine.SetWindowHorizontalAlignCenter()
    textLine.SetWindowVerticalAlignCenter()
    textLine.SetHorizontalAlignCenter()
    textLine.SetVerticalAlignCenter()
    textLine.Show()
    return textLine

def MakeButton(parent, x, y, tooltipText, path, up, over, down):
    button = Button()
    button.SetParent(parent)
    button.SetPosition(x, y)
    button.SetUpVisual(path + up)
    button.SetOverVisual(path + over)
    button.SetDownVisual(path + down)
    button.SetToolTipText(tooltipText)
    button.Show()
    return button

def RenderRoundBox(x, y, width, height, color):
    grp.SetColor(color)
    grp.RenderLine(x+2, y, width-3, 0)
    grp.RenderLine(x+2, y+height, width-3, 0)
    grp.RenderLine(x, y+2, 0, height-4)
    grp.RenderLine(x+width, y+1, 0, height-3)
    grp.RenderLine(x, y+2, 2, -2)
    grp.RenderLine(x, y+height-2, 2, 2)
    grp.RenderLine(x+width-2, y, 2, 2)
    grp.RenderLine(x+width-2, y+height, 2, -2)

def GenerateColor(r, g, b):
    r = float(r) / 255.0
    g = float(g) / 255.0
    b = float(b) / 255.0
    return grp.GenerateColor(r, g, b, 1.0)

def EnablePaste(flag):
    ime.EnablePaste(flag)

def GetHyperlink():
    return wndMgr.GetHyperlink()

RegisterToolTipWindow("TEXT", TextLine)