Bonus Board Official

Natox · August 10, 2020

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

My syserr client :

0810 20:05:23346 :: R :: AttributeError
0810 20:05:23346 :: R :: : 
0810 20:05:23346 :: R :: 'TitleBar' object has no attribute 'CloseButtonHide'

Edited September 4, 2022 by Metin2 Dev
Core X - External 2 Internal

Asentrix · August 10, 2020

class TitleBar in ui.py doesn't have def CloseButtonHide

it's true that you have def CloseButtonHide in ui.py, but it's inside another class (class HorizontalBar) not the titlebar

Natox · August 10, 2020

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'

Asentrix · August 10, 2020

in ui.py in

class RadioButton(Button):

you have:

	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

move them to

class Button(Window):

AZICKO · August 10, 2020

Spoiler pls

Natox · August 10, 2020

Its good, thanks for your help bro

Sign In

Bonus Board Official

Recommended Posts

Natox 18

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Popular Posts

AZICKO

Asentrix

Asentrix 142

Link to comment

Share on other sites

Natox 18

Link to comment

Share on other sites

Asentrix 142

Link to comment

Share on other sites

AZICKO 7089

Link to comment

Share on other sites

Natox 18

Link to comment

Share on other sites

Please sign in to comment

Announcements

Similar Content

Activity

Recently Browsing

Important Information