#include "SunClientPrecompiledHeader.h"
#include "Hero.h"
#include "MouseHandler.h"
#include "ItemUnitRenderer.h"
#include "Mouse.h"
#include <ItemInfoParser.h>
#include <SCSlotContainer.h>
#include "SoundEffect.h"
#include "ItemManager.h"
#include "QuickSlot.h"
#include "StyleSlot.h"
#include "SCSkillSlot.h"
#include "InterfaceManager.h"
#include "ShopDialog.h"
#include "InventoryDialog.h"
#include "QuickContainer.h"
#include "StyleContainer.h"
#include "EventInventoryDialog.h"
#include "HeroEquipmentContainer.h"

#include "IconImage.h"
#include "asknormalenchantdialog.h"
#include "AskExtraStoneUse.h"
#include "heroactioninput.h"
#include "SkillInfoParser.h"
#include "StyleInfoParser.h"
#include "chatdialog.h"
#include "dummyItemSlot.h"


#include "SocketOptionDescParser.h"
#include "ItemUnitRenderer.h"
#include "ItemCompositeParser.h"

#include "uiVendorMan/uiVendorMan_def.h"
#include "uiVendorSell/uiVendorSell.h"
#include "uiVendorPopup/uiVendorPopup.h"
#include "uiTradeMan/uiTradeMan.h"
#include "Application.h"
#include "MouseCursor.h"
#ifdef __NA_001358_ENCHANT_UNIFICATION
#else //__NA_001358_ENCHANT_UNIFICATION
#include "EnchantDialog2.h"
#endif //__NA_001358_ENCHANT_UNIFICATION
#ifdef _NA_003923_20120130_GUILD_RENEWAL_MOD_WAREHOUSE_SLOT_NUM
    #include "uiBankMan/uiBankDialog.h"
#else
    #include "BankDialog.h"
#endif //_NA_003923_20120130_GUILD_RENEWAL_MOD_WAREHOUSE_SLOT_NUM
#include "uiItemCompositeMan/uiItemCompositeMan.h"
#include "ItemETCCompositeDlg.h"
#include "CastLeaveFieldDialog.h"
#include "uiItemShopDiv/uiItemShopDiv.h"
#include "uiItemDiv/uiItemDiv.h"
#include "uiItemDivMan/uiItemDivMan.h"
#include "CursorChangeTransact.h"
#include "globalfunc.h"
#include "GameFramework.h"
#include "BattleScene.h"
#include "uiSystemMan/uiSystemMan.h"
#include "uiAssistMan/uiAssistMan.h"
#include "MapInfoParser.h"
#include "uiCashItemShopExtensionBuy/uiCashItemShopExtensionBuy.h"
#include "Map.h"
#include "uiFateItemSystemMan/uiFateItemSystemMan.h"
#include "uiFateItemSystem/uiFateItemSystem.h"
#include "uiPartyMan/uiPartyMan.h"
#include "LotteryInventoryDialog.h"
#include "uiPetNameSetting/uiPetNameSetting.h"
#include "uiPetMan/uiPetMan.h"
#include "ProjectileManagerEx.h"
#include "uiGuildMan/uiGuildMan.h"
#ifdef _NA_003923_20120217_GUILD_RENEWAL_UI_GUILD_MANAGER
    #include "GuildSystem/uiGuildRelationAsk.h"
#else
    #include "uiChangeGuildName/uiChangeGuildName.h"
#endif //_NA_003923_20120217_GUILD_RENEWAL_UI_GUILD_MANAGER
#include "uiQuestMan/uiQuestMan.h"
#include "RiderInventoryDialog.h"
#include "RidingInfoParser.h"

#include "uiDominationTowerMan/uiDominationTowerMan.h"

#include "uiCharCustomizeMan/uiCharCustomizeMan.h"
#include "uiCharCustomizeDlg/uiCharCustomizeDlg.h"

#include "SCPerkSlot.h"
#include "uiSkillMan/uiNewSkillMan.h"
#include "uiPerkDialog/uiPerkDialog.h"

#include "Interface/uiAutobot/uiAutobotConditionBattle.h"
#include "ObjectManager.h"

#include "uiItemCompositeMan/uiItemCompositeMan.h"
#include "uiItemCube.h"

#include "SocketSystem/ZardComposeInfoParser.h"
#include "uiSocketComposite/uiSocketComposite.h"
#include "SocketSystem/SocketItemRatioParser.h"
#include "uiSocketMan/uiSocketMan.h"
#include "ItemOptionHeader.h"

#include "SkillMain.h"
#include "CastDialog.h"

#ifdef _NA_000000_20140120_SMART_NPC_SYSTEM
#include "uiSmartNpcDialogMan/uiSmartNpcDialogMan.h"
#include "uiSmartNpcDialogMan/uiSmartNpcDialogReply.h"
#endif //_NA_000000_20140120_SMART_NPC_SYSTEM
#include "ItemCrystalizeListParser.h"
#include "CooltimeManager.h"
#include "ItemCooltimeManager.h"
#ifdef _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
#include "uiEquipmentAwakeningMan/uiEquipmentAwakeningDialog.h"
#endif // _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
//------------------------------------------------------------------------------
/**
*/
void _CallBack_Item_Use(bool bYes)
{
}

MouseHandler::MouseHandler()
:m_bCtlKeyDown(FALSE)
{
	memset(&m_MouseItem, 0, sizeof(MouseItem));
	m_eTradeState = MouseHandler::NONE;
	m_pItemUnitRender = NULL;
	m_bPendingLockDeleteItem = FALSE;
	InitConfirmState();
	m_bIsProssessionWin = false;
}

MouseHandler::~MouseHandler()
{
	ReleaseUnitRenderer();
}


VOID	MouseHandler::InitConfirmState( void )
{

	SetSavingPosition(FALSE);
	SetTryPortal(FALSE);



	SetTryUseChageItem(FALSE);

	SetTryRemoveSocket(FALSE);

#ifdef _ADD_CHARGE_ITEM_RANDOM_OPTION
	SetTryAddRandomOption(FALSE);
#endif	
}


VOID 
MouseHandler::InitUnitRenderer( CDrawBase * pDraw )
{
	assert(pDraw);

	m_pItemUnitRender = new ItemUnitRenderer;
	m_pItemUnitRender->Init(pDraw, MOUSE_ITEM_MAX);
}

VOID				
MouseHandler::ReleaseUnitRenderer()
{
	if (m_pItemUnitRender)
	{
		m_pItemUnitRender->Release();
		delete m_pItemUnitRender;
		m_pItemUnitRender = NULL;
	}
}

VOID MouseHandler::Update()
{
	if( m_MouseItem.m_pRenderUnit	!= NULL )
	{
		ItemUnitRenderer::RenderUnit *	pRenderUnit = m_pItemUnitRender->GetItemUnit(DEFAULT_MOUSE_ITEM_SERIAL);

		int iMouseX, iMouseY;
		iMouseX = Mouse::Instance()->GetMouseX();
		iMouseY = Mouse::Instance()->GetMouseY();

		if(pRenderUnit)
		{
			RECT * prcDest = pRenderUnit->GetViewRect();
			
			if(prcDest)
			{
				int iWidth	= prcDest->right - prcDest->left;
				int iHeight = prcDest->bottom - prcDest->top;

				prcDest->left	= iMouseX - (iWidth/2);
				prcDest->top	= iMouseY - (iHeight/2);
				prcDest->right	= prcDest->left + pRenderUnit->m_iWidth;
				prcDest->bottom	= prcDest->top + pRenderUnit->m_iHeight;
			}
		}

	}
}


VOID MouseHandler::Render()
{
	ENUM_ALPHABLEND eAlphablendMode = g_pSunRenderer->GetAlphaBlendMode();
	BOOL bAlphaTest = g_pSunRenderer->IsEnableAlphaTest();
	g_pSunRenderer->SetAlphaBlendMode( AB_ALPHA );
	g_pSunRenderer->EnableAlphaTest(FALSE);


	if (m_pItemUnitRender)
		m_pItemUnitRender->Render();

	g_pSunRenderer->SetAlphaBlendMode( eAlphablendMode );
	g_pSunRenderer->EnableAlphaTest(bAlphaTest);
}

VOID MouseHandler::RollbackItemAtHand()
{
	if( this->IsExistItemAtHand() )
	{
        if (m_MouseItem.m_pRenderUnit)
        {
		    m_MouseItem.m_pRenderUnit->SetViewRect( &m_MouseItem.m_OldRect );
		    m_MouseItem.m_pRenderUnit->SetShow(TRUE);
            m_MouseItem.m_pRenderUnit->m_altNum = 0;
            m_MouseItem.m_pRenderUnit->m_isDiv = 0;
        }

		// ½½·ÔÀ» °»½ÅÇØÁØ´Ù.
		// ÇöÀç À§Ä¡¿¡ º¸ÀÌÁö ¸»¾Æ¾ß ÇÒ »óȲÀÌ ¹ß»ýÇϱ⠶§¹®¿¡ È£Ãâ
		refreshContainer(m_MouseItem.m_fromSlotIdx);	

		if ( m_MouseItem.m_pFromSlot->GetSlotType() == ST_QUICK ) 
		{
			ItemManager::Instance()->PlaySlotSound(eSLOT_SOUND_TYPE_LINK, m_MouseItem.m_pFromSlot);
		}
		else if (m_MouseItem.m_fromSlotIdx == SI_EQUIPMENT)
		{
			ItemManager::Instance()->PlaySlotSound(eSLOT_SOUND_TYPE_LINK, m_MouseItem.m_pFromSlot);
		}
		else
		{
			ItemManager::Instance()->PlaySlotSound(eSLOT_SOUND_TYPE_PUT, m_MouseItem.m_pFromSlot);
		}
		
		initMouseItem();

        if (m_pItemUnitRender)
        {
		    m_pItemUnitRender->RemoveItemUnit(DEFAULT_MOUSE_ITEM_SERIAL);
        }
	}
}

VOID MouseHandler::RemoveItemAtHand()
{
	if (m_MouseItem.m_pFromSlot)
	{
		m_MouseItem.m_pFromBaseItemInfo = 
			ItemInfoParser::Instance()->GetItemInfo( m_MouseItem.m_pFromSlot->GetCode() );
		// ³ªÁß¿¡ ŸÀÔÀÌ Á¤Àǵȴٸé Á¦´ë·Î ¾ÆÀÌÅÛ¿¡ µû¸¥ »ç¿îµå Ãâ·ÂÀ» ÇؾßÇÑ´Ù.

	}
	initMouseItem();

	SUN_ASSERT(m_pItemUnitRender);
	if (m_pItemUnitRender)
	{
		this->m_pItemUnitRender->RemoveItemUnit(DEFAULT_MOUSE_ITEM_SERIAL);
	}
}

//------------------------------------------------------------------------------
/**
*/
VOID 
MouseHandler::AddItemAtHandWithItemDiv(DURATYPE divNum,
                                       SLOTIDX fromSlotIdx, 
                                       POSTYPE fromPos, 
                                       eSlotType slotType, 
                                       SLOTCODE code, 
                                       ItemUnitRenderer::RenderUnit *	pRenderUnit, 
                                       RECT * pRect)
{
    m_MouseItem.m_fromSlotIdx		= fromSlotIdx;
    m_MouseItem.m_fromPos			= fromPos;
    m_MouseItem.m_slotType			= slotType;
    m_MouseItem.m_OldRect			= *pRect;
    m_MouseItem.m_pRenderUnit		= pRenderUnit;
    m_MouseItem.m_pFromBaseItemInfo = ItemInfoParser::Instance()->GetItemInfo(code);

    if (m_MouseItem.m_pRenderUnit)
    {
        m_MouseItem.m_pRenderUnit->SetSize(pRect->right - pRect->left,  pRect->bottom - pRect->top);
        m_MouseItem.m_pRenderUnit->SetShow(TRUE);		// ¾ÆÀÌÅÛ ³ª´­¶§´Â º¸¿©ÁÖ°í
    }

    SCSlotContainer * pAtContainer	= ItemManager::Instance()->GetContainer( fromSlotIdx );
    if(pAtContainer && (!pAtContainer->IsEmpty( fromPos ))) 
    {
        m_MouseItem.m_pFromSlot = &pAtContainer->GetSlot( fromPos );
        // ³ªÁß¿¡ ŸÀÔÀÌ Á¤Àǵȴٸé Á¦´ë·Î ¾ÆÀÌÅÛ¿¡ µû¸¥ »ç¿îµå Ãâ·ÂÀ» ÇؾßÇÑ´Ù.
        // RemoveItemAtHand ÂüÁ¶
        ItemManager::Instance()->PlaySlotSound(eSLOT_SOUND_TYPE_PICK, m_MouseItem.m_pFromSlot);
    }

    if ( m_MouseItem.m_pFromSlot && 
        ST_ITEM == m_MouseItem.m_pFromSlot->GetSlotType())
    {
        SCItemSlot * pFromItemSlot = (SCItemSlot *)m_MouseItem.m_pFromSlot;
        
		if( CheckBlockedItem( pFromItemSlot ))
		{
			return;
		}

		if ( pFromItemSlot->IsLocked() )
        {
            RollbackItemAtHand();
            // ƯÁ¤ ¸Þ½ÃÁö ¾øÀ½ ¸»°í.
            return;
        }
        
        m_MouseItem.m_pRenderUnit->m_altNum = pFromItemSlot->GetNum() - divNum;
        m_MouseItem.m_pRenderUnit->m_isDiv = true;
    }

    ItemUnitRenderer::RenderUnit *	pOrgRenderUnit = this->m_pItemUnitRender->AddItemUnit(
        DEFAULT_MOUSE_ITEM_SERIAL, 
        code, 
        pRect, 
        pRenderUnit->m_pRefSlot);

    pOrgRenderUnit->SetSize(pRect->right - pRect->left,  pRect->bottom - pRect->top);
    pOrgRenderUnit->m_altNum = divNum;
    pOrgRenderUnit->m_isDiv = true;

	uiBase * itemDiv = GET_DIALOG(IM_ITEMDIV_MANAGER::ITEMDIV);
	
    if (itemDiv)
    {
        itemDiv->ShowInterface(FALSE);
    }
}

//----------------------------------------------------------------------------
/**
*/
VOID 
MouseHandler::AddItemAtHand( 
								 SLOTIDX fromSlotIdx, 
								 POSTYPE fromPos, 
								 eSlotType slotType, 
								 SLOTCODE code, 
								 ItemUnitRenderer::RenderUnit *	pRenderUnit, 
								 RECT * pRect )
{
	m_MouseItem.m_fromSlotIdx		= fromSlotIdx;
	m_MouseItem.m_fromPos			= fromPos;
	m_MouseItem.m_slotType			= slotType;
	m_MouseItem.m_OldRect			= *pRect;
	m_MouseItem.m_pRenderUnit		= pRenderUnit;
	m_MouseItem.m_pFromBaseItemInfo = ItemInfoParser::Instance()->GetItemInfo(code);

    if (m_MouseItem.m_pRenderUnit)
    {
	    m_MouseItem.m_pRenderUnit->SetSize(pRect->right - pRect->left,  pRect->bottom - pRect->top);
	    m_MouseItem.m_pRenderUnit->SetShow(FALSE);		// ½ÇÁ¦ À¯´ÖÀº ¾Èº¸¿©ÁÖ°í. 
    }

	SCSlotContainer * pAtContainer	= ItemManager::Instance()->GetContainer( fromSlotIdx );
	if (pAtContainer && !pAtContainer->IsEmpty(fromPos)) 
	{
		m_MouseItem.m_pFromSlot = &pAtContainer->GetSlot( fromPos );
		// ³ªÁß¿¡ ŸÀÔÀÌ Á¤Àǵȴٸé Á¦´ë·Î ¾ÆÀÌÅÛ¿¡ µû¸¥ »ç¿îµå Ãâ·ÂÀ» ÇؾßÇÑ´Ù.
		// RemoveItemAtHand ÂüÁ¶
       	ItemManager::Instance()->PlaySlotSound(eSLOT_SOUND_TYPE_PICK, m_MouseItem.m_pFromSlot);
	}

	if ( m_MouseItem.m_pFromSlot && 
		 ST_ITEM == m_MouseItem.m_pFromSlot->GetSlotType())
	{
		SCItemSlot * pFromItemSlot = (SCItemSlot *)m_MouseItem.m_pFromSlot;
		
		if( CheckBlockedItem( pFromItemSlot ))
		{
			return;
		}
		
		if ( pFromItemSlot->IsLocked() )
		{
			RollbackItemAtHand();
			// ƯÁ¤ ¸Þ½ÃÁö ¾øÀ½ ¸»°í.
			return;
		}
	}

	ItemUnitRenderer::RenderUnit *	pOrgRenderUnit = this->m_pItemUnitRender->AddItemUnit(
		DEFAULT_MOUSE_ITEM_SERIAL, 
		code, 
		pRect, 
		pRenderUnit->m_pRefSlot);

	pOrgRenderUnit->SetSize(pRect->right - pRect->left,  pRect->bottom - pRect->top);
}

