Çözüldü Oyunda Gezinirken Syserr Alıyorum!

uicharecter.py dosyanının blokları.
import ui
import uiScriptLocale
import app
import net
import dbg
import snd
import player
import mouseModule
import wndMgr
import skill
import playerSettingModule
import quest
import localeInfo
import uiToolTip
import constInfo
import emotion
import chr

SHOW_ONLY_ACTIVE_SKILL = FALSE
SHOW_LIMIT_SUPPORT_SKILL_LIST = []
HIDE_SUPPORT_SKILL_POINT = FALSE

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

FACE_IMAGE_DICT = {
    playerSettingModule.RACE_WARRIOR_M    : "icon/face/warrior_m.tga",
    playerSettingModule.RACE_WARRIOR_W    : "icon/face/warrior_w.tga",
    playerSettingModule.RACE_ASSASSIN_M    : "icon/face/assassin_m.tga",
    playerSettingModule.RACE_ASSASSIN_W    : "icon/face/assassin_w.tga",
    playerSettingModule.RACE_SURA_M        : "icon/face/sura_m.tga",
    playerSettingModule.RACE_SURA_W        : "icon/face/sura_w.tga",
    playerSettingModule.RACE_SHAMAN_M    : "icon/face/shaman_m.tga",
    playerSettingModule.RACE_SHAMAN_W    : "icon/face/shaman_w.tga",
}

class CharacterWindow(ui.ScriptWindow):

    ACTIVE_PAGE_SLOT_COUNT = 8
    SUPPORT_PAGE_SLOT_COUNT = 12

    PAGE_SLOT_COUNT = 12
    PAGE_HORSE = 2

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

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


    STAT_MINUS_DESCRIPTION = localeInfo.STAT_MINUS_DESCRIPTION

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.state = "STATUS"
        self.isLoaded = 0

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

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

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

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

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

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

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

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

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

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

        self.emotionToolTip = None
        self.soloEmotionSlot = None
        self.dualEmotionSlot = None

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)

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

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

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

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

        self.statu_ver = self.GetChild("statu_ver")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __SetEmotionSlot(self):

        self.emotionToolTip = uiToolTip.ToolTip()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if not slotIndex in emotion.EMOTION_DICT:
                return

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

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

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

        self.RefreshQuest()
        self.__HideJobToolTip()

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

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

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

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

        self.statu_ver.SAFE_SetEvent(self.__statu_veriyoruz)
        self.statu_ver.ShowToolTip = self.__OverInStatButton2()
        self.statu_ver.HideToolTip = self.__OverOutStatButton()

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

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

        self.isLoaded = 1

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

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

    def Destroy(self):
        self.ClearDictionary()

        self.__Initialize()

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

        self.Hide()

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

    def __statu_veriyoruz(self):
        import uiStatusUp
        self.StatusUp = uiStatusUp.StatusUp()
        if False == self.StatusUp.IsShow():
            self.StatusUp.Show()
        else:
            self.StatusUp.Hide()
    
    
    def __OnClickStatusPlusButton(self, statusKey):
        try:
            statusPlusCommand=self.statusPlusCommandDict[statusKey]
            net.SendChatPacket(statusPlusCommand)
        except KeyError, msg:
            dbg.TraceError("CharacterWindow.__OnClickStatusPlusButton KeyError: %s", msg)

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


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

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

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

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

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

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

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

    def GetState(self):
        return self.state

    def __GetTotalAtkText(self):
        minAtk=player.GetStatus(player.ATT_MIN)
        maxAtk=player.GetStatus(player.ATT_MAX)
        atkBonus=player.GetStatus(player.ATT_BONUS)
        attackerBonus=player.GetStatus(player.ATTACKER_BONUS)
        min = int(minAtk+atkBonus+attackerBonus)
        max = int(maxAtk+atkBonus+attackerBonus)
        if minAtk==maxAtk:
            return "%s" % (localeInfo.NumberToString2(min))
        else:
            return "%s-%s" % (localeInfo.NumberToString2(min), localeInfo.NumberToString2(max))

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

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

    def __GetTotalDefText(self):
        defValue=player.GetStatus(player.DEF_GRADE)
        if constInfo.ADD_DEF_BONUS_ENABLE:
            defValue+=player.GetStatus(player.DEF_BONUS)
        return "%s" % (localeInfo.NumberToString2(defValue))

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

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

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

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

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

            self.GetChild("MDEF_Value").SetText(str(player.GetStatus(player.MAG_DEF)))
            self.GetChild("ASPD_Value").SetText(str(player.GetStatus(player.ATT_SPEED)))
            self.GetChild("MSPD_Value").SetText(str(player.GetStatus(player.MOVING_SPEED)))
            self.GetChild("CSPD_Value").SetText(str(player.GetStatus(player.CASTING_SPEED)))
            self.GetChild("ER_Value").SetText(str(player.GetStatus(player.EVADE_RATE)))
            
            self.GetChild("Dif_spada_Value").SetText(str(self.Spada())) #Spada 29
            self.GetChild("Dif_spadone_Value").SetText(str(self.Spadone())) #Spadone 30
            self.GetChild("Dif_pugnale_Value").SetText(str(self.Pugnale())) #Pugnale 31
            self.GetChild("Res_magia_Value").SetText(str(self.ResMagia())) #Res Magia 37
            self.GetChild("Res_freccia_Value").SetText(str(self.Freccia())) #Freccia 34
            self.GetChild("Blocco_Value").SetText(str(self.Blocco())) #Res Veleno 41
            self.GetChild("Res_war_Value").SetText(str(self.ResWar())) #Res War 78
            self.GetChild("Res_Sura_Value").SetText(str(self.ResSura())) #Res Sura 80
            self.GetChild("Res_Ninja_Value").SetText(str(self.ResNinja())) #Res Ninja 79
            self.GetChild("Res_Shamy_Value").SetText(str(self.ResShamy())) #Res Shamy 81
            self.GetChild("Mezziuomini_Value").SetText(str(self.Mezzi()))#Mezzi 17
            self.GetChild("Danni_medi_Value").SetText(str(self.Medi()))#Medi 72
            self.GetChild("Danni_abi_Value").SetText(str(self.Abilita())) #Abi 71
            self.GetChild("Mostri_Value").SetText(str(self.Mostri())) # Vel Magia 9
            self.GetChild("Vs_zombie_Value").SetText(str(self.Zombie())) # Zombie 21
            self.GetChild("Critici_Value").SetText(str(self.Critici())) #Critici 15
            self.GetChild("Trafiggenti_Value").SetText(str(self.Trafi())) #Trafi 16
            self.GetChild("Rig_HP_Value").SetText(str(self.RigHP())) #Rig HP 10
            self.GetChild("Rig_MP_Value").SetText(str(self.RigMP())) #Rig MP 11
            self.GetChild("Veleno_Value").SetText(str(self.Avvelenamento())) #Avvelenamento 12
            

        except:
            #import exception
            #exception.Abort("CharacterWindow.RefreshStatus.BindObject")
            ## 게임이 튕겨 버림
            pass

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

        if self.refreshToolTip:
            self.refreshToolTip()

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

        statusPlusPoint=player.GetStatus(player.STAT)

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

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

        statusMinusPoint=self.__GetStatMinusPoint()

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

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

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

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

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

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

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

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

    def SelectSkill(self, skillSlotIndex):

        mouseController = mouseModule.mouseController

        if FALSE == mouseController.isAttached():

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

            if skill.CanUseSkill(selectedSkillIndex):

                if app.IsPressed(app.DIK_LCONTROL):

                    player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_SKILL, srcSlotIndex)
                    return

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

        else:

            mouseController.DeattachObject()

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

    ## ToolTip
    def OverInItem(self, slotNumber):

        if mouseModule.mouseController.isAttached():
            return

        if 0 == self.toolTipSkill:
            return

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

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

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

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

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

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

        import event
        event.QuestButtonClick(-2147483648 + questIndex)

    def RefreshQuest(self):

        if self.isLoaded==0:
            return

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

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

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

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

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

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

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

        self.__UpdateQuestClock()

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

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

                    if lastTime <= 0:
                        clockText = localeInfo.QUEST_TIMEOVER

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

                        clockText = lastName + " : "

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

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

                self.questLastTimeList.SetText(clockText)
                
    def Spada(self):
        exsta = 69
        return player.GetStatus(exsta)
        
    def Spadone(self):
        exsta = 70
        return player.GetStatus(exsta)    
        
    def Pugnale(self):
        exsta = 71
        return player.GetStatus(exsta)    
        
    def ResMagia(self):
        exsta = 77
        return player.GetStatus(exsta)    
        
    def Freccia(self):
        exsta = 74
        return player.GetStatus(exsta)    
        
    def Blocco(self):
        exsta = 67
        return player.GetStatus(exsta)    
        
    def ResWar(self):
        exsta = 59
        return player.GetStatus(exsta)
        
    def ResSura(self):
        exsta = 61
        return player.GetStatus(exsta)
        
    def ResNinja(self):
        exsta = 60
        return player.GetStatus(exsta)
        
    def ResShamy(self):
        exsta = 62
        return player.GetStatus(exsta)
    
    def Mezzi(self):
        exsta = 43
        return player.GetStatus(exsta)
        
    def Medi(self):
        exsta = 121
        return player.GetStatus(exsta)
        
    def Abilita(self):
        exsta = 122
        return player.GetStatus(exsta)
        
    def Mostri(self):
        exsta = 53
        return player.GetStatus(exsta)
        
    def Zombie(self):
        exsta = 47
        return player.GetStatus(exsta)    
        
    def Critici(self):
        exsta = 40
        return player.GetStatus(exsta)    
        
    def Trafi(self):
        exsta = 41
        return player.GetStatus(exsta)
        
    def RigHP(self):
        exsta = 32
        return player.GetStatus(exsta)
        
    def RigMP(self):
        exsta = 33
        return player.GetStatus(exsta)
        
    def Avvelenamento(self):
        exsta = 37
        return player.GetStatus(exsta)
        
    def __GetStatMinusPoint(self):
        POINT_STAT_RESET_COUNT = 112
        return player.GetStatus(POINT_STAT_RESET_COUNT)

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

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

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

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

    def __OverInStatButton2(self):    
        try:
            self.__ShowStatToolTip("statu")
        except KeyError:
            pass

    def __OverOutStatButton(self):
        self.__HideStatToolTip()

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

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

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

    def OnUpdate(self):
        self.__UpdateQuestClock()

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

        skillPage = self.skillPageDict[name]

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

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

            slotIndex = i + startSlotIndex
            skillIndex = getSkillIndex(slotIndex)

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

            if 0 == skillIndex:
                continue

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

            ## 승마 스킬 예외 처리
            if player.SKILL_INDEX_RIDING == skillIndex:
                if 1 == skillGrade:
                    skillLevel += 19
                elif 2 == skillGrade:
                    skillLevel += 29
                elif 3 == skillGrade:
                    skillLevel = 40

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

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

                    if (skillGrade == skill.SKILL_GRADE_COUNT) and j == (skill.SKILL_GRADE_COUNT-1):
                        skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
                    elif (not self.__CanUseSkillNow()) or (skillGrade != j):
                        skillPage.SetSlotCount(realSlotIndex, 0)
                        skillPage.DisableCoverButton(realSlotIndex)
                    else:
                        skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)

            ## 그외
            else:
                if not SHOW_LIMIT_SUPPORT_SKILL_LIST or skillIndex in SHOW_LIMIT_SUPPORT_SKILL_LIST:
                    realSlotIndex = self.__GetETCSkillRealSlotIndex(slotIndex)
                    skillPage.SetSkillSlot(realSlotIndex, skillIndex, skillLevel)
                    skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)

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

            skillPage.RefreshSlot()


    def RefreshSkill(self):

        if self.isLoaded==0:
            return

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


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

        self.RefreshSkillPlusButtonList()

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

        ## 스킬이 있으면
        if 0 == skillIndex:
            return FALSE

        ## 레벨업 조건을 만족한다면
        if not skill.CanLevelUpSkill(skillIndex, skillLevel):
            return FALSE

        return TRUE

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

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

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

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

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

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

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

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

    def RefreshSkillPlusButtonList(self):

        if self.isLoaded==0:
            return

        self.RefreshSkillPlusPointLabel()

        if not self.__CanUseSkillNow():
            return

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

            self.__RefreshSkillPlusButton("SUPPORT")

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

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

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

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

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

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

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

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

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

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

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

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

        mouseModule.mouseController.DeattachObject()

    ## FIXME : 스킬을 사용했을때 슬롯 번호를 가지고 해당 슬롯을 찾아서 업데이트 한다.
    ##         매우 불합리. 구조 자체를 개선해야 할듯.
    def OnUseSkill(self, slotIndex, coolTime):

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

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

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

    def OnActivateSkill(self, slotIndex):

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

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

    def OnDeactivateSkill(self, slotIndex):

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

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

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

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

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

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

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

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

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

            self.toolTipJob.AlignHorizonalCenter()

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

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

    def RefreshCharacter(self):

        if self.isLoaded==0:
            return

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

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

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

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

        ## FaceImage
        try:
            faceImageName = FACE_IMAGE_DICT[race]

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

        except KeyError:
            self.faceImage.Hide()

        ## GroupName
        self.__SetSkillGroupName(race, group)

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

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

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

    def __SetSkillGroupName(self, race, group):

        job = chr.RaceToJob(race)

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

        nameList = self.SKILL_GROUP_NAME_DICT[job]

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

        else:

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

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

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

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

        ## Event
        self.__SetSkillSlotEvent()

        ## Refresh
        self.RefreshSkill()

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

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

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

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

        return TRUE

    def __CanUseHorseSkill(self):

        slotIndex = player.GetSkillSlotIndex(player.SKILL_INDEX_RIDING)

        if not slotIndex:
            return FALSE

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

        return FALSE

    def __IsChangedHorseRidingSkillLevel(self):
        ret = FALSE

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

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

        self.canUseHorseSkill = self.__CanUseHorseSkill()
        return ret

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

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

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

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

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

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

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

