LRESULT ff::ViewWindow::WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_SIZE:
if (wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED)
{
Layout();
}
break;
case WM_CLOSE:
if (!OnClose())
{
return 0;
}
break;
case WM_DESTROY:
OnDestroy();
break;
}
return DoDefault(hwnd, msg, wParam, lParam);
}
void StatementListVisitor::Visit(StatementList* list)
{
if (list == NULL) return;
const int32 n = list->Size();
for (int32 i = 0; i < n; i ++) {
Statement* statement = list->StatementAt(i);
GroupStatement group(statement);
if (group.IsOpenGroup()) {
BeginGroup(&group);
fLevel ++;
} else if (statement->IsValueStatement()) {
DoValue(statement);
} else if (statement->IsDefaultStatement()) {
DoDefault(statement);
} else if (statement->IsQueryStatement()) {
DoQuery(statement);
} else if (statement->IsParamStatement()) {
DoParam(statement);
}
StatementList* children = statement->GetChildren();
if (children != NULL) {
Visit(children);
}
// Close statements have been removed
if (group.IsOpenGroup()) {
fLevel --;
EndGroup(&group);
}
}
}
//****************************************************************************************
void CBCGPShellList::OnReturn(NMHDR* /*pNMHDR*/, LRESULT* pResult)
{
int nItem = GetNextItem(-1, LVNI_FOCUSED);
if (nItem != -1)
{
DoDefault(nItem);
}
*pResult = 0;
}
// WindowMsgFilter
bool NWindow::OnMessage(UINT message, WPARAM wParam, LPARAM lParam, LRESULT& lResult)
{
if(NWindowBase::OnMessage(message, wParam, lParam, lResult))
return true;
switch(message)
{
case WM_CREATE:
render_ = NUiBus::Instance().CreateRender();
break;
case WM_DESTROY:
render_ = NULL;
rootFrame_ = NULL;
break;
case WM_ERASEBKGND:
lResult = 1;
return true;
case WM_NCACTIVATE:
{
if(::IsIconic(window_))
return false;
lResult = (wParam == 0) ? TRUE : FALSE;
return true;
}
case WM_NCHITTEST:
{
lResult = HTCLIENT;
if((::GetWindowLongPtr(window_, GWL_STYLE) & WS_SIZEBOX) == WS_SIZEBOX)
{
Base::NRect rcWnd;
GetRect(rcWnd);
POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
if(pt.x <= rcWnd.Left + sizableBorder_.Left)
{
if(pt.y <= rcWnd.Top + sizableBorder_.Top)
lResult = HTTOPLEFT;
else if(pt.y >= rcWnd.Bottom - sizableBorder_.Bottom)
lResult = HTBOTTOMLEFT;
else
lResult = HTLEFT;
}
else if(pt.x >= rcWnd.Right - sizableBorder_.Right)
{
if(pt.y <= rcWnd.Top + sizableBorder_.Top)
lResult = HTTOPRIGHT;
else if(pt.y >= rcWnd.Bottom - sizableBorder_.Bottom)
lResult = HTBOTTOMRIGHT;
else
lResult = HTRIGHT;
}
else if(pt.y <= rcWnd.Top + sizableBorder_.Top)
{
lResult = HTTOP;
}
else if(pt.y >= rcWnd.Bottom - sizableBorder_.Bottom)
{
lResult = HTBOTTOM;
}
}
return true;
}
case WM_NCPAINT:
case WM_NCCALCSIZE:
{
lResult = 0;
return true;
}
case WM_SIZE:
if(wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED)
{
lResult = DoDefault(message, wParam, lParam);
OnSize(LOWORD(lParam), HIWORD(lParam));
return true;
}
break;
case WM_ACTIVATE:
{
BOOL bActive = (LOWORD(wParam) != WA_INACTIVE);
if(!bActive)
{
SetHoverItem(NULL);
NUiBus::Instance().SetCaptureFrame(NULL);
}
break;
}
case WM_MOUSEMOVE:
{
Base::NPoint point(LOWORD(lParam), HIWORD(lParam));
RefreshHoverItem(point);
}
break;
case WM_LBUTTONDOWN:
{
Base::NPoint point(LOWORD(lParam), HIWORD(lParam));
RefreshHoverItem(point);
if(hoverFrame_ == NULL)
{
::SendMessage(window_, WM_SYSCOMMAND, SC_MOVE | HTCAPTION, 0);
}
else
{
::SetCapture(window_);
}
}
break;
case WM_LBUTTONUP:
if(::GetCapture() == window_)
{
::ReleaseCapture();
if(hoverFrame_ != NULL)
{
Base::NPoint point(LOWORD(lParam), HIWORD(lParam));
hoverFrame_->OnClicked(point);
if(hoverFrame_)
hoverFrame_->UpdateStatus(NFrame::StatusPressed, false);
}
}
break;
case WM_MOUSELEAVE:
SetHoverItem(NULL);
break;
}
return false;
}
// Actual allocation is done by an instance of real allocator,
// which is specified by the template parameter.
TestAllocator() : real(createAllocator<T>())
{
// We use 'ON_CALL' and 'WillByDefault' here to specify the
// default actions (call in to the real allocator). This allows
// the tests to leverage the 'DoDefault' action.
// However, 'ON_CALL' results in a "Uninteresting mock function
// call" warning unless each test puts expectations in place.
// As a result, we also use 'EXPECT_CALL' and 'WillRepeatedly'
// to get the best of both worlds: the ability to use 'DoDefault'
// and no warnings when expectations are not explicit.
ON_CALL(*this, initialize(_, _, _))
.WillByDefault(InvokeInitialize(this));
EXPECT_CALL(*this, initialize(_, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, recover(_, _))
.WillByDefault(InvokeRecover(this));
EXPECT_CALL(*this, recover(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, addFramework(_, _, _, _, _))
.WillByDefault(InvokeAddFramework(this));
EXPECT_CALL(*this, addFramework(_, _, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, removeFramework(_))
.WillByDefault(InvokeRemoveFramework(this));
EXPECT_CALL(*this, removeFramework(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, activateFramework(_))
.WillByDefault(InvokeActivateFramework(this));
EXPECT_CALL(*this, activateFramework(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, deactivateFramework(_))
.WillByDefault(InvokeDeactivateFramework(this));
EXPECT_CALL(*this, deactivateFramework(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateFramework(_, _, _))
.WillByDefault(InvokeUpdateFramework(this));
EXPECT_CALL(*this, updateFramework(_, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, addSlave(_, _, _, _, _, _))
.WillByDefault(InvokeAddSlave(this));
EXPECT_CALL(*this, addSlave(_, _, _, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, removeSlave(_))
.WillByDefault(InvokeRemoveSlave(this));
EXPECT_CALL(*this, removeSlave(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateSlave(_, _, _, _))
.WillByDefault(InvokeUpdateSlave(this));
EXPECT_CALL(*this, updateSlave(_, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, addResourceProvider(_, _, _))
.WillByDefault(InvokeAddResourceProvider(this));
EXPECT_CALL(*this, addResourceProvider(_, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, activateSlave(_))
.WillByDefault(InvokeActivateSlave(this));
EXPECT_CALL(*this, activateSlave(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, deactivateSlave(_))
.WillByDefault(InvokeDeactivateSlave(this));
EXPECT_CALL(*this, deactivateSlave(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateWhitelist(_))
.WillByDefault(InvokeUpdateWhitelist(this));
EXPECT_CALL(*this, updateWhitelist(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, requestResources(_, _))
.WillByDefault(InvokeRequestResources(this));
EXPECT_CALL(*this, requestResources(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateAllocation(_, _, _, _))
.WillByDefault(InvokeUpdateAllocation(this));
EXPECT_CALL(*this, updateAllocation(_, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateAvailable(_, _))
.WillByDefault(InvokeUpdateAvailable(this));
EXPECT_CALL(*this, updateAvailable(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateUnavailability(_, _))
.WillByDefault(InvokeUpdateUnavailability(this));
EXPECT_CALL(*this, updateUnavailability(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateInverseOffer(_, _, _, _, _))
.WillByDefault(InvokeUpdateInverseOffer(this));
EXPECT_CALL(*this, updateInverseOffer(_, _, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, getInverseOfferStatuses())
.WillByDefault(InvokeGetInverseOfferStatuses(this));
EXPECT_CALL(*this, getInverseOfferStatuses())
.WillRepeatedly(DoDefault());
ON_CALL(*this, recoverResources(_, _, _, _))
.WillByDefault(InvokeRecoverResources(this));
EXPECT_CALL(*this, recoverResources(_, _, _, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, suppressOffers(_, _))
.WillByDefault(InvokeSuppressOffers(this));
EXPECT_CALL(*this, suppressOffers(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, reviveOffers(_, _))
.WillByDefault(InvokeReviveOffers(this));
EXPECT_CALL(*this, reviveOffers(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, setQuota(_, _))
.WillByDefault(InvokeSetQuota(this));
EXPECT_CALL(*this, setQuota(_, _))
.WillRepeatedly(DoDefault());
ON_CALL(*this, removeQuota(_))
.WillByDefault(InvokeRemoveQuota(this));
EXPECT_CALL(*this, removeQuota(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, updateWeights(_))
.WillByDefault(InvokeUpdateWeights(this));
EXPECT_CALL(*this, updateWeights(_))
.WillRepeatedly(DoDefault());
ON_CALL(*this, pause())
.WillByDefault(InvokePause(this));
EXPECT_CALL(*this, pause())
.WillRepeatedly(DoDefault());
ON_CALL(*this, resume())
.WillByDefault(InvokeResume(this));
EXPECT_CALL(*this, resume())
.WillRepeatedly(DoDefault());
}
bool
TKSwitch::
Statement(SyntaxHandler & sh)
{
// Switches must have braces
TokenType::E_TYPE
type = sh.Advance(TokenType::TO_BRACE_O).GetType();
if (type == TokenType::TO_BRACE_C)
{
Message::Send(Message::EMPTY_SWITCH);
sh.Advance(TokenType::TO_BRACE_C);
return false;
}
else if (type == TokenType::TT_EOS)
{
Message::Send(Message::EMPTY_SWITCH);
sh.EoS();
return false;
}
bool
def = false;
for ( ; ; )
{
switch (type)
{
case TokenType::TO_BRACE_C:
// Could warn them here if
// they don't have a default
// statement, but we won't.
/*if (!def)
{
Message::Send(Message::NO_DEFAULT);
}*/
sh.Advance(TokenType::TO_BRACE_C);
return true;
case TokenType::TT__END:
case TokenType::TT__EOF:
Message::Send(Message::UNEXPECTED_EOF);
return false;
case TokenType::TK_case:
// Add the case statement
Add(DoCase(sh));
break;
case TokenType::TK_default:
// Check for multiple defaults
if (def)
{
Message::Send(Message::MULTI_DEFAULT);
// Get rid of the second default
delete &DoDefault(sh);
}
else
{
// Add the default statement
Add(DoDefault(sh));
// Mark as done default
def = true;
}
break;
default:
Message::Send(Message::UNEXPECTED_TOKEN, SC::L(type));
break;
}
type = sh.GetCurrent().GetType();
}
}