#include "StdAfx.h" #include "../eterBase/CRC32.h" #include "PythonWindow.h" #include "PythonSlotWindow.h" #include "PythonWindowManager.h" BOOL g_bOutlineBoxEnable = FALSE; namespace UI { CWindow::CWindow(PyObject * ppyObject) : m_x(0), m_y(0), m_lWidth(0), m_lHeight(0), m_poHandler(ppyObject), m_bShow(false), m_pParent(NULL), m_dwFlag(0), m_isUpdatingChildren(FALSE) { #ifdef _DEBUG static DWORD DEBUG_dwGlobalCounter=0; DEBUG_dwCounter=DEBUG_dwGlobalCounter++; m_strName = "!!debug"; #endif //assert(m_poHandler != NULL); m_HorizontalAlign = HORIZONTAL_ALIGN_LEFT; m_VerticalAlign = VERTICAL_ALIGN_TOP; m_rect.bottom = m_rect.left = m_rect.right = m_rect.top = 0; m_limitBiasRect.bottom = m_limitBiasRect.left = m_limitBiasRect.right = m_limitBiasRect.top = 0; } CWindow::~CWindow() { } DWORD CWindow::Type() { static DWORD s_dwType = GetCRC32("CWindow", strlen("CWindow")); return (s_dwType); } BOOL CWindow::IsType(DWORD dwType) { return OnIsType(dwType); } BOOL CWindow::OnIsType(DWORD dwType) { if (CWindow::Type() == dwType) return TRUE; return FALSE; } struct FClear { void operator () (CWindow * pWin) { pWin->Clear(); } }; void CWindow::Clear() { // FIXME : Children을 즉시 Delete하지는 않는다. // 어차피 Python쪽에서 Destroy가 하나씩 다시 호출 될 것이므로.. // 하지만 만약을 위해 링크는 끊어 놓는다. // 더 좋은 형태는 있는가? - [levites] std::for_each(m_pChildList.begin(), m_pChildList.end(), FClear()); m_pChildList.clear(); m_pParent = NULL; DestroyHandle(); Hide(); } void CWindow::DestroyHandle() { m_poHandler = NULL; } void CWindow::Show() { m_bShow = true; } void CWindow::Hide() { m_bShow = false; } // NOTE : IsShow는 "자신이 보이는가?" 이지만, __IsShowing은 "자신이 그려지고 있는가?" 를 체크한다 // 자신은 Show 지만 Tree 위쪽의 Parent 중 하나는 Hide 일 수 있으므로.. - [levites] bool CWindow::IsRendering() { if (!IsShow()) return false; if (!m_pParent) return true; return m_pParent->IsRendering(); } void CWindow::__RemoveReserveChildren() { if (m_pReserveChildList.empty()) return; TWindowContainer::iterator it; for(it = m_pReserveChildList.begin(); it != m_pReserveChildList.end(); ++it) { m_pChildList.remove(*it); } m_pReserveChildList.clear(); } void CWindow::Update() { if (!IsShow()) return; __RemoveReserveChildren(); OnUpdate(); m_isUpdatingChildren = TRUE; TWindowContainer::iterator it; for(it = m_pChildList.begin(); it != m_pChildList.end();) { TWindowContainer::iterator it_next = it; ++it_next; (*it)->Update(); it = it_next; } m_isUpdatingChildren = FALSE; } void CWindow::Render() { if (!IsShow()) return; OnRender(); if (g_bOutlineBoxEnable) { CPythonGraphic::Instance().SetDiffuseColor(1.0f, 1.0f, 1.0f); CPythonGraphic::Instance().RenderBox2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); } std::for_each(m_pChildList.begin(), m_pChildList.end(), std::void_mem_fun(&CWindow::Render)); } void CWindow::OnUpdate() { if (!m_poHandler) return; if (!IsShow()) return; static PyObject* poFuncName_OnUpdate = PyString_InternFromString("OnUpdate"); //PyCallClassMemberFunc(m_poHandler, "OnUpdate", BuildEmptyTuple()); PyCallClassMemberFunc_ByPyString(m_poHandler, poFuncName_OnUpdate, BuildEmptyTuple()); } void CWindow::OnRender() { if (!m_poHandler) return; if (!IsShow()) return; //PyCallClassMemberFunc(m_poHandler, "OnRender", BuildEmptyTuple()); PyCallClassMemberFunc(m_poHandler, "OnRender", BuildEmptyTuple()); } void CWindow::SetName(const char * c_szName) { m_strName = c_szName; } void CWindow::SetSize(long width, long height) { m_lWidth = width; m_lHeight = height; m_rect.right = m_rect.left + m_lWidth; m_rect.bottom = m_rect.top + m_lHeight; } void CWindow::SetHorizontalAlign(DWORD dwAlign) { m_HorizontalAlign = (EHorizontalAlign)dwAlign; UpdateRect(); } void CWindow::SetVerticalAlign(DWORD dwAlign) { m_VerticalAlign = (EVerticalAlign)dwAlign; UpdateRect(); } void CWindow::SetPosition(long x, long y) { m_x = x; m_y = y; UpdateRect(); } void CWindow::GetPosition(long * plx, long * ply) { *plx = m_x; *ply = m_y; } long CWindow::UpdateRect() { m_rect.top = m_y; if (m_pParent) { switch (m_VerticalAlign) { case VERTICAL_ALIGN_BOTTOM: m_rect.top = m_pParent->GetHeight() - m_rect.top; break; case VERTICAL_ALIGN_CENTER: m_rect.top = (m_pParent->GetHeight() - GetHeight()) / 2 + m_rect.top; break; } m_rect.top += m_pParent->m_rect.top; } m_rect.bottom = m_rect.top + m_lHeight; #if defined( _USE_CPP_RTL_FLIP ) if( m_pParent == NULL ) { m_rect.left = m_x; m_rect.right = m_rect.left + m_lWidth; } else { if( m_pParent->IsFlag(UI::CWindow::FLAG_RTL) == true ) { m_rect.left = m_pParent->GetWidth() - m_lWidth - m_x; switch (m_HorizontalAlign) { case HORIZONTAL_ALIGN_RIGHT: m_rect.left = - m_x; break; case HORIZONTAL_ALIGN_CENTER: m_rect.left = m_pParent->GetWidth() / 2 - GetWidth() - m_x; break; } m_rect.left += m_pParent->m_rect.left; m_rect.right = m_rect.left + m_lWidth; } else { m_rect.left = m_x; switch (m_HorizontalAlign) { case HORIZONTAL_ALIGN_RIGHT: m_rect.left = m_pParent->GetWidth() - m_rect.left; break; case HORIZONTAL_ALIGN_CENTER: m_rect.left = (m_pParent->GetWidth() - GetWidth()) / 2 + m_rect.left; break; } m_rect.left += m_pParent->m_rect.left; m_rect.right = m_rect.left + m_lWidth; } } #else m_rect.left = m_x; if (m_pParent) { switch (m_HorizontalAlign) { case HORIZONTAL_ALIGN_RIGHT: m_rect.left = ::abs(m_pParent->GetWidth()) - m_rect.left; break; case HORIZONTAL_ALIGN_CENTER: m_rect.left = m_pParent->GetWidth() / 2 - GetWidth() / 2 + m_rect.left; break; } m_rect.left += 0L < m_pParent->GetWidth() ? m_pParent->m_rect.left : m_pParent->m_rect.right + ::abs(m_pParent->GetWidth()); } m_rect.right = m_rect.left + m_lWidth; #endif std::for_each(m_pChildList.begin(), m_pChildList.end(), std::mem_fun(&CWindow::UpdateRect)); OnChangePosition(); return 1; } void CWindow::GetLocalPosition(long & rlx, long & rly) { rlx = rlx - m_rect.left; rly = rly - m_rect.top; } void CWindow::GetMouseLocalPosition(long & rlx, long & rly) { CWindowManager::Instance().GetMousePosition(rlx, rly); rlx = rlx - m_rect.left; rly = rly - m_rect.top; } void CWindow::AddChild(CWindow * pWin) { m_pChildList.push_back(pWin); pWin->m_pParent = this; } CWindow * CWindow::GetRoot() { if (m_pParent) if (m_pParent->IsWindow()) return m_pParent->GetRoot(); return this; } CWindow * CWindow::GetParent() { return m_pParent; } bool CWindow::IsChild(CWindow * pWin) { std::list::iterator itor = m_pChildList.begin(); while (itor != m_pChildList.end()) { if (*itor == pWin) return true; ++itor; } return false; } void CWindow::DeleteChild(CWindow * pWin) { if (m_isUpdatingChildren) { m_pReserveChildList.push_back(pWin); } else { m_pChildList.remove(pWin); } } void CWindow::SetTop(CWindow * pWin) { if (!pWin->IsFlag(CWindow::FLAG_FLOAT)) return; TWindowContainer::iterator itor = std::find(m_pChildList.begin(), m_pChildList.end(), pWin); if (m_pChildList.end() != itor) { m_pChildList.push_back(*itor); m_pChildList.erase(itor); pWin->OnTop(); } else { TraceError(" CWindow::SetTop - Failed to find child window\n"); } } void CWindow::OnMouseDrag(long lx, long ly) { PyCallClassMemberFunc(m_poHandler, "OnMouseDrag", Py_BuildValue("(ii)", lx, ly)); } void CWindow::OnMoveWindow(long lx, long ly) { PyCallClassMemberFunc(m_poHandler, "OnMoveWindow", Py_BuildValue("(ii)", lx, ly)); } void CWindow::OnSetFocus() { //PyCallClassMemberFunc(m_poHandler, "OnSetFocus", BuildEmptyTuple()); PyCallClassMemberFunc(m_poHandler, "OnSetFocus", BuildEmptyTuple()); } void CWindow::OnKillFocus() { PyCallClassMemberFunc(m_poHandler, "OnKillFocus", BuildEmptyTuple()); } void CWindow::OnMouseOverIn() { PyCallClassMemberFunc(m_poHandler, "OnMouseOverIn", BuildEmptyTuple()); } void CWindow::OnMouseOverOut() { PyCallClassMemberFunc(m_poHandler, "OnMouseOverOut", BuildEmptyTuple()); } void CWindow::OnMouseOver() { } void CWindow::OnDrop() { PyCallClassMemberFunc(m_poHandler, "OnDrop", BuildEmptyTuple()); } void CWindow::OnTop() { PyCallClassMemberFunc(m_poHandler, "OnTop", BuildEmptyTuple()); } void CWindow::OnIMEUpdate() { PyCallClassMemberFunc(m_poHandler, "OnIMEUpdate", BuildEmptyTuple()); } BOOL CWindow::RunIMETabEvent() { if (!IsRendering()) return FALSE; if (OnIMETabEvent()) return TRUE; TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->RunIMETabEvent()) return TRUE; } return FALSE; } BOOL CWindow::RunIMEReturnEvent() { if (!IsRendering()) return FALSE; if (OnIMEReturnEvent()) return TRUE; TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->RunIMEReturnEvent()) return TRUE; } return FALSE; } BOOL CWindow::RunIMEKeyDownEvent(int ikey) { if (!IsRendering()) return FALSE; if (OnIMEKeyDownEvent(ikey)) return TRUE; TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->RunIMEKeyDownEvent(ikey)) return TRUE; } return FALSE; } CWindow * CWindow::RunKeyDownEvent(int ikey) { if (OnKeyDown(ikey)) return this; TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->IsShow()) { CWindow * pProcessedWindow = pWindow->RunKeyDownEvent(ikey); if (NULL != pProcessedWindow) { return pProcessedWindow; } } } return NULL; } BOOL CWindow::RunKeyUpEvent(int ikey) { if (OnKeyUp(ikey)) return TRUE; TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->IsShow()) if (pWindow->RunKeyUpEvent(ikey)) return TRUE; } return FALSE; } BOOL CWindow::RunPressEscapeKeyEvent() { TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->IsShow()) if (pWindow->RunPressEscapeKeyEvent()) return TRUE; } if (OnPressEscapeKey()) return TRUE; return FALSE; } BOOL CWindow::RunPressExitKeyEvent() { TWindowContainer::reverse_iterator itor; for (itor = m_pChildList.rbegin(); itor != m_pChildList.rend(); ++itor) { CWindow * pWindow = *itor; if (pWindow->RunPressExitKeyEvent()) return TRUE; if (pWindow->IsShow()) if (pWindow->OnPressExitKey()) return TRUE; } return FALSE; } BOOL CWindow::OnMouseLeftButtonDown() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseLeftButtonDown", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseLeftButtonUp() { PyCallClassMemberFunc(m_poHandler, "OnMouseLeftButtonUp", BuildEmptyTuple()); return TRUE; // NOTE : ButtonUp은 예외로 무조건 TRUE } BOOL CWindow::OnMouseLeftButtonDoubleClick() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseLeftButtonDoubleClick", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseRightButtonDown() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseRightButtonDown", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseRightButtonUp() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseRightButtonUp", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseRightButtonDoubleClick() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseRightButtonDoubleClick", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseMiddleButtonDown() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseMiddleButtonDown", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnMouseMiddleButtonUp() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnMouseMiddleButtonUp", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMETabEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMETab", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMEReturnEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMEReturn", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMEKeyDownEvent(int ikey) { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMEKeyDown", Py_BuildValue("(i)", ikey), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMEChangeCodePage() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMEChangeCodePage", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMEOpenCandidateListEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMEOpenCandidateList", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMECloseCandidateListEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMECloseCandidateList", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMEOpenReadingWndEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMEOpenReadingWnd", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnIMECloseReadingWndEvent() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnIMECloseReadingWnd", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnKeyDown(int ikey) { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnKeyDown", Py_BuildValue("(i)", ikey), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnKeyUp(int ikey) { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnKeyUp", Py_BuildValue("(i)", ikey), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnPressEscapeKey() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnPressEscapeKey", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } BOOL CWindow::OnPressExitKey() { long lValue; if (PyCallClassMemberFunc(m_poHandler, "OnPressExitKey", BuildEmptyTuple(), &lValue)) if (0 != lValue) return TRUE; return FALSE; } ///// bool CWindow::IsIn(long x, long y) { if (x >= m_rect.left && x <= m_rect.right) if (y >= m_rect.top && y <= m_rect.bottom) return true; return false; } bool CWindow::IsIn() { long lx, ly; UI::CWindowManager::Instance().GetMousePosition(lx, ly); return IsIn(lx, ly); } CWindow * CWindow::PickWindow(long x, long y) { std::list::reverse_iterator ritor = m_pChildList.rbegin(); for (; ritor != m_pChildList.rend(); ++ritor) { CWindow * pWin = *ritor; if (pWin->IsShow()) { if (!pWin->IsFlag(CWindow::FLAG_IGNORE_SIZE)) { if (!pWin->IsIn(x, y)) { if (0L <= pWin->GetWidth()) { continue; } } } CWindow * pResult = pWin->PickWindow(x, y); if (pResult) return pResult; } } if (IsFlag(CWindow::FLAG_NOT_PICK)) return NULL; return (this); } CWindow * CWindow::PickTopWindow(long x, long y) { std::list::reverse_iterator ritor = m_pChildList.rbegin(); for (; ritor != m_pChildList.rend(); ++ritor) { CWindow * pWin = *ritor; if (pWin->IsShow()) if (pWin->IsIn(x, y)) if (!pWin->IsFlag(CWindow::FLAG_NOT_PICK)) return pWin; } return NULL; } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CBox::CBox(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0xff000000) { } CBox::~CBox() { } void CBox::SetColor(DWORD dwColor) { m_dwColor = dwColor; } void CBox::OnRender() { CPythonGraphic::Instance().SetDiffuseColor(m_dwColor); CPythonGraphic::Instance().RenderBox2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CBar::CBar(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0xff000000) { } CBar::~CBar() { } void CBar::SetColor(DWORD dwColor) { m_dwColor = dwColor; } void CBar::OnRender() { CPythonGraphic::Instance().SetDiffuseColor(m_dwColor); CPythonGraphic::Instance().RenderBar2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CLine::CLine(PyObject * ppyObject) : CWindow(ppyObject), m_dwColor(0xff000000) { } CLine::~CLine() { } void CLine::SetColor(DWORD dwColor) { m_dwColor = dwColor; } void CLine::OnRender() { CPythonGraphic & rkpyGraphic = CPythonGraphic::Instance(); rkpyGraphic.SetDiffuseColor(m_dwColor); rkpyGraphic.RenderLine2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// DWORD CBar3D::Type() { static DWORD s_dwType = GetCRC32("CBar3D", strlen("CBar3D")); return (s_dwType); } CBar3D::CBar3D(PyObject * ppyObject) : CWindow(ppyObject) { m_dwLeftColor = D3DXCOLOR(0.2f, 0.2f, 0.2f, 1.0f); m_dwRightColor = D3DXCOLOR(0.7f, 0.7f, 0.7f, 1.0f); m_dwCenterColor = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f); } CBar3D::~CBar3D() { } void CBar3D::SetColor(DWORD dwLeft, DWORD dwRight, DWORD dwCenter) { m_dwLeftColor = dwLeft; m_dwRightColor = dwRight; m_dwCenterColor = dwCenter; } void CBar3D::OnRender() { CPythonGraphic & rkpyGraphic = CPythonGraphic::Instance(); rkpyGraphic.SetDiffuseColor(m_dwCenterColor); rkpyGraphic.RenderBar2d(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom); rkpyGraphic.SetDiffuseColor(m_dwLeftColor); rkpyGraphic.RenderLine2d(m_rect.left, m_rect.top, m_rect.right, m_rect.top); rkpyGraphic.RenderLine2d(m_rect.left, m_rect.top, m_rect.left, m_rect.bottom); rkpyGraphic.SetDiffuseColor(m_dwRightColor); rkpyGraphic.RenderLine2d(m_rect.left, m_rect.bottom, m_rect.right, m_rect.bottom); rkpyGraphic.RenderLine2d(m_rect.right, m_rect.top, m_rect.right, m_rect.bottom); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CTextLine::CTextLine(PyObject * ppyObject) : CWindow(ppyObject) { m_TextInstance.SetColor(0.78f, 0.78f, 0.78f); m_TextInstance.SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_LEFT); m_TextInstance.SetVerticalAlign(CGraphicTextInstance::VERTICAL_ALIGN_TOP); } CTextLine::~CTextLine() { m_TextInstance.Destroy(); } void CTextLine::SetMax(int iMax) { m_TextInstance.SetMax(iMax); } void CTextLine::SetHorizontalAlign(int iType) { m_TextInstance.SetHorizonalAlign(iType); } void CTextLine::SetVerticalAlign(int iType) { m_TextInstance.SetVerticalAlign(iType); } void CTextLine::SetSecret(BOOL bFlag) { m_TextInstance.SetSecret(bFlag ? true : false); } void CTextLine::SetOutline(BOOL bFlag) { m_TextInstance.SetOutline(bFlag ? true : false); } void CTextLine::SetFeather(BOOL bFlag) { m_TextInstance.SetFeather(bFlag ? true : false); } void CTextLine::SetMultiLine(BOOL bFlag) { m_TextInstance.SetMultiLine(bFlag ? true : false); } void CTextLine::SetFontName(const char * c_szFontName) { std::string stFontName = c_szFontName; stFontName += ".fnt"; CResourceManager& rkResMgr=CResourceManager::Instance(); CResource* pkRes = rkResMgr.GetTypeResourcePointer(stFontName.c_str()); CGraphicText* pkResFont=static_cast(pkRes); m_TextInstance.SetTextPointer(pkResFont); } void CTextLine::SetFontColor(DWORD dwColor) { m_TextInstance.SetColor(dwColor); } void CTextLine::SetLimitWidth(float fWidth) { m_TextInstance.SetLimitWidth(fWidth); } void CTextLine::SetText(const char * c_szText) { OnSetText(c_szText); } void CTextLine::GetTextSize(int* pnWidth, int* pnHeight) { m_TextInstance.GetTextSize(pnWidth, pnHeight); } const char * CTextLine::GetText() { return m_TextInstance.GetValueStringReference().c_str(); } void CTextLine::ShowCursor() { m_TextInstance.ShowCursor(); } void CTextLine::HideCursor() { m_TextInstance.HideCursor(); } int CTextLine::GetCursorPosition() { long lx, ly; CWindow::GetMouseLocalPosition(lx, ly); return m_TextInstance.PixelPositionToCharacterPosition(lx); } void CTextLine::OnSetText(const char * c_szText) { m_TextInstance.SetValue(c_szText); m_TextInstance.Update(); } void CTextLine::OnUpdate() { if (IsShow()) m_TextInstance.Update(); } void CTextLine::OnRender() { if (IsShow()) m_TextInstance.Render(); } void CTextLine::OnChangePosition() { // FOR_ARABIC_ALIGN //if (m_TextInstance.GetHorizontalAlign() == CGraphicTextInstance::HORIZONTAL_ALIGN_ARABIC) if( GetDefaultCodePage() == CP_ARABIC ) { m_TextInstance.SetPosition(m_rect.right, m_rect.top); } else { m_TextInstance.SetPosition(m_rect.left, m_rect.top); } } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CNumberLine::CNumberLine(PyObject * ppyObject) : CWindow(ppyObject) { m_strPath = "d:/ymir work/ui/game/taskbar/"; m_iHorizontalAlign = HORIZONTAL_ALIGN_LEFT; m_dwWidthSummary = 0; } CNumberLine::CNumberLine(CWindow * pParent) : CWindow(NULL) { m_strPath = "d:/ymir work/ui/game/taskbar/"; m_iHorizontalAlign = HORIZONTAL_ALIGN_LEFT; m_dwWidthSummary = 0; m_pParent = pParent; } CNumberLine::~CNumberLine() { ClearNumber(); } void CNumberLine::SetPath(const char * c_szPath) { m_strPath = c_szPath; } void CNumberLine::SetHorizontalAlign(int iType) { m_iHorizontalAlign = iType; } void CNumberLine::SetNumber(const char * c_szNumber) { if (0 == m_strNumber.compare(c_szNumber)) return; ClearNumber(); m_strNumber = c_szNumber; for (DWORD i = 0; i < m_strNumber.size(); ++i) { char cChar = m_strNumber[i]; std::string strImageFileName; if (':' == cChar) { strImageFileName = m_strPath + "colon.sub"; } else if ('?' == cChar) { strImageFileName = m_strPath + "questionmark.sub"; } else if ('/' == cChar) { strImageFileName = m_strPath + "slash.sub"; } else if ('%' == cChar) { strImageFileName = m_strPath + "percent.sub"; } else if ('+' == cChar) { strImageFileName = m_strPath + "plus.sub"; } else if ('m' == cChar) { strImageFileName = m_strPath + "m.sub"; } else if ('g' == cChar) { strImageFileName = m_strPath + "g.sub"; } else if ('p' == cChar) { strImageFileName = m_strPath + "p.sub"; } else if (cChar >= '0' && cChar <= '9') { strImageFileName = m_strPath; strImageFileName += cChar; strImageFileName += ".sub"; } else continue; if (!CResourceManager::Instance().IsFileExist(strImageFileName.c_str())) continue; CGraphicImage * pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(strImageFileName.c_str()); CGraphicImageInstance * pInstance = CGraphicImageInstance::New(); pInstance->SetImagePointer(pImage); m_ImageInstanceVector.push_back(pInstance); m_dwWidthSummary += pInstance->GetWidth(); } } void CNumberLine::ClearNumber() { m_ImageInstanceVector.clear(); m_dwWidthSummary = 0; m_strNumber = ""; } void CNumberLine::OnRender() { for (DWORD i = 0; i < m_ImageInstanceVector.size(); ++i) { m_ImageInstanceVector[i]->Render(); } } void CNumberLine::OnChangePosition() { int ix = m_x; int iy = m_y; if (m_pParent) { ix = m_rect.left; iy = m_rect.top; } switch (m_iHorizontalAlign) { case HORIZONTAL_ALIGN_LEFT: break; case HORIZONTAL_ALIGN_CENTER: ix -= int(m_dwWidthSummary) / 2; break; case HORIZONTAL_ALIGN_RIGHT: ix -= int(m_dwWidthSummary); break; } for (DWORD i = 0; i < m_ImageInstanceVector.size(); ++i) { m_ImageInstanceVector[i]->SetPosition(ix, iy); ix += m_ImageInstanceVector[i]->GetWidth(); } } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CImageBox::CImageBox(PyObject * ppyObject) : CWindow(ppyObject) { m_pImageInstance = NULL; } CImageBox::~CImageBox() { OnDestroyInstance(); } void CImageBox::OnCreateInstance() { OnDestroyInstance(); m_pImageInstance = CGraphicImageInstance::New(); } void CImageBox::OnDestroyInstance() { if (m_pImageInstance) { CGraphicImageInstance::Delete(m_pImageInstance); m_pImageInstance=NULL; } } BOOL CImageBox::LoadImage(const char * c_szFileName) { if (!c_szFileName[0]) return FALSE; OnCreateInstance(); CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource) return FALSE; if (!pResource->IsType(CGraphicImage::Type())) return FALSE; m_pImageInstance->SetImagePointer(static_cast(pResource)); if (m_pImageInstance->IsEmpty()) return FALSE; SetSize(m_pImageInstance->GetWidth(), m_pImageInstance->GetHeight()); UpdateRect(); return TRUE; } void CImageBox::SetDiffuseColor(float fr, float fg, float fb, float fa) { if (!m_pImageInstance) return; m_pImageInstance->SetDiffuseColor(fr, fg, fb, fa); } int CImageBox::GetWidth() { if (!m_pImageInstance) return 0; return m_pImageInstance->GetWidth(); } int CImageBox::GetHeight() { if (!m_pImageInstance) return 0; return m_pImageInstance->GetHeight(); } void CImageBox::OnUpdate() { } void CImageBox::OnRender() { if (!m_pImageInstance) return; if (IsShow()) m_pImageInstance->Render(); } void CImageBox::OnChangePosition() { if (!m_pImageInstance) return; m_pImageInstance->SetPosition(m_rect.left, m_rect.top); } /////////////////////////////////////////////////////////////////////////////////////////////// // MarkBox - 마크 출력용 UI 윈도우 /////////////////////////////////////////////////////////////////////////////////////////////// CMarkBox::CMarkBox(PyObject * ppyObject) : CWindow(ppyObject) { m_pMarkInstance = NULL; } CMarkBox::~CMarkBox() { OnDestroyInstance(); } void CMarkBox::OnCreateInstance() { OnDestroyInstance(); m_pMarkInstance = CGraphicMarkInstance::New(); } void CMarkBox::OnDestroyInstance() { if (m_pMarkInstance) { CGraphicMarkInstance::Delete(m_pMarkInstance); m_pMarkInstance=NULL; } } void CMarkBox::LoadImage(const char * c_szFilename) { OnCreateInstance(); m_pMarkInstance->SetImageFileName(c_szFilename); m_pMarkInstance->Load(); SetSize(m_pMarkInstance->GetWidth(), m_pMarkInstance->GetHeight()); UpdateRect(); } void CMarkBox::SetScale(FLOAT fScale) { if (!m_pMarkInstance) return; m_pMarkInstance->SetScale(fScale); } void CMarkBox::SetIndex(UINT uIndex) { if (!m_pMarkInstance) return; m_pMarkInstance->SetIndex(uIndex); } void CMarkBox::SetDiffuseColor(float fr, float fg, float fb, float fa) { if (!m_pMarkInstance) return; m_pMarkInstance->SetDiffuseColor(fr, fg, fb, fa); } void CMarkBox::OnUpdate() { } void CMarkBox::OnRender() { if (!m_pMarkInstance) return; if (IsShow()) m_pMarkInstance->Render(); } void CMarkBox::OnChangePosition() { if (!m_pMarkInstance) return; m_pMarkInstance->SetPosition(m_rect.left, m_rect.top); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// DWORD CExpandedImageBox::Type() { static DWORD s_dwType = GetCRC32("CExpandedImageBox", strlen("CExpandedImageBox")); return (s_dwType); } BOOL CExpandedImageBox::OnIsType(DWORD dwType) { if (CExpandedImageBox::Type() == dwType) return TRUE; return FALSE; } CExpandedImageBox::CExpandedImageBox(PyObject * ppyObject) : CImageBox(ppyObject) { } CExpandedImageBox::~CExpandedImageBox() { OnDestroyInstance(); } void CExpandedImageBox::OnCreateInstance() { OnDestroyInstance(); m_pImageInstance = CGraphicExpandedImageInstance::New(); } void CExpandedImageBox::OnDestroyInstance() { if (m_pImageInstance) { CGraphicExpandedImageInstance::Delete((CGraphicExpandedImageInstance*)m_pImageInstance); m_pImageInstance=NULL; } } void CExpandedImageBox::SetScale(float fx, float fy) { if (!m_pImageInstance) return; ((CGraphicExpandedImageInstance*)m_pImageInstance)->SetScale(fx, fy); CWindow::SetSize(long(float(GetWidth())*fx), long(float(GetHeight())*fy)); } void CExpandedImageBox::SetOrigin(float fx, float fy) { if (!m_pImageInstance) return; ((CGraphicExpandedImageInstance*)m_pImageInstance)->SetOrigin(fx, fy); } void CExpandedImageBox::SetRotation(float fRotation) { if (!m_pImageInstance) return; ((CGraphicExpandedImageInstance*)m_pImageInstance)->SetRotation(fRotation); } void CExpandedImageBox::SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom) { if (!m_pImageInstance) return; ((CGraphicExpandedImageInstance*)m_pImageInstance)->SetRenderingRect(fLeft, fTop, fRight, fBottom); } void CExpandedImageBox::SetRenderingMode(int iMode) { ((CGraphicExpandedImageInstance*)m_pImageInstance)->SetRenderingMode(iMode); } void CExpandedImageBox::OnUpdate() { } void CExpandedImageBox::OnRender() { if (!m_pImageInstance) return; if (IsShow()) m_pImageInstance->Render(); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// DWORD CAniImageBox::Type() { static DWORD s_dwType = GetCRC32("CAniImageBox", strlen("CAniImageBox")); return (s_dwType); } BOOL CAniImageBox::OnIsType(DWORD dwType) { if (CAniImageBox::Type() == dwType) return TRUE; return FALSE; } CAniImageBox::CAniImageBox(PyObject * ppyObject) : CWindow(ppyObject), m_bycurDelay(0), m_byDelay(4), m_bycurIndex(0) { m_ImageVector.clear(); } CAniImageBox::~CAniImageBox() { for_each(m_ImageVector.begin(), m_ImageVector.end(), CGraphicExpandedImageInstance::DeleteExpandedImageInstance); } void CAniImageBox::SetDelay(int iDelay) { m_byDelay = iDelay; } void CAniImageBox::AppendImage(const char * c_szFileName) { CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource->IsType(CGraphicImage::Type())) return; CGraphicExpandedImageInstance * pImageInstance = CGraphicExpandedImageInstance::New(); pImageInstance->SetImagePointer(static_cast(pResource)); if (pImageInstance->IsEmpty()) { CGraphicExpandedImageInstance::Delete(pImageInstance); return; } m_ImageVector.push_back(pImageInstance); m_bycurIndex = rand() % m_ImageVector.size(); // SetSize(pImageInstance->GetWidth(), pImageInstance->GetHeight()); // UpdateRect(); } struct FSetRenderingRect { float fLeft, fTop, fRight, fBottom; void operator () (CGraphicExpandedImageInstance * pInstance) { pInstance->SetRenderingRect(fLeft, fTop, fRight, fBottom); } }; void CAniImageBox::SetRenderingRect(float fLeft, float fTop, float fRight, float fBottom) { FSetRenderingRect setRenderingRect; setRenderingRect.fLeft = fLeft; setRenderingRect.fTop = fTop; setRenderingRect.fRight = fRight; setRenderingRect.fBottom = fBottom; for_each(m_ImageVector.begin(), m_ImageVector.end(), setRenderingRect); } struct FSetRenderingMode { int iMode; void operator () (CGraphicExpandedImageInstance * pInstance) { pInstance->SetRenderingMode(iMode); } }; void CAniImageBox::SetRenderingMode(int iMode) { FSetRenderingMode setRenderingMode; setRenderingMode.iMode = iMode; for_each(m_ImageVector.begin(), m_ImageVector.end(), setRenderingMode); } void CAniImageBox::ResetFrame() { m_bycurIndex = 0; } void CAniImageBox::OnUpdate() { ++m_bycurDelay; if (m_bycurDelay < m_byDelay) return; m_bycurDelay = 0; ++m_bycurIndex; if (m_bycurIndex >= m_ImageVector.size()) { m_bycurIndex = 0; OnEndFrame(); } } void CAniImageBox::OnRender() { if (m_bycurIndex < m_ImageVector.size()) { CGraphicExpandedImageInstance * pImage = m_ImageVector[m_bycurIndex]; pImage->Render(); } } struct FChangePosition { float fx, fy; void operator () (CGraphicExpandedImageInstance * pInstance) { pInstance->SetPosition(fx, fy); } }; void CAniImageBox::OnChangePosition() { FChangePosition changePosition; changePosition.fx = m_rect.left; changePosition.fy = m_rect.top; for_each(m_ImageVector.begin(), m_ImageVector.end(), changePosition); } void CAniImageBox::OnEndFrame() { PyCallClassMemberFunc(m_poHandler, "OnEndFrame", BuildEmptyTuple()); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CButton::CButton(PyObject * ppyObject) : CWindow(ppyObject), m_pcurVisual(NULL), m_bEnable(TRUE), m_isPressed(FALSE), m_isFlash(FALSE) { CWindow::AddFlag(CWindow::FLAG_NOT_CAPTURE); } CButton::~CButton() { } BOOL CButton::SetUpVisual(const char * c_szFileName) { CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource->IsType(CGraphicImage::Type())) return FALSE; m_upVisual.SetImagePointer(static_cast(pResource)); if (m_upVisual.IsEmpty()) return FALSE; SetSize(m_upVisual.GetWidth(), m_upVisual.GetHeight()); // SetCurrentVisual(&m_upVisual); // return TRUE; } BOOL CButton::SetOverVisual(const char * c_szFileName) { CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource->IsType(CGraphicImage::Type())) return FALSE; m_overVisual.SetImagePointer(static_cast(pResource)); if (m_overVisual.IsEmpty()) return FALSE; SetSize(m_overVisual.GetWidth(), m_overVisual.GetHeight()); return TRUE; } BOOL CButton::SetDownVisual(const char * c_szFileName) { CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource->IsType(CGraphicImage::Type())) return FALSE; m_downVisual.SetImagePointer(static_cast(pResource)); if (m_downVisual.IsEmpty()) return FALSE; SetSize(m_downVisual.GetWidth(), m_downVisual.GetHeight()); return TRUE; } BOOL CButton::SetDisableVisual(const char * c_szFileName) { CResource * pResource = CResourceManager::Instance().GetResourcePointer(c_szFileName); if (!pResource->IsType(CGraphicImage::Type())) return FALSE; m_disableVisual.SetImagePointer(static_cast(pResource)); if (m_downVisual.IsEmpty()) return FALSE; SetSize(m_disableVisual.GetWidth(), m_disableVisual.GetHeight()); return TRUE; } const char * CButton::GetUpVisualFileName() { return m_upVisual.GetGraphicImagePointer()->GetFileName(); } const char * CButton::GetOverVisualFileName() { return m_overVisual.GetGraphicImagePointer()->GetFileName(); } const char * CButton::GetDownVisualFileName() { return m_downVisual.GetGraphicImagePointer()->GetFileName(); } void CButton::Flash() { m_isFlash = TRUE; } void CButton::Enable() { SetUp(); m_bEnable = TRUE; } void CButton::Disable() { m_bEnable = FALSE; if (!m_disableVisual.IsEmpty()) SetCurrentVisual(&m_disableVisual); } BOOL CButton::IsDisable() { return m_bEnable; } void CButton::SetUp() { SetCurrentVisual(&m_upVisual); m_isPressed = FALSE; } void CButton::Up() { if (IsIn()) SetCurrentVisual(&m_overVisual); else SetCurrentVisual(&m_upVisual); PyCallClassMemberFunc(m_poHandler, "CallEvent", BuildEmptyTuple()); } void CButton::Over() { SetCurrentVisual(&m_overVisual); } void CButton::Down() { m_isPressed = TRUE; SetCurrentVisual(&m_downVisual); PyCallClassMemberFunc(m_poHandler, "DownEvent", BuildEmptyTuple()); } void CButton::OnUpdate() { } void CButton::OnRender() { if (!IsShow()) return; if (m_pcurVisual) { if (m_isFlash) if (!IsIn()) if (int(timeGetTime() / 500)%2) { return; } m_pcurVisual->Render(); } PyCallClassMemberFunc(m_poHandler, "OnRender", BuildEmptyTuple()); } void CButton::OnChangePosition() { if (m_pcurVisual) m_pcurVisual->SetPosition(m_rect.left, m_rect.top); } BOOL CButton::OnMouseLeftButtonDown() { if (!IsEnable()) return TRUE; m_isPressed = TRUE; Down(); return TRUE; } BOOL CButton::OnMouseLeftButtonDoubleClick() { if (!IsEnable()) return TRUE; OnMouseLeftButtonDown(); return TRUE; } BOOL CButton::OnMouseLeftButtonUp() { if (!IsEnable()) return TRUE; if (!IsPressed()) return TRUE; m_isPressed = FALSE; Up(); return TRUE; } void CButton::OnMouseOverIn() { if (!IsEnable()) return; Over(); PyCallClassMemberFunc(m_poHandler, "ShowToolTip", BuildEmptyTuple()); } void CButton::OnMouseOverOut() { if (!IsEnable()) return; SetUp(); PyCallClassMemberFunc(m_poHandler, "HideToolTip", BuildEmptyTuple()); } void CButton::SetCurrentVisual(CGraphicImageInstance * pVisual) { m_pcurVisual = pVisual; m_pcurVisual->SetPosition(m_rect.left, m_rect.top); } BOOL CButton::IsEnable() { return m_bEnable; } BOOL CButton::IsPressed() { return m_isPressed; } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CRadioButton::CRadioButton(PyObject * ppyObject) : CButton(ppyObject) { } CRadioButton::~CRadioButton() { } BOOL CRadioButton::OnMouseLeftButtonDown() { if (!IsEnable()) return TRUE; if (!m_isPressed) { Down(); PyCallClassMemberFunc(m_poHandler, "CallEvent", BuildEmptyTuple()); } return TRUE; } BOOL CRadioButton::OnMouseLeftButtonUp() { return TRUE; } void CRadioButton::OnMouseOverIn() { if (!IsEnable()) return; if (!m_isPressed) { SetCurrentVisual(&m_overVisual); } PyCallClassMemberFunc(m_poHandler, "ShowToolTip", BuildEmptyTuple()); } void CRadioButton::OnMouseOverOut() { if (!IsEnable()) return; if (!m_isPressed) { SetCurrentVisual(&m_upVisual); } PyCallClassMemberFunc(m_poHandler, "HideToolTip", BuildEmptyTuple()); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CToggleButton::CToggleButton(PyObject * ppyObject) : CButton(ppyObject) { } CToggleButton::~CToggleButton() { } BOOL CToggleButton::OnMouseLeftButtonDown() { if (!IsEnable()) return TRUE; if (m_isPressed) { SetUp(); if (IsIn()) SetCurrentVisual(&m_overVisual); else SetCurrentVisual(&m_upVisual); PyCallClassMemberFunc(m_poHandler, "OnToggleUp", BuildEmptyTuple()); } else { Down(); PyCallClassMemberFunc(m_poHandler, "OnToggleDown", BuildEmptyTuple()); } return TRUE; } BOOL CToggleButton::OnMouseLeftButtonUp() { return TRUE; } void CToggleButton::OnMouseOverIn() { if (!IsEnable()) return; if (!m_isPressed) { SetCurrentVisual(&m_overVisual); } PyCallClassMemberFunc(m_poHandler, "ShowToolTip", BuildEmptyTuple()); } void CToggleButton::OnMouseOverOut() { if (!IsEnable()) return; if (!m_isPressed) { SetCurrentVisual(&m_upVisual); } PyCallClassMemberFunc(m_poHandler, "HideToolTip", BuildEmptyTuple()); } /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// CDragButton::CDragButton(PyObject * ppyObject) : CButton(ppyObject) { CWindow::RemoveFlag(CWindow::FLAG_NOT_CAPTURE); m_restrictArea.left = 0; m_restrictArea.top = 0; m_restrictArea.right = CWindowManager::Instance().GetScreenWidth(); m_restrictArea.bottom = CWindowManager::Instance().GetScreenHeight(); } CDragButton::~CDragButton() { } void CDragButton::SetRestrictMovementArea(int ix, int iy, int iwidth, int iheight) { m_restrictArea.left = ix; m_restrictArea.top = iy; m_restrictArea.right = ix + iwidth; m_restrictArea.bottom = iy + iheight; } void CDragButton::OnChangePosition() { m_x = max(m_x, m_restrictArea.left); m_y = max(m_y, m_restrictArea.top); m_x = min(m_x, max(0, m_restrictArea.right - m_lWidth)); m_y = min(m_y, max(0, m_restrictArea.bottom - m_lHeight)); m_rect.left = m_x; m_rect.top = m_y; if (m_pParent) { const RECT & c_rRect = m_pParent->GetRect(); m_rect.left += c_rRect.left; m_rect.top += c_rRect.top; } m_rect.right = m_rect.left + m_lWidth; m_rect.bottom = m_rect.top + m_lHeight; std::for_each(m_pChildList.begin(), m_pChildList.end(), std::mem_fun(&CWindow::UpdateRect)); if (m_pcurVisual) m_pcurVisual->SetPosition(m_rect.left, m_rect.top); if (IsPressed()) PyCallClassMemberFunc(m_poHandler, "OnMove", BuildEmptyTuple()); } void CDragButton::OnMouseOverIn() { if (!IsEnable()) return; CButton::OnMouseOverIn(); PyCallClassMemberFunc(m_poHandler, "OnMouseOverIn", BuildEmptyTuple()); } void CDragButton::OnMouseOverOut() { if (!IsEnable()) return; CButton::OnMouseOverIn(); PyCallClassMemberFunc(m_poHandler, "OnMouseOverOut", BuildEmptyTuple()); } };