//----------------------------------------------------------------------------
/**
*/
BOOL 
MouseHandler::ItemTransaction(SLOTIDX SlotIdx, 
								   POSTYPE ToPos, RECT * pRect)
{
	TCHAR	szMessage[INTERFACE_STRING_LENGTH], szText[INTERFACE_STRING_LENGTH];


	if( IsExistItemAtHand() )
	{ 
		// ¿©±â¿¡ µé¾î¿Ô´Ù´Â°ÍÀº ƯÁ¤ ÄÁÅ×À̳ʿ¡¼­ ¸¶¿ì½º¿¡ ¾ÆÀÌÅÛÀ» °¡Á®¿Â °ÍÀÌ´Ù.

		SCSlotContainer * pFromContainer = 
			ItemManager::Instance()->GetContainer(m_MouseItem.m_fromSlotIdx); 
		SCSlotContainer * pToContainer =
			ItemManager::Instance()->GetContainer(SlotIdx); 
        
        if ( ToPos >= pToContainer->GetMaxSlotNum() )
		{
			return FALSE;
		}
		
		switch( m_MouseItem.m_slotType )
		{
		case ST_ITEM:
			{
                if (m_MouseItem.m_pRenderUnit->m_isDiv)
                {
                    switch(SlotIdx)
                    {
                    case SI_INVENTORY: // no operation
                        {
                            if (m_MouseItem.m_fromSlotIdx == SI_WAREHOUSE ||
                                m_MouseItem.m_fromSlotIdx == SI_GUILDWAREHOUSE)
                            {
                                if (pToContainer && pToContainer->IsEmpty(ToPos))
                                {
                                    ItemManager::Instance()->SendItemMoveMsg(m_MouseItem.m_fromSlotIdx,
                                        SlotIdx, m_MouseItem.m_fromPos, ToPos,
                                        (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum));
                                    return TRUE;
                                }
                                else
                                {
                                    SCSlot & rFromSlot	= pFromContainer->GetSlot(m_MouseItem.m_fromPos);
					                SCSlot & rToSlot	= pToContainer->GetSlot(ToPos);
                    				
					                if ( rFromSlot.GetCode() && rToSlot.GetCode() 
						                && (rFromSlot.GetCode() == rToSlot.GetCode())
						                && SCItemSlot::IsOverlap(rFromSlot.GetCode())
						                )
                                    {
							            ItemManager::Instance()->SendItemCombineMsg(
								            m_MouseItem.m_fromSlotIdx, 
								            SlotIdx, 
								            m_MouseItem.m_fromPos,
								            ToPos,
                                            (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum)
								            );
                                        return TRUE;
                                    }
                                    else
                                    {
                                        return FALSE;
                                    }
                                }
                            }
                        }
                        break;
                    case SI_WAREHOUSE:
                    case SI_GUILDWAREHOUSE:
                        {   // â°í¿¡ ³ª´©¾î¼­ ³Ö±â
                            if (m_MouseItem.m_fromSlotIdx != SlotIdx)
                            {
                                if(pToContainer && pToContainer->IsEmpty(ToPos))
                                {
                                    ItemManager::Instance()->SendItemMoveMsg(m_MouseItem.m_fromSlotIdx,
                                        SlotIdx, m_MouseItem.m_fromPos, ToPos,
                                        (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum));
                                    return TRUE;
                                }
                                else
                                {
                                    SCSlot & rFromSlot	= pFromContainer->GetSlot(m_MouseItem.m_fromPos);
					                SCSlot & rToSlot	= pToContainer->GetSlot(ToPos);
                					
					                if ( rFromSlot.GetCode() && rToSlot.GetCode() 
						                && (rFromSlot.GetCode() == rToSlot.GetCode())
						                && SCItemSlot::IsOverlap(rFromSlot.GetCode())
						                )
                                    {
							            ItemManager::Instance()->SendItemCombineMsg(
								            m_MouseItem.m_fromSlotIdx, 
								            SlotIdx, 
								            m_MouseItem.m_fromPos,
								            ToPos,
                                            (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum)
								            );
                                        return TRUE;
                                    }
                                    else
                                    {
                                        return FALSE;
                                    }
                                }
                            }
                            else
                            {
                                if (ToPos == m_MouseItem.m_fromPos)
                                {
                                    RollbackItemAtHand();
                                    return FALSE;
                                }
                                else
                                {
                                    // DB ¹®Á¦·Î â°í¿¡¼­´Â ¾ÆÀÌÅÛ ºÐÇÒ ºÒ°¡´É
                                    // 988	â°í¿¡¼­´Â ¾ÆÀÌÅÛ ºÐÇÒÀÌ ºÒ°¡´É ÇÕ´Ï´Ù. Àκ¥Å丮¿¡¼­ ½ÃµµÇØ ÁÖ¼¼¿ä
						            g_InterfaceManager.GetInterfaceString(988 , szMessage ,INTERFACE_STRING_LENGTH);
                                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_TOP_SHOW, szMessage);
                                    return FALSE;
                                }
                            }
                        }
                        break;
                    case SI_NPCSTORE:
                        {   // »óÁ¡¿¡ ³ª´©¾î¼­ Æȱâ
                            if (SI_INVENTORY == m_MouseItem.m_fromSlotIdx)// && SI_NPCSTORE == SlotIdx)
				            {
					            // Ŭ¶óÀ̾ðÆ®¿¡¼­´Â ¾ÆÀÌÅÛ °Å·¡ ŸÀÔ¿¡ µû¸¥ üũ ¾ÈÇÔ
					            // Àκ¥¿¡¼­ »óÁ¡À¸·Î ¿ÔÀ»¶§´Â ÆǸÅ
					            ItemManager::Instance()->SendSellMsg(m_MouseItem.m_fromSlotIdx, m_MouseItem.m_fromPos, 
                                    (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum));
					            return TRUE;
				            }
                        }
                        break;
                    default:
                        {
                            // 5133	¾ÆÀÌÅÛ ºÐÇÒÀº Àκ¥Å丮¿¡¼­¸¸ °¡´ÉÇÕ´Ï´Ù.
						    g_InterfaceManager.GetInterfaceString(eST_ITEM_DIV_ONLY_INVENTORY , szMessage ,INTERFACE_STRING_LENGTH);
                            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_TOP_SHOW, szMessage);
                            return FALSE;
                        }
                    }
                }

				// TODO :
				// À̺κРÀÌ»Ú°Ô ÇÔ¼ö·Î ³ª´²¼­ °ü¸®ÇÏÀÚ..

				//////////////////////////////////////////////////////////////////////////
				// Shop container
                if (m_MouseItem.m_fromSlotIdx == SlotIdx && m_MouseItem.m_fromPos == ToPos)
				{
					RollbackItemAtHand();
				}
				else if (SI_NPCSTORE == m_MouseItem.m_fromSlotIdx && SI_NPCSTORE == SlotIdx)
				{
					RollbackItemAtHand();
					return FALSE;
				}
				else if(SI_EQUIPMENT == m_MouseItem.m_fromSlotIdx && SI_GUILDWAREHOUSE == SlotIdx)
				{
					RollbackItemAtHand();
					return FALSE;
				}
				else if (SI_INVENTORY == m_MouseItem.m_fromSlotIdx && SI_NPCSTORE == SlotIdx)
				{
					// Ŭ¶óÀ̾ðÆ®¿¡¼­´Â ¾ÆÀÌÅÛ °Å·¡ ŸÀÔ¿¡ µû¸¥ üũ ¾ÈÇÔ
					// Àκ¥¿¡¼­ »óÁ¡À¸·Î ¿ÔÀ»¶§´Â ÆǸÅ
					ItemManager::Instance()->SendSellMsg(m_MouseItem.m_fromSlotIdx, m_MouseItem.m_fromPos);

					return TRUE;

				}
				else if (SI_NPCSTORE == m_MouseItem.m_fromSlotIdx && SI_INVENTORY == SlotIdx)
				{
					// »óÁ¡¿¡¼­ Àκ¥À¸·Î ¿ÔÀ»¶§´Â ±¸¸Å

					SCSlot & rSlot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);

					ShopDialog * pShopDlg = (ShopDialog *)
						ItemManager::Instance()->GetItemContainerDialog(SI_NPCSTORE);

					DWORD dwShopID = (DWORD)pShopDlg->GetShopID();
					SHOPINFO * pShopInfo = (SHOPINFO *)ShopInfoParser::Instance()->GetShopList( dwShopID );

					SHOPINFO::SHOP_ITEM * pShopItem = pShopInfo->GetItem(rSlot.GetCode());
					if (!pShopItem)
					{
						assert(!"ShopInfo.txt È®ÀÎ!!");
						return FALSE;
					}
						                    
					ItemManager::Instance()->SendBuyMsg(
						pShopDlg ->GetShopID(), 
						rSlot.GetCode(), 
						pShopDlg->GetCurrentTab(), 
						pShopDlg->GetRelativeSlotPos( m_MouseItem.m_fromPos) );

					RollbackItemAtHand();

					return TRUE;
				}
				else if (SI_EVENT_INVENTORY == SlotIdx)
				{
					// À̺¥Æ® Àκ¥Å丮¿¡´Ù°¡´Â À¯Àú°¡ ÀÓÀÇ·Î ¿Ã·Á³õÀ»¼ö ¾ø´Ù.
					RollbackItemAtHand();
					return FALSE;
				}
				else if (SI_EVENT_INVENTORY == m_MouseItem.m_fromSlotIdx && SI_INVENTORY != SlotIdx)
				{
					// À̺¥Æ® Àκ¥Å丮¿¡´Ù°¡´Â À¯Àú°¡ ÀÓÀÇ·Î ¿Ã·Á³õÀ»¼ö ¾ø´Ù.
					RollbackItemAtHand();
					return FALSE;
				}
				else if (SI_EVENT_INVENTORY == m_MouseItem.m_fromSlotIdx && SI_INVENTORY == SlotIdx)
				{
					EventInventoryDialog * pEventInventory = GET_CAST_DIALOG( EventInventoryDialog, IM_INVENTORY_MANAGER::EVENTINVEN_DLG );
					assert( pEventInventory );
					if ( pEventInventory )
					{
						pEventInventory->SendItemMoveMsg(m_MouseItem.m_fromPos);
						return TRUE;
					}
					else
					{
						return FALSE;
					}
				}
				//////////////////////////////////////////////////////////////////////////

				//////////////////////////////////////////////////////////////////////////
				// EquipContainer 
				else if (SI_EQUIPMENT == m_MouseItem.m_fromSlotIdx && SI_INVENTORY == SlotIdx)
				{					 

					BOOL bUnEquip = ItemManager::Instance()->CanMoveUnEquipItem(
						m_MouseItem.m_fromSlotIdx, 
						m_MouseItem.m_fromPos, 
						TRUE);

					if (!bUnEquip)
					{
						MouseHandler::Instance()->RollbackItemAtHand();
						return FALSE;
					}
					else
					{
						ItemManager::Instance()->SendItemMoveMsg( 
							m_MouseItem.m_fromSlotIdx, 
							SlotIdx, 
							m_MouseItem.m_fromPos, 
							ToPos 
							);
					}
				}
				else if (SI_EQUIPMENT == SlotIdx && SI_INVENTORY == m_MouseItem.m_fromSlotIdx )
				{
					// ÀÌÅ¢°¡´ÉÇÑ°¡?
					BOOL bEquipRet = 
						ItemManager::Instance()->CanEquip( m_MouseItem.m_fromSlotIdx, m_MouseItem.m_fromPos, ToPos );

					if ( TRUE == bEquipRet )
					{
						SCItemSlot & rItemSlot = (SCItemSlot &)pFromContainer->GetSlot(m_MouseItem.m_fromPos);
						const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
						if( !pItemInfo )
						{
							return FALSE;
						}
						
						if ( rItemSlot.IsPossessionItem() )
						{// ±Í¼Ó ¾ÆÀÌÅÛ »ç¿ë 
							if ( rItemSlot.GetIdentifyPossession() == 0 )
							{//±Í¼Ó¾ÆÀÌÅÛ Ã³À½ »ç¿ë
								//»ç¿ëÇÒ°ÇÁö Æ˾÷(±Í¼Ó ÀÎÁõ)
								if(	GetPossessionWin() != true )
								{
									//5090	ÀåÂø½Ã ±Í¼ÓµË´Ï´Ù. ÀåÂøÇϽðڽÀ´Ï±î?
									TCHAR szBuf[INTERFACE_STRING_LENGTH];
									g_InterfaceManager.GetInterfaceString( 5090 , szBuf, INTERFACE_STRING_LENGTH-1);
									
									uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
									if(pSystemMan)
									{
										pSystemMan->Sys_Confirm(NULL, GlobalFunc::UsePossessionItem, NULL/*szTitle*/, szBuf);
										SetPossessionItemPOS(m_MouseItem.m_fromPos, ToPos);
										SetPossessionWin(true);
									}
									return FALSE;
								}
								else
								{
									// 6130: Çѹø¿¡ Çϳª¾¿ ±Í¼Ó ÇÒ ¼ö ÀÖ½À´Ï´Ù.
									TCHAR szBuf[INTERFACE_STRING_LENGTH];
									g_InterfaceManager.GetInterfaceString( 6130 , szBuf, INTERFACE_STRING_LENGTH-1);
									GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szBuf );
								}
							}
						}					


						ItemManager::Instance()->SendItemMoveMsg( 
							m_MouseItem.m_fromSlotIdx, 
							SlotIdx, 
							m_MouseItem.m_fromPos, 
							ToPos 
							);
					}
					else
					{

						g_HeroInput.PlayLimitUseSound();
						RollbackItemAtHand();
						return FALSE;
					}
				}
				//////////////////////////////////////////////////////////////////////////
				
				//////////////////////////////////////////////////////////////////////////
				// Guild WareHouse
				else if(SI_GUILDWAREHOUSE == SlotIdx && SI_INVENTORY == m_MouseItem.m_fromSlotIdx)
				{
						SCItemSlot & rItemSlot = (SCItemSlot &)pFromContainer->GetSlot(m_MouseItem.m_fromPos);
						if( rItemSlot.IsPossessionItem() && rItemSlot.GetIdentifyPossession() )
						{
							RollbackItemAtHand();
							ItemManager::Instance()->NoticeReasonItemErrorCode(RC_ITEM_CANNOT_MOVE_WAREHOUSE_ITEM);
							return FALSE;
						}
					ItemManager::Instance()->SendItemMoveMsg( 
						SI_INVENTORY, 
						SI_GUILDWAREHOUSE, 
						m_MouseItem.m_fromPos, 
						ToPos 
						);
				}
				else if(SI_GUILDWAREHOUSE == m_MouseItem.m_fromSlotIdx && SI_INVENTORY == SlotIdx)
				{
					ItemManager::Instance()->SendItemMoveMsg( 
						SI_GUILDWAREHOUSE, 
						SI_INVENTORY, 
						m_MouseItem.m_fromPos, 
						ToPos 
						);
				}

				//¶óÀÌ´õ-->Àκ¥(UNEQUIP)
				else if(SI_RIDER == m_MouseItem.m_fromSlotIdx && SI_INVENTORY == SlotIdx)
				{
                    //ºó½½·ÔÀ̾ߵȴÙ
                    if(pToContainer && pToContainer->IsEmpty(ToPos))
                    {
                        RiderInventoryDialog *pInven=(RiderInventoryDialog *)pFromContainer;
                        MSG_CG_ITEM_RIDER_CONTROL_PARTS_SYN SendMsg;
                        SendMsg.header.request = SendMsg.header.eReq_UnEquipParts;
                        SendMsg.header.args.unequip.from.value = m_MouseItem.m_fromPos+eRIDER_PARTS_POS::StartIndex;
                        SendMsg.header.args.unequip.to         = ToPos;
                        if(pInven)
                        {
                            SendMsg.header.args.unequip.where      = pInven->GetRiderSummonPos();
                        }
                        GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg) );
                    }
                    else
                    {
                        //	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖÁö¾Ê½À´Ï´Ù.
                        g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_NOT_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
                        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
                    }
                    
                    RollbackItemAtHand();

				}//Àκ¥(INVEN)-->¶óÀÌ´õ(EQUIP)
				else if(SI_INVENTORY == m_MouseItem.m_fromSlotIdx && SI_RIDER == SlotIdx)
				{
                    RiderInventoryDialog *pInven=(RiderInventoryDialog *)pToContainer;

                    //¶óÀÌ´õ¾ÆÀÌÅÛ
                    SCItemSlot & rRiderSlot = (SCItemSlot &)pFromContainer->GetSlot(pInven->GetRiderSummonPos());

                    if(!g_pHero->IsRiding() || !rRiderSlot.IsContainValidItem())
                    {
                        assert(!"Not Summon Rider");
                        RollbackItemAtHand();
                        break;
                    }

                    //¶óÀÌ´õ ÆÄÃ÷¾ÆÀÌÅÛ
                    SCItemSlot & rItemSlot = (SCItemSlot &)pFromContainer->GetSlot(m_MouseItem.m_fromPos);
                
                    RC::eITEM_RESULT result = rRiderSlot.CanEquipRiderParts(rItemSlot);

                    switch(result)
                    {
                    case RC::RC_ITEM_SUCCESS:
                        {
                            //ÀåÂøÇÑ´Ù.
                            MSG_CG_ITEM_RIDER_CONTROL_PARTS_SYN SendMsg;
                            SendMsg.header.request = SendMsg.header.eReq_EquipParts;
                            SendMsg.header.args.equip.from = m_MouseItem.m_fromPos;
                            SendMsg.header.args.equip.to.value   =ToPos+eRIDER_PARTS_POS::StartIndex;
                            GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg) );
                        }
                        break;
                    case RC::RC_ITEM_INVALID_TYPE:
                        {
                            //6440:¼ÒȯÇÑ Å»°Í°ú ¸ÂÁö¾Ê´Â¾ÆÀÌÅÛÀÔ´Ï´Ù.
                            g_InterfaceManager.GetInterfaceString(6440,szMessage);
                            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                        }
                        break;
                    case RC::RC_ITEM_CAN_NOT_EQUIP:
                        {
                            //6440 ÇØ´ç Å»°Í¿¡ ÀåÂøÇÒ¼ö ¾ø´Â ÀåºñÀÔ´Ï´Ù.
                            g_InterfaceManager.GetInterfaceString(6440,szMessage);
                            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                        }
                        break;
                    case RC::RC_ITEM_INVALIDPOS:
                        {
                            //6453 Å»°Í ÀåºñÀ§Ä¡°¡ ¿Ã¹Ù¸£Áö¾Ê½À´Ï´Ù.
                            g_InterfaceManager.GetInterfaceString(6453,szMessage);
                            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                        }
                        break;
                    }
                       
                    RollbackItemAtHand();
    			}

				//////////////////////////////////////////////////////////////////////////

				//////////////////////////////////////////////////////////////////////////
				// quickcontainer
				else if (SI_QUICK == SlotIdx)
				{
					// ÄüÀ¸·Î ¸µÅ©

					if (SI_INVENTORY != m_MouseItem.m_fromSlotIdx)
					{
						// ÀåÂø ¾ÆÀÌÅÛÀº Àκ¥Å丮¿¡¼­¸¸ ÄüÀ¸·Î µî·Ï ÇÒ ¼ö ÀÖ´Ù.

						MouseHandler::Instance()->RollbackItemAtHand();
						return FALSE;
					}
					
					BOOL bQuick = ItemManager::Instance()->CanLinkQuick(SI_QUICK, ToPos, m_MouseItem.m_pFromSlot);
					if (bQuick)
					{
						ItemManager::Instance()->SendQuickItemLinkMsg( 
							m_MouseItem.m_fromPos, 
							ToPos);
					}
					else
					{
						RollbackItemAtHand();
						return FALSE;
					}
				}
				//////////////////////////////////////////////////////////////////////////
				else if ( SI_STYLE == SlotIdx )
				{
					//	½ºÅ¸ÀÏ Äü â¿¡´Â ½ºÅ¸Àϸ¸ ¿Ã·Á³õÀ» ¼ö ÀÖ½À´Ï´Ù.
					g_InterfaceManager.GetInterfaceString( eST_STYLE_ONLY_STYLE_QUICK_SLOT, szText, INTERFACE_STRING_LENGTH );
					GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szText );
					RollbackItemAtHand();

					return FALSE;
				}
				//////////////////////////////////////////////////////////////////////////
                // trade
                else if (SI_TRADE == SlotIdx && SI_INVENTORY == m_MouseItem.m_fromSlotIdx)
                {
					//// Ŭ¶óÀ̾ðÆ®¿¡¼­´Â ¾ÆÀÌÅÛ °Å·¡ ŸÀÔ¿¡ µû¸¥ üũ ¾ÈÇÔ

					uiTradeMan* tradeMan =
						static_cast<uiTradeMan *>(g_InterfaceManager.GetUserInterfaceManager(UIMAN_TRADE));
					assert (tradeMan);

					if (tradeMan)
					{
						tradeMan->TEST_Put(m_MouseItem.m_fromPos);
					}
                }
				else if (SI_TRADE == m_MouseItem.m_fromSlotIdx) 
				{
					switch (SlotIdx) 
					{
					case SI_TRADE:
						RollbackItemAtHand();
						break;

					default:
						{
							uiTradeMan* tradeMan =
							static_cast<uiTradeMan *>(g_InterfaceManager.GetUserInterfaceManager(UIMAN_TRADE));
							assert (tradeMan);

							if (tradeMan)
							{
								tradeMan->TEST_Get(m_MouseItem.m_fromPos);
							}			
						}
						break;
					}
				}	
                //------------------------------------------------------------------------------
                //! Å¥ºê
                else if (SlotIdx == SI_CUBE && SI_INVENTORY == m_MouseItem.m_fromSlotIdx)
                {
                    uiItemCube* dialog = GET_CAST_DIALOG(uiItemCube, IM_ITEM_COMPOSITE_MANAGER::ITEM_CUBE);
                    if (dialog != NULL)
                    {
                        SCSlot& toSlot = dialog->GetSlot(ToPos);
                        SCSlot& slot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);
                        //if (dialog->CanLinkSlot(&slot, ToPos) == true)
                        {
                            if (this->m_MouseItem.m_fromSlotIdx == SI_INVENTORY)
                            {
                                // Àκ¥¿¡¼­¸¸ ¿Ã¸± ¼ö ÀÖµµ·Ï ¼³Á¤
                                bool bAlreadyUpdated = false;
                                // check already uploaded
                                for (int i=0; i<dialog->GetMaxSlotNum(); ++i)
                                {
                                    if (!dialog->IsEmpty(i))
                                    {
                                        SCSlot& _slot = pToContainer->GetSlot(i);
                                        if( _slot.GetSerial() == slot.GetSerial() )
                                        {
                                            // ÀÌ¹Ì ¿Ã¶ó°¬´Ù.
                                            bAlreadyUpdated = true;
                                        }
                                    }
                                }
                                if( g_pHero && g_pHero->GetCharInfo()->m_iInventoryLock == PLAYERINFO_FOR_PACKET::DISABLEDnEXIST)
                                {
                                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5571));
                                }
                                else
                                {
                                    ItemManager::Instance()->CopyItem(m_MouseItem.m_fromSlotIdx,
                                        SI_CUBE, m_MouseItem.m_fromPos,ToPos);
                                }
                            }
                        }
                    }
                    RollbackItemAtHand();
                    return TRUE;
                }
                //////////////////////////////////////////////////////////////////////////
                // vendor sell
                else if (SI_VENDOR_SELL == SlotIdx && SI_INVENTORY == m_MouseItem.m_fromSlotIdx)
                {
				
					// Ŭ¶óÀ̾ðÆ®¿¡¼­´Â ¾ÆÀÌÅÛ °Å·¡ ŸÀÔ¿¡ µû¸¥ üũ ¾ÈÇÔ

                    // Àκ¥Å丮¿¡¼­ °¡Á®¿ÔÀ» °æ¿ì
                    
                    // pToContainer ÀÌ»óÀÇ ±â´ÉÀ» ¿øÇϹǷΠȮÀåµÈ Æ÷ÀÎÅÍÀÎ ¿ø·¡Å¬·¡½º Æ÷ÀÎÅͷΠó¸®ÇÑ´Ù.

					uiVendorSell* vendorSell = GET_CAST_DIALOG( uiVendorSell, IM_VENDOR_MANAGER::VENDOR_SELL );

                    SCSlot& toSlot      = vendorSell->GetSlot(ToPos);
                    SCSlot& fromSlot	= pFromContainer->GetSlot(m_MouseItem.m_fromPos);

                    if (toSlot.GetCode())
                    {
                        // ½½·Ô¿¡ ä¿öÁ® ÀÖ´Â ¾ÆÀÌÅÛÀ» Ŭ¸¯ÇßÀ» °æ¿ì

                        if (this->IsExistItemAtHand())
                            this->RollbackItemAtHand();

                        uiSCItemSlot& toItemSlot = (uiSCItemSlot&)toSlot;

                        if (toItemSlot.CanEquip())
                        {
                            vendorSell->SetCurrentItemSlotInfo(1,
                                                                toItemSlot.GetMoney(),
                                                                ToPos);
                        }
                        else
                        {
                            vendorSell->SetCurrentItemSlotInfo(toItemSlot.GetNum(),
                                                                toItemSlot.GetMoney(),
                                                                ToPos);
                        }
                    }
                    else
                    {
                        if (this->IsExistItemAtHand())
                        {
                            if (vendorSell->IsVending())
                            {
                                // °³ÀÎ »óÁ¡ ½ÃÀÛ ÈÄ »õ·Î ¿Ã¸®´Â ¾ÆÀÌÅÛ

                                this->RollbackItemAtHand();
                            }
                            else
                            {
                                // °³ÀÎ »óÁ¡ ½ÃÀÛ Àü »õ·Î ¿Ã¸®´Â ¾ÆÀÌÅÛ

                                if (this->m_MouseItem.m_fromSlotIdx == SI_INVENTORY)
                                {
                                    // Àκ¥¿¡¼­¸¸ ¿Ã¸± ¼ö ÀÖµµ·Ï ¼³Á¤

                                    bool bAlreadyUpdated = false;

                                    // check already uploaded
                                    for (int i=0; i<vendorSell->GetMaxSlotNum(); ++i)
                                    {
                                        if (!vendorSell->IsEmpty(i))
                                        {
                                            SCSlot& _slot = pToContainer->GetSlot(i);
                                            if( _slot.GetSerial() == fromSlot.GetSerial() )
                                            {
                                                // ÀÌ¹Ì ¿Ã¶ó°¬´Ù.
                                                bAlreadyUpdated = true;
                                            }
                                        }
                                    }

									if (!bAlreadyUpdated)
                                    {
                                        // ¾ÆÀÌÅÛ °¡°Ý ¿Ã¸®±â â ¶ç¿ì±â

										if( g_pHero && g_pHero->GetCharInfo()->m_iInventoryLock == PLAYERINFO_FOR_PACKET::DISABLEDnEXIST)
										{
											GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5571));
										}
										else
										{
											uiVendorPopup *vendorPopup = GET_CAST_DIALOG ( uiVendorPopup, IM_VENDOR_MANAGER::VENDOR_POPUP );

											vendorPopup->ShowInterface(TRUE);
											vendorPopup->SetInfos(m_MouseItem.m_fromSlotIdx,
												SI_VENDOR_SELL,
												m_MouseItem.m_fromPos,
												ToPos);
											vendorPopup->SetItemSlot((SCItemSlot*)&toSlot);

											// ÀÏ´Ü °³ÀλóÁ¡ ½½·Ô¿¡ ²È¾Æ³õ°í °¡°ÝÃ¥Á¤

											ItemManager::Instance()->CopyItem(m_MouseItem.m_fromSlotIdx,
												SI_VENDOR_SELL,
												m_MouseItem.m_fromPos,
												ToPos);

											g_InterfaceManager.AttachFirstDialog(InterfaceManager::DIALOG_VENDOR_POPUP);
										}

                                        // ¸¶¿ì½º¿¡ µé°í ÀÖ´ø ¾ÆÀÌÅÛÀº ½½·Ô¿¡ ²È¾Æ ³õ¾ÒÀ¸¹Ç·Î ³»·Á³õ±â
                                        this->RollbackItemAtHand();
                                    }
                                    else
                                    {
                                        this->RollbackItemAtHand();
                                    }
                                }
                            }
                        }
                    }
                }
                //////////////////////////////////////////////////////////////////////////
                // vendor sell
                else if (SI_VENDOR_SELL == SlotIdx && SI_EQUIPMENT == m_MouseItem.m_fromSlotIdx)
                {
                    this->RollbackItemAtHand();

					//	ÀåÂøÁßÀÎ ¾ÆÀÌÅÛÀº ÆǸÅÇÒ ¼ö ¾ø½À´Ï´Ù.
					const int	c_iNotSellEqItem = 70418;
                    g_InterfaceManager.GetInterfaceString( c_iNotSellEqItem, szMessage, INTERFACE_STRING_LENGTH );
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage, CHAT_TYPE_SYSTEM );
                }

                //------------------------------------------------------------------------------
                //! ÀÚµ¿ »ç³É
#ifdef _YMS_AUTOBOT_GAME
                else if (SlotIdx == SI_AUTOMATIC_INFO)
                {
                    uiAutobotConditionBattle* dialog = GET_CAST_DIALOG(uiAutobotConditionBattle, 
                                                            uiAutobotConditionBattle::kDialog_ID);
                    if (dialog != NULL)
                    {
                        SCSlot& slot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);

                        if (dialog->CanLinkSlot(&slot, ToPos) == true)
                        {
                            ItemManager::Instance()->AutobotLinkItem(m_MouseItem.m_fromSlotIdx, 
                                                                        m_MouseItem.m_fromPos, 
                                                                        ToPos, 
                                                                        slot.GetCode());
                        }
                    }

                    RollbackItemAtHand();
                    return TRUE;
                }
#endif //_YMS_AUTOBOT_GAME
                else if (SlotIdx == SI_PERK && m_MouseItem.m_fromSlotIdx == SI_INVENTORY)
                {
                    SCItemSlot* item_slot = static_cast<SCItemSlot*>(m_MouseItem.m_pFromSlot);
                    if (item_slot == NULL)
                    {
                        return FALSE;
                    }

                    const BASE_ITEMINFO* item_info = item_slot->GetItemInfo();
                    if (item_info == NULL)
                    {
                        return FALSE;
                    }

                    if (item_info->m_wType == eITEMTYPE_PERK_CASH_ITEM)
                    {
                        ItemUseTransactionFromInventoryByItemTpye(SI_INVENTORY, m_MouseItem.m_fromPos);
                    }
                    
                    RollbackItemAtHand();

                    return TRUE;
                }
                //////////////////////////////////////////////////////////////////////////
                // Àκ¥ -> Áö´ÉÇüNPCâ
#ifdef _NA_000000_20140120_SMART_NPC_SYSTEM
                else if (SI_INVENTORY == m_MouseItem.m_fromSlotIdx && SI_SMARTNPC == SlotIdx)
                {
                    uiSmartNpcDialogReply* dialog = GET_CAST_DIALOG(uiSmartNpcDialogReply, IM_SMARTNPCDIALOG_MANAGER::SMARTNPCDIALOG_REPLY);
                    if (dialog && dialog->IsVisibleWindow() &&
                        dialog->GetSubType() == SmartDialogSubType_SlotInput)
                    {
                        SCSlot& toSlot = dialog->GetSlot(ToPos);
                        SCSlot& slot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);
                        if (this->m_MouseItem.m_fromSlotIdx == SI_INVENTORY)
                        {
                            ItemManager::Instance()->CopyItem(m_MouseItem.m_fromSlotIdx,
                                SI_SMARTNPC, m_MouseItem.m_fromPos,ToPos);

                        }
                    }
                    RollbackItemAtHand();

                    return TRUE;
                }
#endif //_NA_000000_20140120_SMART_NPC_SYSTEM
				//////////////////////////////////////////////////////////////////////////
				// default transaction
				else
				{
					SCSlot & rFromSlot	= pFromContainer->GetSlot(m_MouseItem.m_fromPos);
					SCSlot & rToSlot	= pToContainer->GetSlot(ToPos);
					
					if ( rFromSlot.GetCode() && rToSlot.GetCode() 
						&& (rFromSlot.GetCode() == rToSlot.GetCode())
						&& SCItemSlot::IsOverlap(rFromSlot.GetCode())
						)
					{
						// ºñ¿öÀÖÁö¾Ê°í Äڵ尡 °°´Ù

						SCItemSlot & rFromItemSlot = (SCItemSlot & )rFromSlot;
						SCItemSlot & rToItemSlot   = (SCItemSlot & )rToSlot;

						BOOL bIsCombineState = (!rFromItemSlot.IsBlocked()
												&&	!rFromItemSlot.IsLocked()
												&&	!rToItemSlot.IsBlocked()
												&&	!rToItemSlot.IsLocked());

						if ( bIsCombineState && rFromItemSlot.GetMaxNum() != rToItemSlot.GetNum())
						{
                            DURATYPE item_count = 0;
                            if (m_MouseItem.m_pRenderUnit->m_isDiv)
                            {
                                item_count = (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum);
                            }
							ItemManager::Instance()->SendItemCombineMsg(
								m_MouseItem.m_fromSlotIdx, 
								SlotIdx, 
								m_MouseItem.m_fromPos,
                                ToPos,
                                item_count );
						}
						else
						{
							RollbackItemAtHand();
						}
					}
					else if (m_MouseItem.m_pRenderUnit->m_isDiv)
                    {
                        
                        ItemManager::Instance()->SendItemMoveMsgWithDiv( 
                            m_MouseItem.m_fromSlotIdx, 
                            SlotIdx, 
                            m_MouseItem.m_fromPos, 
                            ToPos,
                            m_MouseItem.m_pFromSlot->GetNum() - (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum),
                            (m_MouseItem.m_pFromSlot->GetNum() - m_MouseItem.m_pRenderUnit->m_altNum));
                    }
                    else
					{
						ItemManager::Instance()->SendItemMoveMsg( 
							m_MouseItem.m_fromSlotIdx, 
							SlotIdx, 
							m_MouseItem.m_fromPos, 
							ToPos 
							);
					}
				}
				//////////////////////////////////////////////////////////////////////////
			}
			break;

		case ST_QUICK:
			{
#ifdef _YMS_AUTOBOT_GAME
                if (m_MouseItem.m_fromSlotIdx == SI_QUICK && SlotIdx == SI_QUICK)
                {
                    if (m_MouseItem.m_fromPos == ToPos)
                    {
                        // °°ÀºÀ§Ä¡¸é ·Ñ¹é
                        MouseHandler::Instance()->RollbackItemAtHand();
                        return FALSE;
                    }
                    else
                    {
                        ItemManager::Instance()->SendSimplexMoveLinkMsg(m_MouseItem.m_fromPos, ToPos);
                        return TRUE;
                    }
                }
                else if (m_MouseItem.m_fromSlotIdx == SI_AUTOMATIC_INFO && SlotIdx == SI_AUTOMATIC_INFO)
                {
                    if (m_MouseItem.m_fromPos == ToPos)
                    {
                        // °°ÀºÀ§Ä¡¸é ·Ñ¹é
                        MouseHandler::Instance()->RollbackItemAtHand();
                        return FALSE;
                    }
                    else
                    {
                        uiAutobotConditionBattle* dialog = GET_CAST_DIALOG(uiAutobotConditionBattle, uiAutobotConditionBattle::kDialog_ID);
                        if (dialog != NULL)
                        {
                            SCSlot& slot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);

                            if (dialog->CanLinkSlot(&slot, ToPos) == true)
                            {
                                ItemManager::Instance()->SimplexMoveLinkItem(SI_AUTOMATIC_INFO, m_MouseItem.m_fromPos, ToPos);
                            }
                        }
                        MouseHandler::Instance()->RollbackItemAtHand();
                        return TRUE;
                    }
                }
                else
                {
                    if (m_MouseItem.m_fromSlotIdx == SI_QUICK)
                    {
                        // Äü ¾ÆÀÌÅÛ Unlink
                        ItemManager::Instance()->SendQuickItemRemoveMsg(m_MouseItem.m_fromPos);
                        return TRUE;
                    }
                    else if (m_MouseItem.m_fromSlotIdx == SI_AUTOMATIC_INFO)
                    {
                        //! ¾ð¸µÅ©
                        ItemManager::Instance()->GetContainer(m_MouseItem.m_fromSlotIdx)->DeleteSlot(m_MouseItem.m_fromPos, NULL);	
                        MouseHandler::Instance()->RemoveItemAtHand();
                        return TRUE;
                    }
                }

#else
				if (SI_QUICK == SlotIdx)
				{
					if (m_MouseItem.m_fromPos == ToPos)
					{
						// °°ÀºÀ§Ä¡¸é ·Ñ¹é
						MouseHandler::Instance()->RollbackItemAtHand();
						return FALSE;
					}
					else
					{
						ItemManager::Instance()->SendSimplexMoveLinkMsg( 
							m_MouseItem.m_fromPos, 
							ToPos);
						return TRUE;
					}
				}
				else
				{
					// Äü ¾ÆÀÌÅÛ Unlink
					ItemManager::Instance()->SendQuickItemRemoveMsg( m_MouseItem.m_fromPos );
				}
