Natox

Cause when i have 6 drop on metinstone if i have 2 skillbook (100%) with 4 objects 60 / 60 / 40 / 20 i not drop a skillbook or just 1

That's why I'm asking for this solution and it will allow me to have a better rate

Its not a 100% drop, so i want add a skillbook on C++ on metinstone

Hi guys,

I search for the code to add the drop skillbooks in the metins in c++

Thanks

up

Up

Hello guys,

I search a wing costum system for the sash system.

Exemple : We have a sash equiped and we can add a costum (Wing Plechito) on us

Thanks for your attention

Thanks for the reply, but i want on Map not minimap u see ?

Hi guys,

I'm looking for the "system" to show bosses on the big map (when you press ",") like npc

Thank you for your attention, waiting for your answer

Hi, u don't have a bonus elementary ?

Its good, thanks for your help bro

Hi @Asentrix, thanks for your reply.

I have this error now after adding the line like you told me

0810 21:03:21476 :: R :: AttributeError
0810 21:03:21476 :: R :: : 
0810 21:03:21476 :: R :: 'Button' object has no attribute 'SetOverEvent'

Hi,

I need your help, i have this problem with the bonus board..

Gif : https://metin2.download/picture/56PN2Dp504nSuqR6yv9jtq6jR233vkAv/.gif

ui.py

Quote

import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import petskill
import localeInfo
import dbg
import guild

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)

if localeInfo.IsCANADA():
    SELECT_COLOR = grp.GenerateColor(0.9, 0.03, 0.01, 0.4)
else:
    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)

## Window Manager Event List##
##############################
## "OnMouseLeftButtonDown"
## "OnMouseLeftButtonUp"
## "OnMouseLeftButtonDoubleClick"
## "OnMouseRightButtonDown"
## "OnMouseRightButtonUp"
## "OnMouseRightButtonDoubleClick"
## "OnMouseDrag"
## "OnSetFocus"
## "OnKillFocus"
## "OnMouseOverIn"
## "OnMouseOverOut"
## "OnRender"
## "OnUpdate"
## "OnKeyDown"
## "OnKeyUp"
## "OnTop"
## "OnIMEUpdate" ## IME Only
## "OnIMETab"    ## IME Only
## "OnIMEReturn" ## IME Only
##############################
## Window Manager Event List##

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.onMouseLeftButtonUpEvent = None
        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 GetWindowName(self):
        return wndMgr.GetName(self.hWnd)

    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 SetSlotCoolTimeColor(self, slotIndex, r, g, b, a):
        wndMgr.SetSlotCoolTimeColor(self.hWnd, slotIndex, r, g, b, a)

    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 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)

    def SetOnMouseLeftButtonUpEvent(self, event):
        self.onMouseLeftButtonUpEvent = event
        
    def OnMouseLeftButtonUp(self):
        if self.onMouseLeftButtonUpEvent:
            self.onMouseLeftButtonUpEvent()

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

        if localeInfo.IsARABIC():
            self.itemWidth=130
        else:
            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):
        if localeInfo.IsARABIC():
            return (self.GetWidth()-itemWidth-10, (pos-self.basePos)*self.itemStep)
        else:
            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 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={}
        self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
        self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}

    def __del__(self):
        Window.__del__(self)
        self.eventFunc = None
        self.eventArgs = None

    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)

    def SetEvent(self, func, *args) :
        result = self.eventFunc.has_key(args[0])
        if result :
            self.eventFunc[args[0]] = func
            self.eventArgs[args[0]] = args
        else :
            print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]

    def OnMouseLeftButtonUp(self) :
        if self.eventFunc["mouse_click"] :
            apply(self.eventFunc["mouse_click"], self.eventArgs["mouse_click"])

    def OnMouseOverIn(self) :
        if self.eventFunc["mouse_over_in"] :
            apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
        else:
            try:
                self.eventDict["MOUSE_OVER_IN"]()
            except KeyError:
                pass

    def OnMouseOverOut(self) :
        if self.eventFunc["mouse_over_out"] :
            apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
        else :
            try:
                self.eventDict["MOUSE_OVER_OUT"]()
            except KeyError:
                pass

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

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

    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):
        wndMgr.SetRotation(self.hWnd, rotation)

    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)

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
        self.overFunc = None
        self.overArgs = None
        self.overOutFunc = None
        self.overOutArgs = None

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

        self.eventFunc = None
        self.eventArgs = None
        self.overFunc = None
        self.overArgs = None
        self.overOutFunc = None
        self.overOutArgs = 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)

    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 OnMouseOverIn(self):
        if self.overFunc:
            apply(self.overFunc, self.overArgs )
    def OnMouseOverOut(self):
        if self.overOutFunc:
            apply(self.overOutFunc, self.overOutArgs )
    def SetOverEvent(self, func, *args):
        self.overFunc = func
        self.overArgs = args
    def SetOverOutEvent(self, func, *args):
        self.overOutFunc = func
        self.overOutArgs = args

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

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

class RadioButtonGroup:
    def __init__(self):
        self.buttonGroup = []
        self.selectedBtnIdx = -1
    
    def __del__(self):
        for button, ue, de in self.buttonGroup:
            button.__del__()
     
    def Show(self):
        for (button, selectEvent, unselectEvent) in self.buttonGroup:
            button.Show()
     
    def Hide(self):
        for (button, selectEvent, unselectEvent) in self.buttonGroup:
            button.Hide()
     
    def SetText(self, idx, text):
        if idx >= len(self.buttonGroup):
            return
        (button, selectEvent, unselectEvent) = self.buttonGroup[idx]
        button.SetText(text)
     
    def OnClick(self, btnIdx):
        if btnIdx == self.selectedBtnIdx:
            return
        (button, selectEvent, unselectEvent) = self.buttonGroup[self.selectedBtnIdx]
        if unselectEvent:
            unselectEvent()
        button.SetUp()
         
        self.selectedBtnIdx = btnIdx
        (button, selectEvent, unselectEvent) = self.buttonGroup[btnIdx]
        if selectEvent:
            selectEvent()

        button.Down()
         
    def AddButton(self, button, selectEvent, unselectEvent):
        i = len(self.buttonGroup)
        button.SetEvent(lambda : self.OnClick(i))
        self.buttonGroup.append([button, selectEvent, unselectEvent])
        button.SetUp()

    def Create(rawButtonGroup):
        radioGroup = RadioButtonGroup()
        for (button, selectEvent, unselectEvent) in rawButtonGroup:
            radioGroup.AddButton(button, selectEvent, unselectEvent)
        
        radioGroup.OnClick(0)
        
        return radioGroup
        
    Create=staticmethod(Create)

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.eventOverIn = None
        self.eventOverOut = None

        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.eventOverIn = None
        self.eventOverOut = None

        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="d:/ymir work/ui/public/slot_cover_button_01.sub",\
                        overName="d:/ymir work/ui/public/slot_cover_button_02.sub",\
                        downName="d:/ymir work/ui/public/slot_cover_button_03.sub",\
                        disableName="d:/ymir work/ui/public/slot_cover_button_04.sub",\
                        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)
    

    if app.ENABLE_ACCE_SYSTEM:
        def ActivateSlot(self, slotNumber, r = 1.0, g = 1.0, b = 1.0, a = 1.0):
            wndMgr.ActivateEffect(self.hWnd, slotNumber, r, g, b, a)

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

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

        def DeactivateSlotOld(self, slotNumber):
            wndMgr.DeactivateSlot(self.hWnd, slotNumber)
    else:
        def ActivateSlot(self, slotNumber):
            wndMgr.ActivateSlot(self.hWnd, slotNumber)

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

    
    # def ActivateAcceSlot(self, slotNumber):
        # wndMgr.ActivateAcceSlot(self.hWnd, slotNumber)

    # def DeactivateAcceSlot(self, slotNumber):
        # wndMgr.DeactivateAcceSlot(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 SetOverInEvent(self, event):
        self.eventOverIn = event

    def SetOverOutEvent(self, event):
        self.eventOverOut = event

    def OnOverIn(self, slotNumber):
        if self.eventOverIn:
            self.eventOverIn(slotNumber)

    def OnOverOut(self):
        if self.eventOverOut:
            self.eventOverOut()

    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
    if app.WJ_ENABLE_TRADABLE_ICON:
        def SetCanMouseEventSlot(self, slotIndex):
            wndMgr.SetCanMouseEventSlot(self.hWnd, slotIndex)

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

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

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

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

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

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

    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, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
        wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor)

    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, diffuseColor = (1.0, 1.0, 1.0, 1.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, diffuseColor)
        wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)

        #itemName=item.GetItemName().strip()
        #itemNameP=item.GetItemName().rfind('+')
        #if itemNameP>0 and len(itemName)>itemNameP+1:
        #    level=itemName[itemNameP+1:]
        #    if level.isdigit():
        #        wndMgr.SetSlotLevelImage(self.hWnd, renderingSlotNumber, ("icon/level/%d.tga"%int(level)))

    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 = 32
    BLOCK_HEIGHT = 23

    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()
        imgLeft.AddFlag("not_pick")
        imgCenter.AddFlag("not_pick")
        imgRight.AddFlag("not_pick")
        imgLeft.SetParent(self)
        imgCenter.SetParent(self)
        imgRight.SetParent(self)

        if localeInfo.IsARABIC():
            imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
            imgCenter.LoadImage("locale/ae/ui/pattern/titlebar_center.tga")
            imgRight.LoadImage("locale/ae/ui/pattern/titlebar_right.tga")
        else:
            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")

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

        btnClose = Button()
        btnClose.SetParent(self)
        btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
        btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
        btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
        btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -23)
        btnClose.Show()

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

        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)

        if localeInfo.IsARABIC():
            self.btnClose.SetPosition(3, 3)
        else:
            self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)
            
        self.SetSize(width, self.BLOCK_HEIGHT)

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

