Client Chatfenster/logo bug

[Lino™]

Hallo liebe Community,

ich bräuchte eure Hilfe wenn mir in Game jemand eine Nachricht schreibt (blinkt das Logo) Wenn ich es aufmache, lese was mir der jenige geschrieben hatt und dann das Chatfenster "Minimiere" zum Chatlogo wieder und mir der jenige wider schreibt Blinkt das Logo "nicht" !
Ich denke es liegt an der: uiwhisper.py oder uichat.py.
Kann aber nichts merkwürdiges finden!
Hier mal die beiden Dateien:

uichat.py

 Spoiler

PHP Code:

import ui
import grp
import chat
import wndMgr
import net
import app
import ime
import locale
import colorInfo
import constInfo
import systemSetting

ENABLE_CHAT_COMMAND = TRUE
ENABLE_LAST_SENTENCE_STACK = TRUE
ENABLE_INSULT_CHECK = TRUE

if locale.IsHONGKONG():
    ENABLE_LAST_SENTENCE_STACK = TRUE

if locale.IsEUROPE():
    ENABLE_CHAT_COMMAND = FALSE

if locale.IsCANADA():
    ENABLE_LAST_SENTENCE_STACK = FALSE

chatInputSetList = []
def InsertChatInputSetWindow(wnd):
    global chatInputSetList
    chatInputSetList.append(wnd)
def RefreshChatMode():
    global chatInputSetList
    map(lambda wnd:wnd.OnRefreshChatMode(), chatInputSetList)
def DestroyChatInputSetWindow():
    global chatInputSetList
    chatInputSetList = []

## ChatModeButton
class ChatModeButton(ui.Window):

    OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
    OVER_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
    BUTTON_STATE_UP = 0
    BUTTON_STATE_OVER = 1
    BUTTON_STATE_DOWN = 2

    def __init__(self):
        ui.Window.__init__(self)
        self.state = None
        self.buttonText = None
        self.event = None

        net.EnableChatInsultFilter(ENABLE_INSULT_CHECK)

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

    def SAFE_SetEvent(self, event):
        self.event=ui.__mem_func__(event)

    def SetText(self, text):
        if None == self.buttonText:
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetWindowHorizontalAlignCenter()
            textLine.SetWindowVerticalAlignCenter()
            textLine.SetVerticalAlignCenter()
            textLine.SetHorizontalAlignCenter()
            textLine.SetPackedFontColor(self.OUTLINE_COLOR)
            textLine.Show()
            self.buttonText = textLine

        self.buttonText.SetText(text)

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

    def OnMouseOverIn(self):
        self.state = self.BUTTON_STATE_OVER

    def OnMouseOverOut(self):
        self.state = self.BUTTON_STATE_UP

    def OnMouseLeftButtonDown(self):
        self.state = self.BUTTON_STATE_DOWN

    def OnMouseLeftButtonUp(self):
        self.state = self.BUTTON_STATE_UP
        if self.IsIn():
            self.state = self.BUTTON_STATE_OVER

        if None != self.event:
            self.event()

    def OnRender(self):

        (x, y) = self.GetGlobalPosition()

        grp.SetColor(self.OUTLINE_COLOR)
        grp.RenderRoundBox(x, y, self.width, self.height)

        if self.state >= self.BUTTON_STATE_OVER:
            grp.RenderRoundBox(x+1, y, self.width-2, self.height)
            grp.RenderRoundBox(x, y+1, self.width, self.height-2)

            if self.BUTTON_STATE_DOWN == self.state:
                grp.SetColor(self.OVER_COLOR)
                grp.RenderBar(x+1, y+1, self.width-2, self.height-2)

## ChatLine
class ChatLine(ui.EditLine):

    CHAT_MODE_NAME = {    chat.CHAT_TYPE_TALKING : locale.CHAT_NORMAL,
                        chat.CHAT_TYPE_PARTY : locale.CHAT_PARTY,
                        chat.CHAT_TYPE_GUILD : locale.CHAT_GUILD,
                        chat.CHAT_TYPE_SHOUT : locale.CHAT_SHOUT, }

    def __init__(self):
        ui.EditLine.__init__(self)
        self.SetWindowName("Chat Line")
        self.lastShoutTime = 0
        self.eventEscape = lambda *arg: None
        self.eventReturn = lambda *arg: None
        self.eventTab = None
        self.chatMode = chat.CHAT_TYPE_TALKING
        self.bCodePage = TRUE

        self.overTextLine = ui.TextLine()
        self.overTextLine.SetParent(self)
        self.overTextLine.SetPosition(-1, 0)
        self.overTextLine.SetFontColor(1.0, 1.0, 0.0)
        self.overTextLine.SetOutline()
        self.overTextLine.Hide()

        self.lastSentenceStack = []
        self.lastSentencePos = 0

    def SetChatMode(self, mode):
        self.chatMode = mode

    def GetChatMode(self):
        return self.chatMode

    def ChangeChatMode(self):
        if chat.CHAT_TYPE_TALKING == self.GetChatMode():
            self.SetChatMode(chat.CHAT_TYPE_PARTY)
            self.SetText("#")
            self.SetEndPosition()

        elif chat.CHAT_TYPE_PARTY == self.GetChatMode():
            self.SetChatMode(chat.CHAT_TYPE_GUILD)
            self.SetText("%")
            self.SetEndPosition()

        elif chat.CHAT_TYPE_GUILD == self.GetChatMode():
            self.SetChatMode(chat.CHAT_TYPE_SHOUT)
            self.SetText("!")
            self.SetEndPosition()

        elif chat.CHAT_TYPE_SHOUT == self.GetChatMode():
            self.SetChatMode(chat.CHAT_TYPE_TALKING)
            self.SetText("")

        self.__CheckChatMark()

    def GetCurrentChatModeName(self):
        try:
            return self.CHAT_MODE_NAME[self.chatMode]
        except:
            import exception
            exception.Abort("ChatLine.GetCurrentChatModeName")

    def SAFE_SetEscapeEvent(self, event):
        self.eventReturn = ui.__mem_func__(event)

    def SAFE_SetReturnEvent(self, event):
        self.eventEscape = ui.__mem_func__(event)

    def SAFE_SetTabEvent(self, event):
        self.eventTab = ui.__mem_func__(event)

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

    def OpenChat(self):
        self.SetFocus()
        self.__ResetChat()

    def __ClearChat(self):
        self.SetText("")
        self.lastSentencePos = 0

    def __ResetChat(self):
        if chat.CHAT_TYPE_PARTY == self.GetChatMode():
            self.SetText("#")
            self.SetEndPosition()
        elif chat.CHAT_TYPE_GUILD == self.GetChatMode():
            self.SetText("%")
            self.SetEndPosition()
        elif chat.CHAT_TYPE_SHOUT == self.GetChatMode():
            self.SetText("!")
            self.SetEndPosition()
        else:
            self.__ClearChat()

        self.__CheckChatMark()
        

    def __SendChatPacket(self, text, type):