#endif //_YMS_AUTOBOT_GAME

			}
			break;

		case ST_STYLE_QUICK:
			{
                if (SlotIdx != SI_INVENTORY)
                {
                    return FALSE;
                }
               
                SCPerkSlot* perk_slot = static_cast<SCPerkSlot*>(m_MouseItem.m_pFromSlot);
                const PerkInfo* perk_info = perk_slot->perk_info();
                if ((perk_info != NULL) &&
                    (perk_info->item_code_ == 0))
                {
                    return FALSE;
                }

                BOOL is_empty_slot = pToContainer->IsEmpty(ToPos);
                if (is_empty_slot == FALSE)
                {
                    return FALSE;
                }

                uiPerkDialog* perk_dialog = static_cast<uiPerkDialog*>(pFromContainer);
                if (perk_dialog != NULL)
                {
                    perk_dialog->RequestPerkOperaion(PerkControl::eReq_Uproot, 
                                                     m_MouseItem.m_fromPos, 
                                                     ToPos);
                    RollbackItemAtHand();
                }                

                return TRUE;
                
				
			}
			break;


		case ST_SKILL:
            {
				// ½ºÅ³¾ÆÀÌÅÛÀÌ´Ù.

                    // TODO :
                // À̺κРÀÌ»Ú°Ô ÇÔ¼ö·Î ³ª´²¼­ °ü¸®ÇÏÀÚ..

                //////////////////////////////////////////////////////////////////////////
                // Shop container
                if (m_MouseItem.m_fromSlotIdx == SlotIdx && m_MouseItem.m_fromPos == ToPos)
                {
                    MouseHandler::Instance()->RollbackItemAtHand();
                }
                //////////////////////////////////////////////////////////////////////////

                //////////////////////////////////////////////////////////////////////////
                // quickcontainer
                else if (SI_QUICK == SlotIdx)
                {
                    // ÄüÀ¸·Î ¸µÅ©

					BOOL bQuick = ItemManager::Instance()->CanLinkQuick(SI_QUICK, ToPos, m_MouseItem.m_pFromSlot);
                    if (bQuick)
                    {
                        ItemManager::Instance()->SendQuickSkillLinkMsg( 
                            m_MouseItem.m_pFromSlot->GetCode(), 
                            ToPos);
                    }
                    else
                    {
                        RollbackItemAtHand();
						return FALSE;
                    }
                }
#ifdef _YMS_AUTOBOT_GAME
                else if (SlotIdx == SI_AUTOMATIC_INFO)
                {
                    uiAutobotConditionBattle* dialog = GET_CAST_DIALOG(uiAutobotConditionBattle, uiAutobotConditionBattle::kDialog_ID);
                    if (dialog != NULL)
                    {
                        SCSlot& slot = pFromContainer->GetSlot(m_MouseItem.m_fromPos);

                        if (dialog->CanLinkSlot(&slot, ToPos) == true)
                        {
                            ItemManager::Instance()->AutobotLinkSkill(ToPos, slot.GetCode());
                        }
                    }

                    RollbackItemAtHand();
                    return TRUE;
                }
#endif //_YMS_AUTOBOT_GAME
				else if (SI_STYLE == SlotIdx)
				{
					return FALSE;			
				}
                //////////////////////////////////////////////////////////////////////////

                //////////////////////////////////////////////////////////////////////////
                // default transaction
                else
                {
                    ItemManager::Instance()->SendItemMoveMsg( 
                        m_MouseItem.m_fromSlotIdx, 
                        SlotIdx, 
                        m_MouseItem.m_fromPos, 
                        ToPos 
                        );
                }
                //////////////////////////////////////////////////////////////////////////
            }
			break;


		default:
			{
				assert( !"À߸øµÈ ŸÀÔÀÇ ½½·ÔÀ» ´ÜÃàâ¿¡ À̵¿Çß½À´Ï´Ù." );
			}
		}

	}
	else
	{
		// óÀ½ Ŭ¸¯

		SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
		assert(pAtContainer);

		SolarDialog * pContainerDlg = ItemManager::Instance()->GetItemContainerDialog(SlotIdx);
		assert(pContainerDlg);

		if( pAtContainer == NULL || pContainerDlg == NULL )
			return FALSE;

		if ( ToPos >= pAtContainer->GetMaxSlotNum() )
		{
			return FALSE;
		}

		if ( pAtContainer->IsEmpty(ToPos))
		{
			return FALSE;
		}

		SCSlot & rSlot = pAtContainer->GetSlot(ToPos);

		eSlotType eTempSlotType = rSlot.GetSlotType();

		switch( eTempSlotType  )
		{
		case ST_ITEM:
			{
				if ( SI_NPCSTORE == SlotIdx )
				{
					if (GetMouseState() == BUY)
					{
						// ¾ÆÀ̵ðÀÌ°í ¸î¹ø° 
						// ¾ÆÀÌÅÛÀÌ ¸î¹ø° À妽ºÀΰ¡?

						SCItemSlot & rSlot1 = (SCItemSlot &)pAtContainer->GetSlot(ToPos);

						ShopDialog * pShopDlg = static_cast<ShopDialog * >(pContainerDlg);

						DWORD dwShopID = (DWORD)pShopDlg->GetShopID();
						SHOPINFO * pShopInfo = (SHOPINFO *)ShopInfoParser::Instance()->GetShopList( dwShopID );

						SHOPINFO::SHOP_ITEM * pShopItem = pShopInfo->GetItem(rSlot1.GetCode());
						if (!pShopItem)
						{
							assert(!"ShopInfo.txt È®ÀÎ!!");
							return FALSE;
						}
						
#ifdef _NA_008678_20160203_ADD_HEIM_TRADINGVOLUME_NOTIFICATION_OPTION
						if (GlobalFunc::HeimTradingvolumeCheck(rSlot1.GetPriceForBuy()))
						{
							uiSystemMan* ui_system_manager_ptr = GET_DIALOG_MANAGER(uiSystemMan, UIMAN_SYSTEM);
							if (ui_system_manager_ptr)
							{
								ui_system_manager_ptr->Sys_SystemHeimTradingvolumeNpcStore(
									pShopDlg->GetDialogKey(), 
									1, 
									SlotIdx, 
									ToPos, 
									eTempSlotType, 
									rSlot1.GetCode(), rSlot1.GetPriceForBuy());
							}
						}
						else
						{
							ItemManager::Instance()->SendBuyMsg(
								pShopDlg ->GetShopID(), 
								rSlot1.GetCode(), pShopDlg->GetCurrentTab(), pShopDlg->GetRelativeSlotPos(ToPos) );
						}
#else
						ItemManager::Instance()->SendBuyMsg(
							pShopDlg ->GetShopID(), 
							rSlot1.GetCode(), pShopDlg->GetCurrentTab(), pShopDlg->GetRelativeSlotPos(ToPos) );
#endif // _NA_008678_20160203_ADD_HEIM_TRADINGVOLUME_NOTIFICATION_OPTION

						return TRUE;
					}

				}
				else if ( SI_EQUIPMENT == SlotIdx || SI_INVENTORY == SlotIdx)
				{  
					// ¼ö¸®
					if (GetMouseState() == REPAIR)
					{
						TCHAR szMessage[INTERFACE_STRING_LENGTH];
						TCHAR szItemName[INTERFACE_STRING_LENGTH];

						SCItemSlot & rItemSlot = (SCItemSlot &)rSlot;

						g_InterfaceManager.GetItemName( 
							rItemSlot.GetCode(), 
							szItemName, 
							INTERFACE_STRING_LENGTH);                        					

						TCHAR szTemp[INTERFACE_STRING_LENGTH];
						if ((rItemSlot.IsContainValidItem() == false) ||
                            (rItemSlot.WithDura() == false) ||								// ³»±¸µµ°¡ ¾ø´Â ¾ÆÀÌÅÛ
                            (rItemSlot.IsLimited() && (rItemSlot.GetLimitedDuraMax() <= 2)) // ¼ö¸®ÇÒ ¼ö ¾ø´Â ¸®¹ÌƼµå ¾ÆÀÌÅÛ
                           )
						{
							// ¼ö¸® ÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛ ÀÔ´Ï´Ù. 5130
							g_InterfaceManager.GetInterfaceString( eST_NOT_REPAIR_STATUS , szTemp ,INTERFACE_STRING_LENGTH);
							GlobalFunc::OutputMsg_Notice(
								eOUTPUT_MSG_CHAT, szTemp );
							return FALSE;
						}

						SetPendingRepairSlotIdx(SlotIdx);
						SetPendingRepairPos( ToPos );
						SetPendingRepairAll( FALSE );
						// [%s] ¸¦ ¼ö¸® ÇϽðڽÀ´Ï±î?#%I64u ÇÏÀÓÀÌ ¼Ò¿äµË´Ï´Ù. 5131
						g_InterfaceManager.GetInterfaceString( eST_IS_REPAIR_NEED_HAIM , szTemp ,INTERFACE_STRING_LENGTH) ;
                        TCHAR repair_money_string[INTERFACE_STRING_LENGTH] = "";
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
                        // ±æµå ½Ã¼³ È¿°ú ¿©ºÎ
                        if (g_pHero && 
                            g_pHero->GetPlayerAttribute()->GetAttrValue(eATTR_SHOP_REPAIR_HEIM_RATIO) != 0 && 
                            rItemSlot.GetPriceForRepair() > 0)
                        {
                            MONEY repair_need_money = rItemSlot.GetPriceForRepair();
                            int ratio = g_pHero->GetPlayerAttribute()->GetAttrValue(eATTR_SHOP_REPAIR_HEIM_RATIO);
                            bool is_plus = false;
                            if (ratio > 0)
                                is_plus = true;
                            ratio = abs(ratio);
                            MONEY percent_value = repair_need_money / 100 * ratio;
                            if (is_plus)
                            {
                                repair_need_money += percent_value;
                            }
                            else
                            {
                                repair_need_money -= percent_value;
                            }
                            GlobalFunc::SetPointText(repair_money_string, repair_need_money);
                        }
                        else
                        {
                            GlobalFunc::SetPointText(repair_money_string, rItemSlot.GetPriceForRepair());
                        }
#else
                        GlobalFunc::SetPointText(repair_money_string, rItemSlot.GetPriceForRepair());
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
                        // [%s] ¸¦ ¼ö¸® ÇϽðڽÀ´Ï±î?%s ÇÏÀÓÀÌ ¼Ò¿äµË´Ï´Ù. 5131
                        Sprintf(
							szMessage, 
							szTemp, 
							szItemName, 
							repair_money_string);

						uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
						if(pSystemMan)
							pSystemMan->Sys_Confirm(szMessage, GlobalFunc::RepairConfirm);

						return TRUE;
					}
					else if (GetMouseState() == SELL && SI_INVENTORY == SlotIdx)
					{
				
						// Ŭ¶óÀ̾ðÆ®¿¡¼­´Â ¾ÆÀÌÅÛ °Å·¡ ŸÀÔ¿¡ µû¸¥ üũ ¾ÈÇÔ
						ItemManager::Instance()->SendSellMsg(SlotIdx, ToPos);

						return TRUE;
					}
					else if (GetMouseState() == DEPOSIT && SI_INVENTORY == SlotIdx)
					{	// ÀÔ°í
						POSTYPE EmptyPos = 0xFF;
						BOOL bRet = ItemManager::Instance()->GetEmptySlotPos(SI_WAREHOUSE, EmptyPos);
						if (bRet)
						{
							ItemManager::Instance()->SendItemMoveMsg(
								SI_INVENTORY, 
								SI_WAREHOUSE, 
								ToPos, 
								EmptyPos
							);
						}						
						
						return TRUE;
					}
					else if(GetMouseState() == GUILD_DEPOSIT && SI_INVENTORY == SlotIdx)
					{	//±æµåâ°í ÀÔ°í
						POSTYPE EmptyPos = 0xFF;
						BOOL bRet = ItemManager::Instance()->GetEmptySlotPos(SI_GUILDWAREHOUSE, EmptyPos);
						if (bRet)
						{
							SCSlotContainer * pFromContainer = ItemManager::Instance()->GetContainer(SlotIdx); 
							SCItemSlot & rItemSlot = (SCItemSlot &)pFromContainer->GetSlot(ToPos);

							if( rItemSlot.IsPossessionItem() && rItemSlot.GetIdentifyPossession() )
							{								
								ItemManager::Instance()->NoticeReasonItemErrorCode(RC_ITEM_CANNOT_MOVE_WAREHOUSE_ITEM);
								return FALSE;
							}
							ItemManager::Instance()->SendItemMoveMsg(
								SI_INVENTORY, 
								SI_GUILDWAREHOUSE, 
								ToPos, 
								EmptyPos
								);
						}						

						return TRUE;
					}

					else if ( GetMouseState() == THROW_WASTE_BASKET && SI_INVENTORY == SlotIdx )
					{
						if ( IsLockWasteDeleteItem() )
						{
							return FALSE;							
						}

						LockWasteDeleteItem();

						ItemManager::Instance()->SetPendingDeleteItemPos(ToPos);

						TCHAR	szItemName[INTERFACE_STRING_LENGTH];
						TCHAR	szResult[INTERFACE_STRING_LENGTH];						
						TCHAR	szResultMsg[INTERFACE_STRING_LENGTH];						

						BOOL bExgist = g_InterfaceManager.GetItemName(
							rSlot.GetCode(), 
							szItemName, 
							INTERFACE_STRING_LENGTH );

						//5125	[%s] ¾ÆÀÌÅÛÀ» »èÁ¦ÇϽðڽÀ´Ï±î?
						g_InterfaceManager.GetInterfaceString(5125, szResult, INTERFACE_STRING_LENGTH);
						
						//¿¹¿Üó¸®:Á¤»óÀûÀ¸·Î ¾ÆÀÌÅÛÀ̸§À» ¼¼ÆøøÇßÀ»°æ¿ì
						if(!bExgist)
						{
						
						#ifdef _DEBUG
							Snprintf (szItemName, INTERFACE_STRING_LENGTH-1, _T("DebugMsg:Could Not Find ItemCode: %d"),rSlot.GetCode());
							GlobalFunc::default_OutputMsg(eOUTPUT_MSG_CHAT,szItemName);
						#endif//_DEBUG(µð¹ö±×¿¡¼­¸¸Ã¼Å©)

							Snprintf (szItemName, INTERFACE_STRING_LENGTH-1, _T("NULL"));
						}

						Snprintf( szResultMsg, INTERFACE_STRING_LENGTH, szResult, szItemName );

						uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
						if(pSystemMan)
						{
							m_WasteBasketDialogID = pSystemMan->Sys_Confirm(szResultMsg, GlobalFunc::DeleteItemConfirm);
						}

						return TRUE;
					}

				}
                else if ( SI_TRADE == SlotIdx )
                {
                    if (m_MouseItem.m_slotType == ST_NONE)
                    {
                        return TRUE;
                    }

                    if (m_MouseItem.m_fromPos >= 10)
                    {
                        return TRUE;
                    }
                }
				else if ( SI_WAREHOUSE == SlotIdx )
				{
					// Ãâ°í
					if (GetMouseState() == WITHDRAW)
					{
						POSTYPE EmptyPos = 0xFF;
						BOOL bRet = ItemManager::Instance()->GetEmptySlotPos(SI_INVENTORY, EmptyPos);
						if (bRet)
						{
							ItemManager::Instance()->SendItemMoveMsg(
								SI_WAREHOUSE, 
								SI_INVENTORY, 
								ToPos, 
								EmptyPos
							);
						}

						return TRUE;
					}
					else if(DEPOSIT == GetMouseState())
					{
						return TRUE;
					}
				}
				else if(SI_GUILDWAREHOUSE == SlotIdx)
				{ //±æµåâ°í Ãâ°í
					if (GetMouseState() == GUILD_WITHDRAW)
					{
						POSTYPE EmptyPos = 0xFF;
						BOOL bRet = ItemManager::Instance()->GetEmptySlotPos(SI_INVENTORY, EmptyPos);
						if (bRet)
						{
							ItemManager::Instance()->SendItemMoveMsg(
								SI_GUILDWAREHOUSE, 
								SI_INVENTORY, 
								ToPos, 
								EmptyPos
								);
						}

						return TRUE;
					}
					else if(GUILD_DEPOSIT == GetMouseState())
					{
						return TRUE;
					}
				}
                else if (SI_VENDOR_SELL == SlotIdx)
                {
                    // pToContainer ÀÌ»óÀÇ ±â´ÉÀ» ¿øÇϹǷΠȮÀåµÈ Æ÷ÀÎÅÍÀÎ ¿ø·¡Å¬·¡½º Æ÷ÀÎÅͷΠó¸®ÇÑ´Ù.

					uiVendorSell *vendorSell = GET_CAST_DIALOG ( uiVendorSell, IM_VENDOR_MANAGER::VENDOR_SELL );

					if(vendorSell)
					{
						SCSlot& toSlot      = vendorSell->GetSlot(ToPos);

						if (toSlot.GetCode())
						{
							// ½½·Ô¿¡ ä¿öÁ® ÀÖ´Â ¾ÆÀÌÅÛÀ» Ŭ¸¯ÇßÀ» °æ¿ì

							if (this->IsExistItemAtHand())
								this->RollbackItemAtHand();

							uiSCItemSlot& toItemSlot = (uiSCItemSlot&)toSlot;

                            if (toItemSlot.CanEquip())
							{
								vendorSell->SetCurrentItemSlotInfo(1,
									toItemSlot.GetMoney(),
									ToPos);
							}
							else
							{
								vendorSell->SetCurrentItemSlotInfo(toItemSlot.GetNum(),
									toItemSlot.GetMoney(),
									ToPos);
							}

							return TRUE;
						}
					}
					else
					{
						return FALSE;
					}
                }
                else if (SlotIdx == SI_SMARTNPC)
                {
                    return TRUE;
                }
                else if (SlotIdx == SI_DOMINATION_TOKEN)
                {
                    return FALSE;
                }
			}
			break;

		case ST_QUICK:
			{
				QuickSlot & rQuickSlot = (QuickSlot & )rSlot;

				if( !pAtContainer->IsEmpty( ToPos ) )
				{
					ItemUnitRenderer::RenderUnit * pRenderUnit = 
						pContainerDlg->GetItemUnitRender()->GetItemUnit( 
						rQuickSlot.GetOrgSerial() );

					assert(pRenderUnit);
					if (pRenderUnit)
					{
						AddItemAtHand( 
							SlotIdx, 
							ToPos, 
							eTempSlotType, 
							rQuickSlot.GetOrgCode(),
							pRenderUnit, 
							pRect 
							);
					}

					return TRUE;
				}
			}
			break;

		case ST_STYLE_QUICK:
			{
                // Perk ´ÙÀ̾ó·Î±×¿¡¼­ PerkÀ» µé¾î¿Ã¸°´Ù.
                SCPerkSlot& perk_slot_ref = static_cast<SCPerkSlot&>(rSlot);
                if (perk_slot_ref.is_active_slot() == true)
                {
                    return FALSE;
                }

                const PerkInfo* perk_info = perk_slot_ref.perk_info();
                if (perk_info == NULL)
                {
                    return FALSE;
                }

                ItemUnitRenderer* unit_renderer = pContainerDlg->GetItemUnitRender();
                if (unit_renderer == NULL)
                {
                    return FALSE;
                }
                DWORD perk_group = perk_slot_ref.GetPerkID().group_;
                ItemUnitRenderer::RenderUnit* render_unit = 
                    unit_renderer->GetItemUnit(perk_group);
                if (render_unit == NULL)
                {
                    return FALSE;
                }
                AddItemAtHand(SlotIdx, ToPos, eTempSlotType, 0, render_unit, pRect);
                return TRUE;
			}
			break;

		case ST_SKILL:
			{
				
				SLOTCODE code=rSlot.GetCode();
				BASE_SKILLINFO *pInfo = SkillInfoParser::Instance()->GetSkillInfo(code);
				if(pInfo == NULL)// /*&& pInfo->m_bySkillUserType==eSKILL_USER_SUMMONED*/)
				{
					return FALSE;
				}

			}
			break;

		default:
			assert(!"Á¤ÀǵÇÁö ¾ÊÀº ¾ÆÀÌÅÛ Å¸ÀÔÀÌ ¿Ô´Ù!!");
			return FALSE;
			break;
		}

		if (!pAtContainer->IsEmpty(ToPos))
		{
			SCSlot & rSlot = pAtContainer->GetSlot(ToPos);

			ItemUnitRenderer::RenderUnit * pRenderUnit = 
				pContainerDlg->GetItemUnitRender()->GetItemUnit( rSlot.GetSerial() );


            if (pRenderUnit)
            {
				BOOL bEnableDiv = TRUE;
                if (bEnableDiv && g_Input.GetState(DIK_LSHIFT, KS_KEY))
                {
                    if (eTempSlotType == ST_ITEM)
                    {
						SCItemSlot& rItemSlot = (SCItemSlot&)pAtContainer->GetSlot(ToPos);

						if (rItemSlot.GetLaxLock()->IsLock()) 
						{
							//GS_ADD:¾ÆÀÌÅÛ ºí·°½Ã ºÐÇÒÇÒ ¼ö ¾ø´Ù.
							return FALSE;
						}

                      
                        if (SlotIdx == SI_NPCSTORE)
                        {
                            if (rItemSlot.GetMaxNum() > 1 && !rItemSlot.IsBlocked() && !rItemSlot.IsLocked())
                            {
                                uiItemShopDiv* itemShopDiv = 
                                    GET_CAST_DIALOG(uiItemShopDiv, IM_ITEMDIV_MANAGER::ITEMSHOPDIV);

                                if (itemShopDiv)
                                {
                                    itemShopDiv->SetData(rItemSlot.GetMaxNum(),
                                        SlotIdx, 
                                        ToPos, 
                                        eTempSlotType, 
                                        pAtContainer->GetSlot(ToPos).GetCode(),
                                        pRenderUnit, 
                                        pRect,
                                        rItemSlot.GetPriceForBuy()
                                        );
                                    itemShopDiv->ShowInterface(TRUE);
                                }
                            }
                            else
                            {
                                AddItemAtHand( 
                                    SlotIdx, 
                                    ToPos, 
                                    eTempSlotType, 
                                    pAtContainer->GetSlot(ToPos).GetCode(),
                                    pRenderUnit, 
                                    pRect 
                                    );
                            }
                        }
                        else
                        {
						    if (rItemSlot.GetNum() > 1 && !rItemSlot.IsBlocked() && !rItemSlot.IsLocked() )
                            {
                                uiItemDiv* itemDiv = GET_CAST_DIALOG(uiItemDiv, IM_ITEMDIV_MANAGER::ITEMDIV);

                                if (itemDiv)
                                {
                                    itemDiv->SetData(rItemSlot.GetNum(),
                                        SlotIdx, 
                                        ToPos, 
                                        eTempSlotType, 
                                        pAtContainer->GetSlot(ToPos).GetCode(),
                                        pRenderUnit, 
                                        pRect 
                                        );
                                    itemDiv->ShowInterface(TRUE);
                                }
                            }
                            else
                            {
                                uiBase* itemDiv = GET_DIALOG(IM_ITEMDIV_MANAGER::ITEMDIV);
                                if ((itemDiv != NULL) && (itemDiv->IsVisible() == TRUE))
                                {
                                    itemDiv->ShowInterface(FALSE);
                                }
                                AddItemAtHand(SlotIdx, 
                                                ToPos, 
                                                eTempSlotType, 
                                                pAtContainer->GetSlot(ToPos).GetCode(),
                                                pRenderUnit, 
                                                pRect);
                            }
                        }
                    } // if( eTempSlotType == ST_ITEM )
                    else
                    {
                        AddItemAtHand( 
                            SlotIdx, 
                            ToPos, 
                            eTempSlotType, 
                            pAtContainer->GetSlot(ToPos).GetCode(),
                            pRenderUnit, 
                            pRect 
                            );
                    }
                } // if (g_Input.GetState(DIK_LSHIFT, KS_KEY))
                else
                {
                    uiBase* itemDiv = GET_DIALOG(IM_ITEMDIV_MANAGER::ITEMDIV);
                    if (itemDiv)
                    {
                        itemDiv->ShowInterface(FALSE);
                    }
                    AddItemAtHand( 
                        SlotIdx, 
                        ToPos, 
                        eTempSlotType, 
                        pAtContainer->GetSlot(ToPos).GetCode(),
                        pRenderUnit, 
                        pRect 
                        );
                }
            }
		}
	}

	return TRUE;
}


//----------------------------------------------------------------
/** ItemUseTransaction
	¾ÆÀÌÅÛ »ç¿ë°ü·ÃÇؼ­ Á¶°Ç ó¸®¿Í »ç¿ë ÆÐŶÀ» º¸³»´Â °ÍÀ» ´ã´ç. 
	comment by j0
*/
BOOL MouseHandler::ItemUseTransaction( SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	assert(pAtContainer);

	if (!pAtContainer)
	{
		return FALSE;
	}

	if (!g_pHero)
	{
		return FALSE;
	}
	
	if ( !_canUseTransaction(SlotIdx, AtPos) )
	{
		return FALSE;
	}

	switch (SlotIdx)
	{
	case SI_INVENTORY:
		{	
			ItemUseTransactionFromInventory(SlotIdx, AtPos);
		}
		break;

	case SI_SKILL:
		{
			SCSlot & rSlot = pAtContainer->GetSlot(AtPos);
			ItemUseTransactionFromSkill(rSlot.GetCode());
		}
		break;

	case SI_QUICK:
		{						
			ItemUseTransactionFromQuick(SlotIdx, AtPos);
		}
		break;
	}

	return TRUE;
}

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::_canUseTransaction( SLOTIDX SlotIdx, POSTYPE AtPos)
{
	if( g_pHero == NULL )
		return FALSE;

	if( g_pHero->IsPolymorph() == TRUE )
		return FALSE;

	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	if( pAtContainer == NULL )
	{
		return FALSE;
	}

	switch(SlotIdx)
	{
	case SI_INVENTORY:
		{	
			if (pAtContainer->IsEmpty(AtPos))
			{
				return FALSE;
			}	

			SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

			const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
			if ( pItemInfo )
			{
				if (eITEMTYPE_RECALL_ALLIANCE != pItemInfo->m_wType)
				{
					if (g_pHero && g_pHero->IsDead())
					{
						return FALSE;
					}	
				}
			}

			if ( GlobalFunc::IsInventoryLocknMessage() )
			{
				return FALSE;
			}
		}
		break;

	case SI_QUICK:
		{						
			QuickContainer * pQuickContainer = (QuickContainer * )pAtContainer;
			if ( !pQuickContainer )
			{
				return FALSE;
			}	

            POSTYPE RealQuickPos = pQuickContainer->GetCurTabNum();	// ÇöÀç ÅÜÀ§Ä¡.
            RealQuickPos = 0;// µÎÁÙÀ϶§´Â ÅÇÀ§Ä¡¸¦ ¾È´õÇÑ´Ù.
            AtPos = pQuickContainer->GetRealSlotPos(AtPos);
            RealQuickPos += AtPos;

			// °øÅë ¼±Çà Á¶°Ç

			if (RealQuickPos > pQuickContainer->GetMaxSlotNum() )
			{
				return FALSE;
			}

			if (pQuickContainer->IsEmpty(RealQuickPos)) 
			{
				return FALSE;
			}

			QuickSlot & rFromSlot = (QuickSlot &)pQuickContainer->GetSlot( RealQuickPos );
			POSTYPE OrgPos		= 0; 

			if ( ST_ITEM == rFromSlot.GetOrgSlotType() )
			{
				if ( !rFromSlot.GetOrgSlot() )
					return FALSE;

				SCItemSlot & rItemSlot = (SCItemSlot &)*rFromSlot.GetOrgSlot();

				const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
				if ( pItemInfo )
				{
					if (eITEMTYPE_RECALL_ALLIANCE != pItemInfo->m_wType)
					{
						if (g_pHero && g_pHero->IsDead())
						{
							return FALSE;
						}	
					}
				}

				if ( GlobalFunc::IsInventoryLocknMessage() )
				{
					return FALSE;
				}
			}
		}
		break;

	default:
	case SI_STYLE:
	case SI_SKILL:
		{
			if (g_pHero && g_pHero->IsDead())
			{
				return FALSE;
			}	
		}
		break;
	}


	return TRUE;
}

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::ItemUseTransactionFromInventory( SLOTIDX SlotIdx, POSTYPE AtPos )
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	if (!pAtContainer)
	{
		return FALSE;
	}

	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if( !pItemInfo )
	{
		return FALSE;
	}


#ifdef _NA_004035_20120227_COSTUME_ITEM
#ifdef _NA_008633_20160104_ADD_DECORATECOSTUME
	if( pItemInfo->m_wType == eITEMTYPE_COSTUME || 
		pItemInfo->m_wType == eITEMTYPE_COSTUME_DECORATE )
#else
    if( pItemInfo->m_wType == eITEMTYPE_COSTUME )
#endif // _NA_008633_20160104_ADD_DECORATECOSTUME
    {
        //ÄÚ½ºÆ¬ ¾ÆÀÌÅÛ
        if( ItemManager::Instance()->CanEquipClass( g_pHero, pItemInfo ) == TRUE &&
            ItemManager::Instance()->CanEquipByGender( g_pHero, pItemInfo ) == TRUE )
        {
            ItemManager::Instance()->SendItemUseMsg(SlotIdx, AtPos);
        }
        else
        {
            // 70667 ¾ÆÀÌÅÛ »ç¿ë Á¶°ÇÀÌ ¸ÂÁö ¾Ê½À´Ï´Ù.
            TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0,};	
            g_InterfaceManager.GetInterfaceString(70667, szMessage, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
        }

        return TRUE;
    }
#endif//_NA_004035_20120227_COSTUME_ITEM

    
    if (SCItemSlot::CanEquip(pItemInfo))
	{
        if ((rItemSlot.GetItemRuleInfo().is_valid_item == false) ||
            (rItemSlot.GetItemRuleInfo().is_etheria || rItemSlot.GetItemRuleInfo().is_shell))
        {
            ItemManager::Instance()->NoticeReasonItemErrorCode(RC::RC_ITEM_CAN_NOT_EQUIP);
            return FALSE;
        }

        //------------------------------------------------------------------------------ 
        if ( rItemSlot.IsPossessionItem() )
        {// ±Í¼Ó ¾ÆÀÌÅÛ »ç¿ë 
            if ( rItemSlot.GetIdentifyPossession() == 0 )
            {//±Í¼Ó¾ÆÀÌÅÛ Ã³À½ »ç¿ë
                // Ŭ·¡½º üũ
                if ( !ItemManager::Instance()->CanEquipClass(g_pHero, pItemInfo) )
                {
                    //	ÀåÂøÇÒ ¼ö ¾ø´Â Ŭ·¹½º ÀÔ´Ï´Ù.
                    TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0, };
                    g_InterfaceManager.GetInterfaceString( eST_CAN_NOT_EQUIP_CLASS, szMessage, INTERFACE_STRING_LENGTH );
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );

                    return FALSE;
                }

                // ´É·ÂÄ¡ Á¦ÇÑ Ã¼Å©
                if ( !ItemManager::Instance()->CanEquipLimit((SCItemSlot &)rItemSlot, TRUE))
                {
                    return FALSE;
                }
                //»ç¿ëÇÒ°ÇÁö Æ˾÷(±Í¼Ó ÀÎÁõ)
                if(	GetPossessionWin() != true )
                {
                    //5090	ÀåÂø½Ã ±Í¼ÓµË´Ï´Ù. ÀåÂøÇϽðڽÀ´Ï±î?
                    TCHAR szBuf[INTERFACE_STRING_LENGTH];
                    g_InterfaceManager.GetInterfaceString( 5090 , szBuf, INTERFACE_STRING_LENGTH-1);

                    uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
                    if(pSystemMan)
                    {
                        //! ¿©±â¼öÁ¤
                        //pSystemMan->Sys_Confirm(NULL, GlobalFunc::UsePossessionItem, NULL/*szTitle*/, szBuf);
                        pSystemMan->Sys_ConfirmLock(szBuf, GlobalFunc::UsePossessionItem);
                    }
                    SetPossessionItemPOS(AtPos, 255);
                    SetPossessionWin(true);
                    return FALSE;
                }
                else
                {
                    // 6130: Çѹø¿¡ Çϳª¾¿ ±Í¼Ó ÇÒ ¼ö ÀÖ½À´Ï´Ù.
                    TCHAR szBuf[INTERFACE_STRING_LENGTH];
                    g_InterfaceManager.GetInterfaceString( 6130 , szBuf, INTERFACE_STRING_LENGTH-1);
                    GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szBuf );
                    return FALSE;
                }
            }
        }		
        //------------------------------------------------------------------------------ 

		if (g_pMap->IsSnowManEventMap())
		{
			if (pItemInfo->IsWeapon())
			{
				//´«»ç¶÷À̺¥Æ®¸Ê¿¡¼­´Â ¹«±â Âø¿ë±ÝÁö!
				ItemManager::Instance()->NoticeReasonItemErrorCode(RC_ITEM_CANT_EQUIP_WEAPON);
				return FALSE;
			}
		}
		
		if (_useTransactionFateItemIdentify(rItemSlot, pItemInfo, AtPos) == TRUE)
        {
			return TRUE;
        }


		POSTYPE EQPos = 255;
		BOOL bCorrectPos = ItemManager::Instance()->GetEquipPosition(rItemSlot, EQPos);
		if (!bCorrectPos)
		{
			return FALSE;
		}

		

		BOOL bCanEquip = ItemManager::Instance()->CanEquip(SlotIdx, AtPos, (POSTYPE)EQPos);
		if (bCanEquip)
		{
			ItemManager::Instance()->SendItemMoveMsg(
				SI_INVENTORY, 
				SI_EQUIPMENT,
				AtPos, 
				EQPos);
			
			if (IsLockWasteDeleteItem() && (AtPos == ItemManager::Instance()->GetPendingDeleteItemPos()))
			{
				uiSystemMan* pSystemMan = (uiSystemMan*)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
				if (pSystemMan)
				{
					pSystemMan->Destroy_Sys_Confirm(m_WasteBasketDialogID);
					GlobalFunc::DeleteItemConfirm(false);
				}				
			}
		}
		else
		{
			g_HeroInput.PlayLimitUseSound();
		}

		return TRUE;
	}
    else if (eITEMTYPE_STAT_CHANGE == pItemInfo->m_wType || eITEMTYPE_SOCKET_CREATE == pItemInfo->m_wType) //xiaomi fix rclick destory stone
    {
        // ±â´É º¯°æÀ¸·Î ÀÎÇØ ´Ù¸¥ °÷¿¡¼­ È®ÀÎ ÇÔ
        return FALSE;
    }
#ifdef _20220329_ADD_EQU_RECOVERY
	else if (eITEMTYPE_EQU_RECOVERY == pItemInfo->m_wType )
	{
		return FALSE;
	}
