Çözüldü Üzerine sürükleyince çalıştırma kodu?

                            if (!IsValidItemPosition(DestCell))
                                return false;

                            LPITEM item2 = GetItem(DestCell);

                            if (!item2)
                                return false;

                            if (item2->IsExchanging())
                                return false;

                            if (item2->IsEquipped())
                                return false;

case USE_ADD_ACCESSORY_SOCKET:
            {
                char buf[21];
                snprintf(buf, sizeof(buf), "%u", item2->GetID());

                if (item2->IsAccessoryForSocket())
                {

            case USE_ADD_ACCESSORY_SOCKET:
            {
                char buf[21];
                snprintf(buf, sizeof(buf), "%u", item2->GetID());

                if (item2->IsAccessoryForSocket())
                {
                    // EKLENEN KODLAR
                    if(item->GetVnum() == ESYANIN_KODU)
                    {
                        if ((item2->GetType() == ITEM_COSTUME) && (item2->GetSubType() == COSTUME_ACCE))
                        {
                            item2->SetSocket(2, 1);
                            item->SetCount(item->GetCount() - 1);
                        }
                        else
                        {
                            ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Bu öğe sadece kuşaklara özeldir."));
                        }
                    }   
                    // EKLENEN KODLAR - SON

71500    Kuşak Bonus Arttırıcı    ITEM_USE    USE_SPECIAL    1    NONE    LOG    NONE    NONE    0    0    0    0    0    LIMIT_NONE    0    LIMIT_NONE    0    APPLY_NONE    0    APPLY_NONE    0    APPLY_NONE    0    0    0    0    0    0    0    0    0    0

71500    Kuşak Bonus Arttırıcı    ITEM_USE    USE_CHANGE_ATTRIBUTE    1    NONE    LOG    NONE        0    0    0    0    0    LIMIT_NONE    0    LIMIT_NONE    0    APPLY_NONE    0    APPLY_NONE    0    APPLY_NONE    0    0    0    0    0    0    0    0    0    0

if (ITEM_COSTUME == item2->GetType())
{
    ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
    return false;
}

if (ITEM_COSTUME == item2->GetType() && item2->GetSubType() != COSTUME_ACCE)
{
    ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
    return false;
}

                    case USE_SPECIAL:
                        switch (item->GetVnum())
                        {
                            case 71500:
                                {
                                    LPITEM item2;

                                    if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
                                        return false;

                                    if (item2->IsExchanging())
                                        return false;

                                    if (item2->IsEquipped())
                                        return false;

                                    if ((item2->GetType() != ITEM_COSTUME) && (item2->GetSubType() != COSTUME_ACCE))
                                    {
                                        ChatPacket(CHAT_TYPE_INFO, "Bu öğe kuşaklara özeldir.");
                                        return false;
                                    }

                                    if (item2->GetValue(ACCE_GRADE_VALUE_FIELD) == 4)
                                    {
                                        item2->SetSocket(ACCE_BOOSTER_SOCKET, 1);
                                        item->SetCount(item->GetCount() - 1);
                                    }
                                    else
                                    {
                                        ChatPacket(CHAT_TYPE_INFO, "Bu öğe sadece 11 emiş ve üzeri kuşaklara özeldir.");
                                    }
                                }
                                break;

    def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
        if srcItemSlotPos == dstItemSlotPos:
            return
               
        elif item.IsRefineScroll(srcItemVID):
            self.RefineItem(srcItemSlotPos, dstItemSlotPos)
            self.wndItem.SetUseMode(False)

        elif item.IsMetin(srcItemVID):
            self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

        elif item.IsDetachScroll(srcItemVID):
            self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

        elif item.IsKey(srcItemVID):
            self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)          

        elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
            self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

        elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
            self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)          

        elif player.GetItemIndex(srcItemSlotPos) == 71500:
            self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

        else:
            #snd.PlaySound("sound/ui/drop.wav")

            ## À̵¿½ÃŲ °÷ÀÌ ÀåÂø ½½·ÔÀÏ °æ¿ì ¾ÆÀÌÅÛÀ» »ç¿ëÇؼ ÀåÂø ½ÃŲ´Ù - [levites]
            if player.IsEquipmentSlot(dstItemSlotPos):

                ## µé°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ÀåºñÀ϶§¸¸
                if item.IsEquipmentVID(srcItemVID):
                    self.__UseItem(srcItemSlotPos)

            else:
                self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
                #net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)

    def __SellItem(self, itemSlotPos):
        if not player.IsEquipmentSlot(itemSlotPos):
            self.sellingSlotNumber = itemSlotPos
            itemIndex = player.GetItemIndex(itemSlotPos)
            itemCount = player.GetItemCount(itemSlotPos)
           
           
            self.sellingSlotitemIndex = itemIndex
            self.sellingSlotitemCount = itemCount

            item.SelectItem(itemIndex)
            ## ¾ÈƼ Ç÷¹±× °Ë»ç ºüÁ®¼ Ãß°¡
            ## 20140220
            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
       
            constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

    def __OnClosePopupDialog(self):
        self.pop = None

    def RefineItem(self, scrollSlotPos, targetSlotPos):

        scrollIndex = player.GetItemIndex(scrollSlotPos)
        targetIndex = player.GetItemIndex(targetSlotPos)

        if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
            return
        if app.ENABLE_REFINE_RENEWAL:
            constInfo.AUTO_REFINE_TYPE = 1
            constInfo.AUTO_REFINE_DATA["ITEM"][0] = scrollSlotPos
            constInfo.AUTO_REFINE_DATA["ITEM"][1] = targetSlotPos

        ###########################################################
        self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
        #net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)
        return
        ###########################################################

        ###########################################################
        #net.SendRequestRefineInfoPacket(targetSlotPos)
        #return
        ###########################################################

        result = player.CanRefine(scrollIndex, targetSlotPos)

        if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
            #snd.PlaySound("sound/ui/jaeryun_fail.wav")
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_MORE_SOCKET)

        elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
            #snd.PlaySound("sound/ui/jaeryun_fail.wav")
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NEED_BETTER_SCROLL)

        elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
            #snd.PlaySound("sound/ui/jaeryun_fail.wav")
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_SOCKET_DISABLE_ITEM)

        elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
            #snd.PlaySound("sound/ui/jaeryun_fail.wav")
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)

        elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

        if player.REFINE_OK != result:
            return

        self.refineDialog.Open(scrollSlotPos, targetSlotPos)

    def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
        scrollIndex = player.GetItemIndex(scrollSlotPos)
        targetIndex = player.GetItemIndex(targetSlotPos)
        if not player.CanDetach(scrollIndex, targetSlotPos):
            if app.ENABLE_ACCE_SYSTEM:
                item.SelectItem(scrollIndex)
                if item.GetValue(0) == acce.CLEAN_ATTR_VALUE0:
                    chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.ACCE_FAILURE_CLEAN)
                else:
                    chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
            else:
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
            return

        self.questionDialog = uiCommon.QuestionDialog()
        self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)
        if app.ENABLE_ACCE_SYSTEM:
            item.SelectItem(targetIndex)
            if item.GetItemType() == item.ITEM_TYPE_COSTUME and item.GetItemSubType() == item.COSTUME_TYPE_ACCE:
                item.SelectItem(scrollIndex)
                if item.GetValue(0) == acce.CLEAN_ATTR_VALUE0:
                    self.questionDialog.SetText(localeInfo.ACCE_DO_YOU_CLEAN)
       
        self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))
        self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
        self.questionDialog.Open()
        self.questionDialog.sourcePos = scrollSlotPos
        self.questionDialog.targetPos = targetSlotPos

    def AttachMetinToItem(self, metinSlotPos, targetSlotPos):
        metinIndex = player.GetItemIndex(metinSlotPos)
        targetIndex = player.GetItemIndex(targetSlotPos)

        item.SelectItem(metinIndex)
        itemName = item.GetItemName()

        result = player.CanAttachMetin(metinIndex, targetSlotPos)

        if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))

        if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_SOCKET(itemName))

        elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))

        elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

        if player.ATTACH_METIN_OK != result:
            return

        self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)


       
    def OverOutItem(self):
        self.wndItem.SetUsableItem(False)
        if None != self.tooltipItem:
            self.tooltipItem.HideToolTip()

    def OverInItem(self, overSlotPos):
        overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
        self.wndItem.SetUsableItem(False)

        if app.ENABLE_HIGHLIGHT_NEW_ITEM and overSlotPosGlobal in self.liHighlightedItems:
            self.liHighlightedItems.remove(overSlotPosGlobal)
            self.wndItem.DeactivateSlot(overSlotPos)

        if mouseModule.mouseController.isAttached():
            attachedItemType = mouseModule.mouseController.GetAttachedType()
            if app.WJ_SPLIT_INVENTORY_SYSTEM:
                if player.SLOT_TYPE_INVENTORY == attachedItemType or player.SLOT_TYPE_STONE_INVENTORY == attachedItemType or player.SLOT_TYPE_EFSUN_INVENTORY == attachedItemType:
                    attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                    attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

                    if attachedItemVNum==player.ITEM_MONEY: # @fixme005
                        pass
                    elif self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPosGlobal):
                        self.wndItem.SetUsableItem(True)
                        self.wndItem.SetUseMode(True)
                        self.ShowToolTip(overSlotPosGlobal)
                        return
            else:
                if player.SLOT_TYPE_INVENTORY == attachedItemType:

                    attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
                    attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

                    if attachedItemVNum==player.ITEM_MONEY: # @fixme005
                        pass
                    elif self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPosGlobal):
                        self.wndItem.SetUsableItem(True)
                        self.ShowToolTip(overSlotPosGlobal)
                        return

        self.ShowToolTip(overSlotPosGlobal)


    def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
        "´Ù¸¥ ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀΰ¡?"

        if item.IsRefineScroll(srcItemVNum):
            return True
        elif item.IsMetin(srcItemVNum):
            return True
        elif item.IsDetachScroll(srcItemVNum):
            return True
        elif item.IsKey(srcItemVNum):
            return True
        elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
            return True

        elif player.GetItemIndex(srcSlotPos) == 71500:
                return True

        else:
            if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:
                return True
           
        return False

    def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):
        "´ë»ó ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö Àִ°¡?"

        if srcSlotPos == dstSlotPos:
            return False

        if item.IsRefineScroll(srcItemVNum):
            if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
                return True
        elif item.IsMetin(srcItemVNum):
            if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):
                return True
        elif item.IsDetachScroll(srcItemVNum):
            if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):
                return True
        elif item.IsKey(srcItemVNum):
            if player.CanUnlock(srcItemVNum, dstSlotPos):
                return True

        elif player.GetItemIndex(srcSlotPos) == 71500:
            item.SelectItem(player.GetItemIndex(dstSlotPos))
            if item.GetItemType() == item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_ACCE:
                return True

        elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
            return True

        else:
            useType=item.GetUseType(srcItemVNum)

            if "USE_CLEAN_SOCKET" == useType:
                if self.__CanCleanBrokenMetinStone(dstSlotPos):
                    return True
            elif "USE_CHANGE_ATTRIBUTE" == useType:
                if self.__CanChangeItemAttrList(dstSlotPos):
                    return True
            elif "USE_ADD_ATTRIBUTE" == useType:
                if self.__CanAddItemAttr(dstSlotPos):
                    return True
            elif "USE_ADD_ATTRIBUTE2" == useType:
                if self.__CanAddItemAttr(dstSlotPos):
                    return True
            elif "USE_ADD_ACCESSORY_SOCKET" == useType:
                if self.__CanAddAccessorySocket(dstSlotPos):
                    return True
            elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:                              
                if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):
                    return TRUE;
            elif "USE_PUT_INTO_BELT_SOCKET" == useType:                              
                dstItemVNum = player.GetItemIndex(dstSlotPos)
                print "USE_PUT_INTO_BELT_SOCKET", srcItemVNum, dstItemVNum
                item.SelectItem(dstItemVNum)
                if item.ITEM_TYPE_BELT == item.GetItemType():
                    return True
            if app.ENABLE_ITEM_ATTR_UPDATE:
                if "USE_UPDATE_ATTRIBUTE" == useType:
                    if self.__CanUpdateAttr(player.INVENTORY, dstSlotPos):
                        return True
        return False

// EKLENEN KODLAR

                    if(item->GetVnum() == ESYANIN_KODU)
                    {
                        if ((item2->GetType() == ITEM_COSTUME) && (item2->GetSubType() == COSTUME_ACCE))
                        {
                            item2->SetSocket(2, 1);
                            item->SetCount(item->GetCount() - 1);
                            return;
                        }
                        else
                        {
                            ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Bu öğe sadece kuşaklara özeldir."));
                            return;
                        }
                    } 

                    // EKLENEN KODLAR - SON