class HorizontalBar(Window):

    BLOCK_WIDTH = 32
    BLOCK_HEIGHT = 17

    def CloseButtonHide(self) :
        if localeInfo.IsARABIC():
            self.imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
            self.imgLeft.LeftRightReverse()
            self.btnClose.Hide()
        else:
            self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
            self.btnClose.Hide()

    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")

        if app.BL_PARTY_UPDATE:
            imgSlotLeft.AddFlag("not_pick")
            imgSlotCenter.AddFlag("not_pick")
            imgSlotRight.AddFlag("not_pick")
            imgGauge.AddFlag("not_pick")

        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)
        
    if app.BL_PARTY_UPDATE:    
        def GaugeImgBoxAddFlag(self, flag):
            self.imgLeft.AddFlag(flag)
            self.imgCenter.AddFlag(flag)
            self.imgRight.AddFlag(flag)
            self.imgGauge.AddFlag(flag)    

    if app.ENABLE_POISON_GAUGE_EFFECT:
        def SetGaugeColor(self, color):
            if self.imgGauge:
                self.imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga")

class Board(Window):

    CORNER_WIDTH = 32
    CORNER_HEIGHT = 32
    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()

    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)

class DynamicGauge (Gauge):
 
    dynamicGaugePerc =  None
    newGaugePerc =  0
 
    def  __init__(self):
        Gauge. __init__ (self)
 
    def  __del__ ( self
        Gauge. __del__ (self)
 
    def MakeGauge(self, width, color1, color2):
        Gauge.MakeGauge(self, width, color2)
        imgGauge2 = ExpandedImageBox()
        imgGauge2.SetParent(self)
        imgGauge2.LoadImage("d:/ymir work/ui/pattern/gauge_"  + color1 +  ".tga")
        imgGauge2.Show()
        imgGauge2.SetRenderingRect(0.0,0.0,0.0,0.0)
        imgGauge2.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0)
 
        self.imgGauge2 = imgGauge2
 
    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
       
        if self.dynamicGaugePerc == None:
            self.imgGauge.SetRenderingRect(0.0,0.0, (-1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE*2) * percentage / self.GAUGE_WIDTH), 0.0)
            self.dynamicGaugePerc = percentage
        elif self.dynamicGaugePerc + 0.2 < self.newGaugePerc:
            self.imgGauge.SetRenderingRect(0.0,0.0, (-1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE*2) * self.newGaugePerc / self.GAUGE_WIDTH), 0.0)
            self.dynamicGaugePerc = self.newGaugePerc
       
        self.newGaugePerc = percentage
        self.imgGauge2.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0)
        if percentage == 0:
            self.imgGauge.Hide()
        else:
            self.imgGauge.Show()
   
    def OnUpdate(self):
        if self.dynamicGaugePerc > self.newGaugePerc:
            self.dynamicGaugePerc = self.dynamicGaugePerc - 0.005
            self.imgGauge.SetRenderingRect(0.0,0.0, (-1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE * 2 ) * self.dynamicGaugePerc / self.GAUGE_WIDTH), 0.0)
        elif  self.dynamicGaugePerc <  self.newGaugePerc:
            self.dynamicGaugePerc = self.newGaugePerc
            self.imgGauge.SetRenderingRect(0.0,0.0, (-1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE * 2 ) * self.dynamicGaugePerc / self.GAUGE_WIDTH), 0.0)

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, 4)
        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 = 16
    CORNER_HEIGHT = 16
    LINE_WIDTH = 16
    LINE_HEIGHT = 16
    BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)

    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()

class ThinBoardGold(Window):
    CORNER_WIDTH = 16
    CORNER_HEIGHT = 16
    LINE_WIDTH = 16
    LINE_HEIGHT = 16
    BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)

    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/thinboardgold/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_gold", "LeftBottom_gold","RightTop_gold", "RightBottom_gold"]]
        LineFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Line_"+dir+".tga" for dir in ["Left_gold", "Right_gold", "Top_gold", "Bottom_gold"]]
        
        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 = ExpandedImageBox()
        Base.SetParent(self)
        Base.AddFlag("attach")
        Base.AddFlag("not_pick")
        Base.LoadImage("d:/ymir work/ui/pattern/thinboardgold/thinboard_bg_gold.tga")
        Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
        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)
        if self.Base:
            self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)

    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()

class ThinBoardCircle(Window):
    CORNER_WIDTH = 4
    CORNER_HEIGHT = 4
    LINE_WIDTH = 4
    LINE_HEIGHT = 4
    BOARD_COLOR = grp.GenerateColor(255.0, 255.0, 255.0, 1.0)

    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/thinboardcircle/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_circle","LeftBottom_circle","RightTop_circle","RightBottom_circle"] ]
        LineFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Line_"+dir+".tga" for dir in ["Left_circle","Right_circle","Top_circle","Bottom_circle"] ]

        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()

class ScrollBar(Window):

    SCROLLBAR_WIDTH = 17
    SCROLLBAR_MIDDLE_HEIGHT = 9
    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("d:/ymir work/ui/pattern/ScrollBar_Top.tga")
            top.SetPosition(0, 0)
            top.AddFlag("not_pick")
            top.Show()
            bottom = ImageBox()
            bottom.SetParent(self)
            bottom.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Bottom.tga")
            bottom.AddFlag("not_pick")
            bottom.Show()

            middle = ExpandedImageBox()
            middle.SetParent(self)
            middle.LoadImage("d:/ymir work/ui/pattern/ScrollBar_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*3
            self.middle.SetRenderingRect(0, 0, 0, float(height)/4.0)

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

        self.pageSize = 1
        self.curPos = 0.0
        self.eventScroll = lambda *arg: None
        self.lockFlag = False
        self.scrollStep = 0.20

        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("d:/ymir work/ui/public/scrollbar_up_button_01.sub")
        upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_up_button_02.sub")
        upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_up_button_03.sub")
        upButton.Show()

        downButton = Button()
        downButton.SetParent(self)
        downButton.SetEvent(__mem_func__(self.OnDown))
        downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_down_button_01.sub")
        downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_down_button_02.sub")
        downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_down_button_03.sub")
        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

    def SetScrollEvent(self, event):
        self.eventScroll = 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):
        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()

    def SetScrollStep(self, step):
        self.scrollStep = step
    
    def GetScrollStep(self):
        return self.scrollStep
        
    def OnUp(self):
        self.SetPos(self.curPos-self.scrollStep)

    def OnDown(self):
        self.SetPos(self.curPos+self.scrollStep)

    def OnMove(self):

        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)

        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

            if localeInfo.IsARABIC():
                w, h = textLine.GetTextSize()
                textLine.SetPosition(w+10, yPos + 3)
            else:
                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" )

    #####

    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):
        import exception
        import exceptions
        import os
        import errno
        self.Clear()

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

        try:
            # chr, player µîÀº sandbox ³»¿¡¼­ import°¡ Çã¿ëµÇÁö ¾Ê±â ¶§¹®¿¡,(º¿ÀÌ ¾Ç¿ëÇÒ ¿©Áö°¡ ¸Å¿ì Å­.)
            #  ¹Ì¸® script dictionary¿¡ ÇÊ¿äÇÑ »ó¼ö¸¦ ³Ö¾î³õ´Â´Ù.
            import chr
            import player
            import app
            self.ScriptDictionary["PLAYER_NAME_MAX_LEN"] = chr.PLAYER_NAME_MAX_LEN
            self.ScriptDictionary["DRAGON_SOUL_EQUIPMENT_SLOT_START"] = player.DRAGON_SOUL_EQUIPMENT_SLOT_START
            self.ScriptDictionary["LOCALE_PATH"] = app.GetLocalePath()
            execfile(FileName, self.ScriptDictionary)
        except IOError, err:
            import sys
            import dbg            
            dbg.TraceError("Failed to load script file : %s" % (FileName))
            dbg.TraceError("error  : %s" % (err))
            exception.Abort("LoadScriptFile1")
        except RuntimeError,err:
            import sys
            import dbg            
            dbg.TraceError("Failed to load script file : %s" % (FileName))
            dbg.TraceError("error  : %s" % (err))
            exception.Abort("LoadScriptFile2")
        except:
            import sys
            import dbg            
            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"]))

        if localeInfo.IsARABIC():
            w = wndMgr.GetScreenWidth()
            h = wndMgr.GetScreenHeight()
            if Body.has_key("width"):
                w = int(Body["width"])
            if Body.has_key("height"):
                h = int(Body["height"])

            window.SetSize(w, h)
        else:
            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 localeInfo.IsARABIC():
            parent.AddFlag( "rtl" )

        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

            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 == "thinboard_gold":
                parent.Children[Index] = ThinBoardGold()
                parent.Children[Index].SetParent(parent)
                self.LoadElementThinBoardGold(parent.Children[Index], ElementValue, parent)

            elif Type == "thinboard_circle":
                parent.Children[Index] = ThinBoardCircle()
                parent.Children[Index].SetParent(parent)
                self.LoadElementThinBoardCircle(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

    ## 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"])

        if localeInfo.IsARABIC():
            pass
        else:
            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)
        if localeInfo.IsARABIC():
            self.LoadDefaultData(window, value, parentWindow)
        else:
            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

    def LoadElementThinBoardGold(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

    def LoadElementThinBoardCircle(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))
        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)

 

