Somebody know this error?

[Mimoza 4]

Hello somebody know this error? : https://metin2.download/picture/mJ7GMmoSN9qTADsdkmC7ppcrwsm28PEQ/.gif

Didn't appear name of item and in syserr i recieve this error:
 

0302 11:37:25028 :: Traceback (most recent call last):

0302 11:37:25028 ::   File "ui.py", line 1915, in OnOverInItem

0302 11:37:25029 ::   File "ui.py", line 55, in __call__

0302 11:37:25029 ::   File "ui.py", line 46, in __call__

0302 11:37:25030 ::   File "uiInventory.py", line 1609, in OverInItem

0302 11:37:25030 ::   File "uiInventory.py", line 1796, in ShowToolTip

0302 11:37:25030 ::   File "uiToolTip.py", line 533, in SetInventoryItem

0302 11:37:25031 ::   File "uiToolTip.py", line 1302, in AddItemData

0302 11:37:25031 :: TypeError
0302 11:37:25031 :: : 
0302 11:37:25031 :: argument of type 'int' is not iterable
0302 11:37:25031 :: 

uitooltip.py
 

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
if app.ENABLE_SHOULDER_SASH_SYSTEM:
	import sash

WARP_SCROLLS=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)

if app.ENABLE_NEW_PET_SYSTEM:
	def pointop(n):
		t = int(n)
		if t / 10 < 1:
			return "0."+n
		else:		
			return n[0:len(n)-1]+"."+n[len(n)-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

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)

	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)
	
	PRICE_INFO_COLOR = grp.GenerateColor(1.0, 0.88, 0.0, 1.0) #gaya

	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_COLOR1=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
	COLOR_ITEM_VNUM_TOOLTIP=0xFFE5B71B
	CANNOT_LEVEL_UP_COLOR=DISABLE_COLOR

	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):
		self.AppendDescription_WesternLanguage(desc, 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_COLOR1
			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):
	if app.ENABLE_SEND_TARGET_INFO:
		isStone = False
		isBook = False
		isBook2 = False

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

		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)

	if app.ENABLE_SEND_TARGET_INFO:
		def SetItemToolTipStone(self, itemVnum):
			self.itemVnum = itemVnum
			item.SelectItem(itemVnum)
			itemType = item.GetItemType()

			itemDesc = item.GetItemDescription()
			itemSummary = item.GetItemSummary()
			attrSlot = 0
			self.AdjustMaxWidth(attrSlot, itemDesc)
			itemName = item.GetItemName()
			realName = itemName[:itemName.find("+")]
			self.SetTitle(realName + " +0 - +4")

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

			if item.ITEM_TYPE_METIN == itemType:
				self.AppendMetinInformation()
				self.AppendMetinWearInformation()

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

				if item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
					self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)

				elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
					self.AppendTimerBasedOnWearLastTime(metinSlot)

			self.ShowToolTip()

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

	if app.ENABLE_OFFLINE_SHOP_SYSTEM:
		def SetEditPrivateShopItem(self, invenType, invenPos, price):
			itemVnum = player.GetItemIndex(invenType, invenPos)
			if 0 == itemVnum:
				return

			item.SelectItem(itemVnum)
			self.ClearToolTip()
			self.AppendSellingPrice(price)

			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)

	else:
			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 AppendAttackGradeInfo(self):
		atkGrade = item.GetValue(1)
		self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_GRADE % atkGrade, self.GetChangeTextLineColor(atkGrade))

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def CalcSashValue(self, value, abs):
			if not value:
				return 0
			
			valueCalc = int((round(value * abs) / 100) - .5) + int(int((round(value * abs) / 100) - .5) > 0)
			if valueCalc <= 0 and value > 0:
				value = 1
			else:
				value = valueCalc
			
			return value

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def AppendAttackPowerInfo(self, itemAbsChance = 0):
			minPower = item.GetValue(3)
			maxPower = item.GetValue(4)
			addPower = item.GetValue(5)
	else:
		def AppendAttackPowerInfo(self):
			minPower = item.GetValue(3)
			maxPower = item.GetValue(4)
			addPower = item.GetValue(5)
		
		if app.ENABLE_SHOULDER_SASH_SYSTEM:
			if itemAbsChance:
				minPower = self.CalcSashValue(minPower, itemAbsChance)
				maxPower = self.CalcSashValue(maxPower, itemAbsChance)
				addPower = self.CalcSashValue(addPower, itemAbsChance)
		
		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)

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def AppendMagicAttackInfo(self, itemAbsChance = 0):
			minMagicAttackPower = item.GetValue(1)
			maxMagicAttackPower = item.GetValue(2)
			addPower = item.GetValue(5)
	else:
		def AppendMagicAttackInfo(self):
			minMagicAttackPower = item.GetValue(1)
			maxMagicAttackPower = item.GetValue(2)
			addPower = item.GetValue(5)
		
		if app.ENABLE_SHOULDER_SASH_SYSTEM:
			if itemAbsChance:
				minMagicAttackPower = self.CalcSashValue(minMagicAttackPower, itemAbsChance)
				maxMagicAttackPower = self.CalcSashValue(maxMagicAttackPower, itemAbsChance)
				addPower = self.CalcSashValue(addPower, itemAbsChance)
		
		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)

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def AppendMagicDefenceInfo(self, itemAbsChance = 0):
			magicDefencePower = item.GetValue(0)
	else:
		def AppendMagicDefenceInfo(self):
			magicDefencePower = item.GetValue(0)
		
		if app.ENABLE_SHOULDER_SASH_SYSTEM:
			if itemAbsChance:
				magicDefencePower = self.CalcSashValue(magicDefencePower, itemAbsChance)
		
		if magicDefencePower > 0:
			self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_DEF_POWER % magicDefencePower, self.GetChangeTextLineColor(magicDefencePower))

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def AppendAttributeInformation(self, attrSlot, itemAbsChance = 0):
			if 0 !=attrSlot:

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

					if 0==value:
						continue

					affectString=self.GetAffectString(type, value)
	else:
		def AppendAttributeInformation(self, attrSlot):
			if 0 !=attrSlot:

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

					if 0==value:
						continue

					affectString=self.GetAffectString(type, value)

				if app.ENABLE_SHOULDER_SASH_SYSTEM:
					if item.GetItemType() == item.ITEM_TYPE_COSTUME and item.GetItemSubType() == item.COSTUME_TYPE_SASH and itemAbsChance:
						value = self.CalcSashValue(value, itemAbsChance)
						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_COLOR1
		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):
		itemName=nonplayer.GetMonsterName(monsterVnum)
		itemName+=" "
		itemName+=item.GetItemName()
		self.SetTitle(itemName)

	def SetNormalItemTitle(self):
		if app.ENABLE_SEND_TARGET_INFO:
			if self.isStone:
				itemName = item.GetItemName()
				realName = itemName[:itemName.find("+")]
				self.SetTitle(realName + " +0 - +4")
			else:
				self.SetTitle(item.GetItemName())
		else:
			self.SetTitle(item.GetItemName())

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

	def SetItemTitle(self, itemVnum, metinSlot, attrSlot):
		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[i][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[i]
			if self.GetMetinItemIndex(metinSlotData)==28960:
				metinSlot[i]=player.METIN_SOCKET_TYPE_SILVER

		self.AddItemData(itemVnum, metinSlot, attrSlot)

	if app.ENABLE_NEW_PET_SYSTEM:
		def check_sigillo(self, item_vnum):
			for x in range(55701,55707):
				if x == item_vnum:
					return TRUE	
			if item_vnum == 55801:
				return TRUE
			return FALSE

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

		if app.ENABLE_SEND_TARGET_INFO:
			if 50300 == itemVnum and not self.isBook:
				if 0 != metinSlot and not self.isBook:
					self.SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILLBOOK_NAME, 1)
					self.ShowToolTip()
				elif self.isBook:
					self.SetTitle(item.GetItemName())
					self.AppendDescription(item.GetItemDescription(), 26)
					self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
					self.ShowToolTip()					
				return
			elif 70037 == itemVnum :
				if 0 != metinSlot and not self.isBook2:
					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()
				elif self.isBook2:
					self.SetTitle(item.GetItemName())
					self.AppendDescription(item.GetItemDescription(), 26)
					self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
					self.ShowToolTip()					
				return
		else:
			if 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

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

		isCostumeItem=0
		isCostumeHair=0
		isCostumeBody=0
		if app.ENABLE_SHOULDER_SASH_SYSTEM:
			isCostumeSash = 0
		if app.ENABLE_COSTUME_WEAPON_SYSTEM:
			isCostumeWeapon = 0
		if app.ENABLE_COSTUME_MOUNT_SYSTEM:
			isCostumeMount = 0
			
		if item.ITEM_TYPE_COSTUME == itemType:
			isCostumeItem = 1
			isCostumeHair = item.COSTUME_TYPE_HAIR == itemSubType
			isCostumeBody = item.COSTUME_TYPE_BODY == itemSubType
			if app.ENABLE_SHOULDER_SASH_SYSTEM:
				isCostumeSash = item.COSTUME_TYPE_SASH == itemSubType
			if app.ENABLE_COSTUME_WEAPON_SYSTEM:
				isCostumeWeapon = item.COSTUME_TYPE_WEAPON == itemSubType
			if app.ENABLE_COSTUME_MOUNT_SYSTEM:
				isCostumeMount = item.COSTUME_TYPE_MOUNT == itemSubType

		self.AdjustMaxWidth(attrSlot, itemDesc)
		self.SetItemTitle(itemVnum, metinSlot, attrSlot)

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

		if app.ENABLE_NEW_PET_SYSTEM:
			if self.check_sigillo(itemVnum) or itemVnum == 55002:
				if attrSlot[0][1] != 0:
					self.AppendSpace(5)
					self.AppendTextLine("Nivel: "+str(metinSlot[1]), self.SPECIAL_POSITIVE_COLOR2)
					self.AppendTextLine("HP: +"+pointop(str(attrSlot[0][1]))+"%", self.SPECIAL_POSITIVE_COLOR1)
					self.AppendTextLine("DEF: +"+pointop(str(attrSlot[1][1]))+"%", self.SPECIAL_POSITIVE_COLOR1)
					self.AppendTextLine("ATAC: +"+pointop(str(attrSlot[2][1]))+"%", self.SPECIAL_POSITIVE_COLOR1)
					self.AppendSpace(5)
					if itemVnum != 55002:
						days = (int(attrSlot[3][1])/60)/24
						hours = (int(attrSlot[3][1]) - (days*60*24)) / 60
						mins = int(attrSlot[3][1]) - (days*60*24) - (hours*60)
						self.AppendTextLine("Duratã: %d Zile %d Ore %d Minute" % (days, hours, mins), self.NORMAL_COLOR)		

		if app.ENABLE_FEATURES_REFINE_SYSTEM:
			if itemVnum in (player.REFINE_VNUM_POTION_LOW, player.REFINE_VNUM_POTION_MEDIUM, player.REFINE_VNUM_POTION_EXTRA):

				self.DESCRIPTION_VNUMS = [
					localeInfo.REFINE_TOOLTIP_ITEM_DESCRIPTION_1,
					localeInfo.REFINE_TOOLTIP_ITEM_DESCRIPTION_2,
					localeInfo.REFINE_TOOLTIP_ITEM_DESCRIPTION_3,
					localeInfo.REFINE_TOOLTIP_ITEM_DESCRIPTION_4
				]
				
				self.PERCENTAGE_VNUMS = {
					player.REFINE_VNUM_POTION_LOW : player.REFINE_PERCENTAGE_LOW,
					player.REFINE_VNUM_POTION_MEDIUM : player.REFINE_PERCENTAGE_MEDIUM,
					player.REFINE_VNUM_POTION_EXTRA : player.REFINE_PERCENTAGE_EXTRA
				}
				
				self.COLORS = [
					self.NORMAL_COLOR, self.SPECIAL_POSITIVE_COLOR1, self.DISABLE_COLOR, self.HIGH_PRICE_COLOR
				]
					
				self.AppendSpace(5)

				for it in xrange(len(self.DESCRIPTION_VNUMS) - 1):
					self.AppendDescription(self.DESCRIPTION_VNUMS[it], None, self.COLORS[it])
				self.AppendDescription(self.DESCRIPTION_VNUMS[3] % (self.PERCENTAGE_VNUMS[itemVnum]), None, self.COLORS[3])

		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)

		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)