uisafebox.py Blokları
import ui
import mouseModule
import player
import net
import snd
import safebox
import chat
import app
import localeInfo
import uiScriptLocale
import constInfo
import translate
import uiToolTip

if app.WJ_SECURITY_SYSTEM:
    class SecurityDialog(ui.ScriptWindow):
        UI = []
        UA = []
        def __init__(self):
            ui.ScriptWindow.__init__(self)
            self.__LoadDialog()
            self.isCreate = False
            self.toolTip = uiToolTip.ItemToolTip()
            self.toolTip.Hide()

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

        def __LoadDialog(self):
            try:
                pyScrLoader = ui.PythonScriptLoader()
                pyScrLoader.LoadScriptFile(self, "uiscript/securitydialog.py")
            except:
                import exception
                exception.Abort("GuvenlikDialog.__LoadDialog.LoadObject")

            try:
                self.passwordValue = self.GetChild("password_value")
                self.acceptButton = self.GetChild("accept_button")
                self.cancelButton = self.GetChild("cancel_button")
                self.titleName = self.GetChild("TitleName")
                self.securtiyControl = self.GetChild("security_control")
                self.sifregir = self.GetChild("sifre_gir")
                self.unutButton = self.GetChild("sifremi_unuttum")
                self.bilgiButton = self.GetChild("bilgi_button")
                self.rememberButton = self.GetChild("remember_button")
                self.rememberButton.Show()
                self.num_1 = self.GetChild("number_1")
                self.num_2 = self.GetChild("number_2")
                self.num_3 = self.GetChild("number_3")
                self.num_4 = self.GetChild("number_4")
                self.num_5 = self.GetChild("number_5")
                self.num_6 = self.GetChild("number_6")
                self.num_7 = self.GetChild("number_7")
                self.num_8 = self.GetChild("number_8")
                self.num_9 = self.GetChild("number_9")
                self.num_0 = self.GetChild("number_0")
                self.GetChild("titlebar").SetCloseEvent(ui.__mem_func__(self.OnCancel))
            except:
                import exception
                exception.Abort("GuvenlikDialog.__LoadDialog.BindObject")

            self.unutButton.SetEvent(ui.__mem_func__(self.Unuttum))
            self.bilgiButton.SetEvent(ui.__mem_func__(self.Bilgi))
            self.num_1.SetEvent(lambda arg=1: self.num_click(arg))
            self.num_2.SetEvent(lambda arg=2: self.num_click(arg))
            self.num_3.SetEvent(lambda arg=3: self.num_click(arg))
            self.num_4.SetEvent(lambda arg=4: self.num_click(arg))
            self.num_5.SetEvent(lambda arg=5: self.num_click(arg))
            self.num_6.SetEvent(lambda arg=6: self.num_click(arg))
            self.num_7.SetEvent(lambda arg=7: self.num_click(arg))
            self.num_8.SetEvent(lambda arg=8: self.num_click(arg))
            self.num_9.SetEvent(lambda arg=9: self.num_click(arg))
            self.num_0.SetEvent(lambda arg=0: self.num_click(arg))
            g=1
            self.unutButton.ShowToolTip = lambda arg=g: self.__OverIn()
            self.unutButton.HideToolTip = lambda arg=g: self.__OverOut()
            self.bilgiButton.ShowToolTip = lambda arg=g: self.__OverIn2()
            self.bilgiButton.HideToolTip = lambda arg=g: self.__OverOut()
            self.bilgiButton.SetUpVisual("sidebar/but.tga")
            self.bilgiButton.SetOverVisual("ui/sidebar/but.tga")
            self.bilgiButton.SetDownVisual("sidebar/but.tga")
            self.passwordValue.OnIMEReturn = self.OnAccept
            self.passwordValue.OnPressEscapeKey = self.OnCancel
            self.acceptButton.SetEvent(ui.__mem_func__(self.OnAccept))
            self.cancelButton.SetEvent(ui.__mem_func__(self.OnCancel))
            self.cancelButton.Hide()
            self.rememberButton.SetEvent(ui.__mem_func__(self.OnChangePassword))
            self.wndChangePassword2 = ChangePasswordDialog2()

        def Destroy(self):
            self.ClearDictionary()
            self.passwordValue = None
            self.acceptButton = None
            self.cancelButton = None
            self.bilgiButton = None
            self.titleName = None

        def SetTitle(self, title):
            self.titleName.SetText(title)

        def num_click(self,num):
            val = int(len(self.passwordValue.GetText()))
            if (val < 6):
                val2 = self.passwordValue.GetText()+str(num)
                self.passwordValue.SetText(val2)

        def ShowDialog(self, isCreate):          
            self.passwordValue.SetText("")
            self.passwordValue.SetFocus()
            self.SetCenterPosition()
            #if isCreate == True:
            #    #elf.securtiyControl.SetText("Güvenlik Durumu: " + "|cffff0000" + "Şifre oluşturulmamış.")
            #    self.acceptButton.SetText("Oluştur")
            #    self.rememberButton.Hide()
            #    self.rememberButton.SetToolTipText("Deneme")
            #    self.isCreate = True
            if isCreate == True:
                #self.securtiyControl.SetText("Güvenlik Durumu: " + "|cff00ff00" + "Güvenlik aktif.")
                self.rememberButton.SetText(translate.sifredegis)
                self.rememberButton.SetToolTipText("Deneme")
                self.isCreate = False
            self.Show()

        def CloseDialog(self):
            self.passwordValue.KillFocus()
            self.Hide()

        def OnAccept(self):
            if self.isCreate == True:
                net.SendChatPacket("/create_security {0}".format(self.passwordValue.GetText()))
            else:
                net.SendChatPacket("/input_security {0}".format(self.passwordValue.GetText()))
            return TRUE

        def OnCancel(self):
            pass

        def __OverOut(self):
            self.__HideStatToolTip()

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

        def __OverIn2(self):
            a=0
            self.__ShowStatToolTip(translate.olustur1,translate.olustur2)

        def __ShowStatToolTip(self, bilgi,bilgi2=""):
            self.toolTip.ClearToolTip()
            self.toolTip.AppendTextLine(bilgi)
            if (bilgi2 != ""):
                self.toolTip.AppendTextLine(bilgi2)
            self.toolTip.Show()
          
        def OnChangePassword(self):
            if self.isCreate == False:
                self.wndChangePassword2.Open()
            else:
                pass

        def Bilgi(self):
            Board2 = ui.BoardWithTitleBar()
            self.Board2 = Board2
            self.Board2.SetSize(200, 230)
            self.Board2.SetCenterPosition()
            self.Board2.AddFlag("movable")
            self.Board2.AddFlag("float")
            self.Board2.SetTitleName("Sistem Bilgisi:")

            a = ui.TextLine()
            a.SetParent(self.Board2)
            a.SetPosition(20, 35)
            a.SetText(translate.yazi5)
            a.SetFontColor(4.0, 0.83, 0)
            a.Show()
            self.UA.append(a)
      
            b = ui.TextLine()
            b.SetParent(self.Board2)
            b.SetPosition(20, 50)
            b.SetText(translate.yazi6)
            b.SetFontColor(4.0, 0.83, 0)
            b.Show()
            self.UA.append(b)
            c = ui.TextLine()
            c.SetParent(self.Board2)
            c.SetPosition(20, 65)
            c.SetText(translate.yazi7)
            c.SetFontColor(4.0, 0.83, 0)
            c.Show()
            self.UA.append(c)
            d = ui.TextLine()
            d.SetParent(self.Board2)
            d.SetPosition(20, 80)
            d.SetText(translate.yazi8)
            d.SetFontColor(4.0, 0.83, 0)
            d.Show()
            self.UA.append(d)
            e = ui.TextLine()
            e.SetParent(self.Board2)
            e.SetPosition(20, 95)
            e.SetText(translate.yazi9)
            e.SetFontColor(4.0, 0.83, 0)
            e.Show()
            self.UA.append(e)
            f = ui.TextLine()
            f.SetParent(self.Board2)
            f.SetPosition(20, 110)
            f.SetText(translate.yazi10)
            f.SetFontColor(4.0, 0.83, 0)
            f.Show()
            self.UA.append(f)
            g = ui.TextLine()
            g.SetParent(self.Board2)
            g.SetPosition(20, 125)
            g.SetText(translate.yazi11)
            g.SetFontColor(4.0, 0.83, 0)
            g.Show()
            self.UA.append(g)
            h = ui.TextLine()
            h.SetParent(self.Board2)
            h.SetPosition(20, 140)
            h.SetText(translate.yazi12)
            h.SetFontColor(4.0, 0.83, 0)
            h.Show()
            self.UA.append(h)
            i = ui.TextLine()
            i.SetParent(self.Board2)
            i.SetPosition(20, 155)
            i.SetText(translate.yazi13)
            i.SetFontColor(4.0, 0.83, 0)
            i.Show()
            self.UA.append(i)
            l = ui.TextLine()
            l.SetParent(self.Board2)
            l.SetPosition(20, 170)
            l.SetText(translate.yazi14)
            l.SetFontColor(4.0, 0.83, 0)
            l.Show()
            self.UA.append(l)
            k = ui.TextLine()
            k.SetParent(self.Board2)
            k.SetPosition(20, 185)
            k.SetText(translate.yazi15)
            k.SetFontColor(4.0, 0.83, 0)
            k.Show()
            self.UA.append(k)

            self.Board2.SetCloseEvent(self.Cxd2)
            self.Board2.Show()
      
            return True

        def Unuttum(self):
            Board = ui.BoardWithTitleBar()
            self.Board = Board
            self.Board.SetSize(176, 150)
            self.Board.SetCenterPosition()
            self.Board.AddFlag("movable")
            self.Board.AddFlag("float")
            self.Board.SetTitleName("Bilgi:")

            a = ui.TextLine()
            a.SetParent(self.Board)
            a.SetPosition(20, 35)
            a.SetText(translate.yazi1)
            a.SetFontColor(4.0, 0.83, 0)
            a.Show()
            self.UI.append(a)
      
            b = ui.TextLine()
            b.SetParent(self.Board)
            b.SetPosition(20, 50)
            b.SetText(translate.yazi2)
            b.SetFontColor(4.0, 0.83, 0)
            b.Show()
            self.UI.append(b)
            c = ui.TextLine()
            c.SetParent(self.Board)
            c.SetPosition(20, 65)
            c.SetText(translate.yazi3)
            c.SetFontColor(4.0, 0.83, 0)
            c.Show()
            self.UI.append(c)
            d = ui.TextLine()
            d.SetParent(self.Board)
            d.SetPosition(20, 95)
            d.SetText(translate.yazi4)
            d.SetFontColor(4.0, 0.83, 0)
            d.Show()
            self.UI.append(d)

            self.Board.SetCloseEvent(self.Cxd1)
            self.Board.Show()
      
            return True

        def Cxd1(self):
            self.Board.Hide()

        def Cxd2(self):
            self.Board2.Hide()
      
              
    class ChangePasswordDialog2(ui.ScriptWindow):
        def __init__(self):
            ui.ScriptWindow.__init__(self)
            self.LoadDialog()

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

        def __LoadDialog(self):
            self.dlgMessage = ui.ScriptWindow()
            try:
                pyScrLoader = ui.PythonScriptLoader()
                pyScrLoader.LoadScriptFile(self.dlgMessage, "uiscript/popupdialog.py")
                self.dlgMessage.GetChild("message").SetText("Deneme")
                self.dlgMessage.GetChild("accept").SetEvent(ui.__mem_func__(self.OnCloseMessageDialog))
            except:
                import exception
                exception.Abort("SafeboxWindow.__LoadDialog.LoadObject")

        def LoadDialog(self):
            try:
                pyScrLoader = ui.PythonScriptLoader()
                pyScrLoader.LoadScriptFile(self, "uiscript/changepassworddialog2.py")

            except:
                import exception
                exception.Abort("ChangePasswordDialog.LoadDialog.LoadObject")

            try:
                self.GetChild("accept_button").SetEvent(ui.__mem_func__(self.OnAccept))
                self.GetChild("cancel_button").SetEvent(ui.__mem_func__(self.OnCancel))
                self.GetChild("titlebar").SetCloseEvent(ui.__mem_func__(self.OnCancel))
                oldPassword = self.GetChild("old_password_value")
                newPassword = self.GetChild("new_password_value")
                newPasswordCheck = self.GetChild("new_password_check_value")
            except:
                import exception
                exception.Abort("ChangePasswordDialog.LoadDialog.BindObject")

            oldPassword.SetTabEvent(lambda arg=1: self.OnNextFocus(arg))
            newPassword.SetTabEvent(lambda arg=2: self.OnNextFocus(arg))
            newPasswordCheck.SetTabEvent(lambda arg=3: self.OnNextFocus(arg))
            oldPassword.SetReturnEvent(lambda arg=1: self.OnNextFocus(arg))
            newPassword.SetReturnEvent(lambda arg=2: self.OnNextFocus(arg))
            newPasswordCheck.SetReturnEvent(ui.__mem_func__(self.OnAccept))
            oldPassword.OnPressEscapeKey = self.OnCancel
            newPassword.OnPressEscapeKey = self.OnCancel
            newPasswordCheck.OnPressEscapeKey = self.OnCancel

            self.oldPassword = oldPassword
            self.newPassword = newPassword
            self.newPasswordCheck = newPasswordCheck

        def OnNextFocus(self, arg):
            if 1 == arg:
                self.oldPassword.KillFocus()
                self.newPassword.SetFocus()
            elif 2 == arg:
                self.newPassword.KillFocus()
                self.newPasswordCheck.SetFocus()
            elif 3 == arg:
                self.newPasswordCheck.KillFocus()
                self.oldPassword.SetFocus()

        def Destroy(self):
            self.ClearDictionary()
            self.dlgMessage.ClearDictionary()
            self.oldPassword = None
            self.newPassword = None
            self.newPasswordCheck = None

        def Open(self):
            self.oldPassword.SetText("")
            self.newPassword.SetText("")
            self.newPasswordCheck.SetText("")
            self.oldPassword.SetFocus()
            self.SetCenterPosition()
            self.SetTop()
            self.Show()

        def Close(self):
            self.oldPassword.SetText("")
            self.newPassword.SetText("")
            self.newPasswordCheck.SetText("")
            self.oldPassword.KillFocus()
            self.newPassword.KillFocus()
            self.newPasswordCheck.KillFocus()
            self.Hide()

        def OnAccept(self):
            oldPasswordText = self.oldPassword.GetText()
            newPasswordText = self.newPassword.GetText()
            newPasswordCheckText = self.newPasswordCheck.GetText()
            if newPasswordText != newPasswordCheckText:
                self.dlgMessage.SetCenterPosition()
                self.dlgMessage.SetTop()
                self.dlgMessage.Show()
                return True
            net.SendChatPacket("/change_security %s %s %s" % (oldPasswordText, newPasswordText, newPasswordCheckText))
            self.Close()
            return True

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

        def OnCloseMessageDialog(self):
            self.newPassword.SetText("")
            self.newPasswordCheck.SetText("")
            self.newPassword.SetFocus()
            self.dlgMessage.Hide()

