bool AP_Win32App::handleModelessDialogMessage( MSG * msg )
{
int iCounter;
HWND hWnd = NULL;
// Try to knock off the easy case quickly
if( m_IdTable[ 0 ].id == -1 )
return false;
for( iCounter = 0; iCounter <= NUM_MODELESSID; iCounter++ )
{
if( m_IdTable[ iCounter ].id != -1 )
{
hWnd = (HWND) m_IdTable[ iCounter ].pDialog->pGetWindowHandle();
if(!m_bForceAnsi && UT_IsWinNT())
{
// Since the message was fetched with GetMessageW,
// it must be processed with Unicode functions
if( hWnd && IsDialogMessageW( hWnd, msg ) )
return true;
}
else
{
if( hWnd && IsDialogMessage( hWnd, msg ) )
return true;
}
}
else
break;
}
return false;
}
/// <summary>
/// Window message loop
/// </summary>
/// <returns>wParam of last received message</returns>
WPARAM KinectWindow::MessageLoop()
{
m_hStopStreamEventThread = CreateEventW(nullptr, TRUE, FALSE, nullptr);
HANDLE hEventThread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)StreamEventThread, this, 0, nullptr);
MSG msg = {0};
BOOL ret;
while (0 != (ret = GetMessageW(&msg, nullptr, 0, 0)))
{
if (-1 == ret)
{
break;
}
if (IsDialogMessageW(m_hWnd, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
WaitForSingleObject(hEventThread, INFINITE);
CloseHandle(hEventThread);
return msg.wParam;
}
static void hugsprim_IsDialogMessageW_17(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsPtr arg2;
HsBool res1;
arg1 = hugs->getPtr();
arg2 = hugs->getPtr();
res1 = IsDialogMessageW(arg1, arg2);
hugs->putBool(res1);
hugs->returnIO(hugs_root,1);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CFaceBasics::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU1);
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"Face-And-HDFace-Basics-D2DAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
//hMenu = LoadMenuW(hInstance, MAKEINTRESOURCE(IDR_MENU1));
// Create main application window
HWND hWndApp = CreateDialogParamW( NULL, MAKEINTRESOURCE(IDD_APP), NULL, (DLGPROC)CFaceBasics::MessageRouter, reinterpret_cast<LPARAM>(this));
//HWND hWndApp = CreateDialogParamW( NULL, MAKEINTRESOURCE(IDD_APP), NULL, (DLGPROC)CFaceBasics::MessageRouter, WS_CAPTION);
// Show window
ShowWindow(hWndApp, nCmdShow);
//ShowWindow(hWndApp, 3);
// Main message loop
while (WM_QUIT != msg.message)
{
Update();
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if (hWndApp && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CKinectFusionExplorer::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc = {0};
// Dialog custom window class
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"KinectFusionExplorerAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParamW(
hInstance,
MAKEINTRESOURCE(IDD_APP),
nullptr,
(DLGPROC)CKinectFusionExplorer::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
// Main message loop
while (WM_QUIT != msg.message)
{
if (GetMessage(&msg, nullptr, 0, 0))
{
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != nullptr) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
int WINAPI wWinMain( HINSTANCE, HINSTANCE, LPWSTR, int )
{
try {
INITCOMMONCONTROLSEX icc_ex = {
sizeof( INITCOMMONCONTROLSEX ),
ICC_WIN95_CLASSES
};
InitCommonControlsEx( &icc_ex );
std::locale::global( std::locale( "ja-JP" ) );
std::setlocale( LC_ALL, "ja-JP" );
take_over();
STARTUPINFOW si;
GetStartupInfoW( &si );
mmaccel::key_config::window().show( si.dwX, si.dwY );
auto const args = winapi::get_command_line_args();
if( !args.empty() && args[0] == L"--mmd" ) {
write_key_config_window( si.hStdOutput, mmaccel::key_config::window().handle() );
}
MSG msg;
for( ;; ) {
auto const result = GetMessageW( &msg, nullptr, 0, 0 );
if( result == 0 || result == -1 ) {
break;
}
if( IsDialogMessageW( mmaccel::key_config::window().handle(), &msg ) ) {
continue;
}
DispatchMessageW( &msg );
}
}
catch( std::exception const& e ) {
STARTUPINFOW si;
GetStartupInfoW( &si );
write_key_config_window( si.hStdOutput, nullptr );
winapi::message_box( u8"MMAccel", e.what(), MB_OK | MB_ICONERROR );
}
return 0;
}
bool AP_Win32App::handleModelessDialogMessage( MSG * msg )
{
int iCounter;
HWND hWnd = NULL;
// Try to knock off the easy case quickly
if( m_IdTable[ 0 ].id == -1 )
return false;
for( iCounter = 0; iCounter <= NUM_MODELESSID; iCounter++ )
{
if( m_IdTable[ iCounter ].id != -1 )
{
hWnd = (HWND) m_IdTable[ iCounter ].pDialog->pGetWindowHandle();
if( hWnd && IsDialogMessageW( hWnd, msg ) )
return true;
}
else
break;
}
return false;
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CCoordinateMappingBasics::Run(HINSTANCE hInstance, int nCmdShow)
{
if (m_pBackgroundRGBX)
{
//if (FAILED(LoadResourceImage(L"Background", L"Image", cDepthWidth, cDepthHeight, m_pBackgroundRGBX)))
//if (FAILED(LoadResourceImage(MAKEINTRESOURCE(IDB_BITMAP1), RT_BITMAP, cDepthWidth, cDepthHeight, m_pBackgroundRGBX)))
if (FAILED(LoadResourceImage(MAKEINTRESOURCE(IDB_PNG1), L"Png", cDepthWidth, cDepthHeight, m_pBackgroundRGBX)))
{
delete [] m_pBackgroundRGBX;
m_pBackgroundRGBX = NULL;
}
}
MSG msg = {0};
WNDCLASS wc;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"CoordinateMappingBasicsAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParamW(
NULL,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)CCoordinateMappingBasics::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
// Main message loop
while (WM_QUIT != msg.message)
{
Update();
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if (hWndApp && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CSkeletonBasics::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc = {0};
// Dialog custom window class
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"SkeletonBasicsAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParamW(
hInstance,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)CSkeletonBasics::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
const int eventCount = 1;
HANDLE hEvents[eventCount];
// Main message loop
while (WM_QUIT != msg.message)
{
hEvents[0] = m_hNextSkeletonEvent;
// Check to see if we have either a message (by passing in QS_ALLEVENTS)
// Or a Kinect event (hEvents)
// Update() will check for Kinect events individually, in case more than one are signalled
DWORD dwEvent = MsgWaitForMultipleObjects(eventCount, hEvents, FALSE, INFINITE, QS_ALLINPUT);
// Check if this is an event we're waiting on and not a timeout or message
if (WAIT_OBJECT_0 == dwEvent)
{
Update();
}
if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != NULL) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int KinectEasyGrabber::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"KinectEasyGrabberAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParamW(
hInstance,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)KinectEasyGrabber::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
const int eventCount = 2;
HANDLE hEvents[eventCount];
LoadResourceImage(L"Background", L"Image", m_colorWidth*m_colorHeight*cBytesPerPixel, m_backgroundRGBX);
// Main message loop
while (WM_QUIT != msg.message)
{
hEvents[0] = m_hNextDepthFrameEvent;
hEvents[1] = m_hNextColorFrameEvent;
// Check to see if we have either a message (by passing in QS_ALLINPUT)
// Or a Kinect event (hEvents)
// Update() will check for Kinect events individually, in case more than one are signalled
DWORD dwEvent = MsgWaitForMultipleObjects(eventCount, hEvents, FALSE, INFINITE, QS_ALLINPUT);
// Check if this is an event we're waiting on and not a timeout or message
if (WAIT_OBJECT_0 == dwEvent || WAIT_OBJECT_0 + 1 == dwEvent)
{
//Update();
//Record();
RecordArray();
}
if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != NULL) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int Direct2DWindow::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"DepthBasicsAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParamW(
hInstance,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)Direct2DWindow::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
const int eventCount = 2;
HANDLE hEvents[eventCount];
// Main message loop
while (WM_QUIT != msg.message)
{
hEvents[0] = m_cdmap->GetNextDepthFrameEvent();
hEvents[1] = m_cdmap->GetNextColorFrameEvent();
// Check to see if we have either a message (by passing in QS_ALLINPUT)
// Or a Kinect event (hEvents)
// Update() will check for Kinect events individually, in case more than one are signalled
MsgWaitForMultipleObjects(eventCount, hEvents, FALSE, INFINITE, QS_ALLINPUT);
// Explicitly check the Kinect frame event since MsgWaitForMultipleObjects
// can return for other reasons even though it is signaled.
Update();
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != NULL) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
/* Sends a message to a set of windows, displaying a dialog if the window
* doesn't respond to the message within a set amount of time.
* If the process has already been terminated, the function returns -1.
* If the user or application cancels the process, the function returns 0.
* Otherwise the function returns 0. */
static LRESULT send_messages_with_timeout_dialog(
struct window_info *win, UINT count, HANDLE process_handle,
UINT msg, WPARAM wparam, LPARAM lparam )
{
unsigned int i;
DWORD ret;
DWORD start_time;
struct callback_data *cb_data;
HWND hwnd_endtask = NULL;
struct endtask_dlg_data dlg_data;
LRESULT result;
cb_data = HeapAlloc( GetProcessHeap(), 0, sizeof(*cb_data) );
if (!cb_data)
return 1;
cb_data->result = TRUE; /* we only care if a WM_QUERYENDSESSION response is FALSE */
cb_data->timed_out = FALSE;
cb_data->window_count = count;
dlg_data.win = win;
dlg_data.terminated = FALSE;
dlg_data.cancelled = FALSE;
for (i = 0; i < count; i++)
{
if (!SendMessageCallbackW( win[i].hwnd, msg, wparam, lparam,
end_session_message_callback, (ULONG_PTR)cb_data ))
cb_data->window_count --;
}
start_time = GetTickCount();
while (TRUE)
{
DWORD current_time = GetTickCount();
ret = MsgWaitForMultipleObjects( 1, &process_handle, FALSE,
MESSAGE_TIMEOUT - (current_time - start_time),
QS_ALLINPUT );
if (ret == WAIT_OBJECT_0) /* process exited */
{
HeapFree( GetProcessHeap(), 0, cb_data );
result = 1;
goto cleanup;
}
else if (ret == WAIT_OBJECT_0 + 1) /* window message */
{
MSG msg;
while(PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
{
if (!hwnd_endtask || !IsDialogMessageW( hwnd_endtask, &msg ))
{
TranslateMessage( &msg );
DispatchMessageW( &msg );
}
}
if (!cb_data->window_count)
{
result = dlg_data.terminated || cb_data->result;
HeapFree( GetProcessHeap(), 0, cb_data );
if (!result)
goto cleanup;
break;
}
if (dlg_data.cancelled)
{
cb_data->timed_out = TRUE;
result = 0;
goto cleanup;
}
}
else if ((ret == WAIT_TIMEOUT) && !hwnd_endtask)
{
hwnd_endtask = CreateDialogParamW( GetModuleHandleW(NULL),
MAKEINTRESOURCEW(IDD_ENDTASK),
NULL, endtask_dlg_proc,
(LPARAM)&dlg_data );
}
else break;
}
result = 1;
cleanup:
if (hwnd_endtask) DestroyWindow( hwnd_endtask );
return result;
}
int WINAPI wWinMain(HINSTANCE hinstance, HINSTANCE /* hprevinstance */, PWSTR cmdline, int /* cmdshow */)
{
//AllocConsole();
//freopen("CONOUT$", "w", stdout);
auto args = getArgs(cmdline);
auto standby = args.size() > 2 && args[2] == "standby";
const auto instanceString = L"XKXjdwnFYYL2eVdB";
auto singleInstanceEvent = HandlePtr(OpenEventW(EVENT_ALL_ACCESS, false, instanceString));
if (singleInstanceEvent != nullptr)
{
if (!standby)
{
auto decision = MessageBox(nullptr, L"There is already an instance "
"of passchain running. Start anyway?", L"Warning", MB_OKCANCEL);
if (decision != IDOK)
{
return 0;
}
}
}
else
{
singleInstanceEvent = HandlePtr(CreateEventW(nullptr, false, false, instanceString));
}
std::unique_ptr<LoginDatabase> database;
std::string password;
std::string filename = getFullyQualifiedPathName(args.size() > 1 ? args[1] : "passchain.dat");
while (database == nullptr)
{
try
{
PasswordDialogCreateParams params;
params.password = &password;
params.filename = &filename;
params.standby = standby;
auto result = DialogBoxParamW(hinstance, MAKEINTRESOURCEW(DIALOG_PASSWORD), nullptr,
dialogProcPassword, reinterpret_cast<LPARAM>(¶ms));
if (result == 0)
{ // Pressed cancel or close button
return 0;
}
database = std::make_unique<LoginDatabase>(std::move(password));
auto attributes = GetFileAttributesW(toWideString(filename).c_str());
if (attributes != INVALID_FILE_ATTRIBUTES)
{
database->mergeFromEncryptedFile(filename);
}
}
catch (std::exception& e)
{
database = nullptr;
standby = false;
showMessageBox("Error", e.what());
}
}
bool timeoutQuit = false;
MainDialogCreateParams mainParams;
mainParams.database = database.get();
mainParams.filename = &filename;
mainParams.timeoutQuit = &timeoutQuit;
CreateDialogParamW(hinstance, MAKEINTRESOURCE(DIALOG_MAIN), nullptr,
dialogProcMain, reinterpret_cast<LPARAM>(&mainParams));
MSG message;
while (GetMessageW(&message, nullptr, 0, 0) > 0)
{
database->reseedRng(&message, sizeof message);
if (!IsDialogMessageW(GetParent(message.hwnd), &message))
{
TranslateMessage(&message);
DispatchMessageW(&message);
}
}
if (timeoutQuit)
{
auto callString = formatString("%s %s standby", args[0].c_str(), filename.c_str());
STARTUPINFOA startupInfo = { sizeof startupInfo };
PROCESS_INFORMATION processInformation;
if (0 == CreateProcessA(nullptr, &callString[0], nullptr, nullptr,
false, 0, nullptr, nullptr, &startupInfo, &processInformation))
{
showMessageBox("Warning", "Failed to create standby process.");
}
}
return static_cast<int>(message.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CColorBasics::Run(HINSTANCE hInstance, int nCmdShow, DASHout* dasher)
{
MSG msg = {0};
WNDCLASS wc;
DWORD event_res;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = "ColorBasicsAppDlgWndClass";
if (!RegisterClass(&wc))
{
return 0;
}
// Create main application window
HWND hWndApp = CreateDialogParam(
hInstance,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)CColorBasics::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Show window
ShowWindow(hWndApp, nCmdShow);
const int eventCount = 2;
HANDLE hEvents[eventCount];
#ifdef _DEBUG
char cwd[1024];
if (_getcwd(cwd, sizeof(cwd)) != NULL) fprintf(stdout, "Current working dir: %s\n", cwd);
if(dasher->colFrameCount==0)getchar();
#endif
// Main message loop
while (WM_QUIT != msg.message)
{
hEvents[0] = m_hNextColorFrameEvent;
hEvents[1] = m_hNextSkeletonEvent;
// Check to see if we have either a message (by passing in QS_ALLINPUT)
// Or a Kinect event (hEvents)
// Update() will check for Kinect events individually, in case more than one are signalled
//more info on MsgWaitForMultipleObjects function: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684242%28v=vs.85%29.aspx
event_res = MsgWaitForMultipleObjects(eventCount, hEvents, FALSE, INFINITE, QS_ALLINPUT);
// Explicitly check the Kinect frame event since MsgWaitForMultipleObjects
// can return for other reasons even though it is signaled.
if((0 <= event_res)&&(event_res < 2)) Update(dasher, event_res);
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
#ifdef _DEBUG
if(WM_KEYDOWN == msg.message)
switch(msg.wParam){
case(VK_SPACE): //we have space
case(0x50): //or 'P'
//system("PAUSE");
printf("used for testing \n");
break;
}
#endif
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != NULL) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
if(WM_QUIT == msg.message){
if(dasher->segment_started){
muxer_close_segment(dasher);
}
muxer_destroy(dasher);
system("PAUSE");
}
return static_cast<int>(msg.wParam);
}
/// <summary>
/// Creates the main window and begins processing
/// </summary>
/// <param name="hInstance">handle to the application instance</param>
/// <param name="nCmdShow">whether to display minimized, maximized, or normally</param>
int CBackgroundRemovalBasics::Run(HINSTANCE hInstance, int nCmdShow)
{
MSG msg = {0};
WNDCLASS wc;
// Dialog custom window class
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.cbWndExtra = DLGWINDOWEXTRA;
wc.hInstance = hInstance;
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCE(IDI_APP));
wc.lpfnWndProc = DefDlgProcW;
wc.lpszClassName = L"BackgroundRemovalBasicsAppDlgWndClass";
if (!RegisterClassW(&wc))
{
return 0;
}
DWORD threadId;
HANDLE hThread = CreateThread(NULL, 0, NetworkManager::ThreadFunc, (LPVOID)nManager, CREATE_SUSPENDED, &threadId);
ResumeThread(hThread);
// Create main application window
HWND hWndApp = CreateDialogParamW(
hInstance,
MAKEINTRESOURCE(IDD_APP),
NULL,
(DLGPROC)CBackgroundRemovalBasics::MessageRouter,
reinterpret_cast<LPARAM>(this));
// Set the init sensor status
UpdateNscControlStatus();
// Show window
ShowWindow(hWndApp, nCmdShow);
UpdateWindow(hWndApp);
const HANDLE hEvents[] = {m_hNextDepthFrameEvent, m_hNextColorFrameEvent, m_hNextSkeletonFrameEvent, m_hNextBackgroundRemovedFrameEvent};
LoadResourceImage(L"Background", L"Image", m_colorWidth * m_colorHeight * cBytesPerPixel, m_backgroundRGBX);
// Main message loop
while (WM_QUIT != msg.message)
{
// Check to see if we have either a message (by passing in QS_ALLINPUT)
// Or a Kinect event (hEvents)
// Update() will check for Kinect events individually, in case more than one are signaled
MsgWaitForMultipleObjects(_countof(hEvents), hEvents, FALSE, INFINITE, QS_ALLINPUT);
// Individually check the Kinect stream events since MsgWaitForMultipleObjects
// can return for other reasons even though these are signaled.
Update();
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
// If a dialog message will be taken care of by the dialog proc
if ((hWndApp != NULL) && IsDialogMessageW(hWndApp, &msg))
{
continue;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return static_cast<int>(msg.wParam);
}
