Source link bonus

eterconfig · July 11, 2015

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 ::

Shisui · July 11, 2015

Check your TABS.

Can you be more specific?

Edited July 11, 2015 by Shisui

eterconfig · July 11, 2015

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

Shisui · July 11, 2015

I still don't know what you're trying to say.
You post some random error and some random file without explain what you want to add or do.

So, please tell me.
And next time, please use tag spoiler, it's easier to read.

Edited July 11, 2015 by Shisui

eterconfig · July 11, 2015

picture by google

i'm can't open the linked item

Shisui · July 11, 2015

I can't see the image.

If you want send PM with all the stuff and I'll help you.

eterconfig · July 11, 2015

[sword+0] etc... on the main chat

Shisui · July 11, 2015

Try this file.

http://pastebin.com/g6sSrai9

eterconfig · July 11, 2015

problem solved thanks <3

Sign In

Source link bonus

Recommended Posts

eterconfig 0

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Shisui 487

Link to comment

Share on other sites

eterconfig 0

Link to comment

Share on other sites

Shisui 487

Link to comment

Share on other sites

eterconfig 0

Link to comment

Share on other sites

Shisui 487

Link to comment

Share on other sites

eterconfig 0

Link to comment

Share on other sites

Shisui 487

Link to comment

Share on other sites

eterconfig 0

Link to comment

Share on other sites

Please sign in to comment

Announcements

Similar Content

Activity

Recently Browsing

Important Information