#endif
	
    else if(pItemInfo->m_wType == eITEMTYPE_WAX)
    {
         MouseHandler::Instance()->RollbackItemAtHand();
         MouseHandler::Instance()->SetMouseState(MouseHandler::RIDER_WAX);
         CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair);
         keyMsg msg;
         ZeroMemory(&msg,sizeof(msg));
         msg.dwType=eDoType_Cursor_Rider_Wax;				
         msg.DoSomething=GlobalFunc::DoWaxGlossItemCancle;
         g_KeyQueueManager.PushBack(msg);
         SetPendingUseChargeItemPos(AtPos);
    }
	 else if (pItemInfo->IsRandomItem()) 
	 {
		if(	GetRandomWin() != true )
		{
			//6881	[%s] ¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
			TCHAR szBuf[INTERFACE_STRING_LENGTH];
			TCHAR szText[INTERFACE_STRING_LENGTH];
			TCHAR szItemName[MAX_PATH];
			g_InterfaceManager.GetInterfaceString( 6881 , szBuf, INTERFACE_STRING_LENGTH-1);
			
			g_InterfaceManager.GetItemName( pItemInfo->m_Code, szItemName, MAX_PATH );
			Snprintf( szText, INTERFACE_STRING_LENGTH - 1, szBuf, szItemName );
			
			SetRandomItemPOS(AtPos);
			SetRandomWin(true);

			//Àκ¥Å丮´Â ¶ô°ÉÀÚ
            uiInventoryMan* inventory_manager = GET_DIALOG_MANAGER(uiInventoryMan, UIMAN_INVENTORY);
            if (inventory_manager != NULL)
            {
                inventory_manager->LockInventoryUI();
            }

			uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
			if(pSystemMan)
				pSystemMan->Sys_ConfirmLock(szText, GlobalFunc::UseRandomItem);
			return FALSE;
		}
		else
		{
			// 6882: ÇØ´ç ¾ÆÀÌÅÛÀº Áߺ¹À¸·Î »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù. ÀÌÀü ¾ÆÀÌÅÛÀ» »ç¿ëÇÑ ÈÄ ½ÃµµÇØ ÁֽʽÿÀ.
			TCHAR szBuf[INTERFACE_STRING_LENGTH];
			g_InterfaceManager.GetInterfaceString( 6882 , szBuf, INTERFACE_STRING_LENGTH-1);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szBuf );
		}

	 }
	else if (pItemInfo->IsCanUseWaste() || pItemInfo->IsCanOnlyUseWaste()) 
	{
		BOOL bSpecialItem = FALSE;

		BASE_ITEMINFO * pItemInfo = 
			(BASE_ITEMINFO *)ItemInfoParser::Instance()->GetItemInfo(rItemSlot.GetCode());
		if(!pItemInfo)
		{
			return FALSE;
		}
		if(g_pHero->CanUseItem(pItemInfo,TRUE) && FALSE == rItemSlot.IsLocked())
		{

			if( ItemUseTransactionFromInventoryByItemTpye(SlotIdx, AtPos ) )
				return TRUE;

		}
	}
    else if(pItemInfo->IsRiderPartsItem())
    {
        if(ItemUseTransactionFromInventoryByRiderItemParts(SlotIdx,AtPos ))
        {
            return TRUE;
        }
    }
	else
	{
		//ÀÌÅ¢ÀÌ¾Æ´Ï°í ¼Ò¸ð¼º¾ÆÀÌÅÛµµ ¾Æ´Ï´Ù.
		if(ItemUseTransactionFromInventoryByChargeStyle(SlotIdx,AtPos ))
			return TRUE;
	}

	return TRUE;
}

//----------------------------------------------------------------
/** ¶óÀÌ´õ ¾ÆÀÌÅÛ ÆÄÃ÷¿¡´ëÇÑó¸®
*/
BOOL MouseHandler::ItemUseTransactionFromInventoryByRiderItemParts( SLOTIDX SlotIdx, POSTYPE AtPos )
{
    if (!g_pMap) return FALSE;

    if (!g_pHero) return FALSE;

    SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
    SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);
    const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();

    if(g_pHero->IsRiding() && pItemInfo)
    {
        TCHAR szMessage[INTERFACE_STRING_LENGTH]; 

        //¶óÀÌ´õ½½·ÔÀÌ ºñ¾îÀÖ´Ù¸é ÆÐŶº¸³½´Ù.
        POSTYPE RiderEquipPos = pItemInfo->m_wEqPos - eRIDER_PARTS_POS::StartIndex;
        if(g_pHero->GetSlotContainer(SI_RIDER) && g_pHero->GetSlotContainer(SI_RIDER)->IsEmpty(RiderEquipPos))
        {
            //º¸³»±âÀü ÀÌÅ¢°¡´ÉÇÑÁöÇѹø´õüũ

            SCItemSlot & rRiderSlot = (SCItemSlot &)g_pHero->GetSlotContainer(SI_INVENTORY)->GetSlot(g_pHero->m_RiderInfo.m_RiderItemPos);

            if(rRiderSlot.IsRiderItem())
            {
                RC::eITEM_RESULT result = rRiderSlot.CanEquipRiderParts(rItemSlot);

                if(result==RC::RC_ITEM_SUCCESS)
                {
                    MSG_CG_ITEM_RIDER_CONTROL_PARTS_SYN SendMsg;
                    SendMsg.header.request = SendMsg.header.eReq_EquipParts;
                    SendMsg.header.args.equip.from = AtPos;
                    SendMsg.header.args.equip.to.value =(BYTE)pItemInfo->m_wEqPos;
                    GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg) );
                    return TRUE;
                }
                else
                {
                    //6440:¼ÒȯÇÑ Å»°Í°ú ¸ÂÁö¾Ê´Â¾ÆÀÌÅÛÀÔ´Ï´Ù.
                    g_InterfaceManager.GetInterfaceString(6440,szMessage);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                }
            }
        }
        else
        {
            //6454 Å»°ÍÀåºñ°¡ ÀÌ¹Ì Âø¿ëÁßÀÔ´Ï´Ù.
            g_InterfaceManager.GetInterfaceString(6454,szMessage);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
        }
    }
    
    return FALSE;
}

//----------------------------------------------------------------
/** ij½¬¾ÆÀÌÅÛ ½ºÅ¸ÀÏ¿¡¿¡ µû¸¥Ã³¸®
*/
BOOL MouseHandler::ItemUseTransactionFromInventoryByChargeStyle( SLOTIDX SlotIdx, POSTYPE AtPos )
{
	if (!g_pMap) return FALSE;
	
	if (!g_pHero) return FALSE;
	
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);
	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();

	//3°¡ÁöÁ¶°ÇÀ» ¸¸Á·½Ã ¼­¹ö¿¡°Ô ÆÐŶÀ»º¸³½´Ù.(ex:Ãß°¡µÈ ¸íÁöÈÖºÀ°è¿­)
	// 1. ÀÌÅ¢¾ÆÀÌÅÛÀÌ ¾Æ´Ï¿©¾ÆÇÏ°í
	// 2. ChargeSubTypeÀÌ  eCHARGE_SUB_FIXED_AMOUNT_EX¿©¾ßÇϸé	  
	// 3. IsProgressTimeÀÌ falseÀ϶§
    BYTE charge_subtype = rItemSlot.GetItemRuleInfo().charge_sub_type;
	if (charge_subtype == eCHARGE_SUB_FIXED_AMOUNT_EX &&
		!rItemSlot.IsProgressTime())
	{
#ifdef _DEV_VER
				GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, _T("MSG_CG_ITEM_FIXED_AMOUNT_EX_ITEM_FIRE_UP_SYN"));
#endif 
		//ÁöÈÖºÀÀ϶§´Â ¿ìŬ¸¯½Ã ÄÑ°í ²ô°í¼­¹ö·Î ÆÐŶÀ» º¸³½´Ù.
		MSG_CG_ITEM_FIXED_AMOUNT_EX_ITEM_FIRE_UP_SYN SendPacket;
		SendPacket.m_FireUpItemPos = AtPos;
		GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendPacket, sizeof(SendPacket) );
	}
	return TRUE;
}


//----------------------------------------------------------------
/** ó¸® ÇßÀ¸¸é TRUE ó¸® ÇÏÁö ¸øÇßÀ¸¸é FALSE ¸¦ ¸®ÅÏÇÑ´Ù.
*/
BOOL MouseHandler::ItemUseTransactionFromInventoryByItemTpye(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	// ÀúÀå µÇÁö ¾ÊÀº »óÅ ( ÀúÀåÇØ¾ß ÇÑ´Ù. )
	if (!g_pMap)
	{
		return FALSE;
	}

	if (!g_pHero)
	{
		return FALSE;
	}



	// »ó´ÜÀÇ ÇÔ¼ö¿¡¼­ Á¶°Ç üũ¸¦ ÇßÀ¸´Ï ¹Ï°í ¾²ÀÚ.

	SCSlotContainer* pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot& rItemSlot = (SCItemSlot&)pAtContainer->GetSlot(AtPos);
	const BASE_ITEMINFO* pItemInfo = rItemSlot.GetItemInfo();

	//ÀÌÅ¢¾ÆÀÌÅÛÁß m_byEventCode¿Í µ¿ÀÏÇÑ ¾ÆÀÌÅÛÀÌ ÀÖ´ÂÁöüũ
	if (pItemInfo->m_byEventCode != 0)
	{
		if (!g_pHero->GetHeroEquipContainer()->FindEventCode(pItemInfo->m_byEventCode))
		{
			//5092 ¾ÆÀÌÅÛÀ» Àû¿ë½Ãų¼ö ÀÖ´Â Àåºñ¸¦ Âø¿ëÇؾߵ˴ϴÙ.
			GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5092));
			return FALSE;
		}
	}

	// À¯·áÈ­ ¾ÆÀÌÅÛ Ã³¸®
	switch (pItemInfo->m_wType)
	{
	case eITEMTYPE_SSQ:
		{
			if (g_ProjectileManagerEx.GetProjectile(g_dwSSQPortalKey) == NULL )
            {
				return UseTransationItemSSQ(SlotIdx, AtPos);
            }
			else
            {
				return FALSE;
            }
		}
		break;


	case eITEMTYPE_TOP_OF_TRIAL:
	case eITEMTYPE_TOP_OF_TRIAL_CHARGE:
		{
			return _useTransactionItemTopOfTrial(SlotIdx, AtPos);
		}
		break;

	case eITEMTYPE_PORTAL_QUEST_ITEM:
		{
			return _useTransactionItemPortalQuest(SlotIdx, AtPos);
		}
		break;

	case eITEMTYPE_TOTEM:
		{
			return _useTransactionChargeItemTransact(SlotIdx, AtPos);
		}
		break;


	case eITEMTYPE_PORTAL:				
	case eITEMTYPE_SAVE_COORD:
		return _useTransactionChargeItemPortalScroll(SlotIdx, AtPos);
		break;

	case eITEMTYPE_WAYPOINT:
		return _useTransactionChargeItemPersonalWaypoint(SlotIdx, AtPos);
		break;


	case eITEMTYPE_RECALL:
		{
			if (GameFramework::GetCurrentScene() && 
				(GameFramework::GetCurrentScene()->GetType() == SCENE_TYPE_VILLAGE))
			{
				// 5067	¸¶À»¿¡¼­´Â ÇØ´ç ¾ÆÀÌÅÛÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
				GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5067));
				return TRUE;
			}

			return _useTransactionChargeItemTransact(SlotIdx, AtPos);	
		}
		break;


	case eITEMTYPE_RECALL_ALLIANCE:
		{
			if (GameFramework::GetCurrentScene() && 
				GameFramework::GetCurrentScene()->GetType() == SCENE_TYPE_VILLAGE )
			{
				// 5067	¸¶À»¿¡¼­´Â ÇØ´ç ¾ÆÀÌÅÛÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
				GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5067) );
				return TRUE;
			}
			return _useTransactionChargeItemTransact( SlotIdx, AtPos );
		}
		break;

	case eITEMTYPE_REPAIR:
		{
			BOOL bRepairItem = ItemManager::Instance()->IsExistRepairItem(SI_EQUIPMENT);
			if (!bRepairItem)
			{
				//85225	¼ö¸®ÇÒ ¾ÆÀÌÅÛÀÌ ¾ø½À´Ï´Ù
				GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(85225));
				return TRUE;
			}			

			return _useTransactionItemDuraRepair( SlotIdx, AtPos );

		}
		break;



	case eITEMTYPE_STAT_RESET:
		{
			return _useTransactionChargeItemStatInit( SlotIdx, AtPos );							
		}
		break;


	case eITEMTYPE_SOCKETEXTRACT:
		{
			return TRUE;
		}
		break;


	case eITEMTYPE_RANK_DOWN:
		{
			return TRUE;
		}
		break;



	case eITEMTYPE_HAMMER_OF_ALCHEMIST:
		{
			return TRUE;
		}
		break;

	case eITEMTYPE_PET:		
		{
			if(!g_pHero) break;
			
			POSTYPE PetPos = AtPos; 
			//Æê¼Òȯ»óÅ¿¡¼­ ´Ù¸¥ÆêÀ» Ŭ¸¯Çß´Ù(ÀÚµ¿Æ걳ü)
			if(g_pHero->IsPetReturn() && g_pHero->GetPetItemPos() != AtPos)
			{
				SCPetInfo  * pPetInfo  = rItemSlot.GetPetInfo();
					
				//¼ÒȯºÒ°¡´É»óÅÂÀÎ ÆêÀ» Ŭ¸¯ÇßÀ»¶§
				if(pPetInfo->GetFullness()<=0 && GameFramework::GetCurrentScene()->GetType() != SCENE_TYPE_VILLAGE)
				{
					//6391
					GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(6391));
					break;
				}
				else
				{					
					g_pHero->PetChangeON(AtPos);			
					PetPos = g_pHero->GetPetItemPos();
				}
			}
			
			//Æê¼Òȯ
			MSG_CG_ITEM_USE_PET_ITEM_SYN SendPacket; 
			SendPacket.m_PetItemPos = PetPos;
			GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendPacket, sizeof(SendPacket) );
		}
		break;

	case eITEMTYPE_PET_FEED:		
		{
			//Æê»ç·á ¾ÆÀÌÅÛ
			ItemManager::Instance()->SendItemUseMsg(SlotIdx, AtPos);

			if(g_pHero)
				g_pHero->UsePetFeed();
		}
		break;

	case eITEMTYPE_PET_NAME_CARD:
		{
			//Æê¼Òȯ»óÅ¿¡¼­¸¸ °¡´É
			if (!g_pHero || !g_pHero->IsPetReturn()) 
            {
                break;
            }
						
			//Æê À̸§ ¼³Á¤ ¾ÆÀÌÅÛ
			uiPetNameSetting* pPetNameDlg = GET_CAST_DIALOG(uiPetNameSetting, IM_PET_MANAGER::PET_NAME_DLG);

			if (!pPetNameDlg || pPetNameDlg->IsVisible()) 
            {
                break;
            }

			pPetNameDlg->SetLockNameCard(AtPos);
			pPetNameDlg->ShowInterface(TRUE);
		}
		break;
 

	case eITEMTYPE_ETHER_BULLET:
		{
			if (!g_pHero) 
            {
                break;
            }

			//ÆÐŶ±â´Ù¸®´Â»óÅ¿¡¼­´Â ÀÏ´ÜÁ¤Áö
			if (g_pHero->GetEthreInfo().bWait) 
            {
                break;
            }

			MSG_CG_ITEM_ACTIVE_ETHER_BULLET_SYN SendPacket;
				
			//ÀåÀüµÇÀִµ¥ ´Ù¸¥ źȯÀ» ´­·¶À»°æ¿ì
			if (g_pHero->GetEthreActive())
			{
				SendPacket.m_bActive = FALSE;
				if (AtPos == g_pHero->GetEthreInfo().byEtherChargePos) 
				{
					//ÇØÁ¦
					SendPacket.m_ActiveBulletItemPos = AtPos;
				}
				else
				{
					//±³Ã¼
					SendPacket.m_ActiveBulletItemPos = g_pHero->GetEthreInfo().byEtherChargePos;
                    g_pHero->EtherChangeON(AtPos);
				}
			}
			else
			{
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
                if (GlobalFunc::IsBattleGroundScene() == TRUE)
                {
                    // ÀüÀå¿¡¼± ¿¡Å׸£ÅºÈ¯ »ç¿ë ºÒ°¡
                    // 3578
                    TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0,};	
                    g_InterfaceManager.GetInterfaceString(3578,szMessage,INTERFACE_STRING_LENGTH);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                    
                    break;
                }

#endif //_NA_008679_20160202_REWORK_BATTLEGROUND

				//ÀåÀü:µô·¹ÀÌ»óÅÂÀ϶§ ¸®ÅÏ
				SendPacket.m_bActive = TRUE;
				g_pHero->SetEtherChargePos(AtPos);
				SendPacket.m_ActiveBulletItemPos = AtPos;
				
			}

			g_pHero->SetEtherWaitPacket(true);
			GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendPacket, sizeof(SendPacket));
		}
		break;



		case eITEMTYPE_LOTTO:
			{
				//Ÿ¶ôÇÑ»ç¿ø¿¡¼­´Â º¹±ÇÀ» ¿­¼ö¾ø´Ù.
				if(GlobalFunc::IsSSQScene())
				{
					break;
				}

				if(!g_pHero) break;
				 
				LotteryInventoryDialog *pPandoraDlg =  GET_CAST_DIALOG( LotteryInventoryDialog, IM_INVENTORY_MANAGER::LOTTERYINVEN_DLG);
				
				if(!pPandoraDlg) break;

				//º¹±ÇâÀÌ ¿­·ÁÀÖ´Ù¸é ºí·°½ÃŲ´Ù.
				if(pPandoraDlg->IsVisible()) break;
												
				pPandoraDlg->SetInvenPos(AtPos);
				
				int nEmptySlot =  g_pHero->GetEmptyUseSlot();

				SCLottoInfo* pLottoSlot = rItemSlot.GetLottoInfo();
				if(!pLottoSlot) break;

                if (pLottoSlot->GetIdentityStatus())
                {
                    pPandoraDlg->SendItemUseSync(TRUE);		//Æǵµ¶ó ¾ÆÀÌÅÛ ¿­±âÆÐŶº¸³»±â
                }
                else
                {
                    keyMsg msg;
                    ZeroMemory(&msg,sizeof(msg));
                    msg.dwType = eDoType_Lottery_OpenDlg;
                    msg.DoSomething = GlobalFunc::DoLotteryOpenCancel;
                    msg.lParam = InterfaceManager::DIALOG_DELAY_CASTING;
                    g_KeyQueueManager.PushBack(msg);
                    StartLeaveFieldCastTimer(eDoType_Lottery_OpenDlg,3000); 
                    RollbackItemAtHand();
                    //Àκ¥Å丮´Â ¶ô°ÉÀÚ
                    uiInventoryMan* inventory_manager = GET_DIALOG_MANAGER(uiInventoryMan, UIMAN_INVENTORY);
                    if (inventory_manager != NULL)
                    {
                        inventory_manager->LockInventoryUI();
                    }
                }
			}
			break;  


		case eITEMTYPE_RIDER:// Å» °Í ¾ÆÀÌÅÛ ¿ìŬ¸¯½Ã
			{
                //¿¹¿Üó¸®:1.¿ëº¯½Å»óÅ¿¡¼­ ¾ÆÀÌÅÛŬ¸¯¹æÁö(6472)
                //         2.¶óÀÌ´õ ±³Ã¼»óÅÂ(ÆÐŶ´ë±â½Ã¿¡´Â À̺¥Æ®¸·´Â´Ù)
                //         3.ij½ºÆýÃÀÛÀ» º¸³ÂÀ»¶§
                //         4.Á¡ÇÁ»óÅ¿¡¼­ Ŭ¸¯¹æÁö
                //         5.ij½ºÆþִÏÁß¿¡´Â Áߺ¹Å¬¸¯À» ¸·´Â´Ù
                //         6.½ºÅ³»óÅ¿¡¼­´Â ¼ÒȯÇÒ¼ö¾ø´Ù.
                //         7.½ºÅ³Å¥¿¡ °ªÀÌ ÀÖÀ»¶§
                //         8.½¦µµ¿ì ÇÏÀÌµå »óÅ¿¡¼­´Â ºÒ°¡
                if(g_pHero->IsTransForm() || 
                   g_pHero->m_RiderInfo.m_bChangeRider|| 
                   g_pHero->m_RiderInfo.m_bSendSummon || 
                   g_pHero->GetCurState()==STATE::KEYBOARDJUMP ||
                   g_pHero->GetCurState()==STATE::SUMMON_RIDER || 
                   g_pHero->GetCurState()==STATE::SKILL        ||
                   (g_pHero->GetHideSkill()&&g_pHero->GetClass()==eCHAR_SHADOW) || 
                   g_SkillQueue.Size()>0        )
                {
                        //6472:Áö±ÝÀº »óÅ¿¡¼­´Â ¼ÒȯÇÒ¼ö¾ø´Ù
                        TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0,};	
                        g_InterfaceManager.GetInterfaceString(6472,szMessage,INTERFACE_STRING_LENGTH);
                        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                        break;
                }       

                //±â°£¸¸·á¶óÀÌ´õ¿¡´ëÇÑó¸®
                if(rItemSlot.IsExpiredWaitTime())
                {
                    //¶óÀ̵ù»óÅ¿¡¼­´Â  ¹ÝÀÀ¾ø¾î¾ßÇÔ
                    if(g_pHero->IsRiding())
                    {
                        break;
                    }

                    RiderInventoryDialog *pInven = (RiderInventoryDialog *)g_pHero->GetSlotContainer(SI_RIDER);
                    
                    if(pInven)
                    {
                        //¿­·ÁÀÖ°í µð½ºÇ÷¹À̿밴ü°¡ º¸¿©Áö´Â»óÅÂÀ϶§
                        if(pInven->IsSlotRider())
                        {   
                            //À§Ä¡°¡ Ʋ¸®´Ù¸é ¿ä³ðÇØÁ¦ÇÏ°í ÀÌ°É·ç ±³Ã¼ÇØÁØ´Ù.
                            if(pInven->GetRiderSummonPos()!=AtPos)
                            {
                                pInven->UnlockSlotRider(TRUE);
                                pInven->CopySlotRider(AtPos);
                            }
                            else
                            {
                                //È°¼ºÈ­»óÅ¿¡¼­ ¶ÇÇѹø´©¸£¸é âÀ» ´Ý¾ÆÁØ´Ù.
                                pInven->ShowInterface(FALSE);
                            }
                        }
                        else
                        {   
                            //¾È¿­·È´Ù¸é ¹Ù·Î open
                            pInven->CopySlotRider(AtPos);
                            pInven->ShowInterface(TRUE);
                        }
                        break;
                    }
                }
                
         	    MSG_CG_ITEM_RIDER_CONTROL_SYN SendMsg;
        		
                //ÇöÀç¼Òȯ»óÅÂÀ϶§(ÇØÁ¦ÇÑ´Ù:request==eReq_SummonRelease)
			    if(g_pHero->IsRiding())
			    {
                    if(g_pHero->GetCurState()==STATE::KEYBOARDJUMP)
                    {
                        //Á¡ÇÁ½Ã¿¡´Â ¾×¼ÇÀ» ¸·´Â´Ù.
                        break;
                    }

    			    SendMsg.header.request = SendMsg.header.eReq_SummonRelease;
                    
				    //Ŭ¸¯À§Ä¡°¡ ÇöÀç¼ÒȯµÈÀ§Ä¡°¡ ¾Æ´Ï¶ó¸é(´Ù¸¥Å»°ÍÀ» Ŭ¸¯Çß´Ù)
				    if(g_pHero->m_RiderInfo.m_RiderItemPos!=AtPos)
				    {
					    //Ŭ¶ó¿¡¼­ ÀÚµ¿ÀǷμÒȯÇØÁ¦ÈÄ ¼ÒȯÇÒ¼öÀÖµµ·Ï m_bChangeRiderº¯¼ötrue
					    g_pHero->m_RiderInfo.m_bChangeRider = TRUE;
					    g_pHero->m_RiderInfo.m_RiderChangePos = AtPos;
                        SendMsg.header.args.summon.slot_pos = g_pHero->m_RiderInfo.m_RiderItemPos;
				    }
                    else
                    {
                        SendMsg.header.args.summon.slot_pos = AtPos;
                    }
                    
                    GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg) );
			    }
			    else
			    {       
                    //º¸³»±âÀü¿¡ ¼ÒȯÇÒ¼öÀÖ´Â Áö¿ªÀÎÁöüũÇÑ´Ù
                    const  sRiderInfo* pRiderInfo = RidingInfoParser::Instance()->GetInfo(rItemSlot.GetItemInfo()->m_wSkillCode);

                    const sMAPINFO * pMapInfo = MapInfoParser::Instance()->FindMapInfo( (MAPCODE)g_pMap->GetMapID() );

                    if(pRiderInfo && pMapInfo)
                    {
                        if(pRiderInfo->IsAcceptField(eZONETYPE(pMapInfo->byMKind)))
                        {
                            //µ¿±âÈ­¸¦ ¸ØÃá´Ù
                            g_HeroInput.SetAutoRun(FALSE);
                            g_HeroInput.SetFollowState(FALSE);
                            g_HeroInput.SetAutoAttack(FALSE);

                            //Å»°Íºñ¼Òȯ»óÅ¿¡¼­´Â ¼Òȯij½ºÆÃÀ» º¸³½´Ù.
                            SendMsg.header.request = SendMsg.header.eReq_SummonStart;
                            SendMsg.header.args.casting_start.slot_pos = AtPos;
                            g_pHero->m_RiderInfo.m_RiderItemPos = AtPos;
                            g_pHero->m_RiderInfo.m_bSendSummon  = TRUE;
                            GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg) );
                        }
                        else
                        {
                            //6436:¼ÒȯÇÒ¼ö¾ø´Â Áö¿ªÀÔ´Ï´Ù.
                            TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0,};	
                            g_InterfaceManager.GetInterfaceString(6436,szMessage,INTERFACE_STRING_LENGTH);
                            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                            break;
                        }
                    }
                    else
                    {
                        assert(!"¸Ê or ¶óÀÌ´õÁ¤º¸¾øÀ½");
                        break;
                    }
			    }
			}
			break;

        case eITEMTYPE_ETHEREALIZER:
            {
                SetEtheriaExtractState();
                SetPendingUseChargeItemPos(AtPos);
            }
            break;

        case eITEMTYPE_CHANGE_CHARACTER_APPEARANCE_ALL:
        case eITEMTYPE_CHANGE_CHARACTER_FACE:
        case eITEMTYPE_CHANGE_CHARACTER_HAIR:
            {
				if (ItemManager::Instance()->CanEquipClass(g_pHero, pItemInfo))
				{
					SetCharCustomizeDlg(pItemInfo->m_wType, AtPos);
				}
                else
                {
                    int class_code = 0;
                    switch (pItemInfo->GetFirstAvailableClass())
                    {
                    case eCHAR_BERSERKER:
                        class_code = eST_CHARACTER_CLASS_NAME_BERSERKER;
                        break;
                    case eCHAR_DRAGON:		
                        class_code = eST_CHARACTER_CLASS_NAME_DRAGON;
                        break;
                    case eCHAR_SHADOW:		
                        class_code = eST_CHARACTER_CLASS_NAME_SHADOW;
                        break;
                    case eCHAR_VALKYRIE:		
                        class_code = eST_CHARACTER_CLASS_NAME_VALKYRIE;
                        break;
                    case eCHAR_MAGICIAN:
                        class_code = eST_CHARACTER_CLASS_NAME_MAGICIAN;
                        break;
                    case eCHAR_MYSTIC: //_NA_004965_20120613_NEW_CHARACTER_MYSTIC
                        class_code = eST_CHARACTER_CLASS_NAME_MYSTIC;
                        break;
                    case eCHAR_HELLROID: //_NA_000000_20130812_NEW_CHARACTER_HELLROID
                        class_code = eST_CHARACTER_CLASS_NAME_HELLROID;
                        break;
                    case eCHAR_WITCHBLADE: //_NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
                        class_code = eST_CHARACTER_CLASS_NAME_WITCHBLADE;
                        break;
                    }

                    TCHAR class_name[512]; 
                    g_InterfaceManager.GetInterfaceString(class_code, class_name);
                    // 2228: ÇØ´ç ¾ÆÀÌÅÛÀº %s Ŭ·¡½º¸¸ »ç¿ëÇÒ ¼ö ÀÖ½À´Ï´Ù.
                    TCHAR string_msg[INTERFACE_STRING_LENGTH]; 
                    g_InterfaceManager.GetInterfaceString(2228, string_msg);
                    TCHAR output_message[INTERFACE_STRING_LENGTH]; 
                    Snprintf(output_message,INTERFACE_STRING_LENGTH-1, string_msg, class_name);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, output_message);
                }
            }
            break;

		case eITEMTYPE_POLLEN:
		case eITEMTYPE_TORCH:
		case eITEMTYPE_MINE:
		case eITEMTYPE_FIRECRACKER:
			{	
				if(g_pHero->IsRiding())
				{
                    //6455 Å»°Í ¼Òȯ»óÅ·ΠÇØ´ç¾ÆÀÌÅÛÀ» »ç¿ëÇÒ¼ö¾ø½À´Ï´Ù.
                    TCHAR szMessage[INTERFACE_STRING_LENGTH]; 
                    g_InterfaceManager.GetInterfaceString(6455,szMessage);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
					break;
				}
				if( g_pHero && g_pHero->GetCurState() == STATE::IDLE )
				{
					WzVector wvTargetPos;
					if( pItemInfo->m_wType == eITEMTYPE_TORCH )
					{
						wvTargetPos = g_pHero->GetPosition() +  g_pHero->GetDirection() * 10.0f;

						float fT=0.0f;
						int iMesh = g_pMap->GetWorldBase()->PathExp_GetMeshToStand( wvTargetPos, &fT, 100.0f,TMGO_NO_COLLISION);

						if( iMesh>=0 && fT > 0.0f && fT < 5.0f)
						{
							wvTargetPos.z -= fT;
						}

					}
					else if( pItemInfo->m_wType == eITEMTYPE_MINE)
					{
						wvTargetPos = g_pHero->GetPosition() + g_pHero->GetDirection() * 0.5f;
					}
					else
					{
						wvTargetPos = g_pHero->GetPosition();
					}	
					if( GameFunc::IsMove(g_pHero->GetPosition(), wvTargetPos) )
					{
						SetPendingSkillItemPos(AtPos);

#ifdef _YJ_PK_OPTION_001120
						BOOL bPKO = GAMEOPTION->GetPKWithoutCtrlKey();
						m_bCtlKeyDown = ( bPKO ||  ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) );
#else
						m_bCtlKeyDown = (GetAsyncKeyState(VK_CONTROL) & 0x8000);
#endif //_YJ_PK_OPTION_001120
						
						

						MSG_CG_ITEM_USE_MOTION_SYN SendMsg;
						SendMsg.m_wvMainTargetPos = wvTargetPos;
						SendMsg.m_atPos =AtPos;
						SendMsg.m_atIndex =SlotIdx;
						GlobalFunc::SendPacket(CI_GAMESERVERIDX, &SendMsg, sizeof(SendMsg));
					}
					else
					{
						//6137 ÇØ´ç Áö¿ªÀ¸·Î´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
						GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(6137));
					}
				}
			}	
			break;

		case eITEMTYPE_CHANGE_GUILD_NAME:
			{
#ifdef _NA_003923_20120217_GUILD_RENEWAL_UI_GUILD_MANAGER
                uiGuildRelationAsk* ui_guild_ask = 
                    GET_CAST_DIALOG(uiGuildRelationAsk, uiGuildRelationAsk::kDialog_ID);
                if (ui_guild_ask != NULL)
                {
                    ui_guild_ask->set_guild_ask_type(uiGuildRelationAsk::kGuild_Rename);
                    ui_guild_ask->set_item_slot_position(AtPos);
                    ui_guild_ask->ShowInterface(TRUE);
                }
#else
                if(g_pHero && g_pHero->IsExistGuild())
                {
                    uiChangeGuildName* pDlg = GET_CAST_DIALOG(uiChangeGuildName, IM_GUILD_MANAGER::GUILD_CHANGE_GUILD_NAME);
                    if(pDlg && FALSE == pDlg->IsVisibleWindow())
                    {
                        pDlg->SetSlotInfo(SlotIdx, AtPos);
                        pDlg->ShowInterface(TRUE);
                    }
                }
#endif //_NA_003923_20120217_GUILD_RENEWAL_UI_GUILD_MANAGER
			}
			break;

        case eITEMTYPE_PERK_CASH_ITEM:
            {
                uiPerkDialog* perk_dialog = GET_CAST_DIALOG(uiPerkDialog, IM_SKILL_MANAGER::SKILL_PERK_DLG);
                if (perk_dialog != NULL)
                {
                    perk_dialog->RequestPerkOperaion(PerkControl::eReq_Plants, 
                                                     AtPos,
                                                     0);
                }
            }
            break;

        case eITEMTYPE_DOMINATION_BUFF:
            {
                Object* object_ptr = g_ObjectManager.GetObject(g_HeroInput.GetCurrentTarget());
                if (object_ptr != NULL)
                {
                    GlobalFunc::NET_SEND_CG_ITEM_USE_SKILL_ACTION_SYN(static_cast<eSlotContainerIndex>(SlotIdx), 
                                                                        AtPos, 
                                                                        object_ptr->GetObjectKey(),
                                                                        object_ptr->GetPosition());
                }
            }
            break;

        case eITEMTYPE_CHANGE_CHARACTER_GENDER:
            {
                // Àåºñ¸¦ ÀüºÎ ÇØÁ¦ÇÏ¿´´ÂÁö üũ
                if (g_pHero == NULL)
                {
                    return FALSE;
                }

                if (g_pHero->CanUseChangeGenderItem() == FALSE )
                {
					TCHAR message[INTERFACE_STRING_LENGTH] = {'\0', };
					// 5884 ¾ÆÀÌÅÛÀÌ ÀåÂøµÇ¾î ÀÖ´Â »óÅ¿¡¼­´Â »ç¿ëÀÌ °¡´ÉÇÏÁö ¾Ê½À´Ï´Ù.
					g_InterfaceManager.GetInterfaceString(5884, message);
					GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);
				}
