void Visor(void *data)
{
MSG msg;
unsigned long idThrd;
while (PeekMessage(&msg, 0, WM_USER, WM_USER + 5, PM_REMOVE));
while(1) {
GetMessageA(&msg, 0, MAIN_READY, MAIN_READY);
GetMessageA(&msg, 0, THRD_READY, THRD_READY);
idThrd = msg.lParam;
PostThreadMessageA(MainThreadID, MAIN_START, 0, 0);
PostThreadMessageA(idThrd, THRD_START, 0, 0);
}
}
/**************************************************************************
* midiStreamOut [WINMM.@]
*/
MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr,
UINT cbMidiHdr)
{
WINE_MIDIStream* lpMidiStrm;
DWORD ret = MMSYSERR_NOERROR;
TRACE("(%p, %p, %u)!\n", hMidiStrm, lpMidiHdr, cbMidiHdr);
if (cbMidiHdr < offsetof(MIDIHDR,dwOffset) || !lpMidiHdr || !lpMidiHdr->lpData
|| lpMidiHdr->dwBufferLength < lpMidiHdr->dwBytesRecorded
|| lpMidiHdr->dwBytesRecorded % 4 /* player expects DWORD padding */)
return MMSYSERR_INVALPARAM;
/* FIXME: Native additionally checks if the MIDIEVENTs in lpData
* exactly fit dwBytesRecorded. */
if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
return MIDIERR_UNPREPARED;
if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
return MIDIERR_STILLPLAYING;
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
ret = MMSYSERR_INVALHANDLE;
} else {
lpMidiHdr->dwFlags |= MHDR_ISSTRM | MHDR_INQUEUE;
lpMidiHdr->dwFlags &= ~MHDR_DONE;
if (!PostThreadMessageA(lpMidiStrm->dwThreadID,
WINE_MSM_HEADER, cbMidiHdr,
(LPARAM)lpMidiHdr)) {
ERR("bad PostThreadMessageA\n");
ret = MMSYSERR_ERROR;
}
}
return ret;
}
/**************************************************************************
* midiStreamClose [WINMM.@]
*/
MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
{
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = 0;
TRACE("(%p)!\n", hMidiStrm);
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
return MMSYSERR_INVALHANDLE;
midiStreamStop(hMidiStrm);
PostThreadMessageA(lpMidiStrm->dwThreadID, WM_QUIT, 0, 0);
CloseHandle(lpMidiStrm->hEvent);
if (lpMidiStrm->hThread) {
if (GetCurrentThreadId() != lpMidiStrm->dwThreadID)
WaitForSingleObject(lpMidiStrm->hThread, INFINITE);
else {
FIXME("leak from call within function callback\n");
ret = MMSYSERR_HANDLEBUSY; /* yet don't signal it to app */
}
CloseHandle(lpMidiStrm->hThread);
}
if(!ret)
HeapFree(GetProcessHeap(), 0, lpMidiStrm);
return midiOutClose((HMIDIOUT)hMidiStrm);
}
static BOOL PostMessageToProcessMsgThread(IDirectMusicPerformance8Impl* This, UINT iMsg) {
if (FALSE == This->procThreadTicStarted && PROCESSMSG_EXIT != iMsg) {
BOOL res;
This->procThread = CreateThread(NULL, 0, ProcessMsgThread, This, 0, &This->procThreadId);
if (NULL == This->procThread) return FALSE;
SetThreadPriority(This->procThread, THREAD_PRIORITY_TIME_CRITICAL);
This->procThreadTicStarted = TRUE;
while(1) {
res = PostThreadMessageA(This->procThreadId, iMsg, 0, 0);
/* Let the thread creates its message queue (with MsgWaitForMultipleObjects call) by yielding and retrying */
if (!res && (GetLastError() == ERROR_INVALID_THREAD_ID))
Sleep(0);
else
break;
}
return res;
}
return PostThreadMessageA(This->procThreadId, iMsg, 0, 0);
}
/**************************************************************************
* midiStreamStop [WINMM.@]
*/
MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm)
{
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = MMSYSERR_NOERROR;
TRACE("(%p)!\n", hMidiStrm);
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
return MMSYSERR_INVALHANDLE;
PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_STOP, 0, 0);
return ret;
}
/***********************************************************************
* MZ_RunInThread
*/
void WINAPI MZ_RunInThread( PAPCFUNC proc, ULONG_PTR arg )
{
if (loop_thread) {
DOS_SPC spc;
HANDLE event;
spc.proc = proc;
spc.arg = arg;
event = CreateEventW(NULL, TRUE, FALSE, NULL);
PostThreadMessageA(loop_tid, WM_USER, (WPARAM)event, (LPARAM)&spc);
WaitForSingleObject(event, INFINITE);
CloseHandle(event);
} else
proc(arg);
}
BOOL CALLBACK close_alert_window_enum( HWND hwnd, LPARAM lParam )
{
char buf[ 7 ] = { 0 };
PROCESS_HANDLE_ID p = *( (PROCESS_HANDLE_ID *)lParam );
DWORD pid = 0;
DWORD tid = 0;
/* We want to find and close any window that:
* 1. is visible and
* 2. is a dialog and
* 3. is displayed by any of our child processes
*/
if ( !IsWindowVisible( hwnd ) )
return TRUE;
if ( !GetClassNameA( hwnd, buf, sizeof( buf ) ) )
return TRUE; /* Failed to read class name; presume it is not a dialog. */
if ( strcmp( buf, "#32770" ) )
return TRUE; /* Not a dialog */
/* GetWindowThreadProcessId() returns 0 on error, otherwise thread id of
* window message pump thread.
*/
tid = GetWindowThreadProcessId( hwnd, &pid );
if ( tid && is_parent_child( p.pid, pid ) )
{
/* Ask really nice. */
PostMessageA( hwnd, WM_CLOSE, 0, 0 );
/* Now wait and see if it worked. If not, insist. */
if ( WaitForSingleObject( p.h, 200 ) == WAIT_TIMEOUT )
{
PostThreadMessageA( tid, WM_QUIT, 0, 0 );
WaitForSingleObject( p.h, 300 );
}
/* Done, we do not want to check any other window now. */
return FALSE;
}
return TRUE;
}
void __fastcall TMainForm::ToolButton3Click(TObject *Sender)
{
String FileName = "ExpMtr\\mtr.xml";
TSendThread *Client;
int mr, r, cnt;
String err;
MSG msg;
if ((err = cVerifData()) != "") {
ShowMessage(err);
return;
}
LoginForm->UserEdit->Text = /*"sc910001" + */"sc" + IntToStr(School.SchoolCode);
LoginForm->PasswordEdit->Text = "jXCHJQQo";
Client = new TSendThread(true);
if (LoginForm->ShowModal() != mrOk)
return;
Client->idVisor = idVisor;
Client->User = LoginForm->UserEdit->Text;
Client->Password = LoginForm->PasswordEdit->Text;
Client->ms = new TMemoryStream;
SaveXMLToStream(Client->ms);
Client->CommandID = "3";
Client->srv = GetServerIP();
Client->FreeOnTerminate = true;
SendForm->Show();
SendForm->Memo1->Lines->Append("Соединение с сервером.");
while (PeekMessage(&msg, this->Handle, WM_USER, THRD_END, PM_REMOVE)); //инициализация и отчистка очереди
Client->Resume();
GetMessageA(&msg, 0, THRD_READY, THRD_READY);
while (!PeekMessageA(&msg, 0, THRD_END, THRD_END, PM_NOREMOVE)) {
Application->ProcessMessages();
WaitMessage();
}
PostThreadMessageA(0, MAIN_READY, 0, 0);
ShowMessage(ThreadMsg);
}
__declspec(dllexport) void __cdecl SDR_EndMovie()
{
/*
If the user didn't already close it.
*/
if (Window::WindowPtr)
{
auto handle = Window::WindowThread.native_handle();
auto id = GetThreadId(handle);
PostThreadMessageA(id, WM_QUIT, 0, 0);
}
if (Window::WindowThread.joinable())
{
Window::WindowThread.join();
}
Synchro::Destroy();
}
BOOL CALLBACK close_alert_window_enum( HWND hwnd, LPARAM lParam )
{
char buf[ 7 ] = { 0 };
PROCESS_INFORMATION const * const pi = (PROCESS_INFORMATION *)lParam;
DWORD pid;
DWORD tid;
/* We want to find and close any window that:
* 1. is visible and
* 2. is a dialog and
* 3. is displayed by any of our child processes
*/
if (
/* We assume hidden windows do not require user interaction. */
!IsWindowVisible( hwnd )
/* Failed to read class name; presume it is not a dialog. */
|| !GetClassNameA( hwnd, buf, sizeof( buf ) )
/* All Windows system dialogs use the same Window class name. */
|| strcmp( buf, "#32770" ) )
return TRUE;
/* GetWindowThreadProcessId() returns 0 on error, otherwise thread id of
* the window's message pump thread.
*/
tid = GetWindowThreadProcessId( hwnd, &pid );
if ( !tid || !is_parent_child( pi->dwProcessId, pid ) )
return TRUE;
/* Ask real nice. */
PostMessageA( hwnd, WM_CLOSE, 0, 0 );
/* Wait and see if it worked. If not, insist. */
if ( WaitForSingleObject( pi->hProcess, 200 ) == WAIT_TIMEOUT )
{
PostThreadMessageA( tid, WM_QUIT, 0, 0 );
WaitForSingleObject( pi->hProcess, 300 );
}
/* Done, we do not want to check any other windows now. */
return FALSE;
}
/**************************************************************************
* midiStreamOpen [WINMM.@]
*/
MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
DWORD cMidi, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen)
{
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret;
MIDIOPENSTRMID mosm;
LPWINE_MIDI lpwm;
HMIDIOUT hMidiOut;
TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
return MMSYSERR_INVALPARAM;
ret = WINMM_CheckCallback(dwCallback, fdwOpen, FALSE);
if (ret != MMSYSERR_NOERROR)
return ret;
lpMidiStrm = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream));
if (!lpMidiStrm)
return MMSYSERR_NOMEM;
lpMidiStrm->dwTempo = 500000;
lpMidiStrm->dwTimeDiv = 480; /* 480 is 120 quarter notes per minute *//* FIXME ??*/
lpMidiStrm->dwPositionMS = 0;
mosm.dwStreamID = (DWORD)lpMidiStrm;
/* FIXME: the correct value is not allocated yet for MAPPER */
mosm.wDeviceID = *lpuDeviceID;
lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm);
if (!lpwm) {
HeapFree(GetProcessHeap(), 0, lpMidiStrm);
return MMSYSERR_NOMEM;
}
lpMidiStrm->hDevice = hMidiOut;
*lphMidiStrm = (HMIDISTRM)hMidiOut;
lpwm->mld.uDeviceID = *lpuDeviceID;
ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD_PTR)&lpwm->mod, fdwOpen);
if (ret != MMSYSERR_NOERROR) {
MMDRV_Free(hMidiOut, &lpwm->mld);
HeapFree(GetProcessHeap(), 0, lpMidiStrm);
return ret;
}
lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
lpMidiStrm->wFlags = HIWORD(fdwOpen);
lpMidiStrm->hThread = CreateThread(NULL, 0, MMSYSTEM_MidiStream_Player,
lpMidiStrm, 0, &(lpMidiStrm->dwThreadID));
if (!lpMidiStrm->hThread) {
midiStreamClose((HMIDISTRM)hMidiOut);
return MMSYSERR_NOMEM;
}
SetThreadPriority(lpMidiStrm->hThread, THREAD_PRIORITY_TIME_CRITICAL);
/* wait for thread to have started, and for its queue to be created */
WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_PAUSE, 0, 0);
TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
*lpuDeviceID, lpwm->mld.uDeviceID, *lphMidiStrm, ret, lpMidiStrm);
return ret;
}
/**************************************************************************
* DriverCallback [WINMM.@]
*/
BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
DWORD_PTR dwParam2)
{
TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX)\n",
dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
switch (uFlags & DCB_TYPEMASK) {
case DCB_NULL:
TRACE("Null !\n");
break;
case DCB_WINDOW:
TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break;
case DCB_TASK: /* aka DCB_THREAD */
TRACE("Task(%04lx) !\n", dwCallBack);
PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break;
case DCB_FUNCTION:
TRACE("Function (32 bit) !\n");
if (dwCallBack)
((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
break;
case DCB_EVENT:
TRACE("Event(%08lx) !\n", dwCallBack);
SetEvent((HANDLE)dwCallBack);
break;
#if 0
/* FIXME: for now only usable in mmsystem.dll16
* If needed, should be enabled back
*/
case 6: /* I would dub it DCB_MMTHREADSIGNAL */
/* this is an undocumented DCB_ value used for mmThreads
* loword of dwCallBack contains the handle of the lpMMThd block
* which dwSignalCount has to be incremented
*/
if (pFnGetMMThread16)
{
WINE_MMTHREAD* lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
/* same as mmThreadSignal16 */
InterlockedIncrement(&lpMMThd->dwSignalCount);
SetEvent(lpMMThd->hEvent);
/* some other stuff on lpMMThd->hVxD */
}
break;
#endif
#if 0
case 4:
/* this is an undocumented DCB_ value for... I don't know */
break;
#endif
default:
WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
return FALSE;
}
TRACE("Done\n");
return TRUE;
}
int WINAPI WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow
)
{
SECURITY_ATTRIBUTES sa;
sa.bInheritHandle = true;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
if (!IsWow64())
return 1;
if (!CString(lpCmdLine).IsEmpty())
pidToAttach = atoi(lpCmdLine);
HMODULE hKernel32 = LoadLibrary("KERNEL32.DLL");
pfnLoadLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(hKernel32, ("LoadLibraryA"));
char *pDataRemote = 0;
DWORD numBytes = 0;
HANDLE fledgeProcess = NULL;
int numTries = 30;
while (numTries)
{
EnumWindows(FindFledge, pidToAttach);
if (fledgeWindow != NULL)
break;
Sleep(1000);
numTries--;
}
if (fledgeWindow == NULL)
return 1;
GetWindowThreadProcessId(fledgeWindow, &pidToAttach);
fledgeProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pidToAttach);
CStringA curDir;
GetCurrentDirectoryA(MAX_PATH, curDir.GetBuffer(MAX_PATH + 1));
CString param = curDir.GetBuffer();
param.Append("\\");
param.Append(HOOK_DLLNAME);
pDataRemote = (char*) VirtualAllocEx(fledgeProcess, 0, param.GetAllocLength(), MEM_COMMIT, PAGE_READWRITE);
if (pDataRemote == NULL)
return 1;
if (!WriteProcessMemory(fledgeProcess, pDataRemote, param.GetBuffer(), param.GetAllocLength(), &numBytes))
return 1;
DWORD threadID;
HANDLE fledgeThread = CreateRemoteThread(fledgeProcess, NULL, 0, (LPTHREAD_START_ROUTINE) pfnLoadLibrary, pDataRemote, 0, &threadID);
CStringA eventName;
eventName.Format("%s%d", "Global\\FledgeHook", pidToAttach);
HANDLE hEvent = CreateEventA(NULL, false, false, eventName);
WaitForSingleObject(hEvent, INFINITE);
DWORD WM_FLEDGEHOOKDATA = RegisterWindowMessageA("FledgeHookDataEvent");
PostThreadMessageA(threadID, WM_FLEDGEHOOKDATA, 0, (LPARAM)fledgeWindow);
curDir.ReleaseBuffer();
param.ReleaseBuffer();
CloseHandle(fledgeProcess);
return 0;
}
void __fastcall TMainForm::ToolButton6Click(TObject *Sender)
{
String FileName = "ExpMtr\\mtr.xml";
TStringList *list = new TStringList;
TSendThread *Client;
int mr;
String err, s;
char c[512];
MSG msg;
if ((err = cVerifData()) != "") {
ShowMessage(err);
return;
}
LoginForm->UserEdit->Text = /*"sc910001" + */"sc" + IntToStr(School.SchoolCode);
LoginForm->PasswordEdit->Text = "jXCHJQQo";
Client = new TSendThread(true);
if (LoginForm->ShowModal() != mrOk)
return;
Client->User = LoginForm->UserEdit->Text;
Client->Password = LoginForm->PasswordEdit->Text;
Client->ms = new TMemoryStream;
s = "SchoolCode=" + Client->User.SubString(3, 6);
Client->ms->Write(s.c_str(), 512);
// Client->ms->Write('\0', 1);
Client->CommandID = "4";
Client->srv = GetServerIP();
Client->FreeOnTerminate = true;
SendForm->Show();
SendForm->Memo1->Lines->Append("Соединение с сервером...");
while (PeekMessage(&msg, this->Handle, WM_USER, THRD_END, PM_REMOVE)); //инициализация и отчистка очереди
Client->Resume();
GetMessageA(&msg, 0, THRD_READY, THRD_READY);
while (!PeekMessageA(&msg, 0, THRD_END, THRD_END, PM_NOREMOVE)) {
Application->ProcessMessages();
WaitMessage();
}
if (!PostThreadMessageA(Client->ThreadID, MAIN_READY, 0, 0)) {
Client->Suspend();
Client->Terminate();
ShowMessage("Непредвиденная ошибка при попытке отправить сообщение окну.");
}
if (msg.wParam)
ShowMessage("WParam=" + IntToStr(msg.wParam));
if (msg.lParam) {
SendForm->Close();
FillServerMatrixForm(ReceiveStream);
ServerMatrixForm->Show();
}
else {
ShowMessage("Ошибка при получении списка матриц.");
}
}
void RMS_Socket::ReceviceRequest(SOCKET sockConn,int &timerId)
{
char recvType[1];
if (recv(sockConn, recvType, 1, 0) > 0)
{
char recvBuffer[4];
switch (recvType[0])
{
case heartbeat:
//重置超时计时
KillTimer(NULL, timerId);
timerId=SetTimer(NULL, 2, TIME_OVER, TimerProc);
break;
case picture:
break;
case video:
break;
//接收到控制信息，发送信息给主线程，主线程重新启动所有服务（待定）
case control:
//接收controlType
if (recv(sockConn, recvType, 1, 0) > 0)
{
switch (recvType[0])
{
case sampleInterval:
//发送消息给主线程，主线程重置计时器
if (recv(sockConn, recvBuffer, sizeof(int), 0) > 0)
{
int sample_interval;
/*memcpy(&sample_interval, recvBuffer, sizeof(int));
//网络字节序转换为主机字节序
sample_interval = ntohs(sampleInterval);*/
sample_interval = (int)recvBuffer[3];
PostThreadMessageA(mainThreadId, UM_CONTORL_SAMPLEINTERVAL, (WPARAM)sample_interval, NULL);
}
break;
case threshold:
if (recv(sockConn, recvBuffer, sizeof(int), 0) > 0)
{
int threshold = (int)recvBuffer[3];
PostThreadMessageA(mainThreadId, UM_CONTORL_THRESHOLD, (WPARAM)threshold, NULL);
}
break;
case recoverTime://异常恢复时间，暂时未加入该功能
if (recv(sockConn, recvBuffer, sizeof(int), 0) > 0)
{
int recoverTime= (int)recvBuffer[3];
PostThreadMessageA(mainThreadId, UM_CONTORL_RECOVERTIME, (WPARAM)recoverTime, NULL);
}
break;
default:
break;
}
}
break;
case disconnect:
isConnectted = false;
break;
case trust:
PostThreadMessageA(mainThreadId, UM_TRUST, NULL, NULL);
break;
default:
break;
}
}
}
