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 uiScriptLocale

import ui
import mouseModule
import constInfo
from constInfo import Emoji

if app.ENABLE_ACCE_COSTUME_SYSTEM:
	import acce
if app.ENABLE_DS_SET:
	import uiDragonSoul
if app.ENABLE_RENDER_TARGET:
	import uiRenderTarget

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 GetAffectString(affectType, affectValue):
	if 0 == affectType:
		return None
	try:
		return ItemToolTip.AFFECT_DICT[affectType](affectValue)
	except TypeError:
		return "UNKNOWN_VALUE[%s] %s" % (affectType, affectValue)
	except KeyError:
		return "UNKNOWN_TYPE[%s] %s" % (affectType, affectValue)


def SplitDescription(desc, limit):
    total_tokens = desc.split()
    line_tokens = []
    line_len = 0
    lines = []
    is_colored = False

    for token in total_tokens:
        if "|" in token:
            sep_pos = token.find("|")

            line_tokens.append(token[:sep_pos])
            lines.append(" ".join(line_tokens))
            line_tokens = []

            line_tokens.append("|cFFD3936F" + token[sep_pos+1:])
            is_colored = True

        elif is_colored:
            line_tokens.append(token)

        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:
        if is_colored:
            line_tokens.append("|r")
        lines.append(" ".join(line_tokens))

    return lines