uicharacter.py

Quote

import ui
import uiScriptLocale
import app
import net
import dbg
import snd
import player
import mouseModule
import wndMgr
import skill
import playerSettingModule
import quest
import localeInfo
import uiToolTip
import constInfo
import emotion
import chr
import uiCharacterDetails

SHOW_ONLY_ACTIVE_SKILL = False
SHOW_LIMIT_SUPPORT_SKILL_LIST = []
HIDE_SUPPORT_SKILL_POINT = False

if localeInfo.IsYMIR():
    SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140,141,142]
    if not localeInfo.IsCHEONMA():
        HIDE_SUPPORT_SKILL_POINT = True
        SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140,141,142]
elif localeInfo.IsJAPAN() or   (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/ca") and (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/br"):
    HIDE_SUPPORT_SKILL_POINT = True    
    SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140]
else:
    HIDE_SUPPORT_SKILL_POINT = True

FACE_IMAGE_DICT = {
    playerSettingModule.RACE_WARRIOR_M    : "icon/face/warrior_m.tga",
    playerSettingModule.RACE_WARRIOR_W    : "icon/face/warrior_w.tga",
    playerSettingModule.RACE_ASSASSIN_M    : "icon/face/assassin_m.tga",
    playerSettingModule.RACE_ASSASSIN_W    : "icon/face/assassin_w.tga",
    playerSettingModule.RACE_SURA_M        : "icon/face/sura_m.tga",
    playerSettingModule.RACE_SURA_W        : "icon/face/sura_w.tga",
    playerSettingModule.RACE_SHAMAN_M    : "icon/face/shaman_m.tga",
    playerSettingModule.RACE_SHAMAN_W    : "icon/face/shaman_w.tga",
}
def unsigned32(n):
    return n & 0xFFFFFFFFL
    
