Mythic DS slots problem

[metrix2020 4]

Hey, i installed and reinstalled this system dozens of times and i still can't find what i did wrong.

The problem is that the inventory from mythic class have only the first 8 slots available. What could be the problem?

https://metin2.download/picture/G6ZYF9QQ1b0BnYPniPgfkCHpZLGDn43x/.gif

Edit: I used this system: ds-mythic-class

Edited November 2, 2022 by metrix2020
Core X - External 2 Internal

[metrix2020 4]

Spoiler

import ui
import player
import mouseModule
import net
import app
import snd
import item
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder
import localeInfo
import constInfo
import ime
import uiInventory
import sys
ITEM_FLAG_APPLICABLE = 1 << 14

# ¿ëÈ¥¼® Vnum¿¡ ´ëÇÑ comment
# ITEM VNUMÀ» 10¸¸ ÀÚ¸®ºÎÅÍ, FEDCBA¶ó°í ÇÑ´Ù¸é
# FE : ¿ëÈ¥¼® Á¾·ù.    D : µî±Þ
# C : ´Ü°è            B : °­È­
# A : ¿©¹úÀÇ ¹øÈ£µé...

class DragonSoulWindow(ui.ScriptWindow):
    KIND_TAP_TITLES = [uiScriptLocale.DRAGONSOUL_TAP_TITLE_1, uiScriptLocale.DRAGONSOUL_TAP_TITLE_2,
            uiScriptLocale.DRAGONSOUL_TAP_TITLE_3, uiScriptLocale.DRAGONSOUL_TAP_TITLE_4, uiScriptLocale.DRAGONSOUL_TAP_TITLE_5, uiScriptLocale.DRAGONSOUL_TAP_TITLE_6]
    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.questionDialog = None
        self.tooltipItem = None
        self.sellingSlotNumber = -1
        self.isLoaded = 0
        self.isActivated = False
        self.DSKindIndex = 0
        self.tabDict = None
        self.tabButtonDict = None
        self.deckPageIndex = 0
        self.inventoryPageIndex = 0
        self.SetWindowName("DragonSoulWindow")
        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)
    def __LoadWindow(self):
        if self.isLoaded == 1:
            return
        self.isLoaded = 1
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulwindow.py")

        except:
            import exception
            exception.Abort("dragonsoulwindow.LoadWindow.LoadObject")
        try:
            if localeInfo.IsARABIC():
                self.board = self.GetChild("Equipment_Base")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_01")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_02")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_03")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_04")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_05")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
                self.board = self.GetChild("Tab_06")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)

            wndItem = self.GetChild("ItemSlot")
            wndEquip = self.GetChild("EquipmentSlot")
            self.activateButton = self.GetChild("activate")
            self.deckTab = []
            self.deckTab.append(self.GetChild("deck1"))
            self.deckTab.append(self.GetChild("deck2"))
            self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
            self.inventoryTab = []
            self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
            self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
            self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
            self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))
            self.inventoryTab.append(self.GetChild("Inventory_Tab_05"))
            if app.ENABLE_DS_GRADE_MYTH:
                self.inventoryTab.append(self.GetChild("Inventory_Tab_06"))
            self.tabDict = {
                0    : self.GetChild("Tab_01"),
                1    : self.GetChild("Tab_02"),
                2    : self.GetChild("Tab_03"),
                3    : self.GetChild("Tab_04"),
                4    : self.GetChild("Tab_05"),
                5    : self.GetChild("Tab_06"),
            }
            self.tabButtonDict = {
                0    : self.GetChild("Tab_Button_01"),
                1    : self.GetChild("Tab_Button_02"),
                2    : self.GetChild("Tab_Button_03"),
                3    : self.GetChild("Tab_Button_04"),
                4    : self.GetChild("Tab_Button_05"),
                5    : self.GetChild("Tab_Button_06"),
            }
            self.tabText = self.GetChild("tab_text_area")
        except:
            import exception
            exception.Abort("InventoryWindow.LoadWindow.BindObject")
        ## DragonSoul Kind Tap
        for (tabKey, tabButton) in self.tabButtonDict.items():
            tabButton.SetEvent(ui.__mem_func__(self.SetDSKindIndex), tabKey)
        ## Item
        wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
        wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
        wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
        wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
        wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
        wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))

        ## Equipment
        wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptyEquipSlot))
        wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectEquipItemSlot))
        wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseEquipItemSlot))
        wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseEquipItemSlot))
        wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInEquipItem))
        wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutEquipItem))

        ## Deck
        self.deckTab[0].SetToggleDownEvent(lambda arg=0: self.SetDeckPage(arg))
        self.deckTab[1].SetToggleDownEvent(lambda arg=1: self.SetDeckPage(arg))
        self.deckTab[0].SetToggleUpEvent(lambda arg=0: self.__DeckButtonDown(arg))
        self.deckTab[1].SetToggleUpEvent(lambda arg=1: self.__DeckButtonDown(arg))
        self.deckTab[0].Down()
        ## Grade button
        self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
        self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
        self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
        self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
        self.inventoryTab[4].SetEvent(lambda arg=4: self.SetInventoryPage(arg))
        if app.ENABLE_DS_GRADE_MYTH:
            self.inventoryTab[5].SetEvent(lambda arg=5: self.SetInventoryPage(arg))
        self.inventoryTab[0].Down()
        ## Etc
        self.wndItem = wndItem
        self.wndEquip = wndEquip

        self.dlgQuestion = uiCommon.QuestionDialog2()
        self.dlgQuestion.Close()

        self.activateButton.SetToggleDownEvent(ui.__mem_func__(self.ActivateButtonClick))
        self.activateButton.SetToggleUpEvent(ui.__mem_func__(self.ActivateButtonClick))
        self.wndPopupDialog = uiCommon.PopupDialog()

        ##
        self.listHighlightedSlot = []

        ## Refresh
        self.SetInventoryPage(0)
        self.RefreshItemSlot()
        self.RefreshEquipSlotWindow()
        self.RefreshBagSlotWindow()
        self.SetDSKindIndex(0)
        self.activateButton.Enable()
        self.deckTab[self.deckPageIndex].Down()
        self.activateButton.SetUp()

    def Destroy(self):
        self.ClearDictionary()
        self.tooltipItem = None
        self.wndItem = 0
        self.wndEquip = 0
        self.activateButton = 0
        self.questionDialog = None
        self.mallButton = None
        self.inventoryTab = []
        self.deckTab = []
        self.equipmentTab = []
        self.tabDict = None
        self.tabButtonDict = None

    def Close(self):
        if None != self.tooltipItem:
            self.tooltipItem.HideToolTip()
        self.Hide()

    def __DeckButtonDown(self, deck):
        self.deckTab[deck].Down()

    def SetInventoryPage(self, page):
        if self.inventoryPageIndex != page:
            self.__HighlightSlot_ClearCurrentPage()
        self.inventoryPageIndex = page
        if app.ENABLE_DS_GRADE_MYTH:
            self.inventoryTab[(page+1)%6].SetUp()
            self.inventoryTab[(page+2)%6].SetUp()
            self.inventoryTab[(page+3)%6].SetUp()
            self.inventoryTab[(page+4)%6].SetUp()
            self.inventoryTab[(page+5)%6].SetUp()
        else:
            self.inventoryTab[(page+1)%5].SetUp()
            self.inventoryTab[(page+2)%5].SetUp()
            self.inventoryTab[(page+3)%5].SetUp()
            self.inventoryTab[(page+4)%5].SetUp()
        self.RefreshBagSlotWindow()

    def SetItemToolTip(self, tooltipItem):
        self.tooltipItem = tooltipItem

    def RefreshItemSlot(self):
        self.RefreshBagSlotWindow()
        self.RefreshEquipSlotWindow()

    def RefreshEquipSlotWindow(self):
        for i in xrange(6):
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
            itemVnum = player.GetItemIndex(slotNumber)
            self.wndEquip.SetItemSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i, itemVnum, 0)
            self.wndEquip.EnableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)

            if itemVnum != 0:
                item.SelectItem(itemVnum)
                for j in xrange(item.LIMIT_MAX_NUM):
                    (limitType, limitValue) = item.GetLimit(j)

                    # ¹Ø¿¡¼­ remain_timeÀÌ 0ÀÌÇÏÀÎÁö üũ Çϱ⠶§¹®¿¡ ÀÓÀÇÀÇ ¾ç¼ö·Î ÃʱâÈ­
                    remain_time = 999
                    # ÀÏ´Ü ÇöÀç ŸÀ̸Ӵ ÀÌ ¼¼°³ »ÓÀÌ´Ù.
                    if item.LIMIT_REAL_TIME == limitType:
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp()
                    elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp()
                    elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0)

                    if remain_time <= 0:
                        self.wndEquip.DisableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
                        break

        self.wndEquip.RefreshSlot()

    def RefreshStatus(self):
        self.RefreshItemSlot()

    def __InventoryLocalSlotPosToGlobalSlotPos(self, window_type, local_slot_pos):
        if player.INVENTORY == window_type:
            return self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + local_slot_pos

        if app.ENABLE_DS_GRADE_MYTH:
            return (self.DSKindIndex * 6 * player.DRAGON_SOUL_PAGE_SIZE) + self.inventoryPageIndex * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos
        else:
            return (self.DSKindIndex * 5 * player.DRAGON_SOUL_PAGE_SIZE) + self.inventoryPageIndex * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos

    def RefreshBagSlotWindow(self):
        getItemVNum=player.GetItemIndex
        getItemCount=player.GetItemCount
        setItemVnum=self.wndItem.SetItemSlot
        for i in xrange(player.DRAGON_SOUL_PAGE_SIZE):
            self.wndItem.EnableSlot(i)
            #<- dragon soul kind
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)

            itemCount = getItemCount(player.DRAGON_SOUL_INVENTORY, slotNumber)
            if 0 == itemCount:
                self.wndItem.ClearSlot(i)
                continue
            elif 1 == itemCount:
                itemCount = 0
            itemVnum = getItemVNum(player.DRAGON_SOUL_INVENTORY, slotNumber)

            setItemVnum(i, itemVnum, itemCount)

            if itemVnum != 0:
                item.SelectItem(itemVnum)
                for j in xrange(item.LIMIT_MAX_NUM):
                    (limitType, limitValue) = item.GetLimit(j)

                    # ¹Ø¿¡¼­ remain_timeÀÌ À½¼öÀÎÁö üũ Çϱ⠶§¹®¿¡ ÀÓÀÇÀÇ ¾ç¼ö·Î ÃʱâÈ­
                    remain_time = 999
                    if item.LIMIT_REAL_TIME == limitType:
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)
                    elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)
                    elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0)

                    if remain_time <= 0:
                        self.wndItem.DisableSlot(i)
                        break

        self.__HighlightSlot_RefreshCurrentPage()
        self.wndItem.RefreshSlot()

    def ShowToolTip(self, window_type, slotIndex):
        if None != self.tooltipItem:
            if player.INVENTORY == window_type:
                self.tooltipItem.SetInventoryItem(slotIndex)
            else:
                self.tooltipItem.SetInventoryItem(slotIndex, player.DRAGON_SOUL_INVENTORY)

    def OnPressEscapeKey(self):
        self.Close()
        return True

    def OnTop(self):
        if None != self.tooltipItem:
            self.tooltipItem.SetTop()

    # item slot °ü·Ã ÇÔ¼ö
    def OverOutItem(self):
        self.wndItem.SetUsableItem(False)
        if None != self.tooltipItem:
            self.tooltipItem.HideToolTip()

    def OverInItem(self, overSlotPos):
        self.wndItem.DeactivateSlot(overSlotPos)
        overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, overSlotPos)
        try:
            self.listHighlightedSlot.remove(overSlotPos)
        except:
            pass

        self.wndItem.SetUsableItem(False)
        self.ShowToolTip(player.DRAGON_SOUL_INVENTORY, overSlotPos)

    def __UseItem(self, slotIndex):
        ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex)
        if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotIndex, 0):
            self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_EXPIRED)
            self.wndPopupDialog.Open()
            return

        self.__EquipItem(slotIndex)

    def __EquipItem(self, slotIndex):
        ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex)
        item.SelectItem(ItemVNum)
        subType = item.GetItemSubType()
        equipSlotPos = player.DRAGON_SOUL_EQUIPMENT_SLOT_START + self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + subType
        srcItemPos = (player.DRAGON_SOUL_INVENTORY, slotIndex)
        dstItemPos = (player.INVENTORY, equipSlotPos)
        self.__OpenQuestionDialog(True, srcItemPos, dstItemPos)

    def SelectItemSlot(self, itemSlotIndex):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

        itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)

        if mouseModule.mouseController.isAttached():
            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
            #@fixme011 BEGIN (changed behavior)
            if player.SLOT_TYPE_INVENTORY == attachedSlotType:
                if player.IsDSEquipmentSlot(attachedInvenType, attachedSlotPos):
                    srcItemPos = (attachedInvenType, attachedSlotPos)
                    dstItemPos = (player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
                    self.__OpenQuestionDialog(False, srcItemPos, dstItemPos)
                else:
                    ITEM_USE = 3
                    ITEM_EXTRACT = 31
                    item.SelectItem(attachedItemVID)
                    if item.GetItemType(attachedItemVID) == ITEM_EXTRACT or\
                        item.GetItemType(attachedItemVID) == ITEM_USE and\
                        item.GetItemSubType(attachedItemVID) in (item.USE_TIME_CHARGE_PER, item.USE_TIME_CHARGE_FIX):
                        net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, itemSlotIndex)

            elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedInvenType:
                net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
            #@fixme011 END

            mouseModule.mouseController.DeattachObject()

        else:
            ## »óÁ¡¿¡¼­ Æȵµ·Ï Ãß°¡
            ## 20140220
            curCursorNum = app.GetCursor()

            if app.SELL == curCursorNum:
                self.__SellItem(itemSlotIndex)
            elif app.BUY == curCursorNum:
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
            else:
                selectedItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
                itemCount = player.GetItemCount(player.DRAGON_SOUL_INVENTORY, itemSlotIndex)
                mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_DRAGON_SOUL_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
                self.wndItem.SetUseMode(False)
                snd.PlaySound("sound/ui/pick.wav")

    ## »óÁ¡¿¡ Æȱâ
    ## 2014.02.20 Ãß°¡
    def __SellItem(self, itemSlotPos):
        if not player.IsDSEquipmentSlot(player.DRAGON_SOUL_INVENTORY, itemSlotPos):
            self.sellingSlotNumber = itemSlotPos
            itemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, itemSlotPos)
            itemCount = player.GetItemCount(player.DRAGON_SOUL_INVENTORY, itemSlotPos)

            item.SelectItem(itemIndex)

            if item.IsAntiFlag(item.ANTIFLAG_SELL):
                popup = uiCommon.PopupDialog()
                popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)
                popup.SetAcceptEvent(self.__OnClosePopupDialog)
                popup.Open()
                self.popup = popup
                return

            itemPrice = item.GetISellItemPrice()

            if item.Is1GoldItem():
                itemPrice = itemCount / itemPrice / 5
            else:
                itemPrice = itemPrice * itemCount / 5

            item.GetItemName(itemIndex)
            itemName = item.GetItemName()

            self.questionDialog = uiCommon.QuestionDialog()
            self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
            self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
            self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
            self.questionDialog.Open()
            self.questionDialog.count = itemCount

    ## »óÁ¡¿¡ Æȱâ
    def SellItem(self):

        net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count, player.DRAGON_SOUL_INVENTORY)
        snd.PlaySound("sound/ui/money.wav")
        self.OnCloseQuestionDialog()

    ## »óÁ¡¿¡ Æȱâ
    def OnCloseQuestionDialog(self):
        if self.questionDialog:
            self.questionDialog.Close()

        self.questionDialog = None

    ## »óÁ¡¿¡ Æȱâ
    def __OnClosePopupDialog(self):
        self.pop = None

    def SelectEmptySlot(self, selectedSlotPos):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

        selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
        if mouseModule.mouseController.isAttached():

            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
            attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
            if player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
                mouseModule.mouseController.RunCallBack("INVENTORY")

            elif player.SLOT_TYPE_SHOP == attachedSlotType:
                net.SendShopBuyPacket(attachedSlotPos)

            elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:
                if player.ITEM_MONEY == attachedItemIndex:
                    net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
                    snd.PlaySound("sound/ui/money.wav")

                else:
                    net.SendSafeboxCheckoutPacket(attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos)

            elif player.SLOT_TYPE_MALL == attachedSlotType:
                net.SendMallCheckoutPacket(attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos)

            #@fixme011 BEGIN (changed behavior)
            elif player.SLOT_TYPE_INVENTORY == attachedSlotType:
                if player.IsDSEquipmentSlot(attachedInvenType, attachedSlotPos):
                    srcItemPos = (attachedInvenType, attachedSlotPos)
                    dstItemPos = (player.DRAGON_SOUL_INVENTORY, selectedSlotPos)
                    self.__OpenQuestionDialog(False, srcItemPos, dstItemPos)

            elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType:
                itemCount = player.GetItemCount(attachedInvenType, attachedSlotPos)
                attachedCount = mouseModule.mouseController.GetAttachedItemCount()

                self.__SendMoveItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos, attachedCount)
            #@fixme011 END

            mouseModule.mouseController.DeattachObject()

    def UseItemSlot(self, slotIndex):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
            return
        slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, slotIndex)
        try:
            # ¿ëÈ¥¼® °­È­Ã¢ÀÌ ¿­·ÁÀÖÀ¸¸é, ¾ÆÀÌÅÛ ¿ìŬ¸¯ ½Ã ÀÚµ¿À¸·Î °­È­Ã¢À¸·Î µé¾î°¨.
            if self.wndDragonSoulRefine.IsShow():
                if uiPrivateShopBuilder.IsBuildingPrivateShop():
                    chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
                    return
                self.wndDragonSoulRefine.AutoSetItem((player.DRAGON_SOUL_INVENTORY, slotIndex), 1)
                return
        except:
            pass

        self.__UseItem(slotIndex)

        mouseModule.mouseController.DeattachObject()
        self.OverOutItem()

    def __SendMoveItemPacket(self, srcSlotWindow, srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
            return

        net.SendItemMovePacket(srcSlotWindow , srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount)

    # equip ½½·Ô °ü·Ã ÇÔ¼öµé.
    def OverOutEquipItem(self):
        self.OverOutItem()

    def OverInEquipItem(self, overSlotPos):
        overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, overSlotPos)
        self.wndItem.SetUsableItem(False)
        self.ShowToolTip(player.INVENTORY, overSlotPos)

    def UseEquipItemSlot(self, slotIndex):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
            return

        slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, slotIndex)

        self.__UseEquipItem(slotIndex)
        mouseModule.mouseController.DeattachObject()
        self.OverOutEquipItem()

    def __UseEquipItem(self, slotIndex):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
            return

        self.__OpenQuestionDialog(False, (player.INVENTORY, slotIndex), (1, 1))

    def SelectEquipItemSlot(self, itemSlotIndex):

        ## ¸¶¿ì½º ¹öÆ°ÀÌ sell buy üũ Çؼ­ return
        curCursorNum = app.GetCursor()
        if app.SELL == curCursorNum:
            return
        elif app.BUY == curCursorNum:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
            return

        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

        itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, itemSlotIndex)

        if mouseModule.mouseController.isAttached():
            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            # ÀÚ±â ÀÚ½ÅÀ» ÀÚ±â Àڽſ¡°Ô µå·¡±×ÇÏ´Â °æ¿ì
            if player.SLOT_TYPE_INVENTORY == attachedSlotType and itemSlotIndex == attachedSlotPos:
                mouseModule.mouseController.DeattachObject() #@fixme011
                return

            #@fixme011 BEGIN (enable only the extract items so far)
            attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
            if player.SLOT_TYPE_INVENTORY == attachedSlotType:
                ITEM_USE = 3
                ITEM_EXTRACT = 31
                item.SelectItem(attachedItemVID)
                if item.GetItemType(attachedItemVID) == ITEM_EXTRACT or\
                    item.GetItemType(attachedItemVID) == ITEM_USE and\
                    item.GetItemSubType(attachedItemVID) in (item.USE_TIME_CHARGE_PER, item.USE_TIME_CHARGE_FIX):
                    net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.INVENTORY, itemSlotIndex)
            #@fixme011 END

            mouseModule.mouseController.DeattachObject()
        else:
            selectedItemVNum = player.GetItemIndex(player.INVENTORY, itemSlotIndex)
            itemCount = player.GetItemCount(player.INVENTORY, itemSlotIndex)
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
            self.wndItem.SetUseMode(False)
            snd.PlaySound("sound/ui/pick.wav")

    def SelectEmptyEquipSlot(self, selectedSlot):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

        selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, selectedSlot)

        if mouseModule.mouseController.isAttached():
            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
            attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

            if player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType:
                if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, attachedSlotPos, 0):
                    self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_EXPIRED)
                    self.wndPopupDialog.Open()
                    return

                item.SelectItem(attachedItemIndex)
                subType = item.GetItemSubType()
                if subType != (selectedSlot - player.DRAGON_SOUL_EQUIPMENT_SLOT_START):
                    self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_UNMATCHED_SLOT)
                    self.wndPopupDialog.Open()
                else:
                    srcItemPos = (player.DRAGON_SOUL_INVENTORY, attachedSlotPos)
                    dstItemPos = (player.INVENTORY, selectedSlotPos)
                    self.__OpenQuestionDialog(True, srcItemPos, dstItemPos)

            mouseModule.mouseController.DeattachObject()
    # equip ½½·Ô °ü·Ã ÇÔ¼öµé ³¡.

    # °æ°íâ °ü·Ã
    def __OpenQuestionDialog(self, Equip, srcItemPos, dstItemPos):
        self.srcItemPos = srcItemPos
        self.dstItemPos = dstItemPos

        self.dlgQuestion.SetAcceptEvent(ui.__mem_func__(self.__Accept))
        self.dlgQuestion.SetCancelEvent(ui.__mem_func__(self.__Cancel))

        if Equip:
            self.dlgQuestion.SetText1(localeInfo.DRAGON_SOUL_EQUIP_WARNING1)
            self.dlgQuestion.SetText2(localeInfo.DRAGON_SOUL_EQUIP_WARNING2)
        else:
            self.dlgQuestion.SetText1(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING1)
            self.dlgQuestion.SetText2(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING2)

        self.dlgQuestion.Open()

    def __Accept(self):
        if (-1, -1) == self.dstItemPos:
            net.SendItemUsePacket(*self.srcItemPos)
        else:
            self.__SendMoveItemPacket(*(self.srcItemPos + self.dstItemPos + (0,)))
        self.dlgQuestion.Close()

    def __Cancel(self):
        self.srcItemPos = (0, 0)
        self.dstItemPos = (0, 0)
        self.dlgQuestion.Close()

    # °æ°íâ °ü·Ã ³¡

    def SetDSKindIndex(self, kindIndex):
        if self.DSKindIndex != kindIndex:
            self.__HighlightSlot_ClearCurrentPage()

        self.DSKindIndex = kindIndex

        for (tabKey, tabButton) in self.tabButtonDict.items():
            if kindIndex!=tabKey:
                tabButton.SetUp()

        for tabValue in self.tabDict.itervalues():
            tabValue.Hide()

        self.tabDict[kindIndex].Show()
        self.tabText.SetText(DragonSoulWindow.KIND_TAP_TITLES[kindIndex])

        self.RefreshBagSlotWindow()

    def SetDeckPage(self, page):
        if page == self.deckPageIndex:
            return

        if self.isActivated:
            self.DeactivateDragonSoul()
            net.SendChatPacket("/dragon_soul deactivate")
        self.deckPageIndex = page
        self.deckTab[page].Down()
        self.deckTab[(page+1)%2].SetUp()

        self.RefreshEquipSlotWindow()

    # ¿ëÈ¥¼® È°¼ºÈ­ °ü·Ã
    def ActivateDragonSoulByExtern(self, deck):
        self.isActivated = True
        self.activateButton.Down()
        self.deckPageIndex = deck
        self.deckTab[deck].Down()
        self.deckTab[(deck+1)%2].SetUp()
        self.RefreshEquipSlotWindow()

    def DeactivateDragonSoul(self):
        self.isActivated = False
        self.activateButton.SetUp()

    def ActivateButtonClick(self):
        self.isActivated = self.isActivated ^ True
        if self.isActivated:
            if self.__CanActivateDeck():
                net.SendChatPacket("/dragon_soul activate " + str(self.deckPageIndex))
            else:
                self.isActivated = False
                self.activateButton.SetUp()
        else:
            net.SendChatPacket("/dragon_soul deactivate")

    def __CanActivateDeck(self):
        canActiveNum = 0
        for i in xrange(6):
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i)
            itemVnum = player.GetItemIndex(slotNumber)

            if itemVnum != 0:
                item.SelectItem(itemVnum)
                isNoLimit = True
                for i in xrange(item.LIMIT_MAX_NUM):
                    (limitType, limitValue) = item.GetLimit(i)

                    # LIMIT_TIMER_BASED_ON_WEAR´Â ¼ÒÄÏ0¿¡ ³²Àº ½Ã°£À» ¹Ú´Â´Ù.
                    # LIMIT_REAL_TIMEÀº ½Ã°£ ´Ù µÇ¸é ¾ÆÀÌÅÛÀÌ »ç¶óÁö¹Ç·Î ÇÒ ÇÊ¿ä°¡ ¾ø´Ù.
                    # LIMIT_REAL_TIME_START_FIRST_USE´Â ¼­¹ö¿¡ Á¦´ë·Î Á¤ÀǵÇÁö ¾Ê¾Æ ÀÏ´Ü ³ÀµÐ´Ù.
                    if item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
                        isNoLimit = False
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0)
                        if 0 != remain_time:
                            canActiveNum += 1
                            break
                # ŸÀ̸Ӱ¡ ¾ø´Ù¸é ActivateÇÒ ¼ö ÀÖ´Â ¿ëÈ¥¼®.
                if isNoLimit:
                    canActiveNum += 1

        return canActiveNum > 0

    # È°¼ºÈ­ °ü·Ã ³¡

    # ½½·Ô highlight °ü·Ã
    def __HighlightSlot_ClearCurrentPage(self):
        for i in xrange(self.wndItem.GetSlotCount()):
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)
            if slotNumber in self.listHighlightedSlot:
                self.wndItem.DeactivateSlot(i)
                self.listHighlightedSlot.remove(slotNumber)

    def __HighlightSlot_RefreshCurrentPage(self):
        for i in xrange(self.wndItem.GetSlotCount()):
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i)
            if slotNumber in self.listHighlightedSlot:
                self.wndItem.ActivateSlot(i)

    def HighlightSlot(self, slot):
        if not slot in self.listHighlightedSlot:
            self.listHighlightedSlot.append (slot)
    # ½½·Ô highlight °ü·Ã ³¡

    def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):
        if app.ENABLE_DRAGON_SOUL_SYSTEM:
            from _weakref import proxy
            self.wndDragonSoulRefine = proxy(wndDragonSoulRefine)