#ifdef _NA_000000_20130812_NEW_CHARACTER_HELLROID
                else if( g_pHero->GetClass() == eCHAR_HELLROID )
                {
                }
#endif //_NA_000000_20130812_NEW_CHARACTER_HELLROID
#ifdef _NA_004965_20120613_NEW_CHARACTER_MYSTIC
				else if( g_pHero->GetClass() == eCHAR_MYSTIC )
				{
					//// ¹Ì½ºÆ½Àº »ç¿ë°¡´ÉÇÏÁö ¾Ê´Ù°í ¾È³»¸Þ¼¼Áö¸¦ Ç¥½ÃÇÒ°Í
					//TCHAR message[INTERFACE_STRING_LENGTH] = {'\0', };
					//// 5884 ¾ÆÀÌÅÛÀÌ ÀåÂøµÇ¾î ÀÖ´Â »óÅ¿¡¼­´Â »ç¿ëÀÌ °¡´ÉÇÏÁö ¾Ê½À´Ï´Ù.
					//g_InterfaceManager.GetInterfaceString(5884, message);
					//GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);

#ifdef _DEV_VER
					GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, "¤»¤»¤»¤»");
#endif //_DEV_VER
				}
#ifdef _NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
                else if (g_pHero->GetClass() == eCHAR_WITCHBLADE)
                {
                }
#endif //_NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
#endif //_NA_004965_20120613_NEW_CHARACTER_MYSTIC
				else
				{
                    const BASE_ITEMINFO* item_info = rItemSlot.GetItemInfo();
                    BYTE gender = static_cast<BYTE>(g_pHero->GetGender());
                    gender = (gender == GenderType::kMale) ? GenderType::kFemale : GenderType::kMale;
                    if (item_info->m_byWasteType != 0 && item_info->m_byWasteType != gender)
                    {
                        return FALSE;
                    }
                    
                    uiAssistMan* assist_man = static_cast<uiAssistMan*>(
                        g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  

                    if (assist_man)
                    {
                        assist_man->ShowAskCharChangeGender(gender, AtPos);
                    }
                }
            }
            break;
        case eITEMTYPE_EXTEND_CHARACTER_SLOT:
            {
                uiAssistMan* assist_man = static_cast<uiAssistMan*>(
                    g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  

                if (assist_man)
                {
                    assist_man->ShowAskAddCharSlot(AtPos);
                }
            }
            break;
        case eITEMTYPE_SOCKET_COMPOSE_ADDITIVE:
            {
                //Àðµå ÇÕ¼º ÷°¡Á¦ÀÇ °æ¿ì Àκ¥Å丮¿¡¼­ »ç¿ë ºÒ°¡´ÉÇÏ´Ù.
                // 2011.7.13 / ¼ÛÂùÁ¾ / ½ºÅ©¸³Æ®ÀÇ ¾ÆÀÌÅÛ »ç¿ë °¡´É(MaterialType)À» ²ô´Â °ÍÀ¸·Î ¸·Áö ¾Ê°í ÀÌ°÷¿¡¼­ ¾Æ¹« ó¸® ¾ÈÇϵµ·Ï ÇÔ
                //                      ½ºÅ©¸³Æ® »ó¿¡¼­ ¾ÆÀÌÅÛ »ç¿ë ºÒ°¡´ÉÀ¸·Î Çϸé Àðµå ÇÕ¼ºÃ¢¿¡¼­ ¼­¹ö¿¡¼­ Á¦´ë·Î µ¿ÀÛ ÇÏÁö ¾ÊÀ» ¼ö ÀÖ´Ù°í ÇÔ
            }
            break;

#ifdef _NA_003740_20111122_RANDOM_ITEM
        case eITEMTYPE_RANDOMIZE_ITEM:
            {
                SetRandomizeItemMode( AtPos );
                return TRUE;
            }
            break;
#endif //_NA_003740_20111122_RANDOM_ITEM

#ifdef _NA004034_20120102_POINT_WALLET_SYSTEM
        case eITEMTYPE_BILL:
            {
                uiAssistMan::ShowUseCurrencyItem(AtPos);
            }
            break;
#endif //_NA004034_20120102_POINT_WALLET_SYSTEM

        case eITEMTYPE_CHARACTER_NAME_CHANGE:
            {
                // ij¸¯¸í º¯°æ ¾ÆÀÌÅÛ
                if (GameFramework::GetCurrentScene() &&
                    (GameFramework::GetCurrentScene()->GetType() != SCENE_TYPE_VILLAGE))
                {
                    TCHAR message[INTERFACE_STRING_LENGTH] = {'\0', };
                    // 158555 ÇØ´ç ¾ÆÀÌÅÛÀº ¸¶À»¿¡¼­¸¸ »ç¿ë °¡´ÉÇÕ´Ï´Ù.
                    g_InterfaceManager.GetInterfaceString(158555, message);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);

                }
                else
                {
                    uiSystemMan* ui_system_manager = GET_DIALOG_MANAGER(uiSystemMan, UIMAN_SYSTEM);
                    if (ui_system_manager)
                    {
                        m_SendSlotIdx = SlotIdx;
                        m_SendAtPos	  = AtPos;

                        TCHAR message[INTERFACE_STRING_LENGTH] = {'\0', };
                        // 158550 %s ij¸¯ÅÍ¿¡°Ô ij¸¯ÅÍ¸í º¯°æ±ÇÀ» »ç¿ëÇϽðԽÀ´Ï±î?
                        g_InterfaceManager.GetInterfaceStringFormat(message,
                            INTERFACE_STRING_LENGTH,
                            158550,
                            g_pHero->GetName());

                        ui_system_manager->Sys_SystemMessage(message, 
                            NULL,
                            GlobalFunc::_fn_UseCharacterNameChangeItem, 
                            uiSystemMessage::kConfirm_Type);
                    }
                }
            }
            break;
            //_NA_006372_20130108_BADGE_ITEM
        case eITEMTYPE_RENDER_EFFECT_ITEM:
            {
                // ¹îÁö ¾ÆÀÌÅÛ
                if( ItemManager::Instance()->CanEquipClass( g_pHero, pItemInfo ) == TRUE &&
                    ItemManager::Instance()->CanEquipByGender( g_pHero, pItemInfo ) == TRUE )
                {
                    ItemManager::Instance()->SendItemUseMsg(SlotIdx, AtPos);
                }
                else
                {
                    // 70667 ¾ÆÀÌÅÛ »ç¿ë Á¶°ÇÀÌ ¸ÂÁö ¾Ê½À´Ï´Ù.
                    TCHAR szMessage[INTERFACE_STRING_LENGTH] = {0,};	
                    g_InterfaceManager.GetInterfaceString(70667, szMessage, INTERFACE_STRING_LENGTH);
                    GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
                }
            }
            break;
#ifdef _NA_008069_20150210_ADD_SPA_SYSTEM
        case eITEMTYPE_SPA_WARP_SCROLL:
            {
                if ((GameFramework::GetCurScene() == SCENE_TYPE_VILLAGE) ||
                    (GameFramework::GetCurScene() == SCENE_TYPE_FIELD))
                {
                    // ¿Âõ ÀÔÀå±Ç
                    keyMsg key_message;
                    ZeroMemory(&key_message, sizeof(key_message));
                    key_message.dwType		= eDoType_Delay_SpaWarp_Dialog;
                    key_message.DoSomething	= GlobalFunc::DoLeaveFieldCancel;
                    key_message.lParam		= InterfaceManager::DIALOG_DELAY_CASTING;
                    key_message.wParam		= eDoType_Delay_SpaWarp_Dialog;
                    g_KeyQueueManager.PushBack(key_message);


                    //¾ÆÀÌÅÛ ¶ôÀÌ ¼º°ø Çϸé ÄɽºÆà âÀ» ¶ç¿î´Ù
                    if( ItemManager::Instance()->SetItemLock(SlotIdx, AtPos, true) )
                    {
                        ItemManager::Instance()->SetPendingUseItemSlotIdx(SlotIdx);
                        ItemManager::Instance()->SetPendingUseItemPos(AtPos);

                        StartLeaveFieldCastTimer(eDoType_Delay_SpaWarp_Dialog, DELAY_LEAVE_FIELD_TICK);
                    }
                }
                else
                {
                    // 5360 Çʵ忡¼­¸¸ »ç¿ëÇÒ ¼ö ÀÖ½À´Ï´Ù.
                    GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5360));
                }

                
            }
            break;
        case eITEMTYPE_SPA_TICKET:
            {
                if (GlobalFunc::IsSpaScene())
                {
                    MSG_CG_ITEM_SPA_COSTUME_CHANGE_SYN packet;
                    packet.slotcontainer_type = SlotIdx;
                    packet.item_pos = AtPos;
                    GlobalFunc::SendPacket(CI_GAMESERVERIDX, &packet, sizeof(packet));
                }
            }
            break;
#endif //_NA_008069_20150210_ADD_SPA_SYSTEM
	default:
		{

#ifdef _NA_0_20111012_ITEM_DATE_EXTEND
            if( pItemInfo->m_byWasteType == eITEMWASTE_EXTEND_DATE_WEAPON ||        //< ±â°£ ¿¬Àå ¾ÆÀÌÅÛ(¹«±â).
                pItemInfo->m_byWasteType == eITEMWASTE_EXTEND_DATE_ARMOR ||         //< ±â°£ ¿¬Àå ¾ÆÀÌÅÛ(¹æ¾î±¸).
                pItemInfo->m_byWasteType == eITEMWASTE_EXTEND_DATE_RIDER ||         //< ±â°£ ¿¬Àå ¾ÆÀÌÅÛ(Å»°Í).
                pItemInfo->m_byWasteType == eITEMWASTE_EXTEND_DATE_RIDER_PARTS      //< ±â°£ ¿¬Àå ¾ÆÀÌÅÛ(Å»°ÍÀÇ ÆÄÃ÷).
                )
            {
                SetUseExtendItemDateMode( AtPos );
                return TRUE;
            }
#endif// _NA_0_20111012_ITEM_DATE_EXTEND

            


			if(pItemInfo->m_byWasteType == eITEMWASTE_RETURNSCROLL)
			{
				if (GameFramework::GetCurScene() == SCENE_TYPE_VILLAGE )
				{
					// ÇöÀç ¸¶À»¿¡ ÀÖ´Ù.
					return FALSE;
				}

				keyMsg sendMsg;
				ZeroMemory( &sendMsg, sizeof( sendMsg ) );
				sendMsg.dwType		= eDoType_Delay_Use_Return_Stone;
				sendMsg.DoSomething	= GlobalFunc::DoLeaveFieldCancel;
				sendMsg.lParam		= InterfaceManager::DIALOG_DELAY_CASTING;
				sendMsg.wParam			= eDoType_Delay_Use_Return_Stone;
				g_KeyQueueManager.PushBack( sendMsg );



				//¾ÆÀÌÅÛ ¶ôÀÌ ¼º°ø Çϸé ÄɽºÆà âÀ» ¶ç¿î´Ù
				if( ItemManager::Instance()->SetItemLock(SlotIdx, AtPos, true) )
				{
                    ItemManager::Instance()->SetPendingUseItemSlotIdx(SlotIdx);
                    ItemManager::Instance()->SetPendingUseItemPos(AtPos);

					StartLeaveFieldCastTimer( eDoType_Delay_Use_Return_Stone, DELAY_LEAVE_FIELD_TICK );
				}
			}
			else if ( pItemInfo->m_byWasteType == eITEMWASTE_QUESTACCEPT )
			{
				uiQuestMan* pQuestMan = GET_DIALOG_MANAGER(uiQuestMan, UIMAN_QUEST);
				if (pQuestMan)
				{
					pQuestMan->NET_SEND_CG_QUEST_ACCEPT_SYN(pItemInfo->m_wQuestCode, 1, AtPos);
				}				
			}
			else
			{
				if( pItemInfo->m_byPopup != 0 )
				{
					TCHAR szText[INTERFACE_STRING_LENGTH];
					TCHAR szBuf[INTERFACE_STRING_LENGTH];
					TCHAR szItemName[MAX_PATH + 1];

					g_InterfaceManager.GetInterfaceString( 5953, szBuf, INTERFACE_STRING_LENGTH - 1 );					
					g_InterfaceManager.GetItemName( pItemInfo->m_Code, szItemName, MAX_PATH );

					Snprintf( szText, INTERFACE_STRING_LENGTH - 1, szBuf, szItemName );

					m_SendSlotIdx = SlotIdx;
					m_SendAtPos	  = AtPos;	 	

					GlobalFunc::SysConfirmBox( szText, GlobalFunc::SendCheckUseItemByPopup );

				}
				else
				{
					ItemManager::Instance()->SendItemUseMsg( SlotIdx, AtPos );
				}
			}
		}
		break;
	}

	return TRUE;
}

BOOL MouseHandler::UseTransationItemSSQ(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer* pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot& rItemSlot = (SCItemSlot&)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO* pItemInfo = rItemSlot.GetItemInfo();
	if (!pItemInfo )
    {
		return FALSE;
    }


	if (GameFramework::GetCurrentScene() && 
		(SCENE_TYPE_VILLAGE != GameFramework::GetCurrentScene()->GetType() &&
		SCENE_TYPE_FIELD != GameFramework::GetCurrentScene()->GetType()))
	{					
		//5745	¹èƲÁ¸¿¡¼­´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5745));
		return TRUE;
	}

	if (FALSE == GetTryUseChageItem())
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);
		TCHAR szText[INTERFACE_STRING_LENGTH];
		TCHAR szItemName[INTERFACE_STRING_LENGTH];
		TCHAR szBuf[INTERFACE_STRING_LENGTH];

		// 5953	[%s]¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
		g_InterfaceManager.GetInterfaceString(5953, szBuf, INTERFACE_STRING_LENGTH);					
		g_InterfaceManager.GetItemName(rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH);
		Snprintf(
			szText, 
			INTERFACE_STRING_LENGTH-1, 
			szBuf, 
			szItemName);

		GlobalFunc::SysConfirmBox(szText, GlobalFunc::_fn_UseSSQItem);

	}

	return TRUE;
}



BOOL MouseHandler::_useTransactionItemTopOfTrial(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if ( !pItemInfo )
		return FALSE;


	if (GameFramework::GetCurrentScene() && 
		(SCENE_TYPE_VILLAGE != GameFramework::GetCurrentScene()->GetType() &&
		SCENE_TYPE_FIELD != GameFramework::GetCurrentScene()->GetType() ) )
	{					
		//5745	¹èƲÁ¸¿¡¼­´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5745));
		return TRUE;
	}

	if ( FALSE == GetTryUseChageItem() )
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);
		TCHAR szText[INTERFACE_STRING_LENGTH];
		TCHAR szItemName[INTERFACE_STRING_LENGTH];
		TCHAR szBuf[INTERFACE_STRING_LENGTH];

		// 5953	[%s]¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
		g_InterfaceManager.GetInterfaceString(5953, szBuf, INTERFACE_STRING_LENGTH);					
		g_InterfaceManager.GetItemName( rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH );
		Snprintf(
			szText, 
			INTERFACE_STRING_LENGTH-1, 
			szBuf, 
			szItemName);

		uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
		pSystemMan->Sys_Confirm(szText, GlobalFunc::_fn_UseTopOfTrialItem);
	}

	return TRUE;
}	



BOOL MouseHandler::_useTransactionItemDuraRepair(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if ( !pItemInfo )
		return FALSE;

	if ( FALSE == GetTryUseChageItem() )
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);
		TCHAR szText[INTERFACE_STRING_LENGTH];
		TCHAR szItemName[INTERFACE_STRING_LENGTH];
		TCHAR szBuf[INTERFACE_STRING_LENGTH];

		// 5953	[%s]¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
		g_InterfaceManager.GetInterfaceString(5953, szBuf, INTERFACE_STRING_LENGTH);					
		g_InterfaceManager.GetItemName( rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH );
		Snprintf(
			szText, 
			INTERFACE_STRING_LENGTH-1, 
			szBuf, 
			szItemName);

		if(ItemManager::Instance()->IsExistLimitedItem( SI_EQUIPMENT ))
		{
			ZeroMemory(szBuf, INTERFACE_STRING_LENGTH);
			//	6056	# ¸®¹ÌƼµå¾ÆÀÌÅÛÀº Àüü ¼ö¸® ½Ã ÀÏ°ýÀûÀ¸·Î ÃÖ´ë³»±¸µµ°¡ °¨¼ÒÇÏ°Ô µË´Ï´Ù.
			g_InterfaceManager.GetInterfaceString(6056, szBuf, INTERFACE_STRING_LENGTH);
			strcat(szText, szBuf);
		}

		uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
		pSystemMan->Sys_Confirm(szText, GlobalFunc::UseChargeItem);
	}

	return TRUE;
}	

//----------------------------------------------------------------
BOOL MouseHandler::_useTransactionChargeItemPersonalWaypoint(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	// todo : ¿ìŬ¸¯ÇÑ ¾ÆÀÌÅÛÀ» È°¼ºÈ­ ÇÑ´Ù.
	// È°¼ºÈ­µÈ ¾ÆÀÌÅÛÀÏ °æ¿ì ¸®ÅÏ
	// È°¼ºÈ­µÇÁö ¾Ê¾ÒÁö¸¸ ÀÌ¹Ì È°¼ºÈ­µÈ ¾ÆÀÌÅÛÀÌ ÀÖÀ» °æ¿ì ¸®ÅÏ
	if (GlobalFunc::IsWayPointItemPending())
    {
		return TRUE;
    }

	SCSlotContainer* pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
    if (!pAtContainer)
    {
        return FALSE;
    }

	SCItemSlot& rItemSlot = (SCItemSlot&)pAtContainer->GetSlot(AtPos);
	
	if (rItemSlot.IsProgressTime())
    {
		return TRUE;
    }

	for (int i = 0; i < pAtContainer->GetMaxSlotNum(); ++i)
	{
		if (pAtContainer->IsEmpty(i))
        {
			continue;
        }

		SCSlot& rSlot = pAtContainer->GetSlot(i);
		if (rSlot.GetSlotType() == ST_ITEM)
		{
			SCItemSlot& ItemSlot = (SCItemSlot&)rSlot;
			if (ItemSlot.GetItemInfo()->m_wType == eITEMTYPE_WAYPOINT)
			{
				if (ItemSlot.IsProgressTime())
				{
					return TRUE;
				}
			}
		}			
	}

	ItemManager::Instance()->SendItemUseMsg(SlotIdx, AtPos);
	GlobalFunc::SetWayPointItemPending(true);

	return TRUE;
}


//----------------------------------------------------------------
/** RETURN : ó¸®ÇßÀ¸¸é TRUE, ó¸® ÇÏÁö ¾Ê¾ÒÀ¸¸é FALSE
*/
BOOL MouseHandler::_useTransactionChargeItemPortalScroll(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();	
	if ( !pItemInfo )
		return FALSE;

	if ( pItemInfo->m_wType != eITEMTYPE_SAVE_COORD)
	{
		return TRUE;	// ÀÌ°Ç µû·Î ó¸®ÇÒ°ÍÀÌ ¾ø°í »ç¿ë½Ã¿¡µµ ¾Æ¹«·± Áþµµ ÇÏÁö¸»ÀÚ. 
	}

	if (GameFramework::GetCurrentScene() && 
		(SCENE_TYPE_VILLAGE != GameFramework::GetCurrentScene()->GetType() &&
		 SCENE_TYPE_FIELD != GameFramework::GetCurrentScene()->GetType() ) )
	{					
		//5745	¹èƲÁ¸¿¡¼­´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5745));
		return TRUE;
	}

	if (rItemSlot.GetMapCode())
	{ // ÀúÀåµÈ »óÅ ( Æ÷Å» ½Ãµµ¸¦ ÇÑ´Ù ).
		// ¾ÆÀÌÅÛÀÌ ÀÖ³Ä?
		POSTYPE OutPos = INVALID_SLOT_POS;
		BOOL bRet = ItemManager::Instance()->FindFirstItem( eITEMTYPE_PORTAL, OutPos );
		if ( !bRet )
		{
			// Æ÷Å»¾ÆÀÌÅÛÀÌ ¾ø½À´Ï´Ù.( 5931 )
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5931));
			return TRUE;
		}

		if ( FALSE == GetTryPortal() )
		{
			SetTryPortal(TRUE);
			SetPendingUseCoordPortalPos(AtPos);

			TCHAR szText[INTERFACE_STRING_LENGTH];
			TCHAR szMapName[INTERFACE_STRING_LENGTH];
			TCHAR szTitle[INTERFACE_STRING_LENGTH];

			const sMAPINFO * pMapInfo = MapInfoParser::Instance()->FindMapInfo( rItemSlot.GetMapCode() );
			if ( pMapInfo )
			{
				g_InterfaceManager.GetInterfaceString( pMapInfo->dwNCode, szMapName, INTERFACE_STRING_LENGTH );				
				//5946	%s (%d, %d)ÁöÁ¡À¸·Î À̵¿ÇϽðڽÀ´Ï±î?
				TCHAR szBuf[INTERFACE_STRING_LENGTH];
				g_InterfaceManager.GetInterfaceString(5946, szBuf, INTERFACE_STRING_LENGTH);					
				Snprintf( szText, INTERFACE_STRING_LENGTH, 
					szBuf, szMapName, rItemSlot.GetX(), rItemSlot.GetY()) ;

				// ÀúÀåµÈ À§Ä¡·Î À̵¿ 5932
				g_InterfaceManager.GetInterfaceString(5932, szTitle, INTERFACE_STRING_LENGTH);

				uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
				if(pSystemMan)
					pSystemMan->Sys_Confirm(NULL, GlobalFunc::UsePoralCoordItem, szTitle, szText);
			}
		}
	}
	else
	{
		// ÀúÀåµÇÁö ¾ÊÀº »óÅ ( Æ÷Å»¾ÆÀÌÅÛ¿¡ À§Ä¡ ÀúÀå )
		if ( FALSE == GetSavingPosition() )
		{	
			SetPendingSavePositionPos( AtPos );	
			SetSavingPosition(TRUE);

			TCHAR szText[INTERFACE_STRING_LENGTH];
			TCHAR szBuf[INTERFACE_STRING_LENGTH];
			TCHAR szMapName[INTERFACE_STRING_LENGTH];

			const sMAPINFO * pMapInfo = MapInfoParser::Instance()->FindMapInfo( g_pMap->GetMapID() );
			if ( pMapInfo )
			{
				WzVector wzPos = g_pHero->GetPosition();
				g_InterfaceManager.GetInterfaceString( pMapInfo->dwNCode, szMapName, INTERFACE_STRING_LENGTH );				

				// %s (%d, %d) ÁÂÇ¥·Î ÀúÀå ÇϽðڽÀ´Ï±î? - 5934
				g_InterfaceManager.GetInterfaceString( 5934, szBuf, INTERFACE_STRING_LENGTH );				
				Snprintf( szText, INTERFACE_STRING_LENGTH, szBuf, szMapName, (SHORT)wzPos.x, (SHORT)wzPos.y) ;

				// ÇöÀçÀ§Ä¡ ÀúÀå ( 5933 )
				g_InterfaceManager.GetInterfaceString( 5933, szBuf, INTERFACE_STRING_LENGTH );				

				uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
				if(pSystemMan)
                    pSystemMan->Sys_Confirm(NULL, GlobalFunc::SaveCurrentPosAtItem, szBuf, szText);

			}
		}
	}

	return TRUE;
}





BOOL MouseHandler::_useTransactionChargeItemStatInit(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if ( !pItemInfo )
    {
		return FALSE;
    }

	if ( pItemInfo->m_wType != eITEMTYPE_STAT_RESET)
	{
		return FALSE;	// ÀÌ°Ç µû·Î ó¸®ÇÒ°ÍÀÌ ¾ø°í »ç¿ë½Ã¿¡µµ ¾Æ¹«·± Áþµµ ÇÏÁö¸»ÀÚ. 
	}

    if ((g_pHero != NULL) && (g_pHero->IsTransForm() == TRUE))
    {
        uiSystemMan* system_main = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
        if (system_main != NULL)
        {
            TCHAR message[INTERFACE_STRING_LENGTH] = {NULL, };						
            // 5139	º¯½Å »óÅ¿¡¼­´Â ÀÌ¿ëÀÌ °¡´ÉÇÏÁö ¾Ê½À´Ï´Ù.
            g_InterfaceManager.GetInterfaceString(5139, message ,INTERFACE_STRING_LENGTH);
            system_main->Sys_VerifyLock(message);
        }
        return FALSE;
    }

	if ( FALSE == GetTryUseChageItem() )
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);

		TCHAR szText[INTERFACE_STRING_LENGTH];
		TCHAR szItemName[INTERFACE_STRING_LENGTH];
		TCHAR szBuf[INTERFACE_STRING_LENGTH];	

		// ¾ÆÀÌÅÛ WASTE TYPE ¿¡ µû¶ó¼­ ¸ðµç ½ºÅÝ ÃʱâÈ­´Â °³¼ö ÀÔ·ÂÇÏÁö¾Ê°í ƯÁ¤ ÆÐŶÀ» ¹Ù·Î º¸³½´Ù.
		eWASTETYPE_FOR_STAT_INIT eStatInitType = (eWASTETYPE_FOR_STAT_INIT)pItemInfo->m_byWasteType;

		switch (eStatInitType)
		{
		case eItemWASTE_INIT_ALL:
		case eItemWASTE_INIT_BASIC_STAT_ALL:
		case eItemWASTE_INIT_EXPERTY_ALL:
		
			{
				// 5953	[%s]¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
				g_InterfaceManager.GetInterfaceString(5953, szBuf, INTERFACE_STRING_LENGTH);					
				g_InterfaceManager.GetItemName( rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH );
				Snprintf(
						szText, 
						INTERFACE_STRING_LENGTH-1, 
						szBuf, 
						szItemName);
				

						uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
						if(pSystemMan)
							pSystemMan->Sys_Confirm(szText, GlobalFunc::UseChargeItemStatInitAll);

			}
			break;

		default:
			{
				//5725	[%s] ¾ÆÀÌÅÛÀ» ¸î °³ »ç¿ëÇϽðڽÀ´Ï±î?				
				g_InterfaceManager.GetInterfaceString(5725, szBuf, INTERFACE_STRING_LENGTH);					
				g_InterfaceManager.GetItemName( rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH );
				Snprintf(
					szText, 
					INTERFACE_STRING_LENGTH-1, 
					szBuf, 
					szItemName );

				TCHAR szNum[INTERFACE_STRING_LENGTH];
				_itot( rItemSlot.GetNum(), szNum, 10);

				uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
				if(pSystemMan)
					pSystemMan->Sys_ConfirmMessage(szText, GlobalFunc::GetStateInitItemNumConfirm, szNum, true);

			}
			break;
		}			
		
	}

	return TRUE;
}	



