BOOL CDockContext::Track()
/************************/
{
ASSERT( m_pBar != NULL );
m_pBar->SetCapture();
while( CWnd::GetCapture() == m_pBar ) {
MSG msg;
if( !::GetMessage( &msg, NULL, 0, 0 ) ) {
::PostQuitMessage( msg.wParam );
::ReleaseCapture();
break;
}
if( msg.message == WM_MOUSEMOVE ) {
Move( msg.pt );
} else if( msg.message == WM_LBUTTONUP ) {
EndDrag();
::ReleaseCapture();
return( TRUE );
} else if( msg.message == WM_KEYDOWN ) {
OnKey( msg.wParam, TRUE );
} else if( msg.message == WM_KEYUP ) {
OnKey( msg.wParam, FALSE );
}
}
return( FALSE );
}
void App::ProcessEvents()
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT)
{
Quit();
}
else if (event.type == SDL_KEYDOWN)
{
OnKey(event.key, true);
}
else if (event.type == SDL_KEYUP)
{
OnKey(event.key, false);
}
else if (event.type == SDL_MOUSEBUTTONDOWN)
{
OnMouseButton(event.button.x, event.button.y, event.button.button, true);
}
else if (event.type == SDL_MOUSEBUTTONUP)
{
OnMouseButton(event.button.x, event.button.y, event.button.button, false);
}
else if (event.type == SDL_MOUSEMOTION)
{
OnMouseMove(event.button.x, event.button.y);
}
//TODO add more event filters as appropriate
}
}
BOOL CCJDockContext::TrackDockBar()
{
if (::GetCapture() != NULL)
return FALSE;
m_pBar->SetCapture();
ASSERT(m_pBar == CWnd::GetCapture());
while (CWnd::GetCapture() == m_pBar)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
AfxPostQuitMessage(msg.wParam);
break;
}
switch (msg.message)
{
case WM_LBUTTONUP:
if (m_bDragging)
EndDragDockBar();
else
EndResize();
return TRUE;
case WM_MOUSEMOVE:
if (m_bDragging)
MoveDockBar(msg.pt);
else
Stretch(msg.pt);
break;
case WM_KEYUP:
if (m_bDragging)
OnKey((int)msg.wParam, FALSE);
break;
case WM_KEYDOWN:
if (m_bDragging)
OnKey((int)msg.wParam, TRUE);
if (msg.wParam == VK_ESCAPE)
{
CancelLoop();
return FALSE;
}
break;
case WM_RBUTTONDOWN:
CancelLoop();
return FALSE;
// just dispatch rest of the messages
default:
DispatchMessage(&msg);
break;
}
}
CancelLoop();
return FALSE;
}
// Window Message handler. Interprets windows messages and dispatches
// mouse/keyboard input to the OnMouse/OnKeyboard functions.
LRESULT FxPlayerTiny::MemberWndProc(UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_SETCURSOR:
if (LOWORD(lParam)==HTCLIENT)
{
::SetCursor(::LoadCursor(0, IDC_ARROW));
return 0;
}
break;
// *** The following logic is used to route input to GFxPlayer.
case WM_MOUSEMOVE:
OnMouse(GFxEvent::MouseMove, 0, LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_LBUTTONDOWN:
::SetCapture(hWnd);
OnMouse(GFxEvent::MouseDown, 0, LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_LBUTTONUP:
::ReleaseCapture();
OnMouse(GFxEvent::MouseUp, 0, LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_KEYDOWN:
OnKey((UInt)wParam, 1);
return 0;
case WM_KEYUP:
OnKey((UInt)wParam, 0);
return 0;
case WM_CHAR:
{
UInt32 wcharCode = (UInt32)wParam;
if (pMovie && wcharCode)
{
GFxCharEvent event(wcharCode);
pMovie->HandleEvent(event);
}
}
break;
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
void SpectDisplay::OnMenu(wxCommandEvent& event)
{//=============================================
int id;
int code;
wxKeyEvent keyevent;
SpectFrame *sf;
static int key[] = {0x1044,0x3044,0x104e,0x1047,0x105a,0x1051,0x3051,WXK_F1,WXK_F2,0x1049,WXK_F10,0x104b};
id = event.GetId();
if(id >= 300)
{
sf = spectseq->frames[sframe];
sf->ToggleMarker(id-300);
Refresh();
return;
}
// simulate a KeyEvent that corresponds to this menu entry
code = key[id - 201];
keyevent.m_keyCode = code & 0xfff;
if(code & 0x1000)
keyevent.m_controlDown = TRUE;
else
keyevent.m_controlDown = FALSE;
if(code & 0x2000)
keyevent.m_shiftDown = TRUE;
else
keyevent.m_shiftDown = FALSE;
OnKey(keyevent);
}
bool Listen(SDL_Event &event)
{
switch (event.type)
{
case SDL_KEYDOWN:
OnKey(event.key.keysym.sym);
break;
case SDL_KEYUP:
break;
case SDL_MOUSEMOTION:
mx = float(event.motion.x) / float(screen_width);
my = float(event.motion.y) / float(screen_height);
break;
case SDL_MOUSEBUTTONDOWN:
break;
case SDL_MOUSEBUTTONUP:
break;
case SDL_JOYAXISMOTION:
break;
case SDL_JOYBUTTONDOWN:
break;
case SDL_JOYBUTTONUP:
break;
case SDL_QUIT:
AppRunning = false;
break;
case SDL_VIDEORESIZE:
Reshape(event.resize.w, event.resize.h);
break;
default:
return false;
break;
}
return true;
}
BOOL cIMEWnd::OnMsg(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
if(!m_pDockingEx ) return FALSE;
switch(msg)
{
case WM_IME_COMPOSITION:
case WM_IME_CHAR:
{
return OnIMEComposition(hWnd, msg, wparam, lparam);
}
break;
case WM_CHAR:
{
return OnChar(hWnd, msg, wparam, lparam);
}
break;
case WM_KEYDOWN:
{
return OnKey(hWnd, msg, wparam, lparam);
}
break;
case WM_KEYUP:
{
if( wparam == VK_CONTROL )
m_bCtrlPushed = FALSE;
}
break;
}
return TRUE;
}
bool CMMsgBox::OnKey(AWS_KeyType type, AWS_KeyCode code)
{
if ( AWS_Key_Up == type )
{
switch ( code )
{
case AWS_KeyCode_LeftMenu:
OnLeftMenu();
return true;
case AWS_KeyCode_RightMenu:
OnRightMenu();
return true;
}
}
if ( AWS_Key == type )
{
switch ( code )
{
case AWS_KeyCode_OK:
return OnKey(AWS_Key_Up, AWS_KeyCode_LeftMenu);
}
}
return true;
// return CAwsContainer::OnKey(type, code);
}
//---------------------------------------------------------------------------
//process individual OnKey events passed from pushkeys
//and default key delay
void TPushKeys::HandleOnKeyEvent(CString &Key,TShiftState &ShiftState)
{
//pass keys to users OnKey event handler
if (OnKey)
{
OnKey(this,Key,ShiftState);
}
}
void menu_Key(int key, int mod)
{
for(int i = g_itemStack.size() - 1; i >= 0; --i)
{
auto ptr = g_itemStack[i];
if(ptr->OnKey(key, mod))
break;
}
}
LRESULT CALLBACK MsgProc1(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
HDC hdc;
PAINTSTRUCT pc;
RECT rc;
GetClientRect(hwnd, &rc);
POINT WindowCenter = { rc.left + (rc.right - rc.left) / 2, rc.top + (rc.bottom - rc.top) / 2 };
switch (message)
{
case WM_MOUSEMOVE: {
// Convert mouse motion to be relative
// (report the offset and re-center).
POINT newPos = { LOWORD(lparam), HIWORD(lparam) };
::ClientToScreen(hwnd, &newPos);
if ((newPos.x == WindowCenter.x) && (newPos.y == WindowCenter.y))
break;
SetCursorPos(WindowCenter.x, WindowCenter.y);
const float Sensitivity = 1.0f;
MouseRotY -= (Sensitivity * (newPos.x - WindowCenter.x)) / 360.0f;
if (newPos.x < WindowCenter.x)
{
GraphicsEngine::Instance().GetScene().getCameraController()->setLeftRotation();
}
else
{
GraphicsEngine::Instance().GetScene().getCameraController()->setRightRotation();
}
break;
}
case WM_KEYDOWN: OnKey(wparam, true); break;
case WM_KEYUP: OnKey(wparam, false); break;
case WM_PAINT:
hdc = BeginPaint(hwnd, &pc);
EndPaint(hwnd, &pc);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, message, wparam, lparam);
}
return 0;
}
LRESULT CALLBACK MyFunc( HWND h, UINT msg, WPARAM w, LPARAM p )
{
int x = ( ( int )( short )LOWORD( p ) ), y = ( ( int )( short )HIWORD( p ) );
float Xf = ( float )x / ( float )WindowW;
float Yf = ( float )y / ( float )WindowH;
switch ( msg )
{
case WM_KEYUP:
OnKey( w, false );
if ( w == 27 ) { SendMessage( h, WM_DESTROY, 0, 0 ); }
break;
case WM_KEYDOWN:
OnKey( w, true );
break;
case WM_LBUTTONDOWN:
SetCapture( h );
OnMouseDown( 0, LVector2( Xf, Yf ) );
break;
case WM_MOUSEMOVE:
OnMouseMove( LVector2( Xf, Yf ) );
break;
case WM_LBUTTONUP:
OnMouseUp( 0, LVector2( Xf, Yf ) );
ReleaseCapture();
break;
case WM_DESTROY:
PostQuitMessage( 0 );
break;
}
return DefWindowProc( h, msg, w, p );
}
LRESULT CDangleWindowHex::DangleProc(UINT Msg,WPARAM wParam,LPARAM lParam)
{
//выбор по сообщению
switch(Msg)
{
case WM_KEYDOWN:
return OnKey(wParam),0;
case WM_COMMAND:
return OnCommand(LOWORD(wParam),HIWORD(wParam),(HWND)lParam),0;
case WM_MOUSEWHEEL:
return OnMouseWheel(GET_WHEEL_DELTA_WPARAM(wParam)/WHEEL_DELTA,GET_KEYSTATE_WPARAM(wParam)),0;
default:
return DefWindowProc(mhWindow,Msg,wParam,lParam);
}
}
dword Tapplication::EventHandler( word event, dword param1, dword param2 )
{
if (IsClosing())
return param1;
switch ( event )
{
case EVT_IDLE:
OnIdle();
return 0;
case EVT_KEY:
if (m_reshowUIKey != 0)
return OnKeyWhenHidden(param1, param2);
return OnKey( param1, param2 );
default:
return OnOtherEvent(event, param1, param2);
}
}
bool CWidgetDisplay::HandleEvent(SDL_Event vEvent, CPaintingParms* pPaintingParms)
{
// Handle keyboard and mouse events
switch (vEvent.type)
{
case SDL_KEYDOWN:
//case SDL_KEYUP:
OnKey(vEvent, pPaintingParms);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
OnMouse(vEvent, pPaintingParms);
break;
default:
break;
}
return true;
}
JNIEXPORT void JNICALL Java_com_packtpub_ndkcookbook_game1_Game1Activity_DrawFrame( JNIEnv* env, jobject obj )
{
// send events synchronously
{
LMutex Lock( &g_MotionEventsQueueMutex );
for ( auto m : g_MotionEventsQueue )
{
GestureHandler_SendMotion( m.ContactID, m.Flag, m.Pos, m.Pressed );
}
for ( auto m : g_KeysQueue )
{
OnKey( m.Code, m.Pressed );
}
g_MotionEventsQueue.clear();
g_KeysQueue.clear();
}
GenerateTicks();
}
bool WindowSDL::Update()
{
if(_is_destroyed)
return false;
SDL_Event e;
while(SDL_PollEvent(&e))
{
if(e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_CLOSE)
_is_destroyed = true;
else if(e.type == SDL_KEYDOWN || e.type == SDL_KEYUP)
OnKey(ToKeyEvent(e.type, e.key.keysym));
else if(e.type == SDL_MOUSEBUTTONUP)
{
switch(e.button.button)
{
case SDL_BUTTON_LEFT: OnMouseUp(1); break;
case SDL_BUTTON_RIGHT: OnMouseUp(2); break;
case SDL_BUTTON_MIDDLE: OnMouseUp(3); break;
}
}
else if(e.type == SDL_MOUSEBUTTONDOWN)
{
switch(e.button.button)
{
case SDL_BUTTON_LEFT: OnMouseDown(1); break;
case SDL_BUTTON_RIGHT: OnMouseDown(2); break;
case SDL_BUTTON_MIDDLE: OnMouseDown(3); break;
}
}
else if(e.type == SDL_MOUSEMOTION)
{
OnMouseMove(e.motion.x, e.motion.y);
}
}
return !_is_destroyed;
}
BOOL CDockContext::Track()
{
// don't handle if capture already set
if (::GetCapture() != NULL)
return FALSE;
// set capture to the window which received this message
m_pBar->SetCapture();
ASSERT(m_pBar == CWnd::GetCapture());
#ifndef _MAC
// get messages until capture lost or cancelled/accepted
while (CWnd::GetCapture() == m_pBar)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
AfxPostQuitMessage(msg.wParam);
break;
}
switch (msg.message)
{
case WM_LBUTTONUP:
if (m_bDragging)
EndDrag();
else
EndResize();
return TRUE;
case WM_MOUSEMOVE:
if (m_bDragging)
Move(msg.pt);
else
Stretch(msg.pt);
break;
case WM_KEYUP:
if (m_bDragging)
OnKey((int)msg.wParam, FALSE);
break;
case WM_KEYDOWN:
if (m_bDragging)
OnKey((int)msg.wParam, TRUE);
if (msg.wParam == VK_ESCAPE)
{
CancelLoop();
return FALSE;
}
break;
case WM_RBUTTONDOWN:
CancelLoop();
return FALSE;
// just dispatch rest of the messages
default:
DispatchMessage(&msg);
break;
}
}
#else
Point ptCur = {0};
// get messages until capture lost or cancelled/accepted
while (CWnd::GetCapture() == m_pBar)
{
EventRecord er;
if (OSEventAvail(everyEvent, &er))
{
GetNextEvent(everyEvent, &er);
switch (er.what)
{
case mouseUp:
if (m_bDragging)
EndDrag();
else
EndResize();
return TRUE;
case keyDown:
case keyUp:
case autoKey:
case app2Evt:
{
MSG msg;
if (WrapEvent(&er, &msg, PM_REMOVE))
{
if (m_bDragging)
OnKey((int)msg.wParam, msg.message == WM_KEYDOWN);
if (msg.message == WM_KEYUP && msg.wParam == VK_ESCAPE)
{
CancelLoop();
return FALSE;
}
}
break;
}
default:
break;
}
}
else
{
if (!EqualPt(er.where, ptCur))
{
POINT pt = {er.where.h, er.where.v};
if (m_bDragging)
Move(pt);
else
Stretch(pt);
}
}
}
#endif
CancelLoop();
return FALSE;
}
bool CBMenu::OnKey(AWS_KeyType type, AWS_KeyCode code)
{
CEspRect rt;
rt.m_ptLT.m_nX = m_nFullBorderPixel;
rt.m_ptRB.m_nX = m_nMenuWidth - m_nFullBorderPixel;
if ( AWS_Key == type )
{
switch ( code )
{
case AWS_KeyCode_UpArrow:
if ( m_nFocusItemIndex > 0 )
{
--m_nFocusItemIndex;
if ( m_nFocusItemIndex < m_nDrawItemStartIndex )
{
m_nDrawItemStartIndex = m_nFocusItemIndex;
// 全都要移动
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nDrawItemCount * m_nItemHeight;
InvalideRect(rt);
}
else
{
// 只需要移动两个
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight + (m_nFocusItemIndex - m_nDrawItemStartIndex) * m_nItemHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight * 2;
InvalideRect(rt);
}
}
else
{
m_nFocusItemIndex = m_nItemCount - 1;
int n = m_nItemCount - m_nDrawItemCount;
if ( n != m_nDrawItemStartIndex )
{
// 全都要移动
m_nDrawItemStartIndex = n;
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nDrawItemCount * m_nItemHeight;
InvalideRect(rt);
}
else
{
// 只需要移动两个
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight;
InvalideRect(rt);
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight + (m_nDrawItemCount - 1) * m_nItemHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight;
InvalideRect(rt);
}
}
return true;
case AWS_KeyCode_DownArrow:
if ( m_nFocusItemIndex < m_nItemCount - 1 )
{
++m_nFocusItemIndex;
if ( m_nFocusItemIndex - m_nDrawItemStartIndex >= m_nDrawItemCount )
{
++m_nDrawItemStartIndex;
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nDrawItemCount * m_nItemHeight;
InvalideRect(rt);
}
else
{
// 只需要移动两个
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight + (m_nFocusItemIndex -1 - m_nDrawItemStartIndex) * m_nItemHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight * 2;
InvalideRect(rt);
}
}
else
{
int n = m_nDrawItemStartIndex;
m_nFocusItemIndex = 0;
m_nDrawItemStartIndex = 0;
if ( 0 != n )
{
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nDrawItemCount * m_nItemHeight;
InvalideRect(rt);
}
else
{
// 只需要移动两个
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight;
InvalideRect(rt);
rt.m_ptLT.m_nY = m_nFullBorderPixel + m_nTBBorderHeight + (m_nDrawItemCount - 1) * m_nItemHeight;
rt.m_ptRB.m_nY = rt.m_ptLT.m_nY + m_nItemHeight;
InvalideRect(rt);
}
}
return true;
case AWS_KeyCode_LeftArrow:
if ( m_bIsSubMenu )
{
// 销毁自己
DestroyPopWnd();
}
return true;
case AWS_KeyCode_RightArrow:
if ( m_pItemData[m_nFocusItemIndex].m_nSubMenuID > 0 )
{
CEspPoint ptLT;
ptLT.m_nX = m_tRect.m_ptLT.m_nX + m_nMenuWidth;
ptLT.m_nY = m_tRect.m_ptLT.m_nY + m_nItemHeight * (m_nFocusItemIndex - m_nDrawItemStartIndex);
PumpCommand(m_nWndID, AWS_SysCmd_PopMenu, m_pItemData[m_nFocusItemIndex].m_nSubMenuID, (int)(&ptLT));
}
return true;
case AWS_KeyCode_OK:
if ( m_pItemData[m_nFocusItemIndex].m_nSubMenuID > 0 )
{
return OnKey(type, AWS_KeyCode_RightArrow);
}
else
{
PostCommand(m_nWndID, AWS_SysCmd_MenuCmd, m_nFocusItemIndex);
PumpCommand(m_nWndID, AWS_SysCmd_MenuDestroy);
// 销毁所有弹出式菜单
DestroyPopWnd(m_nPopMenuCount);
return true;
}
}
}
if ( AWS_Key_Up == type )
{
if ( !m_bIsPopupOnly )
{
switch ( code )
{
case AWS_KeyCode_LeftMenu:
return OnKey(AWS_Key, AWS_KeyCode_OK);
case AWS_KeyCode_RightMenu:
// 销毁所有弹出式菜单
PumpCommand(m_nWndID, AWS_SysCmd_MenuDestroy);
DestroyPopWnd(m_nPopMenuCount);
return true;
}
}
if ( code >= AWS_KeyCode_1 && code <= AWS_KeyCode_9 )
{
int nIndex = code - AWS_KeyCode_1;
if ( nIndex < m_nItemCount )
{
// 重绘前focus窗口
int n = m_nFocusItemIndex;
CEspRect rect;
m_nFocusItemIndex = nIndex;
if ( GetItemRectFromIndex(n, rect) )
InvalideRect(rect);
if ( GetItemRectFromIndex(m_nFocusItemIndex, rect) )
InvalideRect(rect);
return OnKey(AWS_Key, AWS_KeyCode_OK);
}
}
}
if ( m_bIsPopupOnly )
return CAwsContainer::OnKey(type, code);
else
return true;
}
void CWallTool::OnGoldKey () { OnKey (2); }
void CWallTool::OnRedKey () { OnKey (3); }
void CWallTool::OnNoKey () { OnKey (0); }
void CWallTool::OnBlueKey () { OnKey (1); }
BOOL COXDragDockContext::Track()
{
// don't handle if capture already set
if (::GetCapture() != NULL)
return FALSE;
// set capture to the window which received this message
m_pBar->SetCapture();
ASSERT(m_pBar == CWnd::GetCapture());
// get messages until capture lost or cancelled/accepted
while(CWnd::GetCapture() == m_pBar)
{
MSG msg;
#ifndef _MAC
if (!::GetMessage(&msg, NULL, 0, 0))
#else
// don't allow yielding while tracking since we don't have LockWindowUpdate
if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE|PM_NOYIELD))
continue;
if (msg.message == WM_QUIT)
#endif
{
AfxPostQuitMessage(PtrToInt(msg.wParam));
break;
}
switch (msg.message)
{
case WM_LBUTTONUP: // drag finished
EndDrag();
return TRUE;
case WM_MOUSEMOVE:
Move(msg.pt);
break;
case WM_KEYUP:
OnKey((int)msg.wParam, FALSE);
break;
case WM_KEYDOWN:
OnKey((int)msg.wParam, TRUE);
if (msg.wParam == VK_ESCAPE)
goto exit_cancel_drag;
break;
case WM_RBUTTONDOWN:
goto exit_cancel_drag;
// just dispatch rest of the messages
default:
DispatchMessage(&msg);
break;
}
}
exit_cancel_drag: // goto - can't use break as we're inside a switch()
CancelDrag();
return FALSE;
}
BOOL CDockContext::Track()
{
// don't handle if capture already set
if (::GetCapture() != NULL)
return FALSE;
// set capture to the window which received this message
m_pBar->SetCapture();
ASSERT(m_pBar == CWnd::GetCapture());
// get messages until capture lost or cancelled/accepted
while (CWnd::GetCapture() == m_pBar)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
AfxPostQuitMessage(msg.wParam);
break;
}
switch (msg.message)
{
case WM_LBUTTONUP:
if (m_bDragging)
EndDrag();
else
EndResize();
return TRUE;
case WM_MOUSEMOVE:
if (m_bDragging)
Move(msg.pt);
else
Stretch(msg.pt);
break;
case WM_KEYUP:
if (m_bDragging)
OnKey((int)msg.wParam, FALSE);
break;
case WM_KEYDOWN:
if (m_bDragging)
OnKey((int)msg.wParam, TRUE);
if (msg.wParam == VK_ESCAPE)
{
CancelLoop();
return FALSE;
}
break;
case WM_RBUTTONDOWN:
CancelLoop();
return FALSE;
// just dispatch rest of the messages
default:
DispatchMessage(&msg);
break;
}
}
CancelLoop();
return FALSE;
}
LRESULT OculusRoomTinyApp::windowProc(UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_MOUSEMOVE:
{
if (MouseCaptured)
{
// Convert mouse motion to be relative (report the offset and re-center).
POINT newPos = { LOWORD(lp), HIWORD(lp) };
::ClientToScreen(hWnd, &newPos);
if ((newPos.x == WindowCenter.x) && (newPos.y == WindowCenter.y))
break;
::SetCursorPos(WindowCenter.x, WindowCenter.y);
LONG dx = newPos.x - WindowCenter.x;
LONG dy = newPos.y - WindowCenter.y;
pApp->OnMouseMove(dx, dy, 0);
}
}
break;
case WM_MOVE:
{
RECT r;
GetClientRect(hWnd, &r);
WindowCenter.x = r.right/2;
WindowCenter.y = r.bottom/2;
::ClientToScreen(hWnd, &WindowCenter);
}
break;
case WM_KEYDOWN:
OnKey((unsigned)wp, true);
break;
case WM_KEYUP:
OnKey((unsigned)wp, false);
break;
case WM_SETFOCUS:
giveUsFocus(true);
break;
case WM_KILLFOCUS:
giveUsFocus(false);
break;
case WM_CREATE:
// Hack to position mouse in fullscreen window shortly after startup.
SetTimer(hWnd, 0, 100, NULL);
break;
case WM_TIMER:
KillTimer(hWnd, 0);
giveUsFocus(true);
break;
case WM_QUIT:
case WM_CLOSE:
Quit = true;
return 0;
}
return DefWindowProc(hWnd, msg, wp, lp);
}
void sTextControl::OnKey(sU32 key)
{
sInt len;
sU32 ckey;
sInt i,j;
sChar buffer[2];
// prepare...
if(key&sKEYQ_SHIFT) key|=sKEYQ_SHIFT;
if(key&sKEYQ_CTRL ) key|=sKEYQ_CTRL ;
len = sGetStringLen(Text);
if(Cursor>len)
Cursor = len;
// normal keys
switch(key&(0x8001ffff|sKEYQ_SHIFT|sKEYQ_CTRL))
{
case sKEY_BACKSPACE:
if(SelMode)
{
DelSel();
}
else
{
if(Cursor==0)
break;
Cursor--;
Engine(Cursor,1,0);
Post(DoneCmd);
SelMode = 0;
OnCalcSize();
ScrollToCursor();
}
break;
case sKEY_DELETE:
if(SelMode)
{
DelSel();
}
else
{
Engine(Cursor,1,0);
OnCalcSize();
Post(DoneCmd);
}
ScrollToCursor();
break;
case sKEY_ENTER:
if(SelMode)
DelSel();
i = Cursor-GetCursorX();
for(j=0;i<Cursor && Text[i]==' ';i++)
j++;
if(Cursor>i && Text[Cursor-1]=='{')
j+=2;
Engine(Cursor,1,"\n");
Cursor++;
for(i=0;i<j;i++)
{
Engine(Cursor,1," ");
Cursor++;
}
OnCalcSize();
ScrollToCursor();
break;
case sKEY_PAGEUP:
len = RealY/sPainter->GetHeight(sGui->FixedFont)-8;
if(len<1) len = 1;
for(i=0;i<len;i++)
OnKey(sKEY_UP);
break;
case sKEY_PAGEDOWN:
len = RealY/sPainter->GetHeight(sGui->FixedFont)-8;
if(len<1) len = 1;
for(i=0;i<len;i++)
OnKey(sKEY_DOWN);
break;
case sKEY_INSERT:
Overwrite = !Overwrite;
ScrollToCursor();
break;
case 'x'|sKEYQ_CTRL:
OnCommand(sTCC_CUT);
OnCalcSize();
ScrollToCursor();
break;
case 'c'|sKEYQ_CTRL:
OnCommand(sTCC_COPY);
ScrollToCursor();
break;
case 'v'|sKEYQ_CTRL:
OnCommand(sTCC_PASTE);
OnCalcSize();
ScrollToCursor();
break;
case 'b'|sKEYQ_CTRL:
OnCommand(sTCC_BLOCK);
ScrollToCursor();
break;
}
// sDPrintF("key %08x\n",key);
ckey = key&~(sKEYQ_SHIFT|sKEYQ_ALTGR|sKEYQ_REPEAT);
if((ckey>=0x20 && ckey<=0x7e) || (ckey>=0xa0 && ckey<=0xff))
{
DelSel();
buffer[0] = ckey;
buffer[1] = 0;
if(Overwrite && Cursor<len)
{
Engine(Cursor,1,0);
Engine(Cursor,1,buffer);
Cursor++;
Post(DoneCmd);
}
else
{
Engine(Cursor,1,buffer);
Cursor++;
Post(DoneCmd);
}
OnCalcSize();
ScrollToCursor();
}
else
{
Parent->OnKey(key);
}
// cursor movement and shift-block-marking
switch(key&0x8001ffff)
{
case sKEY_LEFT:
case sKEY_RIGHT:
case sKEY_UP:
case sKEY_DOWN:
case sKEY_HOME:
case sKEY_END:
if(SelMode==0 && (key&sKEYQ_SHIFT))
{
SelMode = 1;
SelPos = Cursor;
}
if(SelMode==1 && !(key&sKEYQ_SHIFT))
{
SelMode = 0;
}
break;
}
switch(key&0x8001ffff)
{
case sKEY_LEFT:
if(Cursor>0)
Cursor--;
ScrollToCursor();
break;
case sKEY_RIGHT:
if(Cursor<len)
Cursor++;
ScrollToCursor();
break;
case sKEY_UP:
j = i = CursorWish;
if(Text[Cursor]=='\n' && Cursor>0)
Cursor--;
while(Text[Cursor]!='\n' && Cursor>0)
Cursor--;
while(Text[Cursor-1]!='\n' && Cursor>0)
Cursor--;
while(i>0 && Text[Cursor]!='\n' && Text[Cursor]!=0)
{
Cursor++;
i--;
}
ScrollToCursor();
CursorWish = j;
break;
case sKEY_DOWN:
j = i = CursorWish;
while(Text[Cursor]!='\n' && Text[Cursor]!=0)
Cursor++;
if(Text[Cursor]=='\n')
{
Cursor++;
while(i>0 && Text[Cursor]!='\n' && Text[Cursor]!=0)
{
Cursor++;
i--;
}
}
ScrollToCursor();
CursorWish = j;
break;
case sKEY_HOME:
while(Cursor>0 && Text[Cursor-1]!='\n')
Cursor--;
ScrollToCursor();
break;
case sKEY_END:
while(Text[Cursor]!='\n' && Text[Cursor]!=0)
Cursor++;
ScrollToCursor();
break;
}
}
sBool PageWin::OnCommand(sU32 cmd)
{
sMenuFrame *mf;
// ToolObject *to;
ViewWin *view;
switch(cmd)
{
case CMD_POPUP:
mf = new sMenuFrame;
mf->AddMenu("Add",CMD_POPADD,'a');
mf->AddMenu("Add Misc",CMD_POPMISC,'1');
mf->AddMenu("Add Texture",CMD_POPTEX,'2');
mf->AddMenu("Add Mesh",CMD_POPMESH,'3');
mf->AddMenu("Add Scene",CMD_POPSCENE,'4');
mf->AddMenu("Add Material",CMD_POPMAT,'5');
mf->AddMenu("Add FXChain",CMD_POPFX,'6');
mf->AddSpacer();
mf->AddMenu("Normal Mode",' ',' ');
mf->AddMenu("Select Rect",'r','r');
mf->AddMenu("Pick",'p','p');
mf->AddMenu("Duplicate",'d','d');
mf->AddMenu("Width",'w','w');
mf->AddMenu("Move",'m','m');
mf->AddSpacer();
mf->AddMenu("Show",CMD_SHOW,'s');
mf->AddSpacer();
mf->AddMenu("Delete",CMD_DELETE,sKEY_DELETE);
mf->AddMenu("Cut",CMD_CUT,'x');
mf->AddMenu("Copy",CMD_COPY,'c');
mf->AddMenu("Paste",CMD_PASTE,'v');
mf->AddBorder(new sNiceBorder);
mf->SendTo = this;
sGui->AddPopup(mf);
return sTRUE;
case CMD_SHOW:
view = (ViewWin *) App->FindActiveWindow(sCID_TOOL_VIEWWIN);
if(EditOp && view && EditOp->Class->OutputCID)
{
view->SetObject(EditOp);
}
if(EditOp && view && (EditOp->Class->Flags & POCF_STORE)) // store
{
view->SetObject(EditOp);
}
if(Doc)
Doc->UpdatePage();
return sTRUE;
case CMD_POPADD:
AddOps(AddOpClass);
return sTRUE;
case CMD_POPMISC:
AddOpClass = 0;
AddOps(AddOpClass);
return sTRUE;
case CMD_POPTEX:
AddOpClass = sCID_GENBITMAP;
AddOps(AddOpClass);
return sTRUE;
case CMD_POPMESH:
AddOpClass = sCID_GENMESH;
AddOps(AddOpClass);
return sTRUE;
case CMD_POPSCENE:
AddOpClass = sCID_GENSCENE;
AddOps(AddOpClass);
return sTRUE;
case CMD_POPMAT:
AddOpClass = sCID_GENMATERIAL;
AddOps(AddOpClass);
return sTRUE;
case CMD_POPFX:
AddOpClass = sCID_GENFXCHAIN;
AddOps(AddOpClass);
return sTRUE;
case ' ':
case 'r':
case 'p':
case 'd':
case 'w':
case 'm':
OnKey(cmd);
return sTRUE;
case CMD_DELETE:
if(Doc)
Doc->Delete();
return sTRUE;
case CMD_CUT:
if(Doc)
{
Doc->Copy();
Doc->Delete();
}
return sTRUE;
case CMD_COPY:
if(Doc)
Doc->Copy();
return sTRUE;
case CMD_PASTE:
if(Doc)
Doc->Paste(CursorX,CursorY);
return sTRUE;
default:
if(cmd>=1024 && cmd<2048)
{
if(App->ClassList[cmd-1024].Name)
AddOp(&App->ClassList[cmd-1024]);
return sTRUE;
}
return sFALSE;
}
}
VOID CDangleWindowHex::OnKey(UINT Key)
{
//выбор по клавише
switch(Key)
{
case VK_DOWN:
{
//сдвинуть курсор вниз
mSelectionOffset+=LINE_COUNT;
UINT FileSize=mpEditedFile->GetSize();
if(mSelectionOffset>=FileSize) mSelectionOffset=FileSize-1;
//если курсор не помещаетс¤ в окне, сдвинуть окно
if((mSelectionOffset-mWindowOffset)/LINE_COUNT>=mWindowLinesCount)
mWindowOffset+=LINE_COUNT;
//обновить окно
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
case VK_UP:
{
//сдвинуть курсор вверх
if(mSelectionOffset<LINE_COUNT) mSelectionOffset=0;
else mSelectionOffset-=LINE_COUNT;
//если курсор не помещаетс¤ в окне, сдвинуть окно
if(mSelectionOffset<mWindowOffset)
if(mWindowOffset<LINE_COUNT) mWindowOffset=0;
else mWindowOffset-=LINE_COUNT;
//обновить окно
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
case VK_RIGHT:
{
//сдвинуть курсор вправо
UINT FileSize=mpEditedFile->GetSize();
if(mSelectionOffset<FileSize-1) mSelectionOffset++;
//если курсор не помещаетс¤ в окне, сдвинуть окно
if((mSelectionOffset-mWindowOffset)/LINE_COUNT>=mWindowLinesCount)
mWindowOffset+=LINE_COUNT;
//обновить окно
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
case VK_LEFT:
{
//сдвинуть курсор влево
if(mSelectionOffset>=1) mSelectionOffset--;
//если курсор не помещаетс¤ в окне, сдвинуть окно
if(mSelectionOffset<mWindowOffset)
if(mWindowOffset<LINE_COUNT) mWindowOffset=0;
else mWindowOffset-=LINE_COUNT;
//обновить окно
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
case VK_NEXT:
{
for(UINT i=0;i<mWindowLinesCount;++i)
OnKey(VK_DOWN);
}
break;
case VK_PRIOR:
{
for(UINT i=0;i<mWindowLinesCount;++i)
OnKey(VK_UP);
}
break;
case VK_HOME:
{
mSelectionOffset=0;
mWindowOffset=0;
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
case VK_END:
{
mSelectionOffset=mpEditedFile->GetSize()-1;
mWindowOffset=mSelectionOffset/LINE_COUNT*LINE_COUNT;
InvalidateRect(mhWindow,NULL,FALSE);
}
break;
}
}
void EngineStatePoolGetPlayerName::Red(bool down)
{
// Allow spaces
OnKey(' ', down);
}
