自学教程：C++ CreateEventA函数代码示例

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);}

nsresultNamedPipeInfo::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;}

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}

Signal::Signal(int count){    signalCount = count;    for (int a = 0; a < count; a++)    {        signalEvent[a] = CreateEventA(nullptr, false, false, nullptr);    }}

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);    }}

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 constructorBOOST_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; }