BOOL MouseHandler::_useTransactionChargeItemTransact(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if ( !pItemInfo )
		return FALSE;

	if ( FALSE == GetTryUseChageItem() )
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);

		TCHAR szText[INTERFACE_STRING_LENGTH];
		TCHAR szItemName[INTERFACE_STRING_LENGTH];
		TCHAR szBuf[INTERFACE_STRING_LENGTH];

		// 5953	[%s]¾ÆÀÌÅÛÀ» »ç¿ëÇϽðڽÀ´Ï±î?
		g_InterfaceManager.GetInterfaceString(5953, szBuf, INTERFACE_STRING_LENGTH);					
		g_InterfaceManager.GetItemName( rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH );
		Snprintf(
			szText, 
			INTERFACE_STRING_LENGTH-1, 
			szBuf, 
			szItemName);

		uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
		if(pSystemMan)
			pSystemMan->Sys_Confirm(szText, GlobalFunc::UseChargeItem);
	}

	return TRUE;
}

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::ItemUseTransactionFromQuick( SLOTIDX SlotIdx, POSTYPE AtPos )
{
	// ÄüÄÁÅ×À̳ʿ¡¼­ ¾ÆÀÌÅÛ »ç¿ëÀ» ÇÒ·Á°í ÇÑ´Ù.
	QuickContainer * pAtContainer = 
		(QuickContainer * )ItemManager::Instance()->GetItemContainerDialog( SI_QUICK);
	if (!pAtContainer)
	{
		return FALSE;
	}	

	POSTYPE RealQuickPos = pAtContainer->GetCurTabNum();	// ÇöÀç ÅÜÀ§Ä¡.
    RealQuickPos = 0;// µÎÁÙÀ϶§´Â ÅÇÀ§Ä¡¸¦ ¾È´õÇÑ´Ù.
    AtPos = pAtContainer->GetRealSlotPos(AtPos);
    RealQuickPos += AtPos;

	// °øÅë ¼±Çà Á¶°Ç

	if (RealQuickPos > pAtContainer->GetMaxSlotNum() )
	{
		return FALSE;
	}

	if( pAtContainer->IsEmpty( RealQuickPos ) ) 
	{
		return FALSE;
	}

	QuickSlot & rFromSlot = (QuickSlot &)pAtContainer->GetSlot( RealQuickPos );
	POSTYPE OrgPos		= 0;        

	if (SLOT_RENDER_STATE_ACTIVATED !=  rFromSlot.GetStatus())
	{
		return FALSE;
	}

	///////////////////////////////////////////////

	switch (rFromSlot.GetOrgSlotType())
	{
	case ST_ITEM:
		{
			if (SI_INVENTORY != rFromSlot.GetOrgSlotIndex())
			{
				// ÀÌ¹Ì ´Ù¸¥ (ÀåÂø)â¿¡ µî·ÏµÇ¾îÀÖ´Â »óÅÂÀÌ´Ù.
				return FALSE;
			}

			if (!rFromSlot.GetOrgSlot())
			{
				return FALSE;
			}
			
			const BASE_ITEMINFO* pOrgItemInfo = 
				((SCItemSlot*)rFromSlot.GetOrgSlot())->GetItemInfo();

			if (!pOrgItemInfo)
			{
				return FALSE;
			}

			POSTYPE OrgPos = rFromSlot.GetOrgPos();
			BOOL bRet = TRUE;

			if (pOrgItemInfo->IsCanUseWaste())
			{
				bRet = ItemManager::Instance()->FindFirstItem(rFromSlot.GetOrgCode(), OrgPos);				
			}

			if (bRet)
			{
				//GS_BUG_FIX:¿¡Å׸£ źȯÀº¿¹¿Üó¸®,IsCanUseWaste ¾ÆÀÌÅÛƯ¼º»ó ºÒ°¡´É
				if (pOrgItemInfo->m_wType == eITEMTYPE_ETHER_BULLET) 
				{
					ItemUseTransactionFromInventory(SI_INVENTORY, rFromSlot.GetOrgPos());
				}
				else
				{
					ItemUseTransactionFromInventory(SI_INVENTORY, OrgPos);	
				}
				
			}							

		}
		break;

	case ST_SKILL:
		{
            // ½ºÅ³ »ç¿ëÀº ½ÇÁ¦ ½ºÅ³À» ÀÌ¿ë
            int skill_code = xGetSkillData()->GetRealSkillCode(rFromSlot.GetOrgCode() );
            if( skill_code != INVALID_SKILL_CODE )
            {
                // ¾×¼ÇÀº ±×´ë·Î »ç¿ë
                ItemUseTransactionFromSkill( skill_code );
            }
            else
            {
                ItemUseTransactionFromSkill( rFromSlot.GetOrgCode() );   // Action
            }
		}
		break;
	}

	return TRUE;
}

BOOL MouseHandler::ItemUseTransactionFromSkill( SLOTCODE SlotCode )
{
	return g_HeroInput.OnSkill( SlotCode );
}

BOOL MouseHandler::ItemUseTransactionFromStyle( SLOTIDX SlotIdx, POSTYPE AtPos )
{
	StyleContainer *pAtContainer = (StyleContainer * )ItemManager::Instance()->GetItemContainerDialog( SI_STYLE);
    if (!pAtContainer)
    {
        return FALSE;
    }

	POSTYPE RealStylePos = pAtContainer->GetCurTabNum();	// ÇöÀç ÅÜÀ§Ä¡.
	RealStylePos += AtPos;

	if (RealStylePos > pAtContainer->GetMaxSlotNum() )
	{
		return FALSE;
	}

	if( pAtContainer->IsEmpty( RealStylePos ) ) 
	{
		return FALSE;
	}

	StyleSlot & rFromSlot = (StyleSlot &) pAtContainer->GetSlot( RealStylePos );
	POSTYPE OrgPos		= 0;        

	assert(rFromSlot.GetOrgSlotType() == ST_SKILL);
	// ½ºÅ¸ÀÏ ¼±ÅÃ. 

	SCSkillSlot * pSkillSlot = (SCSkillSlot *)ItemManager::Instance()->GetSkillSlotByCode( rFromSlot.GetOrgCode() );
	if (!pSkillSlot)
	{
		assert(!"À̺κÐÀÌ ¿À´Ù´Ï È®ÀÎÇغ¸ÀÚ.!!");
		return FALSE;
	}

	BASE_STYLEINFO * pStyleInfo = SkillInfoParser::Instance()->GetStyleInfo(pSkillSlot->GetCode());

	if(pStyleInfo)
	{
		//½ºÅ¸ÀÏÁöÁ¤ 
		if(	g_pHero->GetCurrentAttackStyle() != pSkillSlot->GetCode() )
        {
            if( g_pHero->CheckChangeAttackStyle( pSkillSlot->GetCode() ) == TRUE )
	        {
                g_pHero->SetCurrentAttackStyle(pSkillSlot->GetCode());

		        MSG_CG_STYLE_SELECT_STYLE_SYN packet;
		        packet.m_byCategory		= CG_STYLE;
		        packet.m_byProtocol		= CG_STYLE_SELECT_STYLE_SYN;
		        packet.m_NewStyleCode = pSkillSlot->GetCode();

		        if(GlobalFunc::SendPacket(CI_GAMESERVERIDX, &packet, sizeof(packet) )==FALSE)
		        {
			        assert(!"½ºÅ¸ÀÏ º¯°æ ÆÐŶ Àü¼Û ½ÇÆÐ");
		        }
		        else 
		        {
#ifdef _DEBUG
			        g_InterfaceManager.ShowMessageBox(_T("½ºÅ¸ÀÏÆÐŶÀü¼Û"),1000,NULL,0);
#endif			
		        }
	        }
        }
	}
	else
	{
		assert(0);
	}

	return TRUE;
}

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::ItemCompositeNormalEnchant(SLOTIDX SlotIdx, POSTYPE TargetPos)
{
	SCSlotContainer *pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	assert(pAtContainer);
    if (!pAtContainer)
    {
        return FALSE;
    }

	TCHAR	szMessage[INTERFACE_STRING_LENGTH];

	// ºñ¿öÀÖ´À³Ä?
	if (pAtContainer->IsEmpty(TargetPos))
	{
		//	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage, CHAT_TYPE_SYSTEM );
		return FALSE;
	}

	// Á¶ÇÕ¾ÆÀÌÅÛÀÌ Àû¹ýÇÑÁö °Ë»ç
	SCItemSlot & rItemSlot = (SCItemSlot & )pAtContainer->GetSlot(TargetPos);
	SCItemSlot & rCrystalItemSlot = (SCItemSlot & )pAtContainer->GetSlot(m_CrystalPos);

	if (!rItemSlot.GetItemInfo()->IsArmor() &&
		!rItemSlot.GetItemInfo()->IsWeapon() 
#ifdef _NA002823_WINGS_EQUIPMENTS_EXTENTION
        && !rItemSlot.IsWingItem()
#endif //_NA002823_WINGS_EQUIPMENTS_EXTENTION
        )
	{
		//	ÀÎþƮ°¡ °¡´ÉÇÏÁö ¾ÊÀº ¾ÆÀÌÅÛ ÀÔ´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_NOT_ENCHANT_ITEM, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage, CHAT_TYPE_SYSTEM );
		return FALSE;
	}

	BYTE byEnchant = rItemSlot.GetEnchant();  
	if ( byEnchant > 8)
	{
		//	»ó±Þ ÀÎþƮ´Â Á¦Á¶ NPC¿¡°Ô ¹®ÀÇ ÇϽñ⠹ٶø´Ï´Ù.
		g_InterfaceManager.GetInterfaceString( eST_NOT_HERE_HIGH_ENCHANT, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage, CHAT_TYPE_SYSTEM );
		return FALSE;
	}

	eNormalEnchantType EnchantType;
	
	// ÇÏ / Áß ÀÎþƮ ºÐ±â
	if ( byEnchant <= 5)					// 0~5´Â ÇÏ±Þ ÀÎþƮ ÀÌ´Ù.
	{
		// ÇÏ±Þ ÀÎþƮ ¾ÆÀÌÅÛÀÌ À̳Ä?
		sITEMCOMPOSITE * pInfo = ItemCompositeParser::Instance()->GetCompositeInfo(eITEMCOMPOSITE_LOW_ENCHANT);

		if(!pInfo)
			return FALSE;

		if (rCrystalItemSlot.GetCode() != pInfo->m_sCompositeMaterials[0].m_dwCompositeMaterialCode )
		{
			//	ÇÏ±Þ ÀÎþƮ¿¡ ÇÊ¿äÇÑ Àç·á°¡ ¾Æ´Õ´Ï´Ù.
			g_InterfaceManager.GetInterfaceString( eST_NOT_LOW_ENCHANT, szMessage, INTERFACE_STRING_LENGTH );
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
			return FALSE;
		}			

		// ÇÊ¿ä¹°Ç°ÀÌ ÀÖ´À³Ä?
		if (!ItemManager::Instance()->IsExistCompositeMaterials(eITEMCOMPOSITE_LOW_ENCHANT, SI_INVENTORY) )
		{
			g_InterfaceManager.GetInterfaceString( eST_ITEM_NOT_EXIST_COMPOSITE_MATERIALS, szMessage, INTERFACE_STRING_LENGTH );
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
			return FALSE;
		}

        
		// ÀÎþƮ Á¶°Ç¿¡ µû¶ó ó¸®
		EnchantType = LOW_ENCHANT;
	}
	else if (byEnchant <= 8)		// 6~8 Àº Áß±Þ ÀÎþƮÀÌ´Ù.
	{
		// Áß±Þ ÀÎþƮ
		sITEMCOMPOSITE * pInfo = ItemCompositeParser::Instance()->GetCompositeInfo(eITEMCOMPOSITE_MEDIUM_ENCHANT);

		if(!pInfo)
			return FALSE;


		if (rCrystalItemSlot.GetCode() != pInfo->m_sCompositeMaterials[0].m_dwCompositeMaterialCode )
		{
			//	Áß±Þ ÀÎþƮ¿¡ ÇÊ¿äÇÑ Àç·á°¡ ¾Æ´Õ´Ï´Ù.
			g_InterfaceManager.GetInterfaceString( eST_NOT_MID_ENCHANT, szMessage, INTERFACE_STRING_LENGTH );
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
			return FALSE;
		}			

		// ÇÊ¿ä¹°Ç°ÀÌ ÀÖ´À³Ä?
		if (!ItemManager::Instance()->IsExistCompositeMaterials(eITEMCOMPOSITE_MEDIUM_ENCHANT, SI_INVENTORY) )
		{
			g_InterfaceManager.GetInterfaceString( eST_ITEM_NOT_EXIST_COMPOSITE_MATERIALS, szMessage, INTERFACE_STRING_LENGTH );
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
			return FALSE;
		}

		// ÀÎþƮ Á¶°Ç¿¡ µû¶ó ó¸®
		
		EnchantType = MIDDLE_ENCHANT;
	}

	uiAssistMan* pMan = (uiAssistMan*)g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST);
	if(pMan)
	{
		pMan->ShowAskNormalEnchantDialog(
			EnchantType,
			rItemSlot.GetCode(), 
			MouseHandler::Instance()->GetCrystalPos(),	// À¯Àú¿¡°Ô¼­ ¹Þ¾Æ³õÀº º¸¼®À§Ä¡
			TargetPos
		);
	}

	MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);

    return TRUE;

}

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::ItemExtension(SLOTIDX SlotIdx, POSTYPE AtPos, RECT * pRect)
{


#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
    //! ¿¬ÀåÀº ¾ÆÀÌÅÛÀ¸·Î º°µµ ÆǸÅ
#else

	SCSlotContainer *	pToContainer = ItemManager::Instance()->GetContainer(SlotIdx); 
	uiCashItemShopExtensionBuy * pUICashITemShopExtensionBuy 
		= (uiCashItemShopExtensionBuy *)ItemManager::Instance()->GetItemContainerDialog(SlotIdx);

	TCHAR	szMessage[INTERFACE_STRING_LENGTH] = {0,};

	if( IsExistItemAtHand() )
	{ 
        SCItemSlot* from_item_slot = static_cast<SCItemSlot*>(m_MouseItem.m_pFromSlot);

		if (from_item_slot == NULL)
		{
			return FALSE;
		}

		if (from_item_slot->GetItemInfo() == NULL)
		{
			return FALSE;
		}

		if (ST_ITEM != from_item_slot->GetSlotType())
		{
			return FALSE;
		}

        if (ItemManager::CanPeriodExtend(from_item_slot) == false)
		{
			// 5899	±â°£ ¿¬ÀåÀÌ °¡´ÉÇÑ ¾ÆÀÌÅÛÀÌ ¾Æ´Õ´Ï´Ù.
			const int c_iCannotInchantLevel = 5899;
			g_InterfaceManager.GetInterfaceString(c_iCannotInchantLevel, szMessage, INTERFACE_STRING_LENGTH);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szMessage, INTERFACE_STRING_LENGTH);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_TOP_SHOW, szMessage, INTERFACE_STRING_LENGTH);
			return FALSE;
		}

		if(!from_item_slot->IsExpiredWaitTime())
		{
			// 5898	»ç¿ë±â°£ÀÌ ¸¸·áµÇÁö ¾ÊÀº ¾ÆÀÌÅÛÀÔ´Ï´Ù.
			const int c_iCannotInchantLevel = 5898;
			g_InterfaceManager.GetInterfaceString(c_iCannotInchantLevel, szMessage, INTERFACE_STRING_LENGTH);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szMessage, INTERFACE_STRING_LENGTH);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_TOP_SHOW, szMessage, INTERFACE_STRING_LENGTH);
			return FALSE;
		}

        if (from_item_slot->CanUseMixture(MIXTURE_PERIOD_EXTEND) == false)
		{
			g_InterfaceManager.GetInterfaceString(5937, szMessage, INTERFACE_STRING_LENGTH);	//5937	ÇØ´ç ±â´ÉÀ» ÀÌ¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛ Á¾·ù°¡ ¾Æ´Õ´Ï´Ù.
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_CHAT, szMessage, INTERFACE_STRING_LENGTH);
			GlobalFunc::OutputMsg_Notice( eOUTPUT_MSG_TOP_SHOW, szMessage, INTERFACE_STRING_LENGTH);

			return FALSE;
		}

		if ( SI_INVENTORY != m_MouseItem.m_fromSlotIdx && SI_EQUIPMENT != m_MouseItem.m_fromSlotIdx )
		{
			return FALSE;
		}

		for (int i = 0; i < pUICashITemShopExtensionBuy->GetMaxSlotNum(); ++i)
		{
			if (pUICashITemShopExtensionBuy->IsEmpty(i))
			{
				continue;
			}
			pUICashITemShopExtensionBuy->DeleteSlot(i, NULL);
		}

		ItemManager::Instance()->CopyItem(
			m_MouseItem.m_fromSlotIdx, 
			SI_EXTENSION,
			m_MouseItem.m_fromPos,
			AtPos );

		pUICashITemShopExtensionBuy->SetTargetInfo( m_MouseItem.m_fromSlotIdx, this->m_MouseItem.m_fromPos );
	}
	else
	{
		// ´Ù½Ã µé¾î¿ÃÇÊ¿ä°¡ ¾ø´Ù.
		return FALSE;
	}


#endif //#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL


	return TRUE;
}

//----------------------------------------------------------------
/** 
*/
#ifdef __NA_001358_ENCHANT_UNIFICATION
#else //__NA_001358_ENCHANT_UNIFICATION
BOOL				
MouseHandler::ItemCompositeNewEnchant(SLOTIDX SlotIdx, POSTYPE AtPos)
{
    if( IsExistItemAtHand() == FALSE )
    { 
        return FALSE;
    }

    if ( !m_MouseItem.m_pFromSlot )
    {
        return FALSE;
    }

    return ItemCompositeNewEnchant_InventoryRightClick( this->m_MouseItem.m_toSlotIdx, SlotIdx, this->m_MouseItem.m_fromSlotIdx, AtPos );
}
#endif //__NA_001358_ENCHANT_UNIFICATION

//------------------------------------------------------------------------------
bool MouseHandler::ItemCompositeNewEnchant_InventoryRightClick(const SLOTIDX from_container_index, 
                                                               const SLOTIDX to_container_index, 
                                                               const POSTYPE from_position_in_container, 
                                                               const POSTYPE to_position_in_container)
{
    if (from_container_index != SI_INVENTORY)
    {
        //! ÀÎþƮ´Â Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÏ´Ù. : 5307
        GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(5307));
        return false;
    }


    if (to_container_index != SI_ENCHANT && to_container_index != SI_ENCHANT_OPTION )
    {
        return false;
    }

    EnchantDialog* enchant_dialog = (EnchantDialog *)ItemManager::Instance()->GetItemContainerDialog(to_container_index);
    if( enchant_dialog == NULL )
    {
        return false;
    }


    // ÀÎæƮ ´ë»ó ½½·Ô
    if (to_container_index == SI_ENCHANT )
    {
        SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index);
        SCSlotContainer* enchant_container_ptr = ItemManager::Instance()->GetContainer(to_container_index); 
        if ((inventory_container_ptr == NULL) || 
            (inventory_container_ptr->IsEmpty(from_position_in_container) == TRUE) || 
            (enchant_container_ptr == NULL))
        {
            return false;
        }

        SCItemSlot* item = static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_position_in_container)));

        if ((item == NULL) || 
            (item->GetItemInfo() == NULL) || 
            (item->GetSlotType() != ST_ITEM))
        {
            return false;
        }

        if (item->IsLocked())
        {
            return false;
        }

        if ((item->GetItemInfo()->IsWeapon() == FALSE) &&
            (item->GetItemInfo()->IsArmor() == FALSE)
#ifdef _NA002823_WINGS_EQUIPMENTS_EXTENTION
            && (item->IsWingItem() == FALSE)
#endif //_NA002823_WINGS_EQUIPMENTS_EXTENTION
            )
        {
            return false;
        }

        if (enchant_container_ptr->IsEmpty(to_position_in_container) == FALSE)
        {
            enchant_dialog->ReTry();
        }

        TCHAR error_message[INTERFACE_STRING_LENGTH] = {NULL,};

        if ((item->IsFateItem() == TRUE) && 
            (item->GetFateIdentify() == FALSE))
        {
            //6329	ÀÎÁõ ÀǽÄÀÌ ¿Ï·áµÈ ¾ÆÀÌÅÛ¸¸ ÀÎþƮ°¡ °¡´ÉÇÕ´Ï´Ù.
            GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(6329));
            return false;
        }

        if (item->GetItemInfo()->m_LV == 0)
        {
            // ¾ÆÀÌÅÛ ·¹º§ÀÌ 0À̸é ÀÎþƮ ÇÏÁö ¸øÇÑ´Ù. : 5306
            g_InterfaceManager.GetInterfaceString(5306, error_message, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, error_message);
            return false;
        }

        if (item->GetEnchant() >= MAX_ENCHANT_GRADE )
        {
            // ÃÖ°í ÀÎþƮÀÔ´Ï´Ù!
            g_InterfaceManager.GetInterfaceString(eST_MAX_ENCHANT_LEVEL, 
                                                error_message, 
                                                INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, error_message);
            return false;
        }

        return true;
    }
#ifdef _NA_003966_20111227_ADD_ENCHANT
    else if( to_container_index == SI_ENCHANT_OPTION )
    {
        if( const MATERIALS_FOR_LEVEL* const enchant_material_info = enchant_dialog->GetCurrentEnchantInfo() )
        {
            if (enchant_material_info->IsDownGrade() == false)
            {
                return false;
            }

            if( SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index) )
            {
                SCItemSlot* from_itemslot_ptr = static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_position_in_container)));

                if ((from_itemslot_ptr == NULL) || 
                    (from_itemslot_ptr->GetItemInfo() == NULL) || 
                    (from_itemslot_ptr->GetSlotType() != ST_ITEM))
                {
                    return false;
                }

                const BASE_ITEMINFO* const down_guard_item_info = from_itemslot_ptr->GetItemInfo();
                if (down_guard_item_info->m_wType != eITEMTYPE_ENCHANT)
                {
                    return false;
                }

                if( enchant_material_info->GetDownGradeType() == 0 )
                {
                    return false;
                }

                if (down_guard_item_info->m_wSubType != enchant_material_info->GetDownGradeType())
                {
                    return false;
                }

                return true;
            }
        }
    }
#endif //_NA_003966_20111227_ADD_ENCHANT

    return false;
}

//-------------------------------------------------------------------------------------------
/**
*/
#ifdef _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
bool MouseHandler::ItemEquipmentAwakening_InventoryRightClick( const SLOTIDX from_container_index, const SLOTIDX to_container_index, const POSTYPE from_position_in_container, const POSTYPE to_position_in_container )
{
	if (from_container_index != SI_INVENTORY)
	{
		// 3967 : °¢¼ºÀº Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(3967));
		return false;
	}

	if (to_container_index != SI_EQUIPMENT_AWAKENING)
	{
		return false;
	}

	uiEquipmentAwakeningDialog* equipment_wakeup_dialog = static_cast<uiEquipmentAwakeningDialog*>(ItemManager::Instance()->GetItemContainerDialog(to_container_index));
	if( equipment_wakeup_dialog == NULL )
	{
		return false;
	}

	// ÁøÈ­ ´ë»ó ½½·Ô
	if (to_container_index == SI_EQUIPMENT_AWAKENING )
	{
		SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index);
		SCSlotContainer* equipment_awakening_container = ItemManager::Instance()->GetContainer(to_container_index); 
		if ((inventory_container_ptr == NULL) || 
			(inventory_container_ptr->IsEmpty(from_position_in_container) == TRUE) || 
			(equipment_awakening_container == NULL))
		{
			return false;
		}

		SCItemSlot* item = static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_position_in_container)));

		if ((item == NULL) || 
			(item->GetItemInfo() == NULL) || 
			(item->GetSlotType() != ST_ITEM))
		{
			return false;
		}

		if (item->IsLocked())
		{
			return false;
		}
	}

	return true;
}
#endif // _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
//-------------------------------------------------------------------------------------------
/**
*/

#ifdef _NA_008121_20150318_EQUIPMENT_EVOLUTION_SYSTEM
bool MouseHandler::ItemEquipmentEvolution_InventoryRightClick( const SLOTIDX from_container_index, const SLOTIDX to_container_index, const POSTYPE from_position_in_container, const POSTYPE to_position_in_container )
{
	if (from_container_index != SI_INVENTORY)
	{
		// 3968 : ÁøÇÏ´Â Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, g_InterfaceManager.GetInterfaceString(3968));
		return false;
	}

	if (to_container_index != SI_EQUIPMENT_EVOLUTION)
	{
		return false;
	}

	uiEquipmentAwakeningDialog* equipment_wakeup_dialog = static_cast<uiEquipmentAwakeningDialog*>(ItemManager::Instance()->GetItemContainerDialog(to_container_index));
	if( equipment_wakeup_dialog == NULL )
	{
		return false;
	}

	// ÀÎæƮ ´ë»ó ½½·Ô
	if (to_container_index == SI_EQUIPMENT_EVOLUTION )
	{
		SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index);
		SCSlotContainer* equipment_evolution_container = ItemManager::Instance()->GetContainer(to_container_index); 
		if ((inventory_container_ptr == NULL) || 
			(inventory_container_ptr->IsEmpty(from_position_in_container) == TRUE) || 
			(equipment_evolution_container == NULL))
		{
			return false;
		}

		SCItemSlot* item = static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_position_in_container)));

		if ((item == NULL) || 
			(item->GetItemInfo() == NULL) || 
			(item->GetSlotType() != ST_ITEM))
		{
			return false;
		}

		if (item->IsLocked())
		{
			return false;
		}
	}

	return true;
}
#endif // _NA_008121_20150318_EQUIPMENT_EVOLUTION_SYSTEM

