Jump to content

eterconfig

Inactive Member
  • Posts

    10
  • Joined

  • Last visited

  • Feedback

    0%

Posts posted by eterconfig

  1. import dbg
    import player
    import item
    import grp
    import wndMgr
    import skill
    import shop
    import exchange
    import grpText
    import safebox
    import localeInfo
    import app
    import background
    import nonplayer
    import chr

    import ui
    import mouseModule
    import constInfo

    WARP_SCROLLS = [22011, 22000, 22010]

    DESC_DEFAULT_MAX_COLS = 26 
    DESC_WESTERN_MAX_COLS = 35
    DESC_WESTERN_MAX_WIDTH = 220

    def chop(n):
        return round(n - 0.5, 1)

    def SplitDescription(desc, limit):
        total_tokens = desc.split()
        line_tokens = []
        line_len = 0
        lines = []
        for token in total_tokens:
            if "|" in token:
                sep_pos = token.find("|")
                line_tokens.append(token[:sep_pos])

                lines.append(" ".join(line_tokens))
                line_len = len(token) - (sep_pos + 1)
                line_tokens = [token[sep_pos+1:]]
            else:
                line_len += len(token)
                if len(line_tokens) + line_len > limit:
                    lines.append(" ".join(line_tokens))
                    line_len = len(token)
                    line_tokens = [token]
                else:
                    line_tokens.append(token)
        
        if line_tokens:
            lines.append(" ".join(line_tokens))

        return lines

    ###################################################################################################
    ## ToolTip
    ##
    ##   NOTE : ÇöŔç´Â Item°ú SkillŔ» »óĽÓŔ¸·Î ĆŻČ­ ˝ĂÄѵξúŔ˝
    ##          ÇĎÁö¸¸ ±×´ŮÁö Ŕǹ̰ˇ ľřľî ş¸ŔÓ
    ##
    class ToolTip(ui.ThinBoard):

        TOOL_TIP_WIDTH = 190
        TOOL_TIP_HEIGHT = 10

        TEXT_LINE_HEIGHT = 17

        TITLE_COLOR = grp.GenerateColor(0.9490, 0.9058, 0.7568, 1.0)
        SPECIAL_TITLE_COLOR = grp.GenerateColor(1.0, 0.7843, 0.0, 1.0)
        NORMAL_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
        FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
        PRICE_COLOR = 0xffFFB96D

        HIGH_PRICE_COLOR = SPECIAL_TITLE_COLOR
        MIDDLE_PRICE_COLOR = grp.GenerateColor(0.85, 0.85, 0.85, 1.0)
        LOW_PRICE_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)

        ENABLE_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
        DISABLE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)

        NEGATIVE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
        POSITIVE_COLOR = grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)
        SPECIAL_POSITIVE_COLOR = grp.GenerateColor(0.6911, 0.8754, 0.7068, 1.0)
        SPECIAL_POSITIVE_COLOR2 = grp.GenerateColor(0.8824, 0.9804, 0.8824, 1.0)

        CONDITION_COLOR = 0xffBEB47D
        CAN_LEVEL_UP_COLOR = 0xff8EC292
        CANNOT_LEVEL_UP_COLOR = DISABLE_COLOR
        NEED_SKILL_POINT_COLOR = 0xff9A9CDB

        def __init__(self, width = TOOL_TIP_WIDTH, isPickable=False):
            ui.ThinBoard.__init__(self, "TOP_MOST")

            if isPickable:
                pass
            else:
                self.AddFlag("not_pick")

            self.AddFlag("float")

            self.followFlag = True
            self.toolTipWidth = width

            self.xPos = -1
            self.yPos = -1

            self.defFontName = localeInfo.UI_DEF_FONT
            self.ClearToolTip()

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

        def ClearToolTip(self):
            self.toolTipHeight = 12
            self.childrenList = []

        def SetFollow(self, flag):
            self.followFlag = flag

        def SetDefaultFontName(self, fontName):
            self.defFontName = fontName

        def AppendSpace(self, size):
            self.toolTipHeight += size
            self.ResizeToolTip()

        def AppendHorizontalLine(self):

            for i in xrange(2):
                horizontalLine = ui.Line()
                horizontalLine.SetParent(self)
                horizontalLine.SetPosition(0, self.toolTipHeight + 3 + i)
                horizontalLine.SetWindowHorizontalAlignCenter()
                horizontalLine.SetSize(150, 0)
                horizontalLine.Show()

                if 0 == i:
                    horizontalLine.SetColor(0xff555555)
                else:
                    horizontalLine.SetColor(0xff000000)

                self.childrenList.append(horizontalLine)

            self.toolTipHeight += 11
            self.ResizeToolTip()

        def AlignHorizonalCenter(self):
            for child in self.childrenList:
                (x, y)=child.GetLocalPosition()
                child.SetPosition(self.toolTipWidth/2, y)

            self.ResizeToolTip()

        def AutoAppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetFontName(self.defFontName)
            textLine.SetPackedFontColor(color)
            textLine.SetText(text)
            textLine.SetOutline()
            textLine.SetFeather(False)
            textLine.Show()

            if centerAlign:
                textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
                textLine.SetHorizontalAlignCenter()

            else:
                textLine.SetPosition(10, self.toolTipHeight)

            self.childrenList.append(textLine)

            (textWidth, textHeight)=textLine.GetTextSize()

            textWidth += 40
            textHeight += 5

            if self.toolTipWidth < textWidth:
                self.toolTipWidth = textWidth

            self.toolTipHeight += textHeight

            return textLine

        def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetFontName(self.defFontName)
            textLine.SetPackedFontColor(color)
            textLine.SetText(text)
            textLine.SetOutline()
            textLine.SetFeather(False)
            textLine.Show()

            if centerAlign:
                textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
                textLine.SetHorizontalAlignCenter()

            else:
                textLine.SetPosition(10, self.toolTipHeight)

            self.childrenList.append(textLine)

            self.toolTipHeight += self.TEXT_LINE_HEIGHT
            self.ResizeToolTip()

            return textLine

        def AppendDescription(self, desc, limit, color = FONT_COLOR):
            if localeInfo.IsEUROPE():
                self.__AppendDescription_WesternLanguage(desc, color)
            else:
                self.__AppendDescription_EasternLanguage(desc, limit, color)

        def __AppendDescription_EasternLanguage(self, description, characterLimitation, color=FONT_COLOR):
            length = len(description)
            if 0 == length:
                return

            lineCount = grpText.GetSplitingTextLineCount(description, characterLimitation)
            for i in xrange(lineCount):
                if 0 == i:
                    self.AppendSpace(5)
                self.AppendTextLine(grpText.GetSplitingTextLine(description, characterLimitation, i), color)

        def __AppendDescription_WesternLanguage(self, desc, color=FONT_COLOR):
            lines = SplitDescription(desc, DESC_WESTERN_MAX_COLS)
            if not lines:
                return

            self.AppendSpace(5)
            for line in lines:
                self.AppendTextLine(line, color)
                

        def ResizeToolTip(self):
            self.SetSize(self.toolTipWidth, self.TOOL_TIP_HEIGHT + self.toolTipHeight)

        def SetTitle(self, name):
            self.AppendTextLine(name, self.TITLE_COLOR)

        def GetLimitTextLineColor(self, curValue, limitValue):
            if curValue < limitValue:
                return self.DISABLE_COLOR

            return self.ENABLE_COLOR

        def GetChangeTextLineColor(self, value, isSpecial=False):
            if value > 0:
                if isSpecial:
                    return self.SPECIAL_POSITIVE_COLOR
                else:
                    return self.POSITIVE_COLOR

            if 0 == value:
                return self.NORMAL_COLOR

            return self.NEGATIVE_COLOR

        def SetToolTipPosition(self, x = -1, y = -1):
            self.xPos = x
            self.yPos = y

        def ShowToolTip(self):
            self.SetTop()
            self.Show()

            self.OnUpdate()

        def HideToolTip(self):
            self.Hide()

        def OnUpdate(self):

            if not self.followFlag:
                return

            x = 0
            y = 0
            width = self.GetWidth()
            height = self.toolTipHeight

            if -1 == self.xPos and -1 == self.yPos:

                (mouseX, mouseY) = wndMgr.GetMousePosition()

                if mouseY < wndMgr.GetScreenHeight() - 300:
                    y = mouseY + 40
                else:
                    y = mouseY - height - 30

                x = mouseX - width/2                

            else:

                x = self.xPos - width/2
                y = self.yPos - height

            x = max(x, 0)
            y = max(y, 0)
            x = min(x + width/2, wndMgr.GetScreenWidth() - width/2) - width/2
            y = min(y + self.GetHeight(), wndMgr.GetScreenHeight()) - self.GetHeight()

            parentWindow = self.GetParentProxy()
            if parentWindow:
                (gx, gy) = parentWindow.GetGlobalPosition()
                x -= gx
                y -= gy

            self.SetPosition(x, y)

    class ItemToolTip(ToolTip):

        CHARACTER_NAMES = ( 
            localeInfo.TOOLTIP_WARRIOR,
            localeInfo.TOOLTIP_ASSASSIN,
            localeInfo.TOOLTIP_SURA,
            localeInfo.TOOLTIP_SHAMAN 
        )        

        CHARACTER_COUNT = len(CHARACTER_NAMES)
        WEAR_NAMES = ( 
            localeInfo.TOOLTIP_ARMOR, 
            localeInfo.TOOLTIP_HELMET, 
            localeInfo.TOOLTIP_SHOES, 
            localeInfo.TOOLTIP_WRISTLET, 
            localeInfo.TOOLTIP_WEAPON, 
            localeInfo.TOOLTIP_NECK,
            localeInfo.TOOLTIP_EAR,
            localeInfo.TOOLTIP_UNIQUE,
            localeInfo.TOOLTIP_SHIELD,
            localeInfo.TOOLTIP_ARROW,
        )
        WEAR_COUNT = len(WEAR_NAMES)

        AFFECT_DICT = {
            item.APPLY_MAX_HP : localeInfo.TOOLTIP_MAX_HP,
            item.APPLY_MAX_SP : localeInfo.TOOLTIP_MAX_SP,
            item.APPLY_CON : localeInfo.TOOLTIP_CON,
            item.APPLY_INT : localeInfo.TOOLTIP_INT,
            item.APPLY_STR : localeInfo.TOOLTIP_STR,
            item.APPLY_DEX : localeInfo.TOOLTIP_DEX,
            item.APPLY_ATT_SPEED : localeInfo.TOOLTIP_ATT_SPEED,
            item.APPLY_MOV_SPEED : localeInfo.TOOLTIP_MOV_SPEED,
            item.APPLY_CAST_SPEED : localeInfo.TOOLTIP_CAST_SPEED,
            item.APPLY_HP_REGEN : localeInfo.TOOLTIP_HP_REGEN,
            item.APPLY_SP_REGEN : localeInfo.TOOLTIP_SP_REGEN,
            item.APPLY_POISON_PCT : localeInfo.TOOLTIP_APPLY_POISON_PCT,
            item.APPLY_STUN_PCT : localeInfo.TOOLTIP_APPLY_STUN_PCT,
            item.APPLY_SLOW_PCT : localeInfo.TOOLTIP_APPLY_SLOW_PCT,
            item.APPLY_CRITICAL_PCT : localeInfo.TOOLTIP_APPLY_CRITICAL_PCT,
            item.APPLY_PENETRATE_PCT : localeInfo.TOOLTIP_APPLY_PENETRATE_PCT,

            item.APPLY_ATTBONUS_WARRIOR : localeInfo.TOOLTIP_APPLY_ATTBONUS_WARRIOR,
            item.APPLY_ATTBONUS_ASSASSIN : localeInfo.TOOLTIP_APPLY_ATTBONUS_ASSASSIN,
            item.APPLY_ATTBONUS_SURA : localeInfo.TOOLTIP_APPLY_ATTBONUS_SURA,
            item.APPLY_ATTBONUS_SHAMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_SHAMAN,
            item.APPLY_ATTBONUS_MONSTER : localeInfo.TOOLTIP_APPLY_ATTBONUS_MONSTER,

            item.APPLY_ATTBONUS_HUMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_HUMAN,
            item.APPLY_ATTBONUS_ANIMAL : localeInfo.TOOLTIP_APPLY_ATTBONUS_ANIMAL,
            item.APPLY_ATTBONUS_ORC : localeInfo.TOOLTIP_APPLY_ATTBONUS_ORC,
            item.APPLY_ATTBONUS_MILGYO : localeInfo.TOOLTIP_APPLY_ATTBONUS_MILGYO,
            item.APPLY_ATTBONUS_UNDEAD : localeInfo.TOOLTIP_APPLY_ATTBONUS_UNDEAD,
            item.APPLY_ATTBONUS_DEVIL : localeInfo.TOOLTIP_APPLY_ATTBONUS_DEVIL,
            item.APPLY_STEAL_HP : localeInfo.TOOLTIP_APPLY_STEAL_HP,
            item.APPLY_STEAL_SP : localeInfo.TOOLTIP_APPLY_STEAL_SP,
            item.APPLY_MANA_BURN_PCT : localeInfo.TOOLTIP_APPLY_MANA_BURN_PCT,
            item.APPLY_DAMAGE_SP_RECOVER : localeInfo.TOOLTIP_APPLY_DAMAGE_SP_RECOVER,
            item.APPLY_BLOCK : localeInfo.TOOLTIP_APPLY_BLOCK,
            item.APPLY_DODGE : localeInfo.TOOLTIP_APPLY_DODGE,
            item.APPLY_RESIST_SWORD : localeInfo.TOOLTIP_APPLY_RESIST_SWORD,
            item.APPLY_RESIST_TWOHAND : localeInfo.TOOLTIP_APPLY_RESIST_TWOHAND,
            item.APPLY_RESIST_DAGGER : localeInfo.TOOLTIP_APPLY_RESIST_DAGGER,
            item.APPLY_RESIST_BELL : localeInfo.TOOLTIP_APPLY_RESIST_BELL,
            item.APPLY_RESIST_FAN : localeInfo.TOOLTIP_APPLY_RESIST_FAN,
            item.APPLY_RESIST_BOW : localeInfo.TOOLTIP_RESIST_BOW,
            item.APPLY_RESIST_FIRE : localeInfo.TOOLTIP_RESIST_FIRE,
            item.APPLY_RESIST_ELEC : localeInfo.TOOLTIP_RESIST_ELEC,
            item.APPLY_RESIST_MAGIC : localeInfo.TOOLTIP_RESIST_MAGIC,
            item.APPLY_RESIST_WIND : localeInfo.TOOLTIP_APPLY_RESIST_WIND,
            item.APPLY_REFLECT_MELEE : localeInfo.TOOLTIP_APPLY_REFLECT_MELEE,
            item.APPLY_REFLECT_CURSE : localeInfo.TOOLTIP_APPLY_REFLECT_CURSE,
            item.APPLY_POISON_REDUCE : localeInfo.TOOLTIP_APPLY_POISON_REDUCE,
            item.APPLY_KILL_SP_RECOVER : localeInfo.TOOLTIP_APPLY_KILL_SP_RECOVER,
            item.APPLY_EXP_DOUBLE_BONUS : localeInfo.TOOLTIP_APPLY_EXP_DOUBLE_BONUS,
            item.APPLY_GOLD_DOUBLE_BONUS : localeInfo.TOOLTIP_APPLY_GOLD_DOUBLE_BONUS,
            item.APPLY_ITEM_DROP_BONUS : localeInfo.TOOLTIP_APPLY_ITEM_DROP_BONUS,
            item.APPLY_POTION_BONUS : localeInfo.TOOLTIP_APPLY_POTION_BONUS,
            item.APPLY_KILL_HP_RECOVER : localeInfo.TOOLTIP_APPLY_KILL_HP_RECOVER,
            item.APPLY_IMMUNE_STUN : localeInfo.TOOLTIP_APPLY_IMMUNE_STUN,
            item.APPLY_IMMUNE_SLOW : localeInfo.TOOLTIP_APPLY_IMMUNE_SLOW,
            item.APPLY_IMMUNE_FALL : localeInfo.TOOLTIP_APPLY_IMMUNE_FALL,
            item.APPLY_BOW_DISTANCE : localeInfo.TOOLTIP_BOW_DISTANCE,
            item.APPLY_DEF_GRADE_BONUS : localeInfo.TOOLTIP_DEF_GRADE,
            item.APPLY_ATT_GRADE_BONUS : localeInfo.TOOLTIP_ATT_GRADE,
            item.APPLY_MAGIC_ATT_GRADE : localeInfo.TOOLTIP_MAGIC_ATT_GRADE,
            item.APPLY_MAGIC_DEF_GRADE : localeInfo.TOOLTIP_MAGIC_DEF_GRADE,
            item.APPLY_MAX_STAMINA : localeInfo.TOOLTIP_MAX_STAMINA,
            item.APPLY_MALL_ATTBONUS : localeInfo.TOOLTIP_MALL_ATTBONUS,
            item.APPLY_MALL_DEFBONUS : localeInfo.TOOLTIP_MALL_DEFBONUS,
            item.APPLY_MALL_EXPBONUS : localeInfo.TOOLTIP_MALL_EXPBONUS,
            item.APPLY_MALL_ITEMBONUS : localeInfo.TOOLTIP_MALL_ITEMBONUS,
            item.APPLY_MALL_GOLDBONUS : localeInfo.TOOLTIP_MALL_GOLDBONUS,
            item.APPLY_SKILL_DAMAGE_BONUS : localeInfo.TOOLTIP_SKILL_DAMAGE_BONUS,
            item.APPLY_NORMAL_HIT_DAMAGE_BONUS : localeInfo.TOOLTIP_NORMAL_HIT_DAMAGE_BONUS,
            item.APPLY_SKILL_DEFEND_BONUS : localeInfo.TOOLTIP_SKILL_DEFEND_BONUS,
            item.APPLY_NORMAL_HIT_DEFEND_BONUS : localeInfo.TOOLTIP_NORMAL_HIT_DEFEND_BONUS,
            item.APPLY_PC_BANG_EXP_BONUS : localeInfo.TOOLTIP_MALL_EXPBONUS_P_STATIC,
            item.APPLY_PC_BANG_DROP_BONUS : localeInfo.TOOLTIP_MALL_ITEMBONUS_P_STATIC,
            item.APPLY_RESIST_WARRIOR : localeInfo.TOOLTIP_APPLY_RESIST_WARRIOR,
            item.APPLY_RESIST_ASSASSIN : localeInfo.TOOLTIP_APPLY_RESIST_ASSASSIN,
            item.APPLY_RESIST_SURA : localeInfo.TOOLTIP_APPLY_RESIST_SURA,
            item.APPLY_RESIST_SHAMAN : localeInfo.TOOLTIP_APPLY_RESIST_SHAMAN,
            item.APPLY_MAX_HP_PCT : localeInfo.TOOLTIP_APPLY_MAX_HP_PCT,
            item.APPLY_MAX_SP_PCT : localeInfo.TOOLTIP_APPLY_MAX_SP_PCT,
            item.APPLY_ENERGY : localeInfo.TOOLTIP_ENERGY,
            item.APPLY_COSTUME_ATTR_BONUS : localeInfo.TOOLTIP_COSTUME_ATTR_BONUS,
            
            item.APPLY_MAGIC_ATTBONUS_PER : localeInfo.TOOLTIP_MAGIC_ATTBONUS_PER,
            item.APPLY_MELEE_MAGIC_ATTBONUS_PER : localeInfo.TOOLTIP_MELEE_MAGIC_ATTBONUS_PER,
            item.APPLY_RESIST_ICE : localeInfo.TOOLTIP_RESIST_ICE,
            item.APPLY_RESIST_EARTH : localeInfo.TOOLTIP_RESIST_EARTH,
            item.APPLY_RESIST_DARK : localeInfo.TOOLTIP_RESIST_DARK,
            item.APPLY_ANTI_CRITICAL_PCT : localeInfo.TOOLTIP_ANTI_CRITICAL_PCT,
            item.APPLY_ANTI_PENETRATE_PCT : localeInfo.TOOLTIP_ANTI_PENETRATE_PCT,
        }

        ATTRIBUTE_NEED_WIDTH = {
            23 : 230,
            24 : 230,
            25 : 230,
            26 : 220,
            27 : 210,

            35 : 210,
            36 : 210,
            37 : 210,
            38 : 210,
            39 : 210,
            40 : 210,
            41 : 210,

            42 : 220,
            43 : 230,
            45 : 230,
        }

        ANTI_FLAG_DICT = {
            0 : item.ITEM_ANTIFLAG_WARRIOR,
            1 : item.ITEM_ANTIFLAG_ASSASSIN,
            2 : item.ITEM_ANTIFLAG_SURA,
            3 : item.ITEM_ANTIFLAG_SHAMAN,
        }

        FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)

        def __init__(self, *args, **kwargs):
            ToolTip.__init__(self, *args, **kwargs)
            self.itemVnum = 0
            self.isShopItem = False

            # ľĆŔĚĹŰ ĹřĆÁŔ» ÇĄ˝ĂÇŇ ¶§ ÇöŔç Äł¸ŻĹÍ°ˇ ÂřżëÇŇ Ľö ľř´Â ľĆŔĚĹŰŔ̶ó¸é °­Á¦·Î Disable Color·Î ĽłÁ¤ (ŔĚąĚ ±×·¸°Ô Ŕ۵żÇĎ°í ŔÖŔ¸łŞ ˛¨ľß ÇŇ ÇĘżä°ˇ Ŕ־)
            self.bCannotUseItemForceSetDisableColor = True 

        def __del__(self):
            ToolTip.__del__(self)

        def SetCannotUseItemForceSetDisableColor(self, enable):
            self.bCannotUseItemForceSetDisableColor = enable

        def CanEquip(self):
            if not item.IsEquipmentVID(self.itemVnum):
                return True

            race = player.GetRace()
            job = chr.RaceToJob(race)
            if not self.ANTI_FLAG_DICT.has_key(job):
                return False

            if item.IsAntiFlag(self.ANTI_FLAG_DICT[job]):
                return False

            sex = chr.RaceToSex(race)
            
            MALE = 1
            FEMALE = 0

            if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE) and sex == MALE:
                return False

            if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE) and sex == FEMALE:
                return False

            for i in xrange(item.LIMIT_MAX_NUM):
                (limitType, limitValue) = item.GetLimit(i)

                if item.LIMIT_LEVEL == limitType:
                    if player.GetStatus(player.LEVEL) < limitValue:
                        return False
                """
                elif item.LIMIT_STR == limitType:
                    if player.GetStatus(player.ST) < limitValue:
                        return False
                elif item.LIMIT_DEX == limitType:
                    if player.GetStatus(player.DX) < limitValue:
                        return False
                elif item.LIMIT_INT == limitType:
                    if player.GetStatus(player.IQ) < limitValue:
                        return False
                elif item.LIMIT_CON == limitType:
                    if player.GetStatus(player.HT) < limitValue:
                        return False
                """

            return True

        def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
            if not self.CanEquip() and self.bCannotUseItemForceSetDisableColor:
                color = self.DISABLE_COLOR

            return ToolTip.AppendTextLine(self, text, color, centerAlign)

        def ClearToolTip(self):
            self.isShopItem = False
            self.toolTipWidth = self.TOOL_TIP_WIDTH
            ToolTip.ClearToolTip(self)

        def SetInventoryItem(self, slotIndex, window_type = player.INVENTORY):
            itemVnum = player.GetItemIndex(window_type, slotIndex)
            if 0 == itemVnum:
                return

            self.ClearToolTip()
            if shop.IsOpen():
                if not shop.IsPrivateShop():
                    item.SelectItem(itemVnum)
                    self.AppendSellingPrice(player.GetISellItemPrice(window_type, slotIndex))

            metinSlot = [player.GetItemMetinSocket(window_type, slotIndex, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
            attrSlot = [player.GetItemAttribute(window_type, slotIndex, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]

            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def SetShopItem(self, slotIndex):
            itemVnum = shop.GetItemID(slotIndex)
            if 0 == itemVnum:
                return

            price = shop.GetItemPrice(slotIndex)
            self.ClearToolTip()
            self.isShopItem = True

            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(shop.GetItemMetinSocket(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(shop.GetItemAttribute(slotIndex, i))

            self.AddItemData(itemVnum, metinSlot, attrSlot)
            self.AppendPrice(price)

        def SetShopItemBySecondaryCoin(self, slotIndex):
            itemVnum = shop.GetItemID(slotIndex)
            if 0 == itemVnum:
                return

            price = shop.GetItemPrice(slotIndex)
            self.ClearToolTip()
            self.isShopItem = True

            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(shop.GetItemMetinSocket(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(shop.GetItemAttribute(slotIndex, i))

            self.AddItemData(itemVnum, metinSlot, attrSlot)
            self.AppendPriceBySecondaryCoin(price)

        def SetExchangeOwnerItem(self, slotIndex):
            itemVnum = exchange.GetItemVnumFromSelf(slotIndex)
            if 0 == itemVnum:
                return

            self.ClearToolTip()

            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(exchange.GetItemMetinSocketFromSelf(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(exchange.GetItemAttributeFromSelf(slotIndex, i))
            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def SetExchangeTargetItem(self, slotIndex):
            itemVnum = exchange.GetItemVnumFromTarget(slotIndex)
            if 0 == itemVnum:
                return

            self.ClearToolTip()

            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(exchange.GetItemMetinSocketFromTarget(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(exchange.GetItemAttributeFromTarget(slotIndex, i))
            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def SetPrivateShopBuilderItem(self, invenType, invenPos, privateShopSlotIndex):
            itemVnum = player.GetItemIndex(invenType, invenPos)
            if 0 == itemVnum:
                return

            item.SelectItem(itemVnum)
            self.ClearToolTip()
            self.AppendSellingPrice(shop.GetPrivateShopItemPrice(invenType, invenPos))

            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(player.GetItemMetinSocket(invenPos, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(player.GetItemAttribute(invenPos, i))

            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def SetSafeBoxItem(self, slotIndex):
            itemVnum = safebox.GetItemID(slotIndex)
            if 0 == itemVnum:
                return

            self.ClearToolTip()
            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(safebox.GetItemMetinSocket(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(safebox.GetItemAttribute(slotIndex, i))
            
            self.AddItemData(itemVnum, metinSlot, attrSlot, safebox.GetItemFlags(slotIndex))

        def SetMallItem(self, slotIndex):
            itemVnum = safebox.GetMallItemID(slotIndex)
            if 0 == itemVnum:
                return

            self.ClearToolTip()
            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(safebox.GetMallItemMetinSocket(slotIndex, i))
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append(safebox.GetMallItemAttribute(slotIndex, i))

            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def SetItemToolTip(self, itemVnum):
            self.ClearToolTip()
            metinSlot = []
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlot.append(0)
            attrSlot = []
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                attrSlot.append((0, 0))

            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def __AppendAttackSpeedInfo(self, item):
            atkSpd = item.GetValue(0)

            if atkSpd < 80:
                stSpd = localeInfo.TOOLTIP_ITEM_VERY_FAST
            elif atkSpd <= 95:
                stSpd = localeInfo.TOOLTIP_ITEM_FAST
            elif atkSpd <= 105:
                stSpd = localeInfo.TOOLTIP_ITEM_NORMAL
            elif atkSpd <= 120:
                stSpd = localeInfo.TOOLTIP_ITEM_SLOW
            else:
                stSpd = localeInfo.TOOLTIP_ITEM_VERY_SLOW

            self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_SPEED % stSpd, self.NORMAL_COLOR)

        def __AppendAttackGradeInfo(self):
            atkGrade = item.GetValue(1)
            self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_GRADE % atkGrade, self.GetChangeTextLineColor(atkGrade))

        def __AppendAttackPowerInfo(self):
            minPower = item.GetValue(3)
            maxPower = item.GetValue(4)
            addPower = item.GetValue(5)
            if maxPower > minPower:
                self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_POWER % (minPower+addPower, maxPower+addPower), self.POSITIVE_COLOR)
            else:
                self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_POWER_ONE_ARG % (minPower+addPower), self.POSITIVE_COLOR)

        def __AppendMagicAttackInfo(self):
            minMagicAttackPower = item.GetValue(1)
            maxMagicAttackPower = item.GetValue(2)
            addPower = item.GetValue(5)

            if minMagicAttackPower > 0 or maxMagicAttackPower > 0:
                if maxMagicAttackPower > minMagicAttackPower:
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_ATT_POWER % (minMagicAttackPower+addPower, maxMagicAttackPower+addPower), self.POSITIVE_COLOR)
                else:
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_ATT_POWER_ONE_ARG % (minMagicAttackPower+addPower), self.POSITIVE_COLOR)

        def __AppendMagicDefenceInfo(self):
            magicDefencePower = item.GetValue(0)

            if magicDefencePower > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_DEF_POWER % magicDefencePower, self.GetChangeTextLineColor(magicDefencePower))

        def __AppendAttributeInformation(self, attrSlot):
            if 0 != attrSlot:

                for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                    type = attrSlot[0]
                    value = attrSlot[1]

                    if 0 == value:
                        continue

                    affectString = self.__GetAffectString(type, value)
                    if affectString:
                        affectColor = self.__GetAttributeColor(i, value)
                        self.AppendTextLine(affectString, affectColor)

        def __GetAttributeColor(self, index, value):
            if value > 0:
                if index >= 5:
                    return self.SPECIAL_POSITIVE_COLOR2
                else:
                    return self.SPECIAL_POSITIVE_COLOR
            elif value == 0:
                return self.NORMAL_COLOR
            else:
                return self.NEGATIVE_COLOR

        def __IsPolymorphItem(self, itemVnum):
            if itemVnum >= 70103 and itemVnum <= 70106:
                return 1
            return 0

        def __SetPolymorphItemTitle(self, monsterVnum):
            if localeInfo.IsVIETNAM():
                itemName =item.GetItemName()
                itemName+=" "
                itemName+=nonplayer.GetMonsterName(monsterVnum)
            else:
                itemName =nonplayer.GetMonsterName(monsterVnum)
                itemName+=" "
                itemName+=item.GetItemName()
            self.SetTitle(itemName)

        def __SetNormalItemTitle(self):
            self.SetTitle(item.GetItemName())

        def __SetSpecialItemTitle(self):
            self.AppendTextLine(item.GetItemName(), self.SPECIAL_TITLE_COLOR)

        def __SetItemTitle(self, itemVnum, metinSlot, attrSlot):
            if localeInfo.IsCANADA():
                if 72726 == itemVnum or 72730 == itemVnum:
                    self.AppendTextLine(item.GetItemName(), grp.GenerateColor(1.0, 0.7843, 0.0, 1.0))
                    return
                
            if self.__IsPolymorphItem(itemVnum):
                self.__SetPolymorphItemTitle(metinSlot[0])
            else:
                if self.__IsAttr(attrSlot):
                    self.__SetSpecialItemTitle()
                    return

                self.__SetNormalItemTitle()

        def __IsAttr(self, attrSlot):
            if not attrSlot:
                return False

            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                type = attrSlot[0]
                if 0 != type:
                    return True

            return False
        
        def AddRefineItemData(self, itemVnum, metinSlot, attrSlot = 0):
            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlotData=metinSlot
                if self.GetMetinItemIndex(metinSlotData) == constInfo.ERROR_METIN_STONE:
                    metinSlot=player.METIN_SOCKET_TYPE_SILVER

            self.AddItemData(itemVnum, metinSlot, attrSlot)

        def AddItemData_Offline(self, itemVnum, itemDesc, itemSummary, metinSlot, attrSlot):
            self.__AdjustMaxWidth(attrSlot, itemDesc)
            self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
            
            if self.__IsHair(itemVnum):    
                self.__AppendHairIcon(itemVnum)

            ### Description ###
            self.AppendDescription(itemDesc, 26)
            self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)

        def AddItemData(self, itemVnum, metinSlot, attrSlot = 0, flags = 0, unbindTime = 0):
            self.itemVnum = itemVnum
            item.SelectItem(itemVnum)
            itemType = item.GetItemType()
            itemSubType = item.GetItemSubType()

            if 50026 == itemVnum:
                if 0 != metinSlot:
                    name = item.GetItemName()
                    if metinSlot[0] > 0:
                        name += " "
                        name += localeInfo.NumberToMoneyString(metinSlot[0])
                    self.SetTitle(name)

                    self.ShowToolTip()
                return

            ### Skill Book ###
            elif 50300 == itemVnum:
                if 0 != metinSlot:
                    self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILLBOOK_NAME, 1)

                    self.ShowToolTip()
                return 
            elif 70037 == itemVnum:
                if 0 != metinSlot:
                    self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
                    self.AppendDescription(item.GetItemDescription(), 26)
                    self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)

                    self.ShowToolTip()
                return
            elif 70055 == itemVnum:
                if 0 != metinSlot:
                    self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
                    self.AppendDescription(item.GetItemDescription(), 26)
                    self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)

                    self.ShowToolTip()
                return
            ###########################################################################################


            itemDesc = item.GetItemDescription()
            itemSummary = item.GetItemSummary()

            isCostumeItem = 0
            isCostumeHair = 0
            isCostumeBody = 0
                
            if app.ENABLE_COSTUME_SYSTEM:
                if item.ITEM_TYPE_COSTUME == itemType:
                    isCostumeItem = 1
                    isCostumeHair = item.COSTUME_TYPE_HAIR == itemSubType
                    isCostumeBody = item.COSTUME_TYPE_BODY == itemSubType
                    
                    #dbg.TraceError("IS_COSTUME_ITEM! body(%d) hair(%d)" % (isCostumeBody, isCostumeHair))

            self.__AdjustMaxWidth(attrSlot, itemDesc)
            self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
            
            ### Hair Preview Image ###
            if self.__IsHair(itemVnum):    
                self.__AppendHairIcon(itemVnum)

            ### Description ###
            self.AppendDescription(itemDesc, 26)
            self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)

            ### Weapon ###
            if item.ITEM_TYPE_WEAPON == itemType:

                self.__AppendLimitInformation()

                self.AppendSpace(5)

                ## şÎäŔĎ °ćżě ¸¶°řŔ» ¸ŐŔú ÇĄ˝ĂÇŃ´Ů.
                if item.WEAPON_FAN == itemSubType:
                    self.__AppendMagicAttackInfo()
                    self.__AppendAttackPowerInfo()

                else:
                    self.__AppendAttackPowerInfo()
                    self.__AppendMagicAttackInfo()

                self.__AppendAffectInformation()
                self.__AppendAttributeInformation(attrSlot)

                self.AppendWearableInformation()
                self.__AppendMetinSlotInfo(metinSlot)

            ### Armor ###
            elif item.ITEM_TYPE_ARMOR == itemType:
                self.__AppendLimitInformation()

                ## ąćľî·Â
                defGrade = item.GetValue(1)
                defBonus = item.GetValue(5)*2 ## ąćľî·Â ÇĄ˝Ă Ŕ߸ř µÇ´Â ą®Á¦¸¦ ĽöÁ¤
                if defGrade > 0:
                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade+defBonus), self.GetChangeTextLineColor(defGrade))

                self.__AppendMagicDefenceInfo()
                self.__AppendAffectInformation()
                self.__AppendAttributeInformation(attrSlot)

                self.AppendWearableInformation()

                if itemSubType in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):                
                    self.__AppendAccessoryMetinSlotInfo(metinSlot, constInfo.GET_ACCESSORY_MATERIAL_VNUM(itemVnum, itemSubType))
                else:
                    self.__AppendMetinSlotInfo(metinSlot)

            ### Ring Slot Item (Not UNIQUE) ###
            elif item.ITEM_TYPE_RING == itemType:
                self.__AppendLimitInformation()
                self.__AppendAffectInformation()
                self.__AppendAttributeInformation(attrSlot)

                #ąÝÁö ĽŇÄĎ ˝Ă˝şĹŰ °ü·ĂÇŘĽ± ľĆÁ÷ ±âČą ąĚÁ¤
                #self.__AppendAccessoryMetinSlotInfo(metinSlot, 99001)
                

            ### Belt Item ###
            elif item.ITEM_TYPE_BELT == itemType:
                self.__AppendLimitInformation()
                self.__AppendAffectInformation()
                self.__AppendAttributeInformation(attrSlot)

                self.__AppendAccessoryMetinSlotInfo(metinSlot, constInfo.GET_BELT_MATERIAL_VNUM(itemVnum))

            ## ÄÚ˝şĂő ľĆŔĚĹŰ ##
            elif 0 != isCostumeItem:
                self.__AppendLimitInformation()
                self.__AppendAffectInformation()
                self.__AppendAttributeInformation(attrSlot)

                self.AppendWearableInformation()
            
                bHasRealtimeFlag = 0
                
                ## »çżë°ˇ´É ˝Ă°Ł Á¦ÇŃŔĚ ŔÖ´ÂÁö ĂŁľĆş¸°í
                for i in xrange(item.LIMIT_MAX_NUM):
                    (limitType, limitValue) = item.GetLimit(i)

                    if item.LIMIT_REAL_TIME == limitType:
                        bHasRealtimeFlag = 1
                
                ## ŔÖ´Ů¸é °ü·Ă Á¤ş¸¸¦ ÇĄ˝ĂÇÔ. ex) ł˛Ŕş ˝Ă°Ł : 6ŔĎ 6˝Ă°Ł 58şĐ 
                if 1 == bHasRealtimeFlag:
                    self.AppendMallItemLastTime(metinSlot[0])
                    #dbg.TraceError("1) REAL_TIME flag On ")
                    
            ## Rod ##
            elif item.ITEM_TYPE_ROD == itemType:

                if 0 != metinSlot:
                    curLevel = item.GetValue(0) / 10
                    curEXP = metinSlot[0]
                    maxEXP = item.GetValue(2)
                    self.__AppendLimitInformation()
                    self.__AppendRodInformation(curLevel, curEXP, maxEXP)

            ## Pick ##
            elif item.ITEM_TYPE_PICK == itemType:

                if 0 != metinSlot:
                    curLevel = item.GetValue(0) / 10
                    curEXP = metinSlot[0]
                    maxEXP = item.GetValue(2)
                    self.__AppendLimitInformation()
                    self.__AppendPickInformation(curLevel, curEXP, maxEXP)

            ## Lottery ##
            elif item.ITEM_TYPE_LOTTERY == itemType:
                if 0 != metinSlot:

                    ticketNumber = int(metinSlot[0])
                    stepNumber = int(metinSlot[1])

                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_LOTTERY_STEP_NUMBER % (stepNumber), self.NORMAL_COLOR)
                    self.AppendTextLine(localeInfo.TOOLTIP_LOTTO_NUMBER % (ticketNumber), self.NORMAL_COLOR);

            ### Metin ###
            elif item.ITEM_TYPE_METIN == itemType:
                self.AppendMetinInformation()
                self.AppendMetinWearInformation()

            ### Fish ###
            elif item.ITEM_TYPE_FISH == itemType:
                if 0 != metinSlot:
                    self.__AppendFishInfo(metinSlot[0])
            
            ## item.ITEM_TYPE_BLEND
            elif item.ITEM_TYPE_BLEND == itemType:
                self.__AppendLimitInformation()

                if metinSlot:
                    affectType = metinSlot[0]
                    affectValue = metinSlot[1]
                    time = metinSlot[2]
                    self.AppendSpace(5)
                    affectText = self.__GetAffectString(affectType, affectValue)

                    self.AppendTextLine(affectText, self.NORMAL_COLOR)

                    if time > 0:
                        minute = (time / 60)
                        second = (time % 60)
                        timeString = localeInfo.TOOLTIP_POTION_TIME

                        if minute > 0:
                            timeString += str(minute) + localeInfo.TOOLTIP_POTION_MIN
                        if second > 0:
                            timeString += " " + str(second) + localeInfo.TOOLTIP_POTION_SEC

                        self.AppendTextLine(timeString)
                    else:
                        self.AppendTextLine(localeInfo.BLEND_POTION_NO_TIME)
                else:
                    self.AppendTextLine("BLEND_POTION_NO_INFO")

            elif item.ITEM_TYPE_UNIQUE == itemType:
                if 0 != metinSlot:
                    bHasRealtimeFlag = 0
                    
                    for i in xrange(item.LIMIT_MAX_NUM):
                        (limitType, limitValue) = item.GetLimit(i)

                        if item.LIMIT_REAL_TIME == limitType:
                            bHasRealtimeFlag = 1
                    
                    if 1 == bHasRealtimeFlag:
                        self.AppendMallItemLastTime(metinSlot[0])        
                    else:
                        time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]

                        if 1 == item.GetValue(2): ## ˝Ç˝Ă°Ł ŔĚżë Flag / ŔĺÂř ľČÇصµ ÁŘ´Ů
                            self.AppendMallItemLastTime(time)
                        else:
                            self.AppendUniqueItemLastTime(time)

            ### Use ###
            elif item.ITEM_TYPE_USE == itemType:
                self.__AppendLimitInformation()

                if item.USE_POTION == itemSubType or item.USE_POTION_NODELAY == itemSubType:
                    self.__AppendPotionInformation()

                elif item.USE_ABILITY_UP == itemSubType:
                    self.__AppendAbilityPotionInformation()


                ## żµĽ® °¨Áö±â
                if 27989 == itemVnum or 76006 == itemVnum:
                    if 0 != metinSlot:
                        useCount = int(metinSlot[0])

                        self.AppendSpace(5)
                        self.AppendTextLine(localeInfo.TOOLTIP_REST_USABLE_COUNT % (6 - useCount), self.NORMAL_COLOR)

                ## ŔĚşĄĆ® °¨Áö±â
                elif 50004 == itemVnum:
                    if 0 != metinSlot:
                        useCount = int(metinSlot[0])

                        self.AppendSpace(5)
                        self.AppendTextLine(localeInfo.TOOLTIP_REST_USABLE_COUNT % (10 - useCount), self.NORMAL_COLOR)

                ## ŔÚµżą°ľŕ
                elif constInfo.IS_AUTO_POTION(itemVnum):
                    if 0 != metinSlot:
                        ## 0: Č°ĽşČ­, 1: »çżë·®, 2: ĂŃ·®
                        isActivated = int(metinSlot[0])
                        usedAmount = float(metinSlot[1])
                        totalAmount = float(metinSlot[2])
                        
                        if 0 == totalAmount:
                            totalAmount = 1
                        
                        self.AppendSpace(5)

                        if 0 != isActivated:
                            self.AppendTextLine("(%s)" % (localeInfo.TOOLTIP_AUTO_POTION_USING), self.SPECIAL_POSITIVE_COLOR)
                            self.AppendSpace(5)
                            
                        self.AppendTextLine(localeInfo.TOOLTIP_AUTO_POTION_REST % (100.0 - ((usedAmount / totalAmount) * 100.0)), self.POSITIVE_COLOR)
                                    
                ## ±ÍČŻ ±âľďşÎ
                elif itemVnum in WARP_SCROLLS:
                    if 0 != metinSlot:
                        xPos = int(metinSlot[0])
                        yPos = int(metinSlot[1])

                        if xPos != 0 and yPos != 0:
                            (mapName, xBase, yBase) = background.GlobalPositionToMapInfo(xPos, yPos)
                            
                            localeMapName=localeInfo.MINIMAP_ZONE_NAME_DICT.get(mapName, "")

                            self.AppendSpace(5)

                            if localeMapName!="":                        
                                self.AppendTextLine(localeInfo.TOOLTIP_MEMORIZED_POSITION % (localeMapName, int(xPos-xBase)/100, int(yPos-yBase)/100), self.NORMAL_COLOR)
                            else:
                                self.AppendTextLine(localeInfo.TOOLTIP_MEMORIZED_POSITION_ERROR % (int(xPos)/100, int(yPos)/100), self.NORMAL_COLOR)
                                dbg.TraceError("NOT_EXIST_IN_MINIMAP_ZONE_NAME_DICT: %s" % mapName)

                #####
                if item.USE_SPECIAL == itemSubType:
                    bHasRealtimeFlag = 0
                    for i in xrange(item.LIMIT_MAX_NUM):
                        (limitType, limitValue) = item.GetLimit(i)

                        if item.LIMIT_REAL_TIME == limitType:
                            bHasRealtimeFlag = 1
            
                    ## ŔÖ´Ů¸é °ü·Ă Á¤ş¸¸¦ ÇĄ˝ĂÇÔ. ex) ł˛Ŕş ˝Ă°Ł : 6ŔĎ 6˝Ă°Ł 58şĐ 
                    if 1 == bHasRealtimeFlag:
                        self.AppendMallItemLastTime(metinSlot[0])
                    else:
                        # ... ŔĚ°Ĺ... Ľ­ąöżˇ´Â ŔĚ·± ˝Ă°Ł ĂĽĹ© ľČµÇľî ŔִµĄ...
                        # żÖ ŔĚ·±°Ô ŔÖ´ÂÁö ľËÁö´Â ¸řÇĎłŞ ±×łÉ µÎŔÚ...
                        if 0 != metinSlot:
                            time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]

                            ## ˝Ç˝Ă°Ł ŔĚżë Flag
                            if 1 == item.GetValue(2):
                                self.AppendMallItemLastTime(time)
                
                elif item.USE_TIME_CHARGE_PER == itemSubType:
                    bHasRealtimeFlag = 0
                    for i in xrange(item.LIMIT_MAX_NUM):
                        (limitType, limitValue) = item.GetLimit(i)

                        if item.LIMIT_REAL_TIME == limitType:
                            bHasRealtimeFlag = 1
                    if metinSlot[2]:
                        self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(metinSlot[2]))
                    else:
                        self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(item.GetValue(0)))
             
                    ## ŔÖ´Ů¸é °ü·Ă Á¤ş¸¸¦ ÇĄ˝ĂÇÔ. ex) ł˛Ŕş ˝Ă°Ł : 6ŔĎ 6˝Ă°Ł 58şĐ 
                    if 1 == bHasRealtimeFlag:
                        self.AppendMallItemLastTime(metinSlot[0])

                elif item.USE_TIME_CHARGE_FIX == itemSubType:
                    bHasRealtimeFlag = 0
                    for i in xrange(item.LIMIT_MAX_NUM):
                        (limitType, limitValue) = item.GetLimit(i)

                        if item.LIMIT_REAL_TIME == limitType:
                            bHasRealtimeFlag = 1
                    if metinSlot[2]:
                        self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(metinSlot[2]))
                    else:
                        self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(item.GetValue(0)))
            
                    ## ŔÖ´Ů¸é °ü·Ă Á¤ş¸¸¦ ÇĄ˝ĂÇÔ. ex) ł˛Ŕş ˝Ă°Ł : 6ŔĎ 6˝Ă°Ł 58şĐ 
                    if 1 == bHasRealtimeFlag:
                        self.AppendMallItemLastTime(metinSlot[0])

            elif item.ITEM_TYPE_QUEST == itemType:
                for i in xrange(item.LIMIT_MAX_NUM):
                    (limitType, limitValue) = item.GetLimit(i)

                    if item.LIMIT_REAL_TIME == limitType:
                        self.AppendMallItemLastTime(metinSlot[0])
            elif item.ITEM_TYPE_DS == itemType:
                self.AppendTextLine(self.__DragonSoulInfoString(itemVnum))
                self.__AppendAttributeInformation(attrSlot)
            else:
                self.__AppendLimitInformation()

            for i in xrange(item.LIMIT_MAX_NUM):
                (limitType, limitValue) = item.GetLimit(i)
                #dbg.TraceError("LimitType : %d, limitValue : %d" % (limitType, limitValue))
                
                if item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
                    self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)
                    #dbg.TraceError("2) REAL_TIME_START_FIRST_USE flag On ")
                    
                elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
                    self.AppendTimerBasedOnWearLastTime(metinSlot)
                    #dbg.TraceError("1) REAL_TIME flag On ")


                    
            self.ShowToolTip()

        def __DragonSoulInfoString (self, dwVnum):
            step = (dwVnum / 100) % 10
            refine = (dwVnum / 10) % 10
            if 0 == step:
                return localeInfo.DRAGON_SOUL_STEP_LEVEL1 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
            elif 1 == step:
                return localeInfo.DRAGON_SOUL_STEP_LEVEL2 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
            elif 2 == step:
                return localeInfo.DRAGON_SOUL_STEP_LEVEL3 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
            elif 3 == step:
                return localeInfo.DRAGON_SOUL_STEP_LEVEL4 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
            elif 4 == step:
                return localeInfo.DRAGON_SOUL_STEP_LEVEL5 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
            else:
                return ""


        ## ÇěľîŔΰˇ?
        def __IsHair(self, itemVnum):
            return (self.__IsOldHair(itemVnum) or 
                self.__IsNewHair(itemVnum) or
                self.__IsNewHair2(itemVnum) or
                self.__IsNewHair3(itemVnum) or
                self.__IsCostumeHair(itemVnum)
                )

        def __IsOldHair(self, itemVnum):
            return itemVnum > 73000 and itemVnum < 74000    

        def __IsNewHair(self, itemVnum):
            return itemVnum > 74000 and itemVnum < 75000    

        def __IsNewHair2(self, itemVnum):
            return itemVnum > 75000 and itemVnum < 76000    

        def __IsNewHair3(self, itemVnum):
            return ((74012 < itemVnum and itemVnum < 74022) or
                (74262 < itemVnum and itemVnum < 74272) or
                (74512 < itemVnum and itemVnum < 74522) or
                (74762 < itemVnum and itemVnum < 74772) or
                (45000 < itemVnum and itemVnum < 47000))

        def __IsCostumeHair(self, itemVnum):
            return app.ENABLE_COSTUME_SYSTEM and self.__IsNewHair3(itemVnum - 100000)
            
        def __AppendHairIcon(self, itemVnum):
            itemImage = ui.ImageBox()
            itemImage.SetParent(self)
            itemImage.Show()            

            if self.__IsOldHair(itemVnum):
                itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum)+".tga")
            elif self.__IsNewHair3(itemVnum):
                itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
            elif self.__IsNewHair(itemVnum): # ±âÁ¸ Çěľî ąřČŁ¸¦ ż¬°á˝ĂÄŃĽ­ »çżëÇŃ´Ů. »ő·Îżî ľĆŔĚĹŰŔş 1000¸¸Ĺ­ ąřČŁ°ˇ ´Ăľú´Ů.
                itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum-1000)+".tga")
            elif self.__IsNewHair2(itemVnum):
                itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
            elif self.__IsCostumeHair(itemVnum):
                itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum - 100000))

            itemImage.SetPosition(itemImage.GetWidth()/2, self.toolTipHeight)
            self.toolTipHeight += itemImage.GetHeight()
            #self.toolTipWidth += itemImage.GetWidth()/2
            self.childrenList.append(itemImage)
            self.ResizeToolTip()

        ## »çŔĚÁî°ˇ Ĺ« Description ŔĎ °ćżě ĹřĆÁ »çŔĚÁ Á¶Á¤ÇŃ´Ů
        def __AdjustMaxWidth(self, attrSlot, desc):
            newToolTipWidth = self.toolTipWidth
            newToolTipWidth = max(self.__AdjustAttrMaxWidth(attrSlot), newToolTipWidth)
            newToolTipWidth = max(self.__AdjustDescMaxWidth(desc), newToolTipWidth)
            if newToolTipWidth > self.toolTipWidth:
                self.toolTipWidth = newToolTipWidth
                self.ResizeToolTip()

        def __AdjustAttrMaxWidth(self, attrSlot):
            if 0 == attrSlot:
                return self.toolTipWidth

            maxWidth = self.toolTipWidth
            for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
                type = attrSlot[0]
                value = attrSlot[1]
                if self.ATTRIBUTE_NEED_WIDTH.has_key(type):
                    if value > 0:
                        maxWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], maxWidth)

                        # ATTR_CHANGE_TOOLTIP_WIDTH
                        #self.toolTipWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], self.toolTipWidth)
                        #self.ResizeToolTip()
                        # END_OF_ATTR_CHANGE_TOOLTIP_WIDTH

            return maxWidth

        def __AdjustDescMaxWidth(self, desc):
            if len(desc) < DESC_DEFAULT_MAX_COLS:
                return self.toolTipWidth
        
            return DESC_WESTERN_MAX_WIDTH

        def __SetSkillBookToolTip(self, skillIndex, bookName, skillGrade):
            skillName = skill.GetSkillName(skillIndex)

            if not skillName:
                return

            if localeInfo.IsVIETNAM():
                itemName = bookName + " " + skillName
            else:
                itemName = skillName + " " + bookName
            self.SetTitle(itemName)

        def __AppendPickInformation(self, curLevel, curEXP, maxEXP):
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_PICK_LEVEL % (curLevel), self.NORMAL_COLOR)
            self.AppendTextLine(localeInfo.TOOLTIP_PICK_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)

            if curEXP == maxEXP:
                self.AppendSpace(5)
                self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE1, self.NORMAL_COLOR)
                self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE2, self.NORMAL_COLOR)
                self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE3, self.NORMAL_COLOR)


        def __AppendRodInformation(self, curLevel, curEXP, maxEXP):
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_LEVEL % (curLevel), self.NORMAL_COLOR)
            self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)

            if curEXP == maxEXP:
                self.AppendSpace(5)
                self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE1, self.NORMAL_COLOR)
                self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE2, self.NORMAL_COLOR)
                self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE3, self.NORMAL_COLOR)

        def __AppendLimitInformation(self):

            appendSpace = False

            for i in xrange(item.LIMIT_MAX_NUM):

                (limitType, limitValue) = item.GetLimit(i)

                if limitValue > 0:
                    if False == appendSpace:
                        self.AppendSpace(5)
                        appendSpace = True

                else:
                    continue

                if item.LIMIT_LEVEL == limitType:
                    color = self.GetLimitTextLineColor(player.GetStatus(player.LEVEL), limitValue)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_LEVEL % (limitValue), color)
                """
                elif item.LIMIT_STR == limitType:
                    color = self.GetLimitTextLineColor(player.GetStatus(player.ST), limitValue)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_STR % (limitValue), color)
                elif item.LIMIT_DEX == limitType:
                    color = self.GetLimitTextLineColor(player.GetStatus(player.DX), limitValue)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_DEX % (limitValue), color)
                elif item.LIMIT_INT == limitType:
                    color = self.GetLimitTextLineColor(player.GetStatus(player.IQ), limitValue)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_INT % (limitValue), color)
                elif item.LIMIT_CON == limitType:
                    color = self.GetLimitTextLineColor(player.GetStatus(player.HT), limitValue)
                    self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_CON % (limitValue), color)
                """

     

     

     

     

     


        def __GetAffectString(self, affectType, affectValue):
            if 0 == affectType:
                return None

            if 0 == affectValue:
                return None

            try:
                return self.AFFECT_DICT[affectType](affectValue)
            except TypeError:
                return "UNKNOWN_VALUE[%s] %s" % (affectType, affectValue)
            except KeyError:
                return "UNKNOWN_TYPE[%s] %s" % (affectType, affectValue)

        def __AppendAffectInformation(self):
            for i in xrange(item.ITEM_APPLY_MAX_NUM):

                (affectType, affectValue) = item.GetAffect(i)

                affectString = self.__GetAffectString(affectType, affectValue)
                if affectString:
                    self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

        def AppendWearableInformation(self):

            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)

            flagList = (
                not item.IsAntiFlag(item.ITEM_ANTIFLAG_WARRIOR),
                not item.IsAntiFlag(item.ITEM_ANTIFLAG_ASSASSIN),
                not item.IsAntiFlag(item.ITEM_ANTIFLAG_SURA),
                not item.IsAntiFlag(item.ITEM_ANTIFLAG_SHAMAN))

            characterNames = ""
            for i in xrange(self.CHARACTER_COUNT):

                name = self.CHARACTER_NAMES
                flag = flagList

                if flag:
                    characterNames += " "
                    characterNames += name

            textLine = self.AppendTextLine(characterNames, self.NORMAL_COLOR, True)
            textLine.SetFeather()

            if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE):
                textLine = self.AppendTextLine(localeInfo.FOR_FEMALE, self.NORMAL_COLOR, True)
                textLine.SetFeather()

            if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE):
                textLine = self.AppendTextLine(localeInfo.FOR_MALE, self.NORMAL_COLOR, True)
                textLine.SetFeather()

        def __AppendPotionInformation(self):
            self.AppendSpace(5)

            healHP = item.GetValue(0)
            healSP = item.GetValue(1)
            healStatus = item.GetValue(2)
            healPercentageHP = item.GetValue(3)
            healPercentageSP = item.GetValue(4)

            if healHP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_HP_POINT % healHP, self.GetChangeTextLineColor(healHP))
            if healSP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_SP_POINT % healSP, self.GetChangeTextLineColor(healSP))
            if healStatus != 0:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_CURE)
            if healPercentageHP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_HP_PERCENT % healPercentageHP, self.GetChangeTextLineColor(healPercentageHP))
            if healPercentageSP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_SP_PERCENT % healPercentageSP, self.GetChangeTextLineColor(healPercentageSP))

        def __AppendAbilityPotionInformation(self):

            self.AppendSpace(5)

            abilityType = item.GetValue(0)
            time = item.GetValue(1)
            point = item.GetValue(2)

            if abilityType == item.APPLY_ATT_SPEED:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_ATTACK_SPEED % point, self.GetChangeTextLineColor(point))
            elif abilityType == item.APPLY_MOV_SPEED:
                self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_MOVING_SPEED % point, self.GetChangeTextLineColor(point))

            if time > 0:
                minute = (time / 60)
                second = (time % 60)
                timeString = localeInfo.TOOLTIP_POTION_TIME

                if minute > 0:
                    timeString += str(minute) + localeInfo.TOOLTIP_POTION_MIN
                if second > 0:
                    timeString += " " + str(second) + localeInfo.TOOLTIP_POTION_SEC

                self.AppendTextLine(timeString)

        def GetPriceColor(self, price):
            if price>=constInfo.HIGH_PRICE:
                return self.HIGH_PRICE_COLOR
            if price>=constInfo.MIDDLE_PRICE:
                return self.MIDDLE_PRICE_COLOR
            else:
                return self.LOW_PRICE_COLOR
                            
        def AppendPrice(self, price):    
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_BUYPRICE  % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
            
        def AppendPriceBySecondaryCoin(self, price):
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_BUYPRICE  % (localeInfo.NumberToSecondaryCoinString(price)), self.GetPriceColor(price))

        def AppendSellingPrice(self, price):
            if item.IsAntiFlag(item.ITEM_ANTIFLAG_SELL):            
                self.AppendTextLine(localeInfo.TOOLTIP_ANTI_SELL, self.DISABLE_COLOR)
                self.AppendSpace(5)
            else:
                self.AppendTextLine(localeInfo.TOOLTIP_SELLPRICE % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
                self.AppendSpace(5)

        def AppendMetinInformation(self):
            affectType, affectValue = item.GetAffect(0)
            #affectType = item.GetValue(0)
            #affectValue = item.GetValue(1)

            affectString = self.__GetAffectString(affectType, affectValue)

            if affectString:
                self.AppendSpace(5)
                self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

        def AppendMetinWearInformation(self):

            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_SOCKET_REFINABLE_ITEM, self.NORMAL_COLOR)

            flagList = (item.IsWearableFlag(item.WEARABLE_BODY),
                        item.IsWearableFlag(item.WEARABLE_HEAD),
                        item.IsWearableFlag(item.WEARABLE_FOOTS),
                        item.IsWearableFlag(item.WEARABLE_WRIST),
                        item.IsWearableFlag(item.WEARABLE_WEAPON),
                        item.IsWearableFlag(item.WEARABLE_NECK),
                        item.IsWearableFlag(item.WEARABLE_EAR),
                        item.IsWearableFlag(item.WEARABLE_UNIQUE),
                        item.IsWearableFlag(item.WEARABLE_SHIELD),
                        item.IsWearableFlag(item.WEARABLE_ARROW))

            wearNames = ""
            for i in xrange(self.WEAR_COUNT):

                name = self.WEAR_NAMES
                flag = flagList

                if flag:
                    wearNames += "  "
                    wearNames += name

            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetFontName(self.defFontName)
            textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
            textLine.SetHorizontalAlignCenter()
            textLine.SetPackedFontColor(self.NORMAL_COLOR)
            textLine.SetText(wearNames)
            textLine.Show()
            self.childrenList.append(textLine)

            self.toolTipHeight += self.TEXT_LINE_HEIGHT
            self.ResizeToolTip()

        def GetMetinSocketType(self, number):
            if player.METIN_SOCKET_TYPE_NONE == number:
                return player.METIN_SOCKET_TYPE_NONE
            elif player.METIN_SOCKET_TYPE_SILVER == number:
                return player.METIN_SOCKET_TYPE_SILVER
            elif player.METIN_SOCKET_TYPE_GOLD == number:
                return player.METIN_SOCKET_TYPE_GOLD
            else:
                item.SelectItem(number)
                if item.METIN_NORMAL == item.GetItemSubType():
                    return player.METIN_SOCKET_TYPE_SILVER
                elif item.METIN_GOLD == item.GetItemSubType():
                    return player.METIN_SOCKET_TYPE_GOLD
                elif "USE_PUT_INTO_ACCESSORY_SOCKET" == item.GetUseType(number):
                    return player.METIN_SOCKET_TYPE_SILVER
                elif "USE_PUT_INTO_RING_SOCKET" == item.GetUseType(number):
                    return player.METIN_SOCKET_TYPE_SILVER
                elif "USE_PUT_INTO_BELT_SOCKET" == item.GetUseType(number):
                    return player.METIN_SOCKET_TYPE_SILVER

            return player.METIN_SOCKET_TYPE_NONE

        def GetMetinItemIndex(self, number):
            if player.METIN_SOCKET_TYPE_SILVER == number:
                return 0
            if player.METIN_SOCKET_TYPE_GOLD == number:
                return 0

            return number

        def __AppendAccessoryMetinSlotInfo(self, metinSlot, mtrlVnum):        
            ACCESSORY_SOCKET_MAX_SIZE = 3        

            cur=min(metinSlot[0], ACCESSORY_SOCKET_MAX_SIZE)
            end=min(metinSlot[1], ACCESSORY_SOCKET_MAX_SIZE)

            affectType1, affectValue1 = item.GetAffect(0)
            affectList1=[0, max(1, affectValue1*10/100), max(2, affectValue1*20/100), max(3, affectValue1*40/100)]

            affectType2, affectValue2 = item.GetAffect(1)
            affectList2=[0, max(1, affectValue2*10/100), max(2, affectValue2*20/100), max(3, affectValue2*40/100)]

            mtrlPos=0
            mtrlList=[mtrlVnum]*cur+[player.METIN_SOCKET_TYPE_SILVER]*(end-cur)
            for mtrl in mtrlList:
                affectString1 = self.__GetAffectString(affectType1, affectList1[mtrlPos+1]-affectList1[mtrlPos])            
                affectString2 = self.__GetAffectString(affectType2, affectList2[mtrlPos+1]-affectList2[mtrlPos])

                leftTime = 0
                if cur == mtrlPos+1:
                    leftTime=metinSlot[2]

                self.__AppendMetinSlotInfo_AppendMetinSocketData(mtrlPos, mtrl, affectString1, affectString2, leftTime)
                mtrlPos+=1

        def __AppendMetinSlotInfo(self, metinSlot):
            if self.__AppendMetinSlotInfo_IsEmptySlotList(metinSlot):
                return

            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                self.__AppendMetinSlotInfo_AppendMetinSocketData(i, metinSlot)

        def __AppendMetinSlotInfo_IsEmptySlotList(self, metinSlot):
            if 0 == metinSlot:
                return 1

            for i in xrange(player.METIN_SOCKET_MAX_NUM):
                metinSlotData=metinSlot
                if 0 != self.GetMetinSocketType(metinSlotData):
                    if 0 != self.GetMetinItemIndex(metinSlotData):
                        return 0

            return 1

        def __AppendMetinSlotInfo_AppendMetinSocketData(self, index, metinSlotData, custumAffectString="", custumAffectString2="", leftTime=0):

            slotType = self.GetMetinSocketType(metinSlotData)
            itemIndex = self.GetMetinItemIndex(metinSlotData)

            if 0 == slotType:
                return

            self.AppendSpace(5)

            slotImage = ui.ImageBox()
            slotImage.SetParent(self)
            slotImage.Show()

            ## Name
            nameTextLine = ui.TextLine()
            nameTextLine.SetParent(self)
            nameTextLine.SetFontName(self.defFontName)
            nameTextLine.SetPackedFontColor(self.NORMAL_COLOR)
            nameTextLine.SetOutline()
            nameTextLine.SetFeather()
            nameTextLine.Show()            

            self.childrenList.append(nameTextLine)

            if player.METIN_SOCKET_TYPE_SILVER == slotType:
                slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_silver.sub")
            elif player.METIN_SOCKET_TYPE_GOLD == slotType:
                slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_gold.sub")

            self.childrenList.append(slotImage)
            
            if localeInfo.IsARABIC():
                slotImage.SetPosition(self.toolTipWidth - slotImage.GetWidth() - 9, self.toolTipHeight-1)
                nameTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 2)
            else:
                slotImage.SetPosition(9, self.toolTipHeight-1)
                nameTextLine.SetPosition(50, self.toolTipHeight + 2)

            metinImage = ui.ImageBox()
            metinImage.SetParent(self)
            metinImage.Show()
            self.childrenList.append(metinImage)

            if itemIndex:

                item.SelectItem(itemIndex)

                ## Image
                try:
                    metinImage.LoadImage(item.GetIconImageFileName())
                except:
                    dbg.TraceError("ItemToolTip.__AppendMetinSocketData() - Failed to find image file %d:%s" % 
                        (itemIndex, item.GetIconImageFileName())
                    )

                nameTextLine.SetText(item.GetItemName())
                
                ## Affect        
                affectTextLine = ui.TextLine()
                affectTextLine.SetParent(self)
                affectTextLine.SetFontName(self.defFontName)
                affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
                affectTextLine.SetOutline()
                affectTextLine.SetFeather()
                affectTextLine.Show()            
                    
                if localeInfo.IsARABIC():
                    metinImage.SetPosition(self.toolTipWidth - metinImage.GetWidth() - 10, self.toolTipHeight)
                    affectTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 16 + 2)
                else:
                    metinImage.SetPosition(10, self.toolTipHeight)
                    affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2)
                                
                if custumAffectString:
                    affectTextLine.SetText(custumAffectString)
                elif itemIndex!=constInfo.ERROR_METIN_STONE:
                    affectType, affectValue = item.GetAffect(0)
                    affectString = self.__GetAffectString(affectType, affectValue)
                    if affectString:
                        affectTextLine.SetText(affectString)
                else:
                    affectTextLine.SetText(localeInfo.TOOLTIP_APPLY_NOAFFECT)
                
                self.childrenList.append(affectTextLine)            

                if custumAffectString2:
                    affectTextLine = ui.TextLine()
                    affectTextLine.SetParent(self)
                    affectTextLine.SetFontName(self.defFontName)
                    affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
                    affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
                    affectTextLine.SetOutline()
                    affectTextLine.SetFeather()
                    affectTextLine.Show()
                    affectTextLine.SetText(custumAffectString2)
                    self.childrenList.append(affectTextLine)
                    self.toolTipHeight += 16 + 2

                if 0 != leftTime:
                    timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHM(leftTime))

                    timeTextLine = ui.TextLine()
                    timeTextLine.SetParent(self)
                    timeTextLine.SetFontName(self.defFontName)
                    timeTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
                    timeTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
                    timeTextLine.SetOutline()
                    timeTextLine.SetFeather()
                    timeTextLine.Show()
                    timeTextLine.SetText(timeText)
                    self.childrenList.append(timeTextLine)
                    self.toolTipHeight += 16 + 2

            else:
                nameTextLine.SetText(localeInfo.TOOLTIP_SOCKET_EMPTY)

            self.toolTipHeight += 35
            self.ResizeToolTip()

        def __AppendFishInfo(self, size):
            if size > 0:
                self.AppendSpace(5)
                self.AppendTextLine(localeInfo.TOOLTIP_FISH_LEN % (float(size) / 100.0), self.NORMAL_COLOR)

        def AppendUniqueItemLastTime(self, restMin):
            restSecond = restMin*60
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHM(restSecond), self.NORMAL_COLOR)

        def AppendMallItemLastTime(self, endTime):
            leftSec = max(0, endTime - app.GetGlobalTimeStamp())
            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHM(leftSec), self.NORMAL_COLOR)
            
        def AppendTimerBasedOnWearLastTime(self, metinSlot):
            if 0 == metinSlot[0]:
                self.AppendSpace(5)
                self.AppendTextLine(localeInfo.CANNOT_USE, self.DISABLE_COLOR)
            else:
                endTime = app.GetGlobalTimeStamp() + metinSlot[0]
                self.AppendMallItemLastTime(endTime)        
        
        def AppendRealTimeStartFirstUseLastTime(self, item, metinSlot, limitIndex):        
            useCount = metinSlot[1]
            endTime = metinSlot[0]
            
            # ÇŃ ąřŔĚ¶óµµ »çżëÇߴٸé Socket0żˇ Áľ·á ˝Ă°Ł(2012łâ 3żů 1ŔĎ 13˝Ă 01şĐ °°Ŕş..) ŔĚ ąÚÇôŔÖŔ˝.
            # »çżëÇĎÁö ľĘľŇ´Ů¸é Socket0żˇ ŔĚżë°ˇ´É˝Ă°Ł(Ŕ̸¦Ĺ׸é 600 °°Ŕş °Ş. ĂĘ´ÜŔ§)ŔĚ µéľîŔÖŔ» Ľö ŔÖ°í, 0Ŕ̶ó¸é Limit Valueżˇ ŔÖ´Â ŔĚżë°ˇ´É˝Ă°ŁŔ» »çżëÇŃ´Ů.
            if 0 == useCount:
                if 0 == endTime:
                    (limitType, limitValue) = item.GetLimit(limitIndex)
                    endTime = limitValue

                endTime += app.GetGlobalTimeStamp()
        
            self.AppendMallItemLastTime(endTime)
        
    class HyperlinkItemToolTip(ItemToolTip):
        def __init__(self):
            ItemToolTip.__init__(self, isPickable=True)

        def SetHyperlinkItem(self, tokens):
            minTokenCount = 3 + player.METIN_SOCKET_MAX_NUM
            maxTokenCount = minTokenCount + 2 * player.ATTRIBUTE_SLOT_MAX_NUM
            if tokens and len(tokens) >= minTokenCount and len(tokens) <= maxTokenCount:
                head, vnum, flag = tokens[:3]
                itemVnum = int(vnum, 16)
                metinSlot = [int(metin, 16) for metin in tokens[3:6]]

                rests = tokens[6:]
                if rests:
                    attrSlot = []

                    rests.reverse()
                    while rests:
                        key = int(rests.pop(), 16)
                        if rests:
                            val = int(rests.pop())
                            attrSlot.append((key, val))

                    attrSlot += [(0, 0)] * (player.ATTRIBUTE_SLOT_MAX_NUM - len(attrSlot))
                else:
                    attrSlot = [(0, 0)] * player.ATTRIBUTE_SLOT_MAX_NUM

                self.ClearToolTip()
                self.AddItemData(itemVnum, metinSlot, attrSlot)

                ItemToolTip.OnUpdate(self)

        def OnUpdate(self):
            pass

        def OnMouseLeftButtonDown(self):
            self.Hide()

    class SkillToolTip(ToolTip):

        POINT_NAME_DICT = {
            player.LEVEL : localeInfo.SKILL_TOOLTIP_LEVEL,
            player.IQ : localeInfo.SKILL_TOOLTIP_INT,
        }

        SKILL_TOOL_TIP_WIDTH = 200
        PARTY_SKILL_TOOL_TIP_WIDTH = 340

        PARTY_SKILL_EXPERIENCE_AFFECT_LIST = (    ( 2, 2,  10,),
                                                ( 8, 3,  20,),
                                                (14, 4,  30,),
                                                (22, 5,  45,),
                                                (28, 6,  60,),
                                                (34, 7,  80,),
                                                (38, 8, 100,), )

        PARTY_SKILL_PLUS_GRADE_AFFECT_LIST = (    ( 4, 2, 1, 0,),
                                                (10, 3, 2, 0,),
                                                (16, 4, 2, 1,),
                                                (24, 5, 2, 2,), )

        PARTY_SKILL_ATTACKER_AFFECT_LIST = (    ( 36, 3, ),
                                                ( 26, 1, ),
                                                ( 32, 2, ), )

        SKILL_GRADE_NAME = {    player.SKILL_GRADE_MASTER : localeInfo.SKILL_GRADE_NAME_MASTER,
                                player.SKILL_GRADE_GRAND_MASTER : localeInfo.SKILL_GRADE_NAME_GRAND_MASTER,
                                player.SKILL_GRADE_PERFECT_MASTER : localeInfo.SKILL_GRADE_NAME_PERFECT_MASTER, }

        AFFECT_NAME_DICT =    {
                                "HP" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_POWER,
                                "ATT_GRADE" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_GRADE,
                                "DEF_GRADE" : localeInfo.TOOLTIP_SKILL_AFFECT_DEF_GRADE,
                                "ATT_SPEED" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_SPEED,
                                "MOV_SPEED" : localeInfo.TOOLTIP_SKILL_AFFECT_MOV_SPEED,
                                "DODGE" : localeInfo.TOOLTIP_SKILL_AFFECT_DODGE,
                                "RESIST_NORMAL" : localeInfo.TOOLTIP_SKILL_AFFECT_RESIST_NORMAL,
                                "REFLECT_MELEE" : localeInfo.TOOLTIP_SKILL_AFFECT_REFLECT_MELEE,
                            }
        AFFECT_APPEND_TEXT_DICT =    {
                                        "DODGE" : "%",
                                        "RESIST_NORMAL" : "%",
                                        "REFLECT_MELEE" : "%",
                                    }

        def __init__(self):
            ToolTip.__init__(self, self.SKILL_TOOL_TIP_WIDTH)
        def __del__(self):
            ToolTip.__del__(self)

        def SetSkill(self, skillIndex, skillLevel = -1):

            if 0 == skillIndex:
                return

            if skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):

                if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
                    self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
                    self.ResizeToolTip()

                self.AppendDefaultData(skillIndex)
                self.AppendSkillConditionData(skillIndex)
                self.AppendGuildSkillData(skillIndex, skillLevel)

            else:

                if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
                    self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
                    self.ResizeToolTip()

                slotIndex = player.GetSkillSlotIndex(skillIndex)
                skillGrade = player.GetSkillGrade(slotIndex)
                skillLevel = player.GetSkillLevel(slotIndex)
                skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
                skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)

                self.AppendDefaultData(skillIndex)
                self.AppendSkillConditionData(skillIndex)
                self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
                self.AppendSkillRequirement(skillIndex, skillLevel)

            self.ShowToolTip()

        def SetSkillNew(self, slotIndex, skillIndex, skillGrade, skillLevel):

            if 0 == skillIndex:
                return

            if player.SKILL_INDEX_TONGSOL == skillIndex:

                slotIndex = player.GetSkillSlotIndex(skillIndex)
                skillLevel = player.GetSkillLevel(slotIndex)

                self.AppendDefaultData(skillIndex)
                self.AppendPartySkillData(skillGrade, skillLevel)

            elif player.SKILL_INDEX_RIDING == skillIndex:

                slotIndex = player.GetSkillSlotIndex(skillIndex)
                self.AppendSupportSkillDefaultData(skillIndex, skillGrade, skillLevel, 30)

            elif player.SKILL_INDEX_SUMMON == skillIndex:

                maxLevel = 10

                self.ClearToolTip()
                self.__SetSkillTitle(skillIndex, skillGrade)

                ## Description
                description = skill.GetSkillDescription(skillIndex)
                self.AppendDescription(description, 25)

                if skillLevel == 10:
                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
                    self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (skillLevel*10), self.NORMAL_COLOR)

                else:
                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
                    self.__AppendSummonDescription(skillLevel, self.NORMAL_COLOR)

                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel+1), self.NEGATIVE_COLOR)
                    self.__AppendSummonDescription(skillLevel+1, self.NEGATIVE_COLOR)

            elif skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):

                if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
                    self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
                    self.ResizeToolTip()

                self.AppendDefaultData(skillIndex)
                self.AppendSkillConditionData(skillIndex)
                self.AppendGuildSkillData(skillIndex, skillLevel)

            else:

                if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
                    self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
                    self.ResizeToolTip()

                slotIndex = player.GetSkillSlotIndex(skillIndex)

                skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
                skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)

                self.AppendDefaultData(skillIndex, skillGrade)
                self.AppendSkillConditionData(skillIndex)
                self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
                self.AppendSkillRequirement(skillIndex, skillLevel)

            self.ShowToolTip()

        def __SetSkillTitle(self, skillIndex, skillGrade):
            self.SetTitle(skill.GetSkillName(skillIndex, skillGrade))
            self.__AppendSkillGradeName(skillIndex, skillGrade)

        def __AppendSkillGradeName(self, skillIndex, skillGrade):        
            if self.SKILL_GRADE_NAME.has_key(skillGrade):
                self.AppendSpace(5)
                self.AppendTextLine(self.SKILL_GRADE_NAME[skillGrade] % (skill.GetSkillName(skillIndex, 0)), self.CAN_LEVEL_UP_COLOR)

        def SetSkillOnlyName(self, slotIndex, skillIndex, skillGrade):
            if 0 == skillIndex:
                return

            slotIndex = player.GetSkillSlotIndex(skillIndex)

            self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
            self.ResizeToolTip()

            self.ClearToolTip()
            self.__SetSkillTitle(skillIndex, skillGrade)        
            self.AppendDefaultData(skillIndex, skillGrade)
            self.AppendSkillConditionData(skillIndex)        
            self.ShowToolTip()

        def AppendDefaultData(self, skillIndex, skillGrade = 0):
            self.ClearToolTip()
            self.__SetSkillTitle(skillIndex, skillGrade)

            ## Level Limit
            levelLimit = skill.GetSkillLevelLimit(skillIndex)
            if levelLimit > 0:

                color = self.NORMAL_COLOR
                if player.GetStatus(player.LEVEL) < levelLimit:
                    color = self.NEGATIVE_COLOR

                self.AppendSpace(5)
                self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_LEVEL % (levelLimit), color)

            ## Description
            description = skill.GetSkillDescription(skillIndex)
            self.AppendDescription(description, 25)

        def AppendSupportSkillDefaultData(self, skillIndex, skillGrade, skillLevel, maxLevel):
            self.ClearToolTip()
            self.__SetSkillTitle(skillIndex, skillGrade)

            ## Description
            description = skill.GetSkillDescription(skillIndex)
            self.AppendDescription(description, 25)

            if 1 == skillGrade:
                skillLevel += 19
            elif 2 == skillGrade:
                skillLevel += 29
            elif 3 == skillGrade:
                skillLevel = 40

            self.AppendSpace(5)
            self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_WITH_MAX % (skillLevel, maxLevel), self.NORMAL_COLOR)

        def AppendSkillConditionData(self, skillIndex):
            conditionDataCount = skill.GetSkillConditionDescriptionCount(skillIndex)
            if conditionDataCount > 0:
                self.AppendSpace(5)
                for i in xrange(conditionDataCount):
                    self.AppendTextLine(skill.GetSkillConditionDescription(skillIndex, i), self.CONDITION_COLOR)

        def AppendGuildSkillData(self, skillIndex, skillLevel):
            skillMaxLevel = 7
            skillCurrentPercentage = float(skillLevel) / float(skillMaxLevel)
            skillNextPercentage = float(skillLevel+1) / float(skillMaxLevel)
            ## Current Level
            if skillLevel > 0:
                if self.HasSkillLevelDescription(skillIndex, skillLevel):
                    self.AppendSpace(5)
                    if skillLevel == skillMaxLevel:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
                    else:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)

                    #####

                    for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
                        self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillCurrentPercentage), self.ENABLE_COLOR)

                    ## Cooltime
                    coolTime = skill.GetSkillCoolTime(skillIndex, skillCurrentPercentage)
                    if coolTime > 0:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.ENABLE_COLOR)

                    ## SP
                    needGSP = skill.GetSkillNeedSP(skillIndex, skillCurrentPercentage)
                    if needGSP > 0:
                        self.AppendTextLine(localeInfo.TOOLTIP_NEED_GSP % (needGSP), self.ENABLE_COLOR)

            ## Next Level
            if skillLevel < skillMaxLevel:
                if self.HasSkillLevelDescription(skillIndex, skillLevel+1):
                    self.AppendSpace(5)
                    self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevel), self.DISABLE_COLOR)

                    #####

                    for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
                        self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillNextPercentage), self.DISABLE_COLOR)

                    ## Cooltime
                    coolTime = skill.GetSkillCoolTime(skillIndex, skillNextPercentage)
                    if coolTime > 0:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.DISABLE_COLOR)

                    ## SP
                    needGSP = skill.GetSkillNeedSP(skillIndex, skillNextPercentage)
                    if needGSP > 0:
                        self.AppendTextLine(localeInfo.TOOLTIP_NEED_GSP % (needGSP), self.DISABLE_COLOR)

        def AppendSkillDataNew(self, slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage):

            self.skillMaxLevelStartDict = { 0 : 17, 1 : 7, 2 : 10, }
            self.skillMaxLevelEndDict = { 0 : 20, 1 : 10, 2 : 10, }

            skillLevelUpPoint = 1
            realSkillGrade = player.GetSkillGrade(slotIndex)
            skillMaxLevelStart = self.skillMaxLevelStartDict.get(realSkillGrade, 15)
            skillMaxLevelEnd = self.skillMaxLevelEndDict.get(realSkillGrade, 20)

            ## Current Level
            if skillLevel > 0:
                if self.HasSkillLevelDescription(skillIndex, skillLevel):
                    self.AppendSpace(5)
                    if skillGrade == skill.SKILL_GRADE_COUNT:
                        pass
                    elif skillLevel == skillMaxLevelEnd:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
                    else:
                        self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
                    self.AppendSkillLevelDescriptionNew(skillIndex, skillCurrentPercentage, self.ENABLE_COLOR)

            ## Next Level
            if skillGrade != skill.SKILL_GRADE_COUNT:
                if skillLevel < skillMaxLevelEnd:
                    if self.HasSkillLevelDescription(skillIndex, skillLevel+skillLevelUpPoint):
                        self.AppendSpace(5)
                        ## HPş¸°­, °üĹëȸÇÇ ş¸Á¶˝şĹłŔÇ °ćżě
                        if skillIndex == 141 or skillIndex == 142:
                            self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_3 % (skillLevel+1), self.DISABLE_COLOR)
                        else:
                            self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevelEnd), self.DISABLE_COLOR)
                        self.AppendSkillLevelDescriptionNew(skillIndex, skillNextPercentage, self.DISABLE_COLOR)

        def AppendSkillLevelDescriptionNew(self, skillIndex, skillPercentage, color):

            affectDataCount = skill.GetNewAffectDataCount(skillIndex)
            if affectDataCount > 0:
                for i in xrange(affectDataCount):
                    type, minValue, maxValue = skill.GetNewAffectData(skillIndex, i, skillPercentage)

                    if not self.AFFECT_NAME_DICT.has_key(type):
                        continue

                    minValue = int(minValue)
                    maxValue = int(maxValue)
                    affectText = self.AFFECT_NAME_DICT[type]

                    if "HP" == type:
                        if minValue < 0 and maxValue < 0:
                            minValue *= -1
                            maxValue *= -1

                        else:
                            affectText = localeInfo.TOOLTIP_SKILL_AFFECT_HEAL

                    affectText += str(minValue)
                    if minValue != maxValue:
                        affectText += " - " + str(maxValue)
                    affectText += self.AFFECT_APPEND_TEXT_DICT.get(type, "")

                    #import debugInfo
                    #if debugInfo.IsDebugMode():
                    #    affectText = "!!" + affectText

                    self.AppendTextLine(affectText, color)
                
            else:
                for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
                    self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillPercentage), color)
            

            ## Duration
            duration = skill.GetDuration(skillIndex, skillPercentage)
            if duration > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_SKILL_DURATION % (duration), color)

            ## Cooltime
            coolTime = skill.GetSkillCoolTime(skillIndex, skillPercentage)
            if coolTime > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), color)

            ## SP
            needSP = skill.GetSkillNeedSP(skillIndex, skillPercentage)
            if needSP != 0:
                continuationSP = skill.GetSkillContinuationSP(skillIndex, skillPercentage)

                if skill.IsUseHPSkill(skillIndex):
                    self.AppendNeedHP(needSP, continuationSP, color)
                else:
                    self.AppendNeedSP(needSP, continuationSP, color)

        def AppendSkillRequirement(self, skillIndex, skillLevel):

            skillMaxLevel = skill.GetSkillMaxLevel(skillIndex)

            if skillLevel >= skillMaxLevel:
                return

            isAppendHorizontalLine = False

            ## Requirement
            if skill.IsSkillRequirement(skillIndex):

                if not isAppendHorizontalLine:
                    isAppendHorizontalLine = True
                    self.AppendHorizontalLine()

                requireSkillName, requireSkillLevel = skill.GetSkillRequirementData(skillIndex)

                color = self.CANNOT_LEVEL_UP_COLOR
                if skill.CheckRequirementSueccess(skillIndex):
                    color = self.CAN_LEVEL_UP_COLOR
                self.AppendTextLine(localeInfo.TOOLTIP_REQUIREMENT_SKILL_LEVEL % (requireSkillName, requireSkillLevel), color)

            ## Require Stat
            requireStatCount = skill.GetSkillRequireStatCount(skillIndex)
            if requireStatCount > 0:

                for i in xrange(requireStatCount):
                    type, level = skill.GetSkillRequireStatData(skillIndex, i)
                    if self.POINT_NAME_DICT.has_key(type):

                        if not isAppendHorizontalLine:
                            isAppendHorizontalLine = True
                            self.AppendHorizontalLine()

                        name = self.POINT_NAME_DICT[type]
                        color = self.CANNOT_LEVEL_UP_COLOR
                        if player.GetStatus(type) >= level:
                            color = self.CAN_LEVEL_UP_COLOR
                        self.AppendTextLine(localeInfo.TOOLTIP_REQUIREMENT_STAT_LEVEL % (name, level), color)

        def HasSkillLevelDescription(self, skillIndex, skillLevel):
            if skill.GetSkillAffectDescriptionCount(skillIndex) > 0:
                return True
            if skill.GetSkillCoolTime(skillIndex, skillLevel) > 0:
                return True
            if skill.GetSkillNeedSP(skillIndex, skillLevel) > 0:
                return True

            return False

        def AppendMasterAffectDescription(self, index, desc, color):
            self.AppendTextLine(desc, color)

        def AppendNextAffectDescription(self, index, desc):
            self.AppendTextLine(desc, self.DISABLE_COLOR)

        def AppendNeedHP(self, needSP, continuationSP, color):

            self.AppendTextLine(localeInfo.TOOLTIP_NEED_HP % (needSP), color)

            if continuationSP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_NEED_HP_PER_SEC % (continuationSP), color)

        def AppendNeedSP(self, needSP, continuationSP, color):

            if -1 == needSP:
                self.AppendTextLine(localeInfo.TOOLTIP_NEED_ALL_SP, color)

            else:
                self.AppendTextLine(localeInfo.TOOLTIP_NEED_SP % (needSP), color)

            if continuationSP > 0:
                self.AppendTextLine(localeInfo.TOOLTIP_NEED_SP_PER_SEC % (continuationSP), color)

        def AppendPartySkillData(self, skillGrade, skillLevel):

            if 1 == skillGrade:
                skillLevel += 19
            elif 2 == skillGrade:
                skillLevel += 29
            elif 3 == skillGrade:
                skillLevel =  40

            if skillLevel <= 0:
                return

            skillIndex = player.SKILL_INDEX_TONGSOL
            slotIndex = player.GetSkillSlotIndex(skillIndex)
            skillPower = player.GetSkillCurrentEfficientPercentage(slotIndex)
            if localeInfo.IsBRAZIL():
                k = skillPower
            else:
                k = player.GetSkillLevel(skillIndex) / 100.0
            self.AppendSpace(5)
            self.AutoAppendTextLine(localeInfo.TOOLTIP_PARTY_SKILL_LEVEL % skillLevel, self.NORMAL_COLOR)

            if skillLevel>=10:
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_ATTACKER % chop( 10 + 60 * k ))

            if skillLevel>=20:
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_BERSERKER     % chop(1 + 5 * k))
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_TANKER     % chop(50 + 1450 * k))

            if skillLevel>=25:
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_BUFFER % chop(5 + 45 * k ))

            if skillLevel>=35:
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_SKILL_MASTER % chop(25 + 600 * k ))

            if skillLevel>=40:
                self.AutoAppendTextLine(localeInfo.PARTY_SKILL_DEFENDER % chop( 5 + 30 * k ))

            self.AlignHorizonalCenter()

        def __AppendSummonDescription(self, skillLevel, color):
            if skillLevel > 1:
                self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (skillLevel * 10), color)
            elif 1 == skillLevel:
                self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (15), color)
            elif 0 == skillLevel:
                self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (10), color)


    if __name__ == "__main__":    
        import app
        import wndMgr
        import systemSetting
        import mouseModule
        import grp
        import ui
        
        #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()

        toolTip = ItemToolTip()
        toolTip.ClearToolTip()
        #toolTip.AppendTextLine("Test")
        desc = "Item descriptions:|increase of width of display to 35 digits per row AND installation of function that the displayed words are not broken up in two parts, but instead if one word is too long to be displayed in this row, this word will start in the next row."
        summ = ""

        toolTip.AddItemData_Offline(10, desc, summ, 0, 0) 
        toolTip.Show()
        
        app.Loop()

  2.  

    Hey, even though I click the linked object does not open why this might be?

    0711 00:29:42139 :: IndexError
    0711 00:29:42139 :: :
    0711 00:29:42139 :: list index out of range
    0711 00:29:42139 ::
    0711 00:29:42316 :: Traceback (most recent call last):
     
    0711 00:29:42317 ::   File "game.py", line 1287, in OnMouseLeftButtonUp
     
    0711 00:29:42318 ::   File "interfaceModule.py", line 341, in MakeHyperlinkTooltip
     
    0711 00:29:42319 ::   File "uiToolTip.py", line 1818, in SetHyperlinkItem
     
    0711 00:29:42319 ::   File "uiToolTip.py", line 902, in AddItemData
     
    0711 00:29:42320 ::   File "uiToolTip.py", line 1618, in __AppendMetinSlotInfo
     
    0711 00:29:42320 :: IndexError
    0711 00:29:42320 :: :
    0711 00:29:42320 :: list index out of range
    0711 00:29:42320 ::
     
    0711 00:29:42495 :: Traceback (most recent call last):
     
    0711 00:29:42496 ::   File "game.py", line 1287, in OnMouseLeftButtonUp
     
    0711 00:29:42496 ::   File "interfaceModule.py", line 341, in MakeHyperlinkTooltip
     
    0711 00:29:42497 ::   File "uiToolTip.py", line 1818, in SetHyperlinkItem
     
    0711 00:29:42497 ::   File "uiToolTip.py", line 902, in AddItemData
     
    0711 00:29:42498 ::   File "uiToolTip.py", line 1618, in __AppendMetinSlotInfo
     
    0711 00:29:42498 :: IndexError
    0711 00:29:42498 :: :
    0711 00:29:42498 :: list index out of range
    0711 00:29:42498 ::
     
    0711 00:29:42672 :: Traceback (most recent call last):
     
    0711 00:29:42673 ::   File "game.py", line 1287, in OnMouseLeftButtonUp
     
    0711 00:29:42674 ::   File "interfaceModule.py", line 341, in MakeHyperlinkTooltip
     
    0711 00:29:42675 ::   File "uiToolTip.py", line 1818, in SetHyperlinkItem
     
    0711 00:29:42675 ::   File "uiToolTip.py", line 902, in AddItemData
     
    0711 00:29:42676 ::   File "uiToolTip.py", line 1618, in __AppendMetinSlotInfo
     
    0711 00:29:42676 :: IndexError
    0711 00:29:42676 :: :
    0711 00:29:42676 :: list index out of range
    0711 00:29:42676 ::

     

×
×
  • Create New...

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.