#        if text[0] == '/':
#            if ENABLE_CHAT_COMMAND or constInfo.CONSOLE_ENABLE:
#                pass
#            else:
#                return
        if text == "(buff1)":
            return
        elif text == "(buff2)":
            return
        elif text == "(buff3)":
            return
        elif text == "(buff4)":
            return
        elif text == "(buff5)":
            return
        elif text == "(buff6)":
            return
        elif net.IsChatInsultIn(text):
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_INSULT_STRING)
        else:
            net.SendChatPacket(text, type)
        
    def __SendPartyChatPacket(self, text):

        if 1 == len(text):
            self.RunCloseEvent()
            return

        self.__SendChatPacket(text[1:], chat.CHAT_TYPE_PARTY)
        self.__ResetChat()

    def __SendGuildChatPacket(self, text):

        if 1 == len(text):
            self.RunCloseEvent()
            return

        self.__SendChatPacket(text[1:], chat.CHAT_TYPE_GUILD)
        self.__ResetChat()

    def __SendShoutChatPacket(self, text):

        if 1 == len(text):
            self.RunCloseEvent()
            return

        if app.GetTime() < self.lastShoutTime + 15:
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_SHOUT_LIMIT)
            self.__ResetChat()
            return

        self.__SendChatPacket(text[1:], chat.CHAT_TYPE_SHOUT)
        self.__ResetChat()

        self.lastShoutTime = app.GetTime()

    def __SendTalkingChatPacket(self, text):
        self.__SendChatPacket(text, chat.CHAT_TYPE_TALKING)
        self.__ResetChat()

    def OnIMETab(self):
        #if None != self.eventTab:
        #    self.eventTab()
        #return TRUE
        return FALSE

    def OnIMEUpdate(self):
        ui.EditLine.OnIMEUpdate(self)
        self.__CheckChatMark()

    def __CheckChatMark(self):

        self.overTextLine.Hide()

        text = self.GetText()
        if len(text) > 0:
            if '#' == text[0]:
                self.overTextLine.SetText("#")
                self.overTextLine.Show()
            elif '%' == text[0]:
                self.overTextLine.SetText("%")
                self.overTextLine.Show()
            elif '!' == text[0]:
                self.overTextLine.SetText("!")
                self.overTextLine.Show()

    def OnIMEKeyDown(self, key):
        # LAST_SENTENCE_STACK
        if app.VK_UP == key:
            self.__PrevLastSentenceStack()
            return TRUE

        if app.VK_DOWN == key:
            self.__NextLastSentenceStack()                
            return TRUE            
        # END_OF_LAST_SENTENCE_STACK

        ui.EditLine.OnIMEKeyDown(self, key)

    # LAST_SENTENCE_STACK
    def __PrevLastSentenceStack(self):
        global ENABLE_LAST_SENTENCE_STACK
        if not ENABLE_LAST_SENTENCE_STACK:
            return

        if self.lastSentenceStack and self.lastSentencePos < len(self.lastSentenceStack):
            self.lastSentencePos += 1
            lastSentence = self.lastSentenceStack[-self.lastSentencePos]
            self.SetText(lastSentence)                
            self.SetEndPosition()            

    def __NextLastSentenceStack(self):
        global ENABLE_LAST_SENTENCE_STACK
        if not ENABLE_LAST_SENTENCE_STACK:
            return

        if self.lastSentenceStack and self.lastSentencePos > 1:
            self.lastSentencePos -= 1
            lastSentence = self.lastSentenceStack[-self.lastSentencePos]
            self.SetText(lastSentence)                
            self.SetEndPosition()            

    def __PushLastSentenceStack(self, text):        
        global ENABLE_LAST_SENTENCE_STACK
        if not ENABLE_LAST_SENTENCE_STACK:
            return

        if len(text) <= 0:
            return
            
        LAST_SENTENCE_STACK_SIZE = 32
        if len(self.lastSentenceStack) > LAST_SENTENCE_STACK_SIZE:
            self.lastSentenceStack.pop(0)

        self.lastSentenceStack.append(text)
    # END_OF_LAST_SENTENCE_STACK

    def OnIMEReturn(self):
        text = self.GetText()
        textLen=len(text)

        # LAST_SENTENCE_STACK
        self.__PushLastSentenceStack(text)
        # END_OF_LAST_SENTENCE_STACK
                
        textSpaceCount=text.count(' ')

        if (textLen > 0) and (textLen != textSpaceCount):
            if '#' == text[0]:
                self.__SendPartyChatPacket(text)
            elif '%' == text[0]:
                self.__SendGuildChatPacket(text)
            elif '!' == text[0]:
                self.__SendShoutChatPacket(text)
            else:
                self.__SendTalkingChatPacket(text)
        else:
            self.__ClearChat()
            self.eventReturn()

        return TRUE

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

    def RunCloseEvent(self):
        self.eventEscape()

    def BindInterface(self, interface):
        self.interface = interface

    def OnMouseLeftButtonDown(self):
        hyperlink = ui.GetHyperlink()
        if hyperlink:
            if app.IsPressed(app.DIK_LALT):
                link = chat.GetLinkFromHyperlink(hyperlink)
                ime.PasteString(link)
            else:
                self.interface.MakeHyperlinkTooltip(hyperlink)
        else:
            ui.EditLine.OnMouseLeftButtonDown(self)

class ChatInputSet(ui.Window):

    CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)

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

        InsertChatInputSetWindow(self)
        self.__Create()

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

    def __Create(self):
        chatModeButton = ChatModeButton()
        chatModeButton.SetParent(self)
        chatModeButton.SetSize(40, 17)
        chatModeButton.SetText(locale.CHAT_NORMAL)
        chatModeButton.SetPosition(7, 2)
        chatModeButton.SAFE_SetEvent(self.OnChangeChatMode)
        self.chatModeButton = chatModeButton

        chatLine = ChatLine()
        chatLine.SetParent(self)
        chatLine.SetMax(512)
        chatLine.SetUserMax(76)
        chatLine.SetText("")
        chatLine.SAFE_SetTabEvent(self.OnChangeChatMode)
        chatLine.x = 0
        chatLine.y = 0
        chatLine.width = 0
        chatLine.height = 0
        self.chatLine = chatLine

        btnSend = ui.Button()
        btnSend.SetParent(self)
        btnSend.SetUpVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_01.sub")
        btnSend.SetOverVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_02.sub")
        btnSend.SetDownVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_03.sub")
        btnSend.SetToolTipText(locale.CHAT_SEND_CHAT)
        btnSend.SAFE_SetEvent(self.chatLine.OnIMEReturn)
        self.btnSend = btnSend

    def Destroy(self):
        self.chatModeButton = None
        self.chatLine = None
        self.btnSend = None

    def Open(self):
        self.chatLine.Show()
        self.chatLine.SetPosition(57, 5)
        self.chatLine.SetFocus()
        self.chatLine.OpenChat()

        self.chatModeButton.SetPosition(7, 2)
        self.chatModeButton.Show()

        self.btnSend.Show()
        self.Show()

        self.RefreshPosition()
        return TRUE

    def Close(self):
        self.chatLine.KillFocus()
        self.chatLine.Hide()
        self.chatModeButton.Hide()
        self.btnSend.Hide()
        self.Hide()
        return TRUE

    def SetEscapeEvent(self, event):
        self.chatLine.SetEscapeEvent(event)

    def SetReturnEvent(self, event):
        self.chatLine.SetReturnEvent(event)

    def OnChangeChatMode(self):
        RefreshChatMode()

    def OnRefreshChatMode(self):
        self.chatLine.ChangeChatMode()
        self.chatModeButton.SetText(self.chatLine.GetCurrentChatModeName())

    def SetChatFocus(self):
        self.chatLine.SetFocus()

    def KillChatFocus(self):
        self.chatLine.KillFocus()

    def SetChatMax(self, max):
        self.chatLine.SetUserMax(max)

    def RefreshPosition(self):
        if locale.IsARABIC():
            self.chatLine.SetSize(self.GetWidth() - 93, 18)
        else:
            self.chatLine.SetSize(self.GetWidth() - 93, 13)

        self.btnSend.SetPosition(self.GetWidth() - 25, 2)

        (self.chatLine.x, self.chatLine.y, self.chatLine.width, self.chatLine.height) = self.chatLine.GetRect()

    def BindInterface(self, interface):
        self.chatLine.BindInterface(interface)

    def OnRender(self):
        (x, y, width, height) = self.chatLine.GetRect()
        ui.RenderRoundBox(x-4, y-3, width+7, height+4, self.CHAT_OUTLINE_COLOR)

