Jump to content

.Zero.

Inactive Member
 View Profile  See their activity

  • Posts

    22

  • Joined

  • Last visited

  • Feedback

    0%

 Content Type 

Forums

Store

Third Party - Providers Directory

Feature Plan

Release Notes

Docs

Events

Posts posted by .Zero.

    Sash Item_scale Client Error

    in Community Support - Questions & Answers

    Posted

    Hi Everyone

    i've added the new sash system to my client

    witch have the official item_scale

    but i have one little problem

    when i compile the binary 

    i got this one error Capture.thumb.JPG.4197b6e7537f3ccb502a974ca8b71b47.JPG

    this is my PythonSlotWindow.cpp

    Spoiler

    #include "StdAfx.h"
    #include "../eterBase/CRC32.h"
    #include "../eterBase/Filename.h"
    #include "PythonWindow.h"
    #include "PythonSlotWindow.h"

    //#define __RENDER_SLOT_AREA__

    using namespace UI;

    class UI::CSlotWindow::CSlotButton : public CButton
    {
        public:
            enum ESlotButtonType
            {
                SLOT_BUTTON_TYPE_PLUS,
                SLOT_BUTTON_TYPE_COVER,
            };

        public:
            CSlotButton(ESlotButtonType dwType, DWORD dwSlotNumber, CSlotWindow * pParent) : CButton(NULL)
            {
                m_dwSlotButtonType = dwType;
                m_dwSlotNumber = dwSlotNumber;
                m_pParent = pParent;
            }
            virtual ~CSlotButton()
            {
            }

            BOOL OnMouseLeftButtonDown()
            {
                if (!IsEnable())
                    return TRUE;
                if (UI::CWindowManager::Instance().IsAttaching())
                    return TRUE;

                m_isPressed = TRUE;
                Down();

                return TRUE;
            }
            BOOL OnMouseLeftButtonUp()
            {
                if (!IsEnable())
                    return TRUE;
                if (!IsPressed())
                    return TRUE;

                if (IsIn())
                    SetCurrentVisual(&m_overVisual);
                else
                    SetCurrentVisual(&m_upVisual);

                m_pParent->OnPressedSlotButton(m_dwSlotButtonType, m_dwSlotNumber);

                return TRUE;
            }

            void OnMouseOverIn()
            {
                if (IsEnable())
                {
                    SetCurrentVisual(&m_overVisual);
                }
                m_pParent->OnOverInItem(m_dwSlotNumber);
            }
            void OnMouseOverOut()
            {
                if (IsEnable())
                {
                    SetUp();
                    SetCurrentVisual(&m_upVisual);
                }
                m_pParent->OnOverOutItem();
            }

        protected:
            ESlotButtonType m_dwSlotButtonType;
            DWORD m_dwSlotNumber;
            CSlotWindow * m_pParent;
    };

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

    class UI::CSlotWindow::CCoverButton : public CSlotButton
    {
        public:
            CCoverButton(ESlotButtonType dwType, DWORD dwSlotNumber, CSlotWindow * pParent) : CSlotButton(dwType, dwSlotNumber, pParent)
            {
                m_bLeftButtonEnable = TRUE;
                m_bRightButtonEnable = TRUE;
            }
            virtual ~CCoverButton()
            {
            }

            void SetLeftButtonEnable(BOOL bEnable)
            {
                m_bLeftButtonEnable = bEnable;
            }
            void SetRightButtonEnable(BOOL bEnable)
            {
                m_bRightButtonEnable = bEnable;
            }

            void OnRender()
            {
            }

            void RenderButton()
            {
                CButton::OnRender();
            }

            BOOL OnMouseLeftButtonDown()
            {
                if (!IsEnable())
                    return TRUE;
                if (m_bLeftButtonEnable)
                {
                    CButton::OnMouseLeftButtonDown();
                }
                else
                {
                    m_pParent->OnMouseLeftButtonDown();
                }
                return TRUE;
            }
            BOOL OnMouseLeftButtonUp()
            {
                if (!IsEnable())
                    return TRUE;
                if (m_bLeftButtonEnable)
                {
                    CButton::OnMouseLeftButtonUp();
                    m_pParent->OnMouseLeftButtonDown();
                }
                else
                {
                    m_pParent->OnMouseLeftButtonUp();
                }
                return TRUE;
            }

            BOOL OnMouseRightButtonDown()
            {
                if (!IsEnable())
                    return TRUE;
                if (m_bRightButtonEnable)
                    CButton::OnMouseLeftButtonDown();
                return TRUE;
            }
            BOOL OnMouseRightButtonUp()
            {
                if (!IsEnable())
                    return TRUE;
                m_pParent->OnMouseRightButtonDown();
                if (m_bRightButtonEnable)
                    CButton::OnMouseLeftButtonUp();
                return TRUE;
            }

        protected:
            BOOL m_bLeftButtonEnable;
            BOOL m_bRightButtonEnable;
    };

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

    class UI::CSlotWindow::CCoolTimeFinishEffect : public CAniImageBox
    {
        public:
            CCoolTimeFinishEffect(CSlotWindow * pParent, DWORD dwSlotIndex) : CAniImageBox(NULL)
            {
                m_pParent = pParent;
                m_dwSlotIndex = dwSlotIndex;
            }
            virtual ~CCoolTimeFinishEffect()
            {
            }

            void OnEndFrame()
            {
                ((CSlotWindow *)m_pParent)->ReserveDestroyCoolTimeFinishEffect(m_dwSlotIndex);
            }

        protected:
            DWORD m_dwSlotIndex;
    };

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

    // Set & Append

    void CSlotWindow::SetSlotType(DWORD dwType)
    {
        m_dwSlotType = dwType;
    }

    void CSlotWindow::SetSlotStyle(DWORD dwStyle)
    {
        m_dwSlotStyle = dwStyle;
    }

    void CSlotWindow::AppendSlot(DWORD dwIndex, int ixPosition, int iyPosition, int ixCellSize, int iyCellSize)
    {
        TSlot Slot;
        Slot.pInstance = NULL;
        Slot.pNumberLine = NULL;
        Slot.pCoverButton = NULL;
        Slot.pSlotButton = NULL;
        Slot.pSignImage = NULL;
        Slot.pFinishCoolTimeEffect = NULL;
    #ifdef ENABLE_SASH_SYSTEM
        for (int i = 0; i < 3; ++i)
        {
            Slot.pActiveSlotEffect = NULL;
        }
    #endif

        ClearSlot(&Slot);
        Slot.dwSlotNumber = dwIndex;
        Slot.dwCenterSlotNumber = dwIndex;
        Slot.ixPosition = ixPosition;
        Slot.iyPosition = iyPosition;
        Slot.ixCellSize = ixCellSize;
        Slot.iyCellSize = iyCellSize;
        m_SlotList.push_back(Slot);
    }

    void CSlotWindow::SetCoverButton(DWORD dwIndex, const char * c_szUpImageName, const char * c_szOverImageName, const char * c_szDownImageName, const char * c_szDisableImageName, BOOL bLeftButtonEnable, BOOL bRightButtonEnable)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        CCoverButton *& rpCoverButton = pSlot->pCoverButton;

        if (!rpCoverButton)
        {
            rpCoverButton = new CCoverButton(CSlotButton::SLOT_BUTTON_TYPE_COVER, pSlot->dwSlotNumber, this);
            CWindowManager::Instance().SetParent(rpCoverButton, this);
        }

        rpCoverButton->SetLeftButtonEnable(bLeftButtonEnable);
        rpCoverButton->SetRightButtonEnable(bRightButtonEnable);
        rpCoverButton->SetUpVisual(c_szUpImageName);
        rpCoverButton->SetOverVisual(c_szOverImageName);
        rpCoverButton->SetDownVisual(c_szDownImageName);
        rpCoverButton->SetDisableVisual(c_szDisableImageName);
        rpCoverButton->Enable();
        rpCoverButton->Show();

        // NOTE : Cover 버튼이 Plus 버튼을 가려버려서 임시 코드를..
        if (pSlot->pSlotButton)
        {
            SetTop(pSlot->pSlotButton);
        }
    }

    void CSlotWindow::EnableCoverButton(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (!pSlot->pCoverButton)
            return;

        pSlot->pCoverButton->Enable();
    }

    void CSlotWindow::DisableCoverButton(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (!pSlot->pCoverButton)
            return;

        pSlot->pCoverButton->Disable();
    }

    void CSlotWindow::SetAlwaysRenderCoverButton(DWORD dwIndex, bool bAlwaysRender)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (bAlwaysRender)
            SET_BIT(pSlot->dwState, SLOT_STATE_ALWAYS_RENDER_COVER);
        else
            REMOVE_BIT(pSlot->dwState, SLOT_STATE_ALWAYS_RENDER_COVER);
    }

    void CSlotWindow::ShowSlotBaseImage(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->bRenderBaseSlotImage = true;
    }

    void CSlotWindow::HideSlotBaseImage(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->bRenderBaseSlotImage = false;
    }

    BOOL CSlotWindow::IsDisableCoverButton(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return FALSE;

        if (!pSlot->pCoverButton)
            return FALSE;

        return pSlot->pCoverButton->IsDisable();
    }

    void CSlotWindow::SetSlotBaseImage(const char * c_szFileName, float fr, float fg, float fb, float fa)
    {
        __CreateBaseImage(c_szFileName, fr, fg, fb, fa);
    }

    void CSlotWindow::SetSlotBaseImageScale(const char * c_szFileName, float fr, float fg, float fb, float fa, float sx, float sy)
    {
        __CreateBaseImageScale(c_szFileName, fr, fg, fb, fa, sx, sy);
    }

    void CSlotWindow::AppendSlotButton(const char * c_szUpImageName, const char * c_szOverImageName, const char * c_szDownImageName)
    {
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;
            CSlotButton *& rpSlotButton = rSlot.pSlotButton;

            if (!rpSlotButton)
            {
                rpSlotButton = new CSlotButton(CSlotButton::SLOT_BUTTON_TYPE_PLUS, rSlot.dwSlotNumber, this);
                rpSlotButton->AddFlag(FLAG_FLOAT);
                CWindowManager::Instance().SetParent(rpSlotButton, this);
            }

            rpSlotButton->SetUpVisual(c_szUpImageName);
            rpSlotButton->SetOverVisual(c_szOverImageName);
            rpSlotButton->SetDownVisual(c_szDownImageName);
            rpSlotButton->SetPosition(rSlot.ixPosition + 1, rSlot.iyPosition + 19);
            rpSlotButton->Hide();
        }
    }

    void CSlotWindow::AppendRequirementSignImage(const char * c_szImageName)
    {
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;
            CImageBox *& rpSignImage = rSlot.pSignImage;

            if (!rpSignImage)
            {
                rpSignImage = new CImageBox(NULL);
                CWindowManager::Instance().SetParent(rpSignImage, this);
            }

            rpSignImage->LoadImage(c_szImageName);
            rpSignImage->Hide();
        }
    }

    BOOL CSlotWindow::HasSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return FALSE;

        return TRUE;
    }

    void CSlotWindow::SetSlot(DWORD dwIndex, DWORD dwVirtualNumber, BYTE byWidth, BYTE byHeight, CGraphicImage * pImage, D3DXCOLOR& diffuseColor)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (pSlot->isItem)
        if (pSlot->dwItemIndex == dwVirtualNumber)
        {
            pSlot->dwState = 0;
            pSlot->isItem = TRUE;
            if (pImage && pSlot->pInstance)
            {
                pSlot->pInstance->SetImagePointer(pImage);
            }
            return;
        }

        ClearSlot(pSlot);
        pSlot->dwState = 0;
        pSlot->isItem = TRUE;
        pSlot->dwItemIndex = dwVirtualNumber;

        if (pImage)
        {
            assert(NULL == pSlot->pInstance);
            pSlot->pInstance = CGraphicImageInstance::New();
            pSlot->pInstance->SetDiffuseColor(diffuseColor.r, diffuseColor.g, diffuseColor.b, diffuseColor.a);
            pSlot->pInstance->SetImagePointer(pImage);
        }

        pSlot->byxPlacedItemSize = byWidth;
        pSlot->byyPlacedItemSize = byHeight;

        if (pSlot->pCoverButton)
        {
            pSlot->pCoverButton->Show();
        }
    }

    void CSlotWindow::SetSlotScale(DWORD dwIndex, DWORD dwVirtualNumber, BYTE byWidth, BYTE byHeight, CGraphicImage * pImage, float sx, float sy, D3DXCOLOR& diffuseColor)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (pSlot->isItem)
            if (pSlot->dwItemIndex == dwVirtualNumber)
            {
                pSlot->dwState = 0;
                pSlot->isItem = TRUE;
                if (pImage && pSlot->pInstance)
                {
                    pSlot->pInstance->SetImagePointer(pImage);
                }
                return;
            }

        ClearSlot(pSlot);
        pSlot->dwState = 0;
        pSlot->isItem = TRUE;
        pSlot->dwItemIndex = dwVirtualNumber;

        if (pImage)
        {
            assert(NULL == pSlot->pInstance);
            pSlot->pInstance = CGraphicImageInstance::New();
            pSlot->pInstance->SetDiffuseColor(diffuseColor.r, diffuseColor.g, diffuseColor.b, diffuseColor.a);
            pSlot->pInstance->SetImagePointer(pImage);
            pSlot->pInstance->SetScale(sx, sy);
        }

        pSlot->byxPlacedItemSize = byWidth;
        pSlot->byyPlacedItemSize = byHeight;

        if (pSlot->pCoverButton)
        {
            pSlot->pCoverButton->Show();
        }
    }

    void CSlotWindow::SetSlotCount(DWORD dwIndex, DWORD dwCount)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (dwCount <= 0)
        {
            if (pSlot->pNumberLine)
            {
                delete pSlot->pNumberLine;
                pSlot->pNumberLine = NULL;
            }
        }
        else
        {
            char szCount[16+1];
            _snprintf(szCount, sizeof(szCount), "%d", dwCount);

            if (!pSlot->pNumberLine)
            {
                CNumberLine * pNumberLine = new UI::CNumberLine(this);
                pNumberLine->SetHorizontalAlign(CNumberLine::HORIZONTAL_ALIGN_RIGHT);
                pNumberLine->Show();
                pSlot->pNumberLine = pNumberLine;
            }

            pSlot->pNumberLine->SetNumber(szCount);
        }
    }

    void CSlotWindow::SetSlotCountNew(DWORD dwIndex, DWORD dwGrade, DWORD dwCount)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        if (dwCount <= 0)
        {
            if (pSlot->pNumberLine)
            {
                delete pSlot->pNumberLine;
                pSlot->pNumberLine = NULL;
            }
        }
        else
        {
            char szCount[16+1];

            switch (dwGrade)
            {
                case 0:
                    _snprintf(szCount, sizeof(szCount), "%d", dwCount);
                    break;
                case 1:
                    _snprintf(szCount, sizeof(szCount), "m%d", dwCount);
                    break;
                case 2:
                    _snprintf(szCount, sizeof(szCount), "g%d", dwCount);
                    break;
                case 3:
    #ifdef ENABLE_SKILLS_LEVEL_OVER_P
                    _snprintf(szCount, sizeof(szCount), "p%d", dwCount);
    #else
                    _snprintf(szCount, sizeof(szCount), "p");
    #endif
                    break;
    #ifdef ENABLE_SKILLS_LEVEL_OVER_P
                case 4:
                    _snprintf(szCount, sizeof(szCount), "s");
                    break;
    #endif
            }

            if (!pSlot->pNumberLine)
            {
                CNumberLine * pNumberLine = new UI::CNumberLine(this);
                pNumberLine->SetHorizontalAlign(CNumberLine::HORIZONTAL_ALIGN_RIGHT);
                pNumberLine->Show();
                pSlot->pNumberLine = pNumberLine;
            }

            pSlot->pNumberLine->SetNumber(szCount);
        }
    }

    void CSlotWindow::SetSlotCoolTime(DWORD dwIndex, float fCoolTime, float fElapsedTime)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->fCoolTime = fCoolTime;
        pSlot->fStartCoolTime = CTimer::Instance().GetCurrentSecond() - fElapsedTime;
    }

    void CSlotWindow::ActivateSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->bActive = TRUE;

        if (!m_pSlotActiveEffect)
        {
            __CreateSlotEnableEffect();
        }
    }

    void CSlotWindow::DeactivateSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->bActive = FALSE;
    }

    void CSlotWindow::ClearSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        ClearSlot(pSlot);
    }

    void CSlotWindow::ClearSlot(TSlot * pSlot)
    {
        pSlot->bActive = FALSE;
        pSlot->byxPlacedItemSize = 1;
        pSlot->byyPlacedItemSize = 1;

        pSlot->isItem = FALSE;
        pSlot->dwState = 0;
        pSlot->fCoolTime = 0.0f;
        pSlot->fStartCoolTime = 0.0f;
        pSlot->dwCenterSlotNumber = 0xffffffff;

        pSlot->dwItemIndex = 0;
        pSlot->bRenderBaseSlotImage = true;

        if (pSlot->pInstance)
        {
            CGraphicImageInstance::Delete(pSlot->pInstance);
            pSlot->pInstance = NULL;
        }
        if (pSlot->pCoverButton)
        {
            pSlot->pCoverButton->Hide();
        }
        if (pSlot->pSlotButton)
        {
            pSlot->pSlotButton->Hide();
        }
        if (pSlot->pSignImage)
        {
             pSlot->pSignImage->Hide();
        }
        if (pSlot->pFinishCoolTimeEffect)
        {
            pSlot->pFinishCoolTimeEffect->Hide();
        }
    #ifdef ENABLE_SASH_SYSTEM
        for (int i = 0; i < 3; ++i)
        {
            if (pSlot->pActiveSlotEffect)
                pSlot->pActiveSlotEffect->Hide();
        }
    #endif
    }

    void CSlotWindow::ClearAllSlot()
    {
        Destroy();
    }

    void CSlotWindow::RefreshSlot()
    {
        OnRefreshSlot();

        // NOTE : Refresh 될때 ToolTip 도 갱신 합니다 - [levites]
        if (IsRendering())
        {
            TSlot * pSlot;
            if (GetPickedSlotPointer(&pSlot))
            {
                OnOverOutItem();
                OnOverInItem(pSlot->dwSlotNumber);
            }
        }
    }

    void CSlotWindow::OnRefreshSlot()
    {
    }

    DWORD CSlotWindow::GetSlotCount()
    {
        return m_SlotList.size();
    }

    void CSlotWindow::LockSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->dwState |= SLOT_STATE_LOCK;
    }
    void CSlotWindow::UnlockSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->dwState ^= SLOT_STATE_LOCK;
    }
    void CSlotWindow::SetCantUseSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->dwState |= SLOT_STATE_CANT_USE;
    }
    void CSlotWindow::SetUseSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        pSlot->dwState ^= SLOT_STATE_CANT_USE;
    }
    void CSlotWindow::EnableSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;

        REMOVE_BIT(pSlot->dwState, SLOT_STATE_DISABLE);
        //pSlot->dwState |= SLOT_STATE_DISABLE;
    }
    void CSlotWindow::DisableSlot(DWORD dwIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwIndex, &pSlot))
            return;
        SET_BIT(pSlot->dwState, SLOT_STATE_DISABLE);
        //pSlot->dwState ^= SLOT_STATE_DISABLE;
    }

    // Select

    void CSlotWindow::SetUnusableSlot(DWORD dwIndex)
    {
     TSlot * pSlot;
     if (!GetSlotPointer(dwIndex, &pSlot))
      return;
     
     
     
     SET_BIT(pSlot->dwState, SLOT_STATE_UNUSABLE);
     //pSlot->dwState |= SLOT_STATE_UNUSABLE;
    }

    void CSlotWindow::SetUsableSlot(DWORD dwIndex)
    {
     TSlot * pSlot;
     if (!GetSlotPointer(dwIndex, &pSlot))
      return;
     REMOVE_BIT(pSlot->dwState, SLOT_STATE_UNUSABLE);
     //pSlot->dwState ^= SLOT_STATE_UNUSABLE;
    }

    void CSlotWindow::SelectSlot(DWORD dwSelectingIndex)
    {
        std::list<DWORD>::iterator itor = m_dwSelectedSlotIndexList.begin();
        for (; itor != m_dwSelectedSlotIndexList.end();)
        {
            if (dwSelectingIndex == *itor)
            {
                itor = m_dwSelectedSlotIndexList.erase(itor);
                return;
            }
            else
            {
                ++itor;
            }
        }

        TSlot * pSlot;
        if (GetSlotPointer(dwSelectingIndex, &pSlot))
        {
            if (!pSlot->isItem)
                return;

            m_dwSelectedSlotIndexList.push_back(dwSelectingIndex);
        }
    }

    BOOL CSlotWindow::isSelectedSlot(DWORD dwIndex)
    {
        std::list<DWORD>::iterator itor = m_dwSelectedSlotIndexList.begin();
        for (; itor != m_dwSelectedSlotIndexList.end(); ++itor)
        {
            if (dwIndex == *itor)
                return TRUE;
        }

        return FALSE;
    }

    void CSlotWindow::ClearSelected()
    {
        m_dwSelectedSlotIndexList.clear();
    }

    DWORD CSlotWindow::GetSelectedSlotCount()
    {
        return m_dwSelectedSlotIndexList.size();
    }

    DWORD CSlotWindow::GetSelectedSlotNumber(DWORD dwIndex)
    {
        if (dwIndex >= m_dwSelectedSlotIndexList.size())
            return DWORD(-1);

        DWORD dwCount = 0;
        std::list<DWORD>::iterator itor = m_dwSelectedSlotIndexList.begin();
        for (; itor != m_dwSelectedSlotIndexList.end(); ++itor)
        {
            if (dwIndex == dwCount)
                break;

            ++dwCount;
        }

        return *itor;
    }

    void CSlotWindow::ShowSlotButton(DWORD dwSlotNumber)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotNumber, &pSlot))
            return;

        if (pSlot->pSlotButton)
        {
            pSlot->pSlotButton->Show();
        }
    }

    void CSlotWindow::HideAllSlotButton()
    {
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (rSlot.pSlotButton)
            {
                rSlot.pSlotButton->Hide();
            }
        }
    }

    void CSlotWindow::ShowRequirementSign(DWORD dwSlotNumber)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotNumber, &pSlot))
            return;

        if (!pSlot->pSignImage)
            return;

        pSlot->pSignImage->Show();
    }

    void CSlotWindow::HideRequirementSign(DWORD dwSlotNumber)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotNumber, &pSlot))
            return;

        if (!pSlot->pSignImage)
            return;

        pSlot->pSignImage->Hide();
    }

    // Event

    BOOL CSlotWindow::OnMouseLeftButtonDown()
    {
        TSlot * pSlot;
        if (!GetPickedSlotPointer(&pSlot))
        {
            UI::CWindowManager::Instance().DeattachIcon();
            return TRUE;
        }

        if (pSlot->isItem && !(pSlot->dwState & SLOT_STATE_LOCK))
        {
            OnSelectItemSlot(pSlot->dwSlotNumber);
        }
        else
        {
            OnSelectEmptySlot(pSlot->dwSlotNumber);
        }

        return TRUE;
    }

    BOOL CSlotWindow::OnMouseLeftButtonUp()
    {
        if (UI::CWindowManager::Instance().IsAttaching())
        if (UI::CWindowManager::Instance().IsDragging())
        if (IsIn())
        {
            UI::CWindow * pWin = UI::CWindowManager::Instance().GetPointWindow();

            if (pWin)
            if (pWin->IsType(UI::CSlotWindow::Type()))
            {
                UI::CSlotWindow * pSlotWin = (UI::CSlotWindow *)pWin;

                TSlot * pSlot;
                if (!pSlotWin->GetPickedSlotPointer(&pSlot))
                {
                    UI::CWindowManager::Instance().DeattachIcon();
                    return TRUE;
                }

                if (pSlot->isItem)
                    pSlotWin->OnSelectItemSlot(pSlot->dwSlotNumber);
                else
                    pSlotWin->OnSelectEmptySlot(pSlot->dwSlotNumber);

                return TRUE;
            }

            return FALSE;
        }

        return FALSE;
    }

    BOOL CSlotWindow::OnMouseRightButtonDown()
    {
        TSlot * pSlot;
        if (!GetPickedSlotPointer(&pSlot))
            return TRUE;

        if (pSlot->isItem)
        {
            OnUnselectItemSlot(pSlot->dwSlotNumber);
        }
        else
        {
            OnUnselectEmptySlot(pSlot->dwSlotNumber);
        }

        return TRUE;
    }

    BOOL CSlotWindow::OnMouseLeftButtonDoubleClick()
    {
        OnUseSlot();

        return TRUE;
    }

    void CSlotWindow::OnMouseOverOut()
    {
        OnOverOutItem();
    }

    void CSlotWindow::OnMouseOver()
    {
        // FIXME : 윈도우를 드래깅 하는 도중에 SetTop이 되어버리면 Capture가 풀어져 버린다. 그것의 방지 코드.
        //         좀 더 근본적인 해결책을 찾아야 할 듯 - [levites]
    //    if (UI::CWindowManager::Instance().IsCapture())
    //    if (!UI::CWindowManager::Instance().IsAttaching())
    //        return;

        CWindow * pPointWindow = UI::CWindowManager::Instance().GetPointWindow();
        if (this == pPointWindow)
        {
            TSlot * pSlot;
            if (GetPickedSlotPointer(&pSlot))
            {
                if (OnOverInItem(pSlot->dwSlotNumber))
                    return;
            }
        }

        OnOverOutItem();
    }

    void CSlotWindow::OnSelectEmptySlot(int iSlotNumber)
    {
        PyCallClassMemberFunc(m_poHandler, "OnSelectEmptySlot", Py_BuildValue("(i)", iSlotNumber));
    }
    void CSlotWindow::OnSelectItemSlot(int iSlotNumber)
    {
    //    OnOverOutItem();
        PyCallClassMemberFunc(m_poHandler, "OnSelectItemSlot", Py_BuildValue("(i)", iSlotNumber));

        if (UI::CWindowManager::Instance().IsAttaching())
            OnOverOutItem();
    }
    void CSlotWindow::OnUnselectEmptySlot(int iSlotNumber)
    {
        PyCallClassMemberFunc(m_poHandler, "OnUnselectEmptySlot", Py_BuildValue("(i)", iSlotNumber));
    }
    void CSlotWindow::OnUnselectItemSlot(int iSlotNumber)
    {
        PyCallClassMemberFunc(m_poHandler, "OnUnselectItemSlot", Py_BuildValue("(i)", iSlotNumber));
    }
    void CSlotWindow::OnUseSlot()
    {
        TSlot * pSlot;
        if (GetPickedSlotPointer(&pSlot))
        if (pSlot->isItem)
        {
            PyCallClassMemberFunc(m_poHandler, "OnUseSlot", Py_BuildValue("(i)", pSlot->dwSlotNumber));
        }
    }

    BOOL CSlotWindow::OnOverInItem(DWORD dwSlotNumber)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotNumber, &pSlot))
            return FALSE;

        if (!pSlot->isItem)
            return FALSE;

        if (pSlot->dwSlotNumber == m_dwToolTipSlotNumber)
            return TRUE;

        m_dwToolTipSlotNumber = dwSlotNumber;
        PyCallClassMemberFunc(m_poHandler, "OnOverInItem", Py_BuildValue("(i)", dwSlotNumber));

        return TRUE;
    }

    void CSlotWindow::OnOverOutItem()
    {
        if (SLOT_NUMBER_NONE == m_dwToolTipSlotNumber)
            return;

        m_dwToolTipSlotNumber = SLOT_NUMBER_NONE;
        PyCallClassMemberFunc(m_poHandler, "OnOverOutItem", Py_BuildValue("()"));
    }

    void CSlotWindow::OnPressedSlotButton(DWORD dwType, DWORD dwSlotNumber, BOOL isLeft)
    {
        if (CSlotButton::SLOT_BUTTON_TYPE_PLUS == dwType)
        {
            PyCallClassMemberFunc(m_poHandler, "OnPressedSlotButton", Py_BuildValue("(i)", dwSlotNumber));
        }
        else if (CSlotButton::SLOT_BUTTON_TYPE_COVER == dwType)
        {
            if (isLeft)
            {
                OnMouseLeftButtonDown();
            }
        }
    }

    void CSlotWindow::OnUpdate()
    {
        for (std::deque<DWORD>::iterator itor = m_ReserveDestroyEffectDeque.begin(); itor != m_ReserveDestroyEffectDeque.end(); ++itor)
        {
            DWORD dwSlotIndex = *itor;
            TSlot * pSlot;
            if (!GetSlotPointer(dwSlotIndex, &pSlot))
                continue;
            
            __DestroyFinishCoolTimeEffect(pSlot);
    #ifdef ENABLE_SASH_SYSTEM
            for (int i = 0; i < 3; ++i)
            {
                if (pSlot->pActiveSlotEffect)
                {
                    delete pSlot->pActiveSlotEffect;
                    pSlot->pActiveSlotEffect = NULL;
                }
            }
    #endif
        }
        m_ReserveDestroyEffectDeque.clear();

        if (m_pSlotActiveEffect)
            m_pSlotActiveEffect->Update();
    }

    void CSlotWindow::OnRender()
    {
        RenderSlotBaseImage();

        switch (m_dwSlotStyle)
        {
            case SLOT_STYLE_PICK_UP:
                OnRenderPickingSlot();
                break;
            case SLOT_STYLE_SELECT:
                OnRenderSelectedSlot();
                break;
        }

        std::for_each(m_pChildList.begin(), m_pChildList.end(), std::void_mem_fun(&CWindow::OnRender));

        TSlotListIterator itor;

        //
        // 모든 슬롯 상자 그리기
        //////////////////////////////////////////////////////////////////////////
    #ifdef __RENDER_SLOT_AREA__
        CPythonGraphic::Instance().SetDiffuseColor(0.5f, 0.5f, 0.5f);
        for (itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;
            CPythonGraphic::Instance().RenderBox2d(m_rect.left + rSlot.ixPosition,
                                                   m_rect.top + rSlot.iyPosition,
                                                   m_rect.left + rSlot.ixPosition + rSlot.ixCellSize,
                                                   m_rect.top + rSlot.iyPosition + rSlot.iyCellSize);
        }
        CPythonGraphic::Instance().SetDiffuseColor(1.0f, 0.0f, 0.0f, 1.0f);
        CPythonGraphic::Instance().RenderBox2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom);
    #endif
        //////////////////////////////////////////////////////////////////////////

        for (itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (rSlot.pSlotButton)
            {
                rSlot.pSlotButton->SetPosition(rSlot.ixPosition + 1, rSlot.iyPosition + 19);
            }
            if (rSlot.pSignImage)
            {
                rSlot.pSignImage->SetPosition(rSlot.ixPosition - 7, rSlot.iyPosition + 10);
            }

            if (rSlot.pInstance)
            {
                rSlot.pInstance->SetPosition(m_rect.left + rSlot.ixPosition, m_rect.top + rSlot.iyPosition);
                rSlot.pInstance->Render();
            }

            if (!rSlot.isItem)
            {
                if (IS_SET(rSlot.dwState, SLOT_STATE_ALWAYS_RENDER_COVER))
                {
                    rSlot.pCoverButton->Show();
                    rSlot.pCoverButton->SetPosition(rSlot.ixPosition, rSlot.iyPosition);
                    rSlot.pCoverButton->RenderButton();
                }

                continue;
            }

            if (IS_SET(rSlot.dwState, SLOT_STATE_DISABLE))
            {
                CPythonGraphic::Instance().SetDiffuseColor(1.0f, 0.0f, 0.0f, 0.3f);
                CPythonGraphic::Instance().RenderBar2d(m_rect.left + rSlot.ixPosition,
                    m_rect.top + rSlot.iyPosition,
                    m_rect.left + rSlot.ixPosition + rSlot.ixCellSize,
                    m_rect.top + rSlot.iyPosition + rSlot.iyCellSize);
            }

            if (rSlot.fCoolTime != 0.0f)
            {
                float fcurTime = CTimer::Instance().GetCurrentSecond();
                float fPercentage = (fcurTime - rSlot.fStartCoolTime) / rSlot.fCoolTime;
                CPythonGraphic::Instance().RenderCoolTimeBox(m_rect.left + rSlot.ixPosition + 16.0f, m_rect.top + rSlot.iyPosition + 16.0f, 16.0f, fPercentage);

                if (fcurTime - rSlot.fStartCoolTime >= rSlot.fCoolTime)
                {
                    // 쿨타임이 끝난지 1초 이내라면..
                    if ((fcurTime - rSlot.fStartCoolTime) - rSlot.fCoolTime < 1.0f)
                        __CreateFinishCoolTimeEffect(&rSlot);

                    rSlot.fCoolTime = 0.0f;
                    rSlot.fStartCoolTime = 0.0f;
                }
            }

            if (rSlot.pCoverButton)
            {
                rSlot.pCoverButton->SetPosition(rSlot.ixPosition, rSlot.iyPosition);
                rSlot.pCoverButton->RenderButton();
            }

            if (rSlot.pNumberLine)
            {
                int ix = rSlot.byxPlacedItemSize*ITEM_WIDTH + rSlot.ixPosition - 4;
                int iy = rSlot.iyPosition + rSlot.byyPlacedItemSize*ITEM_HEIGHT - 12 + 2;
                rSlot.pNumberLine->SetPosition(ix, iy);
                rSlot.pNumberLine->Update();
                rSlot.pNumberLine->Render();
            }

            if (rSlot.pFinishCoolTimeEffect)
            {
                rSlot.pFinishCoolTimeEffect->SetPosition(rSlot.ixPosition, rSlot.iyPosition);
                rSlot.pFinishCoolTimeEffect->Update();
                rSlot.pFinishCoolTimeEffect->Render();
            }
            
    #ifdef ENABLE_SASH_SYSTEM
            {
                int iX = m_rect.left + rSlot.ixPosition, iY = m_rect.top + rSlot.iyPosition, iItemYSize = rSlot.byyPlacedItemSize;
                for (int i = 0; i < 3; ++i)
                {
                    if ((rSlot.pActiveSlotEffect) && (iItemYSize == i + 1))
                    {
                        rSlot.pActiveSlotEffect->Show();
                        rSlot.pActiveSlotEffect->SetPosition(iX, iY);
                        rSlot.pActiveSlotEffect->Update();
                        rSlot.pActiveSlotEffect->Render();
                    }
                }
            }
    #endif
            
            if (IS_SET(rSlot.dwState, SLOT_STATE_UNUSABLE))
            {
                CPythonGraphic::Instance().SetDiffuseColor(1.0f, 1.0f, 1.0f, 0.3f);
                CPythonGraphic::Instance().RenderBar2d(m_rect.left + rSlot.ixPosition,
                m_rect.top + rSlot.iyPosition,
                m_rect.left + rSlot.ixPosition + rSlot.byxPlacedItemSize * ITEM_WIDTH,
                m_rect.top + rSlot.iyPosition + rSlot.byyPlacedItemSize * ITEM_HEIGHT);
            }

            if (rSlot.bActive)
            if (m_pSlotActiveEffect)
            {
                int ix = m_rect.left + rSlot.ixPosition;
                int iy = m_rect.top + rSlot.iyPosition;
                m_pSlotActiveEffect->SetPosition(ix, iy);
                m_pSlotActiveEffect->Render();
            }
        }

        RenderLockedSlot();
    }

    void CSlotWindow::RenderSlotBaseImage()
    {
        if (!m_pBaseImageInstance)
            return;

        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (!rSlot.bRenderBaseSlotImage)
                continue;

            m_pBaseImageInstance->SetPosition(m_rect.left + rSlot.ixPosition, m_rect.top + rSlot.iyPosition);
            m_pBaseImageInstance->Render();
        }
    }

    void CSlotWindow::OnRenderPickingSlot()
    {
        if (!UI::CWindowManager::Instance().IsAttaching())
            return;

        TSlot * pSlot;
        if (!GetSelectedSlotPointer(&pSlot))
            return;

        CPythonGraphic::Instance().SetDiffuseColor(1.0f, 1.0f, 1.0f, 0.5f);
        CPythonGraphic::Instance().RenderBar2d(m_rect.left + pSlot->ixPosition,
                                                m_rect.top + pSlot->iyPosition,
                                                m_rect.left + pSlot->ixPosition + pSlot->ixCellSize,
                                                m_rect.top + pSlot->iyPosition + pSlot->iyCellSize);
    }

    void CSlotWindow::OnRenderSelectedSlot()
    {
        std::list<DWORD>::iterator itor = m_dwSelectedSlotIndexList.begin();
        for (; itor != m_dwSelectedSlotIndexList.end(); ++itor)
        {
            TSlot * pSlot;
            if (!GetSlotPointer(*itor, &pSlot))
                continue;

            CPythonGraphic::Instance().SetDiffuseColor(1.0f, 1.0f, 1.0f, 0.5f);
            CPythonGraphic::Instance().RenderBar2d(m_rect.left + pSlot->ixPosition,
                                                    m_rect.top + pSlot->iyPosition,
                                                    m_rect.left + pSlot->ixPosition + pSlot->ixCellSize,
                                                    m_rect.top + pSlot->iyPosition + pSlot->iyCellSize);
        }
    }

    void CSlotWindow::RenderLockedSlot()
    {
        CPythonGraphic::Instance().SetDiffuseColor(0.0f, 0.0f, 0.0f, 0.5f);
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (!rSlot.isItem)
                continue;

            if (rSlot.dwState & SLOT_STATE_LOCK)
            {
                CPythonGraphic::Instance().RenderBar2d(m_rect.left + rSlot.ixPosition,
                                                       m_rect.top  + rSlot.iyPosition,
                                                       m_rect.left + rSlot.ixPosition + rSlot.ixCellSize,
                                                       m_rect.top  + rSlot.iyPosition + rSlot.iyCellSize);
            }
        }
    }

    // Check Slot

    BOOL CSlotWindow::GetSlotPointer(DWORD dwIndex, TSlot ** ppSlot)
    {
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (dwIndex == rSlot.dwSlotNumber)
            {
                *ppSlot = &rSlot;
                return TRUE;
            }
        }

        return FALSE;
    }

    BOOL CSlotWindow::GetSelectedSlotPointer(TSlot ** ppSlot)
    {
        long lx, ly;
        GetMouseLocalPosition(lx, ly);

        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            if (lx >= rSlot.ixPosition)
            if (ly >= rSlot.iyPosition)
            if (lx <= rSlot.ixPosition + rSlot.ixCellSize)
            if (ly <= rSlot.iyPosition + rSlot.iyCellSize)
            {
                *ppSlot = &rSlot;
                return TRUE;
            }
        }

        return FALSE;
    }

    BOOL CSlotWindow::GetPickedSlotPointer(TSlot ** ppSlot)
    {
        long lx, ly;
        CWindowManager::Instance().GetMousePosition(lx, ly);

        int ixLocal = lx - m_rect.left;
        int iyLocal = ly - m_rect.top;

        // NOTE : 왼쪽 맨위 상단 한곳이 기준 이라는 점을 이용해 왼쪽 위에서부터 오른쪽 아래로
        //        차례로 검색해 감으로써 덮혀 있는 Slot은 자동 무시 된다는 특성을 이용한다. - [levites]
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            int ixCellSize = rSlot.ixCellSize;
            int iyCellSize = rSlot.iyCellSize;

            // NOTE : Item이 Hide 되어있을 경우를 위한..
            if (rSlot.isItem)
            {
                ixCellSize = max(rSlot.ixCellSize, int(rSlot.byxPlacedItemSize * ITEM_WIDTH));
                iyCellSize = max(rSlot.iyCellSize, int(rSlot.byyPlacedItemSize * ITEM_HEIGHT));
            }

            if (ixLocal >= rSlot.ixPosition)
            if (iyLocal >= rSlot.iyPosition)
            if (ixLocal <= rSlot.ixPosition + ixCellSize)
            if (iyLocal <= rSlot.iyPosition + iyCellSize)
            {
                *ppSlot = &rSlot;
                return TRUE;
            }
        }

        return FALSE;
    }

    void CSlotWindow::SetUseMode(BOOL bFlag)
    {
        m_isUseMode = bFlag;
    }

    void CSlotWindow::SetUsableItem(BOOL bFlag)
    {
        m_isUsableItem = bFlag;
    }

    void CSlotWindow::ReserveDestroyCoolTimeFinishEffect(DWORD dwSlotIndex)
    {
        m_ReserveDestroyEffectDeque.push_back(dwSlotIndex);
    }

    #ifdef ENABLE_SASH_SYSTEM
    void CSlotWindow::ActivateEffect(DWORD dwSlotIndex, float r, float g, float b, float a)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotIndex, &pSlot))
            return;
        
        for (int i = 0; i < 3; ++i)
        {
            if (pSlot->pActiveSlotEffect)
            {
                delete pSlot->pActiveSlotEffect;
                pSlot->pActiveSlotEffect = NULL;
            }
            
            CAniImageBox * pEff = new CAniImageBox(NULL);
            for (int j = 0; j <= 12; ++j)
            {
                char cBuf[72];
                sprintf_s(cBuf, "d:/ymir work/ui/public/slotactiveeffect/slot%d/%02d.sub", (i + 1), j);
                pEff->AppendImage(cBuf, r, g, b, a);
            }
            
            pEff->SetRenderingMode(CGraphicExpandedImageInstance::RENDERING_MODE_SCREEN);
            pSlot->pActiveSlotEffect = pEff;
        }
    }

    void CSlotWindow::DeactivateEffect(DWORD dwSlotIndex)
    {
        TSlot * pSlot;
        if (!GetSlotPointer(dwSlotIndex, &pSlot))
            return;
        
        for (int i = 0; i < 3; ++i)
        {
            if (pSlot->pActiveSlotEffect)
            {
                delete pSlot->pActiveSlotEffect;
                pSlot->pActiveSlotEffect = NULL;
            }
        }
    }
    #endif

    DWORD CSlotWindow::Type()
    {
        static int s_Type = GetCRC32("CSlotWindow", strlen("CSlotWindow"));
        return s_Type;
    }

    BOOL CSlotWindow::OnIsType(DWORD dwType)
    {
        if (CSlotWindow::Type() == dwType)
            return TRUE;

        return CWindow::OnIsType(dwType);
    }

    void CSlotWindow::__CreateToggleSlotImage()
    {
        __DestroyToggleSlotImage();

        m_pToggleSlotImage = new CImageBox(NULL);
        m_pToggleSlotImage->LoadImage("d:/ymir work/ui/public/slot_toggle.sub");
        m_pToggleSlotImage->Show();
    }

    void CSlotWindow::__CreateSlotEnableEffect()
    {
        __DestroySlotEnableEffect();

        m_pSlotActiveEffect = new CAniImageBox(NULL);
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/00.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/01.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/02.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/03.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/04.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/05.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/06.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/07.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/08.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/09.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/10.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/11.sub");
        m_pSlotActiveEffect->AppendImage("d:/ymir work/ui/public/slotactiveeffect/12.sub");
        m_pSlotActiveEffect->SetRenderingMode(CGraphicExpandedImageInstance::RENDERING_MODE_SCREEN);
        m_pSlotActiveEffect->Show();
    }

    void CSlotWindow::__CreateFinishCoolTimeEffect(TSlot * pSlot)
    {
        __DestroyFinishCoolTimeEffect(pSlot);

        CAniImageBox * pFinishCoolTimeEffect = new CCoolTimeFinishEffect(this, pSlot->dwSlotNumber);
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/00.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/01.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/02.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/03.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/04.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/05.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/06.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/07.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/08.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/09.sub");
        pFinishCoolTimeEffect->AppendImage("d:/ymir work/ui/public/slotfinishcooltimeeffect/10.sub");
        pFinishCoolTimeEffect->SetRenderingMode(CGraphicExpandedImageInstance::RENDERING_MODE_SCREEN);
        pFinishCoolTimeEffect->ResetFrame();
        pFinishCoolTimeEffect->SetDelay(2);
        pFinishCoolTimeEffect->Show();

        pSlot->pFinishCoolTimeEffect = pFinishCoolTimeEffect;
    }

    void CSlotWindow::__CreateBaseImage(const char * c_szFileName, float fr, float fg, float fb, float fa)
    {
        __DestroyBaseImage();

        CGraphicImage * pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(c_szFileName);
        m_pBaseImageInstance = CGraphicImageInstance::New();
        m_pBaseImageInstance->SetImagePointer(pImage);
        m_pBaseImageInstance->SetDiffuseColor(fr, fg, fb, fa);
    }

    void CSlotWindow::__CreateBaseImageScale(const char * c_szFileName, float fr, float fg, float fb, float fa, float sx, float sy)
    {
        __DestroyBaseImage();

        CGraphicImage * pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(c_szFileName);
        m_pBaseImageInstance = CGraphicImageInstance::New();
        m_pBaseImageInstance->SetImagePointer(pImage);
        m_pBaseImageInstance->SetDiffuseColor(fr, fg, fb, fa);
        m_pBaseImageInstance->SetScale(sx, sy);
    }

    void CSlotWindow::__DestroyToggleSlotImage()
    {
        if (m_pToggleSlotImage)
        {
            delete m_pToggleSlotImage;
            m_pToggleSlotImage = NULL;
        }
    }

    void CSlotWindow::__DestroySlotEnableEffect()
    {
        if (m_pSlotActiveEffect)
        {
            delete m_pSlotActiveEffect;
            m_pSlotActiveEffect = NULL;
        }
    }

    void CSlotWindow::__DestroyFinishCoolTimeEffect(TSlot * pSlot)
    {
        if (pSlot->pFinishCoolTimeEffect)
        {
            delete pSlot->pFinishCoolTimeEffect;
            pSlot->pFinishCoolTimeEffect = NULL;
        }
    }

    void CSlotWindow::__DestroyBaseImage()
    {
        if (m_pBaseImageInstance)
        {
            CGraphicImageInstance::Delete(m_pBaseImageInstance);
            m_pBaseImageInstance = NULL;
        }
    }

    void CSlotWindow::__Initialize()
    {
        m_dwSlotType = 0;
        m_dwSlotStyle = SLOT_STYLE_PICK_UP;
        m_dwToolTipSlotNumber = SLOT_NUMBER_NONE;

        m_isUseMode = FALSE;
        m_isUsableItem = FALSE;

        m_pToggleSlotImage = NULL;
        m_pSlotActiveEffect = NULL;
        m_pBaseImageInstance = NULL;
    }

    void CSlotWindow::Destroy()
    {
        for (TSlotListIterator itor = m_SlotList.begin(); itor != m_SlotList.end(); ++itor)
        {
            TSlot & rSlot = *itor;

            ClearSlot(&rSlot);

            if (rSlot.pNumberLine)
            {
                delete rSlot.pNumberLine;
                rSlot.pNumberLine = NULL;
            }
            if (rSlot.pCoverButton)
            {
                CWindowManager::Instance().DestroyWindow(rSlot.pCoverButton);
            }
            if (rSlot.pSlotButton)
            {
                CWindowManager::Instance().DestroyWindow(rSlot.pSlotButton);
            }
            if (rSlot.pSignImage)
            {
                CWindowManager::Instance().DestroyWindow(rSlot.pSignImage);
            }
            if (rSlot.pFinishCoolTimeEffect)
            {
                CWindowManager::Instance().DestroyWindow(rSlot.pFinishCoolTimeEffect);
            }
    #ifdef ENABLE_SASH_SYSTEM
            for (int i = 0; i < 3; ++i)
            {
                if (rSlot.pActiveSlotEffect)
                    CWindowManager::Instance().DestroyWindow(rSlot.pActiveSlotEffect);
            }
    #endif
        }

        m_SlotList.clear();

        __DestroyToggleSlotImage();
        __DestroySlotEnableEffect();
        __DestroyBaseImage();

        __Initialize();
    }

    CSlotWindow::CSlotWindow(PyObject * ppyObject) : CWindow(ppyObject)
    {
        __Initialize();
    }

    CSlotWindow::~CSlotWindow()
    {
        Destroy();
    }
     

     

    Offline Shop npc_table bug

    in Community Support - Questions & Answers

    Posted

    Hello everyone 

    i have this annoying bug witch keeping me mad all the time :(

    my offline shop have some bug's

    i tryied to solve some of them 

    but still the same

    now my biggest problem is 

    when i try to open new offline shop and add the name and the time and the item

    when i click (Open)

    the server Crach..!!!!!!

    i don't know where is the problem 

    i tryied to open the database 

    and duble click on table >> offline_shop_npc

    this is what i got ??

    Capture.JPG.1a091fbb3fc8c59f5f9ed4a90b47d45b.JPG

    if any one can help me 

    please !

    because my server is online :(

×
×
  • Create New...

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.