class CharacterWindow(ui.ScriptWindow):

    ACTIVE_PAGE_SLOT_COUNT = 8
    SUPPORT_PAGE_SLOT_COUNT = 12

    PAGE_SLOT_COUNT = 12
    PAGE_HORSE = 2

    SKILL_GROUP_NAME_DICT = {
        playerSettingModule.JOB_WARRIOR    : { 1 : localeInfo.SKILL_GROUP_WARRIOR_1,    2 : localeInfo.SKILL_GROUP_WARRIOR_2, },
        playerSettingModule.JOB_ASSASSIN    : { 1 : localeInfo.SKILL_GROUP_ASSASSIN_1,    2 : localeInfo.SKILL_GROUP_ASSASSIN_2, },
        playerSettingModule.JOB_SURA        : { 1 : localeInfo.SKILL_GROUP_SURA_1,        2 : localeInfo.SKILL_GROUP_SURA_2, },
        playerSettingModule.JOB_SHAMAN        : { 1 : localeInfo.SKILL_GROUP_SHAMAN_1,    2 : localeInfo.SKILL_GROUP_SHAMAN_2, },
    }

    STAT_DESCRIPTION =    {
        "HTH" : localeInfo.STAT_TOOLTIP_CON,
        "INT" : localeInfo.STAT_TOOLTIP_INT,
        "STR" : localeInfo.STAT_TOOLTIP_STR,
        "DEX" : localeInfo.STAT_TOOLTIP_DEX,
    }

    STAT_MINUS_DESCRIPTION = localeInfo.STAT_MINUS_DESCRIPTION

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.state = "STATUS"
        self.isLoaded = 0
        self.chDetailsWnd = None
        self.isOpenedDetailsWnd = False

        self.toolTipSkill = 0
                
        self.__Initialize()
        self.__LoadWindow()

        self.statusPlusCommandDict={
            "HTH" : "/stat ht",
            "INT" : "/stat iq",
            "STR" : "/stat st",
            "DEX" : "/stat dx",
        }

        self.statusMinusCommandDict={
            "HTH-" : "/stat- ht",
            "INT-" : "/stat- iq",
            "STR-" : "/stat- st",
            "DEX-" : "/stat- dx",
        }

    def __del__(self):
        ui.ScriptWindow.__del__(self)

    def __Initialize(self):
        self.refreshToolTip = 0
        self.curSelectedSkillGroup = 0
        self.canUseHorseSkill = -1

        self.toolTip = None
        self.toolTipJob = None
        self.toolTipAlignment = None
        self.toolTipSkill = None

        self.faceImage = None
        self.statusPlusLabel = None
        self.statusPlusValue = None
        self.activeSlot = None
        self.tabDict = None
        self.tabButtonDict = None
        self.pageDict = None
        self.titleBarDict = None
        self.statusPlusButtonDict = None
        self.statusMinusButtonDict = None

        self.skillPageDict = None
        self.questShowingStartIndex = 0
        self.questScrollBar = None
        self.questSlot = None
        self.questNameList = None
        self.questLastTimeList = None
        self.questLastCountList = None
        self.skillGroupButton = ()

        self.activeSlot = None
        self.activeSkillPointValue = None
        self.supportSkillPointValue = None
        self.skillGroupButton1 = None
        self.skillGroupButton2 = None
        self.activeSkillGroupName = None

        self.guildNameSlot = None
        self.guildNameValue = None
        self.characterNameSlot = None
        self.characterNameValue = None

        self.emotionToolTip = None
        self.soloEmotionSlot = None
        self.dualEmotionSlot = None
        
        def OnTop(self):
            if self.chDetailsWnd:
                self.chDetailsWnd.SetTop()

        def Hide(self):
            if self.chDetailsWnd:
                self.isOpenedDetailsWnd = self.chDetailsWnd.IsShow()
                self.chDetailsWnd.Close()
            wndMgr.Hide(self.hWnd)

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)
        
        self.__InitCharacterDetailsUIButton()
        if self.chDetailsWnd and self.isOpenedDetailsWnd:
            self.chDetailsWnd.Show()

    def __LoadScript(self, fileName):
        pyScrLoader = ui.PythonScriptLoader()
        pyScrLoader.LoadScriptFile(self, fileName)    
        
    def __BindObject(self):
        self.toolTip = uiToolTip.ToolTip()
        self.toolTipJob = uiToolTip.ToolTip()
        self.toolTipAlignment = uiToolTip.ToolTip(130)        

        self.faceImage = self.GetChild("Face_Image")

        faceSlot=self.GetChild("Face_Slot")
        if 949 == app.GetDefaultCodePage():
            faceSlot.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowJobToolTip)
            faceSlot.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideJobToolTip)

        self.statusPlusLabel = self.GetChild("Status_Plus_Label")
        self.statusPlusValue = self.GetChild("Status_Plus_Value")        

        self.characterNameSlot = self.GetChild("Character_Name_Slot")            
        self.characterNameValue = self.GetChild("Character_Name")
        self.guildNameSlot = self.GetChild("Guild_Name_Slot")
        self.guildNameValue = self.GetChild("Guild_Name")
        self.characterNameSlot.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowAlignmentToolTip)
        self.characterNameSlot.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideAlignmentToolTip)

        self.activeSlot = self.GetChild("Skill_Active_Slot")
        self.activeSkillPointValue = self.GetChild("Active_Skill_Point_Value")
        self.supportSkillPointValue = self.GetChild("Support_Skill_Point_Value")
        self.skillGroupButton1 = self.GetChild("Skill_Group_Button_1")
        self.skillGroupButton2 = self.GetChild("Skill_Group_Button_2")
        self.activeSkillGroupName = self.GetChild("Active_Skill_Group_Name")

        self.tabDict = {
            "STATUS"    : self.GetChild("Tab_01"),
            "SKILL"        : self.GetChild("Tab_02"),
            "EMOTICON"    : self.GetChild("Tab_03"),
            "QUEST"        : self.GetChild("Tab_04"),
        }

        self.tabButtonDict = {
            "STATUS"    : self.GetChild("Tab_Button_01"),
            "SKILL"        : self.GetChild("Tab_Button_02"),
            "EMOTICON"    : self.GetChild("Tab_Button_03"),
            "QUEST"        : self.GetChild("Tab_Button_04")
        }

        self.pageDict = {
            "STATUS"    : self.GetChild("Character_Page"),
            "SKILL"        : self.GetChild("Skill_Page"),
            "EMOTICON"    : self.GetChild("Emoticon_Page"),
            "QUEST"        : self.GetChild("Quest_Page")
        }

        self.titleBarDict = {
            "STATUS"    : self.GetChild("Character_TitleBar"),
            "SKILL"        : self.GetChild("Skill_TitleBar"),
            "EMOTICON"    : self.GetChild("Emoticon_TitleBar"),
            "QUEST"        : self.GetChild("Quest_TitleBar")
        }

        self.statusPlusButtonDict = {
            "HTH"        : self.GetChild("HTH_Plus"),
            "INT"        : self.GetChild("INT_Plus"),
            "STR"        : self.GetChild("STR_Plus"),
            "DEX"        : self.GetChild("DEX_Plus"),
        }

        self.statusMinusButtonDict = {
            "HTH-"        : self.GetChild("HTH_Minus"),
            "INT-"        : self.GetChild("INT_Minus"),
            "STR-"        : self.GetChild("STR_Minus"),
            "DEX-"        : self.GetChild("DEX_Minus"),
        }

        self.skillPageDict = {
            "ACTIVE" : self.GetChild("Skill_Active_Slot"),
            "SUPPORT" : self.GetChild("Skill_ETC_Slot"),
            "HORSE" : self.GetChild("Skill_Active_Slot"),
        }

        self.skillPageStatDict = {
            "SUPPORT"    : player.SKILL_SUPPORT,
            "ACTIVE"    : player.SKILL_ACTIVE,
            "HORSE"        : player.SKILL_HORSE,
        }

        self.skillGroupButton = (
            self.GetChild("Skill_Group_Button_1"),
            self.GetChild("Skill_Group_Button_2"),
        )

        
        global SHOW_ONLY_ACTIVE_SKILL
        global HIDE_SUPPORT_SKILL_POINT
        if SHOW_ONLY_ACTIVE_SKILL or HIDE_SUPPORT_SKILL_POINT:    
            self.GetChild("Support_Skill_Point_Label").Hide()

        self.soloEmotionSlot = self.GetChild("SoloEmotionSlot")
        self.dualEmotionSlot = self.GetChild("DualEmotionSlot")
        self.__SetEmotionSlot()

        self.questShowingStartIndex = 0
        self.questScrollBar = self.GetChild("Quest_ScrollBar")
        self.questScrollBar.SetScrollEvent(ui.__mem_func__(self.OnQuestScroll))
        self.questSlot = self.GetChild("Quest_Slot")
        for i in xrange(quest.QUEST_MAX_NUM):
            self.questSlot.HideSlotBaseImage(i)
            self.questSlot.SetCoverButton(i,\
                                            "d:/ymir work/ui/game/quest/slot_button_01.sub",\
                                            "d:/ymir work/ui/game/quest/slot_button_02.sub",\
                                            "d:/ymir work/ui/game/quest/slot_button_03.sub",\
                                            "d:/ymir work/ui/game/quest/slot_button_03.sub", True)

        self.questNameList = []
        self.questLastTimeList = []
        self.questLastCountList = []
        for i in xrange(quest.QUEST_MAX_NUM):
            self.questNameList.append(self.GetChild("Quest_Name_0" + str(i)))
            self.questLastTimeList.append(self.GetChild("Quest_LastTime_0" + str(i)))
            self.questLastCountList.append(self.GetChild("Quest_LastCount_0" + str(i)))

            self.MainBoard = self.GetChild("board")
            self.ExpandBtn = ui.MakeButton(self.MainBoard, 240, 120, "", "d:/ymir work/ui/game/belt_inventory/", "btn_minimize_normal.tga", "btn_minimize_over.tga", "btn_minimize_down.tga")
            self.ExpandBtn.SetEvent(ui.__mem_func__(self.__ClickExpandButton))
            self.MinimizeBtn = ui.MakeButton(self.MainBoard, 240, 120, "", "d:/ymir work/ui/game/belt_inventory/", "btn_expand_normal.tga", "btn_expand_over.tga", "btn_expand_down.tga")
            self.MinimizeBtn.SetEvent(ui.__mem_func__(self.__ClickMinimizeButton))

    def __InitCharacterDetailsUIButton(self):
        self.ExpandBtn.Show()
        self.MinimizeBtn.Hide()
        
    def __ClickExpandButton(self):
        #print "__ClickExpandButton"    
        
        if not self.chDetailsWnd:
            self.chDetailsWnd = uiCharacterDetails.CharacterDetailsUI(self)
            self.chDetailsWnd.Show()
        else:
            self.chDetailsWnd.Show()
            
        self.ExpandBtn.Hide()
        self.MinimizeBtn.Show()
            
    def __ClickMinimizeButton(self):
        #print "__ClickMinimizeButton"
        
        self.chDetailsWnd.Hide()
        self.MinimizeBtn.Hide()
        self.ExpandBtn.Show()
        
    def OnMoveWindow(self, x, y):
        #print "OnMoveWindow x %s y %s" % (x, y)
        if self.chDetailsWnd:
            self.chDetailsWnd.AdjustPosition(x, y)

    def __SetSkillSlotEvent(self):
        for skillPageValue in self.skillPageDict.itervalues():
            skillPageValue.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
            skillPageValue.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectSkill))
            skillPageValue.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
            skillPageValue.SetUnselectItemSlotEvent(ui.__mem_func__(self.ClickSkillSlot))
            skillPageValue.SetUseSlotEvent(ui.__mem_func__(self.ClickSkillSlot))
            skillPageValue.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
            skillPageValue.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
            skillPageValue.SetPressedSlotButtonEvent(ui.__mem_func__(self.OnPressedSlotButton))
            skillPageValue.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
                                            "d:/ymir work/ui/game/windows/btn_plus_over.sub",\
                                            "d:/ymir work/ui/game/windows/btn_plus_down.sub")

    def __SetEmotionSlot(self):

        self.emotionToolTip = uiToolTip.ToolTip()

        for slot in (self.soloEmotionSlot, self.dualEmotionSlot):
            slot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
            slot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectEmotion))
            slot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__ClickEmotionSlot))
            slot.SetUseSlotEvent(ui.__mem_func__(self.__ClickEmotionSlot))
            slot.SetOverInItemEvent(ui.__mem_func__(self.__OverInEmotion))
            slot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutEmotion))
            slot.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
                                            "d:/ymir work/ui/game/windows/btn_plus_over.sub",\
                                            "d:/ymir work/ui/game/windows/btn_plus_down.sub")

        for slotIdx, datadict in emotion.EMOTION_DICT.items():
            emotionIdx = slotIdx

            slot = self.soloEmotionSlot
            if slotIdx > 50:
                slot = self.dualEmotionSlot

            slot.SetEmotionSlot(slotIdx, emotionIdx)
            slot.SetCoverButton(slotIdx)

    def __SelectEmotion(self, slotIndex):
        if not slotIndex in emotion.EMOTION_DICT:
            return

        if app.IsPressed(app.DIK_LCONTROL):
            player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_EMOTION, slotIndex)
            return

        mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_EMOTION, slotIndex, slotIndex)

    def __ClickEmotionSlot(self, slotIndex):
        print "click emotion"
        if not slotIndex in emotion.EMOTION_DICT:
            return

        print "check acting"
        if player.IsActingEmotion():
            return

        command = emotion.EMOTION_DICT[slotIndex]["command"]
        print "command", command

        if slotIndex > 50:
            vid = player.GetTargetVID()

            if 0 == vid or vid == player.GetMainCharacterIndex() or chr.IsNPC(vid) or chr.IsEnemy(vid):
                import chat
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EMOTION_CHOOSE_ONE)
                return

            command += " " + chr.GetNameByVID(vid)

        print "send_command", command
        net.SendChatPacket(command)

    def ActEmotion(self, emotionIndex):
        self.__ClickEmotionSlot(emotionIndex)

    def __OverInEmotion(self, slotIndex):
        if self.emotionToolTip:

            if not slotIndex in emotion.EMOTION_DICT:
                return

            self.emotionToolTip.ClearToolTip()
            self.emotionToolTip.SetTitle(emotion.EMOTION_DICT[slotIndex]["name"])
            self.emotionToolTip.AlignHorizonalCenter()
            self.emotionToolTip.ShowToolTip()

    def __OverOutEmotion(self):
        if self.emotionToolTip:
            self.emotionToolTip.HideToolTip()

    def __BindEvent(self):
        for i in xrange(len(self.skillGroupButton)):
            self.skillGroupButton.SetEvent(lambda arg=i: self.__SelectSkillGroup(arg))

        self.RefreshQuest()
        self.__HideJobToolTip()

        for (tabKey, tabButton) in self.tabButtonDict.items():
            tabButton.SetEvent(ui.__mem_func__(self.__OnClickTabButton), tabKey)

        for (statusPlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
            statusPlusButton.SAFE_SetEvent(self.__OnClickStatusPlusButton, statusPlusKey)
            statusPlusButton.ShowToolTip = lambda arg=statusPlusKey: self.__OverInStatButton(arg)
            statusPlusButton.HideToolTip = lambda arg=statusPlusKey: self.__OverOutStatButton()

        for (statusMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
            statusMinusButton.SAFE_SetEvent(self.__OnClickStatusMinusButton, statusMinusKey)
            statusMinusButton.ShowToolTip = lambda arg=statusMinusKey: self.__OverInStatMinusButton(arg)
            statusMinusButton.HideToolTip = lambda arg=statusMinusKey: self.__OverOutStatMinusButton()

        for titleBarValue in self.titleBarDict.itervalues():
            titleBarValue.SetCloseEvent(ui.__mem_func__(self.Close))

        self.questSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectQuest))

    def __LoadWindow(self):
        if self.isLoaded == 1:
            return

        self.isLoaded = 1

        try:
            if localeInfo.IsARABIC() or localeInfo.IsVIETNAM() or localeInfo.IsJAPAN():
                self.__LoadScript(uiScriptLocale.LOCALE_UISCRIPT_PATH + "CharacterWindow.py")
            else:
                self.__LoadScript("UIScript/CharacterWindow.py")
                
            self.__BindObject()
            self.__BindEvent()
        except:
            import exception
            exception.Abort("CharacterWindow.__LoadWindow")

        #self.tabButtonDict["EMOTICON"].Disable()
        self.SetState("STATUS")

    def Destroy(self):
        self.ClearDictionary()

        self.__Initialize()

    def Close(self):
        if 0 != self.toolTipSkill:
            self.toolTipSkill.Hide()

        if self.chDetailsWnd and self.chDetailsWnd.IsShow():
            self.chDetailsWnd.Hide()

        self.Hide()

    def SetSkillToolTip(self, toolTipSkill):
        self.toolTipSkill = toolTipSkill

    def __OnClickStatusPlusButton(self, statusKey):
        try:
            statusPlusCommand=self.statusPlusCommandDict[statusKey]
            net.SendChatPacket(statusPlusCommand)
        except KeyError, msg:
            dbg.TraceError("CharacterWindow.__OnClickStatusPlusButton KeyError: %s", msg)

    def __OnClickStatusMinusButton(self, statusKey):
        try:
            statusMinusCommand=self.statusMinusCommandDict[statusKey]
            net.SendChatPacket(statusMinusCommand)
        except KeyError, msg:
            dbg.TraceError("CharacterWindow.__OnClickStatusMinusButton KeyError: %s", msg)

    def __OnClickTabButton(self, stateKey):
        self.SetState(stateKey)

    def SetState(self, stateKey):
        
        self.state = stateKey

        for (tabKey, tabButton) in self.tabButtonDict.items():
            if stateKey!=tabKey:
                tabButton.SetUp()

        for tabValue in self.tabDict.itervalues():
            tabValue.Hide()

        for pageValue in self.pageDict.itervalues():
            pageValue.Hide()

        for titleBarValue in self.titleBarDict.itervalues():
            titleBarValue.Hide()

        self.titleBarDict[stateKey].Show()
        self.tabDict[stateKey].Show()
        self.pageDict[stateKey].Show()
        

    def GetState(self):
        return self.state

    def __GetTotalAtkText(self):
        minAtk=player.GetStatus(player.ATT_MIN)
        maxAtk=player.GetStatus(player.ATT_MAX)
        atkBonus=player.GetStatus(player.ATT_BONUS)
        attackerBonus=player.GetStatus(player.ATTACKER_BONUS)

        if minAtk==maxAtk:
            return "%d" % (minAtk+atkBonus+attackerBonus)
        else:
            return "%d-%d" % (minAtk+atkBonus+attackerBonus, maxAtk+atkBonus+attackerBonus)

    def __GetTotalMagAtkText(self):
        minMagAtk=player.GetStatus(player.MAG_ATT)+player.GetStatus(player.MIN_MAGIC_WEP)
        maxMagAtk=player.GetStatus(player.MAG_ATT)+player.GetStatus(player.MAX_MAGIC_WEP)

        if minMagAtk==maxMagAtk:
            return "%d" % (minMagAtk)
        else:
            return "%d-%d" % (minMagAtk, maxMagAtk)

    def __GetTotalDefText(self):
        defValue=player.GetStatus(player.DEF_GRADE)
        if constInfo.ADD_DEF_BONUS_ENABLE:
            defValue+=player.GetStatus(player.DEF_BONUS)
        return "%d" % (defValue)
    
    def RefreshStatus(self):
        if self.isLoaded==0:
            return

        try:
            self.GetChild("Level_Value").SetText(str(player.GetStatus(player.LEVEL)))
            self.GetChild("Exp_Value").SetText(str(unsigned32(player.GetEXP())))
            self.GetChild("RestExp_Value").SetText(str(unsigned32(player.GetStatus(player.NEXT_EXP)) - unsigned32(player.GetStatus(player.EXP))))
            self.GetChild("HP_Value").SetText(str(player.GetStatus(player.HP)) + '/' + str(player.GetStatus(player.MAX_HP)))
            self.GetChild("SP_Value").SetText(str(player.GetStatus(player.SP)) + '/' + str(player.GetStatus(player.MAX_SP)))

            self.GetChild("STR_Value").SetText(str(player.GetStatus(player.ST)))
            self.GetChild("DEX_Value").SetText(str(player.GetStatus(player.DX)))
            self.GetChild("HTH_Value").SetText(str(player.GetStatus(player.HT)))
            self.GetChild("INT_Value").SetText(str(player.GetStatus(player.IQ)))

            self.GetChild("ATT_Value").SetText(self.__GetTotalAtkText())
            self.GetChild("DEF_Value").SetText(self.__GetTotalDefText())

            self.GetChild("MATT_Value").SetText(self.__GetTotalMagAtkText())
            #self.GetChild("MATT_Value").SetText(str(player.GetStatus(player.MAG_ATT)))

            self.GetChild("MDEF_Value").SetText(str(player.GetStatus(player.MAG_DEF)))
            self.GetChild("ASPD_Value").SetText(str(player.GetStatus(player.ATT_SPEED)))
            self.GetChild("MSPD_Value").SetText(str(player.GetStatus(player.MOVING_SPEED)))
            self.GetChild("CSPD_Value").SetText(str(player.GetStatus(player.CASTING_SPEED)))
            self.GetChild("ER_Value").SetText(str(player.GetStatus(player.EVADE_RATE)))

        except:
            #import exception
            #exception.Abort("CharacterWindow.RefreshStatus.BindObject")
            ## °ÔÀÓÀÌ Æ¨°Ü ¹ö¸²
            pass

        self.__RefreshStatusPlusButtonList()
        self.__RefreshStatusMinusButtonList()
        self.RefreshAlignment()

        if self.refreshToolTip:
            self.refreshToolTip()

    def __RefreshStatusPlusButtonList(self):
        if self.isLoaded==0:
            return

        statusPlusPoint=player.GetStatus(player.STAT)

        if statusPlusPoint>0:
            self.statusPlusValue.SetText(str(statusPlusPoint))
            self.statusPlusLabel.Show()
            self.ShowStatusPlusButtonList()
        else:
            self.statusPlusValue.SetText(str(0))
            self.statusPlusLabel.Hide()
            self.HideStatusPlusButtonList()

    def __RefreshStatusMinusButtonList(self):
        if self.isLoaded==0:
            return

        statusMinusPoint=self.__GetStatMinusPoint()

        if statusMinusPoint>0:
            self.__ShowStatusMinusButtonList()
        else:
            self.__HideStatusMinusButtonList()

    def RefreshAlignment(self):
        point, grade = player.GetAlignmentData()

        import colorInfo
        COLOR_DICT = {    0 : colorInfo.TITLE_RGB_GOOD_4,
                        1 : colorInfo.TITLE_RGB_GOOD_3,
                        2 : colorInfo.TITLE_RGB_GOOD_2,
                        3 : colorInfo.TITLE_RGB_GOOD_1,
                        4 : colorInfo.TITLE_RGB_NORMAL,
                        5 : colorInfo.TITLE_RGB_EVIL_1,
                        6 : colorInfo.TITLE_RGB_EVIL_2,
                        7 : colorInfo.TITLE_RGB_EVIL_3,
                        8 : colorInfo.TITLE_RGB_EVIL_4, }
        colorList = COLOR_DICT.get(grade, colorInfo.TITLE_RGB_NORMAL)
        gradeColor = ui.GenerateColor(colorList[0], colorList[1], colorList[2])

        self.toolTipAlignment.ClearToolTip()
        self.toolTipAlignment.AutoAppendTextLine(localeInfo.TITLE_NAME_LIST[grade], gradeColor)
        self.toolTipAlignment.AutoAppendTextLine(localeInfo.ALIGNMENT_NAME + str(point))
        self.toolTipAlignment.AlignHorizonalCenter()

    def __ShowStatusMinusButtonList(self):
        for (stateMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
            statusMinusButton.Show()

    def __HideStatusMinusButtonList(self):
        for (stateMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
            statusMinusButton.Hide()

    def ShowStatusPlusButtonList(self):
        for (statePlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
            statusPlusButton.Show()

    def HideStatusPlusButtonList(self):
        for (statePlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
            statusPlusButton.Hide()

    def SelectSkill(self, skillSlotIndex):

        mouseController = mouseModule.mouseController

        if False == mouseController.isAttached():

            srcSlotIndex = self.__RealSkillSlotToSourceSlot(skillSlotIndex)
            selectedSkillIndex = player.GetSkillIndex(srcSlotIndex)

            if skill.CanUseSkill(selectedSkillIndex):

                if app.IsPressed(app.DIK_LCONTROL):

                    player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_SKILL, srcSlotIndex)
                    return

                mouseController.AttachObject(self, player.SLOT_TYPE_SKILL, srcSlotIndex, selectedSkillIndex)

        else:

            mouseController.DeattachObject()

    def SelectEmptySlot(self, SlotIndex):
        mouseModule.mouseController.DeattachObject()

    ## ToolTip
    def OverInItem(self, slotNumber):

        if mouseModule.mouseController.isAttached():
            return

        if 0 == self.toolTipSkill:
            return

        srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotNumber)
        skillIndex = player.GetSkillIndex(srcSlotIndex)
        skillLevel = player.GetSkillLevel(srcSlotIndex)
        skillGrade = player.GetSkillGrade(srcSlotIndex)
        skillType = skill.GetSkillType(skillIndex)

        ## ACTIVE
        if skill.SKILL_TYPE_ACTIVE == skillType:
            overInSkillGrade = self.__GetSkillGradeFromSlot(slotNumber)

            if overInSkillGrade == skill.SKILL_GRADE_COUNT-1 and skillGrade == skill.SKILL_GRADE_COUNT:
                self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, skillGrade, skillLevel)
            elif overInSkillGrade == skillGrade:
                self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, overInSkillGrade, skillLevel)
            else:
                self.toolTipSkill.SetSkillOnlyName(srcSlotIndex, skillIndex, overInSkillGrade)

        else:
            self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, skillGrade, skillLevel)

    def OverOutItem(self):
        if 0 != self.toolTipSkill:
            self.toolTipSkill.HideToolTip()

    ## Quest
    def __SelectQuest(self, slotIndex):
        questIndex = quest.GetQuestIndex(self.questShowingStartIndex+slotIndex)

        import event
        event.QuestButtonClick(-2147483648 + questIndex)

    def RefreshQuest(self):

        if self.isLoaded==0:
            return

        questCount = quest.GetQuestCount()
        questRange = range(quest.QUEST_MAX_NUM)

        if questCount > quest.QUEST_MAX_NUM:
            self.questScrollBar.Show()
        else:
            self.questScrollBar.Hide()

        for i in questRange[:questCount]:
            (questName, questIcon, questCounterName, questCounterValue) = quest.GetQuestData(self.questShowingStartIndex+i)

            self.questNameList.SetText(questName)
            self.questNameList.Show()
            self.questLastCountList.Show()
            self.questLastTimeList.Show()

            if len(questCounterName) > 0:
                self.questLastCountList.SetText("%s : %d" % (questCounterName, questCounterValue))
            else:
                self.questLastCountList.SetText("")

            ## Icon
            self.questSlot.SetSlot(i, i, 1, 1, questIcon)

        for i in questRange[questCount:]:
            self.questNameList.Hide()
            self.questLastTimeList.Hide()
            self.questLastCountList.Hide()
            self.questSlot.ClearSlot(i)
            self.questSlot.HideSlotBaseImage(i)

        self.__UpdateQuestClock()

    def __UpdateQuestClock(self):
        if "QUEST" == self.state:
            # QUEST_LIMIT_COUNT_BUG_FIX
            for i in xrange(min(quest.GetQuestCount(), quest.QUEST_MAX_NUM)):
            # END_OF_QUEST_LIMIT_COUNT_BUG_FIX
                (lastName, lastTime) = quest.GetQuestLastTime(i)

                clockText = localeInfo.QUEST_UNLIMITED_TIME
                if len(lastName) > 0:

                    if lastTime <= 0:
                        clockText = localeInfo.QUEST_TIMEOVER

                    else:
                        questLastMinute = lastTime / 60
                        questLastSecond = lastTime % 60

                        clockText = lastName + " : "

                        if questLastMinute > 0:
                            clockText += str(questLastMinute) + localeInfo.QUEST_MIN
                            if questLastSecond > 0:
                                clockText += " "

                        if questLastSecond > 0:
                            clockText += str(questLastSecond) + localeInfo.QUEST_SEC

                self.questLastTimeList.SetText(clockText)

    def __GetStatMinusPoint(self):
        POINT_STAT_RESET_COUNT = 112
        return player.GetStatus(POINT_STAT_RESET_COUNT)

    def __OverInStatMinusButton(self, stat):
        try:
            self.__ShowStatToolTip(self.STAT_MINUS_DESCRIPTION[stat] % self.__GetStatMinusPoint())
        except KeyError:
            pass

        self.refreshToolTip = lambda arg=stat: self.__OverInStatMinusButton(arg)

    def __OverOutStatMinusButton(self):
        self.__HideStatToolTip()
        self.refreshToolTip = 0

    def __OverInStatButton(self, stat):    
        try:
            self.__ShowStatToolTip(self.STAT_DESCRIPTION[stat])
        except KeyError:
            pass

    def __OverOutStatButton(self):
        self.__HideStatToolTip()

    def __ShowStatToolTip(self, statDesc):
        self.toolTip.ClearToolTip()
        self.toolTip.AppendTextLine(statDesc)
        self.toolTip.Show()

    def __HideStatToolTip(self):
        self.toolTip.Hide()

    def OnPressEscapeKey(self):
        self.Close()
        return True

    def OnUpdate(self):
        self.__UpdateQuestClock()

    ## Skill Process
    def __RefreshSkillPage(self, name, slotCount):
        global SHOW_LIMIT_SUPPORT_SKILL_LIST

        skillPage = self.skillPageDict[name]

        startSlotIndex = skillPage.GetStartIndex()
        if "ACTIVE" == name:
            if self.PAGE_HORSE == self.curSelectedSkillGroup:
                startSlotIndex += slotCount

        getSkillType=skill.GetSkillType
        getSkillIndex=player.GetSkillIndex
        getSkillGrade=player.GetSkillGrade
        getSkillLevel=player.GetSkillLevel
        getSkillLevelUpPoint=skill.GetSkillLevelUpPoint
        getSkillMaxLevel=skill.GetSkillMaxLevel
        for i in xrange(slotCount+1):

            slotIndex = i + startSlotIndex
            skillIndex = getSkillIndex(slotIndex)

            for j in xrange(skill.SKILL_GRADE_COUNT):
                skillPage.ClearSlot(self.__GetRealSkillSlot(j, i))

            if 0 == skillIndex:
                continue

            skillGrade = getSkillGrade(slotIndex)
            skillLevel = getSkillLevel(slotIndex)
            skillType = getSkillType(skillIndex)

            ## ½Â¸¶ ½ºÅ³ ¿¹¿Ü ó¸®
            if player.SKILL_INDEX_RIDING == skillIndex:
                if 1 == skillGrade:
                    skillLevel += 19
                elif 2 == skillGrade:
                    skillLevel += 29
                elif 3 == skillGrade:
                    skillLevel = 40

                skillPage.SetSkillSlotNew(slotIndex, skillIndex, max(skillLevel-1, 0), skillLevel)
                skillPage.SetSlotCount(slotIndex, skillLevel)

            ## ACTIVE
            elif skill.SKILL_TYPE_ACTIVE == skillType:
                for j in xrange(skill.SKILL_GRADE_COUNT):
                    realSlotIndex = self.__GetRealSkillSlot(j, slotIndex)
                    skillPage.SetSkillSlotNew(realSlotIndex, skillIndex, j, skillLevel)
                    skillPage.SetCoverButton(realSlotIndex)

                    if (skillGrade == skill.SKILL_GRADE_COUNT) and j == (skill.SKILL_GRADE_COUNT-1):
                        skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
                    elif (not self.__CanUseSkillNow()) or (skillGrade != j):
                        skillPage.SetSlotCount(realSlotIndex, 0)
                        skillPage.DisableCoverButton(realSlotIndex)
                    else:
                        skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
            ## ±×¿Ü
            else:
                if not SHOW_LIMIT_SUPPORT_SKILL_LIST or skillIndex in SHOW_LIMIT_SUPPORT_SKILL_LIST:
                    realSlotIndex = self.__GetETCSkillRealSlotIndex(slotIndex)
                    skillPage.SetSkillSlot(realSlotIndex, skillIndex, skillLevel)
                    skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)

                    if skill.CanUseSkill(skillIndex):
                        skillPage.SetCoverButton(realSlotIndex)

            skillPage.RefreshSlot()

    def RefreshSkill(self):

        if self.isLoaded==0:
            return

        if self.__IsChangedHorseRidingSkillLevel():
            self.RefreshCharacter()
            return

        global SHOW_ONLY_ACTIVE_SKILL
        if SHOW_ONLY_ACTIVE_SKILL:
            self.__RefreshSkillPage("ACTIVE", self.ACTIVE_PAGE_SLOT_COUNT)
        else:
            self.__RefreshSkillPage("ACTIVE", self.ACTIVE_PAGE_SLOT_COUNT)
            self.__RefreshSkillPage("SUPPORT", self.SUPPORT_PAGE_SLOT_COUNT)

        self.RefreshSkillPlusButtonList()

    def CanShowPlusButton(self, skillIndex, skillLevel, curStatPoint):

        ## ½ºÅ³ÀÌ ÀÖÀ¸¸é
        if 0 == skillIndex:
            return False

        ## ·¹º§¾÷ Á¶°ÇÀ» ¸¸Á·ÇÑ´Ù¸é
        if not skill.CanLevelUpSkill(skillIndex, skillLevel):
            return False

        return True

    def __RefreshSkillPlusButton(self, name):
        global HIDE_SUPPORT_SKILL_POINT
        if HIDE_SUPPORT_SKILL_POINT and "SUPPORT" == name:
            return

        slotWindow = self.skillPageDict[name]
        slotWindow.HideAllSlotButton()

        slotStatType = self.skillPageStatDict[name]
        if 0 == slotStatType:
            return

        statPoint = player.GetStatus(slotStatType)
        startSlotIndex = slotWindow.GetStartIndex()
        if "HORSE" == name:
            startSlotIndex += self.ACTIVE_PAGE_SLOT_COUNT

        if statPoint > 0:
            for i in xrange(self.PAGE_SLOT_COUNT):
                slotIndex = i + startSlotIndex
                skillIndex = player.GetSkillIndex(slotIndex)
                skillGrade = player.GetSkillGrade(slotIndex)
                skillLevel = player.GetSkillLevel(slotIndex)

                if skillIndex == 0:
                    continue
                if skillGrade != 0:
                    continue

                if name == "HORSE":
                    if player.GetStatus(player.LEVEL) >= skill.GetSkillLevelLimit(skillIndex):
                        if skillLevel < 20:
                            slotWindow.ShowSlotButton(self.__GetETCSkillRealSlotIndex(slotIndex))

                else:
                    if "SUPPORT" == name:                        
                        if not SHOW_LIMIT_SUPPORT_SKILL_LIST or skillIndex in SHOW_LIMIT_SUPPORT_SKILL_LIST:
                            if self.CanShowPlusButton(skillIndex, skillLevel, statPoint):
                                slotWindow.ShowSlotButton(slotIndex)
                    else:
                        if self.CanShowPlusButton(skillIndex, skillLevel, statPoint):
                            slotWindow.ShowSlotButton(slotIndex)
                    

    def RefreshSkillPlusButtonList(self):

        if self.isLoaded==0:
            return

        self.RefreshSkillPlusPointLabel()

        if not self.__CanUseSkillNow():
            return

        try:
            if self.PAGE_HORSE == self.curSelectedSkillGroup:
                self.__RefreshSkillPlusButton("HORSE")
            else:
                self.__RefreshSkillPlusButton("ACTIVE")

            self.__RefreshSkillPlusButton("SUPPORT")

        except:
            import exception
            exception.Abort("CharacterWindow.RefreshSkillPlusButtonList.BindObject")

    def RefreshSkillPlusPointLabel(self):
        if self.isLoaded==0:
            return

        if self.PAGE_HORSE == self.curSelectedSkillGroup:
            activeStatPoint = player.GetStatus(player.SKILL_HORSE)
            self.activeSkillPointValue.SetText(str(activeStatPoint))

        else:
            activeStatPoint = player.GetStatus(player.SKILL_ACTIVE)
            self.activeSkillPointValue.SetText(str(activeStatPoint))

        supportStatPoint = max(0, player.GetStatus(player.SKILL_SUPPORT))
        self.supportSkillPointValue.SetText(str(supportStatPoint))

    ## Skill Level Up Button
    def OnPressedSlotButton(self, slotNumber):
        srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotNumber)

        skillIndex = player.GetSkillIndex(srcSlotIndex)
        curLevel = player.GetSkillLevel(srcSlotIndex)
        maxLevel = skill.GetSkillMaxLevel(skillIndex)

        net.SendChatPacket("/skillup " + str(skillIndex))

    ## Use Skill
    def ClickSkillSlot(self, slotIndex):

        srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotIndex)
        skillIndex = player.GetSkillIndex(srcSlotIndex)
        skillType = skill.GetSkillType(skillIndex)

        if not self.__CanUseSkillNow():
            if skill.SKILL_TYPE_ACTIVE == skillType:
                return

        for slotWindow in self.skillPageDict.values():
            if slotWindow.HasSlot(slotIndex):
                if skill.CanUseSkill(skillIndex):
                    player.ClickSkillSlot(srcSlotIndex)
                    return

        mouseModule.mouseController.DeattachObject()

    ## FIXME : ½ºÅ³À» »ç¿ëÇßÀ»¶§ ½½·Ô ¹øÈ£¸¦ °¡Áö°í ÇØ´ç ½½·ÔÀ» ã¾Æ¼­ ¾÷µ¥ÀÌÆ® ÇÑ´Ù.
    ##         ¸Å¿ì ºÒÇÕ¸®. ±¸Á¶ ÀÚü¸¦ °³¼±ÇØ¾ß ÇÒµí.
    def OnUseSkill(self, slotIndex, coolTime):

        skillIndex = player.GetSkillIndex(slotIndex)
        skillType = skill.GetSkillType(skillIndex)

        ## ACTIVE
        if skill.SKILL_TYPE_ACTIVE == skillType:
            skillGrade = player.GetSkillGrade(slotIndex)
            slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
        ## ETC
        else:
            slotIndex = self.__GetETCSkillRealSlotIndex(slotIndex)

        for slotWindow in self.skillPageDict.values():
            if slotWindow.HasSlot(slotIndex):
                slotWindow.SetSlotCoolTime(slotIndex, coolTime)
                return

    # def OnActivateSkill(self, slotIndex):

        # skillGrade = player.GetSkillGrade(slotIndex)
        # slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)

        # for slotWindow in self.skillPageDict.values():
            # if slotWindow.HasSlot(slotIndex):
                # slotWindow.ActivateSlot(slotIndex)
                # return

    # def OnDeactivateSkill(self, slotIndex):

        # skillGrade = player.GetSkillGrade(slotIndex)
        # slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)

        # for slotWindow in self.skillPageDict.values():
            # if slotWindow.HasSlot(slotIndex):
                # slotWindow.DeactivateSlot(slotIndex)
                # return

    def OnActivateSkill(self, slotIndex):
        skillGrade = player.GetSkillGrade(slotIndex)
        slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
        for slotWindow in self.skillPageDict.values():
            if slotWindow.HasSlot(slotIndex):
                if app.ENABLE_ACCE_SYSTEM:
                    slotWindow.ActivateSlotOld(slotIndex)
                else:
                    slotWindow.ActivateSlot(slotIndex)
                
                return

    def OnDeactivateSkill(self, slotIndex):
        skillGrade = player.GetSkillGrade(slotIndex)
        slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
        for slotWindow in self.skillPageDict.values():
            if slotWindow.HasSlot(slotIndex):
                if app.ENABLE_ACCE_SYSTEM:
                    slotWindow.DeactivateSlotOld(slotIndex)
                else:
                    slotWindow.DeactivateSlot(slotIndex)
                
                return

    def __ShowJobToolTip(self):
        self.toolTipJob.ShowToolTip()

    def __HideJobToolTip(self):
        self.toolTipJob.HideToolTip()

    def __SetJobText(self, mainJob, subJob):
        if player.GetStatus(player.LEVEL)<5:
            subJob=0

        if 949 == app.GetDefaultCodePage():
            self.toolTipJob.ClearToolTip()

            try:
                jobInfoTitle=localeInfo.JOBINFO_TITLE[mainJob][subJob]
                jobInfoData=localeInfo.JOBINFO_DATA_LIST[mainJob][subJob]
            except IndexError:
                print "uiCharacter.CharacterWindow.__SetJobText(mainJob=%d, subJob=%d)" % (mainJob, subJob)
                return

            self.toolTipJob.AutoAppendTextLine(jobInfoTitle)
            self.toolTipJob.AppendSpace(5)

            for jobInfoDataLine in jobInfoData:
                self.toolTipJob.AutoAppendTextLine(jobInfoDataLine)

            self.toolTipJob.AlignHorizonalCenter()

    def __ShowAlignmentToolTip(self):
        self.toolTipAlignment.ShowToolTip()

    def __HideAlignmentToolTip(self):
        self.toolTipAlignment.HideToolTip()

    def RefreshCharacter(self):

        if self.isLoaded==0:
            return

        ## Name
        try:
            characterName = player.GetName()
            guildName = player.GetGuildName()
            self.characterNameValue.SetText(characterName)
            self.guildNameValue.SetText(guildName)
            if not guildName:
                if localeInfo.IsARABIC():
                    self.characterNameSlot.SetPosition(190, 34)
                else:
                    self.characterNameSlot.SetPosition(109, 34)

                self.guildNameSlot.Hide()
            else:
                if localeInfo.IsJAPAN():
                    self.characterNameSlot.SetPosition(143, 34)
                else:
                    self.characterNameSlot.SetPosition(153, 34)
                self.guildNameSlot.Show()
        except:
            import exception
            exception.Abort("CharacterWindow.RefreshCharacter.BindObject")

        race = net.GetMainActorRace()
        group = net.GetMainActorSkillGroup()
        empire = net.GetMainActorEmpire()

        ## Job Text
        job = chr.RaceToJob(race)
        self.__SetJobText(job, group)

        ## FaceImage
        try:
            faceImageName = FACE_IMAGE_DICT[race]

            try:
                self.faceImage.LoadImage(faceImageName)
            except:
                print "CharacterWindow.RefreshCharacter(race=%d, faceImageName=%s)" % (race, faceImageName)
                self.faceImage.Hide()

        except KeyError:
            self.faceImage.Hide()

        ## GroupName
        self.__SetSkillGroupName(race, group)

        ## Skill
        if 0 == group:
            self.__SelectSkillGroup(0)

        else:
            self.__SetSkillSlotData(race, group, empire)

            if self.__CanUseHorseSkill():
                self.__SelectSkillGroup(0)

    def __SetSkillGroupName(self, race, group):

        job = chr.RaceToJob(race)

        if not self.SKILL_GROUP_NAME_DICT.has_key(job):
            return

        nameList = self.SKILL_GROUP_NAME_DICT[job]

        if 0 == group:
            self.skillGroupButton1.SetText(nameList[1])
            self.skillGroupButton2.SetText(nameList[2])
            self.skillGroupButton1.Show()
            self.skillGroupButton2.Show()
            self.activeSkillGroupName.Hide()

        else:

            if self.__CanUseHorseSkill():
                self.activeSkillGroupName.Hide()
                self.skillGroupButton1.SetText(nameList.get(group, "Noname"))
                self.skillGroupButton2.SetText(localeInfo.SKILL_GROUP_HORSE)
                self.skillGroupButton1.Show()
                self.skillGroupButton2.Show()

            else:
                self.activeSkillGroupName.SetText(nameList.get(group, "Noname"))
                self.activeSkillGroupName.Show()
                self.skillGroupButton1.Hide()
                self.skillGroupButton2.Hide()

    def __SetSkillSlotData(self, race, group, empire=0):

        ## SkillIndex
        playerSettingModule.RegisterSkill(race, group, empire)

        ## Event
        self.__SetSkillSlotEvent()

        ## Refresh
        self.RefreshSkill()

    def __SelectSkillGroup(self, index):
        for btn in self.skillGroupButton:
            btn.SetUp()
        self.skillGroupButton[index].Down()

        if self.__CanUseHorseSkill():
            if 0 == index:
                index = net.GetMainActorSkillGroup()-1
            elif 1 == index:
                index = self.PAGE_HORSE

        self.curSelectedSkillGroup = index
        self.__SetSkillSlotData(net.GetMainActorRace(), index+1, net.GetMainActorEmpire())

    def __CanUseSkillNow(self):
        if 0 == net.GetMainActorSkillGroup():
            return False

        return True

    def __CanUseHorseSkill(self):

        slotIndex = player.GetSkillSlotIndex(player.SKILL_INDEX_RIDING)

        if not slotIndex:
            return False

        grade = player.GetSkillGrade(slotIndex)
        level = player.GetSkillLevel(slotIndex)
        if level < 0:
            level *= -1
        if grade >= 1 and level >= 1:
            return True

        return False

    def __IsChangedHorseRidingSkillLevel(self):
        ret = False

        if -1 == self.canUseHorseSkill:
            self.canUseHorseSkill = self.__CanUseHorseSkill()

        if self.canUseHorseSkill != self.__CanUseHorseSkill():
            ret = True

        self.canUseHorseSkill = self.__CanUseHorseSkill()
        return ret

    def __GetRealSkillSlot(self, skillGrade, skillSlot):
        return skillSlot + min(skill.SKILL_GRADE_COUNT-1, skillGrade)*skill.SKILL_GRADE_STEP_COUNT

    def __GetETCSkillRealSlotIndex(self, skillSlot):
        if skillSlot > 100:
            return skillSlot
        return skillSlot % self.ACTIVE_PAGE_SLOT_COUNT

    def __RealSkillSlotToSourceSlot(self, realSkillSlot):
        if realSkillSlot > 100:
            return realSkillSlot
        if self.PAGE_HORSE == self.curSelectedSkillGroup:
            return realSkillSlot + self.ACTIVE_PAGE_SLOT_COUNT
        return realSkillSlot % skill.SKILL_GRADE_STEP_COUNT

    def __GetSkillGradeFromSlot(self, skillSlot):
        return int(skillSlot / skill.SKILL_GRADE_STEP_COUNT)

    def SelectSkillGroup(self, index):
        self.__SelectSkillGroup(index)

    def OnQuestScroll(self):
        questCount = quest.GetQuestCount()
        scrollLineCount = max(0, questCount - quest.QUEST_MAX_NUM)
        startIndex = int(scrollLineCount * self.questScrollBar.GetPos())

        if startIndex != self.questShowingStartIndex:
            self.questShowingStartIndex = startIndex
            self.RefreshQuest()