## ChatWindow
class ChatWindow(ui.Window):

    BOARD_START_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.0)
    BOARD_END_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.8)
    BOARD_MIDDLE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
    CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)

    EDIT_LINE_HEIGHT = 25

    class ChatBackBoard(ui.Window):
        def __init__(self):
            ui.Window.__init__(self)
        def __del__(self):
            ui.Window.__del__(self)

    class ChatButton(ui.DragButton):

        def __init__(self):
            ui.DragButton.__init__(self)
            self.AddFlag("float")
            self.AddFlag("movable")
            self.AddFlag("restrict_x")
            self.topFlag = FALSE

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

        def SetOwner(self, owner):
            self.owner = owner

        def OnMouseOverIn(self):
            app.SetCursor(app.VSIZE)

        def OnMouseOverOut(self):
            app.SetCursor(app.NORMAL)

        def OnTop(self):
            if TRUE == self.topFlag:
                return

            self.topFlag = TRUE
            self.owner.SetTop()
            self.topFlag = FALSE

    def __init__(self):
        ui.Window.__init__(self)
        self.AddFlag("float")

        self.__RegisterChatColorDict()

        self.boardState = chat.BOARD_STATE_VIEW
        self.chatID = chat.CreateChatSet(chat.CHAT_SET_CHAT_WINDOW)
        chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)

        self.xBar = 0
        self.yBar = 0
        self.widthBar = 0
        self.heightBar = 0
        self.curHeightBar = 0
        self.visibleLineCount = 0
        self.scrollBarPos = 1.0
        self.scrollLock = FALSE

        chatInputSet = ChatInputSet()
        chatInputSet.SetParent(self)
        chatInputSet.SetEscapeEvent(ui.__mem_func__(self.CloseChat))
        chatInputSet.SetReturnEvent(ui.__mem_func__(self.CloseChat))
        chatInputSet.SetSize(550, 25)
        self.chatInputSet = chatInputSet

        btnSendWhisper = ui.Button()
        btnSendWhisper.SetParent(self)
        btnSendWhisper.SetUpVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_01.sub")
        btnSendWhisper.SetOverVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_02.sub")
        btnSendWhisper.SetDownVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_03.sub")
        btnSendWhisper.SetToolTipText(locale.CHAT_SEND_MEMO)
        btnSendWhisper.Hide()
        self.btnSendWhisper = btnSendWhisper

        btnChatLog = ui.Button()
        btnChatLog.SetParent(self)
        btnChatLog.SetUpVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_01.sub")
        btnChatLog.SetOverVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_02.sub")
        btnChatLog.SetDownVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_03.sub")
        btnChatLog.SetToolTipText(locale.CHAT_LOG)
        btnChatLog.Hide()
        self.btnChatLog = btnChatLog

        btnChatSizing = self.ChatButton()
        btnChatSizing.SetOwner(self)
        btnChatSizing.SetMoveEvent(ui.__mem_func__(self.Refresh))
        btnChatSizing.Hide()
        self.btnChatSizing = btnChatSizing

        imgChatBarLeft = ui.ImageBox()
        imgChatBarLeft.SetParent(self.btnChatSizing)
        imgChatBarLeft.AddFlag("not_pick")
        imgChatBarLeft.LoadImage("d:/ymir work/ui/pattern/chat_bar_left.tga")
        imgChatBarLeft.Show()
        self.imgChatBarLeft = imgChatBarLeft
        imgChatBarRight = ui.ImageBox()
        imgChatBarRight.SetParent(self.btnChatSizing)
        imgChatBarRight.AddFlag("not_pick")
        imgChatBarRight.LoadImage("d:/ymir work/ui/pattern/chat_bar_right.tga")
        imgChatBarRight.Show()
        self.imgChatBarRight = imgChatBarRight
        imgChatBarMiddle = ui.ExpandedImageBox()
        imgChatBarMiddle.SetParent(self.btnChatSizing)
        imgChatBarMiddle.AddFlag("not_pick")
        imgChatBarMiddle.LoadImage("d:/ymir work/ui/pattern/chat_bar_middle.tga")
        imgChatBarMiddle.Show()
        self.imgChatBarMiddle = imgChatBarMiddle

        scrollBar = ui.ScrollBar()
        scrollBar.AddFlag("float")
        scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
        self.scrollBar = scrollBar

        self.Refresh()
        self.chatInputSet.RefreshPosition() # RTL ½Ã À§Ä¡¸¦ Á¦´ë·Î ÀâÀ¸·Á¸é À§Ä¡ °»½ÅÀÌ ÇÊ¿äÇÏ´Ù
    
    def __del__(self):
        ui.Window.__del__(self)

    def __RegisterChatColorDict(self):
        CHAT_COLOR_DICT = {
            chat.CHAT_TYPE_TALKING : colorInfo.CHAT_RGB_TALK,
            chat.CHAT_TYPE_INFO : colorInfo.CHAT_RGB_INFO,
            chat.CHAT_TYPE_NOTICE : colorInfo.CHAT_RGB_NOTICE,
            chat.CHAT_TYPE_PARTY : colorInfo.CHAT_RGB_PARTY,
            chat.CHAT_TYPE_GUILD : colorInfo.CHAT_RGB_GUILD,
            chat.CHAT_TYPE_COMMAND : colorInfo.CHAT_RGB_COMMAND,
            chat.CHAT_TYPE_SHOUT : colorInfo.CHAT_RGB_SHOUT,
            chat.CHAT_TYPE_WHISPER : colorInfo.CHAT_RGB_WHISPER,
        }

        for colorItem in CHAT_COLOR_DICT.items():
            type=colorItem[0]
            rgb=colorItem[1]
            chat.SetChatColor(type, rgb[0], rgb[1], rgb[2])

    def Destroy(self):
        self.chatInputSet.Destroy()
        self.chatInputSet = None

        self.btnSendWhisper = 0
        self.btnChatLog = 0
        self.btnChatSizing = 0

    ################
    ## Open & Close
    def OpenChat(self):
        chat.SetBoardState(self.chatID, chat.BOARD_STATE_EDIT)
        self.boardState = chat.BOARD_STATE_EDIT

        (x, y, width, height) = self.GetRect()
        (btnX, btnY) = self.btnChatSizing.GetGlobalPosition()

        if locale.IsARABIC():
            chat.SetPosition(self.chatID, x + width - 10, y)
        else:    
            chat.SetPosition(self.chatID, x + 10, y)

        chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)

        if self.IsShow():
            self.btnChatSizing.Show()

        self.Refresh()

        self.btnSendWhisper.SetPosition(self.GetWidth() - 50, 2)
        self.btnSendWhisper.Show()

        self.btnChatLog.SetPosition(self.GetWidth() - 25, 2)
        self.btnChatLog.Show()

        self.chatInputSet.Open()
        self.SetTop()

    def CloseChat(self):
        chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)
        self.boardState = chat.BOARD_STATE_VIEW

        (x, y, width, height) = self.GetRect()

        if locale.IsARABIC():
            chat.SetPosition(self.chatID, x + width - 10, y + height)
        else:
            chat.SetPosition(self.chatID, x + 10, y + height)

        self.chatInputSet.Close()
        self.btnSendWhisper.Hide()
        self.btnChatLog.Hide()
        self.btnChatSizing.Hide()
        self.Refresh()

    def SetSendWhisperEvent(self, event):
        self.btnSendWhisper.SetEvent(event)

    def SetOpenChatLogEvent(self, event):
        self.btnChatLog.SetEvent(event)

    def IsEditMode(self):
        if chat.BOARD_STATE_EDIT == self.boardState:
            return TRUE

        return FALSE

    def __RefreshSizingBar(self):
        (x, y, width, height) = self.GetRect()
        gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
        self.btnChatSizing.SetPosition(x, gyChat)
        self.btnChatSizing.SetSize(width, 22)
        self.imgChatBarLeft.SetPosition(0, 0)
        self.imgChatBarRight.SetPosition(width - 64, 0)
        self.imgChatBarMiddle.SetPosition(64, 0)
        self.imgChatBarMiddle.SetRenderingRect(0.0, 0.0, float(width - 128) / 64.0 - 1.0, 0.0)

    def SetPosition(self, x, y):
        ui.Window.SetPosition(self, x, y)
        self.__RefreshSizingBar()

    def SetSize(self, width, height):
        ui.Window.SetSize(self, width, height)
        self.__RefreshSizingBar()

    def SetHeight(self, height):
        gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
        self.btnChatSizing.SetPosition(gxChat, wndMgr.GetScreenHeight() - height)

    ###########
    ## Refresh
    def Refresh(self):
        if self.boardState == chat.BOARD_STATE_EDIT:
            self.RefreshBoardEditState()
        elif self.boardState == chat.BOARD_STATE_VIEW:
            self.RefreshBoardViewState()

    def RefreshBoardEditState(self):

        (x, y, width, height) = self.GetRect()
        (btnX, btnY) = self.btnChatSizing.GetGlobalPosition()

        self.xBar = x
        self.yBar = btnY
        self.widthBar = width
        self.heightBar = y - btnY + self.EDIT_LINE_HEIGHT
        self.curHeightBar = self.heightBar

        if locale.IsARABIC():
            chat.SetPosition(self.chatID, x + width - 10, y)
        else:
            chat.SetPosition(self.chatID, x + 10, y)

        chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT)
        chat.ArrangeShowingChat(self.chatID)

        if btnY > y:
            self.btnChatSizing.SetPosition(btnX, y)
            self.heightBar = self.EDIT_LINE_HEIGHT

    def RefreshBoardViewState(self):
        (x, y, width, height) = self.GetRect()
        (btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
        textAreaHeight = self.visibleLineCount * chat.GetLineStep(self.chatID)

        if locale.IsARABIC():
            chat.SetPosition(self.chatID, x + width - 10, y + height)
        else:
            chat.SetPosition(self.chatID, x + 10, y + height)

        chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)

        if self.boardState == chat.BOARD_STATE_EDIT:
            textAreaHeight += 45
        elif self.visibleLineCount != 0:
            textAreaHeight += 10 + 10

        self.xBar = x
        self.yBar = y + height - textAreaHeight
        self.widthBar = width
        self.heightBar = textAreaHeight

        self.scrollBar.Hide()

    ##########
    ## Render
    def OnUpdate(self):
        if self.boardState == chat.BOARD_STATE_EDIT:
            chat.Update(self.chatID)
        elif self.boardState == chat.BOARD_STATE_VIEW:
            if systemSetting.IsViewChat():
                chat.Update(self.chatID)

    def OnRender(self):
        if chat.GetVisibleLineCount(self.chatID) != self.visibleLineCount:
            self.visibleLineCount = chat.GetVisibleLineCount(self.chatID)
            self.Refresh()

        if self.curHeightBar != self.heightBar:
            self.curHeightBar += (self.heightBar - self.curHeightBar) / 10

        if self.boardState == chat.BOARD_STATE_EDIT:
            grp.SetColor(self.BOARD_MIDDLE_COLOR)
            grp.RenderBar(self.xBar, self.yBar + (self.heightBar - self.curHeightBar) + 10, self.widthBar, self.curHeightBar)
            chat.Render(self.chatID)
        elif self.boardState == chat.BOARD_STATE_VIEW:
            if systemSetting.IsViewChat():
                grp.RenderGradationBar(self.xBar, self.yBar + (self.heightBar - self.curHeightBar), self.widthBar, self.curHeightBar, self.BOARD_START_COLOR, self.BOARD_END_COLOR)
                chat.Render(self.chatID)

    ##########
    ## Event
    def OnTop(self):
        self.btnChatSizing.SetTop()
        self.scrollBar.SetTop()

    def OnScroll(self):
        if not self.scrollLock:
            self.scrollBarPos = self.scrollBar.GetPos()

        lineCount = chat.GetLineCount(self.chatID)
        visibleLineCount = chat.GetVisibleLineCount(self.chatID)
        endLine = visibleLineCount + int(float(lineCount - visibleLineCount) * self.scrollBarPos)

        chat.SetEndPos(self.chatID, self.scrollBarPos)

    def OnChangeChatMode(self):
        self.chatInputSet.OnChangeChatMode()

    def SetChatFocus(self):
        self.chatInputSet.SetChatFocus()            

    def BindInterface(self, interface):
        self.chatInputSet.BindInterface(interface)