class MailDegistir(ui.ScriptWindow):
    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.__LoadDialog()

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

    def __LoadDialog(self):
        self.dlgMessage = ui.ScriptWindow()
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self.dlgMessage, "uiscript/popupdialog.py")
            self.dlgMessage.GetChild("message").SetText(localeInfo.SAFEBOX_WRONG_PASSWORD)
            self.dlgMessage.GetChild("accept").SetEvent(ui.__mem_func__(self.OnCloseMessageDialog))
        except:
            import exception
            exception.Abort("SafeboxWindow.__LoadDialog.LoadObject")

    def LoadDialog(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "uiscript/maildegistir.py")

        except:
            import exception
            exception.Abort("maildegistir.LoadDialog.LoadObject")

        try:
            self.GetChild("accept_button").SetEvent(ui.__mem_func__(self.OnAccept))
            self.GetChild("cancel_button").SetEvent(ui.__mem_func__(self.OnCancel))
            self.GetChild("titlebar").SetCloseEvent(ui.__mem_func__(self.OnCancel))
            oldPassword = self.GetChild("old_password_value")
            newPassword = self.GetChild("new_password_value")
            newPasswordCheck = self.GetChild("new_password_check_value")
        except:
            import exception
            exception.Abort("maildegistir.LoadDialog.BindObject")

        oldPassword.SetTabEvent(lambda arg=1: self.OnNextFocus(arg))
        newPassword.SetTabEvent(lambda arg=2: self.OnNextFocus(arg))
        newPasswordCheck.SetTabEvent(lambda arg=3: self.OnNextFocus(arg))
        oldPassword.SetReturnEvent(lambda arg=1: self.OnNextFocus(arg))
        newPassword.SetReturnEvent(lambda arg=2: self.OnNextFocus(arg))
        newPasswordCheck.SetReturnEvent(ui.__mem_func__(self.OnAccept))
        oldPassword.OnPressEscapeKey = self.OnCancel
        newPassword.OnPressEscapeKey = self.OnCancel
        newPasswordCheck.OnPressEscapeKey = self.OnCancel

        self.oldPassword = oldPassword
        self.newPassword = newPassword
        self.newPasswordCheck = newPasswordCheck

    def OnNextFocus(self, arg):
        if 1 == arg:
            self.oldPassword.KillFocus()
            self.newPassword.SetFocus()
        elif 2 == arg:
            self.newPassword.KillFocus()
            self.newPasswordCheck.SetFocus()
        elif 3 == arg:
            self.newPasswordCheck.KillFocus()
            self.oldPassword.SetFocus()

    def Destroy(self):
        self.ClearDictionary()
        self.dlgMessage.ClearDictionary()
        self.oldPassword = None
        self.newPassword = None
        self.newPasswordCheck = None

    def Open(self):
        self.oldPassword.SetText("")
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.oldPassword.SetFocus()
        self.SetCenterPosition()
        self.SetTop()
        self.Show()

    def Close(self):
        self.oldPassword.SetText("")
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.oldPassword.KillFocus()
        self.newPassword.KillFocus()
        self.newPasswordCheck.KillFocus()
        self.Hide()

    def OnAccept(self):
        oldPasswordText = self.oldPassword.GetText()
        newPasswordText = self.newPassword.GetText()
        newPasswordCheckText = self.newPasswordCheck.GetText()
        if newPasswordText != newPasswordCheckText:
            self.dlgMessage.SetCenterPosition()
            self.dlgMessage.SetTop()
            self.dlgMessage.Show()
            return True
        net.SendChatPacket("/mail_degistir %s %s" % (oldPasswordText, newPasswordText))
        self.Close()
        return True

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

    def OnCloseMessageDialog(self):
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.newPassword.SetFocus()
        self.dlgMessage.Hide()