//----------------------------------------------------------------
/** 
*/
BOOL MouseHandler::ItemCompositeSocketFill(SLOTIDX SlotIdx, POSTYPE TargetPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);

	assert(pAtContainer);
    if (!pAtContainer)
    {
        return FALSE;
    }

	TCHAR	szMessage[INTERFACE_STRING_LENGTH];

	// ºñ¿öÀÖ´À³Ä?
	if (pAtContainer->IsEmpty(TargetPos))
	{
		//	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	// Á¶ÇÕ¾ÆÀÌÅÛÀÌ Àû¹ýÇÑÁö °Ë»ç
	SCItemSlot & rItemSlot = (SCItemSlot & )pAtContainer->GetSlot(TargetPos);

	/*if (!rItemSlot.GetItemInfo()->IsArmor() &&
		!rItemSlot.GetItemInfo()->IsWeapon() )
	{
		//	ÀÎþƮ°¡ °¡´ÉÇÏÁö ¾ÊÀº ¾ÆÀÌÅÛ ÀÔ´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_NOT_ENCHANT_ITEM, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}*/ //xiaomi cancel ItemCompositeSocketFill

	if (rItemSlot.GetSocketNum() <= 0)
	{
		//	ä¿ö ³ÖÀ» ¼ÒÄÏ ÀÚ¸®°¡ ¾ø½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_NOT_EXIST_SOCKET_FOR_INSERT, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	uiAssistMan* pMan = (uiAssistMan*)g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST);
	if(pMan)
	{
		pMan->ShowAskSocketFillDialog(			
			rItemSlot.GetCode(), 
			MouseHandler::Instance()->GetCrystalPos(),	// À¯Àú¿¡°Ô¼­ ¹Þ¾Æ³õÀº º¸¼®À§Ä¡
			TargetPos
		);
	}
	MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);

    return TRUE;	
}
//--------------------------------------------------------------------------------------------------
/** ¼ÒÄÏ È®ÀÎ À̺¥Æ®
*/
bool MouseHandler::ItemSocketIndentifyTransction(POSTYPE slot_pos)
{
    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    RollbackItemAtHand();

    POSTYPE use_pos = GetPendingUseChargeItemPos();

    if (ItemManager::Instance()->IsInvalidSocketIdentify(slot_pos, use_pos) == false)
    {
        return false;
    }

    SCSlotContainer* container = ItemManager::Instance()->GetContainer(SI_INVENTORY);
    if (container == NULL)
    {
        return false;

    }
    SCItemSlot& use_slot = static_cast<SCItemSlot&>(container->GetSlot(slot_pos));
    if (use_slot.IsContainValidItem() == FALSE)
    {
        return false;
    }

    if (use_slot.GetSocketIdentifyType() != eSOCKET_UNIDENTIFIED_ITEM)
    {
        return false;
    }

    if (use_slot.IsFateItem() && use_slot.GetFateIdentify() == false)
    {
        return false;
    }

    uiAssistMan* assist_man = static_cast<uiAssistMan*>(
        g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  
    if (assist_man == NULL)
    {
        return false;
    }

    assist_man->ShowAskSocketIdentifyDialog(use_slot.GetItemInfo()->m_Code, use_pos, slot_pos);
    return true;
}
//--------------------------------------------------------------------------------------------------
/** ¾ÆÀÌÅÛ °áÁ¤È­ À̺¥Æ®
*/
bool MouseHandler::ItemCrystalizationTransction( POSTYPE TargetPos )
{
    RollbackItemAtHand();

    SCSlotContainer* container = ItemManager::Instance()->GetContainer(SI_INVENTORY);
    if (container == NULL)
    {
        return false;
    }
    SCItemSlot& use_slot = static_cast<SCItemSlot&>(container->GetSlot(TargetPos));
    if (use_slot.IsContainValidItem() == FALSE)
    {
        return false;
    }

    const BASE_ITEMINFO* selected_item_info_ptr = use_slot.GetItemInfo();

    if (selected_item_info_ptr == NULL)
    {
        return false;
    }

    if (use_slot.CanUseMixture(MIXTURE_CRYSTALIZE) == false)
    {
        return false;
    }

    // ÀÌ¹Ì ÁøÇàÁßÀ̸é Ãë¼Ò
    float rate = 100.f;
    if (ItemCooltimeManager::Instance()->FindCooltime(use_slot.GetSerial(), &rate))
    {
        if (ItemCooltimeManager::Instance()->CancelCooltime(use_slot.GetSerial()))
        {
            // 5850 : ¼±ÅÃÇÑ ¾ÆÀÌÅÛÀÇ °áÁ¤È­°¡ Ãë¼ÒµÇ¾ú½À´Ï´Ù.
            TCHAR format_string[INTERFACE_STRING_LENGTH] = {0, };
            g_InterfaceManager.GetInterfaceString(5850, format_string);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, format_string);
            return true;
        }
    }

#ifdef _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
	SLOTCODE slot_code = ItemCrystalizeListParser::Instance()->GetCrystalizeCode(use_slot, use_slot.GetEnchant());
#else
    SLOTCODE slot_code = ItemCrystalizeListParser::Instance()->GetCrystalizeCode(use_slot);
#endif // _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
    if (slot_code == 0)
    {
        return false;
    }

    sITEM_CRYSTALIZE_LIST* item_crystalize_list = ItemCrystalizeListParser::Instance()->GetCrystalizeListInfo(slot_code);
    if (item_crystalize_list == NULL)
    {
        return false;
    }

    if ((use_slot.GetEnchant() >= 10) || 
        selected_item_info_ptr->m_wSubType == eITEMSUBTYPE_ELITE || 
        selected_item_info_ptr->m_wSubType == eITEMSUBTYPE_UNIQUE                    
        )
    {
        // Callback ¸Þ½ÃÁö·Î ¿¬°á
        uiSystemMan* ui_system_manager_ptr = GET_DIALOG_MANAGER(uiSystemMan, UIMAN_SYSTEM);
        TCHAR result_message[INTERFACE_STRING_LENGTH] = {0, };        
        TCHAR format_string[INTERFACE_STRING_LENGTH] = {0, };
        TCHAR item_name[MAX_ITEMNAME_LENGTH] = {0, };
        TCHAR result_item_name[INTERFACE_STRING_LENGTH] = {0, };
        g_InterfaceManager.GetItemName(selected_item_info_ptr->m_Code, item_name);
        Snprintf(result_item_name, INTERFACE_STRING_LENGTH-1, "%s+%d", item_name, use_slot.GetEnchant());
        
        // 5847 : Á¤¸»·Î [%s] ¾ÆÀÌÅÛÀ» °áÁ¤È­ ÇϽðڽÀ´Ï±î? °áÁ¤È­°¡ ¿Ï·áµÇ¸é ¾ÆÀÌÅÛÀ» º¹±¸ÇÒ ¼ö ¾ø½À´Ï´Ù.
        g_InterfaceManager.GetInterfaceString(5847, format_string);
        Snprintf(result_message, INTERFACE_STRING_LENGTH-1, format_string, result_item_name);
        ui_system_manager_ptr->Sys_SystemMessage(result_message, 
            NULL, 
            uiItemCompositeMan::_Callback_Crystalization_Confirm,
            uiSystemMessage::kConfirm_Type,
            true,
            0,
            100,
            155536,
            155537,
            TargetPos
            );

        return true;
    }

    InventoryDialog* inventory_dialog_ptr = static_cast<InventoryDialog*>(GET_DIALOG(IM_INVENTORY_MANAGER::INVEN_DLG));
    if (inventory_dialog_ptr)
    {
        CooltimeStruct data;
        ZeroMemory(&data, sizeof(data));
        data.type = kCrystalization;
        //data.max_time = 8000;
        SkillScriptInfo* skill_script_info_ptr = 
            SkillInfoParser::Instance()->GetSkillInfo(35024);
        data.max_time = static_cast<float>(skill_script_info_ptr ? skill_script_info_ptr->m_dwCoolTime : 8000);
        data.Crystalization.slot_code = slot_code;
        data.Crystalization.target_pos = TargetPos;
        data.slot_index = SI_INVENTORY;
        data.item_pos = TargetPos;
        data.dealy_time = 1000;
        data.serial_key = use_slot.GetSerial();
        ItemCooltimeManager::Instance()->InsertItem(&data);
    }

    return true;
}
//--------------------------------------------------------------------------------------------------
/** Ç츣¸Þ½ÃÁò ¼º¼­ À̺¥Æ®
*/
bool MouseHandler::ItemSocketRecreateTransction(POSTYPE slot_pos)
{
    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    RollbackItemAtHand();

    POSTYPE use_pos = GetPendingUseChargeItemPos();

    SCSlotContainer* container = ItemManager::Instance()->GetContainer(SI_INVENTORY);
    if (container == NULL)
    {
        return false;
    }
    SCItemSlot& use_slot = static_cast<SCItemSlot&>(container->GetSlot(slot_pos));
    if (use_slot.IsContainValidItem() == FALSE)
    {
        return false;
    }

    const BASE_ITEMINFO* selected_item_info_ptr = use_slot.GetItemInfo();

    if (selected_item_info_ptr == NULL)
    {
        return false;
    }
	//³¢ÊÔÔö¼ÓÊ×ÊÎÏâǶ
    if (!selected_item_info_ptr->IsSpecialAccessory() && !selected_item_info_ptr->IsArmor() && !selected_item_info_ptr->IsWeapon() && !selected_item_info_ptr->IsAccessory())
    {
        return false;
    }

    if (use_slot.CanUseMixture(MIXTURE_SOCKET_HOLE_FILL) == false) //xiaomi È¡ÏûÏâǶ¿ª¿×ÏÞÖÆ
    {
        return false;
    }

    const BASE_ITEMINFO* request_item_info = NULL;
    SCItemSlot& from_slot = static_cast<SCItemSlot&>(container->GetSlot(use_pos));
    request_item_info = from_slot.GetItemInfo();

    // ¼ÒÄÏ »ý¼º È®·ü Á¤º¸¸¦ ãÀ» ¼ö ÀÖ´ÂÁö °Ë»çÇÑ´Ù.
    if (request_item_info)
    {
        const SocketItemRatioParser* const ratio_parser = SocketItemRatioParser::Instance();
        SocketItemRatioInfo::RatioType::Value ratio_type = 
            ratio_parser->GetRatioType(selected_item_info_ptr->m_wType, true);
        const SocketItemRatioInfo::RatioType::Value fixed_ratio_type = request_item_info->m_wSubType;
        if (fixed_ratio_type != 0)
        {
            ratio_type = fixed_ratio_type;
            if (selected_item_info_ptr->IsArmor())
            {
                ++ratio_type;
            }
        }
        const SocketItemRatioInfo* const target_ratio = 
            ratio_parser->FindSocketRatio(ratio_type, selected_item_info_ptr->m_LV);
        if (target_ratio == NULL)
        {
            return false;
        }
    }
    

    uiAssistMan* assist_man = static_cast<uiAssistMan*>(
        g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  
    if (assist_man == NULL)
    {
        return false;
    }

    assist_man->ShowAskSocketRecreateDialog(use_slot.GetItemInfo()->m_Code, use_pos, slot_pos);
    return true;
}

//-------------------------------------------------------------------------------------------
/**
*/
BOOL				
MouseHandler::ItemCompositeExtraStoneUse(SLOTIDX SlotIdx, POSTYPE TargetPos)
{
	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);

	assert(pAtContainer);
    if (!pAtContainer)
    {
        return FALSE;
    }

	TCHAR	szMessage[INTERFACE_STRING_LENGTH];

	// ºñ¿öÀÖ´À³Ä?
	if (pAtContainer->IsEmpty(TargetPos))
	{
		//	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	// Á¶ÇÕ¾ÆÀÌÅÛÀÌ Àû¹ýÇÑÁö °Ë»ç
	SCItemSlot & rItemSlot = (SCItemSlot & )pAtContainer->GetSlot(TargetPos);

	if (!rItemSlot.GetItemInfo()->IsArmor() &&
		!rItemSlot.GetItemInfo()->IsWeapon() && 
		!rItemSlot.GetItemInfo()->IsAccessory() && 
		!rItemSlot.GetItemInfo()->IsSpecialAccessory() )
	{
		//	¿¢½ºÆ®¶ó½ºÅæ »ç¿ëÀÌ ºÒ°¡´É ÇÕ´Ï´Ù.	: 5308
		const int c_iCannotUseExtraStone = 5308;
		g_InterfaceManager.GetInterfaceString( c_iCannotUseExtraStone, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	int iValueIndex = rItemSlot.GetNOptionValueIndex();
	if( iValueIndex >= sEXTRASTONE_OPT_INFO::MAX_VALUE_NUM-1 )
	{
		//5123	´õ ÀÌ»ó ¿É¼ÇÀ» Ãß°¡ÇÒ ¼ö ¾ø½À´Ï´Ù.
		g_InterfaceManager.GetInterfaceString( 5123, szMessage, INTERFACE_STRING_LENGTH);
		//Snprintf(szMessage, INTERFACE_STRING_LENGTH, _T("´õ ÀÌ»ó ¿É¼Ç Ãß°¡¸¦ ÇÏ½Ç ¼ö ¾ø½À´Ï´Ù.") );
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, szMessage);
		return FALSE;
	}

	uiAssistMan* pMan = (uiAssistMan*)g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST);
	if(pMan)
	{
		pMan->ShowAskExtraStoneUse(			
			rItemSlot.GetCode(), 
			MouseHandler::Instance()->GetCrystalPos(),	// À¯Àú¿¡°Ô¼­ ¹Þ¾Æ³õÀº º¸¼®À§Ä¡
			TargetPos
		);
	}

	return TRUE;
}

#ifdef _ADD_CHARGE_ITEM_RANDOM_OPTION
BOOL MouseHandler::ItemCompositeAddRandomOption(SLOTIDX SlotIdx, POSTYPE TargetPos)
{
	if ( MouseHandler::Instance()->GetTryAddRandomOption() )
	{
		return FALSE;
	}

	MouseHandler::Instance()->SetTryAddRandomOption(TRUE);

	SCSlotContainer *pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);

	assert(pAtContainer);
	if (!pAtContainer)
    {
		return FALSE;
    }

	TCHAR	szMessage[INTERFACE_STRING_LENGTH];
	TCHAR	szItemName[INTERFACE_STRING_LENGTH];
	// ºñ¿öÀÖ´À³Ä?
	if (pAtContainer->IsEmpty(TargetPos))
	{
		//	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	// Á¶ÇÕ¾ÆÀÌÅÛÀÌ Àû¹ýÇÑÁö °Ë»ç
	SCItemSlot & rItemSlot = (SCItemSlot & )pAtContainer->GetSlot(TargetPos);

	if ( !rItemSlot.GetItemInfo()->IsCanEquip() )
	{
		//	ÇØ´ç ¾ÆÀÌÅÛ¿¡´Â »ç¿ëÀÌ ºÒ°¡´É ÇÕ´Ï´Ù.
		return FALSE;
	}

	if ( rItemSlot.GetSocketNum() > SOCKET_MAX)
	{
		// ´õ ÀÌ»ó ¿É¼ÇÀ» Ãß°¡ÇÒ ¼ö ¾ø½À´Ï´Ù.
		return FALSE;
	}

	TCHAR szTemp[INTERFACE_STRING_LENGTH] ={0,};
	//5148	[%s]¿¡ ·£´ý¿É¼ÇÀ» Ãß°¡ÇϽðڽÀ´Ï±î?
	g_InterfaceManager.GetInterfaceString( 5148 , szTemp ,INTERFACE_STRING_LENGTH);
	g_InterfaceManager.GetItemName(rItemSlot.GetCode(), szItemName, INTERFACE_STRING_LENGTH);
	Snprintf(szMessage, INTERFACE_STRING_LENGTH, szTemp, szItemName);


	uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
	if(pSystemMan)
		pSystemMan->Sys_Confirm(szMessage, GlobalFunc::AddRandomOption);


	return TRUE;
}
#endif

/** ItemCompositeRankUPTransction 
	·©Å©¾÷ °ü·ÃµÈ 󸮸¸!
	y2jinc
*/

bool MouseHandler::ItemCubeTransection(SLOTIDX slot_idx, POSTYPE to_position, RECT* pRect)
{
    SCSlotContainer* to_container = ItemManager::Instance()->GetContainer(slot_idx); 
    if (to_container == NULL)
    {
        return false;
    }

    DummyItemSlot DummyItem;
    TCHAR message[INTERFACE_STRING_LENGTH];

    if(IsExistItemAtHand())
    { 
        if ( SI_INVENTORY != m_MouseItem.m_fromSlotIdx )
        {
            //	¾ÆÀÌÅÛ Á¶ÇÕÀº Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù!
            g_InterfaceManager.GetInterfaceString(eST_ITEM_COMPOSITE_RANKUP_IN_INVENTORY, message, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);
            return false;
        }

        if (m_MouseItem.m_pRenderUnit->m_isDiv)
        {
            // 988	â°í¿¡¼­´Â ¾ÆÀÌÅÛ ºÐÇÒÀÌ ºÒ°¡´É ÇÕ´Ï´Ù. Àκ¥Å丮¿¡¼­ ½ÃµµÇØ ÁÖ¼¼¿ä
            g_InterfaceManager.GetInterfaceString(988 , message ,INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_TOP_SHOW, message);
            return false;
        }

        SCSlotContainer* from_container = ItemManager::Instance()->GetContainer(m_MouseItem.m_fromSlotIdx);

        // ºñ¿öÀÖ¾î¾ß ä¿ï¼ö ÀÖ´Ù.
        if (!to_container->IsEmpty(to_position))
        {
            //	½½·ÔÀÌ ºñ¾îÀÖÁö ¾Ê½À´Ï´Ù!
            g_InterfaceManager.GetInterfaceString(eST_TARGET_SLOT_IS_NOT_EMPTY, message, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);
            return false;
        }

        SCItemSlot* from_itemslot_ptr = static_cast<SCItemSlot*>(m_MouseItem.m_pFromSlot);
        if (from_itemslot_ptr &&
            (from_itemslot_ptr->IsPetItem()) &&
            (from_itemslot_ptr->IsUserBlocked() == true))
        {
            // 5692 ¼ÒȯµÈ ÆêÀº ÇÕ¼ºÀç·á·Î »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù. Æê ¼ÒȯÀ» ÇØÁ¦ÇÑÈÄ ´Ù½Ã ½ÃµµÇØ ÁֽʽÿÀ.
            TCHAR message_buffer[INTERFACE_STRING_LENGTH] = {0,};
            g_InterfaceManager.GetInterfaceString(5692, message_buffer,INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message_buffer);

            return false;
        }
/*
        uiItemCube* cube_dialog = (uiItemCube*)to_container;
        if(cube_dialog == NULL)
        {
            return false;
        }*/

        //SCItemSlot& from_item_slot = (SCItemSlot&)from_container->GetSlot(m_MouseItem.m_fromPos);

        // ¿©±â¿¡ µé¾î¿Ô´Ù´Â°ÍÀº ƯÁ¤ ÄÁÅ×À̳ʿ¡¼­ ·©Å©¾÷ ÄÁÅ×À̳ʷΠ¾ÆÀÌÅÛÀ» °¡Á®¿Â°ÍÀÌ´Ù.
        switch(m_MouseItem.m_slotType)
        {
        case ST_ITEM:
            {
                assert(m_MouseItem.m_pFromSlot);
                DummyItem.SetOrgSlot(m_MouseItem.m_pFromSlot);
                DummyItem.SetFromContainerIdx(m_MouseItem.m_fromSlotIdx);
                DummyItem.SetFromPosition(m_MouseItem.m_fromPos);		
                to_container->InsertSlot(to_position, DummyItem);
                MouseHandler::Instance()->RollbackItemAtHand();
            }
            break;
        default:
            {
                assert( !"À߸øµÈ ŸÀÔÀÇ ½½·ÔÀ» À̵¿Çß½À´Ï´Ù." );
                return false;
            }
        }
        return true;
    }
    return true;
}

bool MouseHandler::ItemCubeInventoryRightClick(const SLOTIDX from_container_index, 
    const SLOTIDX to_container_index, const POSTYPE from_postype)
{
    DummyItemSlot DummyItem;

    if (IsExistItemAtHand()) // ¸¶¿ì½º¿¡ ÀâÈù°ÍÀÌ ¾øÀ» °æ¿ì¸¸
    {
        return false;
    }

    if (from_container_index != SI_INVENTORY)
    {
        //	¾ÆÀÌÅÛ Á¶ÇÕÀº Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù!
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, 
            g_InterfaceManager.GetInterfaceString(eST_ITEM_COMPOSITE_RANKUP_IN_INVENTORY));
        return false;
    }
    if (to_container_index != SI_CUBE)
    {
        return false;
    }

    SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index);
    SCSlotContainer* cube_container_ptr = ItemManager::Instance()->GetContainer(to_container_index); 
    if ((inventory_container_ptr == NULL) || 
        (inventory_container_ptr->IsEmpty(from_postype) == TRUE) || 
        (cube_container_ptr == NULL))
    {
        return false;
    }

    SCItemSlot* from_itemslot_ptr = 
        static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_postype)));
    if ((from_itemslot_ptr == NULL) || 
        (from_itemslot_ptr->GetItemInfo() == NULL) || 
        (from_itemslot_ptr->GetSlotType() != ST_ITEM))
    {
        return false;
    }

    if ((from_itemslot_ptr->IsPetItem()) &&
        (from_itemslot_ptr->IsUserBlocked() == true))
    {
        // 5692 ¼ÒȯµÈ ÆêÀº ÇÕ¼ºÀç·á·Î »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù. Æê ¼ÒȯÀ» ÇØÁ¦ÇÑÈÄ ´Ù½Ã ½ÃµµÇØ ÁֽʽÿÀ.
        TCHAR message_buffer[INTERFACE_STRING_LENGTH] = {0,};
        g_InterfaceManager.GetInterfaceString(5692, message_buffer,INTERFACE_STRING_LENGTH);
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message_buffer);

        return false;
    }

    if (from_itemslot_ptr->IsLocked())
    {
        return false;
    }

    SCItemSlot& from_item_slot = (SCItemSlot&)inventory_container_ptr->GetSlot(from_postype);
    // ¿©±â¿¡ µé¾î¿Ô´Ù´Â°ÍÀº ƯÁ¤ ÄÁÅ×À̳ʿ¡¼­ ·©Å©¾÷ ÄÁÅ×À̳ʷΠ¾ÆÀÌÅÛÀ» °¡Á®¿Â°ÍÀÌ´Ù.
    assert(&from_item_slot);
    DummyItem.SetOrgSlot(&from_item_slot);
    DummyItem.SetFromContainerIdx(from_container_index);
    DummyItem.SetFromPosition(from_postype);

    POSTYPE empty_pos = 0;
    while(!cube_container_ptr->IsEmpty(empty_pos))
    {
        ++empty_pos;
        if (empty_pos >= cube_container_ptr->GetMaxSlotNum())
        {
            return false;
        }
    }
    cube_container_ptr->InsertSlot(empty_pos, DummyItem); 
    return true;
}

bool MouseHandler::ItemSocketCompositeTransection(SLOTIDX slot_idx, POSTYPE to_position, RECT* pRect)
{
    SCSlotContainer* to_container = ItemManager::Instance()->GetContainer(slot_idx); 
    if (to_container == NULL)
    {
        return false;
    }

    DummyItemSlot DummyItem;
    TCHAR message[INTERFACE_STRING_LENGTH];

    if(IsExistItemAtHand())
    { 
        if (SI_INVENTORY != m_MouseItem.m_fromSlotIdx)
        {
            //	¾ÆÀÌÅÛ Á¶ÇÕÀº Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù!
            g_InterfaceManager.GetInterfaceString(eST_ITEM_COMPOSITE_RANKUP_IN_INVENTORY, message, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);
            return false;
        }

        if (m_MouseItem.m_pRenderUnit->m_isDiv)
        {
            // 988	â°í¿¡¼­´Â ¾ÆÀÌÅÛ ºÐÇÒÀÌ ºÒ°¡´É ÇÕ´Ï´Ù. Àκ¥Å丮¿¡¼­ ½ÃµµÇØ ÁÖ¼¼¿ä
            g_InterfaceManager.GetInterfaceString(988 , message ,INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_TOP_SHOW, message);
            return false;
        }

        SCSlotContainer* from_container = ItemManager::Instance()->GetContainer(m_MouseItem.m_fromSlotIdx);

        // ºñ¿öÀÖ¾î¾ß ä¿ï¼ö ÀÖ´Ù.
        if (!to_container->IsEmpty(to_position))
        {
            //	½½·ÔÀÌ ºñ¾îÀÖÁö ¾Ê½À´Ï´Ù!
            g_InterfaceManager.GetInterfaceString(eST_TARGET_SLOT_IS_NOT_EMPTY, message, INTERFACE_STRING_LENGTH);
            GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message);
            return false;
        }

        uiSocketComposite* dialog = 
            GET_CAST_DIALOG(uiSocketComposite, IM_SOCKET_MANAGER::SOCKET_COMPOSITE);
        TCHAR message_buffer[INTERFACE_STRING_LENGTH] = {0,};
        // ¿©±â¿¡ µé¾î¿Ô´Ù´Â°ÍÀº ƯÁ¤ ÄÁÅ×À̳ʿ¡¼­ Àðµå ÇÕ¼º ÄÁÅ×À̳ʷΠ¾ÆÀÌÅÛÀ» °¡Á®¿Â°ÍÀÌ´Ù.
        switch(m_MouseItem.m_slotType)
        {
        case ST_ITEM:
            {
                assert(m_MouseItem.m_pFromSlot);
                SCItemSlot& from_item_slot = (SCItemSlot&)from_container->GetSlot(
                    m_MouseItem.m_fromPos);

                if (to_position < uiSocketComposite::SOCKET_COMPOSITE_SLOT_RESOURCE_MAX)
                {
                    if (from_item_slot.IsZardItem() == false)
                    {   // Àðµå¸¸ ¿Ã¸± ¼ö ÀÖ½À´Ï´Ù.
                        return false;
                    }
                    int pre_zard_grade = 0;
                    for (int i = 0; i < uiSocketComposite::SOCKET_COMPOSITE_SLOT_RESOURCE_MAX; ++i)
                    {
                        if (pre_zard_grade != 0)
                        {
                            break;
                        }
                        if (to_container->IsEmpty(i))
                        {
                            if (from_item_slot.GetItemInfo()->zard_grade > kZardGrade4)
                            {   // 6489 »ó±ÞÀðµå ÇÕ¼ºÀº ÇöÀçÀÇ ±â¼ú·Î ºÒ°¡´ÉÇÕ´Ï´Ù
                                if (dialog && dialog->IsVisibleWindow())
                                {
                                    g_InterfaceManager.GetInterfaceString(6489, message_buffer,INTERFACE_STRING_LENGTH);
                                    dialog->SetMessage(uiSocketComposite::SOCKET_COMPOSITE_INFO_STRING4,
                                        message_buffer);
                                }
                                return false;
                            } 
                        }
                        else
                        {
                            DummyItemSlot& dummy_item_slot = (DummyItemSlot&)to_container->GetSlot(i);
                            SCItemSlot* to_item_slot = (SCItemSlot*)dummy_item_slot.GetOrgSlot();
                            if (to_item_slot && to_item_slot->GetItemInfo() != NULL)
                            {
                                pre_zard_grade = to_item_slot->GetItemInfo()->zard_grade; //ÃÖÃÊ Àðµå µî±ÞÀ» ÀúÀå
                            }
                        }
                    }

                    if (pre_zard_grade != 0)
                    {
                        if (pre_zard_grade != from_item_slot.GetItemInfo()->zard_grade)
                        {   // 6488: ÀðµåÀÇ µî±ÞÀÌ ´Ù¸¨´Ï´Ù. °°Àº µî±ÞÀÇ Àðµå¸¸ ÇÕ¼ºÇÒ ¼ö ÀÖ½À´Ï´Ù.
                            g_InterfaceManager.GetInterfaceString(6488, message_buffer,INTERFACE_STRING_LENGTH);
                            if (dialog && dialog->IsVisibleWindow())
                            {
                                dialog->SetMessage(uiSocketComposite::SOCKET_COMPOSITE_INFO_STRING4,
                                    message_buffer);
                            }  
                            return false; // ÀÌÀü¿¡ µî·ÏµÈ Àðµå¿Í µî±ÞÀÌ ´Ù¸£¸é ¾ÈµÊ
                        }            
                    }
                }
                else if(to_position == uiSocketComposite::SOCKET_COMPOSITE_SLOT_ADD_RESOURCE)
                {
                    if (from_item_slot.IsZardAdditiveItem() == false)
                    {   // Àðµå ÇÕ¼º ÷°¡Á¦¸¸ ¿Ã¸± ¼ö ÀÖ½À´Ï´Ù.
                        return false;
                    }
                }
                else
                {
                    return false;
                }

                DummyItem.SetOrgSlot(m_MouseItem.m_pFromSlot);
                DummyItem.SetFromContainerIdx(m_MouseItem.m_fromSlotIdx);
                DummyItem.SetFromPosition(m_MouseItem.m_fromPos);		
                to_container->InsertSlot(to_position, DummyItem);
                MouseHandler::Instance()->RollbackItemAtHand();
            }
            break;
        default:
            {
                assert( !"À߸øµÈ ŸÀÔÀÇ ½½·ÔÀ» À̵¿Çß½À´Ï´Ù." );
                return false;
            }
        }
        if (dialog && dialog->IsVisibleWindow())
        {
            dialog->SetMessage(uiSocketComposite::SOCKET_COMPOSITE_INFO_STRING4, "");
        }        
        return true;
    }
    return true;
}

bool MouseHandler::SocketCompositeInventoryRightClick(const SLOTIDX from_container_index, 
                                               const SLOTIDX to_container_index, const POSTYPE from_postype)
{
    DummyItemSlot DummyItem;

    if (IsExistItemAtHand()) // ¸¶¿ì½º¿¡ ÀâÈù°ÍÀÌ ¾øÀ» °æ¿ì¸¸
    {
        return false;
    }

    if (from_container_index != SI_INVENTORY)
    {
        //	¾ÆÀÌÅÛ Á¶ÇÕÀº Àκ¥Å丮¿¡ ÀÖ´Â ¾ÆÀÌÅÛ¸¸ °¡´ÉÇÕ´Ï´Ù!
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, 
            g_InterfaceManager.GetInterfaceString(eST_ITEM_COMPOSITE_RANKUP_IN_INVENTORY));
        return false;
    }
    if (to_container_index != SI_SOCKET_COMPOSITE)
    {
        return false;
    }

    SCSlotContainer* inventory_container_ptr = ItemManager::Instance()->GetContainer(from_container_index);
    SCSlotContainer* socket_composite_container_ptr = ItemManager::Instance()->GetContainer(to_container_index); 
    if ((inventory_container_ptr == NULL) || 
        (inventory_container_ptr->IsEmpty(m_MouseItem.m_fromPos) == TRUE) || 
        (socket_composite_container_ptr == NULL))
    {
        return false;
    }

    SCItemSlot* from_itemslot_ptr = 
        static_cast<SCItemSlot*>(&(inventory_container_ptr->GetSlot(from_postype)));
    if ((from_itemslot_ptr == NULL) || 
        (from_itemslot_ptr->GetItemInfo() == NULL) || 
        (from_itemslot_ptr->GetSlotType() != ST_ITEM))
    {
        return false;
    }

    if (from_itemslot_ptr->IsLocked())
    {
        return false;
    }

    SCItemSlot& from_item_slot = (SCItemSlot&)inventory_container_ptr->GetSlot(from_postype);
    // ¿©±â¿¡ µé¾î¿Ô´Ù´Â°ÍÀº ƯÁ¤ ÄÁÅ×À̳ʿ¡¼­ Àðµå ÇÕ¼º ÄÁÅ×À̳ʷΠ¾ÆÀÌÅÛÀ» °¡Á®¿Â°ÍÀÌ´Ù.
    assert(&from_item_slot);
    DummyItem.SetOrgSlot(&from_item_slot);
    DummyItem.SetFromContainerIdx(from_container_index);
    DummyItem.SetFromPosition(from_postype);

    POSTYPE empty_pos = 0;

    if (inventory_container_ptr->IsEmpty(from_postype))
    {
        return false;
    }

    if (from_item_slot.IsZardItem() == true)
    {
        while(!socket_composite_container_ptr->IsEmpty(empty_pos))
        {
            ++empty_pos;
            if (empty_pos >= uiSocketComposite::SOCKET_COMPOSITE_SLOT_RESOURCE_MAX)
            {
                return false;
            }
        }

        uiSocketComposite* dialog = 
            GET_CAST_DIALOG(uiSocketComposite, IM_SOCKET_MANAGER::SOCKET_COMPOSITE);
        TCHAR message_buffer[INTERFACE_STRING_LENGTH] = {0,};
        int pre_zard_grade = 0;
        for (int i = 0; i < uiSocketComposite::SOCKET_COMPOSITE_SLOT_RESOURCE_MAX; ++i)
        {
            if (pre_zard_grade != 0)
            {
                break;
            }
            if (socket_composite_container_ptr->IsEmpty(i))
            {
                if (from_item_slot.GetItemInfo()->zard_grade >= kZardGrade4)
                {   // »ó±ÞÀº Á¶ÇÕ ºÒ°¡
                    // 6489 »ó±ÞÀðµå ÇÕ¼ºÀº ÇöÀçÀÇ ±â¼ú·Î ºÒ°¡´ÉÇÕ´Ï´Ù
                    g_InterfaceManager.GetInterfaceString(6489, message_buffer,INTERFACE_STRING_LENGTH);
                    if (dialog && dialog->IsVisibleWindow())
                    {
                        dialog->SetMessage(uiSocketComposite::SOCKET_COMPOSITE_INFO_STRING4,
                            message_buffer);
                    } 
                    return false;
                }
            }
            else
            {
                DummyItemSlot& dummy_item_slot = (DummyItemSlot&)socket_composite_container_ptr->GetSlot(i);
                SCItemSlot* to_item_slot = (SCItemSlot*)dummy_item_slot.GetOrgSlot();
                if (to_item_slot && to_item_slot->GetItemInfo() != NULL)
                {
                    pre_zard_grade = to_item_slot->GetItemInfo()->zard_grade; //ÃÖÃÊ Àðµå µî±ÞÀ» ÀúÀå
                }
            }
        }

        if (pre_zard_grade != 0)
        {
            if (pre_zard_grade != from_item_slot.GetItemInfo()->zard_grade)
            {   // 6488: ÀðµåÀÇ µî±ÞÀÌ ´Ù¸¨´Ï´Ù. °°Àº µî±ÞÀÇ Àðµå¸¸ ÇÕ¼ºÇÒ ¼ö ÀÖ½À´Ï´Ù.
                g_InterfaceManager.GetInterfaceString(6488, message_buffer,INTERFACE_STRING_LENGTH);
                if (dialog && dialog->IsVisibleWindow())
                {
                    dialog->SetMessage(uiSocketComposite::SOCKET_COMPOSITE_INFO_STRING4,
                        message_buffer);
                } 
                return false; // ÀÌÀü¿¡ µî·ÏµÈ Àðµå¿Í µî±ÞÀÌ ´Ù¸£¸é ¾ÈµÊ
            }            
        }
    }
    else if (from_item_slot.IsZardAdditiveItem() == true)
    {
        empty_pos = uiSocketComposite::SOCKET_COMPOSITE_SLOT_ADD_RESOURCE;
        if (!socket_composite_container_ptr->IsEmpty(empty_pos))
        {
            return false;
        }
    }
    else
    {
        return false;
    }
    socket_composite_container_ptr->InsertSlot(empty_pos, DummyItem);
    return true;
}