## ChatLogWindow
class ChatLogWindow(ui.Window):

    BLOCK_WIDTH = 32
    CHAT_MODE_NAME = ( locale.CHAT_NORMAL, locale.CHAT_PARTY, locale.CHAT_GUILD, locale.CHAT_SHOUT, locale.CHAT_INFORMATION, locale.CHAT_NOTICE, )
    CHAT_MODE_INDEX = ( chat.CHAT_TYPE_TALKING,
                        chat.CHAT_TYPE_PARTY,
                        chat.CHAT_TYPE_GUILD,
                        chat.CHAT_TYPE_SHOUT,
                        chat.CHAT_TYPE_INFO,
                        chat.CHAT_TYPE_NOTICE, )

    CHAT_LOG_WINDOW_MINIMUM_WIDTH = 450
    CHAT_LOG_WINDOW_MINIMUM_HEIGHT = 120

    class ResizeButton(ui.DragButton):

        def __init__(self):
            ui.DragButton.__init__(self)

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

        def OnMouseOverIn(self):
            app.SetCursor(app.HVSIZE)

        def OnMouseOverOut(self):
            app.SetCursor(app.NORMAL)

    def __init__(self):

        self.allChatMode = TRUE
        self.chatInputSet = None

        ui.Window.__init__(self)
        self.AddFlag("float")
        self.AddFlag("movable")

        self.__CreateChatInputSet()
        self.__CreateWindow()
        self.__CreateButton()
        self.__CreateScrollBar()

        self.chatID = chat.CreateChatSet(chat.CHAT_SET_LOG_WINDOW)
        chat.SetBoardState(self.chatID, chat.BOARD_STATE_LOG)
        for i in self.CHAT_MODE_INDEX:
            chat.EnableChatMode(self.chatID, i)

        self.SetPosition(20, 20)
        self.SetSize(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT)
        self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH-self.btnSizing.GetWidth(), self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT-self.btnSizing.GetHeight()+2)

        self.OnResize()

    def __CreateChatInputSet(self):
        chatInputSet = ChatInputSet()
        chatInputSet.SetParent(self)
        chatInputSet.SetEscapeEvent(ui.__mem_func__(self.Close))
        chatInputSet.SetWindowVerticalAlignBottom()
        chatInputSet.Open()
        self.chatInputSet = chatInputSet

    def __CreateWindow(self):
        imgLeft = ui.ImageBox()
        imgLeft.AddFlag("not_pick")
        imgLeft.SetParent(self)                

        imgCenter = ui.ExpandedImageBox()
        imgCenter.AddFlag("not_pick")
        imgCenter.SetParent(self)
        
        imgRight = ui.ImageBox()
        imgRight.AddFlag("not_pick")
        imgRight.SetParent(self)            
        
        if locale.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/chatlogwindow_titlebar_left.tga")
            imgCenter.LoadImage("d:/ymir work/ui/pattern/chatlogwindow_titlebar_middle.tga")
            imgRight.LoadImage("d:/ymir work/ui/pattern/chatlogwindow_titlebar_right.tga")        

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

        btnClose = ui.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(locale.UI_CLOSE, 0, -23)
        btnClose.SetEvent(ui.__mem_func__(self.Close))
        btnClose.Show()

        btnSizing = self.ResizeButton()
        btnSizing.SetParent(self)
        btnSizing.SetMoveEvent(ui.__mem_func__(self.OnResize))
        btnSizing.SetSize(16, 16)
        btnSizing.Show()

        titleName = ui.TextLine()
        titleName.SetParent(self)
        
        if locale.IsARABIC():
            titleName.SetPosition(self.GetWidth()-20, 6)
        else:
            titleName.SetPosition(20, 6)
            
        titleName.SetText(locale.CHAT_LOG_TITLE)
        titleName.Show()

        self.imgLeft = imgLeft
        self.imgCenter = imgCenter
        self.imgRight = imgRight
        self.btnClose = btnClose
        self.btnSizing = btnSizing
        self.titleName = titleName

    def __CreateButton(self):
    
        if locale.IsARABIC():
            bx = 20
        else:
            bx = 13

        btnAll = ui.RadioButton()
        btnAll.SetParent(self)
        btnAll.SetPosition(bx, 24)
        btnAll.SetUpVisual("d:/ymir work/ui/public/xsmall_button_01.sub")
        btnAll.SetOverVisual("d:/ymir work/ui/public/xsmall_button_02.sub")
        btnAll.SetDownVisual("d:/ymir work/ui/public/xsmall_button_03.sub")
        btnAll.SetText(locale.CHAT_ALL)
        btnAll.SetEvent(ui.__mem_func__(self.ToggleAllChatMode))
        btnAll.Down()
        btnAll.Show()
        self.btnAll = btnAll

        x = bx + 48
        i = 0
        self.modeButtonList = []
        for name in self.CHAT_MODE_NAME:
            btn = ui.ToggleButton()
            btn.SetParent(self)
            btn.SetPosition(x, 24)
            btn.SetUpVisual("d:/ymir work/ui/public/xsmall_button_01.sub")
            btn.SetOverVisual("d:/ymir work/ui/public/xsmall_button_02.sub")
            btn.SetDownVisual("d:/ymir work/ui/public/xsmall_button_03.sub")
            btn.SetText(name)
            btn.Show()

            mode = self.CHAT_MODE_INDEX[i]
            btn.SetToggleUpEvent(lambda arg=mode: self.ToggleChatMode(arg))
            btn.SetToggleDownEvent(lambda arg=mode: self.ToggleChatMode(arg))
            self.modeButtonList.append(btn)

            x += 48
            i += 1

    def __CreateScrollBar(self):
        scrollBar = ui.SmallThinScrollBar()
        scrollBar.SetParent(self)
        scrollBar.Show()
        scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
        self.scrollBar = scrollBar
        self.scrollBarPos = 1.0

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

    def Destroy(self):
        self.imgLeft = None
        self.imgCenter = None
        self.imgRight = None
        self.btnClose = None
        self.btnSizing = None
        self.modeButtonList = []
        self.scrollBar = None
        self.chatInputSet = None

    def ToggleAllChatMode(self):
        if self.allChatMode:
            return

        self.allChatMode = TRUE

        for i in self.CHAT_MODE_INDEX:
            chat.EnableChatMode(self.chatID, i)
        for btn in self.modeButtonList:
            btn.SetUp()

    def ToggleChatMode(self, mode):
        if self.allChatMode:
            self.allChatMode = FALSE
            for i in self.CHAT_MODE_INDEX:
                chat.DisableChatMode(self.chatID, i)
            chat.EnableChatMode(self.chatID, mode)
            self.btnAll.SetUp()

        else:
            chat.ToggleChatMode(self.chatID, mode)

    def SetSize(self, width, height):
        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 locale.IsARABIC():
            self.titleName.SetPosition(self.GetWidth()-20, 3)
            self.btnClose.SetPosition(3, 3)
            self.scrollBar.SetPosition(1, 45)
        else:
            self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 5, 5)            
            self.scrollBar.SetPosition(width - 15, 45)
            
        self.scrollBar.SetScrollBarSize(height - 45 - 12)
        self.scrollBar.SetPos(self.scrollBarPos)
        ui.Window.SetSize(self, width, height)

    def Open(self):
        self.OnResize()
        self.chatInputSet.SetChatFocus()
        self.Show()

    def Close(self):
        if self.chatInputSet:
            self.chatInputSet.KillChatFocus()
        self.Hide()

    def OnResize(self):
        x, y = self.btnSizing.GetLocalPosition()
        width = self.btnSizing.GetWidth()
        height = self.btnSizing.GetHeight()

        if x < self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width:
            self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width, y)
            return
        if y < self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height:
            self.btnSizing.SetPosition(x, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height)
            return

        self.scrollBar.LockScroll()
        self.SetSize(x + width, y + height)
        self.scrollBar.UnlockScroll()

        if locale.IsARABIC():
            self.chatInputSet.SetPosition(20, 25)
        else:
            self.chatInputSet.SetPosition(0, 25)
            
        self.chatInputSet.SetSize(self.GetWidth() - 20, 20)
        self.chatInputSet.RefreshPosition()
        self.chatInputSet.SetChatMax(self.GetWidth() / 8)

    def OnScroll(self):
        self.scrollBarPos = self.scrollBar.GetPos()

        lineCount = chat.GetLineCount(self.chatID)
        visibleLineCount = chat.GetVisibleLineCount(self.chatID)
        endLine = visibleLineCount + int(float(lineCount - visibleLineCount) * self.scrollBarPos)

        chat.SetEndPos(self.chatID, self.scrollBarPos)

    def OnRender(self):
        (x, y, width, height) = self.GetRect()
        
        if locale.IsARABIC():
            grp.SetColor(0x77000000)
            grp.RenderBar(x+2, y+45, 13, height-45)
            
            grp.SetColor(0x77000000)
            grp.RenderBar(x, y, width, height)
            grp.SetColor(0xff525552)
            grp.RenderBox(x, y, width-2, height)
            grp.SetColor(0xff000000)
            grp.RenderBox(x+1, y+1, width-2, height)

            grp.SetColor(0xff989898)
            grp.RenderLine(x+width-13, y+height-1, 11, -11)
            grp.RenderLine(x+width-9, y+height-1, 7, -7)
            grp.RenderLine(x+width-5, y+height-1, 3, -3)
        else:            
            grp.SetColor(0x77000000)
            grp.RenderBar(x+width-15, y+45, 13, height-45)

            grp.SetColor(0x77000000)
            grp.RenderBar(x, y, width, height)
            grp.SetColor(0xff525552)
            grp.RenderBox(x, y, width-2, height)
            grp.SetColor(0xff000000)
            grp.RenderBox(x+1, y+1, width-2, height)

            grp.SetColor(0xff989898)
            grp.RenderLine(x+width-13, y+height-1, 11, -11)
            grp.RenderLine(x+width-9, y+height-1, 7, -7)
            grp.RenderLine(x+width-5, y+height-1, 3, -3)

        #####

        chat.ArrangeShowingChat(self.chatID)

        if locale.IsARABIC():
            chat.SetPosition(self.chatID, x + width - 10, y + height - 25)
        else:
            chat.SetPosition(self.chatID, x + 10, y + height - 25)

        chat.SetHeight(self.chatID, height - 45 - 25)
        chat.Update(self.chatID)
        chat.Render(self.chatID)

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

    def BindInterface(self, interface):
        self.interface = interface
        
    def OnMouseLeftButtonDown(self):
        hyperlink = ui.GetHyperlink()
        if hyperlink:
            if app.IsPressed(app.DIK_LALT):
                link = chat.GetLinkFromHyperlink(hyperlink)
                ime.PasteString(link)
            else:
                self.interface.MakeHyperlinkTooltip(hyperlink) 