#ENABLE_FEW_UPDATES_FIXES:
		elif item.ITEM_TYPE_RING == itemType:
			self.AppendLimitInformation()
			self.AppendAffectInformation()
			self.AppendAttributeInformation(attrSlot)

			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):
						self.AppendMallItemLastTime(time)
#END

#ENABLE_NEW_PET_SYSTEM:
		elif item.ITEM_TYPE_QUEST == itemType:		
			if itemVnum >= 53000 and itemVnum <= 53999:
				self.AppendAffectInformation()
				self.AppendAttributeInformation(attrSlot)
				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):
						self.AppendMallItemLastTime(time)
#END

		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()
			
			if app.ENABLE_SHOULDER_SASH_SYSTEM:
				if isCostumeSash:
					absChance = int(metinSlot[sash.ABSORPTION_SOCKET])
					self.AppendTextLine(localeInfo.SASH_ABSORB_CHANCE % (absChance), self.CONDITION_COLOR)
					
					itemAbsorbedVnum = int(metinSlot[sash.ABSORBED_SOCKET])
					if itemAbsorbedVnum:
						item.SelectItem(itemAbsorbedVnum)
						if item.GetItemType() == item.ITEM_TYPE_WEAPON:
							if item.GetItemSubType() == item.WEAPON_FAN:
								self.AppendMagicAttackInfo(metinSlot[sash.ABSORPTION_SOCKET])
								item.SelectItem(itemAbsorbedVnum)
								self.AppendAttackPowerInfo(metinSlot[sash.ABSORPTION_SOCKET])
							else:
								self.AppendAttackPowerInfo(metinSlot[sash.ABSORPTION_SOCKET])
								item.SelectItem(itemAbsorbedVnum)
								self.AppendMagicAttackInfo(metinSlot[sash.ABSORPTION_SOCKET])
						elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
							defGrade = item.GetValue(1)
							defBonus = item.GetValue(5) * 2
							defGrade = self.CalcSashValue(defGrade, metinSlot[sash.ABSORPTION_SOCKET])
							defBonus = self.CalcSashValue(defBonus, metinSlot[sash.ABSORPTION_SOCKET])
							
							if defGrade > 0:
								self.AppendSpace(5)
								self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
							
							item.SelectItem(itemAbsorbedVnum)
							self.AppendMagicDefenceInfo(metinSlot[sash.ABSORPTION_SOCKET])

						item.SelectItem(itemAbsorbedVnum)
						for i in xrange(item.ITEM_APPLY_MAX_NUM):
							(affectType, affectValue) = item.GetAffect(i)
							affectValue = self.CalcSashValue(affectValue, metinSlot[sash.ABSORPTION_SOCKET])
							affectString = self.GetAffectString(affectType, affectValue)
							if affectString and affectValue > 0:
								self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
							
							item.SelectItem(itemAbsorbedVnum)
						
						item.SelectItem(itemVnum)
						self.AppendAttributeInformation(attrSlot, metinSlot[sash.ABSORPTION_SOCKET])
					else:
						self.AppendAttributeInformation(attrSlot)
				else:
					self.AppendAffectInformation()
					self.AppendAttributeInformation(attrSlot)
			else:
				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

			if 1==bHasRealtimeFlag:
				self.AppendMallItemLastTime(metinSlot[0])

		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)