class PasswordDialog(ui.ScriptWindow):
    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.__LoadDialog()
        self.Refreshdepolar()

        self.sendMessage = "/safebox_password "

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

    def __LoadDialog(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
#            if localeInfo.IsEUROPE()and app.GetLocalePath() != "locale/ca"and app.GetLocalePath() != "locale/sg" :
#            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "passworddialog.py")
            pyScrLoader.LoadScriptFile(self, "uiscript/passworddialog.py")
#            else:
#                pyScrLoader.LoadScriptFile(self, "uiscript/passworddialog.py")
        except:
            import exception
            exception.Abort("PasswordDialog.__LoadDialog.LoadObject")

        try:
            self.passwordValue = self.GetChild("password_value")
            self.acceptButton = self.GetChild("accept_button")
            self.cancelButton = self.GetChild("cancel_button")
            self.NormalDepo = self.GetChild("normal_button")
            self.NesneDepo = self.GetChild("nesne_button")
            self.titleName = self.GetChild("TitleName")
            self.GetChild("titlebar").SetCloseEvent(ui.__mem_func__(self.CloseDialog))
        except:
            import exception
            exception.Abort("PasswordDialog.__LoadDialog.BindObject")

        self.passwordValue.OnIMEReturn = self.OnAccept
        self.passwordValue.OnPressEscapeKey = self.OnCancel
        self.acceptButton.SetEvent(ui.__mem_func__(self.OnAccept))
        self.cancelButton.SetEvent(ui.__mem_func__(self.OnCancel))
        self.NormalDepo.SetEvent(ui.__mem_func__(self.__NormalDepo))
        self.NesneDepo.SetEvent(ui.__mem_func__(self.__NesneDepo))

    def Destroy(self):
        self.ClearDictionary()
        self.passwordValue = None
        self.acceptButton = None
        self.cancelButton = None
        self.titleName = None

    def SetTitle(self, title):
        self.titleName.SetText(title)

    def SetSendMessage(self, msg):
        self.sendMessage = msg

    def ShowDialog(self):
        self.passwordValue.SetText("")
        self.passwordValue.SetFocus()
        self.SetCenterPosition()
        self.Show()

    def CloseDialog(self):
        self.passwordValue.KillFocus()
        self.Hide()

    def OnAccept(self):
        if constInfo.depolar == 1:
            net.SendChatPacket(self.sendMessage + self.passwordValue.GetText())
        elif constInfo.depolar == 0:
            net.SendChatPacket("/mall_password " + self.passwordValue.GetText())
          
        self.CloseDialog()
        return TRUE

    def OnCancel(self):
        self.CloseDialog()
        return True

    def __NormalDepo(self):
        constInfo.depolar = 1
        self.Refreshdepolar()
  
    def __NesneDepo(self):
        constInfo.depolar = 0
        self.Refreshdepolar()
  
    def Refreshdepolar(self):
        if constInfo.depolar == 1:
            self.NormalDepo.Down()
            self.NesneDepo.SetUp()
        else:
            self.NesneDepo.Down()
            self.NormalDepo.SetUp()

class ChangePasswordDialog(ui.ScriptWindow):
    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.__LoadDialog()

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

    def __LoadDialog(self):
        self.dlgMessage = ui.ScriptWindow()
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self.dlgMessage, "uiscript/popupdialog.py")
            self.dlgMessage.GetChild("message").SetText(localeInfo.SAFEBOX_WRONG_PASSWORD)
            self.dlgMessage.GetChild("accept").SetEvent(ui.__mem_func__(self.OnCloseMessageDialog))
        except:
            import exception
            exception.Abort("SafeboxWindow.__LoadDialog.LoadObject")

    def LoadDialog(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "uiscript/changepassworddialog.py")

        except:
            import exception
            exception.Abort("ChangePasswordDialog.LoadDialog.LoadObject")

        try:
            self.GetChild("accept_button").SetEvent(ui.__mem_func__(self.OnAccept))
            self.GetChild("cancel_button").SetEvent(ui.__mem_func__(self.OnCancel))
            self.GetChild("titlebar").SetCloseEvent(ui.__mem_func__(self.OnCancel))
            oldPassword = self.GetChild("old_password_value")
            newPassword = self.GetChild("new_password_value")
            newPasswordCheck = self.GetChild("new_password_check_value")
        except:
            import exception
            exception.Abort("ChangePasswordDialog.LoadDialog.BindObject")

        oldPassword.SetTabEvent(lambda arg=1: self.OnNextFocus(arg))
        newPassword.SetTabEvent(lambda arg=2: self.OnNextFocus(arg))
        newPasswordCheck.SetTabEvent(lambda arg=3: self.OnNextFocus(arg))
        oldPassword.SetReturnEvent(lambda arg=1: self.OnNextFocus(arg))
        newPassword.SetReturnEvent(lambda arg=2: self.OnNextFocus(arg))
        newPasswordCheck.SetReturnEvent(ui.__mem_func__(self.OnAccept))
        oldPassword.OnPressEscapeKey = self.OnCancel
        newPassword.OnPressEscapeKey = self.OnCancel
        newPasswordCheck.OnPressEscapeKey = self.OnCancel

        self.oldPassword = oldPassword
        self.newPassword = newPassword
        self.newPasswordCheck = newPasswordCheck

    def OnNextFocus(self, arg):
        if 1 == arg:
            self.oldPassword.KillFocus()
            self.newPassword.SetFocus()
        elif 2 == arg:
            self.newPassword.KillFocus()
            self.newPasswordCheck.SetFocus()
        elif 3 == arg:
            self.newPasswordCheck.KillFocus()
            self.oldPassword.SetFocus()

    def Destroy(self):
        self.ClearDictionary()
        self.dlgMessage.ClearDictionary()
        self.oldPassword = None
        self.newPassword = None
        self.newPasswordCheck = None

    def Open(self):
        self.oldPassword.SetText("")
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.oldPassword.SetFocus()
        self.SetCenterPosition()
        self.SetTop()
        self.Show()

    def Close(self):
        self.oldPassword.SetText("")
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.oldPassword.KillFocus()
        self.newPassword.KillFocus()
        self.newPasswordCheck.KillFocus()
        self.Hide()

    def OnAccept(self):
        oldPasswordText = self.oldPassword.GetText()
        newPasswordText = self.newPassword.GetText()
        newPasswordCheckText = self.newPasswordCheck.GetText()
        if newPasswordText != newPasswordCheckText:
            self.dlgMessage.SetCenterPosition()
            self.dlgMessage.SetTop()
            self.dlgMessage.Show()
            return True
        net.SendChatPacket("/safebox_change_password %s %s" % (oldPasswordText, newPasswordText))
        self.Close()
        return True

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

    def OnCloseMessageDialog(self):
        self.newPassword.SetText("")
        self.newPasswordCheck.SetText("")
        self.newPassword.SetFocus()
        self.dlgMessage.Hide()