uiwhisper.py

 Spoiler

PHP Code:

import ui
import net
import chat
import player
import app
import locale
import ime
import chr

class WhisperButton(ui.Button):
    def __init__(self):
        ui.Button.__init__(self, "TOP_MOST")

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

    def SetToolTipText(self, text, x=0, y = 32):
        ui.Button.SetToolTipText(self, text, x, y)
        self.ToolTipText.Show()

    def SetToolTipTextWithColor(self, text, color, x=0, y = 32):
        ui.Button.SetToolTipText(self, text, x, y)
        self.ToolTipText.SetPackedFontColor(color)
        self.ToolTipText.Show()

    def ShowToolTip(self):
        if 0 != self.ToolTipText:
            self.ToolTipText.Show()

    def HideToolTip(self):
        if 0 != self.ToolTipText:
            self.ToolTipText.Show()

class WhisperDialog(ui.ScriptWindow):

    class TextRenderer(ui.Window):
        def SetTargetName(self, targetName):
            self.targetName = targetName

        def OnRender(self):
            (x, y) = self.GetGlobalPosition()
            chat.RenderWhisper(self.targetName, x, y)

    class ResizeButton(ui.DragButton):

        def __init__(self):
            ui.DragButton.__init__(self)

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

        def OnMouseOverIn(self):
            app.SetCursor(app.HVSIZE)

        def OnMouseOverOut(self):
            app.SetCursor(app.NORMAL)

    def __init__(self, eventMinimize, eventClose):
        print "NEW WHISPER DIALOG  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.targetName = ""
        self.eventMinimize = eventMinimize
        self.eventClose = eventClose
        self.eventAcceptTarget = None
    def __del__(self):
        print "---------------------------------------------------------------------------- DELETE WHISPER DIALOG"
        ui.ScriptWindow.__del__(self)        

    def LoadDialog(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/WhisperDialog.py")
        except:
            import exception
            exception.Abort("WhisperDialog.LoadDialog.LoadScript")

        try:
            GetObject=self.GetChild
            self.titleName = GetObject("titlename")
            self.titleNameEdit = GetObject("titlename_edit")
            self.closeButton = GetObject("closebutton")
            self.scrollBar = GetObject("scrollbar")
            self.chatLine = GetObject("chatline")
            self.minimizeButton = GetObject("minimizebutton")
            self.ignoreButton = GetObject("ignorebutton")
            self.reportViolentWhisperButton = GetObject("reportviolentwhisperbutton")
            self.acceptButton = GetObject("acceptbutton")
            self.sendButton = GetObject("sendbutton")
            self.board = GetObject("board")
            self.editBar = GetObject("editbar")
            self.gamemasterMark = GetObject("gamemastermark")
        except:
            import exception
            exception.Abort("DialogWindow.LoadDialog.BindObject")

        self.gamemasterMark.Hide()
        self.titleName.SetText("")
        self.titleNameEdit.SetText("")
        self.minimizeButton.SetEvent(ui.__mem_func__(self.Minimize))
        self.closeButton.SetEvent(ui.__mem_func__(self.Close))
        self.scrollBar.SetPos(1.0)
        self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
        self.chatLine.SetReturnEvent(ui.__mem_func__(self.SendWhisper))
        self.chatLine.SetEscapeEvent(ui.__mem_func__(self.Minimize))
        self.chatLine.SetMultiLine()
        self.sendButton.SetEvent(ui.__mem_func__(self.SendWhisper))
        self.titleNameEdit.SetReturnEvent(ui.__mem_func__(self.AcceptTarget))
        self.titleNameEdit.SetEscapeEvent(ui.__mem_func__(self.Close))
        self.ignoreButton.SetToggleDownEvent(ui.__mem_func__(self.IgnoreTarget))
        self.ignoreButton.SetToggleUpEvent(ui.__mem_func__(self.IgnoreTarget))
        self.reportViolentWhisperButton.SetEvent(ui.__mem_func__(self.ReportViolentWhisper))
        self.acceptButton.SetEvent(ui.__mem_func__(self.AcceptTarget))

        self.textRenderer = self.TextRenderer()
        self.textRenderer.SetParent(self)
        self.textRenderer.SetPosition(20, 28)
        self.textRenderer.SetTargetName("")
        self.textRenderer.Show()

        self.resizeButton = self.ResizeButton()
        self.resizeButton.SetParent(self)
        self.resizeButton.SetSize(20, 20)
        self.resizeButton.SetPosition(280, 180)
        self.resizeButton.SetMoveEvent(ui.__mem_func__(self.ResizeWhisperDialog))
        self.resizeButton.Show()

        self.ResizeWhisperDialog()

    def Destroy(self):

        self.eventMinimize = None
        self.eventClose = None
        self.eventAcceptTarget = None

        self.ClearDictionary()
        self.scrollBar.Destroy()
        self.titleName = None
        self.titleNameEdit = None
        self.closeButton = None
        self.scrollBar = None
        self.chatLine = None
        self.sendButton = None
        self.ignoreButton = None
        self.reportViolentWhisperButton = None
        self.acceptButton = None
        self.minimizeButton = None
        self.textRenderer = None
        self.board = None
        self.editBar = None
        self.resizeButton = None

    def ResizeWhisperDialog(self):
        (xPos, yPos) = self.resizeButton.GetLocalPosition()
        if xPos < 280:
            self.resizeButton.SetPosition(280, yPos)
            return
        if yPos < 150:
            self.resizeButton.SetPosition(xPos, 150)
            return
        self.SetWhisperDialogSize(xPos + 20, yPos + 20)

    def SetWhisperDialogSize(self, width, height):
        try:

            max = int((width-90)/6) * 3 - 6

            self.board.SetSize(width, height)
            self.scrollBar.SetPosition(width-25, 35)
            self.scrollBar.SetScrollBarSize(height-100)
            self.scrollBar.SetPos(1.0)
            self.editBar.SetSize(width-18, 50)
            self.chatLine.SetSize(width-90, 40)
            self.chatLine.SetLimitWidth(width-90)
            self.SetSize(width, height)

            if 0 != self.targetName:
                chat.SetWhisperBoxSize(self.targetName, width - 50, height - 90)            
            
            if locale.IsARABIC():
                self.textRenderer.SetPosition(width-20, 28)
                self.scrollBar.SetPosition(width-25+self.scrollBar.GetWidth(), 35)
                self.editBar.SetPosition(10 + self.editBar.GetWidth(), height-60)
                self.sendButton.SetPosition(width - 80 + self.sendButton.GetWidth(), 10)
                self.minimizeButton.SetPosition(width-42 + self.minimizeButton.GetWidth(), 12)
                self.closeButton.SetPosition(width-24+self.closeButton.GetWidth(), 12)                
                self.chatLine.SetPosition(5 + self.chatLine.GetWidth(), 5)
                self.board.SetPosition(self.board.GetWidth(), 0)
            else:
                self.textRenderer.SetPosition(20, 28)
                self.scrollBar.SetPosition(width-25, 35)
                self.editBar.SetPosition(10, height-60)
                self.sendButton.SetPosition(width-80, 10)
                self.minimizeButton.SetPosition(width-42, 12)
                self.closeButton.SetPosition(width-24, 12)

            self.SetChatLineMax(max)

        except:
            import exception
            exception.Abort("WhisperDialog.SetWhisperDialogSize.BindObject")

    def SetChatLineMax(self, max):
        self.chatLine.SetMax(max)

        from grpText import GetSplitingTextLine

        text = self.chatLine.GetText()
        if text:
            self.chatLine.SetText(GetSplitingTextLine(text, max, 0))

    def OpenWithTarget(self, targetName):
        chat.CreateWhisper(targetName)
        chat.SetWhisperBoxSize(targetName, self.GetWidth() - 60, self.GetHeight() - 90)
        self.chatLine.SetFocus()
        self.titleName.SetText(targetName)
        self.targetName = targetName
        self.textRenderer.SetTargetName(targetName)
        self.titleNameEdit.Hide()
        self.ignoreButton.Hide()
        if app.IsDevStage():
            self.reportViolentWhisperButton.Show()
        else:
            self.reportViolentWhisperButton.Hide()
        self.acceptButton.Hide()
        self.gamemasterMark.Hide()
        self.minimizeButton.Show()

    def OpenWithoutTarget(self, event):
        self.eventAcceptTarget = event
        self.titleName.SetText("")
        self.titleNameEdit.SetText("")
        self.titleNameEdit.SetFocus()
        self.targetName = 0
        self.titleNameEdit.Show()
        self.ignoreButton.Hide()
        self.reportViolentWhisperButton.Hide()
        self.acceptButton.Show()
        self.minimizeButton.Hide()
        self.gamemasterMark.Hide()

    def SetGameMasterLook(self):
        self.gamemasterMark.Show()
        self.reportViolentWhisperButton.Hide()

    def Minimize(self):
        self.titleNameEdit.KillFocus()
        self.chatLine.KillFocus()
        self.Hide()

        if None != self.eventMinimize:
            self.eventMinimize(self.targetName)

    def Close(self):
        chat.ClearWhisper(self.targetName)
        self.titleNameEdit.KillFocus()
        self.chatLine.KillFocus()
        self.Hide()

        if None != self.eventClose:
            self.eventClose(self.targetName)

    def ReportViolentWhisper(self):
        net.SendChatPacket("/reportviolentwhisper " + self.targetName)

    def IgnoreTarget(self):
        net.SendChatPacket("/ignore " + self.targetName)

    def AcceptTarget(self):
        name = self.titleNameEdit.GetText()
        if len(name) <= 0:
            self.Close()
            return

        if None != self.eventAcceptTarget:
            self.titleNameEdit.KillFocus()
            self.eventAcceptTarget(name)

    def OnScroll(self):
        chat.SetWhisperPosition(self.targetName, self.scrollBar.GetPos())

    def SendWhisper(self):

        text = self.chatLine.GetText()
        textLength = len(text)

        if textLength > 0:
            if net.IsInsultIn(text):
                chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_INSULT_STRING)
                return

            net.SendWhisperPacket(self.targetName, text)
            self.chatLine.SetText("")

            chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, self.targetName, player.GetName() + " : " + text)

    def OnTop(self):
        self.chatLine.SetFocus()
        
    def BindInterface(self, interface):
        self.interface = interface
        
    def OnMouseLeftButtonDown(self):
        hyperlink = ui.GetHyperlink()
        if hyperlink:
            if app.IsPressed(app.DIK_LALT):
                link = chat.GetLinkFromHyperlink(hyperlink)
                ime.PasteString(link)
            else:
                self.interface.MakeHyperlinkTooltip(hyperlink)