#ENABLE_FEW_UPDATES_FIXES:
		elif item.ITEM_TYPE_RING == itemType:
			self.AppendLimitInformation()
			self.AppendAffectInformation()
			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
		
			if 1 == bHasRealtimeFlag:
				self.AppendMallItemLastTime(metinSlot[0])
#END		

		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)

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

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

		elif item.ITEM_TYPE_FISH==itemType:
			if 0 !=metinSlot:
				self.AppendFishInfo(metinSlot[0])

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

#ENABLE_FEW_UPDATES_FIXES:
		elif item.ITEM_TYPE_UNIQUE == itemType:
			if 71158 == itemVnum:
				self.AppendAffectInformation()
				self.AppendAttributeInformation(attrSlot)

				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):
							self.AppendMallItemLastTime(time)

			elif 0 != metinSlot:
				bHasRealtimeFlag=0
#END

				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):
						self.AppendMallItemLastTime(time)
					else:
						self.AppendUniqueItemLastTime(time)

		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 constInfo.IS_AUTO_POTION(itemVnum):
				if 0 !=metinSlot:
					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_COLOR1)
						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

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

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

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

				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)

			if item.LIMIT_REAL_TIME_START_FIRST_USE==limitType:
				self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)

			elif item.LIMIT_TIMER_BASED_ON_WEAR==limitType:
				self.AppendTimerBasedOnWearLastTime(metinSlot)

		if chr.IsGameMaster(player.GetMainCharacterIndex()):
			self.AppendTextLine(localeInfo.ITEM_VNUM_TOOLTIP % (int(itemVnum)), self.COLOR_ITEM_VNUM_TOOLTIP)

		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 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[i][0]
			value=attrSlot[i][1]

			if self.ATTRIBUTE_NEED_WIDTH.has_key(type):
				if value > 0:
					maxWidth=max(self.ATTRIBUTE_NEED_WIDTH[type], maxWidth)

		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

		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)

	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[i]
			flag=flagList[i]

			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 >=500000:
			return self.HIGH_PRICE_COLOR
		if price >=50000:
			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 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)
		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[i]
			flag=flagList[i]
			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[i])

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

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

		return 1

	def AppendMetinSlotInfo_AppendMetinSocketData(self, index, metinSlotData, custumAffectString1="", 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()

		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)
		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)
			try:
				metinImage.LoadImage(item.GetIconImageFileName())
			except:
				dbg.TraceError("ItemToolTip.AppendMetinSocketData() - Failed to find image file %d:%s" % (itemIndex, item.GetIconImageFileName()))

			nameTextLine.SetText(item.GetItemName())
			
			affectTextLine=ui.TextLine()
			affectTextLine.SetParent(self)
			affectTextLine.SetFontName(self.defFontName)
			affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
			affectTextLine.SetOutline()
			affectTextLine.SetFeather()
			affectTextLine.Show()
			metinImage.SetPosition(10, self.toolTipHeight)
			affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2)

			if custumAffectString1:
				affectTextLine.SetText(custumAffectString1)
			elif itemIndex !=28960:
				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):
		if restMin == 0 and shop.IsOpen() and not shop.IsPrivateShop():
			restMin = item.GetValue(0)
		restSecond = restMin*60
		self.AppendSpace(5)
		self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(restSecond), self.NORMAL_COLOR)

	def AppendMallItemLastTime(self, endTime):
		if endTime == 0 and shop.IsOpen() and not shop.IsPrivateShop():
			endTime = item.GetValue(0)+app.GetGlobalTimeStamp()
		leftSec = max(0, endTime - app.GetGlobalTimeStamp())
		self.AppendSpace(5)
		self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(leftSec), self.CONDITION_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]
		
		if 0==useCount:
			if 0==endTime:
				(limitType, limitValue)=item.GetLimit(limitIndex)
				endTime=limitValue

			endTime+=app.GetGlobalTimeStamp()
	
		self.AppendMallItemLastTime(endTime)

	if app.ENABLE_SHOULDER_SASH_SYSTEM:
		def SetSashResultItem(self, slotIndex, window_type = player.INVENTORY):
			(itemVnum, MinAbs, MaxAbs) = sash.GetResultItem()
			if not itemVnum:
				return
			
			self.ClearToolTip()
			
			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)]
			
			item.SelectItem(itemVnum)
			itemType = item.GetItemType()
			itemSubType = item.GetItemSubType()
			if itemType != item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_SASH:
				return
			
			absChance = MaxAbs
			itemDesc = item.GetItemDescription()
			self.AdjustMaxWidth(attrSlot, itemDesc)
			self.SetItemTitle(itemVnum, metinSlot, attrSlot)
			self.AppendDescription(itemDesc, 26)
			self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
			self.AppendLimitInformation()
			
			if MinAbs == MaxAbs:
				self.AppendTextLine(localeInfo.SASH_ABSORB_CHANCE % (MinAbs), self.CONDITION_COLOR)
			else:
				self.AppendTextLine(localeInfo.SASH_ABSORB_CHANCE2 % (MinAbs, MaxAbs), self.CONDITION_COLOR)
			
			itemAbsorbedVnum = int(metinSlot[sash.ABSORBED_SOCKET])
			if itemAbsorbedVnum:
				item.SelectItem(itemAbsorbedVnum)
				if item.GetItemType() == item.ITEM_TYPE_WEAPON:
					if item.GetItemSubType() == item.WEAPON_FAN:
						self.AppendMagicAttackInfo(absChance)
						item.SelectItem(itemAbsorbedVnum)
						self.AppendAttackPowerInfo(absChance)
					else:
						self.AppendAttackPowerInfo(absChance)
						item.SelectItem(itemAbsorbedVnum)
						self.AppendMagicAttackInfo(absChance)
				elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
					defGrade = item.GetValue(1)
					defBonus = item.GetValue(5) * 2
					defGrade = self.CalcSashValue(defGrade, absChance)
					defBonus = self.CalcSashValue(defBonus, absChance)
					
					if defGrade > 0:
						self.AppendSpace(5)
						self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
					
					item.SelectItem(itemAbsorbedVnum)
					self.AppendMagicDefenceInfo(absChance)

				item.SelectItem(itemAbsorbedVnum)
				for i in xrange(item.ITEM_APPLY_MAX_NUM):
					(affectType, affectValue) = item.GetAffect(i)
					affectValue = self.CalcSashValue(affectValue, absChance)
					affectString = self.GetAffectString(affectType, affectValue)
					if affectString and affectValue > 0:
						self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
					
					item.SelectItem(itemAbsorbedVnum)
				
			item.SelectItem(itemVnum)
			self.AppendAttributeInformation(attrSlot, MaxAbs)
			
			self.AppendWearableInformation()
			self.ShowToolTip()

		def SetSashResultAbsItem(self, slotIndex1, slotIndex2, window_type = player.INVENTORY):
			itemVnumSash = player.GetItemIndex(window_type, slotIndex1)
			itemVnumTarget = player.GetItemIndex(window_type, slotIndex2)
			if not itemVnumSash or not itemVnumTarget:
				return
			
			self.ClearToolTip()
			
			item.SelectItem(itemVnumSash)
			itemType = item.GetItemType()
			itemSubType = item.GetItemSubType()
			if itemType != item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_SASH:
				return
			
			metinSlot = [player.GetItemMetinSocket(window_type, slotIndex1, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
			attrSlot = [player.GetItemAttribute(window_type, slotIndex2, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
			
			itemDesc = item.GetItemDescription()
			self.AdjustMaxWidth(attrSlot, itemDesc)
			self.SetItemTitle(itemVnumSash, metinSlot, attrSlot)
			self.AppendDescription(itemDesc, 26)
			self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
			item.SelectItem(itemVnumSash)
			self.AppendLimitInformation()
			
			self.AppendTextLine(localeInfo.SASH_ABSORB_CHANCE % (metinSlot[sash.ABSORPTION_SOCKET]), self.CONDITION_COLOR)

			itemAbsorbedVnum = itemVnumTarget
			item.SelectItem(itemAbsorbedVnum)
			if item.GetItemType() == item.ITEM_TYPE_WEAPON:
				if item.GetItemSubType() == item.WEAPON_FAN:
					self.AppendMagicAttackInfo(metinSlot[sash.ABSORPTION_SOCKET])
					item.SelectItem(itemAbsorbedVnum)
					self.AppendAttackPowerInfo(metinSlot[sash.ABSORPTION_SOCKET])
				else:
					self.AppendAttackPowerInfo(metinSlot[sash.ABSORPTION_SOCKET])
					item.SelectItem(itemAbsorbedVnum)
					self.AppendMagicAttackInfo(metinSlot[sash.ABSORPTION_SOCKET])
			elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
				defGrade = item.GetValue(1)
				defBonus = item.GetValue(5) * 2
				defGrade = self.CalcSashValue(defGrade, metinSlot[sash.ABSORPTION_SOCKET])
				defBonus = self.CalcSashValue(defBonus, metinSlot[sash.ABSORPTION_SOCKET])
				
				if defGrade > 0:
					self.AppendSpace(5)
					self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
				
				item.SelectItem(itemAbsorbedVnum)
				self.AppendMagicDefenceInfo(metinSlot[sash.ABSORPTION_SOCKET])

			item.SelectItem(itemAbsorbedVnum)
			for i in xrange(item.ITEM_APPLY_MAX_NUM):
				(affectType, affectValue) = item.GetAffect(i)
				affectValue = self.CalcSashValue(affectValue, metinSlot[sash.ABSORPTION_SOCKET])
				affectString = self.GetAffectString(affectType, affectValue)
				if affectString and affectValue > 0:
					self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
				
				item.SelectItem(itemAbsorbedVnum)

			item.SelectItem(itemAbsorbedVnum)
			for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
				type = attrSlot[i][0]
				value = attrSlot[i][1]
				if not value:
					continue
				
				value = self.CalcSashValue(value, metinSlot[sash.ABSORPTION_SOCKET])
				affectString = self.GetAffectString(type, value)
				if affectString and value > 0:
					affectColor = self.GetAttributeColor(i, value)
					self.AppendTextLine(affectString, affectColor)
				
				item.SelectItem(itemAbsorbedVnum)

			item.SelectItem(itemVnumSash)
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)
			
			item.SelectItem(itemVnumSash)
			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[i]
				flag = flagList[i]
				if flag:
					characterNames += " "
					characterNames += name
			
			textLine = self.AppendTextLine(characterNames, self.NORMAL_COLOR, True)
			textLine.SetFeather()
			
			item.SelectItem(itemVnumSash)
			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()
			
			self.ShowToolTip()

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):
	SKILL_TOOL_TIP_WIDTH=200

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

	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.AppendSkillData(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=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.AppendSkillData(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)

		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=skill.GetSkillDescription(skillIndex)
		self.AppendDescription(description, 25)

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

		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)

		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=skill.GetSkillCoolTime(skillIndex, skillCurrentPercentage)
				if coolTime > 0:
					self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.ENABLE_COLOR)

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

		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=skill.GetSkillCoolTime(skillIndex, skillNextPercentage)
				if coolTime > 0:
					self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.DISABLE_COLOR)

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

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

		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.AppendSkillLevelDescription(skillIndex, skillCurrentPercentage, self.ENABLE_COLOR)

		if skillGrade !=skill.SKILL_GRADE_COUNT:
			if skillLevel < skillMaxLevelEnd:
				if self.HasSkillLevelDescription(skillIndex, skillLevel+skillLevelUpPoint):
					self.AppendSpace(5)
					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.AppendSkillLevelDescription(skillIndex, skillNextPercentage, self.DISABLE_COLOR)

	def AppendSkillLevelDescription(self, skillIndex, skillPercentage, color):
		affectDataCount=skill.GetAffectDataCount(skillIndex)
		if affectDataCount > 0:
			for i in xrange(affectDataCount):
				type, minValue, maxValue=skill.GetAffectData(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, "")
				self.AppendTextLine(affectText, color)
		else:
			for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
				self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillPercentage), color)
		
		duration=skill.GetDuration(skillIndex, skillPercentage)
		if duration > 0:
			self.AppendTextLine(localeInfo.TOOLTIP_SKILL_DURATION % (duration), color)

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

		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

		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)

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

		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)

 

