Problem z klientem na plikach Terenzo

[InBox]

Siemano ! Mam problem z klientem otóz loguje sie na serwa, wybieram postac, ładuje sie klient do konca i pyk zamyka...

syserr clienta :

0110 14:13:24424 ::
uiCharacter.py(line:395) __LoadWindow
uiCharacter.py(line:153) __BindObject

CharacterWindow.__LoadWindow - exceptions.AttributeError:'module' object has no attribute 'ToolTip'

0110 14:13:24424 :: ============================================================================================================
0110 14:13:24424 :: Abort!!!!

powiem ze wziołem plik uicharacter.py z innego clienta i podmienilem ale dalej to samo. Jest jeszcze w temacie Terenzo taki fix ale nie wiem gdzie go wgrac moze to od tego mam problem ?

[paiter1992]

Rozpakuj root i wklej to w uitooltip.py

 

 

import dbg 
import player 
import item 
import grp 
import wndMgr 
import skill 
import shop 
import exchange 
import grpText 
import safebox 
import locale 
import app 
import background 
import nonplayer 
import chr 


import ui 
import mouseModule 
import constInfo 


WARP_SCROLLS = [22011, 22000, 22010] 


DESC_DEFAULT_MAX_COLS = 26 
DESC_WESTERN_MAX_COLS = 35 
DESC_WESTERN_MAX_WIDTH = 220 


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


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


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


      return lines 


################################################################################################### 
## ToolTip 
## 
##  NOTE : Co?c´A Item°u Skill?≫ ≫o?O?¸·I ???­ ˝?A?μI?u?˝ 
##          C?Ao¸¸ ±×´?Ao ?C??°ˇ ???i ?¸?O 
## 
class ToolTip(ui.ThinBoard): 


      TOOL_TIP_WIDTH = 190 
      TOOL_TIP_HEIGHT = 10 


      TEXT_LINE_HEIGHT = 17 


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


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


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


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


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


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


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


            self.AddFlag("float") 


            self.followFlag = TRUE 
            self.toolTipWidth = width 


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


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


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


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


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


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


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


      def AppendHorizontalLine(self): 


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


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


                  self.childrenList.append(horizontalLine) 


            self.toolTipHeight += 11 
            self.ResizeToolTip() 


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


            self.ResizeToolTip() 


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


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


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


            self.childrenList.append(textLine) 


            (textWidth, textHeight)=textLine.GetTextSize() 


            textWidth += 40 
            textHeight += 5 


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


            self.toolTipHeight += textHeight 


            return textLine 


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


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


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


            self.childrenList.append(textLine) 


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


            return textLine 


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


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


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


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


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


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


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


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


            return self.ENABLE_COLOR 


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


            if 0 == value: 
                  return self.NORMAL_COLOR 


            return self.NEGATIVE_COLOR 


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


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


            self.OnUpdate() 


      def HideToolTip(self): 
            self.Hide() 


      def OnUpdate(self): 


            if not self.followFlag: 
                  return 


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


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


                  (mouseX, mouseY) = wndMgr.GetMousePosition() 


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


                  x = mouseX - width/2                         


            else: 


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


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


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


            self.SetPosition(x, y) 


