ULONG VorticalLayerCtrl::expand(ULONG nItem, BOOL bexpand /*= TRUE*/)
{
m_bCached = FALSE;
ULONG nLine = m_pRoot->expand(nItem, TRUE, bexpand);
if (bexpand)
{
WFX_CONDITION(nItem < m_rgCacheInfo.size());
m_rgCacheInfo[nItem].m_bexpanded = TRUE;
for (int i = 0; i < nLine; i++)
{
WFX_CONDITION(nItem + i + 1 <= m_rgCacheInfo.size());
CacheInfo chinfo(getLayer(nItem + i + 1), TRUE);
m_rgCacheInfo.insert(m_rgCacheInfo.begin() + nItem + 1, chinfo);
}
}
else
{
m_rgCacheInfo[nItem].m_bexpanded = FALSE;
for (int i = 0; i < nLine; i++)
{
WFX_CONDITION(nItem + i + 1 < m_rgCacheInfo.size());
m_rgCacheInfo.erase(m_rgCacheInfo.begin() + nItem + 1);
}
}
refreshCache();
return m_rgCacheInfo.size();
}
void Dispatcher::drawGen( Widget* pWid, HDC hdc, const Rect& rcPaint)
{
WFX_CONDITION(pWid != NULL);
Rect rcTemp;
Rect rcItem = pWid->getRect();
if (!::IntersectRect(&rcTemp, &rcPaint, &rcItem))
return;
if (!pWid->isShow())
return;
WfxRender::RenderClip clip(hdc, rcItem);
pWid->onDraw(hdc, rcPaint);
WfxRender::drawFrame(hdc, rcItem, WBTN_BKGND_MOUSE);
std::vector<Widget*> rgpChildren;
pWid->getChildren(rgpChildren);
for (std::vector<Widget*>::iterator it =
rgpChildren.begin(); it != rgpChildren.end(); ++it)
{
WFX_CONDITION((*it) != NULL);
if (!::IntersectRect(&rcTemp, &rcItem, &(*it)->getRect()))
continue;
drawGen((*it), hdc, rcPaint);
}
}
void Dispatcher::setLButtonDown(Widget* pWid)
{
WFX_CONDITION(m_hWnd != NULL);
WFX_CONDITION(pWid != NULL);
WFX_CONDITION(*pWid != INVALID_HWID);
m_h2oLButtonDown = std::make_pair(pWid->getHwid(), pWid);
}
Widget* Dispatcher::getWidPt(Widget* pWidget, const Point& pt)
{
WFX_CONDITION(pWidget != NULL);
Widget* pWigetFound = NULL;
if (pWidget->getRect().PtInRect(pt))
{
if (!pWidget->hasChild())
{
return pWidget;
}
std::vector<Widget*> rgpChildren;
pWidget->getChildren(rgpChildren);
for (std::vector<Widget*>::iterator it =
rgpChildren.begin(); it != rgpChildren.end(); ++it)
{
WFX_CONDITION((*it) != NULL);
pWigetFound = getWidPt((*it), pt);
if (pWigetFound != NULL)
{
return pWigetFound;
}
}
if (pWigetFound == NULL)
{
return pWidget;
}
}
return NULL;
}
void Dispatcher::setFocus(Widget* pWid)
{
WFX_CONDITION(m_hWnd != NULL);
WFX_CONDITION(pWid != NULL);
WFX_CONDITION(*pWid != INVALID_HWID);
m_h2oFocused = std::make_pair(pWid->getHwid(), pWid);
}
void Dispatcher::setCapture( Widget* pWid )
{
WFX_CONDITION(m_hWnd != NULL);
WFX_CONDITION(pWid != NULL);
WFX_CONDITION(*pWid != INVALID_HWID);
m_h2oCaptured = std::make_pair(pWid->getHwid(), pWid);
::SetCapture(m_hWnd);
}
void ListCtrl::onDrawSeqHead( const LCDrawItemInfo* pDrawItemInfo )
{
WFX_CONDITION(pDrawItemInfo != NULL);
Cell* pCell = getCell(0, 0);
if (pCell == NULL)
{
return;
}
WFX_CONDITION(pDrawItemInfo->m_prcItem != NULL);
pCell->Draw(pDrawItemInfo->m_hDC, *(pDrawItemInfo->m_prcItem),
pDrawItemInfo->m_dwState, L"SEQ", WBTN_BKGND_MOUSE, 0);
}
BOOL Timer::killTimer( Widget* pWid, UINT_PTR nWidTimer )
{
WFX_CONDITION(m_pDispatch != NULL);
WFX_CONDITION(pWid!=NULL);
UINT_PTR nWndTimer = 0;
if (!m_pTimerTranslator->WidTimerToWndTimer(pWid, nWidTimer, nWndTimer))
{
return FALSE;
}
BOOL bRet = ::KillTimer(m_pDispatch->getHwnd(), nWndTimer);
m_pTimerTranslator->removeWidTimer(pWid, nWidTimer);
return bRet;
}
LRESULT LayoutDispatch::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam,
BOOL& bHandled)
{
WFX_CONDITION(m_pRoot != NULL);
if (m_pRoot != NULL)
{
WFX_CONDITION(GetHwnd() != NULL);
Rect rcClient;
::GetClientRect(GetHwnd(), &rcClient);
m_pRoot->SetRect(rcClient);
}
return 1;
}
void ListCtrl::onDrawHeadCtrl( const LCDrawItemInfo* pDrawItemInfo )
{
WFX_CONDITION(pDrawItemInfo != NULL);
Cell* pCell = getCell(0, 0);
if (pCell == NULL)
{
return;
}
WFX_CONDITION(pDrawItemInfo->m_prcItem != NULL);
WFX_CONDITION(pDrawItemInfo->m_pszText != NULL);
pCell->Draw(pDrawItemInfo->m_hDC, *(pDrawItemInfo->m_prcItem), pDrawItemInfo->m_dwState,
pDrawItemInfo->m_pszText, WBTN_BKGND_MOUSE, pDrawItemInfo->m_dwFormat);
}
UINT_PTR Timer::setTimer( Widget* pWid,
UINT_PTR nWidTimer, UINT uElapse,
TIMERPROC lpTimerFunc )
{
WFX_CONDITION(m_pDispatch != NULL);
WFX_CONDITION(pWid != NULL);
WFX_CONDITION(uElapse > 0);
UINT_PTR nWndTimer = 0;
if (!m_pTimerTranslator->WidTimerToWndTimer(pWid, nWidTimer, nWndTimer))
{
return 0;
}
return ::SetTimer(m_pDispatch->getHwnd(), nWndTimer, uElapse, lpTimerFunc);
}
void WidDispatch::SetWidRect( Widget* pWid, const Rect& rc )
{
WFX_CONDITION(pWid != NULL);
Rect rcWid;
rcWid = pWid->GetRect();
Rect rcSB = rcWid;
Rect rcDraw = rcWid;
Size sz(pWid->SendWidMessage(WUM_QUERY_VIRTUAL_SIZE));
BOOL bOutRangeHorz = rcWid.right - rcWid.left < sz.cx;
BOOL bOutRangeVert = rcWid.bottom - rcWid.top < sz.cy;
if (pWid->GetSBFlag() & WESB_VERT)
{
WFX_CONDITION(pWid->GetScrollBar(SB_VERT) != NULL);
if (!bOutRangeVert)
{
memset(&rcSB, 0, sizeof(Rect));
}
else
{
rcSB.left = rcWid.right - SIZE_SCROLLBAR - 1;
rcSB.right = rcSB.left + SIZE_SCROLLBAR;
rcSB.top += 1;
rcSB.bottom -= SIZE_SCROLLBAR + 1;
}
pWid->GetScrollBar(SB_VERT)->SetRect(rcSB);
rcDraw.right -= rcSB.right - rcSB.left;
}
rcSB = rcWid;
if (pWid->GetSBFlag() & WESB_HORZ)
{
WFX_CONDITION(pWid->GetScrollBar(SB_HORZ) != NULL);
if (!bOutRangeHorz)
{
memset(&rcSB, 0, sizeof(Rect));
}
else
{
rcSB.left += 1;
rcSB.right -= SIZE_SCROLLBAR + 1;
rcSB.top = rcWid.top + rcWid.bottom - rcWid.top - SIZE_SCROLLBAR - 1;
rcSB.bottom = rcSB.top + SIZE_SCROLLBAR;
}
pWid->GetScrollBar(SB_HORZ)->SetRect(rcSB);
rcDraw.bottom -= rcSB.bottom - rcSB.top;
}
pWid->SetDrawRect(rcDraw);
pWid->SendWidMessage(WM_SIZE, 0, 0);
}
BOOL Dispatcher::createWid( Widget* pThis )
{
WFX_CONDITION(pThis != NULL);
WFX_CONDITION(pThis->getHwid() == INVALID_HWID);
if (pThis->getHwid() != INVALID_HWID)
{
return FALSE;
}
HWID hNewWid = generateHwid();
WFX_CONDITION(hNewWid != INVALID_HWID);
pThis->setHwid(hNewWid);
WFX_CONDITION(m_Handle2Object.find(hNewWid) == m_Handle2Object.end());
m_Handle2Object.insert(std::make_pair(hNewWid, pThis));
return TRUE;
}
void Dispatcher::drawWid( Widget* pWid, const Rect& rcPaint )
{
WFX_CONDITION(m_hWnd != NULL);
WFX_CONDITION(pWid != NULL);
if (!pWid->isShow())
{
return;
}
__begin_mem_draw
WfxRender::MemDC drawdc(m_hWnd, rcPaint);
drawBkgnd(pWid, drawdc, rcPaint);
drawGen(pWid, drawdc, rcPaint);
__end_mem_draw;
}
ULONG TNode::addChild(const SPTNode& pNode)
{
WFX_CONDITION(pNode != NULL);
pNode->setParent(this);
m_rgpChildren.push_back(pNode);
return m_rgpChildren.size();
}
Widget* WidDispatch::GetWidPt( POINT pt )
{
Widget* pWid = NULL;
std::vector<Widget*> rgpWidInPt;
for (std::map<HWID, Widget*>::iterator it = m_Handle2Object.begin();
it != m_Handle2Object.end(); ++it)
{
WFX_CONDITION(it->second != NULL);
Rect rcWid = it->second->GetRect();
if (rcWid.PtInRect(pt))
{
rgpWidInPt.push_back(it->second);
}
}
if (rgpWidInPt.size() > 0)
{
if (rgpWidInPt.size() != 1)
{
pWid = GetWidPt(rgpWidInPt);
}
else
{
pWid = rgpWidInPt[0];
}
}
return pWid;
}
LRESULT Dispatcher::onLButtonDown( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
Point pt(lParam);
Widget* pWid = NULL;
LRESULT lResult = 0;
WFX_CONDITION(m_hWnd != NULL);
::SetFocus(m_hWnd);
pWid = getWidPt(pt);
if (pWid != NULL)
{
if (pWid->getHwid() != m_h2oFocused.first
&& pWid != m_h2oFocused.second)
{
if (m_h2oFocused.second != NULL)
{
m_h2oFocused.second->sendMessage(WM_KILLFOCUS, (WPARAM)pWid->getHwid());
}
}
pWid->sendMessage(WM_SETFOCUS, (WPARAM)m_h2oFocused.first);
setCapture(pWid);
setFocus(pWid);
setLButtonDown(pWid);
lResult = pWid->sendMessage(uMsg, wParam, lParam);
}
else
{
if (m_h2oFocused.second != NULL)
{
m_h2oFocused.second->sendMessage(WM_KILLFOCUS, INVALID_HWID);
}
}
return lResult;
}
BOOL Dispatcher::destroy( HWID& hWid )
{
std::map<HWID, Widget*>::iterator it =
m_Handle2Object.find(hWid);
if (it == m_Handle2Object.end())
{
return FALSE;
}
Widget* pWid = it->second;
WFX_CONDITION(pWid != NULL);
Widget* pParent = pWid->getParent();
if (pParent != NULL)
{
pParent->removeChild(pWid);
}
m_Handle2Object.erase(it);
std::map<HWID, Widget*>::iterator itPaint =
m_h2oOrphan.find(hWid);
if (itPaint != m_h2oOrphan.end())
{
m_h2oOrphan.erase(itPaint);
}
if (m_h2oCaptured.first == hWid)
{
clearH2O(m_h2oCaptured);
}
m_pTimer->destroy(pWid);
recycleHwid(hWid);
return TRUE;
}
void Dispatcher::setWidRect( Widget* pWid, const Rect& rc )
{
WFX_CONDITION(pWid != NULL);
Rect rcWid;
rcWid = pWid->getRect();
pWid->setVirtualSizeCached(FALSE);
Rect rcSB = rcWid;
Rect rcDraw = rcWid;
Size szVirtual = pWid->getVirtualSize();
Size szView(rcWid.getWidth(), rcWid.getHeight());
BOOL bOutRangeHorz = szView.cx < szVirtual.cx;
BOOL bOutRangeVert = szView.cy < szVirtual.cy;
if (pWid->getSBFlag() & WESB_VERT)
{
WFX_CONDITION(pWid->getScrollBar(SB_VERT) != NULL);
if (!bOutRangeVert)
{
rcSB.empty();
pWid->getScrollBar(SB_VERT)->reset();
}
else
{
rcSB = pWid->getScrollBarRect(SB_VERT);
}
pWid->getScrollBar(SB_VERT)->setRect(rcSB);
rcDraw.right -= rcSB.right - rcSB.left;
}
rcSB = rcWid;
if (pWid->getSBFlag() & WESB_HORZ)
{
WFX_CONDITION(pWid->getScrollBar(SB_HORZ) != NULL);
if (!bOutRangeHorz)
{
rcSB.empty();
pWid->getScrollBar(SB_HORZ)->reset();
}
else
{
rcSB = pWid->getScrollBarRect(SB_HORZ);
}
pWid->getScrollBar(SB_HORZ)->setRect(rcSB);
rcDraw.bottom -= rcSB.bottom - rcSB.top;
}
pWid->setClientRect(rcDraw);
pWid->sendMessage(WM_SIZE, 0, 0);
}
Widget* Dispatcher::getObject( const std::pair<HWID, Widget*>& h2o )
{
if (h2o.first != INVALID_HWID)
{
WFX_CONDITION(h2o.second != NULL);
return h2o.second;
}
return NULL;
}
ULONG HeaderCtrl::getCellType(ULONG nCol) const
{
WFX_CONDITION(nCol < m_rgpHdi.size());
if (nCol < m_rgpHdi.size())
{
return m_rgpHdi[nCol]->m_nType;
}
return 0;
}
BOOL VorticalLayerCtrl::isExpanded(ULONG nItem) const
{
if (m_bCached)
{
WFX_CONDITION(nItem < m_rgCacheInfo.size());
return m_rgCacheInfo[nItem].m_bexpanded;
}
return m_pRoot->isExpanded(nItem);
}
LRESULT CommonWnd::onCreate( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
WFX_CONDITION(m_pRoot != NULL);
LONG styleValue = ::GetWindowLongW(*this, GWL_STYLE);
styleValue &= ~WS_CAPTION;
::SetWindowLongW(*this, GWL_STYLE, styleValue | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
Rect rc;
m_pRoot->create(rc, NULL, getDispatcher());
sendMessage(WUM_WIDROOT_CREATE);
return 1;
}
ULONG TNode::InsertChild(ULONG nPos, const SPTNode& pNode)
{
BOOL bCondition = nPos <= m_rgpChildren.size();
WFX_CONDITION(bCondition);
if (bCondition)
{
m_rgpChildren.insert(m_rgpChildren.begin() + nPos, pNode);
return m_rgpChildren.size();
}
return 0;
}
void Dispatcher::onPaint(const Rect& rcPaint)
{
// Note: only orphans need to handle WM_PAINT message,
// parents will handle it for their children.
for (std::map<HWID, Widget*>::iterator it = m_h2oOrphan.begin();
it != m_h2oOrphan.end(); ++it)
{
WFX_CONDITION(it->second != NULL);
drawWid(it->second, rcPaint);
}
}
ULONG VorticalLayerCtrl::insertItem(ULONG nItem)
{
if (m_pRoot->InsertChild(nItem, SPTNode(new TNode)) != 0)
{
setVirtualSizeCached(FALSE);
CacheInfo chinfo(1, TRUE);
WFX_CONDITION(nItem + 1 <= m_rgCacheInfo.size());
m_rgCacheInfo.insert(m_rgCacheInfo.begin() + nItem + 1, chinfo);
}
return m_rgCacheInfo.size();
}
LRESULT Grid::OnCreate( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
Rect rc;
ULONG nItems = m_rgWidLayout.size();
for (ULONG i = 0; i < nItems; i++)
{
WFX_CONDITION(m_rgWidLayout[i].first != NULL);
m_rgWidLayout[i].first->Create(rc, m_pDispatch, this);
}
return 1;
}
LRESULT LayoutDispatch::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam,
BOOL& bHandled)
{
WFX_CONDITION(m_pRoot != NULL);
if (m_pRoot != NULL)
{
Rect rc;
m_pRoot->Create(rc, this);
}
return 1;
}
ULONG HeaderCtrl::insertItem( ULONG nPos,
const HeaderInfo& hdi )
{
WFX_CONDITION(nPos < m_rgpHdi.size());
if (nPos < m_rgpHdi.size())
{
SPHeaderInfo pHdi(new HeaderInfo(hdi));
m_rgpHdi.insert(m_rgpHdi.begin() + nPos, pHdi);
return m_rgpHdi.size();
}
return 0;
}
void Dispatcher::showWid( Widget* pWid, WORD wShow )
{
WFX_CONDITION(pWid != NULL);
pWid->doshowWid(wShow);
std::vector<Widget*> rgpChilren;
pWid->getChildren(rgpChilren);
for (std::vector<Widget*>::iterator it =
rgpChilren.begin(); it != rgpChilren.end(); ++it)
{
showWid((*it), wShow);
}
}