Edited August 27, 2022 by Metin2 Dev
Core X - External 2 Internal

[VegaS™ 9977]

In your case WARP_SCROLLS is the index not the tuple or list that you are searching, because it is non-iterable type, you are getting this error.

m2devList = [1000, 2000, 3000]
for item in m2devList:
	print item

>> 1000
>> 2000
>> 3000

You're attempting to check if 22010 is in itemVnum, which does not make sense.

in smth operator expects an iterable object on the right side but you are providing an integer.

Either use:

#elif itemVnum in WARP_SCROLLS:
elif itemVnum == WARP_SCROLLS:
	# do smth

Or fix your problem, go in uiToolTip.py and replace:

WARP_SCROLLS=22010

With:

WARP_SCROLLS = (22010, )

 

[Mimoza 4]

1 hour ago, VegaS™ said:

In your case WARP_SCROLLS is the index not the tuple or list that you are searching, because it is non-iterable type, you are getting this error.

m2devList = [1000, 2000, 3000]
for item in m2devList:
	print item

>> 1000
>> 2000
>> 3000

You're attempting to check if 22010 is in itemVnum, which does not make sense.

in smth operator expects an iterable object on the right side but you are providing an integer.

Either use:

#elif itemVnum in WARP_SCROLLS:
elif itemVnum == WARP_SCROLLS:
	# do smth

Or fix your problem, go in uiToolTip.py and replace:

WARP_SCROLLS=22010

With:

WARP_SCROLLS = (22010, )

 

Thanks @VegaS™ and congratulations for where you arrived!!