class ItemToolTip(ToolTip): 


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


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


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


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


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


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


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


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


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


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


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


            # ?????? ???A?≫ C?˝?C? ¶§ Co?c Ał¸??I°ˇ A??eC? ?o ??´A ????????¶o¸e °­A|·I Disable Color·I ?łA¤ (???? ±×·¸°O ??μ?C?°i ?O?¸ł? ˛¨?ß C? C??a°ˇ ?O?i?­) 
            self.bCannotUseItemForceSetDisableColor = TRUE 


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


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


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


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


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


            s*x = chr.RaceToSex(race) 
             
            MALE = 1 
            FEMALE = 0 


            if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE) and s*x == MALE: 
                  return FALSE 


            if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE) and s*x == FEMALE: 
                  return FALSE 


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


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


            return TRUE 


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


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


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


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


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


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


            self.AddItemData(itemVnum, metinSlot, attrSlot) 


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


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


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


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


      def 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, inventorySlotIndex, privateShopSlotIndex): 
            itemVnum = player.GetItemIndex(inventorySlotIndex) 
            if 0 == itemVnum: 
                  return 


            item.SelectItem(itemVnum) 
            self.ClearToolTip() 
            self.AppendSellingPrice(shop.GetPrivateShopItemPrice(inventorySlotIndex)) 


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


            self.AddItemData(itemVnum, metinSlot, attrSlot) 


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


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


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


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


            self.AddItemData(itemVnum, metinSlot, attrSlot) 


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


            self.AddItemData(itemVnum, metinSlot, attrSlot) 


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


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


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


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


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


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


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


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


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


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


                  for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM): 
                        type = attrSlot[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 >= 5: 
                        return self.SPECIAL_POSITIVE_COLOR2 
                  else: 
                        return self.SPECIAL_POSITIVE_COLOR 
            elif value == 0: 
                  return self.NORMAL_COLOR 
            else: 
                  return self.NEGATIVE_COLOR 


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


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


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


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


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


                  self.__SetNormalItemTitle() 


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


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


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


            self.AddItemData(itemVnum, metinSlot, attrSlot) 


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


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


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


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


            ### Skill Book ### 
            elif 50300 == itemVnum: 
                  if 0 != metinSlot: 
                        self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILLBOOK_NAME, 1) 
                        self.ShowToolTip() 
                  return 
            elif 70037 == itemVnum: 
                  if 0 != metinSlot: 
                        self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0) 
                        self.AppendDescription(item.GetItemDescription(), 26) 
                        self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR) 
                        self.ShowToolTip() 
                  return 
            elif 70055 == itemVnum: 
                  if 0 != metinSlot: 
                        self.__SetSkillBookToolTip(metinSlot[0], locale.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0) 
                        self.AppendDescription(item.GetItemDescription(), 26) 
                        self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR) 
                        self.ShowToolTip() 
                  return 
            ########################################################################################### 




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


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


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


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


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


                  self.__AppendLimitInformation() 


                  self.AppendSpace(5) 


                  ## ?I?¤?? °??? ¸¶°??≫ ¸??u C?˝?C?´?. 
                  if item.WEAPON_FAN == itemSubType: 
                        self.__AppendMagicAttackInfo() 
                        self.__AppendAttackPowerInfo() 


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


                  self.__AppendAffectInformation() 
                  self.__AppendAttributeInformation(attrSlot) 


                  self.AppendWearableInformation() 
                  self.__AppendMetinSlotInfo(metinSlot) 


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


                  ## ???i·A 
                  defGrade = item.GetValue(1) 
                  defBonus = item.GetValue(5)*2 ## ???i·A C?˝? ?߸? μC´A ?®A|¸| ?oA¤ 
                  if defGrade > 0: 
                        self.AppendSpace(5) 
                        self.AppendTextLine(locale.TOOLTIP_ITEM_DEF_GRADE % (defGrade+defBonus), self.GetChangeTextLineColor(defGrade)) 


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


                  self.AppendWearableInformation() 


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


            ## AU˝??? ?????? ## 
            elif 0 != isCostumeItem: 
                  self.__AppendLimitInformation() 
                  self.__AppendAffectInformation() 
                  self.__AppendAttributeInformation(attrSlot) 


                  self.AppendWearableInformation() 
             
                  bHasRealtimeFlag = 0 
                   
                  ## ≫c?e°ˇ´E ˝?°Ł A|C??? ?O´AAo ?Ł???¸°i 
                  for i in xrange(item.LIMIT_MAX_NUM): 
                        (limitType, limitValue) = item.GetLimit(i) 


                        if item.LIMIT_REAL_TIME == limitType: 
                              bHasRealtimeFlag = 1 
                   
                  ## ?O´?¸e °u·? A¤?¸¸| C?˝?CO. ex) ł˛?? ˝?°Ł : 6?? 6˝?°Ł 58?đ 
                  if 1 == bHasRealtimeFlag: 
                        self.AppendMallItemLastTime(metinSlot[0]) 
                        #dbg.TraceError("1) REAL_TIME flag On ") 
                         
            ## Rod ## 
            elif item.ITEM_TYPE_ROD == itemType: 


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


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


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


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


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


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


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


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


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


                        self.AppendTextLine(affectText, self.NORMAL_COLOR) 


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


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


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


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


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


                              if 1 == item.GetValue(2): ## ˝C˝?°Ł ???e Flag / ??A? ??C?μμ A?´? 
                                    self.AppendMallItemLastTime(time) 
                              else: 
                                    self.AppendUniqueItemLastTime(time) 


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


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


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




                  ## ?μ?® °¨Ao±a 
                  if 27989 == itemVnum or 76006 == itemVnum: 
                        if 0 != metinSlot: 
                              useCount = int(metinSlot[0]) 


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


                  ## ?????® °¨Ao±a 
                  elif 50004 == itemVnum: 
                        if 0 != metinSlot: 
                              useCount = int(metinSlot[0]) 


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


                  ## ?Uμ??°?? 
                  elif constInfo.IS_AUTO_POTION(itemVnum): 
                        if 0 != metinSlot: 
                              ## 0: ?°???­, 1: ≫c?e·®, 2: ??·® 
                              isActivated = int(metinSlot[0]) 
                              usedAmount = float(metinSlot[1]) 
                              totalAmount = float(metinSlot[2]) 
                               
                              if 0 == totalAmount: 
                                    totalAmount = 1 
                               
                              self.AppendSpace(5) 


                              if 0 != isActivated: 
                                    self.AppendTextLine("(%s)" % (locale.TOOLTIP_AUTO_POTION_USING), self.SPECIAL_POSITIVE_COLOR) 
                                    self.AppendSpace(5) 
                                     
                              self.AppendTextLine(locale.TOOLTIP_AUTO_POTION_REST % (100.0 - ((usedAmount / totalAmount) * 100.0)), self.POSITIVE_COLOR) 
                                                 
                  ## ±I?? ±a???I 
                  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=locale.MINIMAP_ZONE_NAME_DICT.get(mapName, "") 


                                    self.AppendSpace(5) 


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


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


                              if item.LIMIT_REAL_TIME == limitType: 
                                    bHasRealtimeFlag = 1 
             
                        ## ?O´?¸e °u·? A¤?¸¸| C?˝?CO. ex) ł˛?? ˝?°Ł : 6?? 6˝?°Ł 58?đ 
                        if 1 == bHasRealtimeFlag: 
                              self.AppendMallItemLastTime(metinSlot[0]) 
                        else: 
                              # ... ??°?... ?­?o?ˇ´A ??·± ˝?°Ł ???ⓒ ??μC?i ?O´Aμ?... 
                              # ?O ??·±°O ?O´AAo ?EAo´A ¸?C?ł? ±×łE μI?U... 
                              if 0 != metinSlot: 
                                    time = metinSlot[player.METIN_SOCKET_MAX_NUM-1] 


                                    ## ˝C˝?°Ł ???e Flag 
                                    if 1 == item.GetValue(2): 
                                          self.AppendMallItemLastTime(time) 
                   
                  # elif item.USE_TIME_CHARGE_PER == itemSubType: 
                        # bHasRealtimeFlag = 0 
                        # for i in xrange(item.LIMIT_MAX_NUM): 
                              # (limitType, limitValue) = item.GetLimit(i) 


                              # if item.LIMIT_REAL_TIME == limitType: 
                                    # bHasRealtimeFlag = 1 
                        # if metinSlot[2]: 
                              # self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_PER(metinSlot[2])) 
                        # else: 
                              # self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_PER(item.GetValue(0))) 
             
                        # ?O´?¸e °u·? A¤?¸¸| C?˝?CO. ex) ł˛?? ˝?°Ł : 6?? 6˝?°Ł 58?đ 
                        # if 1 == bHasRealtimeFlag: 
                              # self.AppendMallItemLastTime(metinSlot[0]) 


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


                              # if item.LIMIT_REAL_TIME == limitType: 
                                    # bHasRealtimeFlag = 1 
                        # if metinSlot[2]: 
                              # self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_FIX(metinSlot[2])) 
                        # else: 
                              # self.AppendTextLine(locale.TOOLTIP_TIME_CHARGER_FIX(item.GetValue(0))) 
             
                        # ?O´?¸e °u·? A¤?¸¸| C?˝?CO. ex) ł˛?? ˝?°Ł : 6?? 6˝?°Ł 58?đ 
                        # if 1 == bHasRealtimeFlag: 
                              # self.AppendMallItemLastTime(metinSlot[0]) 


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


                        if item.LIMIT_REAL_TIME == limitType: 
                              self.AppendMallItemLastTime(metinSlot[0]) 


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


      ## C??i?I°ˇ? 
      def __IsHair(self, itemVnum): 
            return (self.__IsOldHair(itemVnum) or 
                  self.__IsNewHair(itemVnum) or 
                  self.__IsNewHair2(itemVnum) or 
                  self.__IsNewHair3(itemVnum) or 
                  self.__IsCostumeHair(itemVnum) 
                  ) 


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


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


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


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


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


            if self.__IsOldHair(itemVnum): 
                  itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum)+".tga") 
            elif self.__IsNewHair3(itemVnum): 
                  itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum)) 
            elif self.__IsNewHair(itemVnum): # ±aA¸ C??i ???Ł¸| ?￢°a˝?A??­ ≫c?eC?´?. ≫?·I?i ???????? 1000¸¸?­ ???Ł°ˇ ´??u´?. 
                  itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum-1000)+".tga") 
            elif self.__IsNewHair2(itemVnum): 
                  itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum)) 
            elif self.__IsCostumeHair(itemVnum): 
                  itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum - 100000)) 


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


      ## ≫c??Ai°ˇ ?≪ Description ?? °??? ???A ≫c??Ai¸| A¶A¤C?´? 
      def __AdjustMaxWidth(self, attrSlot, desc): 
            newToolTipWidth = self.toolTipWidth 
            newToolTipWidth = max(self.__AdjustAttrMaxWidth(attrSlot), newToolTipWidth) 
            newToolTipWidth = max(self.__AdjustDescMaxWidth(desc), newToolTipWidth) 
            if newToolTipWidth > self.toolTipWidth: 
                  self.toolTipWidth = newToolTipWidth 
                  self.ResizeToolTip() 


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


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


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


            return maxWidth 


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


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


            if not skillName: 
                  return 


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


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


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




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


            if curEXP == maxEXP: 
                  self.AppendSpace(5) 
                  self.AppendTextLine(locale.TOOLTIP_FISHINGROD_UPGRADE1, self.NORMAL_COLOR) 
                  self.AppendTextLine(locale.TOOLTIP_FISHINGROD_UPGRADE2, self.NORMAL_COLOR) 
                  self.AppendTextLine(locale.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(locale.TOOLTIP_ITEM_LIMIT_LEVEL % (limitValue), color) 
                  """ 
                  elif item.LIMIT_STR == limitType: 
                        color = self.GetLimitTextLineColor(player.GetStatus(player.ST), limitValue) 
                        self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_STR % (limitValue), color) 
                  elif item.LIMIT_DEX == limitType: 
                        color = self.GetLimitTextLineColor(player.GetStatus(player.DX), limitValue) 
                        self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_DEX % (limitValue), color) 
                  elif item.LIMIT_INT == limitType: 
                        color = self.GetLimitTextLineColor(player.GetStatus(player.IQ), limitValue) 
                        self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_INT % (limitValue), color) 
                  elif item.LIMIT_CON == limitType: 
                        color = self.GetLimitTextLineColor(player.GetStatus(player.HT), limitValue) 
                        self.AppendTextLine(locale.TOOLTIP_ITEM_LIMIT_CON % (limitValue), color) 
                  """ 


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


            if 0 == affectValue: 
                  return None 


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


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


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


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


      def AppendWearableInformation(self): 


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


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


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


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


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


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


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


            if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE): 
                  textLine = self.AppendTextLine(locale.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(locale.TOOLTIP_POTION_PLUS_HP_POINT % healHP, self.GetChangeTextLineColor(healHP)) 
            if healSP > 0: 
                  self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_SP_POINT % healSP, self.GetChangeTextLineColor(healSP)) 
            if healStatus != 0: 
                  self.AppendTextLine(locale.TOOLTIP_POTION_CURE) 
            if healPercentageHP > 0: 
                  self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_HP_PERCENT % healPercentageHP, self.GetChangeTextLineColor(healPercentageHP)) 
            if healPercentageSP > 0: 
                  self.AppendTextLine(locale.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(locale.TOOLTIP_POTION_PLUS_ATTACK_SPEED % point, self.GetChangeTextLineColor(point)) 
            elif abilityType == item.APPLY_MOV_SPEED: 
                  self.AppendTextLine(locale.TOOLTIP_POTION_PLUS_MOVING_SPEED % point, self.GetChangeTextLineColor(point)) 


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


                  if minute > 0: 
                        timeString += str(minute) + locale.TOOLTIP_POTION_MIN 
                  if second > 0: 
                        timeString += " " + str(second) + locale.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(locale.TOOLTIP_BUYPRICE  % (locale.NumberToMoneyString(price)), self.GetPriceColor(price)) 


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


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


            affectString = self.__GetAffectString(affectType, affectValue) 


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


      def AppendMetinWearInformation(self): 


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


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


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


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


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


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


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


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


            return player.METIN_SOCKET_TYPE_NONE 


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


            return number 


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


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


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


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


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


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


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


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


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


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


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


            return 1 


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


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


            if 0 == slotType: 
                  return 


            self.AppendSpace(5) 


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


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


            self.childrenList.append(nameTextLine) 


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


            self.childrenList.append(slotImage) 
             
            if locale.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 locale.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(locale.TOOLTIP_APPLY_NOAFFECT) 
                   
                  self.childrenList.append(affectTextLine)                   


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


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


            self.toolTipHeight += 35 
            self.ResizeToolTip() 


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


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


      def AppendMallItemLastTime(self, endTime): 
            leftSec = max(0, endTime - app.GetGlobalTimeStamp()) 
            self.AppendSpace(5) 
            self.AppendTextLine(locale.LEFT_TIME + " : " + locale.SecondToDHM(leftSec), self.NORMAL_COLOR) 
             
      def AppendTimerBasedOnWearLastTime(self, metinSlot): 
            if 0 == metinSlot[0]: 
                  self.AppendSpace(5) 
                  self.AppendTextLine(locale.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] 
             
            # C? ????¶oμμ ≫c?eCß´?¸e Socket0?ˇ A?·a ˝?°Ł(2012ła 3?? 1?? 13˝? 01?đ °°??..) ?? ?UCo?O?˝. 
            # ≫c?eC?Ao ????´?¸e Socket0?ˇ ???e°ˇ´E˝?°Ł(??¸|?׸e 600 °°?? °?. ??´U?§)?? μe?i?O?≫ ?o ?O°i, 0??¶o¸e Limit Value?ˇ ?O´A ???e°ˇ´E˝?°Ł?≫ ≫c?eC?´?. 
            if 0 == useCount: 
                  if 0 == endTime: 
                        (limitType, limitValue) = item.GetLimit(limitIndex) 
                        endTime = limitValue 


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


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


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


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


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


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


                  ItemToolTip.OnUpdate(self) 


      def OnUpdate(self): 
            pass 


      def OnMouseLeftButtonDown(self): 
            self.Hide() 


class SkillToolTip(ToolTip): 


      POINT_NAME_DICT = { 
            player.LEVEL : locale.SKILL_TOOLTIP_LEVEL, 
            player.IQ : locale.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 : locale.SKILL_GRADE_NAME_MASTER, 
                                          player.SKILL_GRADE_GRAND_MASTER : locale.SKILL_GRADE_NAME_GRAND_MASTER, 
                                          player.SKILL_GRADE_PERFECT_MASTER : locale.SKILL_GRADE_NAME_PERFECT_MASTER, } 


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


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


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


            if 0 == skillIndex: 
                  return 


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


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


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


            else: 


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


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


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


            self.ShowToolTip() 


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


            if 0 == skillIndex: 
                  return 


            if player.SKILL_INDEX_TONGSOL == skillIndex: 


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


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


            elif player.SKILL_INDEX_RIDING == skillIndex: 


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


            elif player.SKILL_INDEX_SUMMON == skillIndex: 


                  maxLevel = 10 


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


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


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


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


                        self.AppendSpace(5) 
                        self.AppendTextLine(locale.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(locale.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(locale.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(locale.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR) 
                        else: 
                              self.AppendTextLine(locale.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(locale.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.ENABLE_COLOR) 


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


            ## Next Level 
            if skillLevel < skillMaxLevel: 
                  if self.HasSkillLevelDescription(skillIndex, skillLevel+1): 
                        self.AppendSpace(5) 
                        self.AppendTextLine(locale.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(locale.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.DISABLE_COLOR) 


                        ## SP 
                        needGSP = skill.GetSkillNeedSP(skillIndex, skillNextPercentage) 
                        if needGSP > 0: 
                              self.AppendTextLine(locale.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(locale.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR) 
                        else: 
                              self.AppendTextLine(locale.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR) 
                        self.AppendSkillLevelDescriptionNew(skillIndex, skillCurrentPercentage, self.ENABLE_COLOR) 


            ## Next Level 
            if skillGrade != skill.SKILL_GRADE_COUNT: 
                  if skillLevel < skillMaxLevelEnd: 
                        if self.HasSkillLevelDescription(skillIndex, skillLevel+skillLevelUpPoint): 
                              self.AppendSpace(5) 
                              ## HP?¸°­, °u?e?¸CC ?¸A¶˝??ł?C °??? 
                              if skillIndex == 141 or skillIndex == 142: 
                                    self.AppendTextLine(locale.TOOLTIP_NEXT_SKILL_LEVEL_3 % (skillLevel+1), self.DISABLE_COLOR) 
                              else: 
                                    self.AppendTextLine(locale.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 = locale.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(locale.TOOLTIP_SKILL_DURATION % (duration), color) 


            ## Cooltime 
            coolTime = skill.GetSkillCoolTime(skillIndex, skillPercentage) 
            if coolTime > 0: 
                  self.AppendTextLine(locale.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(locale.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(locale.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(locale.TOOLTIP_NEED_HP % (needSP), color) 


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


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


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


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


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


      def AppendPartySkillData(self, skillGrade, skillLevel): 


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


            if skillLevel <= 0: 
                  return 


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


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


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


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


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


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


            self.AlignHorizonalCenter() 


      def __AppendSummonDescription(self, skillLevel, color): 
            if skillLevel > 1: 
                  self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (skillLevel * 10), color) 
            elif 1 == skillLevel: 
                  self.AppendTextLine(locale.SKILL_SUMMON_DESCRIPTION % (15), color) 
            elif 0 == skillLevel: 
                  self.AppendTextLine(locale.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() 

 

 

[Zagrajmarek]

Pobierz rozpakowane root z tematu z plikami, zmień IP/porty na swoje, spakuj, podmień w pack(client).

http://www.mpcforum.pl/topic/768196-czyste-serverfiles-by-terenzo/

[InBox]

Dzięki panowie ! Udało mi się wszystko chula ze aż miło Temat do zamknięcia. Problem rozwiązany.