BOOL MouseHandler::ItemCompositeEnchants(SLOTIDX SlotIdx, POSTYPE AtPos, RECT * pRect)
{
	SCSlotContainer *pToContainer = ItemManager::Instance()->GetContainer(SlotIdx); 
    if (!pToContainer)
    {
        return FALSE;
    }

	ItemETCCompositeDlg *pEnchantDlg = (ItemETCCompositeDlg *)ItemManager::Instance()->GetItemContainerDialog(SlotIdx);
	 
	SCItemSlot ItemSlot;

	TCHAR	szMessage[INTERFACE_STRING_LENGTH];

	if( IsExistItemAtHand() )
	{ 
		// target pos ÀÇ ½½·ÔÀÌ ºñ¿öÀÖ¾î¾ßÇÑ´Ù.

		if (!pToContainer->IsEmpty(AtPos))
		{
			// target ¾ÆÀÌÅÛÀÌ Â÷ÀÖ½À´Ï´Ù.
			// Àçµî·ÏÇضó.
			return FALSE;
		}

		switch (pEnchantDlg->GetCurrentCompositeType())
		{
		case eITEMCOMPOSITE_EXTRACT_SOCKET:
			{
				if (ST_ITEM != this->m_MouseItem.m_pFromSlot->GetSlotType())
				{
					return FALSE;
				}
			}
			break;
		default:
			return FALSE;
			break;
		}

		// ±âº» Àç·á µéÀÌ µî·ÏµÇ¾î ÀÖ³ª?
		if ( !ItemManager::Instance()->IsExistCompositeMaterials( 
				pEnchantDlg->GetCurrentCompositeType(), 
				SI_INVENTORY) 
			)
		{
			//	ÇÊ¿äÇÑ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù.
			g_InterfaceManager.GetInterfaceString( eST_ITEM_NOT_EXIST_COMPOSITE_MATERIALS, szMessage, INTERFACE_STRING_LENGTH );
			GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
			return FALSE;
		}

		pEnchantDlg->SetTargetInfo(m_MouseItem.m_fromSlotIdx, m_MouseItem.m_fromPos);
		ItemManager::Instance()->CopyItem(
				m_MouseItem.m_fromSlotIdx, 
				SI_ITEM_ETC_COMPOSE, 
				m_MouseItem.m_fromPos,
				AtPos );	
	}
	else
	{
		// ´Ù½Ã µé¾î¿ÃÇÊ¿ä°¡ ¾ø´Ù.
		return FALSE;
	}

	return TRUE;
}


MouseHandler::MOUSE_STATE MouseHandler::GetMouseState() const
{
	return m_eTradeState;
}

VOID MouseHandler::SetMouseState(MOUSE_STATE eShop)
{
	m_eTradeState = eShop;

	switch (m_eTradeState)
	{
	case BUY:
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Buy);
		}
		break;

	case SELL:
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Sell);
		}
		break;
    case ETHERIA_EXTRACT:
    case ETHERIA_EXTRACT_CASTING:
	case REPAIR:
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair);
		}
		break;

	case WITHDRAW:
	case GUILD_WITHDRAW:
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_WireHouse_Out);
		}
		break;

	case DEPOSIT:
	case GUILD_DEPOSIT:
		{
			CursorChangeTransact::Instance()->ChangeTranaction( MouseCursor::eMouseCursor_WireHouse_In );
		}
		break;


	case ETHER_DEVICE_FILL:
    case RIDER_WAX:
    case ETHERIA_COMBINATION:
	case ENCHANT:
	case SOCKET_FILL:
#ifdef _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
	case AWAKENING:
#endif // _NA_008121_20150311_EQUIPMENT_AWAKENING_SYSTEM
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
		}
		break;

	case EXTRASTONE_USE:
		{
			CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
		}
		break;


	case THROW_WASTE_BASKET:
		{
			// TODO : Áö¿ï¶§ ³ª¿À´Â ¾ÆÀÌÄÜ ¸ð¾ç Ãß°¡ ¿äû
			CursorChangeTransact::Instance()->ForceChange( MouseCursor::eMouseCursor_Waste_Basket );
		}
		break;

	case SOCKET_REMOVE:
		CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
		break;	

#ifdef _ADD_CHARGE_ITEM_RANDOM_OPTION
	case ADD_RANDOM_OPTION:
		CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
		break;
#endif			


	case RANK_DOWN:
		CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Item_Rank_Down);
		break;


	case REPAIR_LIMITED:
		CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair_Limited_Item);
		break;

	case NONE:
	default:
		{
			CursorChangeTransact::Instance()->ForceChange( MouseCursor::eMouseCursor_Default );
		}
		break;
	}
}


//----------------------------------------------------------------------------
/**
*/
VOID				
MouseHandler::RemoveMouseState(MOUSE_STATE eShop)
{
	if ( GetMouseState() == eShop )
	{
		SetMouseState( MouseHandler::NONE );

		if ( MouseHandler::THROW_WASTE_BASKET == eShop )
		{
			UnLockWasteDeleteItem();
		}

        if ( MouseHandler::CRYSTALIZATION == eShop )
        {
            InventoryDialog * inventory_dialog_ptr 
                = GET_CAST_DIALOG( InventoryDialog, IM_INVENTORY_MANAGER::INVEN_DLG );
            if (inventory_dialog_ptr)
            {
                inventory_dialog_ptr->RevertCrystalizationItemIconDeActiveRender();
            }
        }
	}
}


//----------------------------------------------------------------------------
/**
*/
VOID MouseHandler::initMouseItem()
{
	m_MouseItem.m_fromSlotIdx		= 0;
	m_MouseItem.m_fromPos			= 0;
	m_MouseItem.m_pRenderUnit		= NULL;
	m_MouseItem.m_pFromSlot			= NULL;
	m_MouseItem.m_pFromBaseItemInfo = NULL;
	SetRectEmpty( &m_MouseItem.m_OldRect);	
}

//----------------------------------------------------------------------------
/**
*/
VOID				
MouseHandler::refreshContainer(SLOTIDX SlotIdx)
{
	SolarDialog * pSolarDialog = 
		(SolarDialog *)ItemManager::Instance()->GetItemContainerDialog(SlotIdx);

	if (!pSolarDialog)
	{
		return;
	}

	switch (SlotIdx)
	{
	case SI_EVENT_INVENTORY:	// temp inventory ´Â â°í¿¡ ¸®¼Ò½º Á¤º¸¸¦ µÎ°í ÀÖ´Ù.
	case SI_INVENTORY:
		{
			InventoryDialog * pInvenDialog = (InventoryDialog *)pSolarDialog;
			if ( pInvenDialog )
			{
				pInvenDialog->ReFreshRenderSlot();
			}
		}
		break;

	case SI_EQUIPMENT:
		{
			HeroEquipmentContainer * pEquipContainer = (HeroEquipmentContainer *)pSolarDialog;
			if ( pEquipContainer )
			{
				pEquipContainer->ReFreshRenderSlot();
			}
		}
		break;
	case SI_WAREHOUSE:
		{
			pSolarDialog = 
				(SolarDialog *)ItemManager::Instance()->GetItemContainerDialog(SlotIdx);

			
#ifdef _NA_003923_20120130_GUILD_RENEWAL_MOD_WAREHOUSE_SLOT_NUM
            uiBankDialog* pBankDialog = (uiBankDialog*)pSolarDialog;
            if ( pBankDialog )
            {
                // 2012.09.06 â°í¿¡¼­ ƯÁ¤ ¾ÆÀÌÅÛÀ» Ŭ¸¯ÇÑ ÈÄ ±× ÀÚ¸®¿¡ ´Ù½Ã Ŭ¸¯ ÇÒ ¶§, ¾ÆÀÌÄÜÀÌ »ç¶óÁö´Â Çö»ó ¼öÁ¤
                // ÀÌÀ¯´Â ¾ÆÁ÷ ¾ÆÀÌÅÛÀ» ¸¶¿ì½º Çڵ鷯¿¡¼­ ³»·Á³õÁö ¾ÊÀº »óȲ¿¡¼­ ReFreshRenderSlot()°¡ È£ÃâµÇ¾î °¡·ÁÁü
                //pBankDialog->ReFreshRenderSlot();
            }
#else
            BankDialog* pBankDialog = (BankDialog*)pSolarDialog;
            if ( pBankDialog )
            {
                pBankDialog->ReFreshRenderSlot();
            }
#endif //_NA_003923_20120130_GUILD_RENEWAL_MOD_WAREHOUSE_SLOT_NUM
		}
		break;

	default:
		break;
	}

}


BOOL MouseHandler::CheckBlockedItem( SCItemSlot * pSlot)
{
	TCHAR szMessage[INTERFACE_STRING_LENGTH];
	if(pSlot->IsBlocked())
	{
		RollbackItemAtHand();
		g_InterfaceManager.GetInterfaceString(eST_BLOCKED_ITEM_NOT_MOVE,szMessage,INTERFACE_STRING_LENGTH);
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT,szMessage);
		return TRUE;
	}
	return FALSE;
}

BOOL MouseHandler::ItemRepairLimitedTransction(SLOTIDX SlotIdx, POSTYPE TargetPos)
{
	MouseHandler::Instance()->SetTryUseChageItem(TRUE);

	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);

	assert(pAtContainer);
	if (!pAtContainer)
    {
		return FALSE;
    }

	TCHAR	szMessage[INTERFACE_STRING_LENGTH] = {0,};
	// ºñ¿öÀÖ´À³Ä?
	if (pAtContainer->IsEmpty(TargetPos))
	{
		//	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
		g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
		return FALSE;
	}

	// ·©Å©´Ù¿î ¾ÆÀÌÅÛÀÌ Àû¹ýÇÑÁö °Ë»ç
	SCItemSlot & rItemSlot = (SCItemSlot & )pAtContainer->GetSlot(TargetPos);

	if ( !rItemSlot.IsLimited() )
	{
		//	ÇØ´ç ¾ÆÀÌÅÛ¿¡´Â »ç¿ëÀÌ ºÒ°¡´É ÇÕ´Ï´Ù.
		return FALSE;
	}

	return TRUE;
}


BOOL MouseHandler::_useTransactionFateItemIdentify(SCItemSlot & rItemSlot, const BASE_ITEMINFO * pItemInfo, POSTYPE AtPos)
{
	if( rItemSlot.IsFateItem() && !rItemSlot.GetFateIdentify())
	{
		uiFateItemSystem* pFateItemSystem=  GET_CAST_DIALOG( uiFateItemSystem, IM_FATEITEM_SYSTEM::FATEITEM_DLG );

		if( pFateItemSystem && !pFateItemSystem->IsVisibleWindow() )
		{
			pFateItemSystem->ShowInterface(TRUE);
			pFateItemSystem->SetTargetItem(pItemInfo, AtPos );
			pFateItemSystem->SetTargetItemLock(TRUE);
		}
		return TRUE;
	}
	return FALSE;
}


BOOL MouseHandler::_useTransactionItemPortalQuest(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	if (GameFramework::GetCurrentScene() && 
		(SCENE_TYPE_VILLAGE != GameFramework::GetCurrentScene()->GetType() &&
		SCENE_TYPE_FIELD != GameFramework::GetCurrentScene()->GetType() ) )
	{					
		//5745	¹èƲÁ¸¿¡¼­´Â »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù.
		TCHAR szBuf[INTERFACE_STRING_LENGTH];
		g_InterfaceManager.GetInterfaceString(5745, szBuf, INTERFACE_STRING_LENGTH);
		GlobalFunc::OutputMsg_Error(eOUTPUT_MSG_CHAT, szBuf);
		return TRUE;
	}

	SCSlotContainer * pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
	SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);

	const BASE_ITEMINFO * pItemInfo = rItemSlot.GetItemInfo();
	if ( !pItemInfo )
		return FALSE;


	if ( FALSE == GetTryUseChageItem() )
	{
		SetTryUseChageItem(TRUE);
		SetPendingUseChargeItemPos(AtPos);

		const sMAPINFO * pMapInfo = MapInfoParser::Instance()->FindMapInfo(pItemInfo->m_wSkillCode);
		if( pMapInfo )
		{
			TCHAR szMessage[INTERFACE_STRING_LENGTH] ={0,};
			TCHAR szTemp[INTERFACE_STRING_LENGTH] ={0,};
			g_InterfaceManager.GetInterfaceString(6269, szTemp, INTERFACE_STRING_LENGTH);
			Snprintf(szMessage, INTERFACE_STRING_LENGTH -1, szTemp ,
				g_InterfaceManager.GetInterfaceString(pMapInfo->dwNCode));

			uiSystemMan * pSystemMan = (uiSystemMan *)g_InterfaceManager.GetUserInterfaceManager(UIMAN_SYSTEM);
			pSystemMan->Sys_Confirm(szMessage, GlobalFunc::_fn_UsePortalQuestItem);
		}
	}

	return TRUE;
}



BOOL MouseHandler::ItemEtherDeviceFillTransction(SLOTIDX SlotIdx, POSTYPE AtPos)
{
	

	SCSlotContainer* container = ItemManager::Instance()->GetContainer(SlotIdx);
	if (container == NULL)
	{
		return FALSE;
	}

	SCItemSlot& item_slot = static_cast<SCItemSlot &>(container->GetSlot(AtPos));
	if (item_slot.IsContainValidItem() == FALSE)
	{
		return FALSE;
	}

	int string_index = -1;
	
	// 70130:ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
	if (container->IsEmpty(AtPos))
	{
		string_index = eST_TARGET_SLOT_IS_EMPTY;
	}
	// 6122:¿¡Å׸£ ¹æÃâÀåÄ¡´Â ¹«±â¿¡¸¸ ÀåÂø°¡´ÉÇÕ´Ï´Ù.
	if (item_slot.GetItemInfo()->IsWeapon() == FALSE)
	{
		string_index = 6122;
	}
	// 6123:¿¡Å׸£ ¹æÃâÀåÄ¡°¡ ÀÌ¹Ì ÀåÂøµÇ¾î ÀÖ½À´Ï´Ù.	
	if (item_slot.IsEquipEtherDevice())
	{
		string_index = 6123;
	}

	// 6122:¿¡Å׸£ ¹æÃâÀåÄ¡´Â ¹«±â¿¡¸¸ ÀåÂø°¡´ÉÇÕ´Ï´Ù.
	if (item_slot.IsEtheriaItem() ||
		item_slot.IsShellItem())
	{
		string_index = 6122;
	}

	if (string_index > 0)
	{
		TCHAR fail_msg[INTERFACE_STRING_LENGTH] ={0,};
		g_InterfaceManager.GetInterfaceString(string_index, fail_msg, INTERFACE_STRING_LENGTH);
		GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, fail_msg);
		return FALSE;
	}

	uiAssistMan* assist_man = static_cast<uiAssistMan*>(
								g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  

	if (assist_man == NULL)
	{
		return FALSE;
	}

	MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
	assist_man->ShowAskEtherDeviceDialog(item_slot.GetCode(), AtPos, GetPendingUseChargeItemPos());

	return TRUE;
}


BOOL MouseHandler::ItemRiderWaxChangeTransction(SLOTIDX SlotIdx, POSTYPE AtPos)
{
    SCSlotContainer *pAtContainer = ItemManager::Instance()->GetContainer(SlotIdx);
    if (!pAtContainer)
    {
        return FALSE;
    }
    SCItemSlot & rItemSlot = (SCItemSlot &)pAtContainer->GetSlot(AtPos);
    SCItemSlot & rItemFromSlot = (SCItemSlot &)pAtContainer->GetSlot(GetPendingUseChargeItemPos());

    BASE_ITEMINFO * pInfo = ItemInfoParser::Instance()->GetItemInfo( rItemSlot.GetCode() );
    if( !pInfo)
        return FALSE;

    TCHAR szMessage[INTERFACE_STRING_LENGTH] ={0,};

    // ºñ¿öÀÖ´À³Ä?
    if (pAtContainer->IsEmpty(AtPos))
    {
        //	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
        g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, szMessage, INTERFACE_STRING_LENGTH );
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage );
        return FALSE;
    }

    if( !pInfo->IsRiderPartsItem())
    {
        //6449 Å»°ÍÀÇ ÀåÂø ¾ÆÀÌÅÛ¿¡¸¸ »ç¿ë ÇÒ ¼ö ÀÖ½À´Ï´Ù.
        g_InterfaceManager.GetInterfaceString(6449,szMessage);
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, szMessage);
        return FALSE;
    }

    uiAssistMan * pAssistMan = (uiAssistMan *) g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST);
    if( pAssistMan  && rItemFromSlot.IsContainValidItem())
    {
        pAssistMan->ShowAskRiderWaxGlossDialog(rItemFromSlot.GetCode(), AtPos, GetPendingUseChargeItemPos());
    }

    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    return TRUE;
}


#ifdef _NA_0_20111012_ITEM_DATE_EXTEND
void MouseHandler::ExtendItemDateTransction( const POSTYPE& TargetPosition )
{
    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    RollbackItemAtHand();
    ItemManager::Instance()->SendExtendItemDate( m_UseWasteItemPosition, TargetPosition );
}

#endif//_NA_0_20111012_ITEM_DATE_EXTEND

#ifdef _NA_003740_20111122_RANDOM_ITEM
void MouseHandler::RandomizeTransction( const POSTYPE& TargetPosition )
{
    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    RollbackItemAtHand();
    ItemManager::Instance()->SendRandomizeItem( m_RandomizeItemPosition, TargetPosition );
}

#endif//_NA_003740_20111122_RANDOM_ITEM



//--------------------------------------------------------------------------------------------------
/** ¿¡Å׸®¾Æ ÃßÃâÀ̺¥Æ®
*/
bool MouseHandler::ItemEtheriaExtractTransction(POSTYPE slot_pos)
{
    CastDialog* cast_dlg = (CastDialog*)g_InterfaceManager.GetDialog(InterfaceManager::DIALOG_CASTING);   

  
    if(cast_dlg && cast_dlg->IsVisible() && cast_dlg->GetCastType() == CastDialog::DO_Etheria)
    {
        //ÀÌ¹Ì Çϳª°¡ ó¸® µÇ°í ÀÖÀ½À¸·Î ´Ù¸¥°ÍÀ» ÀÛ¾÷ÇÏÁö ¾Ê´Â´Ù.
        //Å°°¡ ¿¹¾àµÈ°Í Ãë¼Ò½ÃÅ´
        GlobalFunc::DoEtheriaExtract(0,0);
        return false;
    }

    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);
    RollbackItemAtHand();

    //¿¡Å׸®¾Æ ¾×¼ÇÈÄŬ¸¯ÈÄ ¸¶¿ì½ºÄ¿¼­ ÃßÃâ»óÅ¿¡¼­ ¾ÆÀÌÅÛ Å¬¸¯½Ã
    //Ŭ¶ó -> ¼­¹ö·Î °£´ÜÇÑ Ã¼Å©(ÃßÃâºÒ°¡¾ÆÀÌÅ۽ĺ°)ÈÄ ÆÐŶÀ» º¸³¿
    POSTYPE use_pos = GetPendingUseChargeItemPos();

    if (ItemManager::Instance()->IsInvalidEtheriaExtract(slot_pos, use_pos) == false)
    {
        return false;
    }

    SCSlotContainer* container = ItemManager::Instance()->GetContainer(SI_INVENTORY);
    if (container == NULL)
    {
        return false;
        
    }
    SCItemSlot& use_slot = static_cast<SCItemSlot&>(container->GetSlot(use_pos));
    if (use_slot.IsContainValidItem() == FALSE)
    {
        return false;
    }
    
    uiAssistMan* assist_man = static_cast<uiAssistMan*>(
                                      g_InterfaceManager.GetUserInterfaceManager(UIMAN_ASSIST));  
    if (assist_man == NULL)
    {
        return false;
    }

    assist_man->ShowAskItemCustomize(use_slot.GetItemInfo()->m_byWasteType, slot_pos, use_pos);
    return true;
}
//--------------------------------------------------------------------------------------------------
/** ¿¡Å׸®¾Æ Á¶ÇÕÀ̺¥Æ®
*/
bool MouseHandler::ItemEtheriaCombinationTransction(SLOTIDX slot_index, POSTYPE to_pos)
{
    MouseHandler::Instance()->SetMouseState(MouseHandler::NONE);

    SCSlotContainer* container_ptr = ItemManager::Instance()->GetContainer(slot_index);
   
    if (container_ptr == NULL)
    {
        return false;
    }
    
    SCItemSlot& to_slot = (SCItemSlot &)container_ptr->GetSlot(to_pos);
    SCItemSlot& from_slot = (SCItemSlot &)container_ptr->GetSlot(GetPendingUseChargeItemPos());

    if (GetPendingUseChargeItemPos() == to_pos)
    {
        return false;
    }

    // ºó½½·ÔÀÎÁö üũ
    if (container_ptr->IsEmpty(to_pos))
    {
        //	ÇØ´ç ½½·ÔÀÌ ºñ¾îÀÖ½À´Ï´Ù!
        TCHAR message[INTERFACE_STRING_LENGTH] ={0,};
        g_InterfaceManager.GetInterfaceString( eST_TARGET_SLOT_IS_EMPTY, message, INTERFACE_STRING_LENGTH );
        GlobalFunc::OutputMsg_Notice(eOUTPUT_MSG_CHAT, message );
        return false;
    }
    // form½½·ÔÀº ¹Ýµå½Ã ¿¡Å׸®¾î¾ßÇÑ´Ù
    if (from_slot.IsContainValidItem() == FALSE ||
        from_slot.IsEtheriaItem() == false)
    {
        return false;
    }

	SCItemSlot temp_slot(to_slot);
	RC::eITEM_RESULT result = temp_slot.CombineWithEtheria(from_slot);

	if (result != RC_ITEM_SUCCESS)
	{
		ItemManager::Instance()->NoticeReasonItemErrorCode(result);
		return false;
	}

	return true;
}
//--------------------------------------------------------------------------------------------------
/** ¿¡Å׸®¾Æ ÃßÃâ ¸ÁÄ¡¶ß±â
*/
void MouseHandler::SetEtheriaExtractState()
{
    RollbackItemAtHand();
    SetMouseState(MouseHandler::ETHERIA_EXTRACT);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair);
    keyMsg msg;
    ZeroMemory(&msg,sizeof(msg));
    msg.dwType = eDoType_Etheria_Extract;				
    msg.DoSomething = GlobalFunc::DoEtheriaExtract;
    g_KeyQueueManager.PushBack(msg);
}

#ifdef _NA_0_20111012_ITEM_DATE_EXTEND
//--------------------------------------------------------------------------------------------------
/** ¼Òºñ ¾ÆÀÌÅÛ »ç¿ë
´Ù¸¥ ¾ÆÀÌÅÛÀ» Ÿ°ÙÀ» °¡Áö´Â ¼Òºñ¾ÆÀÌÅÛÀÇ »ç¿ë
*/
void MouseHandler::SetUseExtendItemDateMode( const POSTYPE& ItemPosition )
{
    m_UseWasteItemPosition = ItemPosition;

    RollbackItemAtHand();
    SetMouseState(MouseHandler::EXTEND_ITEMDATE);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair);
    keyMsg msg;
    ZeroMemory(&msg,sizeof(msg));
    msg.dwType = eDoType_Extend_ItemDate;				
    msg.DoSomething = GlobalFunc::DoExtendItemDate;
    g_KeyQueueManager.PushBack(msg);
}
#endif//_NA_0_20111012_ITEM_DATE_EXTEND

#ifdef _NA_003740_20111122_RANDOM_ITEM

void MouseHandler::SetRandomizeItemMode( const POSTYPE& ItemPosition )
{
    m_RandomizeItemPosition = ItemPosition;

    RollbackItemAtHand();
    SetMouseState(MouseHandler::RANDOMIZE_ITEM);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Repair);
    keyMsg msg;
    ZeroMemory(&msg,sizeof(msg));
    msg.dwType = eDoType_Randomize_Item;				
    msg.DoSomething = GlobalFunc::DoRandomizeItem;
    g_KeyQueueManager.PushBack(msg);


    SCItemSlotContainer* inventory = (SCItemSlotContainer*)g_pHero->GetSlotContainer( SI_INVENTORY );
    SCItemSlot& source_item = (SCItemSlot&)inventory->GetSlot(ItemPosition);

    TCHAR source_name[MAX_ITEMNAME_LENGTH];
    g_InterfaceManager.GetItemName( source_item.GetItemCode(), source_name, MAX_ITEMNAME_LENGTH );

    // 70581 [%s] ±â´ÉÀ» »ç¿ëÇÒ ¾ÆÀÌÅÛÀ» ¼±ÅÃÇØÁÖ¼¼¿ä.
    TCHAR message[INTERFACE_STRING_LENGTH];
    g_InterfaceManager.GetInterfaceString(70581, message, INTERFACE_STRING_LENGTH);



    TCHAR buffer[INTERFACE_STRING_LENGTH];
    wsprintf( buffer, message, source_name );
    GlobalFunc::OutputMsg_SysMsg(buffer);

}
#endif//_NA_003740_20111122_RANDOM_ITEM


//--------------------------------------------------------------------------------------------------
/**  ¹ÌÈ®ÀÎ ¼ÒÄÏ È®ÀÎ ¸ÁÄ¡¶ß±â
*/
void MouseHandler::SetSocketIdentifyState()
{
    RollbackItemAtHand();
    SetMouseState(MouseHandler::SOCKET_IDENTIFY);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
    keyMsg msg;
    ZeroMemory(&msg,sizeof(msg));
    msg.dwType = eDoType_SocketIdentify;				
    msg.DoSomething = GlobalFunc::DoSocketIdentify;
    g_KeyQueueManager.PushBack(msg);
}
//--------------------------------------------------------------------------------------------------
/**  °áÁ¤È­ ¸ÁÄ¡¶ß±â
*/
void MouseHandler::SetCrystalizationState()
{
    RollbackItemAtHand();
    SetMouseState(MouseHandler::CRYSTALIZATION);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
    keyMsg msg;
    ZeroMemory(&msg, sizeof(msg));
    msg.dwType = eDoType_Crystalization;
    msg.DoSomething = GlobalFunc::DoCrystalization;
    g_KeyQueueManager.PushBack(msg);
}
//--------------------------------------------------------------------------------------------------
/**  Ç츣¸Þ½ÃÁòÀÇ ¼º¼­
*/
void MouseHandler::SetRecreateSocketState()
{
    RollbackItemAtHand();
    SetMouseState(MouseHandler::SOCKET_RECREATE);
    CursorChangeTransact::Instance()->ChangeTranaction(MouseCursor::eMouseCursor_Composite);
    keyMsg msg;
    ZeroMemory(&msg,sizeof(msg));
    msg.dwType = eDoType_SocketRecreate;				
    msg.DoSomething = GlobalFunc::DoSocketRecreate;
    g_KeyQueueManager.PushBack(msg);
}

void MouseHandler::SetCharCustomizeDlg(WORD item_type, POSTYPE slot_pos)
{

    uiCharCustomizeDlg* custom_dlg = GET_CAST_DIALOG(uiCharCustomizeDlg,
        IM_CHAR_CUSTOMIZE_MGR::CHAR_CUSTOMIZE_DLG);

    if (custom_dlg == NULL)
    {
        return;
    }

    if (custom_dlg->IsVisibleWindow())
    {
        return;
    }

    custom_dlg->GenerateCustomInfo(item_type, slot_pos);
    custom_dlg->ShowInterface(TRUE);
}

void MouseHandler::SetDivideItemOff()
{
	if (m_MouseItem.m_pRenderUnit != NULL)
	{
		m_MouseItem.m_pRenderUnit->m_isDiv = false;
	}
}