Çözüldü Won Sistemi

#ARA :
            self.wndMoney = self.GetChild("Money")
            self.wndMoneySlot = self.GetChild("Money_Slot")
            self.wndMoneyIcon = self.GetChild("Money_Icon")
            self.wndMoneyIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowMoneyTitleToolTip)
            self.wndMoneyIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideMoneyTitleToolTip)

#ALTINA EKLE :
            if app.ENABLE_CHEQUE_SYSTEM:
                self.wndCheque = self.GetChild("Cheque")
                self.wndChequeSlot = self.GetChild("Cheque_Slot")
                self.wndChequeSlotIcon = self.GetChild("Cheque_Icon")
                self.wndChequeSlotIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowChequeTitleToolTip)
                self.wndChequeSlotIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideChequeTitleToolTip)

#ARA :
        self.wndMoneyIcon = 0
        self.wndMoney = 0
        self.wndMoneySlot = 0

#ALTINA EKLE :
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndChequeSlotIcon = 0
            self.wndCheque = 0
            self.wndChequeSlot = 0

#ARA :
        money = player.GetElk()
        self.wndMoney.SetText(localeInfo.NumberToMoney(money))

#ALTINA EKLE :
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndCheque.SetText(str(player.GetCheque()))

#ARA :
        self.toolTipMoneyTitle = uiToolTip.ToolTip(20)
        self.toolTipMoneyTitle.AutoAppendTextLine(localeInfo.MONEY_SYSTEM_UNIT_YANG, uiToolTip.ToolTip.PRICE_INFO_COLOR)
        self.toolTipMoneyTitle.AlignHorizonalCenter()

#ALTINA EKLE :
        self.toolTipChequeTitle = uiToolTip.ToolTip(20)
        self.toolTipChequeTitle.AutoAppendTextLine(localeInfo.MONEY_SYSTEM_UNIT_WON, uiToolTip.ToolTip.PRICE_INFO_COLOR)
        self.toolTipChequeTitle.AlignHorizonalCenter()

#ARA :
    def __ShowMoneyTitleToolTip(self):
        self.toolTipMoneyTitle.ShowToolTip()

    def __HideMoneyTitleToolTip(self):
        self.toolTipMoneyTitle.HideToolTip()

#ALTINA EKLE :
    def __ShowChequeTitleToolTip(self):
        self.toolTipChequeTitle.ShowToolTip()

    def __HideChequeTitleToolTip(self):
        self.toolTipChequeTitle.HideToolTip()

import ui
import net
import item
import skill
import localeInfo
import wndMgr
import player
import constInfo
import mouseModule
import uiScriptLocale
import app

MOUSE_SETTINGS = [0, 0]

def InitMouseButtonSettings(left, right):
    global MOUSE_SETTINGS
    MOUSE_SETTINGS = [left, right]

def SetMouseButtonSetting(dir, event):
    global MOUSE_SETTINGS
    MOUSE_SETTINGS[dir] = event
    
def GetMouseButtonSettings():
    global MOUSE_SETTINGS
    return MOUSE_SETTINGS

def SaveMouseButtonSettings():
    global MOUSE_SETTINGS
    open("mouse.cfg", "w").write("%s\t%s" % tuple(MOUSE_SETTINGS))

def LoadMouseButtonSettings():
    global MOUSE_SETTINGS
    tokens = open("mouse.cfg", "r").read().split()

    if len(tokens) != 2:
        raise RuntimeError, "MOUSE_SETTINGS_FILE_ERROR"

    MOUSE_SETTINGS[0] = int(tokens[0])
    MOUSE_SETTINGS[1] = int(tokens[1])

def unsigned32(n):
    return n & 0xFFFFFFFFL

class ExpandedMoneyTaskBar(ui.ScriptWindow):
    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.LoadWindow()

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

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/expandedmoneytaskbar.py")
        except:
            import exception
            exception.Abort("ExpandedMoneyTaskBar.LoadWindow.LoadObject")
        
        try:
            self.Money_Icon = self.GetChild("Money_Icon")
            self.Money = self.GetChild("Money")
            self.Money_Slot = self.GetChild("Money_Slot")

        except:
            import exception
            exception.Abort("ExpandedMoneyTaskBar.LoadWindow.BindObject")
        
        self.RefreshStatus()

    def Destroy(self):
        self.MoneyIcon = 0
        self.Money = 0
        self.Money_Slot = 0

    def Open(self):
        self.Show()

    def Close(self):
        self.Hide()

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

    def RefreshStatus(self):
        money = player.GetElk()
        self.Money.SetText(localeInfo.NumberToMoney(money))

#-------------------Giftbox Begin------------------------------

class GiftBox(ui.ScriptWindow):
    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")
            self.SetWindowName("GiftBox")
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

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

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.tooltipGift = self.TextToolTip()
        self.tooltipGift.Show()
        
    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "giftbox.py")
        except:
            import exception
            exception.Abort("GiftBox.LoadWindow.LoadObject")       

        self.giftBoxIcon = self.GetChild("GiftBox_Icon")
        self.giftBoxToolTip = self.GetChild("GiftBox_ToolTip")
    
    def Destroy(self):       
        self.giftBoxIcon = 0
        self.giftBoxToolTip = 0       
            