class SafeboxWindow(ui.ScriptWindow):

    BOX_WIDTH = 176 #176

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.tooltipItem = None
        self.sellingSlotNumber = -1
        self.pageButtonList = []
        self.curPageIndex = 0
        self.isLoaded = 0
        self.xSafeBoxStart = 0
        self.ySafeBoxStart = 0

        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)      

    def Destroy(self):
        self.ClearDictionary()

        self.dlgPickMoney.Destroy()
        self.dlgPickMoney = None
        self.dlgChangePassword.Destroy()
        self.dlgChangePassword = None
        self.dlgMailDegistir.Destroy()
        self.dlgMailDegistir = None

        self.tooltipItem = None
        self.wndMoneySlot = None
        self.wndMoney = None
        self.wndBoard = None
        self.wndItem = None

        self.pageButtonList = []

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

        self.isLoaded = 1

        pyScrLoader = ui.PythonScriptLoader()
        pyScrLoader.LoadScriptFile(self, "UIScript/SafeboxWindow.py")

        from _weakref import proxy

        ## Item
        wndItem = ui.GridSlotWindow()
        wndItem.SetParent(self)
        wndItem.SetPosition(8, 35) # 35
        wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
        wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
        wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
        wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
        wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
        wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        wndItem.Show()

        ## PickMoneyDialog
        import uiPickMoney
        dlgPickMoney = uiPickMoney.PickMoneyDialog()
        dlgPickMoney.LoadDialog()
        dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
        dlgPickMoney.Hide()

        ## ChangePasswrod
        dlgChangePassword = ChangePasswordDialog()
        dlgChangePassword.LoadDialog()
        dlgChangePassword.Hide()
      
        ## MailDegistir
        dlgMailDegistir = MailDegistir()
        dlgMailDegistir.LoadDialog()
        dlgMailDegistir.Hide()      

        ## Close Button
        self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
        self.GetChild("ChangePasswordButton").SetEvent(ui.__mem_func__(self.OnChangePassword))
        self.GetChild("MailDegistirButton").SetEvent(ui.__mem_func__(self.MailDegistir))
        self.GetChild("ExitButton").SetEvent(ui.__mem_func__(self.Close))

        self.wndItem = wndItem
        self.dlgPickMoney = dlgPickMoney
        self.dlgChangePassword = dlgChangePassword
        self.dlgMailDegistir = dlgMailDegistir
        self.wndBoard = self.GetChild("board")
        #self.wndMoney = self.GetChild("Money")
        #self.wndMoneySlot = self.GetChild("Money_Slot")
        #self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

        ## Initialize
        self.SetTableSize(3)
        self.RefreshSafeboxMoney()

    def OpenPickMoneyDialog(self):

        if mouseModule.mouseController.isAttached():

            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            if player.SLOT_TYPE_INVENTORY == mouseModule.mouseController.GetAttachedType():

                if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
                    net.SendSafeboxSaveMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
                    snd.PlaySound("sound/ui/money.wav")

            mouseModule.mouseController.DeattachObject()

        else:
            curMoney = safebox.GetMoney()

            if curMoney <= 0:
                return

            self.dlgPickMoney.Open(curMoney)

    def ShowWindow(self, size):

        (self.xSafeBoxStart, self.ySafeBoxStart, z) = player.GetMainCharacterPosition()

        self.SetTableSize(size)
        self.Show()

    def __MakePageButton(self, pageCount):
        self.curPageIndex = 0
        self.pageButtonList = []

        pos = -int(float(pageCount-1)/2 * 33)
        for i in xrange(pageCount):
            text = ""
            if i == 0:
                text = "I"
            elif i == 1:
                text = "II"
            elif i == 2:
                text = "III"
            elif i == 3:
                text = "V"
            elif i == 4:
                text = "IV"
            button = ui.RadioButton()
            button.SetParent(self)
            button.SetUpVisual("d:/ymir work/ui/game/windows/tab_button_small_01.sub")
            button.SetOverVisual("d:/ymir work/ui/game/windows/tab_button_small_02.sub")
            button.SetDownVisual("d:/ymir work/ui/game/windows/tab_button_small_03.sub")
            button.SetWindowHorizontalAlignCenter()
            button.SetWindowVerticalAlignBottom()
            button.SetPosition(pos, 85+6)
            button.SetText(text)
            button.SetEvent(lambda arg=i: self.SelectPage(arg))
            button.Show()
            self.pageButtonList.append(button)

            pos += 33
            text += "I"

        self.pageButtonList[0].Down()

    def SelectPage(self, index):

        self.curPageIndex = index

        for btn in self.pageButtonList:
            btn.SetUp()

        self.pageButtonList[index].Down()
        self.RefreshSafebox()

    def __LocalPosToGlobalPos(self, local):
        return self.curPageIndex*safebox.SAFEBOX_PAGE_SIZE + local

    def SetTableSize(self, size):

        pageCount = max(1, size / safebox.SAFEBOX_SLOT_Y_COUNT)
        pageCount = min(5, pageCount)
        size = safebox.SAFEBOX_SLOT_Y_COUNT

        self.__MakePageButton(pageCount)

        self.wndItem.ArrangeSlot(0, safebox.SAFEBOX_SLOT_X_COUNT, size, 32, 32, 0, 0)
        self.wndItem.RefreshSlot()
        self.wndItem.SetSlotBaseImage("d:/ymir work/ui/public/Slot_Base.sub", 1.0, 1.0, 1.0, 1.0)

        wnd_height = 130 + 32 * size
        self.wndBoard.SetSize(self.BOX_WIDTH, wnd_height)
        self.SetSize(self.BOX_WIDTH, wnd_height)
        self.UpdateRect()

    def RefreshSafebox(self):
        getItemID=safebox.GetItemID
        getItemCount=safebox.GetItemCount
        setItemID=self.wndItem.SetItemSlot

        for i in xrange(safebox.SAFEBOX_PAGE_SIZE):
            slotIndex = self.__LocalPosToGlobalPos(i)
            itemCount = getItemCount(slotIndex)
            if itemCount <= 1:
                itemCount = 0
            setItemID(i, getItemID(slotIndex), itemCount)

        self.wndItem.RefreshSlot()

    def RefreshSafeboxMoney(self):
        pass
        #self.wndMoney.SetText(str(safebox.GetMoney()))

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

    def Close(self):
        net.SendChatPacket("/safebox_close")

    def CommandCloseSafebox(self):
        if self.tooltipItem:
            self.tooltipItem.HideToolTip()

        self.dlgPickMoney.Close()
        self.dlgChangePassword.Close()
        self.Hide()

    ## Slot Event
    def SelectEmptySlot(self, selectedSlotPos):

        selectedSlotPos = self.__LocalPosToGlobalPos(selectedSlotPos)

        if mouseModule.mouseController.isAttached():

            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

            if player.SLOT_TYPE_SAFEBOX == attachedSlotType:

                net.SendSafeboxItemMovePacket(attachedSlotPos, selectedSlotPos, 0)
                #snd.PlaySound("sound/ui/drop.wav")
            else:
                attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
                if player.RESERVED_WINDOW == attachedInvenType:
                    return
                  
                if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
                    net.SendSafeboxSaveMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
                    snd.PlaySound("sound/ui/money.wav")

                else:
                    net.SendSafeboxCheckinPacket(attachedInvenType, attachedSlotPos, selectedSlotPos)
                    #snd.PlaySound("sound/ui/drop.wav")
          
            mouseModule.mouseController.DeattachObject()

    def SelectItemSlot(self, selectedSlotPos):

        selectedSlotPos = self.__LocalPosToGlobalPos(selectedSlotPos)

        if mouseModule.mouseController.isAttached():

            attachedSlotType = mouseModule.mouseController.GetAttachedType()

            if player.SLOT_TYPE_INVENTORY == attachedSlotType:

                if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
                    net.SendSafeboxSaveMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
                    snd.PlaySound("sound/ui/money.wav")

                else:
                    attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                    #net.SendSafeboxCheckinPacket(attachedSlotPos, selectedSlotPos)
                    #snd.PlaySound("sound/ui/drop.wav")

            mouseModule.mouseController.DeattachObject()

        else:

            curCursorNum = app.GetCursor()
            if app.SELL == curCursorNum:
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SAFEBOX_SELL_DISABLE_SAFEITEM)

            elif app.BUY == curCursorNum:
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)

            else:
                selectedItemID = safebox.GetItemID(selectedSlotPos)
                mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_SAFEBOX, selectedSlotPos, selectedItemID)
                snd.PlaySound("sound/ui/pick.wav")

    def UseItemSlot(self, slotIndex):
        mouseModule.mouseController.DeattachObject()

    def __ShowToolTip(self, slotIndex):
        if self.tooltipItem:
            self.tooltipItem.SetSafeBoxItem(slotIndex)

    def OverInItem(self, slotIndex):
        slotIndex = self.__LocalPosToGlobalPos(slotIndex)
        self.wndItem.SetUsableItem(False)
        self.__ShowToolTip(slotIndex)

    def OverOutItem(self):
        self.wndItem.SetUsableItem(False)
        if self.tooltipItem:
            self.tooltipItem.HideToolTip()

    def OnPickMoney(self, money):
        mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_SAFEBOX, money)

    def OnChangePassword(self):
        self.dlgChangePassword.Open()

    def MailDegistir(self):
        self.dlgMailDegistir.Open()

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

    def OnUpdate(self):

        USE_SAFEBOX_LIMIT_RANGE = 1000

        (x, y, z) = player.GetMainCharacterPosition()
        if abs(x - self.xSafeBoxStart) > USE_SAFEBOX_LIMIT_RANGE or abs(y - self.ySafeBoxStart) > USE_SAFEBOX_LIMIT_RANGE:
            self.Close()