## °­È­ÇÒ ¼ö ¾ø´Â °æ¿ì ³¯¸®´Â ¿¹¿Ü
#class DragonSoulRefineException(Exception):
    #pass

class DragonSoulRefineWindow(ui.ScriptWindow):
    REFINE_TYPE_GRADE, REFINE_TYPE_STEP, REFINE_TYPE_STRENGTH = xrange(3)
    DS_SUB_HEADER_DIC = {
        REFINE_TYPE_GRADE : player.DS_SUB_HEADER_DO_UPGRADE,
        REFINE_TYPE_STEP : player.DS_SUB_HEADER_DO_IMPROVEMENT,
        REFINE_TYPE_STRENGTH : player.DS_SUB_HEADER_DO_REFINE
    }
    REFINE_STONE_SLOT, DRAGON_SOUL_SLOT = xrange(2)

    INVALID_DRAGON_SOUL_INFO = -1

    def __init__(self):
        ui.ScriptWindow.__init__(self)
        self.tooltipItem = None
        self.sellingSlotNumber = -1
        self.isLoaded = 0
        self.refineChoiceButtonDict = None
        self.doRefineButton = None
        self.wndMoney = None
        self.SetWindowName("DragonSoulRefineWindow")
        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()
        ui.ScriptWindow.Show(self)

    def __LoadWindow(self):
        if self.isLoaded == 1:
            return
        self.isLoaded = 1
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulrefinewindow.py")

        except:
            import exception
            exception.Abort("dragonsoulrefinewindow.LoadWindow.LoadObject")
        try:
            if localeInfo.IsARABIC():
                self.board = self.GetChild("DragonSoulRefineWindowBaseImage")
                self.board.SetScale(-1.0, 1.0)
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)

            wndRefineSlot = self.GetChild("RefineSlot")
            wndResultSlot = self.GetChild("ResultSlot")
            self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
            self.refineChoiceButtonDict = {
                self.REFINE_TYPE_GRADE    : self.GetChild("GradeButton"),
                self.REFINE_TYPE_STEP: self.GetChild("StepButton"),
                self.REFINE_TYPE_STRENGTH    : self.GetChild("StrengthButton"),
            }
            self.doRefineButton = self.GetChild("DoRefineButton")
            self.wndMoney = self.GetChild("Money_Slot")

        except:
            import exception
            exception.Abort("DragonSoulRefineWindow.LoadWindow.BindObject")

        ## Item Slots
        wndRefineSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInRefineItem))
        wndRefineSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
        wndRefineSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.__SelectRefineEmptySlot))
        wndRefineSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
        wndRefineSlot.SetUseSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))
        wndRefineSlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot))

        wndResultSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInResultItem))
        wndResultSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem))
        self.wndRefineSlot = wndRefineSlot
        self.wndResultSlot = wndResultSlot

        ## Button
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleDownEvent(self.__ToggleDownGradeButton)
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleDownEvent(self.__ToggleDownStepButton)
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleDownEvent(self.__ToggleDownStrengthButton)
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_GRADE))
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STEP))
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STRENGTH))
        self.doRefineButton.SetEvent(self.__PressDoRefineButton)

        ## Dialog
        self.wndPopupDialog = uiCommon.PopupDialog()

        self.currentRefineType = self.REFINE_TYPE_GRADE
        self.refineItemInfo = {}
        self.resultItemInfo = {}
        self.currentRecipe = {}

        self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down()

        self.__Initialize()

    def Destroy(self):
        self.ClearDictionary()
        self.tooltipItem = None
        self.wndItem = 0
        self.wndEquip = 0
        self.activateButton = 0
        self.questionDialog = None
        self.mallButton = None
        self.inventoryTab = []
        self.deckTab = []
        self.equipmentTab = []
        self.tabDict = None
        self.tabButtonDict = None

    def Close(self):
        if None != self.tooltipItem:
            self.tooltipItem.HideToolTip()

        self.__FlushRefineItemSlot()
        player.SendDragonSoulRefine(player.DRAGON_SOUL_REFINE_CLOSE)
        self.Hide()

    def Show(self):
        self.currentRefineType = self.REFINE_TYPE_GRADE
        self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down()
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetUp()
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetUp()

        self.Refresh()

        ui.ScriptWindow.Show(self)

    def SetItemToolTip(self, tooltipItem):
        self.tooltipItem = tooltipItem

    # ¹öÆ° ´­·Á ÀÖ´Â »óŸ¦ Á¦¿ÜÇÑ ¸ðµç °­È­Ã¢ °ü·Ã º¯¼öµéÀ» ÃʱâÈ­.
    def __Initialize(self):
        self.currentRecipe = {}
        self.refineItemInfo = {}
        self.resultItemInfo = {}

        if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
            self.refineSlotLockStartIndex = 2
        else:
            self.refineSlotLockStartIndex = 1

        for i in xrange(self.refineSlotLockStartIndex):
            self.wndRefineSlot.HideSlotBaseImage(i)

        self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))

    def __FlushRefineItemSlot(self):
        ## Item slot settings
        # ¿ø·¡ Àκ¥ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® ȸº¹
        for invenType, invenPos, itemCount in self.refineItemInfo.values():
            remainCount = player.GetItemCount(invenType, invenPos)
            player.SetItemCount(invenType, invenPos, remainCount + itemCount)
        self.__Initialize()

    def __ToggleUpButton(self, idx):
        #if self.REFINE_TYPE_GRADE == self.currentRefineType:
        self.refineChoiceButtonDict[idx].Down()

    def __ToggleDownGradeButton(self):
        if self.REFINE_TYPE_GRADE == self.currentRefineType:
            return
        self.refineChoiceButtonDict[self.currentRefineType].SetUp()
        self.currentRefineType = self.REFINE_TYPE_GRADE
        self.__FlushRefineItemSlot()
        self.Refresh()

    def __ToggleDownStepButton(self):
        if self.REFINE_TYPE_STEP == self.currentRefineType:
            return
        self.refineChoiceButtonDict[self.currentRefineType].SetUp()
        self.currentRefineType = self.REFINE_TYPE_STEP
        self.__FlushRefineItemSlot()
        self.Refresh()

    def __ToggleDownStrengthButton(self):
        if self.REFINE_TYPE_STRENGTH == self.currentRefineType:
            return
        self.refineChoiceButtonDict[self.currentRefineType].SetUp()
        self.currentRefineType = self.REFINE_TYPE_STRENGTH
        self.__FlushRefineItemSlot()
        self.Refresh()

    def __PopUp(self, message):
        self.wndPopupDialog.SetText(message)
        self.wndPopupDialog.Open()

    def __SetItem(self, inven, dstSlotIndex, itemCount):
        invenType, invenPos = inven

        if dstSlotIndex >= self.refineSlotLockStartIndex:
            return False

        itemVnum = player.GetItemIndex(invenType, invenPos)
        maxCount = player.GetItemCount(invenType, invenPos)

        if itemCount > maxCount:
            raise Exception, ("Invalid attachedItemCount(%d). (base pos (%d, %d), base itemCount(%d))" % (itemCount, invenType, invenPos, maxCount))
            #return False

        # strength °­È­ÀÏ °æ¿ì, 0¹ø¿£ °­È­¼®, 1¹ø¿£ ¿ëÈ¥¼®À» ³õµµ·Ï °­Á¦ÇÔ.
        if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
            if self.__IsDragonSoul(itemVnum):
                dstSlotIndex = 1
            else:
                dstSlotIndex = 0

        # ºó ½½·ÔÀ̾î¾ßÇÔ.
        if dstSlotIndex in self.refineItemInfo:
            return False

        # °­È­Ã¢¿¡ ¿Ã¸± ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀÎÁö °Ë»ç.
        if False == self.__CheckCanRefine(itemVnum):
            return False

        # ²ø¾î´Ù ³õÀº ¾ÆÀÌÅÛ Ä«¿îÆ®¸¸Å­ ¿ø·¡ ÀÚ¸®ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® °¨¼Ò
        player.SetItemCount(invenType, invenPos, maxCount - itemCount)
        self.refineItemInfo[dstSlotIndex] = (invenType, invenPos, itemCount)
        self.Refresh()

        return True

    # °­È­ °¡´ÉÇÑ ¾ÆÀÌÅÛÀÎÁö üũ
    # ¿ëÈ¥¼® °­È­´Â °­È­ ·¹½ÃÇǸ¦ Á¤Çسõ°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó,
    # óÀ½¿¡ °­È­Ã¢¿¡ ¿Ã¸° ¿ëÈ¥¼®¿¡ ÀÇÇØ °­È­ ·¹½ÃÇÇ°¡ °áÁ¤µÈ´Ù.
    # ±×·¡¼­ __CanRefineGrade, __CanRefineStep, __CanRefineStrength ÇÔ¼ö¿¡¼­
    # °­È­ ·¹½ÃÇÇ°¡ ¾ø´Ù¸é(óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀ̶ó¸é), °­È­ ·¹½ÃÇǸ¦ ¼³Á¤ÇØÁÖ´Â ¿ªÇÒµµ ÇÑ´Ù.
    def __CheckCanRefine(self, vnum):
        if self.REFINE_TYPE_GRADE == self.currentRefineType:
            return self.__CanRefineGrade(vnum)

        elif self.REFINE_TYPE_STEP == self.currentRefineType:
            return self.__CanRefineStep(vnum)

        elif self.REFINE_TYPE_STRENGTH == self.currentRefineType:
            return self.__CanRefineStrength(vnum)

        else:
            return False

    def __CanRefineGrade(self, vnum):
        ds_info = self.__GetDragonSoulTypeInfo(vnum)

        if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info:
            self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
            return False

        if self.currentRecipe:
            ds_type, grade, step, strength = ds_info
            cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"]
            if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade):
                self.__PopUp(localeInfo.DRAGON_SOUL_INVALID_DRAGON_SOUL)
                return False
        # °­È­ â¿¡ óÀ½ ¾ÆÀÌÅÛÀ» ¿Ã¸®´Â °æ¿ì, °­È­ Àç·á¿¡ °üÇÑ Á¤º¸°¡ ¾ø´Ù.
        # ¿ëÈ¥¼® °­È­°¡, ·¹½ÃÇǸ¦ °¡Áö°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, °­È­Ã¢¿¡ óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀÌ ¹«¾ùÀ̳Ŀ¡ µû¶ó,
        # ¹«¾ùÀ» °­È­ÇÏ°í, Àç·á°¡ ¹«¾ùÀÎÁö(ÀÌÇÏ ·¹½ÃÇÇ)°¡ Á¤ÇØÁø´Ù.
        # ·¹½ÃÇÇ°¡ ¾ø´Ù¸é, óÀ½ ¿Ã¸° ¾ÆÀÌÅÛÀ̶ó »ý°¢ÇÏ°í, vnumÀ» ¹ÙÅÁÀ¸·Î ·¹½ÃÇǸ¦ ¼ÂÆÃ.
        else:
            self.currentRecipe = self.__GetRefineGradeRecipe(vnum)

            if self.currentRecipe:
                self.refineSlotLockStartIndex = self.currentRecipe["need_count"]
                self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
                return True
            else:
            # °­È­ Á¤º¸ ¼ÂÆÿ¡ ½ÇÆÐÇÏ¸é ¿Ã¸± ¼ö ¾ø´Â ¾ÆÀÌÅÛÀ¸·Î ÆÇ´Ü.
                self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE)
                return False

    def __CanRefineStep (self, vnum):
        ds_info = self.__GetDragonSoulTypeInfo(vnum)

        if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info:
            self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
            return False

        if self.currentRecipe:
            ds_type, grade, step, strength = ds_info
            cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"]
            if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade and cur_refine_step == step):
                self.__PopUp(localeInfo.DRAGON_SOUL_INVALID_DRAGON_SOUL)
                return False
        # °­È­ â¿¡ óÀ½ ¾ÆÀÌÅÛÀ» ¿Ã¸®´Â °æ¿ì, Àç·á¿¡ °üÇÑ Á¤º¸°¡ ¾ø´Ù.
        # ¿ëÈ¥¼® °­È­°¡, ·¹½ÃÇǸ¦ °¡Áö°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, °­È­Ã¢¿¡ óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀÌ ¹«¾ùÀ̳Ŀ¡ µû¶ó,
        # ¹«¾ùÀ» °­È­ÇÏ°í, Àç·á°¡ ¹«¾ùÀÎÁö(ÀÌÇÏ ·¹½ÃÇÇ)°¡ Á¤ÇØÁø´Ù.
        # ·¹½ÃÇÇ°¡ ¾ø´Ù¸é, óÀ½ ¿Ã¸° ¾ÆÀÌÅÛÀ̶ó »ý°¢ÇÏ°í, vnumÀ» ¹ÙÅÁÀ¸·Î ·¹½ÃÇǸ¦ ¼ÂÆÃ.
        else:
            self.currentRecipe = self.__GetRefineStepRecipe(vnum)

            if self.currentRecipe:
                self.refineSlotLockStartIndex = self.currentRecipe["need_count"]
                self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
                return True

            else:
            # °­È­ Á¤º¸ ¼ÂÆÿ¡ ½ÇÆÐÇÏ¸é ¿Ã¸± ¼ö ¾ø´Â ¾ÆÀÌÅÛÀ¸·Î ÆÇ´Ü.
                self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE)
                return False

    def __CanRefineStrength (self, vnum):
        # ¿ëÈ¥¼®ÀÎ °æ¿ì, ´õ ÀÌ»ó strength °­È­¸¦ ÇÒ ¼ö ¾ø´ÂÁö üũÇؾßÇÔ.
        if self.__IsDragonSoul(vnum):
            ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)

            import dragon_soul_refine_settings
            if strength >= dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["strength_max_table"][grade][step]:
                self.__PopUp(localeInfo.DRAGON_SOUL_CANNOT_REFINE_MORE)
                return False

            else:
                return True

        # strength °­È­ÀÇ °æ¿ì, refine_recipe°¡ ¿ëÈ¥¼®ÀÇ Á¾·ù°¡ ¾Æ´Ñ, °­È­¼®ÀÇ Á¾·ù¿¡ µû¶ó ´Þ¶óÁø´Ù.
        # µû¶ó¼­ ¿ëÈ¥¼®ÀÌ ¾Æ´Ï¶ó¸é,
        # ÀÌ¹Ì ·¹½ÃÇÇ°¡ ÀÖ´Â °æ¿ì´Â, °­È­¼®ÀÌ °­È­Ã¢¿¡ ÀÖ´Ù´Â °ÍÀ̹ǷÎ, return False
        # ·¹½ÃÇÇ°¡ ¾ø´Â °æ¿ì´Â, °­È­¼®ÀÎÁö È®ÀÎÇÏ°í, ·¹½ÃÇǸ¦ ¼ÂÆÃÇÑ´Ù.
        else:
            if self.currentRecipe:
                self.__PopUp(localeInfo.DRAGON_SOUL_IS_NOT_DRAGON_SOUL)
                return False
            else:
                refineRecipe = self.__GetRefineStrengthInfo(vnum)
                if refineRecipe:
                    self.currentRecipe = refineRecipe
                    self.wndMoney.SetText(localeInfo.NumberToMoneyString(self.currentRecipe["fee"]))
                    return True
                else:
                # ·¹½ÃÇǸ¦ ¼ÂÆÃÇÒ ¼ö ¾ø´Â °æ¿ì
                    self.__PopUp(localeInfo.DRAGON_SOUL_NOT_DRAGON_SOUL_REFINE_STONE)
                    return False

    def __GetRefineGradeRecipe (self, vnum):
        ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
        try:
            import dragon_soul_refine_settings

            return    {
                "ds_info"        : (ds_type, grade, step, strength),
                "need_count"    : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_need_count"][grade],
                "fee"            : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_fee"][grade]
                    }
        except:
            return None

    def __GetRefineStepRecipe (self, vnum):
        ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum)
        try:
            import dragon_soul_refine_settings

            return    {
                "ds_info"        : (ds_type, grade, step, strength),
                "need_count"    : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_need_count"][step],
                "fee"            : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_fee"][step]
                    }
        except:
            return None

    # strength °­È­ÀÇ °æ¿ì, refineInfo´Â °­È­¼®¿¡ µû¶ó ´Þ¶óÁø´Ù.
    def __GetRefineStrengthInfo (self, itemVnum):
        try:
            # À̳ðÀÇ À§Ä¡¸¦ ¾îÂîÇÏÁö....
            # °­È­¼®ÀÌ ¾Æ´Ï¸é ¾ÈµÊ.
            item.SelectItem(itemVnum)
            if not (item.ITEM_TYPE_MATERIAL == item.GetItemType() \
                    and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)):
                return None

            import dragon_soul_refine_settings
            return { "fee" : dragon_soul_refine_settings.strength_fee[item.GetItemSubType()] }
        except:
            return None

    def __IsDragonSoul(self, vnum):
        item.SelectItem(vnum)
        return item.GetItemType() == item.ITEM_TYPE_DS

    # ¿ëÈ¥¼® Vnum¿¡ ´ëÇÑ comment
    # ITEM VNUMÀ» 10¸¸ ÀÚ¸®ºÎÅÍ, FEDCBA¶ó°í ÇÑ´Ù¸é
    # FE : ¿ëÈ¥¼® Á¾·ù.    D : µî±Þ
    # C : ´Ü°è            B : °­È­
    # A : ¿©¹úÀÇ ¹øÈ£µé...
    def __GetDragonSoulTypeInfo(self, vnum):
        if not self.__IsDragonSoul(vnum):
            return DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO
        ds_type = vnum / 10000
        grade = vnum % 10000 /1000
        step = vnum % 1000 / 100
        strength = vnum % 100 / 10

        return (ds_type, grade, step, strength)

    def __MakeDragonSoulVnum(self, ds_type, grade, step, strength):
        return ds_type * 10000 + grade * 1000 + step * 100 + strength * 10

    ## ºó ½½·Ô ¼±Åà Event
    def __SelectRefineEmptySlot(self, selectedSlotPos):
        try:
            if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
                return

            if selectedSlotPos >= self.refineSlotLockStartIndex:
                return

            if mouseModule.mouseController.isAttached():
                attachedSlotType = mouseModule.mouseController.GetAttachedType()
                attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
                attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
                mouseModule.mouseController.DeattachObject()

                if uiPrivateShopBuilder.IsBuildingPrivateShop():
                    chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
                    return

                attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)

                if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
                    return

                if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
                    return

                if True == self.__SetItem((attachedInvenType, attachedSlotPos), selectedSlotPos, attachedItemCount):
                    self.Refresh()

        except Exception, e:
            import dbg
            dbg.TraceError("Exception : __SelectRefineEmptySlot, %s" % e)

    # Ŭ¸¯À¸·Î ½½·Ô¿¡¼­ »èÁ¦.
    def __SelectRefineItemSlot(self, selectedSlotPos):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

        try:
            if not selectedSlotPos in self.refineItemInfo:
                # »õ·Î¿î ¾ÆÀÌÅÛÀ» °­È­Ã¢¿¡ ¿Ã¸®´Â ÀÛ¾÷.
                if mouseModule.mouseController.isAttached():
                    attachedSlotType = mouseModule.mouseController.GetAttachedType()
                    attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                    attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
                    attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
                    mouseModule.mouseController.DeattachObject()

                    if uiPrivateShopBuilder.IsBuildingPrivateShop():
                        chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
                        return

                    attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)

                    if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos):
                        return

                    if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType:
                        return

                    self.AutoSetItem((attachedInvenType, attachedSlotPos), 1)
                return
            elif mouseModule.mouseController.isAttached():
                return

            attachedInvenType, attachedSlotPos, attachedItemCount = self.refineItemInfo[selectedSlotPos]
            selectedItemVnum = player.GetItemIndex(attachedInvenType, attachedSlotPos)

            # °­È­Ã¢¿¡¼­ »èÁ¦ ¹× ¿ø·¡ Àκ¥ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® ȸº¹
            invenType, invenPos, itemCount = self.refineItemInfo[selectedSlotPos]
            remainCount = player.GetItemCount(invenType, invenPos)
            player.SetItemCount(invenType, invenPos, remainCount + itemCount)
            del self.refineItemInfo[selectedSlotPos]

            # °­È­Ã¢ÀÌ ºñ¾ú´Ù¸é, ÃʱâÈ­
            if not self.refineItemInfo:
                self.__Initialize()
            else:
                item.SelectItem(selectedItemVnum)
                # ¾ø¾Ø ¾ÆÀÌÅÛÀÌ °­È­¼®À̾ú´Ù¸é °­È­ ·¹Çǽà ÃʱâÈ­
                if (item.ITEM_TYPE_MATERIAL == item.GetItemType() \
                    and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)):
                    self.currentRecipe = {}
                    self.wndMoney.SetText(localeInfo.NumberToMoneyString(0))
                # ¿ëÈ¥¼®À̾ú´Ù¸é,
                # strength°­È­°¡ ¾Æ´Ñ °æ¿ì, °­È­Ã¢¿¡ ´Ù¸¥ ¿ëÈ¥¼®ÀÌ ³²¾ÆÀÖÀ¸¹Ç·Î, ·¹½ÃÇǸ¦ ÃʱâÈ­ÇÏ¸é ¾ÈµÊ.
                # strength°­È­ÀÇ °æ¿ì, °­È­ ·¹½ÃÇÇ´Â °­È­¼®¿¡ Á¾¼ÓµÈ °ÍÀ̹ǷΠ´Ù¸¥ ó¸®ÇÒ ÇÊ¿ä°¡ ¾øÀ½.
                else:
                    pass

        except Exception, e:
            import dbg
            dbg.TraceError("Exception : __SelectRefineItemSlot, %s" % e)

        self.Refresh()

    def __OverInRefineItem(self, slotIndex):
        if self.refineItemInfo.has_key(slotIndex):
            inven_type, inven_pos, item_count = self.refineItemInfo[slotIndex]
            self.tooltipItem.SetInventoryItem(inven_pos, inven_type)

    def __OverInResultItem(self, slotIndex):
        if self.resultItemInfo.has_key(slotIndex):
            inven_type, inven_pos, item_count = self.resultItemInfo[slotIndex]
            self.tooltipItem.SetInventoryItem(inven_pos, inven_type)

    def __OverOutItem(self):
        if self.tooltipItem:
            self.tooltipItem.HideToolTip()

    def __PressDoRefineButton(self):
        for i in xrange(self.refineSlotLockStartIndex):
            if not i in self.refineItemInfo:
                self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_NOT_ENOUGH_MATERIAL)
                self.wndPopupDialog.Open()

                return

        player.SendDragonSoulRefine(DragonSoulRefineWindow.DS_SUB_HEADER_DIC[self.currentRefineType], self.refineItemInfo)

    def OnPressEscapeKey(self):
        self.Close()
        return True

    def Refresh(self):
        self.__RefreshRefineItemSlot()
        self.__ClearResultItemSlot()

    def __RefreshRefineItemSlot(self):
        try:
            for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
                self.wndRefineSlot.ClearSlot(slotPos)
                if slotPos < self.refineSlotLockStartIndex:
                    # self.refineItemInfo[slotPos]ÀÇ Á¤º¸È®ÀÎ
                    # (½ÇÁ¦·Î ¾ÆÀÌÅÛÀÌ Á¸ÀçÇÏ´ÂÁö È®ÀÎ)
                    # Á¸Àç -> ¾ÆÀÌÅÛ ¾ÆÀÌÄÜÀ» ½½·Ô¿¡ ¼ÂÆÃ.
                    # ºñÁ¸Àç -> ¾ÆÀÌÅÛÀÌ ¾øÀ¸¹Ç·Î °­È­Ã¢¿¡¼­ »èÁ¦.
                    if slotPos in self.refineItemInfo:
                        invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
                        itemVnum = player.GetItemIndex(invenType, invenPos)

                        # if itemVnum:
                        if itemVnum:
                            self.wndRefineSlot.SetItemSlot(slotPos, player.GetItemIndex(invenType, invenPos), itemCount)
                        else:
                            del self.refineItemInfo[slotPos]

                    # ºó ½½·Ô¿¡ reference ¾ÆÀÌÄÜÀ» alpha 0.5·Î ¼ÂÆÃ.
                    if not slotPos in self.refineItemInfo:
                        try:
                            reference_vnum = 0
                            # strength °­È­ÀÏ ¶§´Â,
                            # 0¹ø ½½·Ô¿¡ °­È­¼®À», 1¹ø ½½·Ô¿¡ ¿ëÈ¥¼®À» ³õ´Â´Ù.
                            if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
                                if DragonSoulRefineWindow.REFINE_STONE_SLOT == slotPos:
                                    reference_vnum = 100300
                            else:
                                reference_vnum = self.__MakeDragonSoulVnum(*self.currentRecipe["ds_info"])
                            if 0 != reference_vnum:
                                item.SelectItem(reference_vnum)
                                itemIcon = item.GetIconImage()
                                (width, height) = item.GetItemSize()
                                self.wndRefineSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5))
                                # slot ¿ìÃø ÇÏ´Ü¿¡ ¼ýÀÚ ¶ß¸é ¾È ¿¹»Ý...
                                self.wndRefineSlot.SetSlotCount(slotPos, 0)
                        except:
                            pass
                    # refineSlotLockStartIndex º¸´Ù ÀÛÀº ½½·ÔÀº ´ÝÈù À̹ÌÁö¸¦ º¸¿©ÁÖ¸é ¾ÈµÊ.
                    self.wndRefineSlot.HideSlotBaseImage(slotPos)
                # slotPos >= self.refineSlotLockStartIndex:
                else:
                    # Á¤»óÀûÀÎ °æ¿ì¶ó¸é ÀÌ if¹®¿¡ µé¾î°¥ ÀÏÀº ¾ø°ÚÁö¸¸,
                    # (¾ÖÃÊ¿¡ À妽º°¡ refineSlotLockStartIndex ÀÌ»óÀÎ ½½·Ô¿¡´Â ¾ÆÀÌÅÛÀ» ³ÖÁö ¸øÇÏ°Ô Ç߱⠶§¹®)
                    # Ȥ½Ã ¸ð¸¦ ¿¡·¯¿¡ ´ëºñÇÔ.
                    if slotPos in self.refineItemInfo:
                        invenType, invenPos, itemCount = self.refineItemInfo[slotPos]
                        remainCount = player.GetItemCount(invenType, invenPos)
                        player.SetItemCount(invenType, invenPos, remainCount + itemCount)
                        del self.refineItemInfo[slotPos]
                    # refineSlotLockStartIndex ÀÌ»óÀÎ ½½·ÔÀº ´ÝÈù À̹ÌÁö¸¦ º¸¿©Áà¾ßÇÔ.
                    self.wndRefineSlot.ShowSlotBaseImage(slotPos)

            # °­È­Ã¢¿¡ ¾Æ¹«·± ¾ÆÀÌÅÛÀÌ ¾ø´Ù¸é, ÃʱâÈ­ÇØÁÜ.
            # À§¿¡¼­ Áß°£ Áß°£¿¡ "del self.refineItemInfo[slotPos]"¸¦ Ç߱⠶§¹®¿¡,
            # ¿©±â¼­ Çѹø üũÇØÁà¾ßÇÔ.
            if not self.refineItemInfo:
                self.__Initialize()

            self.wndRefineSlot.RefreshSlot()
        except Exception, e:
            import dbg
            dbg.TraceError("Exception : __RefreshRefineItemSlot, %s" % e)

    def __GetEmptySlot(self, itemVnum = 0):
        # STRENGTH °­È­ÀÇ °æ¿ì, ¿ëÈ¥¼® ½½·Ô°ú °­È­¼® ½½·ÔÀÌ ±¸ºÐµÇ¾îÀֱ⠋š¹®¿¡
        # vnumÀ» ¾Ë¾Æ¾ß ÇÑ´Ù.
        if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType:
            if 0 == itemVnum:
                return -1

            if self.__IsDragonSoul(itemVnum):
                if not DragonSoulRefineWindow.DRAGON_SOUL_SLOT in self.refineItemInfo:
                    return DragonSoulRefineWindow.DRAGON_SOUL_SLOT
            else:
                if not DragonSoulRefineWindow.REFINE_STONE_SLOT in self.refineItemInfo:
                    return DragonSoulRefineWindow.REFINE_STONE_SLOT
        else:
            for slotPos in xrange(self.wndRefineSlot.GetSlotCount()):
                if not slotPos in self.refineItemInfo:
                    return slotPos

        return -1

    def AutoSetItem(self, inven, itemCount):
        invenType, invenPos = inven
        itemVnum = player.GetItemIndex(invenType, invenPos)
        emptySlot = self.__GetEmptySlot(itemVnum)
        if -1 == emptySlot:
            return

        self.__SetItem((invenType, invenPos), emptySlot, itemCount)

    def __ClearResultItemSlot(self):
        self.wndResultSlot.ClearSlot(0)
        self.resultItemInfo = {}

    def RefineSucceed(self, inven_type, inven_pos):
        self.__Initialize()
        self.Refresh()

        itemCount = player.GetItemCount(inven_type, inven_pos)
        if itemCount > 0:
            self.resultItemInfo[0] = (inven_type, inven_pos, itemCount)
            self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount)

    def    RefineFail(self, reason, inven_type, inven_pos):
        if net.DS_SUB_HEADER_REFINE_FAIL == reason:
            self.__Initialize()
            self.Refresh()
            itemCount = player.GetItemCount(inven_type, inven_pos)
            if itemCount > 0:
                self.resultItemInfo[0] = (inven_type, inven_pos, itemCount)
                self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount)
        else:
            self.Refresh()

    def SetInventoryWindows(self, wndInventory, wndDragonSoul):
        self.wndInventory = wndInventory
        self.wndDragonSoul = wndDragonSoul
 

My dragonsoul.py:

Maybe somebody can see what i did wrong

[metrix2020 4]

T/C the problem was from item_proto, the size was on 0