###################################################################################################
## ToolTip
##
##
class ToolTip(ui.ThinBoardNew):

	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) #bonus 1-4
	SPECIAL_POSITIVE_COLOR2 = grp.GenerateColor(0.8824, 0.9804, 0.8824, 1.0) #bonus 6-7
	SPECIAL_POSITIVE_COLOR5 = grp.GenerateColor(0.7824, 0.9004, 0.8024, 1.0) #bonus 5
	if app.ENABLE_DS_SET:
		TEXTLINE_2ND_COLOR_DEFAULT = grp.GenerateColor(1.0, 1.0, 0.6078, 1.0)
	if app.BL_67_ATTR:
		ATTR_6TH_7TH_COLOR = -102

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

	TYRANIS_TOOLTIP_COLOR = 0xff5FFFF3
	CHANGELOOK_ITEMNAME_COLOR = 0xffBCE55C
	RENDER_TARGET = 0xff90ee90

	def __init__(self, width = TOOL_TIP_WIDTH, isPickable=False):
		ui.ThinBoardNew.__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.ThinBoardNew.__del__(self)

	if app.ENABLE_SWITCHBOT:
		def SetSwitchBotItem(self, vnum):
			item.SelectItem(vnum)
			self.AppendTextLine(item.GetItemName(), self.SPECIAL_TITLE_COLOR, True)
			self.AppendSpace(5)
			itemDesc = localeInfo.SWITCHBOT_ACTIVE
			self.__AdjustMaxWidth(0, itemDesc)
			self.AppendDescription(itemDesc, 26)

	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

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

					# 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 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 AutoAppendNewTextLineResize(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()
 
		(textWidth, textHeight) = textLine.GetTextSize()
		textWidth += 30
		textHeight += 10
		if self.toolTipWidth < textWidth:
			self.toolTipWidth = textWidth
 
		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.AlignHorizonalCenter()
		return textLine

	def SetThinBoardSize(self, width, height = 12):
		self.toolTipWidth = width 
		self.toolTipHeight = height

	def AlignTextLineHorizonalCenter(self):
		for child in self.childrenList:
			if type(child).__name__ == "TextLine":
				(x, y) = child.GetLocalPosition()
				child.SetPosition(self.toolTipWidth / 2, y)

		self.ResizeToolTip()

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

		self.childrenList.append(textLine)

		(textWidth, textHeight)=textLine.GetTextSize()

		textWidth += 40
		textHeight += 5

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

		# @fixme017 BEGIN (moved after the set of the new width)
		if centerAlign:
			textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
			textLine.SetHorizontalAlignCenter()
		else:
			textLine.SetPosition(10, self.toolTipHeight)
		# @fixme017 END

		self.toolTipHeight += textHeight

		return textLine

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

		self.childrenList.append(textLine)
		(textWidth, textHeight)=textLine.GetTextSize()
		textWidth += 40
		textHeight += 5

		if self.toolTipWidth < textWidth:
			self.toolTipWidth = textWidth
		if centerAlign:
			textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
			textLine.SetHorizontalAlignCenter()
		else:
			textLine.SetPosition(10, self.toolTipHeight)
		self.toolTipHeight += textHeight
		self.ResizeToolTip()
		return textLine

	if app.ENABLE_DS_SET:
		def AppendTwoColorTextLine(self, text, color, text2, color2 = TEXTLINE_2ND_COLOR_DEFAULT, centerAlign = True):
			textLine = ui.TextLine()
			textLine.SetParent(self)
			textLine.SetFontName(self.defFontName)
			textLine.SetPackedFontColor(color)
			textLine.SetText(text)
			textLine.SetOutline()
			textLine.SetFeather(False)
			w, h = textLine.GetTextSize()
			
			textLine2 = ui.TextLine()
			textLine2.SetParent(textLine)
			textLine2.SetFontName(self.defFontName)
			textLine2.SetPackedFontColor(color2)
			textLine2.SetText(text2)
			textLine2.SetOutline()
			textLine2.SetFeather(False)
			textLine2.Show()
			
			w2, h2 = textLine2.GetTextSize()
			if app.WJ_MULTI_TEXTLINE:
				textLine.SetLineHeight(self.TEXT_LINE_HEIGHT)
			textLine.Show()
			if centerAlign:
				if localeInfo.IsARABIC():
					textLine.SetPosition(self.toolTipWidth/2+w2/2, self.toolTipHeight)
					textLine.SetHorizontalAlignCenter()
					textLine2.SetPosition(-w/2, 0)
				else:
					textLine.SetPosition(self.toolTipWidth/2-w2/2, self.toolTipHeight)
					textLine.SetHorizontalAlignCenter()
					textLine2.SetPosition(w/2, 0)
			else:
				textLine.SetPosition(10, self.toolTipHeight)
			
			self.childrenList.append(textLine)
			self.childrenList.append(textLine2)
			
			if app.WJ_MULTI_TEXTLINE:
				lineCount = textLine.GetTextLineCount()
				self.toolTipHeight += self.TEXT_LINE_HEIGHT * lineCount
			else:
				self.toolTipHeight += self.TEXT_LINE_HEIGHT
			
			self.ResizeToolTip()
			return textLine

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

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

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

		self.childrenList.append(textLine)

		if app.WJ_MULTI_TEXTLINE:
			lineCount = textLine.GetTextLineCount()
			self.toolTipHeight += self.TEXT_LINE_HEIGHT * lineCount
		else:
			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):
	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_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,
		item.APPLY_ATTBONUS_CZ : localeInfo.TOOLTIP_APPLY_ATTBONUS_CZ,
		item.APPLY_ATTBONUS_INSECT : localeInfo.TOOLTIP_APPLY_ATTBONUS_INSECT,
		item.APPLY_ATTBONUS_DESERT : localeInfo.TOOLTIP_APPLY_ATTBONUS_DESERT,
		item.APPLY_ATTBONUS_SWORD : localeInfo.TOOLTIP_APPLY_ATTBONUS_SWORD,
		item.APPLY_ATTBONUS_TWOHAND : localeInfo.TOOLTIP_APPLY_ATTBONUS_TWOHAND,
		item.APPLY_ATTBONUS_DAGGER : localeInfo.TOOLTIP_APPLY_ATTBONUS_DAGGER,
		item.APPLY_ATTBONUS_BELL : localeInfo.TOOLTIP_APPLY_ATTBONUS_BELL,
		item.APPLY_ATTBONUS_FAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_FAN,
		item.APPLY_ATTBONUS_BOW : localeInfo.TOOLTIP_APPLY_ATTBONUS_BOW,
		item.APPLY_RESIST_HUMAN : localeInfo.TOOLTIP_APPLY_RESIST_HUMAN,
		item.APPLY_BLEEDING_PCT : localeInfo.TOOLTIP_APPLY_BLEEDING_PCT,
		item.APPLY_BLEEDING_REDUCE : localeInfo.TOOLTIP_APPLY_BLEEDING_REDUCE,
		item.APPLY_ATTBONUS_WOLFMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_WOLFMAN,
		item.APPLY_RESIST_CLAW : localeInfo.TOOLTIP_APPLY_RESIST_CLAW,
		item.APPLY_RESIST_WOLFMAN : localeInfo.TOOLTIP_APPLY_RESIST_WOLFMAN,
		item.APPLY_ATTBONUS_CLAW : localeInfo.TOOLTIP_APPLY_ATTBONUS_CLAW,
		item.APPLY_RESIST_MAGIC_REDUCTION : localeInfo.TOOLTIP_RESIST_MAGIC_REDUCTION,
		item.APPLY_ENCHANT_ELECT : localeInfo.TOOLTIP_APPLY_ENCHANT_ELECT,
		item.APPLY_ENCHANT_FIRE : localeInfo.TOOLTIP_APPLY_ENCHANT_FIRE,
		item.APPLY_ENCHANT_ICE : localeInfo.TOOLTIP_APPLY_ENCHANT_ICE,
		item.APPLY_ENCHANT_WIND : localeInfo.TOOLTIP_APPLY_ENCHANT_WIND,
		item.APPLY_ENCHANT_EARTH : localeInfo.TOOLTIP_APPLY_ENCHANT_EARTH,
		item.APPLY_ENCHANT_DARK : localeInfo.TOOLTIP_APPLY_ENCHANT_DARK,
		item.APPLY_ATTBONUS_BOSS : localeInfo.TOOLTIP_NORMAL_HIT_DAMAGE_BONUS_BOSS_OR_MORE,
		item.APPLY_RESIST_MONSTER : localeInfo.TOOLTIP_APPLY_MONSTER_DEFEND_BONUS,
		item.APPLY_RESIST_BOSS : localeInfo.TOOLTIP_NORMAL_HIT_DEFEND_BONUS_BOSS_OR_MORE,
		item.APPLY_CRITICAL_DAMAGE_PVM : localeInfo.TOOLTIP_CRITICAL_DAMAGE,
		item.APPLY_RESIST_RACES : localeInfo.TOOLTIP_ALL_RACES,
		item.APPLY_ATTBONUS_STONE : localeInfo.TOOLTIP_ATTBONUS_STONE,
		item.APPLY_ATTBONUS_DUNGEON : localeInfo.TOOLTIP_ATTBONUS_DUNGEON,
		item.APPLY_PARTY_ATTACKER_BONUS : localeInfo.PARTY_BONUS_ATTACKER,
		item.APPLY_PARTY_HASTE_BONUS : localeInfo.PARTY_BONUS_BERSERKER,
		item.APPLY_PARTY_TANKER_BONUS : localeInfo.PARTY_BONUS_TANKER,
		item.APPLY_PARTY_DEFENDER_BONUS : localeInfo.PARTY_BONUS_DEFENDER,
		item.APPLY_PARTY_BUFFER_BONUS : localeInfo.PARTY_BONUS_BUFFER,
		item.APPLY_PARTY_SKILL_MASTER_BONUS : localeInfo.PARTY_BONUS_SKILL_MASTER,
		item.APPLY_RESIST_NORMAL_DAMAGE : localeInfo.SKILL_MELEE_BUFF,
	}
	
	POINT_DICT = {item.GetApplyPoint(affect): name for affect, name in AFFECT_DICT.items()}

	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,
	}
	if app.ENABLE_WOLFMAN_CHARACTER:
		ANTI_FLAG_DICT.update({
			4 : item.ITEM_ANTIFLAG_WOLFMAN,
		})

	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.metinSlot = []
		self.isShopItem = False
		if app.ENABLE_OFFLINESHOP_SYSTEM:
			self.isOfflineShopItem = False
		if app.ENABLE_DS_SET:
			self.interface = None

		self.bCannotUseItemForceSetDisableColor = True

	def __del__(self):
		ToolTip.__del__(self)
		self.metinSlot = None

	if app.ENABLE_DS_SET:
		def BindInterface(self, interface):
			from _weakref import proxy
			self.interface = proxy(interface)

	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)

	if app.ENABLE_OFFLINESHOP_SYSTEM:
		def SetOfflineShopBuilderItem(self, invenType, invenPos, offlineShopIndex):
			self.ClearToolTip()
			itemVnum = player.GetItemIndex(invenType, invenPos)
			if (itemVnum == 0):
				return
			item.SelectItem(itemVnum)
			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,0,0,invenType,invenPos)
			price = shop.GetOfflineShopItemPriceReal(invenType, invenPos)
			if price > 0:
				self.AppendOfflineShopPrice(price, player.GetItemCount(invenType, invenPos))

		def SetOfflineShopItem(self, slotIndex):
			itemVnum = shop.GetOfflineShopItemID(slotIndex)
			if (itemVnum == 0):
				return
			price = shop.GetOfflineShopItemPrice(slotIndex)
			self.ClearToolTip()
			metinSlot = []
			for i in xrange(player.METIN_SOCKET_MAX_NUM):
				metinSlot.append(shop.GetOfflineShopItemMetinSocket(slotIndex, i))
			attrSlot = []
			for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
				attrSlot.append(shop.GetOfflineShopItemAttribute(slotIndex, i))

			self.AddItemData(itemVnum, metinSlot, attrSlot, 0, 0, player.INVENTORY, -1)

			if price > 0:
				self.AppendOfflineShopPrice(price, shop.GetOfflineShopItemCount(slotIndex))
			
			if shop.GetOfflineShopItemStatus(slotIndex) == 1:
				self.AppendTextLine(localeInfo.OFFLINE_SHOP_ITEM_SOLD, self.DISABLE_COLOR)
				self.AppendTextLine(localeInfo.OFFLINE_SHOP_ITEM_SOLD2 % (shop.GetOfflineShopItemBuyerName(slotIndex)), self.DISABLE_COLOR)
		
		def SetOfflineShopItemPanel(self, slotIndex):
			itemVnum = shop.GetOfflineShopItemID(slotIndex)
			if (itemVnum == 0):
				return
			price = shop.GetOfflineShopItemPrice(slotIndex)
			self.ClearToolTip()
			metinSlot = []
			for i in xrange(player.METIN_SOCKET_MAX_NUM):
				metinSlot.append(shop.GetOfflineShopItemMetinSocket(slotIndex, i))
			attrSlot = []
			for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
				attrSlot.append(shop.GetOfflineShopItemAttribute(slotIndex, i))

			self.AddItemData(itemVnum, metinSlot, attrSlot, 0, 0, player.INVENTORY, -1)

			if price > 0:
				self.AppendOfflineShopPrice(price, shop.GetOfflineShopItemCount(slotIndex))
			
			if shop.GetOfflineShopItemStatus(slotIndex) == 1:
				self.AppendTextLine(localeInfo.OFFLINE_SHOP_ITEM_SOLD, self.DISABLE_COLOR)
				self.AppendTextLine(localeInfo.OFFLINE_SHOP_ITEM_SOLD2 % (shop.GetOfflineShopItemBuyerName(slotIndex)), self.DISABLE_COLOR)
		
			self.AppendSpace(3)
			self.AppendTextLine("{} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/lmb|e", localeInfo.CHANGE_PRICE), self.CAN_LEVEL_UP_COLOR)

		def AppendOfflineShopPrice(self, price, count):	
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.TOOLTIP_BUYPRICE  % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
			if count > 1:
				self.AppendSpace(5)
				self.AppendTextLine(localeInfo.TOOLTIP_BUYUNITPRICE  % (localeInfo.NumberToMoneyString(price / count)))

	if app.BL_MOVE_COSTUME_ATTR:
		def SetResulItemAttrMove(self, baseSlotIndex, materialSlotIndex, window_type = player.INVENTORY):
			baseItemVnum = player.GetItemIndex(window_type, baseSlotIndex)
			
			if 0 == baseItemVnum:
				return

			materialItemVnum = player.GetItemIndex(window_type, materialSlotIndex)
			
			if 0 == materialItemVnum:
				return
				
			self.ClearToolTip()

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

			self.AddItemData(baseItemVnum, metinSlot, attrSlot)

	def SetInventoryItem(self, slotIndex, window_type = player.INVENTORY, wndDragonSoulWindow = False):
		if app.ENABLE_DS_SET:
			self.window_type = window_type
		self.wndDragonSoulWindow = wndDragonSoulWindow

		itemVnum = player.GetItemIndex(window_type, slotIndex)
		itemCount = player.GetItemCount(window_type, slotIndex)


		if 0 == itemVnum:
			return

		self.ClearToolTip()
		if shop.IsOpen() or 80008 == itemVnum:
			if not shop.IsPrivateShop():
				self.AppendSellingPrice(5*(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, 0, 0, self.window_type, slotIndex, self.wndDragonSoulWindow)
		
		item.SelectItem(itemVnum)
		itemType = item.GetItemType()
		itemSubType = item.GetItemSubType()

		countForStack = 250 if itemCount > 250 else itemCount

		self.interface = constInfo.GetInterfaceInstance()
		if self.interface.dlgOfflineShopPanel:
			if self.interface.dlgOfflineShopPanel.IsShow():
				self.AppendSpace(5)
				self.AppendTextLine("{} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/rmb|e", localeInfo.ADD_TO_SAME_PRICE), self.CAN_LEVEL_UP_COLOR)
			else:
				self.AppendSpace(3)
				self.AppendTextLine("{} + {} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/shift|e","|Eemoji/rmb|e", localeInfo.PARTY_MATCH_SEARCHING), self.CAN_LEVEL_UP_COLOR)
				self.AppendSpace(3)
				self.AppendTextLine("{} + {} {}".format("|Eemoji/alt|e","|Eemoji/rmb|e", "Wiki"), self.CAN_LEVEL_UP_COLOR)
		else:
			self.AppendSpace(3)
			self.AppendTextLine("{} + {} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/shift|e","|Eemoji/rmb|e", localeInfo.PARTY_MATCH_SEARCHING), self.CAN_LEVEL_UP_COLOR)
			self.AppendSpace(3)
			self.AppendTextLine("{} + {} {}".format("|Eemoji/alt|e","|Eemoji/rmb|e", "Wiki"), self.CAN_LEVEL_UP_COLOR)
			if itemType == item.ITEM_TYPE_GIFTBOX:
				self.AppendSpace(3)
				self.AppendTextLine("{} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/rmb|e",localeInfo.OPEN_MULTIPLE+" x"+ str(countForStack) if countForStack > 1 else localeInfo.OPEN_MULTIPLE))
			if self.interface.dlgExchange and self.interface.dlgExchange.IsShow():
				self.AppendSpace(3)
				self.AppendTextLine("{} {}".format("|Eemoji/rmb|e", localeInfo.TARGET_BUTTON_EXCHANGE), self.CAN_LEVEL_UP_COLOR)
			if constInfo.IS_BLEND_POTION(itemVnum):
				self.AppendSpace(3)
				self.AppendTextLine("{} + {} {}".format("|Eemoji/ctrl|e", "|Eemoji/i|e", localeInfo.USE_DEWS_MULTIPLE), self.CAN_LEVEL_UP_COLOR)		

	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)
		self.AppendSpace(5)
		self.AppendTextLine("{} + {} {}".format("|Eemoji/ctrl|e","|Eemoji/rmb|e", localeInfo.PICK_ITEM_TITLE), self.CAN_LEVEL_UP_COLOR)

	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)

	if app.ENABLE_SHOPEX_RENEWAL:
		def SetShopItemByShopEx(self, slotIndex, type):
			itemVnum = shop.GetItemID(slotIndex)
			PriceVnum = shop.GetItemPriceVnum(slotIndex)
			PriceVnum1 = shop.GetItemPriceVnum1(slotIndex)
			PriceVnum2 = shop.GetItemPriceVnum2(slotIndex)
			PriceVnum3 = shop.GetItemPriceVnum3(slotIndex)
			PriceVnum4 = shop.GetItemPriceVnum4(slotIndex)

			if 0 == itemVnum:
				return

			if PriceVnum == 0 and type == 3:
				return

			price = shop.GetItemPrice(slotIndex)
			price1 = shop.GetItemPrice1(slotIndex)
			price2 = shop.GetItemPrice2(slotIndex)
			price3 = shop.GetItemPrice3(slotIndex)
			price4 = shop.GetItemPrice4(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.AppendSpace(5)

			if type == 3:
				self.AppendTextLine(localeInfo.MONEY_INPUT_DIALOG_SELLPRICE)
				self.AppendSpace(5)
				self.AddShopEXItem(PriceVnum, price)
				if PriceVnum1>0:
					self.AppendSpace(13)
					self.AddShopEXItem(PriceVnum1, price1)
				if PriceVnum2>0:
					self.AppendSpace(13)
					self.AddShopEXItem(PriceVnum2, price2)
				if PriceVnum3>0:
					self.AppendSpace(13)
					self.AddShopEXItem(PriceVnum3, price3)
				if PriceVnum4>0:
					self.AppendSpace(13)
					self.AddShopEXItem(PriceVnum4, price4)
			else:
				self.AppendTextLineDontCheckColor(localeInfo.TOOLTIP_BUYPRICE % (localeInfo.NumberToShopEXP(price)), self.GetPriceColor(price))

		def AddShopEXItem(self, itemVnum, price):
			item.SelectItem(itemVnum)
			have_count = player.GetItemCountByVnum(itemVnum)
			if have_count >= price:
				name = "%s x |E%s|e %s |cff418c0b(%s)|r" % (localeInfo.NumberToGemString(price), item.GetIconImageFileName(), item.GetItemName(), have_count)
			else:
				name = "%s x |E%s|e %s |cffad3603(%s)|r" % (localeInfo.NumberToGemString(price), item.GetIconImageFileName(), item.GetItemName(), have_count)
			self.AutoAppendTextLine(name)
			self.ResizeToolTip()

	def AppendTextLineDontCheckColor(self, text, color = FONT_COLOR, centerAlign = True):
		return ToolTip.AppendTextLine(self, text, color, centerAlign)


	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)

	if app.ENABLE_WIKI:
		def SetItemToolTipWiki(self, itemVnum):
			self.itemVnum = itemVnum
			item.SelectItem(itemVnum)
			metinSlot = [0 for i in xrange(player.METIN_SOCKET_MAX_NUM)]
			attrSlot = [(0,0) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
			for i in xrange(item.LIMIT_MAX_NUM):
				(limitType, limitValue) = item.GetLimit(i)
				if item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
					metinSlot[0] = limitValue
				elif item.LIMIT_REAL_TIME == limitType or item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
					metinSlot[0] = app.GetGlobalTimeStamp()+limitValue
			self.SetTitle(item.GetItemName())
			self.AppendDescription(item.GetItemDescription(), 26)
			self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary4(), 26, self.CONDITION_COLOR)
			self.__AppendAffectInformation()
			self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
			self.AppendWearableInformation()
			for i in xrange(item.LIMIT_MAX_NUM):
				(limitType, limitValue) = item.GetLimit(i)
				if item.LIMIT_REAL_TIME == limitType:
					if metinSlot[0] > 0:
						self.AppendMallItemLastTime(metinSlot[0])
					break
			self.ShowToolTip()

	def SetItemToolTip(self, itemVnum, raceVnum = 0):
		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, 0, 0, player.INVENTORY, -1, 0, raceVnum)

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

	if app.ENABLE_ACCE_COSTUME_SYSTEM:
		def CalcAcceValue(self, value, abs):
			if not value:
				return 0

			valueCalc = int((round(value * abs) / 100))
			if valueCalc <= 0 and value > 0:
				value = 1
			else:
				value = valueCalc

			return value

		def CalcAcceValue2(self, value, abs):
			if not value:
				return 0

			valueCalc = int((round(value * abs) / 100)) + int(int((round(value * abs) / 100)) > 0)
			if valueCalc <= 0 and value > 0:
				value = 1
			else:
				value = valueCalc
			return value

	if app.ENABLE_ACCE_COSTUME_SYSTEM:
		def __AppendAttackPowerInfo(self, itemAbsChance = 0):
			minPower = item.GetValue(3)
			maxPower = item.GetValue(4)
			addPower = item.GetValue(5)

			if itemAbsChance:
				minPower = self.CalcAcceValue2(minPower, itemAbsChance)
				maxPower = self.CalcAcceValue2(maxPower, itemAbsChance)
				addPower = self.CalcAcceValue2(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)
	else:
		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)

	if app.ENABLE_ACCE_COSTUME_SYSTEM:
		def __AppendMagicAttackInfo(self, itemAbsChance = 0):
			minMagicAttackPower = item.GetValue(1)
			maxMagicAttackPower = item.GetValue(2)
			addPower = item.GetValue(5)

			if app.ENABLE_ACCE_COSTUME_SYSTEM:
				if itemAbsChance != 0:
					minMagicAttackPower = self.CalcAcceValue2(minMagicAttackPower, itemAbsChance)
					maxMagicAttackPower = self.CalcAcceValue2(maxMagicAttackPower, itemAbsChance)
					addPower			= self.CalcAcceValue2(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)
	else:
		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)

	if app.ENABLE_ACCE_COSTUME_SYSTEM:
		def __AppendMagicDefenceInfo(self, itemAbsChance = 0):
			magicDefencePower = item.GetValue(0)

			if itemAbsChance:
				magicDefencePower = self.CalcAcceValue2(magicDefencePower, itemAbsChance)

			if magicDefencePower > 0:
				self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_DEF_POWER % magicDefencePower, self.GetChangeTextLineColor(magicDefencePower))
	else:
		def __AppendMagicDefenceInfo(self):
			magicDefencePower = item.GetValue(0)

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

	def __IsItemShopItem(self, vnum):
		if 506034 == vnum or 506035 == vnum or 506036 == vnum or 506037 == vnum or\
		506038 == vnum or 506039 == vnum or 506040 == vnum or 506041 == vnum or\
		506042 == vnum or 506043 == vnum or 506044 == vnum or 506045 == vnum:
			return True
		return False

	if app.ENABLE_ACCE_COSTUME_SYSTEM:
		def __AppendAttributeInformation(self, attrSlot, itemAbsChance = 0, vnum = 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)

					if item.GetItemType() == item.ITEM_TYPE_COSTUME and item.GetItemSubType() == item.COSTUME_TYPE_ACCE and itemAbsChance:
						value = self.CalcAcceValue(value, itemAbsChance)
						affectString = self.__GetAffectString(type, value)

					if affectString:
						affectColor = self.__GetAttributeColor(i, value)
						self.AppendTextLine(affectString, self.POSITIVE_COLOR if self.__IsItemShopItem(vnum) else affectColor)
	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 affectString:
						affectColor = self.__GetAttributeColor(i, value)
						self.AppendTextLine(affectString, affectColor)

	if app.ENABLE_DS_SET:
		def __AppendDragonSoulAttributeInformation(self, attrSlot, dsType = 0, grade = 0):
			if 0 != attrSlot:
				if grade != 0:
					setWeightValue = item.GetDSSetWeight(dsType, grade)
					basicApplyCount = item.GetDSBasicApplyCount(dsType, grade)
					
					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 affectString:
							affectColor = self.__GetAttributeColor(i, value)
							
							setValue = 0
							if i < basicApplyCount:
								setValue = item.GetDSBasicApplyValue(dsType, type)
							else:
								setValue = item.GetDSAdditionalApplyValue(dsType, type)
							
							if setValue != 0:
								setValue = (setValue * setWeightValue - 1)/100 + 1
								if affectString.find('%') == -1:
									self.AppendTwoColorTextLine(affectString, affectColor, " (+%d)" % (setValue))
								else:
									self.AppendTwoColorTextLine(affectString, affectColor, " (+%d%%)" % (setValue))
							else:
								self.AppendTextLine(affectString, affectColor)
				else:
					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 affectString:
							affectColor = self.__GetAttributeColor(i, value)
							self.AppendTextLine(affectString, affectColor)

	def __GetAttributeColor(self, index, value):
		if value > 0:
			if index >= player.ATTRIBUTE_SLOT_RARE_START and index < player.ATTRIBUTE_SLOT_RARE_END:
				return self.SPECIAL_POSITIVE_COLOR2
			else:
				if index == player.ATTRIBUTE_SLOT_NORM_END:
					return self.SPECIAL_POSITIVE_COLOR5
				else:
					return self.SPECIAL_POSITIVE_COLOR
		elif value == 0:
			return self.NORMAL_COLOR
		else:
			return self.NEGATIVE_COLOR

	if app.BL_67_ATTR:
		def AppendAttribute6th7thPossibility(self, attrSlot):
			if attrSlot == 0:
				return

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

				if 0 == type or 0 == value:
					continue

				count += 1

			if (5 <= count <= 6):
				self.AppendTextLine(localeInfo.ATTR_6TH_7TH_POSSIBILITY, self.ATTR_6TH_7TH_COLOR)

	def __IsPolymorphItem(self, itemVnum):
		if itemVnum >= 70103 and itemVnum <= 70107:
			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, raceVnum):
		if app.ENABLE_SEND_TARGET_INFO:
			if self.isStone:
				itemName = item.GetItemName()
				realName = itemName[:itemName.find("+")]
				if raceVnum == 1192:
					self.SetTitle(realName + " +5")
				else:
					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, raceVnum = -1):
		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

		if raceVnum != -1:
			self.__SetNormalItemTitle(raceVnum)

	if app.ENABLE_RENDER_TARGET:
		def __AppendRenderTarget(self, itemVnum):
			if uiRenderTarget.IsCanShowItems(itemVnum):
				self.AppendSpace(5)
				self.AppendTextLine("{} {}".format("|Eemoji/shift|e + |Eemoji/lmb|e -", uiScriptLocale.OPTION_TARGET_BOARD_VIEW), self.POSITIVE_COLOR)

	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

	if app.__RENEWAL_CRYSTAL__:
		def CrystalTimeCalculate(self, time):
			if time <= 0:
				return "0 " + localeInfo.SECOND
			second = int(time % 60)
			minute = int((time / 60) % 60)
			hour = int((time / 60) / 60) % 24
			day = int(int((time / 60) / 60) / 24)
			text = ""
			if day > 0:
				text += str(day) + localeInfo.DAY
				text += " "
			if hour > 0:
				text += str(hour) + " " + localeInfo.HOUR
				text += " "
			if minute > 0:
				text += str(minute) + " " + localeInfo.MINUTE
				text += " "
			if second > 0:
				text += str(second) + " " + localeInfo.SECOND
			return text
		def AppendCrystalLastTime(self, endTime):
			leftSec = max(0, endTime - app.GetGlobalTimeStamp())
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.LEFT_TIME + " : " + self.CrystalTimeCalculate(leftSec), self.NORMAL_COLOR)
		def CheckCrystalAttr(self, itemIdx, attrSlot):
			isCrystal = True if itemIdx >= 51010 and itemIdx <= 51035 else False
			if isCrystal:
				LEVEL_RANGE = 5
				attrSlot = [(0, 0) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
				refineLevel = itemIdx - 51010
				m_AffectList = [[item.APPLY_ATTBONUS_MONSTER, 10], [item.APPLY_MAX_HP, 2000], [item.APPLY_ATTBONUS_HUMAN, 10], [item.APPLY_ATTBONUS_STONE, 10], [item.APPLY_ATTBONUS_ANIMAL, 10]]
				for i in xrange(len(m_AffectList)):
					bonusStartLevel = 1 + (i * LEVEL_RANGE);
					if refineLevel >= bonusStartLevel:
						bonusLevel = LEVEL_RANGE if refineLevel >= bonusStartLevel + (LEVEL_RANGE-1) else LEVEL_RANGE - ((bonusStartLevel + (LEVEL_RANGE-1)) - refineLevel);
						attrSlot[i] = (m_AffectList[i][0], bonusLevel * (m_AffectList[i][1]/LEVEL_RANGE))
			return attrSlot

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

		if app.__RENEWAL_CRYSTAL__:
			attrSlot = self.CheckCrystalAttr(itemVnum, attrSlot)

		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, window_type = player.INVENTORY, slotIndex = -1, isDragonSoulWindow = 0, raceVnum = 0):
		self.itemVnum = itemVnum
		self.metinSlot = metinSlot

		item.SelectItem(itemVnum)
		itemType = item.GetItemType()
		itemSubType = item.GetItemSubType()

		if not item.GetItemDescription():
			self.__CalculateToolTipWidth()

		if itemVnum == 80020:
			self.SetTitle("BETA TESTING - LOTTERY TICKET")
			self.AppendDescription("Item used during beta period to win prizes. Every ticket means an entry in the lottery. Prizes : 5x 50 EURO", 26)

			self.AdditionalTips(window_type, itemVnum, metinSlot, slotIndex)
			self.ShowToolTip()
			return 
		
		if 50026 == itemVnum:
			if 0 != metinSlot:
				name = item.GetItemName()
				if metinSlot[0] > 0:
					name += " "
					name += localeInfo.NumberToMoneyString(metinSlot[0])
			self.SetTitle(name)
			self.__AppendSealInformation(window_type, slotIndex) ## cyh itemseal 2013 11 11
			self.AdditionalTips(window_type, itemVnum, metinSlot, slotIndex)
			self.ShowToolTip()
			return

		if 50011 == itemVnum or 506024 == itemVnum or 506025 == itemVnum or 79505 == itemVnum or 79506 == itemVnum\
			or itemVnum == 50267 or itemVnum == 50268 or itemVnum == 50269:	
			self.SetTitle(item.GetItemName())
			self.__AppendLimitInformation()
			self.AppendEventTime(metinSlot[0])
			self.AppendDescription(item.GetItemDescription(), 26)
			self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary4(), 26, self.CONDITION_COLOR)

			self.__AppendSealInformation(window_type, slotIndex) ## cyh itemseal 2013 11 11

			self.AdditionalTips(window_type, itemVnum, metinSlot, slotIndex)

			self.ShowToolTip()		
			return 
		
		### Skill Book ###
		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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
					self.AppendDescription(item.GetItemSummary4(), 26, self.CONDITION_COLOR)
					self.ShowToolTip()
				return

		###########################################################################################


		itemDesc = item.GetItemDescription()
		itemSummary = item.GetItemSummary()
		itemSummary2 = item.GetItemSummary2()
		itemSummary3 = item.GetItemSummary3()
		itemSummary4 = item.GetItemSummary4()

		isCostumeItem = 0
		isCostumeHair = 0
		isCostumeBody = 0
		if app.ENABLE_MOUNT_COSTUME_SYSTEM:
			isCostumeMount = 0
		if app.ENABLE_ACCE_COSTUME_SYSTEM:
			isCostumeAcce = 0
		if app.ENABLE_WEAPON_COSTUME_SYSTEM:
			isCostumeWeapon = 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
				if app.ENABLE_MOUNT_COSTUME_SYSTEM:
					isCostumeMount = item.COSTUME_TYPE_MOUNT == itemSubType
				if app.ENABLE_ACCE_COSTUME_SYSTEM:
					isCostumeAcce = item.COSTUME_TYPE_ACCE == itemSubType
				if app.ENABLE_WEAPON_COSTUME_SYSTEM:
					isCostumeWeapon = item.COSTUME_TYPE_WEAPON == itemSubType

				#dbg.TraceError("IS_COSTUME_ITEM! body(%d) hair(%d)" % (isCostumeBody, isCostumeHair))

		self.__AdjustMaxWidth(attrSlot, itemDesc)
		self.__SetItemTitle(itemVnum, metinSlot, attrSlot, raceVnum)

		### Hair Preview Image ###
		if self.__IsHair(itemVnum):
			self.__AppendHairIcon(itemVnum)

		if metinSlot[4] == 99:
			self.AppendDescription(localeInfo.EXCHANGE_CANNOT_GIVE, 26, 0xFFFF0000)

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

		if app.__BUFFI_SUPPORT__:
			if itemType == item.ITEM_TYPE_BUFFI:
				if item.BUFFI_SCROLL == itemSubType:
					self.__AdjustMaxWidth(attrSlot, localeInfo.BUFFI_TOOLTIP_INFO)
					self.AppendSpace(5)
					self.AppendTextLine("|Eitem/61030|e", 0xFFFF5C5C)
					for i in xrange(item.LIMIT_MAX_NUM):
						(limitType, limitValue) = item.GetLimit(i)
						if item.LIMIT_REAL_TIME == limitType:
							self.AppendMallItemLastTime(metinSlot[0])
							break

		if app.ENABLE_NEW_PET_SYSTEM:
			if itemType == item.ITEM_TYPE_PET and itemSubType == 0:
				level = metinSlot[1]
				if level > 0:
					curPoint = metinSlot[2]
					if level >= 120:
						maxPoint = 2500000000
					else:
						maxPoint = constInfo.exp_table[level]
					curPoint = min(curPoint, maxPoint)
					curPoint = max(curPoint, 0)
					maxPoint = max(maxPoint, 0)

					self.AppendTextLine("Lv. %d"%level,self.SPECIAL_POSITIVE_COLOR)
					age_text = [localeInfo.PET_GUI_YOUNG, localeInfo.PET_GUI_WILD, localeInfo.PET_GUI_BRAVE, localeInfo.PET_GUI_HERO]
					self.AppendTextLine("%s : %s"%(localeInfo.PET_GUI_AGE,age_text[metinSlot[3]]),self.SPECIAL_POSITIVE_COLOR)

					self.AppendSpace(5)

					pet_bonus_types=[item.APPLY_MAX_HP,item.APPLY_ATTBONUS_MONSTER,item.APPLY_CRITICAL_DAMAGE_PVM]
					pet_bonus_value=[4000,20,10]
					for j in xrange(3):
						ptr = metinSlot[5+j]
						
						bonusLevel = constInfo.FindPetBonusLevel(ptr)
						(first, second) = constInfo.FindPetBonusLevelLast(ptr)

						bonus_value = pet_bonus_value[j] if bonusLevel == 20 else float(float(pet_bonus_value[j])/20.0) * bonusLevel

						text = GetAffectString(pet_bonus_types[j],int(bonus_value))
						text = text.replace(":","")
						index = text.find("+")
						if index == -1:
							index = text.find("%")
							if index == -1:
								index =0
						if not index  <= 0:
							new_text = text[:index]
							new_text += " (Lv %d - %s)"%(bonusLevel, text[index:])
							self.AppendTextLine(new_text,self.TYRANIS_TOOLTIP_COLOR)
						else:
							new_text = text
							new_text += " (Lv %d - +%d)"%(bonusLevel, int(bonus_value))
							self.AppendTextLine(new_text,self.TYRANIS_TOOLTIP_COLOR)

					self.AppendSpace(5)
					for j in xrange(len(attrSlot)):
						if attrSlot[j][0] == 0 or attrSlot[j][0] == 99:
							continue
						self.AppendTextLine(constInfo.pet_skill_data[attrSlot[j][0]][0]+"(Lv"+str(attrSlot[j][1])+")",self.SPECIAL_TITLE_COLOR)

					self.AppendSpace(5)
					self.AppendTextLine(localeInfo.LEFT_TIME+ ": "+localeInfo.SecondToDHMS(metinSlot[0]-app.GetGlobalTimeStamp()),self.SPECIAL_POSITIVE_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, 0, itemVnum)
			if app.BL_67_ATTR:
				self.AppendAttribute6th7thPossibility(attrSlot)

			self.AppendWearableInformation()

			if app.ENABLE_QUIVER_SYSTEM and item.WEAPON_QUIVER == itemSubType:
				self.AppendLastTimeInformation(metinSlot)
			else:
				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, 0, itemVnum)
			if 10790 == itemVnum or 10791 == itemVnum:
				pass
			else:
				if app.BL_67_ATTR:
					self.AppendAttribute6th7thPossibility(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, 0, itemVnum)

			#self.__AppendAccessoryMetinSlotInfo(metinSlot, 99001)


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

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

		elif isCostumeItem:
			self.__AppendLimitInformation()
			if app.ENABLE_ACCE_COSTUME_SYSTEM:
				if item.GetItemSubType() == item.COSTUME_TYPE_ACCE:
					## ABSORPTION RATE
					absChance = int(metinSlot[acce.ABSORPTION_SOCKET])
					self.AppendTextLine(localeInfo.TOOLTIP_APPLY_ACCEDRAIN_RATE(absChance), self.CONDITION_COLOR)
					## END ABSOPRTION RATE

					itemAbsorbedVnum = int(metinSlot[acce.ABSORBED_SOCKET])
					if itemAbsorbedVnum:
						## ATTACK / DEFENCE
						item.SelectItem(itemAbsorbedVnum)
						if item.GetItemType() == item.ITEM_TYPE_WEAPON:
							if item.GetItemSubType() == item.WEAPON_FAN:
								self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
								item.SelectItem(itemAbsorbedVnum)
								self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
							else:
								self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
								item.SelectItem(itemAbsorbedVnum)
								self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
						elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
							defGrade = item.GetValue(1)
							defBonus = item.GetValue(5) * 2
							defGrade = self.CalcAcceValue2(defGrade, metinSlot[acce.ABSORPTION_SOCKET])
							defBonus = self.CalcAcceValue2(defBonus, metinSlot[acce.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[acce.ABSORPTION_SOCKET])
						## END ATTACK / DEFENCE

						## EFFECT
						item.SelectItem(itemAbsorbedVnum)
						for i in xrange(item.ITEM_APPLY_MAX_NUM):
							(affectType, affectValue) = item.GetAffect(i)
							affectValue = self.CalcAcceValue(affectValue, metinSlot[acce.ABSORPTION_SOCKET])
							affectString = self.__GetAffectString(affectType, affectValue)
							if affectString and affectValue > 0:
								self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

							item.SelectItem(itemAbsorbedVnum)
						# END EFFECT

						item.SelectItem(itemVnum)
						self.__AppendAttributeInformation(attrSlot, metinSlot[acce.ABSORPTION_SOCKET], itemVnum)

						self.AppendTextLine("[{}]".format(uiScriptLocale.AURA_SUB), self.CHANGELOOK_ITEMNAME_COLOR)
						self.AppendTextLine(item.GetItemNameByVnum(metinSlot[1]), self.CHANGELOOK_ITEMNAME_COLOR)

					else:
						self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
				else:
					self.__AppendAffectInformation()
					self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
			else:
				self.__AppendAffectInformation()
				self.__AppendAttributeInformation(attrSlot, 0, itemVnum)


			self.AppendWearableInformation()
			self.AppendLastTimeInformation(metinSlot)

		## 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.ATTR_6TH_7TH_COLOR)

				if app.ENABLE_EXTENDED_BLEND_AFFECT:
					status = metinSlot[3]

					self.AppendSpace(10)
					if status != 0:
						self.AppendTextLine(localeInfo.BLEND_ITEM_TOOLTIP_APPLY, 0xff86e57f) # RGB(134, 229, 127)
					else:
						self.AppendTextLine(localeInfo.BLEND_ITEM_TOOLTIP_UNAPPLIED, 0xfff15f5f) # RGB(241, 95, 95)

					self.AppendSpace(5)
					if time > item.MIN_INFINITE_DURATION:
						self.AppendTextLine(localeInfo.INFINITE_USE, self.CONDITION_COLOR)
					else:
						if time > 0:
							endTime = app.GetGlobalTimeStamp() + time
							leftSec = max(0, endTime - app.GetGlobalTimeStamp())

							self.AppendTextLine(localeInfo.TIME_STACKEBLE_INFO, self.SPECIAL_POSITIVE_COLOR)
							self.AppendSpace(5)
							self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(leftSec), self.NORMAL_COLOR)
						else:
							self.AppendTextLine(localeInfo.BLEND_ITEM_TOOLTIP_NO_TIME)
				else:
					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)
					# [MT-489] ???? ?? ?? ??
					#else:
					#	self.AppendTextLine(localeInfo.BLEND_POTION_NO_TIME)
			else:
				self.AppendTextLine("BLEND_POTION_NO_INFO")

		elif item.ITEM_TYPE_UNIQUE == itemType:
			self.__AppendLimitInformation()
			self.__AppendAffectInformation()
			self.__AppendAttributeInformation(attrSlot, 0, itemVnum)

			if 0 != metinSlot:
				if app.__TIME_STACKEBLE__:
					if item.IsFlag(item.ITEM_FLAG_TIME_STACKEBLE):
						self.AppendTextLine(localeInfo.TIME_STACKEBLE_INFO, self.SPECIAL_POSITIVE_COLOR)
						self.AppendSpace(5)
				if not self.AppendLastTimeInformation(metinSlot):
					time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]

					if 1 == item.GetValue(2):
						self.AppendMallItemLastTime(time)
					else:
						self.AppendUniqueItemLastTime(time)

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

			if app.ENABLE_SPECIAL_COSTUME_ATTR:
				if itemVnum >= 401001 and itemVnum <= 403019:
					if item.GetValue(0) != 0:
						self.AppendSpace(5)
						affectString = self.__GetAffectString(item.GetValue(0), item.GetValue(1))
						if affectString:
							affectColor = self.__GetAttributeColor(0, item.GetValue(1))
							self.AppendTextLine("Bonus: "+affectString, affectColor)

			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:
					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)
						
			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:
				if not self.AppendLastTimeInformation(metinSlot):
					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:
				if metinSlot[2]:
					self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(metinSlot[2]))
				else:
					self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(item.GetValue(0)))

				self.AppendLastTimeInformation(metinSlot)

			elif item.USE_TIME_CHARGE_FIX == itemSubType:
				if metinSlot[2]:
					self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(metinSlot[2]))
				else:
					self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(item.GetValue(0)))

				self.AppendLastTimeInformation(metinSlot)

		elif item.ITEM_TYPE_QUEST == itemType:
			if app.__SASH_SKIN__:
				if itemVnum >= 67001 and itemVnum <= 67010:
					self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
			self.__AppendLimitInformation()
			if app.__RENEWAL_CRYSTAL__:
				if itemVnum >= 51010 and itemVnum <= 51035:
					self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
					self.AppendCrystalLastTime(metinSlot[1] if metinSlot[1] > 60 * 60 * 24 * 7 else metinSlot[1] + app.GetGlobalTimeStamp())

			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))
			if app.ENABLE_DS_SET and True == isDragonSoulWindow:
				if window_type == player.INVENTORY and self.interface and self.interface.wndDragonSoul:
					self.__AppendDragonSoulAttributeInformation(attrSlot, itemVnum/10000, self.interface.wndDragonSoul.GetDSSetGrade())
				else:
					self.__AppendDragonSoulAttributeInformation(attrSlot)
			else:
				self.__AppendAttributeInformation(attrSlot, 0, itemVnum)
		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.__AppendSealInformation(window_type, slotIndex) ## cyh itemseal 2013 11 11

		self.AdditionalTips(window_type, itemVnum, metinSlot, slotIndex)
		self.ShowToolTip()

		if app.ENABLE_RENDER_TARGET:
			self.__AppendRenderTarget(itemVnum)

	def HAS_FLAG(value, flag):
		return (value & flag) == flag

	def AdditionalTips(self, window_type, itemVnum, metinSlot, slotIndex):
		item.SelectItem(itemVnum)
		itemType = item.GetItemType()
		itemSubType = item.GetItemSubType()

		self.AppendAntiflagInformation()

		if chr.IsGameMaster(0):
			self.AppendSpace(5)
			self.AppendTextLine("VNUM: {}".format(itemVnum), 0xFFf863ff)
			self.AppendSpace(3)
			self.AppendTextLine("TYPE: {} SUBTYPE {}".format(itemType, itemSubType), 0xFF00cfb6)
			if metinSlot:
				self.AppendSpace(3)
				self.AppendTextLine("SOCKET: {}".format(','.join([str(i) for i in metinSlot])), 0xFF00b6d6)

	def AppendAntiflagInformation(self):
		antiFlagDict = {
			"|Eemoji/drop|e"	: item.ITEM_ANTIFLAG_DROP,    ## ++
			"|Eemoji/sell|e"	: item.ITEM_ANTIFLAG_SELL,    ## ++
			"|Eemoji/shop|e"	: item.ITEM_ANTIFLAG_MYSHOP,  ## ++
			"|Eemoji/safebox|e" : item.ITEM_ANTIFLAG_SAFEBOX, ## ++
		}
		
		antiFlagNames = [name for name, flag in antiFlagDict.iteritems() if item.IsAntiFlag(flag)]
		if antiFlagNames:
			self.AppendSpace(5)

			textLine2 = self.AppendTextLine('{}'.format(' '.join(antiFlagNames)), self.DISABLE_COLOR)
			textLine2.SetFeather()

	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):
		if app.ENABLE_DS_GRADE_MYTH:
			return (self.__IsOldHair(itemVnum) or 
			self.__IsNewHair(itemVnum) or
			self.__IsNewHair2(itemVnum) or
			self.__IsNewHair3(itemVnum))
		else:
			return (self.__IsOldHair(itemVnum) or 
			self.__IsNewHair(itemVnum) or
			self.__IsNewHair2(itemVnum) or
			self.__IsNewHair3(itemVnum) or
			self.__IsCostumeHair(itemVnum)
			)

	if not app.ENABLE_DS_GRADE_MYTH:
		def __IsCostumeHair(self, itemVnum):
			return self.__IsNewHair3(itemVnum - 100000)

	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 < 74599) or
			(74762 < itemVnum and itemVnum < 74799) or
			(45000 < itemVnum and itemVnum < 47000))

	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):
			itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum-1000)+".tga")
		elif self.__IsNewHair2(itemVnum):
			itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
		elif not app.ENABLE_DS_GRADE_MYTH and 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()

	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

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

					# 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 ResizeToolTipWidth(self, width):
		self.toolTipWidth = width

	def __CalculateToolTipWidth(self):
		affectTextLineLenList = []

		metinSocket = self.metinSlot
		if metinSocket:
			for socketIndex in metinSocket:
				if socketIndex:
					# item.SelectItem(socketIndex)

					affectType, affectValue = item.GetAffect(0)
					affectString = self.__GetAffectString(affectType, affectValue)
					if affectString:
						affectTextLineLenList.append(len(affectString))

			if self.itemVnum:
				item.SelectItem(self.itemVnum)
			self.metinSlot = None

		if self.toolTipWidth == self.TOOL_TIP_WIDTH:
			if affectTextLineLenList:
				self.toolTipWidth += max(affectTextLineLenList) + 10

		self.AlignTextLineHorizonalCenter()

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

	## cyh itemseal 2013 11 11
	def __AppendSealInformation(self, window_type, slotIndex):
		if not app.ENABLE_SOULBIND_SYSTEM:
			return

		itemSealDate = player.GetItemSealDate(window_type, slotIndex)
		if itemSealDate == item.GetDefaultSealDate():
			return

		if itemSealDate == item.GetUnlimitedSealDate():
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.TOOLTIP_SEALED, self.NEGATIVE_COLOR)

		elif itemSealDate > 0:
			self.AppendSpace(5)
			hours, minutes = player.GetItemUnSealLeftTime(window_type, slotIndex)
			self.AppendTextLine(localeInfo.TOOLTIP_UNSEAL_LEFT_TIME % (hours, minutes), self.NEGATIVE_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)
			if app.ENABLE_ACCE_COSTUME_SYSTEM and affectType==item.APPLY_ACCEDRAIN_RATE:
				continue
			affectString = self.__GetAffectString(affectType, affectValue)
			if affectString:
				self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

	def AppendLastTimeInformation(self, metinSlot):
		bHasRealtimeFlag = False
		for i in xrange(item.LIMIT_MAX_NUM):
			(limitType, limitValue) = item.GetLimit(i)
			if item.LIMIT_REAL_TIME == limitType:
				bHasRealtimeFlag = True

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

	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))
		if app.ENABLE_WOLFMAN_CHARACTER:
			flagList += (not item.IsAntiFlag(item.ITEM_ANTIFLAG_WOLFMAN),)
		characterNames = ""

		self.AppendSpace(2)
		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()
		self.AppendSpace(5)
		
		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):
		self.AlignHorizonalCenter()
		self.AppendTextLine(localeInfo.TOOLTIP_SELLPRICE % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
		self.AppendSpace(5)

	def AppendMetinInformation(self):
		if constInfo.ENABLE_FULLSTONE_DETAILS:
			for i in xrange(item.ITEM_APPLY_MAX_NUM):
				(affectType, affectValue) = item.GetAffect(i)
				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))
		if app.ENABLE_PENDANT_SYSTEM:
			flagList += (item.IsWearableFlag(item.WEARABLE_PENDANT),)
		if app.ENABLE_GLOVE_SYSTEM:
			flagList += (item.IsWearableFlag(item.WEARABLE_GLOVE),)

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

			name = self.WEAR_NAMES[i]
			flag = flagList[i]

			if flag:
				wearNames += " "*2
				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

	if app.__PERMA_ACCESSORY__:
		def __AppendAccessoryMetinSlotInfo(self, metinSlot, mtrlVnum):
			ACCESSORY_SOCKET_MAX_SIZE = 3
			(cur, end) = (0, 0)
			for j in xrange(ACCESSORY_SOCKET_MAX_SIZE):
				idx = 2 - j
				if metinSlot[idx] == -2 or metinSlot[idx] == -3 or metinSlot[idx] > 0:
					cur = idx + 1
					break
			for j in xrange(ACCESSORY_SOCKET_MAX_SIZE):
				idx = 2 - j
				if metinSlot[idx] == -1 or metinSlot[idx] == -2 or metinSlot[idx] == -3 or metinSlot[idx] > 0:
					end = idx + 1
					break

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

			affectType3, affectValue3 = item.GetAffect(2)
			affectList3=[0, max(1, affectValue3*10/100), max(2, affectValue3*20/100), max(3, affectValue3*40/100)]

			affectType4, affectValue4 = item.GetAffect(3)
			affectList4=[0, max(1, affectValue4*10/100), max(2, affectValue4*20/100), max(3, affectValue4*40/100)]

			mtrlPos=0
			mtrlList=[mtrlVnum]*cur+[player.METIN_SOCKET_TYPE_SILVER]*(end-cur)


			lastLeftTimeIdx = -1
			for j in xrange(3):
				if metinSlot[2-j] > 0:
					lastLeftTimeIdx = 2-j
					break

			for mtrl in mtrlList:
				affectString1 = self.__GetAffectString(affectType1, affectList1[mtrlPos+1]-affectList1[mtrlPos])
				affectString2 = self.__GetAffectString(affectType2, affectList2[mtrlPos+1]-affectList2[mtrlPos])
				affectString3 = self.__GetAffectString(affectType3, affectList3[mtrlPos+1]-affectList3[mtrlPos])
				affectString4 = self.__GetAffectString(affectType4, affectList4[mtrlPos+1]-affectList4[mtrlPos])

				self.__AppendMetinSlotInfo_AppendMetinSocketDataNew(mtrlPos, mtrl, affectString1, affectString2, affectString3, affectString4, metinSlot[lastLeftTimeIdx] if mtrlPos == lastLeftTimeIdx else 0, True if metinSlot[mtrlPos] == -3 else False)
				mtrlPos+=1
	else:

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

			affectType3, affectValue3 = item.GetAffect(2)
			affectList3=[0, max(1, affectValue3*10/100), max(2, affectValue3*20/100), max(3, affectValue3*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])
				affectString3 = self.__GetAffectString(affectType3, affectList3[mtrlPos+1]-affectList3[mtrlPos], True)

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

				self.__AppendMetinSlotInfo_AppendMetinSocketData(mtrlPos, mtrl, affectString1, affectString2, affectString3, 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

	if app.__PERMA_ACCESSORY__:
		def __AppendMetinSlotInfo_AppendAccesory(self, index, metinSlotData, custumAffectString="", custumAffectString2="", custumAffectString3="", custumAffectString4="", metinSockets = [0,0,0,0,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)
			
			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:

				if -1 == metinSockets[index+2]:
					itemIndex += 5000

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

				metinImage.SetPosition(10, self.toolTipHeight)
				affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2)

				self.childrenList.append(affectTextLine)

				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)

					if not custumAffectString2 and not custumAffectString3 and not custumAffectString4:
						timeText= ""
						if metinSockets[index+2] > 0:
							if metinSockets[index+2] >= 1000000000:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]-app.GetGlobalTimeStamp()))
							else:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]))

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

				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 not custumAffectString3 and custumAffectString4:
						timeText= ""
						if metinSockets[index+2] > 0:
							if metinSockets[index+2] >= 1000000000:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]-app.GetGlobalTimeStamp()))
							else:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]))

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

				if custumAffectString3:
					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(custumAffectString3)
					self.childrenList.append(affectTextLine)
					self.toolTipHeight += 16 + 2

					if not custumAffectString3:
						timeText= ""
						if metinSockets[index+2] > 0:
							if metinSockets[index+2] >= 1000000000:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]-app.GetGlobalTimeStamp()))
							else:
								timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]))

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

				if custumAffectString4:
					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(custumAffectString4)
					self.childrenList.append(affectTextLine)
					self.toolTipHeight += 16 + 2

					timeText= ""
					if metinSockets[index+2] > 0:
						if metinSockets[index+2] >= 1000000000:
							timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]-app.GetGlobalTimeStamp()))
						else:
							timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(metinSockets[index+2]))

					if timeText:
						affectTextLineTime = ui.TextLine()
						affectTextLineTime.SetParent(self)
						affectTextLineTime.SetFontName(self.defFontName)
						affectTextLineTime.SetPackedFontColor(self.POSITIVE_COLOR)
						affectTextLineTime.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
						affectTextLineTime.SetOutline()
						affectTextLineTime.SetFeather()
						affectTextLineTime.Show()
						affectTextLineTime.SetText(timeText)
						self.toolTipHeight += 16 + 2
						self.childrenList.append(affectTextLineTime)
			else:
				nameTextLine.SetText(localeInfo.TOOLTIP_SOCKET_EMPTY)

			self.toolTipHeight += 35
			self.ResizeToolTip()


	def __AppendMetinSlotInfo_AppendMetinSocketData(self, index, metinSlotData, custumAffectString="", custumAffectString2="", custumAffectString3="", 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 constInfo.ENABLE_FULLSTONE_DETAILS and (not custumAffectString2) and (itemIndex!=constInfo.ERROR_METIN_STONE):
				custumAffectString2 = self.__GetAffectString(*item.GetAffect(1))

			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 constInfo.ENABLE_FULLSTONE_DETAILS and (not custumAffectString3) and (itemIndex!=constInfo.ERROR_METIN_STONE):
				custumAffectString3 = self.__GetAffectString(*item.GetAffect(2))

			if custumAffectString3:
				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(custumAffectString3)
				self.childrenList.append(affectTextLine)
				self.toolTipHeight += 16 + 2

			if 0 != leftTime:
				timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(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()

	if app.__PERMA_ACCESSORY__:
		def __AppendMetinSlotInfo_AppendMetinSocketDataNew(self, index, metinSlotData, custumAffectString="", custumAffectString2="", custumAffectString3="", custumAffectString4="", leftTime=0, isPerma = False):
			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)
			
			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:
				if metinSlotData == 18900:
					if isPerma:
						itemIndex += 1
				else:
					if isPerma:
						itemIndex += 5000

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

				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 custumAffectString3:
					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(custumAffectString3)
					self.childrenList.append(affectTextLine)
					self.toolTipHeight += 16 + 2

				if custumAffectString4:
					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(custumAffectString4)
					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: # @fixme012
			restSecond = restMin*60
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(restSecond), self.NORMAL_COLOR)

	def AppendMallItemLastTime(self, endTime):
		if endTime > 0: # @fixme012
			if endTime >= app.GetGlobalTimeStamp():
				leftSec = endTime - app.GetGlobalTimeStamp()
				self.AppendSpace(5)
				self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(leftSec), self.NORMAL_COLOR)
			else:
				self.AppendSpace(5)
				self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(endTime), self.NORMAL_COLOR)

	def AppendEventTime(self, endTime):
		if endTime > 0: # @fixme012
			if endTime >= app.GetGlobalTimeStamp():
				leftSec = endTime - app.GetGlobalTimeStamp()
				self.AppendSpace(5)
				self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(leftSec), self.NEGATIVE_COLOR)
			else:
				self.AppendSpace(5)
				self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHMS(endTime), self.NEGATIVE_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_ACCE_COSTUME_SYSTEM:
		def SetAcceResultItem(self, slotIndex, window_type = player.INVENTORY):
			(itemVnum, MinAbs, MaxAbs) = acce.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_ACCE:
				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.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary4(), 26, self.CONDITION_COLOR)
			self.__AppendLimitInformation()

			## ABSORPTION RATE
			if MinAbs == MaxAbs:
				self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE % (MinAbs), self.CONDITION_COLOR)
			else:
				self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE2 % (MinAbs, MaxAbs), self.CONDITION_COLOR)
			## END ABSOPRTION RATE

			itemAbsorbedVnum = int(metinSlot[acce.ABSORBED_SOCKET])
			if itemAbsorbedVnum:
				## ATTACK / DEFENCE
				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.CalcAcceValue2(defGrade, absChance)
					defBonus = self.CalcAcceValue2(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)
				## END ATTACK / DEFENCE

				## EFFECT
				item.SelectItem(itemAbsorbedVnum)
				for i in xrange(item.ITEM_APPLY_MAX_NUM):
					(affectType, affectValue) = item.GetAffect(i)
					affectValue = self.CalcAcceValue(affectValue, absChance)
					affectString = self.__GetAffectString(affectType, affectValue)
					if (not app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue != 0)\
							or (app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue > 0):
						self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

					item.SelectItem(itemAbsorbedVnum)
				# END EFFECT

			item.SelectItem(itemVnum)
			## ATTR
			self.__AppendAttributeInformation(attrSlot, MaxAbs, itemVnum)
			# END ATTR

			self.AppendWearableInformation()
			self.ShowToolTip()

		def SetAcceResultAbsItem(self, slotIndex1, slotIndex2, window_type = player.INVENTORY):
			itemVnumAcce = player.GetItemIndex(window_type, slotIndex1)
			itemVnumTarget = player.GetItemIndex(window_type, slotIndex2)
			if not itemVnumAcce or not itemVnumTarget:
				return

			self.ClearToolTip()

			item.SelectItem(itemVnumAcce)
			itemType = item.GetItemType()
			itemSubType = item.GetItemSubType()
			if itemType != item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_ACCE:
				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(itemVnumAcce, metinSlot, attrSlot)
			self.AppendDescription(itemDesc, 26)
			self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary2(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary3(), 26, self.CONDITION_COLOR)
			self.AppendDescription(item.GetItemSummary4(), 26, self.CONDITION_COLOR)
			item.SelectItem(itemVnumAcce)
			self.__AppendLimitInformation()

			## ABSORPTION RATE
			self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE % (metinSlot[acce.ABSORPTION_SOCKET]), self.CONDITION_COLOR)
			## END ABSOPRTION RATE

			## ATTACK / DEFENCE
			itemAbsorbedVnum = itemVnumTarget
			item.SelectItem(itemAbsorbedVnum)
			if item.GetItemType() == item.ITEM_TYPE_WEAPON:
				if item.GetItemSubType() == item.WEAPON_FAN:
					self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
					item.SelectItem(itemAbsorbedVnum)
					self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
				else:
					self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
					item.SelectItem(itemAbsorbedVnum)
					self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
			elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
				defGrade = item.GetValue(1)
				defBonus = item.GetValue(5) * 2
				defGrade = self.CalcAcceValue2(defGrade, metinSlot[acce.ABSORPTION_SOCKET])
				defBonus = self.CalcAcceValue2(defBonus, metinSlot[acce.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[acce.ABSORPTION_SOCKET])
			## END ATTACK / DEFENCE

			## EFFECT
			item.SelectItem(itemAbsorbedVnum)
			for i in xrange(item.ITEM_APPLY_MAX_NUM):
				(affectType, affectValue) = item.GetAffect(i)
				affectValue = self.CalcAcceValue(affectValue, metinSlot[acce.ABSORPTION_SOCKET])
				affectString = self.__GetAffectString(affectType, affectValue)
				if (not app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue != 0)\
						or (app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue > 0):
					self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))

				item.SelectItem(itemAbsorbedVnum)
			## END EFFECT

			## ATTR
			item.SelectItem(itemAbsorbedVnum)
			for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
				type = attrSlot[i][0]
				value = attrSlot[i][1]
				if not value:
					continue

				affectValue = self.CalcAcceValue(value, metinSlot[acce.ABSORPTION_SOCKET])
				affectString = self.__GetAffectString(type, affectValue)
				if (not app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue != 0)\
						or (app.USE_ACCE_ABSORB_WITH_NO_NEGATIVE_BONUS and affectString and affectValue > 0):
					affectColor = self.__GetAttributeColor(i, affectValue)
					self.AppendTextLine(affectString, affectColor)

				item.SelectItem(itemAbsorbedVnum)
			## END ATTR

			## WEARABLE
			item.SelectItem(itemVnumAcce)
			self.AppendSpace(5)
			self.AppendTextLine(localeInfo.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)

			item.SelectItem(itemVnumAcce)
			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)
			)

			if app.ENABLE_WOLFMAN_CHARACTER:
				flagList += (not item.IsAntiFlag(item.ITEM_ANTIFLAG_WOLFMAN),)

			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(itemVnumAcce)
			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()
			## END WEARABLE

			self.ShowToolTip()