if "__main__" == __name__:
    import uiTest

    class TestApp(uiTest.App):
        def OnInit(self):
            wnd = WhisperDialog(self.OnMax, self.OnMin)
            wnd.LoadDialog()
            wnd.OpenWithoutTarget(self.OnNew)
            wnd.SetPosition(0, 0)
            wnd.Show()

            self.wnd = wnd

        def OnMax(self):
            pass

        def OnMin(self):
            pass

        def OnNew(self):
            pass

    TestApp().MainLoop() 


Ich hoffe ihr könnt mir Helfen.
Gruß Done

[DasSchwarzeT]

Du nutzt den Invoice Client, oder?

[Sir.?]

in der ui ist es glaube ich dort musst du ein "elf" zu "self" machen mfg.

[Lino™]

Originally Posted by DasSchwarzeT

Du nutzt den Invoice Client, oder?

Nein

Originally Posted by Rikarshi ™

in der ui ist es glaube ich dort musst du ein "elf" zu "self" machen mfg.

Hier mal die ui.py

 Spoiler

PHP Code:

import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import locale

# MARK_BUG_FIX
import guild
# END_OF_MARK_BUG_FIX

from _weakref import proxy

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

if locale.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(locale.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.RegisterWindow(layer)
        self.Hide()

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

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

    def Destroy(self):
        pass

    def GetWindowHandle(self):
        return self.hWnd

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

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

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

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

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

    
    def GetParentProxy(self):
        return self.parentWindow

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
class ListBoxEx(Window):

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

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

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

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

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

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

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

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

        if locale.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 locale.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(locale.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, locale.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={}

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

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

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

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

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

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

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

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

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

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


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

    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 SetPercentage(self, curValue, maxValue):
        wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)

    def OnEndFrame(self):
        pass

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

        self.eventFunc = None
        self.eventArgs = None

        self.ButtonText = None
        self.ToolTipText = None

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

        self.eventFunc = None
        self.eventArgs = None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        self.ButtonText.SetText(text)

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

        self.ToolTipText.SetText(text)

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

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

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

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

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

    def HideToolTip(self):
        if self.ToolTipText:
            self.ToolTipText.Hide()
            
    def IsDown(self):
        return wndMgr.IsDown(self.hWnd)

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

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

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

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

        self.eventUp = None
        self.eventDown = None

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

        self.eventUp = None
        self.eventDown = None

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

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

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

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

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

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

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

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

        self.eventMove = lambda: None

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

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

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

    def TurnOnCallBack(self):
        self.callbackEnable = TRUE

    def TurnOffCallBack(self):
        self.callbackEnable = FALSE

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

class NumberLine(Window):

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

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

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

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

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

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

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

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

class Box(Window):

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

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

class Bar(Window):

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

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

class Line(Window):

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

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

class SlotBar(Window):

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

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

## Same with SlotBar
class Bar3D(Window):

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

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

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

class SlotWindow(Window):

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

        self.StartIndex = 0

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

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

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

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

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

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

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

    def 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 AppendSlotButton(self, upName, overName, downName):
        wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def SetUseMode(self, flag):
        "TRUEÀ϶§¸¸ ItemToItem ÀÌ °¡´ÉÇÑÁö º¸¿©ÁØ´Ù"
        wndMgr.SetUseMode(self.hWnd, flag)

    def SetUsableItem(self, flag): 
        "TRUE¸é ÇöÀç °¡¸®Å² ¾ÆÀÌÅÛÀÌ ItemToItem Àû¿ë °¡´ÉÇÏ´Ù"
        wndMgr.SetUsableItem(self.hWnd, flag)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def 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 locale.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(locale.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 locale.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 __init__(self):
        Window.__init__(self)
        self.AddFlag("attach")

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

    def Create(self, width):

        width = max(96, width)

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

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

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

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

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

class Gauge(Window):

    SLOT_WIDTH = 16
    SLOT_HEIGHT = 7

    GAUGE_TEMPORARY_PLACE = 12
    GAUGE_WIDTH = 16

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

    def MakeGauge(self, width, color):

        self.width = max(48, width)

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

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

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

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

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

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

        self.SetSize(width, self.SLOT_HEIGHT)

    def SetPercentage(self, curValue, maxValue):

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

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

class Board(Window):

    CORNER_WIDTH = 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 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 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.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None
        self.lockFlag = FALSE

        self.CreateScrollBar()

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

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

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

        upButton = Button()
        upButton.SetParent(self)
        upButton.SetEvent(__mem_func__(self.OnUp))
        upButton.SetUpVisual("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
        elf.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None

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

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

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

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

        self.UpdateBarSlot()

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

    def GetPos(self):
        return self.curPos

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

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

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

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

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

    def OnMove(self, event=TRUE):

        if self.lockFlag:
            return

        if 0 == self.pageSize:
            return

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

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

    def LockScroll(self):
        self.lockFlag = TRUE

    def UnlockScroll(self):
        self.lockFlag = FALSE

class ThinScrollBar(ScrollBar):

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

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

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

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

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

    def UpdateBarSlot(self):
        pass

class SmallThinScrollBar(ScrollBar):

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

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

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

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

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

    def UpdateBarSlot(self):
        pass

class SliderBar(Window):

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

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

        self.__CreateBackGroundImage()
        self.__CreateCursor()

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

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

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

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

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

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

        if self.eventChange:
            self.eventChange()

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

    def GetSliderPos(self):
        return self.curPos

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

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

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

class ListBox(Window):

    TEMPORARY_PLACE = 3

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

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

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

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

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

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

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

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

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

        self.itemList.append(textLine)

        self._LocateItem()

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

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

                return

    def LocateItem(self):
        self._LocateItem()

    def _LocateItem(self):

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

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

            if skipCount > 0:
                skipCount -= 1
                continue

            if locale.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 locale.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(locale.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):

        self.Clear()

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

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

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

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

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

        if locale.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 locale.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 == "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"])

        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"):
            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 locale.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 locale.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(locale.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

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

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

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

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

        return TRUE

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

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

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

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

        return TRUE

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

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

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

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

        return TRUE

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

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

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

        return TRUE

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

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

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

        return TRUE

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

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

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

        return TRUE

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

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

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

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

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

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

        return TRUE

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

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

        window.SetRowCount(value.get("row_count", 10)) # ±âº» ¼¼·Î °³¼ö 10°³
        window.SetSize(value["width"], value["height"])
        self.LoadDefaultData(window, value, parentWindow)

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

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

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

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

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

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

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

        return TRUE

class ReadingWnd(Bar):

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

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

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

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

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

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

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


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

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

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

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

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

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

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

def GetHyperlink():
    return wndMgr.GetHyperlink()

RegisterToolTipWindow("TEXT", TextLine) 


Gruß Done

#edit: Fehler behoben war das elf in der ui.py hab ins self umgeschrieben!

[DasSchwarzeT]

Originally Posted by Done™

Nein



Hier mal die ui.py

 Spoiler

PHP Code:

import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import locale

# MARK_BUG_FIX
import guild
# END_OF_MARK_BUG_FIX

from _weakref import proxy

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

if locale.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(locale.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.RegisterWindow(layer)
        self.Hide()

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

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

    def Destroy(self):
        pass

    def GetWindowHandle(self):
        return self.hWnd

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

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

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

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

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

    
    def GetParentProxy(self):
        return self.parentWindow

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
class ListBoxEx(Window):

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

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

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

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

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

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

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

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

        if locale.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 locale.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(locale.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, locale.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={}

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

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

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

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

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

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

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

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

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

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


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

    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 SetPercentage(self, curValue, maxValue):
        wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)

    def OnEndFrame(self):
        pass

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

        self.eventFunc = None
        self.eventArgs = None

        self.ButtonText = None
        self.ToolTipText = None

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

        self.eventFunc = None
        self.eventArgs = None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        self.ButtonText.SetText(text)

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

        self.ToolTipText.SetText(text)

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

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

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

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

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

    def HideToolTip(self):
        if self.ToolTipText:
            self.ToolTipText.Hide()
            
    def IsDown(self):
        return wndMgr.IsDown(self.hWnd)

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

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

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

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

        self.eventUp = None
        self.eventDown = None

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

        self.eventUp = None
        self.eventDown = None

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

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

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

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

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

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

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

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

        self.eventMove = lambda: None

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

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

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

    def TurnOnCallBack(self):
        self.callbackEnable = TRUE

    def TurnOffCallBack(self):
        self.callbackEnable = FALSE

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

class NumberLine(Window):

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

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

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

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

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

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

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

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

class Box(Window):

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

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

class Bar(Window):

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

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

class Line(Window):

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

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

class SlotBar(Window):

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

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

## Same with SlotBar
class Bar3D(Window):

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

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

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

class SlotWindow(Window):

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

        self.StartIndex = 0

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

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

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

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

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

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

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

    def 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 AppendSlotButton(self, upName, overName, downName):
        wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def SetUseMode(self, flag):
        "TRUEÀ϶§¸¸ ItemToItem ÀÌ °¡´ÉÇÑÁö º¸¿©ÁØ´Ù"
        wndMgr.SetUseMode(self.hWnd, flag)

    def SetUsableItem(self, flag): 
        "TRUE¸é ÇöÀç °¡¸®Å² ¾ÆÀÌÅÛÀÌ ItemToItem Àû¿ë °¡´ÉÇÏ´Ù"
        wndMgr.SetUsableItem(self.hWnd, flag)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def 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 locale.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(locale.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 locale.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 __init__(self):
        Window.__init__(self)
        self.AddFlag("attach")

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

    def Create(self, width):

        width = max(96, width)

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

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

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

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

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

class Gauge(Window):

    SLOT_WIDTH = 16
    SLOT_HEIGHT = 7

    GAUGE_TEMPORARY_PLACE = 12
    GAUGE_WIDTH = 16

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

    def MakeGauge(self, width, color):

        self.width = max(48, width)

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

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

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

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

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

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

        self.SetSize(width, self.SLOT_HEIGHT)

    def SetPercentage(self, curValue, maxValue):

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

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

class Board(Window):

    CORNER_WIDTH = 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 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 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.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None
        self.lockFlag = FALSE

        self.CreateScrollBar()

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

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

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

        upButton = Button()
        upButton.SetParent(self)
        upButton.SetEvent(__mem_func__(self.OnUp))
        upButton.SetUpVisual("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
        elf.eventScrollUp = lambda *arg: None
        self.eventScrollDown = lambda *arg: None

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

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

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

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

        self.UpdateBarSlot()

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

    def GetPos(self):
        return self.curPos

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

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

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

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

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

    def OnMove(self, event=TRUE):

        if self.lockFlag:
            return

        if 0 == self.pageSize:
            return

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

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

    def LockScroll(self):
        self.lockFlag = TRUE

    def UnlockScroll(self):
        self.lockFlag = FALSE

class ThinScrollBar(ScrollBar):

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

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

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

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

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

    def UpdateBarSlot(self):
        pass

class SmallThinScrollBar(ScrollBar):

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

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

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

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

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

    def UpdateBarSlot(self):
        pass

class SliderBar(Window):

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

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

        self.__CreateBackGroundImage()
        self.__CreateCursor()

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

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

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

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

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

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

        if self.eventChange:
            self.eventChange()

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

    def GetSliderPos(self):
        return self.curPos

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

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

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

class ListBox(Window):

    TEMPORARY_PLACE = 3

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

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

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

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

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

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

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

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

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

        self.itemList.append(textLine)

        self._LocateItem()

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

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

                return

    def LocateItem(self):
        self._LocateItem()

    def _LocateItem(self):

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

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

            if skipCount > 0:
                skipCount -= 1
                continue

            if locale.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 locale.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(locale.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):

        self.Clear()

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

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

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

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

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

        if locale.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 locale.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 == "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"])

        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"):
            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 locale.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 locale.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(locale.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

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

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

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

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

        return TRUE

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

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

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

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

        return TRUE

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

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

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

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

        return TRUE

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

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

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

        return TRUE

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

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

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

        return TRUE

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

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

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

        return TRUE

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

        self.LoadDefaultData(window, value, parentWindow)

        return TRUE

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

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

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

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

        return TRUE

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

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

        window.SetRowCount(value.get("row_count", 10)) # ±âº» ¼¼·Î °³¼ö 10°³
        window.SetSize(value["width"], value["height"])
        self.LoadDefaultData(window, value, parentWindow)

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

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

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

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

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

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

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

        return TRUE

class ReadingWnd(Bar):

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

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

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

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

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

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

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


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

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

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

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

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

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

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

def GetHyperlink():
    return wndMgr.GetHyperlink()

RegisterToolTipWindow("TEXT", TextLine) 


Gruß Done

#edit: Fehler behoben war das elf in der ui.py hab ins self umgeschrieben!

Also doch Invoice Client