class MallWindow(ui.ScriptWindow):

    BOX_WIDTH = 176

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.tooltipItem = None
        self.sellingSlotNumber = -1
        self.pageButtonList = []
        self.curPageIndex = 0
        self.isLoaded = 0
        self.xSafeBoxStart = 0
        self.ySafeBoxStart = 0

        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)      

    def Destroy(self):
        self.ClearDictionary()

        self.tooltipItem = None
        self.wndBoard = None
        self.wndItem = None

        self.pageButtonList = []

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

        self.isLoaded = 1

        pyScrLoader = ui.PythonScriptLoader()
        pyScrLoader.LoadScriptFile(self, "UIScript/MallWindow.py")

        from _weakref import proxy

        ## Item
        wndItem = ui.GridSlotWindow()
        wndItem.SetParent(self)
        wndItem.SetPosition(8, 35)
        wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
        wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
        wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
        wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
        wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
        wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        wndItem.Show()

        ## Close Button
        self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
        self.GetChild("ExitButton").SetEvent(ui.__mem_func__(self.Close))

        self.wndItem = wndItem
        self.wndBoard = self.GetChild("board")

        ## Initialize
        self.SetTableSize(3)

    def ShowWindow(self, size):

        (self.xSafeBoxStart, self.ySafeBoxStart, z) = player.GetMainCharacterPosition()

        self.SetTableSize(size)
        self.Show()

    def SetTableSize(self, size):

        pageCount = max(1, size / safebox.SAFEBOX_SLOT_Y_COUNT)
        pageCount = min(5, pageCount)
        size = safebox.SAFEBOX_SLOT_Y_COUNT

        self.wndItem.ArrangeSlot(0, safebox.SAFEBOX_SLOT_X_COUNT, size, 32, 32, 0, 0)
        self.wndItem.RefreshSlot()
        self.wndItem.SetSlotBaseImage("d:/ymir work/ui/public/Slot_Base.sub", 1.0, 1.0, 1.0, 1.0)

        self.wndBoard.SetSize(self.BOX_WIDTH, 82 + 32*size)
        self.SetSize(self.BOX_WIDTH, 85 + 32*size)
        self.UpdateRect()

    def RefreshMall(self):
        getItemID=safebox.GetMallItemID
        getItemCount=safebox.GetMallItemCount
        setItemID=self.wndItem.SetItemSlot

        for i in xrange(safebox.GetMallSize()):
            itemID = getItemID(i)
            itemCount = getItemCount(i)
            if itemCount <= 1:
                itemCount = 0
            setItemID(i, itemID, itemCount)

        self.wndItem.RefreshSlot()

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

    def Close(self):
        net.SendChatPacket("/mall_close")

    def CommandCloseMall(self):
        if self.tooltipItem:
            self.tooltipItem.HideToolTip()

        self.Hide()

    ## Slot Event
    def SelectEmptySlot(self, selectedSlotPos):

        if mouseModule.mouseController.isAttached():

            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MALL_CANNOT_INSERT)
            mouseModule.mouseController.DeattachObject()

    def SelectItemSlot(self, selectedSlotPos):

        if mouseModule.mouseController.isAttached():

            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MALL_CANNOT_INSERT)
            mouseModule.mouseController.DeattachObject()

        else:

            curCursorNum = app.GetCursor()
            selectedItemID = safebox.GetMallItemID(selectedSlotPos)
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_MALL, selectedSlotPos, selectedItemID)
            snd.PlaySound("sound/ui/pick.wav")

    def UseItemSlot(self, slotIndex):
        mouseModule.mouseController.DeattachObject()

    def __ShowToolTip(self, slotIndex):
        if self.tooltipItem:
            self.tooltipItem.SetMallItem(slotIndex)

    def OverInItem(self, slotIndex):
        self.__ShowToolTip(slotIndex)

    def OverOutItem(self):
        self.wndItem.SetUsableItem(False)
        if self.tooltipItem:
            self.tooltipItem.HideToolTip()

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

    def OnUpdate(self):

        USE_SAFEBOX_LIMIT_RANGE = 1000

        (x, y, z) = player.GetMainCharacterPosition()
        if abs(x - self.xSafeBoxStart) > USE_SAFEBOX_LIMIT_RANGE or abs(y - self.ySafeBoxStart) > USE_SAFEBOX_LIMIT_RANGE:
            self.Close()