class HyperlinkItemToolTip(ItemToolTip):
	def __init__(self):
		ItemToolTip.__init__(self, isPickable=True)

	def SetHyperlinkItem(self, tokens):
		defaultTokenCount = 3 #head, vnum, flag

		minTokenCount = defaultTokenCount + player.METIN_SOCKET_MAX_NUM
		maxTokenCount = minTokenCount + 2 * player.ATTRIBUTE_SLOT_MAX_NUM

		try:
			head, vnum, flag  = tokens[:3]

			itemVnum = int(vnum, 16)

			metinSlot = [long(metin) for metin in tokens[3:11]]

			rests = tokens[11:]

			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()
			if app.IsPressed(app.DIK_LSHIFT):
				if uiRenderTarget.IsCanShowItems(itemVnum):
					interface = constInfo.GetInterfaceInstance()
					interface.OpenRenderTargetWindow(0, itemVnum)
					return 

			self.AddItemData(itemVnum, metinSlot, attrSlot)
			ItemToolTip.OnUpdate(self)
		except:
			pass

	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)

	if app.ENABLE_RENEWAL_AFFECT_SHOWER:
		def SetSkillEx(self, skillIndex, skillLevel = -1):
			if 0 == skillIndex:
				return
			slotIndex = player.GetSkillSlotIndex(skillIndex)
			skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
			for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
				self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillCurrentPercentage), self.ENABLE_COLOR)
			self.ResizeToolTip()

	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 __AppendLeaderShipSkillData(self, skill_grade, skill_level):
		if 1 == skill_grade:
			skill_level += 19
		elif 2 == skill_grade:
			skill_level += 29
		elif 3 == skill_grade:
			skill_level = 40

		self.AppendSpace(5)
		self.AutoAppendTextLine(localeInfo.TOOLTIP_PARTY_SKILL_LEVEL % skill_level, self.NORMAL_COLOR)

		if skill_level == 0:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(10), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 1:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(11), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(4), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 2:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(12), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 3:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(13), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 4:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(14), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 5:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(15), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 6:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(16), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 7:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(17), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(10), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 8:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(18), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(11), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 9:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(19), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(12), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 10:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(20), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(13), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 11:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(21), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(1), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(14), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 12:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(22), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(15), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 13:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(23), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(200), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(16), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 14:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(24), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(200), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(17), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 15:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(25), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(200), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(18), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 16:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(26), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(2), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(19), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 17:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(27), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(3), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(20), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 18:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(28), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(3), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(21), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 19:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(29), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(3), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(22), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 20:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(40), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(4), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(23), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 21:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(41), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(4), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(24), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 22:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(42), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(4), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(25), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 23:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(43), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(4), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(26), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 24:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(44), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(27), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 25:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(46), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(28), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 26:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(47), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(450), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(29), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 27:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(49), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(500), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(200), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(31), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 28:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(51), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(550), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(200), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(33), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 29:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(53), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(5), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(650), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(300), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(35), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 30:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(59), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(750), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(350), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(37), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 31:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(61), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(850), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(39), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 32:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(77), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(6), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1000), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(450), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(40), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 33:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(80), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(7), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(500), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(42), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 34:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(84), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(8), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(530), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(44), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 35:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(86), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1400), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(9), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(613), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(46), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 36:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(88), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(10), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1500), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(13), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(637), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(48), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 37:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(90), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(11), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1750), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(13), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(661), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(50), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 38:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(95), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(12), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(1950), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(13), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(685), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(55), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 39:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(100), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(15), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(2150), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(14), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(715), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(58), self.CHANGELOOK_ITEMNAME_COLOR)
		if skill_level == 40:
			self.AutoAppendTextLine(localeInfo.DETAILS_TOOLTIP_12 + "+%.0f" % int(120), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.LEADERSHIP_SP + "+%.0f" % int(25), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_TOOLTIP_HP + "+%.0f" % int(2250), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_CAST_SPEED + "+%.0f" % int(15), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.PET_SKILL_TOOLTIP_DURATION % int(775), self.CHANGELOOK_ITEMNAME_COLOR)
			self.AutoAppendTextLine(localeInfo.STAT_TOOLTIP_DEF + "+%.0f" % int(60), self.CHANGELOOK_ITEMNAME_COLOR)

		self.AlignHorizonalCenter()


	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.__AppendLeaderShipSkillData(skillGrade, skillLevel)

		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)
					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):
		# @fixme008 BEGIN
		def comma_fix(vl):
			return vl.replace("%,0f", "%.0f")
		# @fixme008 END

		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 = skillPower # @fixme008
		self.AppendSpace(5)
		self.AutoAppendTextLine(localeInfo.TOOLTIP_PARTY_SKILL_LEVEL % skillLevel, self.NORMAL_COLOR)

		# @fixme008 BEGIN
		if skillLevel>=10:
			self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_ATTACKER) % chop( 10 + 60 * k ))

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

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

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

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

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