#-------------------Giftbox End------------------------------

class EnergyBar(ui.ScriptWindow):
    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")
            self.SetWindowName("EnergyBar")
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

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

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.tooltipEnergy = self.TextToolTip()
        self.tooltipEnergy.Show()
        
    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "EnergyBar.py")
        except:
            import exception
            exception.Abort("EnergyBar.LoadWindow.LoadObject")

        self.energyEmpty = self.GetChild("EnergyGauge_Empty")
        self.energyHungry = self.GetChild("EnergyGauge_Hungry")
        self.energyFull = self.GetChild("EnergyGauge_Full")

        self.energyGaugeBoard = self.GetChild("EnergyGauge_Board")
        self.energyGaugeToolTip = self.GetChild("EnergyGauge_ToolTip")

        
    def Destroy(self):       
        self.energyEmpty = None
        self.energyHungry = None
        self.energyFull = None
        self.energyGaugeBoard = 0
        self.energyGaugeToolTip = 0
        self.tooltipEnergy = 0

    ## Gauge
    def RefreshStatus(self):
         pointEnergy = player.GetStatus (player.ENERGY)
        leftTimeEnergy = player.GetStatus (player.ENERGY_END_TIME) - app.GetGlobalTimeStamp()
        # 충기환 지속 시간 = 2시간.
        self.SetEnergy (pointEnergy, leftTimeEnergy, 7200)
            
    def SetEnergy (self, point, leftTime, maxTime):
        leftTime = max (leftTime, 0)
        maxTime = max (maxTime, 0)
            
        self.energyEmpty.Hide()
        self.energyHungry.Hide()
        self.energyFull.Hide()
    
        if leftTime == 0:
            self.energyEmpty.Show()
        elif ((leftTime * 100) / maxTime) < 15:
            self.energyHungry.Show()
        else:
            self.energyFull.Show()

        self.tooltipEnergy.SetText("                                  " + localeInfo.SecondToHM(leftTime) + " - Energie +" + str(point) + "%")

    def OnUpdate(self):
        if TRUE == self.energyGaugeToolTip.IsIn():
            self.RefreshStatus()
            self.tooltipEnergy.Show()
        else:
            self.tooltipEnergy.Hide()

class ExpandedTaskBar(ui.ScriptWindow):
    BUTTON_DRAGON_SOUL = 0
    def __init__(self):
        ui.Window.__init__(self)
        self.SetWindowName("ExpandedTaskBar")
    
    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "ExpandedTaskBar.py")
        except:
            import exception
            exception.Abort("ExpandedTaskBar.LoadWindow.LoadObject")

        self.expandedTaskBarBoard = self.GetChild("ExpanedTaskBar_Board")

        self.toggleButtonDict = {}
        self.toggleButtonDict[ExpandedTaskBar.BUTTON_DRAGON_SOUL] = self.GetChild("DragonSoulButton")
        self.toggleButtonDict[ExpandedTaskBar.BUTTON_DRAGON_SOUL].SetParent(self)
    
    def SetTop(self):
        super(ExpandedTaskBar, self).SetTop()   
        for button in self.toggleButtonDict.values():
            button.SetTop()
    
    def Show(self):
        ui.ScriptWindow.Show(self)
    
    def Close(self):
        self.Hide()
    
    def SetToolTipText(self, eButton, text):
        self.toggleButtonDict[eButton].SetToolTipText(text)
        
    def SetToggleButtonEvent(self, eButton, kEventFunc):
        self.toggleButtonDict[eButton].SetEvent(kEventFunc)

    def OnPressEscapeKey(self):
        self.Close()
        return TRUE
    