if __name__ == "__main__":

    import app
    import wndMgr
    import systemSetting
    import mouseModule
    import grp
    import ui
    import chr
    import background
    import player

    #wndMgr.SetOutlineFlag(True)

    app.SetMouseHandler(mouseModule.mouseController)
    app.SetHairColorEnable(True)
    wndMgr.SetMouseHandler(mouseModule.mouseController)
    wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
    app.Create("METIN2 CLOSED BETA", systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
    mouseModule.mouseController.Create()


    wnd = SafeboxWindow()
    wnd.ShowWindow(1)
  
    app.Loop()

oyuncu=1
gonullu=0
destekac=0
satici="Premium Market"
silahci="Silah Satıcısı"
zirhci="Zırhçı"
uzaktanticsoru=" adlı oyuncu ticaret daveti gönderdi.Kabul ediyor musun?"
skor="Skor:"
katilimci="Katılımcı:"
ac="Aç"
karli="Karlı"
goster="Göster"
gosterme="Gösterme"
nesneisim="Nesne İsmi:"
oxgirisler="Ox Girişleri:"
oxgirisac="Aç"
oxyarisma="Turnuva:"
oxbaslatbuton="Başlat"
oxskillacbuton="Aç"
oxskillkapatbuton="Kapat"
oxskill="Skill Engel:"
oxbitirbuton="Bitir"
girisacbuton="Aç"
giriskapatbuton="Kapat"
katilimciox="Ox Katılımcı Sayısı :"
OxHatali="Hatali bir isim girdiniz."
OxBasari="Oyuncuyu oxtan başarıyla yasakladınız."
oxtanat="Oyuncuyu oxtan yasakla."
oxislemler="Ox Kontrol Paneli"
oxatbuton="Oxtan Yasakla"
itemkilit="Kilitli itemi satışa koyamazsınız."
oxkontrolyazi="Ne yapmak istiyorsun ?"
oxbuton="Baslat"
oxbuton1="Bitir"
HesapDondurBaslik="Hesap Dondur"
HesapDondurButon="Hesap Dondur"
HesapDondurTarihGir="Tarih Giriniz"
HesapDondurHatali="Hatalı Bir İşlem Yaptınız.Tekrar Deneyiniz."
barci="Barı kullanmak istiyormusun ?"
IsimGir="|cffFDD017|H|hİsminizi Girin"
IsimButon="|cffFDD017|H|hİsim Değiştir"
IsimDegisBaslik="İsim Değiştir"
IsimBasari="İsminiz Başarıyla Değiştirilmiştir."
IsimHatali="4 karakterden asagi bir isim yazamazsiniz!"
cek = "Para Aktar"
titlefk="Çevrimdışı Pazar"
offlineshoptitle = "Çevrimdışı Pazar İsmi"
mailbutton= "Mail Değiştir"
mailbaslik="Mail Adresi Değiştir"
acikcar="Açıkta bir pazarınız var zaten"
gerialama = "İtemlerinizi geri alabilmek için öncelikle pazarınızı kapatınız."
TICENGEL = "Karşı taraf ticaret tekliflerini reddediyor."
DUELLOIPTAL = "<Düello> Rakip 15 saniye içinde kalkmadığı için düello iptal olmuştur."
VSENGEL = "<İtemine VS:> : İtemine vs engelliyken, itemine vs yapamazsın."
BUOLMAZ = "Bu oyuncu şuanda itemine düello yapamaz."
UTOLMAZ = "İtemine ws işlemleri varken uzaktan ticaret yapamazsın."
GMENGEL = "GM'lere kapalı mesaj gönderemezsiniz."
ENGEL100 = "100'den fazla karakter içeren bir kapalı mesaj gönderemezsin."
BURDAOLMAZ = "[SERVER] Bu haritada yapamazsın!"
GECMIS = "Pazar Geçmişi"
YENILEGEC = "Pazar Geçmişini Yenile"
YENILE1DK = "Pazar geçmişini 1 dakikada bir yenileyebilirsin."
OPTION_SALESTEXT_RANGE = "Pazar İsim Mesafe"
SHOPNAMES_RANGE = 5000
YANGKAR = " Yang karşılığında "
TICYENILE = "Ticaret geçmişini 1 dakikada bir yenileyebilirsin."
PASSWORD_DESC_1="Depoyu açmak için,"
PASSWORD_DESC_2="şifreni gir."
PASSWORD_DESC_3="Şifreni değiştirdin mi?"
PASSWORD_DESC_4="Değiştirmediysen şifren şudur: '000000'."
PASSWORD_DESC_5="Şifreni Mutlaka değiştir."
PASSWORD_DESC_1_1="Güvenlik kilidini açmak"
PASSWORD_DESC_2_2="için şifreyi gir."
PASSWORD_DESC_3_3="Şifreni değiştirdin mi?"
PASSWORD_DESC_4_4="Değiştirmediysen şifren şudur: '123456'."
PASSWORD_DESC_5_5="Şifreni Mutlaka değiştir."
PASSWORD_DESC_6_6="Değiştirmediysen şifren '123456'dır."
olustur1 = "|cFFe7de0eKarakter Güvenlik Sistemi|r"
olustur2 = "|cFFe7de0eİçin Oluşturulan Şifredir|r"
yazi1 = "Güvenlik şifrenizi unuttuysanız"
yazi2 = "oyunumuzun sitesinden sıfırlama"
yazi3 = "isteği gönderebilirsiniz."
yazi4 = "Sitemiz: www.metin2.com"
yazi5 = "Güvenlik sistemi hesabınızı"
yazi6 = "güvende tutmak için hazırlanmıştır."
yazi7 = "Kullanıp kullanmama hakkına sahipsiniz."
yazi8 = "Sistem kilidi açılana kadar karakterin"
yazi9 = "yapabileceği tek şey şifre girmektir."
unuttum = "|cFFe7de0eUnuttum ?|r"
PASSWORD_TITLE="Güvenlik Şifresi"
sil_onay="Bu eşya silindiğinde geri dönüşü yoktur, emin misin?"
guvenlikbaslik="Güvenlik Şifresi"
gir="Güvenlik Şifre:"
sifredegis="Ş.Değiştir"
sifredegis1="Ş.Değiştir"
guvenlipcislembuton="|cffFDD017|H|hPc Ekle"
guvenlipcislembuton1="|cffFDD017|H|hPc Kaldır"
guvenlipcislemyazi="Güvenli Pc Sistemini Aktif Etmek İçin"
guvenlipcislemyazi1="İçin Pc Eklemelisiniz."
guvenlipcislem="Güvenli Pc"
guvenlipc="Güvenli Pc"
guvenlipcyazi="Ne İşlem Yapmak İstiyorsun?"
guvenlipcbuton1="|cffFDD017|H|hAktif Et"
guvenlipcbuton2="|cffFDD017|H|hDeaktif Et"
guvenlipcbuton3="|cffFDD017|H|hİşlemler"
krc425guvenlik="Güvenlik Paneli"
guvenlikyazi1="Hesap Güvenliği İçin Yapınız!"
guvenlikbuton="|cffFDD017|H|hKarakter Kilit"
guvenlikbuton1="|cffFDD017|H|hGüvenli Pc"
guvenlikbuton2="|cffFDD017|H|hBilgi Al"
guvenlikbuton3="|cffFDD017|H|hHesabı Dondur"
bilgialyazi="Karakter Kilit:"
bilgialyazi1="Karakterinizi Kilitler Ve Siz Deaktif Etmedikçe"
bilgialyazi2="Karakterinizde Hiçbir İşlem Yapılamaz."
bilgialyazi3="Güvenli Pc:"
bilgialyazi4="Hesabınıza Kendi Bilgisayarınızdan Başka Giriş"
bilgialyazi5="Yapılamamasını Sağlar."
bilgialyazi6="Hesabı Dondur:"
bilgialyazi7="Hesabi belirttiğiniz tarihe kadar dondurur."
bilgialyazi8="Hesabiniza erisilmez giris yapilamaz."
bilgialyazi9="Hesabinizi dondurmak icin;"
bilgialyazi10="|cFFFF0000|H|hYıl:Ay:Gün Saat:Dakika:Saniye"
bilgialyazi11="Şeklinde yazmalısınız."
bilgialyazi12="Örn: 2017:05:25 14:23:20"
bilgibuton="Bilgi"
evet="Evet"
hayir="Hayır"
ROUND = "<Düello> Diğer round için hazırlıklarını yap ve hazır butonuna tıkla!"
HMKAPA = "İtemine vs açıkken hızlı menü kullanılamaz."
DUELKAP = "Düello anında rakip seçiliyken bu işlemi kullanamazsın."
OTOMSG = "<Otomatik Mesaj> : Otomatik mesaj kapatıldı."
ITEMSIL = "%s adet %s |c000000|H|h adlı itemi silmek istiyor musun?"
KILITKAP = "İtemine vs açıkken item kilitlenmez."
DUEKAP = "Düello paneli açıkken item kullanamazsın."
TICKAP = "Ticaret açıkken item kilitlenmez."
KILITSOR2 = "|cFF0ea930İşlem sonucuna göre item kilitlenir veya açılır.|r"
KILITSOR1 = "|cFFdb0d0d%s isimli eşyayı işlemek istediğine emin misin?|r"
KILITSOR = "|cFFdb0d0d%dx %s isimli eşyayı işlemek istediğine emin misin?|r"
NF = "Silinecek eşya bulunamadı."
ATC = "<Sistem> At çağırıldı, bekleyin."
ATG = "<Sistem> At gönderildi."
TIENG = "Ticaret açıkken item silemezsin."
PENG = "Pazar açıkken item silemezsin."
maxkisi = "Max. Kişi :"
maxkisiquest = 0
maxskorquest = 0
loncasavasi = 0
verigonder = ""
loncasavasial = 0
DAKIKA =    "%s Dakika"
SAATVEDAKIKA =    "%s Saat ve %s Dakika"
GUNSAAT =    "%s Gün ve %s Saat"
ENVIRONMENT_NIGHT="d:/ymir work/environment/moonlight04.msenv"
ENVIRONMENT_EVENING="d:/ymir work/environment/evening.msenv"
Night=0
gecegunduz = "Gece / Gündüz"
gecebuton = "Gece"
gunduzbuton = "Gündüz"
acik = 0
chpanel = "Yan Panel"
acbut = "Göster"
kapbut = "Gizle"
silah="Silah"
zirh="Zırh"
kask="kask"
kalkan="Kalkan"
bilezik="Bilezik"
ayakkabi="Ayakkabı"
kolye="Kolye"
kupe="Küpe"
efsuntext1="Bonusları Aktarmak İstediğiniz"
efsuntext11="İtem Üzerine Sürükleyin"
efsuntext2="Bonuslarını Kopyalamak İstediğiniz"
Adem_BAR = "|cFF0ea930Fiyatı: %s |r"
Adem_BAR2 = "|cFF0ea930 %s |r"
barpanel = "Bar Miktarı(100m)"
barpanel2 = "Bar Miktarı(250m)"
barpanel3 = "Bar Miktarı(750m)"
yangpanel = "Yang Miktarı"
otysl = "Ot(Yşl.)"
default = "Bu yazı varsa paneli kapatın"
BAR_YAZI1 = "Adet 100M Bar"
BAR_YAZI2 = "Adet 250M Bar"
BAR_YAZI3 = "Adet 750M Bar"
OT_YAZI1 = "Ot Miktarı(Krm)"
OT_YAZI2 = "Ot Miktarı(Mv)"
OT_YAZI3 = "Ot Miktarı(Sr)"
OT_YAZI4 = "Ot Miktarı(Yşl)"
OT_YAZI5 = "Ot Miktarı(Mor)"
gvsystem = "Güvenlik Sistemi"
devredis="Devre Dışı"
kapala="Pasifleştir"
etkink="Aktifleştir"
notet="Güvenlik Sistemi Ayarları"
notet2="Sistem şuan kullanımda."
notet3="Sistem şifresi girilmemiş."
akt = "Sistemi Aktifleştir"
psf = "Sistemi Devre Dışı Bırak"
dgs = "Güvenlik Şifresini Değiştir"
degs = "Şifre Değiştir"
uyar3="Şifreniz 3 haneden az olamaz!"
uyar4="Şifreniz boş olamaz!"
ekkey="Güvenliğiniz için şifreyi ekran klavyesinden giriniz."
ruhtas = "Ruh Taşı"
ruhtas1 = "Ruh Taşı Miktarı"
ruhtas2 = "Adet Ruh Taşı"
lessystem = "|cFF0ea930Leş Sayısı (%d)|r"
kisi = ""
itemAdi = ""
itemFiyati = 0
pos = 0
itemAdeti = 0
itemKodu=0
panelisle=0
panelisle1=0
yanguyar = "[DIKKAT]! : |cFFFF0000|H|h2 Milyar|c000000|H|h'dan fazla altın yazıyorsun."
tiklananbuton = -99
ClickedButtonIndex = -99
List_Button_Objects = {}
ticaret="İtem Satın Al"
satinals = "Satın almak istiyor musun?"

LC_TEXT = {
            # Common
            "PrivateShopSearchDialog":             "Mağazalarda Nesne Arama",
            "PRIVATESHOPSEARCH_ITEMNAME":         "İsim",
            "PRIVATESHOPSEARCH_LEVEL":             "Level",
            "PRIVATESHOPSEARCH_REFINE":         "İtem + Seviyesi",
            "PRIVATESHOPSEARCH_PRICE":             "Yang Fiyat",
            "PRIVATESHOPSEARCH_PRICE2":         "Diğer Fiyat",
            "PRIVATESHOPSEARCH_JOB":             "Sınıf",
            "PRIVATESHOPSEARCH_ITEMTYPE":        "Ürünler",
            "PRIVATESHOPSEARCH_SEARCH":            "Arama",
            "PRIVATESHOPSEARCH_BUY":             "Satın Al",
            "PRIVATESHOPSEARCH_CATEGORY":         "Kategori",
            "PRIVATESHOPSEARCH_SUBCATEGORY":     "Alt Kategori",
            "PRIVATESHOPSEARCH_ITEMCOUNT":        "Adet",
            "PRIVATESHOPSEARCH_ITEMPRICE":        "Yang Fiyat",
            "PRIVATESHOPSEARCH_ITEMFIYAT":        "Diğer Fiyat",
            "PRIVATESHOPSEARCH_SELLERNAME":        "Satıcı",
            "NesneMarket":        "Nesne Market",
        }
        
System_Menu_Yan = {
                1 : "At Çağırma",
                4 : "Çevrimdışı Pazar Yönetimi",
                6 : "Hızlı Ekipman",
                7 : "Efsun Botu",
                8 : "Efsun Botu 2",
                9 : "Log Sistemi",
                10 : "Otomatik Toplama",
                11 : "Çevrimdışı Pazar Yönetim",
                12 : "Şehrinize Döner",
                13 : "Depo - N.Market Aç",
                14 : "Gece/Gündüz",
                15 : "Kostümler",
                16 : "Kanal Değiştirici",
                17 : "Petinizin İtem Toplaması",
                18 : "Güvenlik Sistemi",
                21 : "Nesne Arama Sistemi",
                22 : "Sandık Aynası",
                23 : "İtem Kilit Sistemi",
                24 : "Uzak Market Sistemi",
                25 : "Boss Avcıları Sıralaması",
                26 : "Toplu Eşya Silme Sistemi",
                27 : "Ek Envanter [K]"
}