class TaskBar(ui.ScriptWindow):

    BUTTON_CHARACTER = 0
    BUTTON_INVENTORY = 1
    BUTTON_MESSENGER = 2
    BUTTON_SYSTEM = 3
    BUTTON_CHAT = 4
    BUTTON_EXPAND = 5
    BUTTON_EXPAND_MONEY = 6
    IS_EXPANDED = FALSE

    MOUSE_BUTTON_LEFT = 0
    MOUSE_BUTTON_RIGHT = 1
    NONE = 255

    EVENT_MOVE = 0
    EVENT_ATTACK = 1
    EVENT_MOVE_AND_ATTACK = 2
    EVENT_CAMERA = 3
    EVENT_SKILL = 4
    EVENT_AUTO = 5

    GAUGE_WIDTH = 95
    GAUGE_HEIGHT = 13

    QUICKPAGE_NUMBER_FILENAME = [
        "d:/ymir work/ui/game/taskbar/1.sub",
        "d:/ymir work/ui/game/taskbar/2.sub",
        "d:/ymir work/ui/game/taskbar/3.sub",
        "d:/ymir work/ui/game/taskbar/4.sub",
    ]

    #gift icon show and hide
    def ShowGift(self):
        self.wndGiftBox.Show()
    
    def HideGift(self):
        self.wndGiftBox.Hide()

    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")

            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

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

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    class SkillButton(ui.SlotWindow):

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

            self.event = 0
            self.arg = 0

            self.slotIndex = 0
            self.skillIndex = 0

            slotIndex = 0
            wndMgr.SetSlotBaseImage(self.hWnd, "d:/ymir work/ui/public/slot_base.sub", 1.0, 1.0, 1.0, 1.0)
            wndMgr.AppendSlot(self.hWnd, slotIndex, 0, 0, 32, 32)
            self.SetCoverButton(slotIndex,    "d:/ymir work/ui/public/slot_cover_button_01.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_02.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_03.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_04.sub", TRUE, FALSE)
            self.SetSize(32, 32)

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

        def Destroy(self):
            if 0 != self.tooltipSkill:
                self.tooltipSkill.HideToolTip()

        def RefreshSkill(self):
            if 0 != self.slotIndex:
                self.SetSkill(self.slotIndex)

        def SetSkillToolTip(self, tooltip):
            self.tooltipSkill = tooltip

        def SetSkill(self, skillSlotNumber):
            slotNumber = 0
            skillIndex = player.GetSkillIndex(skillSlotNumber)
            skillGrade = player.GetSkillGrade(skillSlotNumber)
            skillLevel = player.GetSkillLevel(skillSlotNumber)
            skillType = skill.GetSkillType(skillIndex)

            self.skillIndex = skillIndex
            if 0 == self.skillIndex:
                self.ClearSlot(slotNumber)
                return

            self.slotIndex = skillSlotNumber

            self.SetSkillSlotNew(slotNumber, skillIndex, skillGrade, skillLevel)
            self.SetSlotCountNew(slotNumber, skillGrade, skillLevel)

            ## NOTE : CoolTime 체크
            if player.IsSkillCoolTime(skillSlotNumber):
                (coolTime, elapsedTime) = player.GetSkillCoolTime(skillSlotNumber)
                self.SetSlotCoolTime(slotNumber, coolTime, elapsedTime)

            ## NOTE : Activate 되어 있다면 아이콘도 업데이트
            if player.IsSkillActive(skillSlotNumber):
                self.ActivateSlot(slotNumber)

        def SetSkillEvent(self, event, arg=0):
            self.event = event
            self.arg = arg

        def GetSkillIndex(self):
            return self.skillIndex

        def GetSlotIndex(self):
            return self.slotIndex

        def Activate(self, coolTime):
            self.SetSlotCoolTime(0, coolTime)

            if skill.IsToggleSkill(self.skillIndex):
                self.ActivateSlot(0)

        def Deactivate(self):
            if skill.IsToggleSkill(self.skillIndex):
                self.DeactivateSlot(0)

        def OnOverInItem(self, dummy):
            self.tooltipSkill.SetSkill(self.skillIndex)

        def OnOverOutItem(self):
            self.tooltipSkill.HideToolTip()

        def OnSelectItemSlot(self, dummy):
            if 0 != self.event:
                if 0 != self.arg:
                    self.event(self.arg)
                else:
                    self.event()

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"

        ui.ScriptWindow.__init__(self, "TOP_MOST")

        self.quickPageNumImageBox = None
        self.tooltipItem = 0
        self.tooltipSkill = 0
        self.mouseModeButtonList = [ ui.ScriptWindow("TOP_MOST"), ui.ScriptWindow("TOP_MOST") ]

        self.tooltipHP = self.TextToolTip()
        self.tooltipHP.Show()
        self.tooltipSP = self.TextToolTip()
        self.tooltipSP.Show()
        self.tooltipST = self.TextToolTip()
        self.tooltipST.Show()
        self.tooltipEXP = self.TextToolTip()
        self.tooltipEXP.Show()
        
        self.skillCategoryNameList = [ "ACTIVE_1", "ACTIVE_2", "ACTIVE_3" ]
        self.skillPageStartSlotIndexDict = {
            "ACTIVE_1" : 1,
            "ACTIVE_2" : 21,
            "ACTIVE_3" : 41,
        }

        self.selectSkillButtonList = []
        
        self.lastUpdateQuickSlot = 0
        self.SetWindowName("TaskBar")

    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()

            if constInfo.IN_GAME_SHOP_ENABLE:
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "TaskBar.py")
            else:
                pyScrLoader.LoadScriptFile(self, "UIScript/TaskBar.py")
            pyScrLoader.LoadScriptFile(self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT], "UIScript/MouseButtonWindow.py")
            pyScrLoader.LoadScriptFile(self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT], "UIScript/RightMouseButtonWindow.py")
        except:
            import exception
            exception.Abort("TaskBar.LoadWindow.LoadObject")

        self.quickslot = []
        self.quickslot.append(self.GetChild("quick_slot_1"))
        self.quickslot.append(self.GetChild("quick_slot_2"))
        for slot in self.quickslot:
            slot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
            slot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptyQuickSlot))
            slot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemQuickSlot))
            slot.SetUnselectItemSlotEvent(ui.__mem_func__(self.UnselectItemQuickSlot))
            slot.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
            slot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

        toggleButtonDict = {}
        toggleButtonDict[TaskBar.BUTTON_CHARACTER]=self.GetChild("CharacterButton")
        toggleButtonDict[TaskBar.BUTTON_INVENTORY]=self.GetChild("InventoryButton")
        toggleButtonDict[TaskBar.BUTTON_MESSENGER]=self.GetChild("MessengerButton")
        toggleButtonDict[TaskBar.BUTTON_SYSTEM]=self.GetChild("SystemButton")
        toggleButtonDict[TaskBar.BUTTON_EXPAND_MONEY]=self.GetChild("ExpandMoneyButton")
        
        # ChatButton, ExpandButton 둘 중 하나는 반드시 존재한다.
        try:
            toggleButtonDict[TaskBar.BUTTON_CHAT]=self.GetChild("ChatButton")
        except:
            toggleButtonDict[TaskBar.BUTTON_EXPAND]=self.GetChild("ExpandButton")
            TaskBar.IS_EXPANDED = TRUE

        expGauge = []
        expGauge.append(self.GetChild("EXPGauge_01"))
        expGauge.append(self.GetChild("EXPGauge_02"))
        expGauge.append(self.GetChild("EXPGauge_03"))
        expGauge.append(self.GetChild("EXPGauge_04"))

        for exp in expGauge:
            exp.SetSize(0, 0)

      
        self.quickPageNumImageBox=self.GetChild("QuickPageNumber")

        self.GetChild("QuickPageUpButton").SetEvent(ui.__mem_func__(self.__OnClickQuickPageUpButton))
        self.GetChild("QuickPageDownButton").SetEvent(ui.__mem_func__(self.__OnClickQuickPageDownButton))

        ########Anti Exp Button by Sanii##########
        
        #self.antiexp        = self.GetChild("AntiButton")
        #self.antiexp.SetEvent(ui.__mem_func__(self.AntiExp))
        
        #if constInfo.ANTI_EXP_STATE == 1:
            #self.antiexp.SetText("-")
            #self.antiexp.SetToolTipText("Anti-Erfahrung deaktivieren")
        #else:
            #self.antiexp.SetText("+")
            #self.antiexp.SetToolTipText("Anti-Erfahrung aktivieren")
        
        mouseLeftButtonModeButton = self.GetChild("LeftMouseButton")
        mouseRightButtonModeButton = self.GetChild("RightMouseButton")
        mouseLeftButtonModeButton.SetEvent(ui.__mem_func__(self.ToggleLeftMouseButtonModeWindow))       
        mouseRightButtonModeButton.SetEvent(ui.__mem_func__(self.ToggleRightMouseButtonModeWindow))
        self.curMouseModeButton = [ mouseLeftButtonModeButton, mouseRightButtonModeButton ]

        (xLocalRight, yLocalRight) = mouseRightButtonModeButton.GetLocalPosition()
        self.curSkillButton = self.SkillButton()
        self.curSkillButton.SetParent(self)
        self.curSkillButton.SetPosition(xLocalRight, 3)
        self.curSkillButton.SetSkillEvent(ui.__mem_func__(self.ToggleRightMouseButtonModeWindow))
        self.curSkillButton.Hide()

        (xLeft, yLeft) = mouseLeftButtonModeButton.GetGlobalPosition()
        (xRight, yRight) = mouseRightButtonModeButton.GetGlobalPosition()
        leftModeButtonList = self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT]
        leftModeButtonList.SetPosition(xLeft, yLeft - leftModeButtonList.GetHeight()-5)
        rightModeButtonList = self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT]
        rightModeButtonList.SetPosition(xRight - rightModeButtonList.GetWidth() + 32, yRight - rightModeButtonList.GetHeight()-5)
        rightModeButtonList.GetChild("button_skill").SetEvent(lambda adir=self.MOUSE_BUTTON_RIGHT, aevent=self.EVENT_SKILL: self.SelectMouseButtonEvent(adir, aevent))
        rightModeButtonList.GetChild("button_skill").Hide()

        mouseImage = ui.ImageBox("TOP_MOST")
        mouseImage.AddFlag("float")
        mouseImage.LoadImage("d:/ymir work/ui/game/taskbar/mouse_button_camera_01.sub")
        mouseImage.SetPosition(xRight, wndMgr.GetScreenHeight() - 34)
        mouseImage.Hide()
        self.mouseImage = mouseImage

        dir = self.MOUSE_BUTTON_LEFT
        wnd = self.mouseModeButtonList[dir]
        wnd.GetChild("button_move_and_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_MOVE_AND_ATTACK: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_auto_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_AUTO: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_camera").SetEvent(lambda adir=dir, aevent=self.EVENT_CAMERA: self.SelectMouseButtonEvent(adir, aevent))

        dir = self.MOUSE_BUTTON_RIGHT
        wnd = self.mouseModeButtonList[dir]
        wnd.GetChild("button_move_and_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_MOVE_AND_ATTACK: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_camera").SetEvent(lambda adir=dir, aevent=self.EVENT_CAMERA: self.SelectMouseButtonEvent(adir, aevent))

        self.toggleButtonDict = toggleButtonDict
        self.expGauge = expGauge

        if constInfo.IN_GAME_SHOP_ENABLE:
            self.rampageGauge1  = self.GetChild("RampageGauge")
            self.rampageGauge1.OnMouseOverIn = ui.__mem_func__(self.__RampageGauge_OverIn)
            self.rampageGauge2 = self.GetChild("RampageGauge2")
            self.rampageGauge2.OnMouseOverOut = ui.__mem_func__(self.__RampageGauge_OverOut)
            self.rampageGauge2.OnMouseLeftButtonUp = ui.__mem_func__(self.__RampageGauge_Click)
            self.__RampageGauge_OverOut()

        self.hpGauge = self.GetChild("HPGauge")
        self.mpGauge = self.GetChild("SPGauge")
        self.stGauge = self.GetChild("STGauge")
        self.hpRecoveryGaugeBar = self.GetChild("HPRecoveryGaugeBar")
        self.spRecoveryGaugeBar = self.GetChild("SPRecoveryGaugeBar")

        self.hpGaugeBoard=self.GetChild("HPGauge_Board")
        self.mpGaugeBoard=self.GetChild("SPGauge_Board")
        self.stGaugeBoard=self.GetChild("STGauge_Board")
        self.expGaugeBoard=self.GetChild("EXP_Gauge_Board")
        
        #giftbox object
        wndGiftBox = GiftBox()
        wndGiftBox.LoadWindow()
        self.wndGiftBox = wndGiftBox
    
        self.__LoadMouseSettings()
        self.RefreshStatus()
        self.RefreshQuickSlot()

    def __RampageGauge_OverIn(self):
        print "rampage_over_in"
        self.rampageGauge2.Show()
        self.rampageGauge1.Hide()

    def __RampageGauge_OverOut(self):
        print "rampage_over_out"
        self.rampageGauge2.Hide()
        self.rampageGauge1.Show()

    def __RampageGauge_Click(self):
        print "rampage_up"
        net.SendChatPacket("/in_game_mall")
        # gift icon hide when click mall icon
        self.wndGiftBox.Hide()   

    def __LoadMouseSettings(self):
        try:
            LoadMouseButtonSettings()
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()
            if not self.__IsInSafeMouseButtonSettingRange(mouseLeftButtonEvent) or not self.__IsInSafeMouseButtonSettingRange(mouseRightButtonEvent):
                    raise RuntimeError, "INVALID_MOUSE_BUTTON_SETTINGS"
        except:
            InitMouseButtonSettings(self.EVENT_MOVE_AND_ATTACK, self.EVENT_CAMERA)
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()

        try:
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_LEFT,    mouseLeftButtonEvent)
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_RIGHT,    mouseRightButtonEvent)
        except:
            InitMouseButtonSettings(self.EVENT_MOVE_AND_ATTACK, self.EVENT_CAMERA)
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()

            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_LEFT,    mouseLeftButtonEvent)
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_RIGHT,    mouseRightButtonEvent)



    def __IsInSafeMouseButtonSettingRange(self, arg):
        return arg >= self.EVENT_MOVE and arg <= self.EVENT_AUTO

    def Destroy(self):       
        SaveMouseButtonSettings()

        self.ClearDictionary()
        self.mouseModeButtonList[0].ClearDictionary()
        self.mouseModeButtonList[1].ClearDictionary()
        self.mouseModeButtonList = 0
        self.curMouseModeButton = 0
        self.curSkillButton = 0
        self.selectSkillButtonList = 0


        self.expGauge = None
        self.hpGauge = None
        self.mpGauge = None
        self.stGauge = None
        self.hpRecoveryGaugeBar = None
        self.spRecoveryGaugeBar = None
    
        self.tooltipItem = 0
        self.tooltipSkill = 0
        self.quickslot = 0
        self.toggleButtonDict = 0

        self.hpGaugeBoard = 0
        self.mpGaugeBoard = 0
        self.stGaugeBoard = 0
        
        self.expGaugeBoard = 0

        self.tooltipHP = 0
        self.tooltipSP = 0
        self.tooltipST = 0
        self.tooltipEXP = 0

        self.mouseImage = None

    def __OnClickQuickPageUpButton(self):
        player.SetQuickPage(player.GetQuickPage()-1)

    def __OnClickQuickPageDownButton(self):
        player.SetQuickPage(player.GetQuickPage()+1)

    def SetToggleButtonEvent(self, eButton, kEventFunc):
        self.toggleButtonDict[eButton].SetEvent(kEventFunc)

    def SetItemToolTip(self, tooltipItem):
        self.tooltipItem = tooltipItem

    def SetSkillToolTip(self, tooltipSkill):
        self.tooltipSkill = tooltipSkill
        self.curSkillButton.SetSkillToolTip(self.tooltipSkill)

    ## Mouse Image
    def ShowMouseImage(self):
        self.mouseImage.SetTop()
        self.mouseImage.Show()

    def HideMouseImage(self):
        player.SetQuickCameraMode(FALSE)
        self.mouseImage.Hide()

    ## Gauge
    def RefreshStatus(self):
        curHP = player.GetStatus(player.HP)
        maxHP = player.GetStatus(player.MAX_HP)
        curSP = player.GetStatus(player.SP)
        maxSP = player.GetStatus(player.MAX_SP)
        curEXP = unsigned32(player.GetStatus(player.EXP))
        nextEXP = unsigned32(player.GetStatus(player.NEXT_EXP))
        recoveryHP = player.GetStatus(player.HP_RECOVERY)
        recoverySP = player.GetStatus(player.SP_RECOVERY)
        
        self.RefreshStamina()

        self.SetHP(curHP, recoveryHP, maxHP)
        self.SetSP(curSP, recoverySP, maxSP)
        self.SetExperience(curEXP, nextEXP)
        
    def RefreshStamina(self):
        curST = player.GetStatus(player.STAMINA)
        maxST = player.GetStatus(player.MAX_STAMINA)
        self.SetST(curST, maxST)

    def RefreshSkill(self):
        self.curSkillButton.RefreshSkill()
        for button in self.selectSkillButtonList:
            button.RefreshSkill()

    def SetHP(self, curPoint, recoveryPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.hpGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipHP.SetText("%s : %d / %d" % (localeInfo.TASKBAR_HP, curPoint, maxPoint))

            if 0 == recoveryPoint:
                self.hpRecoveryGaugeBar.Hide()
            else:
                destPoint = min(maxPoint, curPoint + recoveryPoint)
                newWidth = int(self.GAUGE_WIDTH * (float(destPoint) / float(maxPoint)))
                self.hpRecoveryGaugeBar.SetSize(newWidth, self.GAUGE_HEIGHT)
                self.hpRecoveryGaugeBar.Show()

    def SetSP(self, curPoint, recoveryPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.mpGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipSP.SetText("%s : %d / %d" % (localeInfo.TASKBAR_SP, curPoint, maxPoint))

            if 0 == recoveryPoint:
                self.spRecoveryGaugeBar.Hide()
            else:
                destPoint = min(maxPoint, curPoint + recoveryPoint)
                newWidth = int(self.GAUGE_WIDTH * (float(destPoint) / float(maxPoint)))
                self.spRecoveryGaugeBar.SetSize(newWidth, self.GAUGE_HEIGHT)
                self.spRecoveryGaugeBar.Show()

    def SetST(self, curPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.stGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipST.SetText("%s : %d / %d" % (localeInfo.TASKBAR_ST, curPoint, maxPoint))

    def SetExperience(self, curPoint, maxPoint):

        curPoint = min(curPoint, maxPoint)
        curPoint = max(curPoint, 0)
        maxPoint = max(maxPoint, 0)

        quarterPoint = maxPoint / 4
        FullCount = 0

        if 0 != quarterPoint:
            FullCount = min(4, curPoint / quarterPoint)

        for i in xrange(4):
            self.expGauge[i].Hide()

        for i in xrange(FullCount):
            self.expGauge[i].SetRenderingRect(0.0, 0.0, 0.0, 0.0)
            self.expGauge[i].Show()

        if 0 != quarterPoint:
            if FullCount < 4:
                Percentage = float(curPoint % quarterPoint) / quarterPoint - 1.0
                self.expGauge[FullCount].SetRenderingRect(0.0, Percentage, 0.0, 0.0)
                self.expGauge[FullCount].Show()

        #####
        self.tooltipEXP.SetText("%s : %.2f%%" % (localeInfo.TASKBAR_EXP, float(curPoint) / max(1, float(maxPoint)) * 100))
    
        
    ## QuickSlot
    def RefreshQuickSlot(self):

        pageNum = player.GetQuickPage()

        try:
            self.quickPageNumImageBox.LoadImage(TaskBar.QUICKPAGE_NUMBER_FILENAME[pageNum])
        except:
            pass

        startNumber = 0
        for slot in self.quickslot:

            for i in xrange(4):

                slotNumber = i+startNumber

                (Type, Position) = player.GetLocalQuickSlot(slotNumber)

                if player.SLOT_TYPE_NONE == Type:
                    slot.ClearSlot(slotNumber)
                    continue

                if player.SLOT_TYPE_INVENTORY == Type:

                    itemIndex = player.GetItemIndex(Position)
                    itemCount = player.GetItemCount(Position)
                    if itemCount <= 1:
                        itemCount = 0
                    
                    ## 자동물약 (#72723, #72724) 특수처리 - 아이템인데도 슬롯에 활성화/비활성화 표시를 위한 작업임 - [hyo]
                    if constInfo.IS_AUTO_POTION(itemIndex):
                        # metinSocket - [0] : 활성화 여부, [1] : 사용한 양, [2] : 최대 용량
                        metinSocket = [player.GetItemMetinSocket(Position, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
                        
                        if 0 != int(metinSocket[0]):
                            slot.ActivateSlot(slotNumber)
                        else:
                            slot.DeactivateSlot(slotNumber)
                    
                    slot.SetItemSlot(slotNumber, itemIndex, itemCount)

                elif player.SLOT_TYPE_SKILL == Type:

                    skillIndex = player.GetSkillIndex(Position)
                    if 0 == skillIndex:
                        slot.ClearSlot(slotNumber)
                        continue

                    skillType = skill.GetSkillType(skillIndex)
                    if skill.SKILL_TYPE_GUILD == skillType:
                        import guild
                        skillGrade = 0
                        skillLevel = guild.GetSkillLevel(Position)

                    else:
                        skillGrade = player.GetSkillGrade(Position)
                        skillLevel = player.GetSkillLevel(Position)

                    slot.SetSkillSlotNew(slotNumber, skillIndex, skillGrade, skillLevel)
                    slot.SetSlotCountNew(slotNumber, skillGrade, skillLevel)
                    slot.SetCoverButton(slotNumber)

                    ## NOTE : CoolTime 체크
                    if player.IsSkillCoolTime(Position):
                        (coolTime, elapsedTime) = player.GetSkillCoolTime(Position)
                        slot.SetSlotCoolTime(slotNumber, coolTime, elapsedTime)

                    ## NOTE : Activate 되어 있다면 아이콘도 업데이트
                    if player.IsSkillActive(Position):
                        slot.ActivateSlot(slotNumber)

                elif player.SLOT_TYPE_EMOTION == Type:

                    emotionIndex = Position
                    slot.SetEmotionSlot(slotNumber, emotionIndex)
                    slot.SetCoverButton(slotNumber)
                    slot.SetSlotCount(slotNumber, 0)

            slot.RefreshSlot()
            startNumber += 4

    def canAddQuickSlot(self, Type, slotNumber):

        if player.SLOT_TYPE_INVENTORY == Type:

            itemIndex = player.GetItemIndex(slotNumber)
            return item.CanAddToQuickSlotItem(itemIndex)

        return TRUE

    def AddQuickSlot(self, localSlotIndex):
        AttachedSlotType = mouseModule.mouseController.GetAttachedType()
        AttachedSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()
        AttachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

        if player.SLOT_TYPE_QUICK_SLOT == AttachedSlotType:
            player.RequestMoveGlobalQuickSlotToLocalQuickSlot(AttachedSlotNumber, localSlotIndex)

        elif player.SLOT_TYPE_EMOTION == AttachedSlotType:

            player.RequestAddLocalQuickSlot(localSlotIndex, AttachedSlotType, AttachedItemIndex)

        elif TRUE == self.canAddQuickSlot(AttachedSlotType, AttachedSlotNumber):

            ## Online Code
            player.RequestAddLocalQuickSlot(localSlotIndex, AttachedSlotType, AttachedSlotNumber)
        
        mouseModule.mouseController.DeattachObject()
        self.RefreshQuickSlot()

    def SelectEmptyQuickSlot(self, slotIndex):

        if TRUE == mouseModule.mouseController.isAttached():
            self.AddQuickSlot(slotIndex)

    def SelectItemQuickSlot(self, localQuickSlotIndex):

        if TRUE == mouseModule.mouseController.isAttached():
            self.AddQuickSlot(localQuickSlotIndex)

        else:
            globalQuickSlotIndex=player.LocalQuickSlotIndexToGlobalQuickSlotIndex(localQuickSlotIndex)
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_QUICK_SLOT, globalQuickSlotIndex, globalQuickSlotIndex)

    def UnselectItemQuickSlot(self, localSlotIndex):

        if FALSE == mouseModule.mouseController.isAttached():
            player.RequestUseLocalQuickSlot(localSlotIndex)
            return

        elif mouseModule.mouseController.isAttached():
            mouseModule.mouseController.DeattachObject()
            return


    def OnUseSkill(self, usedSlotIndex, coolTime):

        QUICK_SLOT_SLOT_COUNT = 4
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Activate(coolTime)

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(QUICK_SLOT_SLOT_COUNT):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.SetSlotCoolTime(slotIndex, coolTime)
                        return

                slotIndex += 1

    def OnActivateSkill(self, usedSlotIndex):
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Deactivate()

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(4):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.ActivateSlot(slotIndex)
                        return

                slotIndex += 1

    def OnDeactivateSkill(self, usedSlotIndex):
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Deactivate()

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(4):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.DeactivateSlot(slotIndex)
                        return

                slotIndex += 1

    ## ToolTip
    def OverInItem(self, slotNumber):
        if mouseModule.mouseController.isAttached():
            return

        (Type, Position) = player.GetLocalQuickSlot(slotNumber)

        if player.SLOT_TYPE_INVENTORY == Type:
            self.tooltipItem.SetInventoryItem(Position)
            self.tooltipSkill.HideToolTip()

        elif player.SLOT_TYPE_SKILL == Type:

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

            if skill.SKILL_TYPE_GUILD == skillType:
                import guild
                skillGrade = 0
                skillLevel = guild.GetSkillLevel(Position)

            else:
                skillGrade = player.GetSkillGrade(Position)
                skillLevel = player.GetSkillLevel(Position)

            self.tooltipSkill.SetSkillNew(Position, skillIndex, skillGrade, skillLevel)
            self.tooltipItem.HideToolTip()

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

    def OnUpdate(self):
        if app.GetGlobalTime() - self.lastUpdateQuickSlot > 500:
            self.lastUpdateQuickSlot = app.GetGlobalTime()
            self.RefreshQuickSlot()

        if TRUE == self.hpGaugeBoard.IsIn():
            self.tooltipHP.Show()
        else:
            self.tooltipHP.Hide()

        if TRUE == self.mpGaugeBoard.IsIn():
            self.tooltipSP.Show()
        else:
            self.tooltipSP.Hide()

        if TRUE == self.stGaugeBoard.IsIn():
            self.tooltipST.Show()
        else:
            self.tooltipST.Hide()
        
        if TRUE == self.expGaugeBoard.IsIn():
            self.tooltipEXP.Show()
        else:
            self.tooltipEXP.Hide()
        
    ## Skill
    def ToggleLeftMouseButtonModeWindow(self):

        wndMouseButtonMode = self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT]

        if TRUE == wndMouseButtonMode.IsShow():

            wndMouseButtonMode.Hide()

        else:
            wndMouseButtonMode.Show()

    def ToggleRightMouseButtonModeWindow(self):

        wndMouseButtonMode = self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT]

        if TRUE == wndMouseButtonMode.IsShow():

            wndMouseButtonMode.Hide()
            self.CloseSelectSkill()

        else:
            wndMouseButtonMode.Show()
            self.OpenSelectSkill()

    def OpenSelectSkill(self):

        PAGE_SLOT_COUNT = 6

        (xSkillButton, y) = self.curSkillButton.GetGlobalPosition()
        y -= (37 + 32 + 1)

        for key in self.skillCategoryNameList:

            appendCount = 0
            startNumber = self.skillPageStartSlotIndexDict[key]
            x = xSkillButton

            getSkillIndex=player.GetSkillIndex
            getSkillLevel=player.GetSkillLevel
            for i in xrange(PAGE_SLOT_COUNT):

                skillIndex = getSkillIndex(startNumber+i)
                skillLevel = getSkillLevel(startNumber+i)

                if 0 == skillIndex:
                    continue
                if 0 == skillLevel:
                    continue
                if skill.IsStandingSkill(skillIndex):
                    continue

                ## FIXME : 스킬 하나당 슬롯 하나씩 할당하는건 아무리 봐도 부하가 크다.
                ##         이 부분은 시간을 나면 고치도록. - [levites]
                skillButton = self.SkillButton()
                skillButton.SetSkill(startNumber+i)
                skillButton.SetPosition(x, y)
                skillButton.SetSkillEvent(ui.__mem_func__(self.CloseSelectSkill), startNumber+i+1)
                skillButton.SetSkillToolTip(self.tooltipSkill)
                skillButton.SetTop()
                skillButton.Show()
                self.selectSkillButtonList.append(skillButton)

                appendCount += 1
                x -= 32

            if appendCount > 0:
                y -= 32

    def CloseSelectSkill(self, slotIndex=-1):

        self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT].Hide()
        for button in self.selectSkillButtonList:
            button.Destroy()

        self.selectSkillButtonList = []

        if -1 != slotIndex:
            self.curSkillButton.Show()
            self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Hide()
            player.SetMouseFunc(player.MBT_RIGHT, player.MBF_SKILL)
            player.ChangeCurrentSkillNumberOnly(slotIndex-1)
        else:
            self.curSkillButton.Hide()
            self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Show()

    def SelectMouseButtonEvent(self, dir, event):
        SetMouseButtonSetting(dir, event)

        self.CloseSelectSkill()
        self.mouseModeButtonList[dir].Hide()

        btn = 0
        type = self.NONE
        func = self.NONE
        tooltip_text = ""       
        
        if self.MOUSE_BUTTON_LEFT == dir:
            type = player.MBT_LEFT

        elif self.MOUSE_BUTTON_RIGHT == dir:
            type = player.MBT_RIGHT

        if self.EVENT_MOVE == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_move")
            func = player.MBF_MOVE
            tooltip_text = localeInfo.TASKBAR_MOVE
        elif self.EVENT_ATTACK == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_attack")
            func = player.MBF_ATTACK
            tooltip_text = localeInfo.TASKBAR_ATTACK
        elif self.EVENT_AUTO == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_auto_attack")
            func = player.MBF_AUTO
            tooltip_text = localeInfo.TASKBAR_AUTO
        elif self.EVENT_MOVE_AND_ATTACK == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_move_and_attack")
            func = player.MBF_SMART
            tooltip_text = localeInfo.TASKBAR_ATTACK
        elif self.EVENT_CAMERA == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_camera")
            func = player.MBF_CAMERA
            tooltip_text = localeInfo.TASKBAR_CAMERA
        elif self.EVENT_SKILL == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_skill")
            func = player.MBF_SKILL
            tooltip_text = localeInfo.TASKBAR_SKILL

        if 0 != btn:
            self.curMouseModeButton[dir].SetToolTipText(tooltip_text, 0, -18)
            self.curMouseModeButton[dir].SetUpVisual(btn.GetUpVisualFileName())
            self.curMouseModeButton[dir].SetOverVisual(btn.GetOverVisualFileName())
            self.curMouseModeButton[dir].SetDownVisual(btn.GetDownVisualFileName())
            self.curMouseModeButton[dir].Show()

        player.SetMouseFunc(type, func)

    def OnChangeCurrentSkill(self, skillSlotNumber):
        self.curSkillButton.SetSkill(skillSlotNumber)
        self.curSkillButton.Show()
        self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Hide()
        
        
    ########Anti Exp Button by Sanii##########       
    def AntiExp(self):
        import constInfo
        import event
        import net
        qid = constInfo.ANTI_EXP
        state = constInfo.ANTI_EXP_STATE
        if state == 0:
            self.antiexp.SetText("-")
            self.antiexp.SetToolTipText("Anti-Erfahrung deaktivieren")
            event.QuestButtonClick(qid)
        else:
            self.antiexp.SetText("+")
            self.antiexp.SetToolTipText("Anti-Erfahrung aktivieren")
            event.QuestButtonClick(qid)
    ##########################################