INT_PTR NewGUI_DoModal(CDialog* pDlg)
{
if(pDlg == NULL) { ASSERT(FALSE); return IDCANCEL; }
CPwSafeDlg* pRootDlg = (CPwSafeDlg*)KPMI_GetMainDialog();
ASSERT(pRootDlg != NULL);
VERIFY(g_csDoModalRoot.Lock() != FALSE);
if(pRootDlg != NULL)
{
pRootDlg->NotifyUserActivity();
pRootDlg->_SetDisplayDialog(true);
}
VERIFY(CGlobalWindowManager::AddDialog(pDlg) == S_OK);
VERIFY(g_csDoModalRoot.Unlock() != FALSE);
const INT_PTR r = pDlg->DoModal();
VERIFY(g_csDoModalRoot.Lock() != FALSE);
VERIFY(CGlobalWindowManager::RemoveDialog(pDlg) == S_OK);
if(pRootDlg != NULL)
{
pRootDlg->NotifyUserActivity();
pRootDlg->_SetDisplayDialog(false);
}
VERIFY(g_csDoModalRoot.Unlock() != FALSE);
return r;
}
void LogManager::AddErrorMessenger(Logger::ErrorMessenger* messenger)
{
m_CritSection.Lock();
S3D_ASSERT(messenger);
m_errorMessengers.push_back(messenger);
m_CritSection.Unlock();
}
unsigned int __stdcall Thread_RecvMsg(void *data)
{
//int nNetTimeout = 30000;
//setsockopt(sockClient,SOL_SOCKET,SO_RCVTIMEO,(char*)&nNetTimeout,sizeof(int));
while(1)
{
int nRet = recv(sockClient,(char*)recvBuf,RECV_BUF_LEN,0);
if((nRet == SOCKET_ERROR)|| (nRet == 0))
{
trySetConnectSocket(true);
critical_section.Lock();
if(exit_flag)
{
critical_section.Unlock();
//shutdown(sockClient,SD_RECEIVE);
shutdown(sockClient,SD_BOTH);
closesocket(sockClient);
return -1;
}
critical_section.Unlock();
Sleep(2000);
}
}
}
void serializeGrantDB(string filename){
LogPrintf(" Serialize Grant Info Database: Current Grant Database Block Height: %ld\n",grantDatabaseBlockHeight);
ofstream grantdb;
grantdb.open (filename.c_str(), ios::trunc);
//grantDatabaseBlockHeight
grantdb << grantDatabaseBlockHeight << "\n";
//Balances
grantdb << balances.size()<< "\n";
for(it=balances.begin(); it!=balances.end(); ++it){
grantdb << it->first << "\n" << it->second<< "\n";
}
//votingPreferences
for(int i=0;i<numberOfOffices;i++){
grantdb << votingPreferences[i].size()<< "\n";
for(vpit=votingPreferences[i].begin(); vpit!=votingPreferences[i].end(); ++vpit){
grantdb << vpit->first << "\n";
grantdb << vpit->second.size() << "\n";
for(it2=vpit->second.begin();it2!=vpit->second.end();++it2){
grantdb << it2->first << "\n" << it2->second<< "\n";
}
}
}
grantdb.flush();
grantdb.close();
}
long long EHS::StaticGetTotalBytesSent ( void )
{
ms_StatsCS.Lock();
long long llResult = ms_HttpTotalBytesSent;
ms_StatsCS.Unlock();
return llResult;
}
void CDlgObjectManager::OnObjmngProperties()
{
if(!m_hI) return;
CCriticalSection cs;
cs.Lock();
CMyObject* pObj;
pObj = FindObj(m_hI);
if(pObj && m_pDoc) {
pObj->Properties();
m_tree.SetItemText(m_hI, pObj->GetIdName());
if(m_pDoc) {
m_pDoc->SetModifiedFlag();
if( pObj->IsKindOf(RUNTIME_CLASS( CImgReferenced )) )
m_pDoc->UpdateAllViews(NULL, UPDATE_BITMAP_CAHNGED);
else if( pObj->IsKindOf(RUNTIME_CLASS(CGridObj)) )
m_pDoc->UpdateAllViews(NULL, UPDATE_LEADHRZ_CAHNGED);
else if( pObj->IsKindOf(RUNTIME_CLASS(CData3D)) )
m_pDoc->UpdateAllViews(NULL, UPDATE_DATA3D_CHANGED);
else
m_pDoc->UpdateAllViews(NULL);
m_hI = NULL;
}
return;
}
CBody* pBd;
pBd = (CBody*) FindBody(m_hI);
if(pBd && m_pDoc) {
pBd->Properties();
m_tree.SetItemText( m_hI, pBd->GetStrIdName() );
m_hI = NULL;
}
}
//
// Retrieves the number of milliseconds that have elapsed since some arbitrary point in time.
//
// GetTickCount64() exists on Vista and up and is like GetTickCount() except it returns
// an __int64 and will effectively never wrap. This is an emulated version for XP and down.
// Note: Wrap around issue is only defeated if the gap between calls is less than 24 days.
//
long long SharedUtil::GetTickCount64_ ( void )
{
ms_criticalSection.Lock ();
static long long llCurrent = ( GetTickCountInternal () % 300000 + 200000 );
static uint uiWas = GetTickCountInternal();
uint uiNow = GetTickCountInternal();
uint uiDelta = uiNow - uiWas;
uiWas = uiNow;
// Ensure delta is not negative
if ( uiDelta > 0x80000000 )
uiDelta = 0;
// Or greater than 600 seconds
if ( uiDelta > 600 * 1000 )
uiDelta = 600 * 1000;
// Add delta to accumulator
llCurrent += uiDelta;
// Add debug value
llCurrent += ms_llTickCountAdd;
ms_llTickCountAdd = 0;
long long llResult = llCurrent;
ms_criticalSection.Unlock ();
return llResult;
}
//插入1条任务结果
bool CSmartCommunicationDlg::SMT_InsertOneTaskResult(SMARTTASKRESULT mTaskResult)
{
g_CriticalSectionLock.Lock();
g_LSaveTaskResult.push_back(mTaskResult);
g_CriticalSectionLock.Unlock();
return true;
}
void CDummyWnd::ProcessMessageServer(CMessage *pMsg)
{
COMMON_PACKET cmnpck;
pMsg->GetData(&cmnpck, 0, sizeof(cmnpck));
switch(cmnpck.header) // ÆÐŶ Çì´õ °Ë»ö
{
case GSM_SERVERINFO : // °ÔÀÓ ¼¹ö Á¤º¸ÀÏ °æ¿ì
{
//AfxMessageBox("°ÔÀÓ ¼¹ö Á¤º¸ ÀúÀå.");
SERVERINFO si;
CHANNELINFO ci;
int nLen = pMsg->GetData(&si, 0, sizeof(si)); // ¿ì¼± °ÔÀÓ ¼¹ö ÀÚüÀÇ Á¤º¸¸¦ ¾òÀ½
LPSERVER server = m_ServerManager.GetServer((SOCKET)pMsg->GetSocket()); // ÆÐŶÀ» º¸³½ ¼¹ö¸¦ ãÀ½
if(server != NULL) // Á¤»óÀûÀÎ ¼¹ö Æ÷ÀÎÅ͸¦ °¡Á®¿ÔÀ» °æ¿ì
{
server->id = si.id; // ¼¹öÀÇ ¾ÆÀ̵ð ÀúÀå
server->ip = (char *)si.ip; // ¾ÆÀÌÇÇ ÀúÀå
server->portno = si.port; // Æ÷Æ®¹øÈ£ ÀúÀå
server->maxchannel = si.channels;
server->rooms = si.rooms;
if(!server->channel.size()) // ÃÖÃÊ¿¡ Á¢¼ÓÇÑ ¼¹öÀÏ °æ¿ì ä³ÎÁ¤º¸°¡ ¾øÀ½
{
CHANNEL channel;
for(int i = 0 ; i < si.channels ; i++) // Àüü ä³Î°¹¼ö¸¸Å
{
nLen += pMsg->GetData(&ci, nLen, sizeof(ci)); // ä³Î Á¤º¸¸¦ Çϳª¾¿ Àоî¿È
channel = ci; // ä³ÎÁ¤º¸¸¦ Çϳª¾¿ ÀúÀå
server->channel.push_back(channel); // ä³ÎÀ» ¸®½ºÆ®¿¡ Ãß°¡
}
}
else // ÀÌ¹Ì Ã¤³Î Á¤º¸°¡ Á¸ÀçÇÒ °æ¿ì // ÁÖ±âÀûÀÎ ¼¹ö Á¤º¸ÀÇ ¿äûÀÏ °æ¿ì
{
g_Critical.Lock();
list<CHANNEL>::iterator i = server->channel.begin();
for(; i != server->channel.end() ; i++)
{
LPCHANNEL lpchannel = &(*i);
nLen += pMsg->GetData(&ci, nLen, sizeof(ci));
*lpchannel = ci;
}
g_Critical.Unlock();
}
}
}
break;
}
}
void StatsNumResponsesInc( void )
{
ms_StatsCS.Lock();
ms_AllocationStats.uiTotalNumResponses++;
ms_AllocationStats.uiActiveNumResponses++;
ms_StatsCS.Unlock();
}
STDMETHODIMP CXRecords::Sort(VARIANT key, VARIANT varAsc)
{
if(!m_pFields)return SetErrorInfo(s_errInit);
int pos, bAsc;
int count = m_listRecords->GetCount();
if(count == 0)
return S_OK;
pos = m_pFields->FindField(key);
if(pos < 0 || pos >= (int)m_pFields->GetCount())
return DISP_E_BADINDEX;
bAsc = varGetNumbar(varAsc, 1);
s_csSort.Enter();
s_posSort = pos;
s_bAscSort = bAsc ? 1 : -1;
qsort(&m_listRecords->GetValue(0), count, sizeof(CXComPtr<CXRecord>), sortProc);
s_csSort.Leave();
return S_OK;
}
void StatsBytesAllocated( int nBodyLength )
{
ms_StatsCS.Lock();
ms_AllocationStats.uiTotalKBAllocated += nBodyLength / 1024;
ms_AllocationStats.uiActiveKBAllocated += nBodyLength / 1024;
ms_StatsCS.Unlock();
}
//Thread safe way to update the load log
void CLoadLTADlg::UpdateLoadLog()
{
CString sTextToAdd;
g_LoadLogPipeCS.Lock(INFINITE);
sTextToAdd = sm_sLoadLogPipe;
sm_sLoadLogPipe = "";
g_LoadLogPipeCS.Unlock();
if(!sTextToAdd.IsEmpty())
{
CString sLogText;
CEdit* pEdit = ((CEdit*)GetDlgItem(IDC_LOADLOG));
pEdit->GetWindowText(sLogText);
sLogText += sTextToAdd;
pEdit->SetWindowText(sLogText);
pEdit->LineScroll(pEdit->GetLineCount());
}
}
//Thread safe way to clear the load log
void CLoadLTADlg::ClearLoadLog()
{
g_LoadLogPipeCS.Lock(INFINITE);
sm_sLoadLogPipe = "";
g_LoadLogPipeCS.Unlock();
}
//Thread safe way to set if the loading thread is done
void CLoadLTADlg::SetLoadThreadDone(BOOL bDone)
{
g_ThreadDoneCS.Lock(INFINITE);
sm_bLoadThreadDone = bDone;
g_ThreadDoneCS.Unlock();
}
//Thread safe way to add text onto the end of the load log
void CLoadLTADlg::AppendLoadLog(const char* pszString)
{
g_LoadLogPipeCS.Lock(INFINITE);
sm_sLoadLogPipe += pszString;
g_LoadLogPipeCS.Unlock();
}
int WINAPI FindDupes(const char* szList, HWND hParent)
{
AFX_MANAGE_STATE(AfxGetAppModuleState());
hStopEvent=CreateEvent(0,0,0,0);
sListOfImages.RemoveAll();
sListOfImagesToDelete.RemoveAll();
sListOfImageDibs.RemoveAll();
CString sFiles=szList;
sFiles.Replace("\r","");
sFiles+="\n";
while(sFiles.GetLength()>0){
CString sWPTitle=sFiles.SpanExcluding("\n");
if(strlen(sWPTitle)!=strlen(sFiles)){
sFiles=sFiles.Mid(strlen(sWPTitle)+1);
}else{
sFiles="";
}
if(sWPTitle!="" && FindMini(sFiles,sWPTitle+"\n")==-1){
sListOfImages.Add(sWPTitle);
}
}
if(hCheckThread){
TerminateThread(hCheckThread,0);
hCheckThread=0;
}
DWORD dwID=0;
hCheckThread=CreateThread(0,0,CheckImages,0,0,&dwID);
DialogBox(theApp.m_hInstance,MAKEINTRESOURCE(IDD_DIALOG),hParent,OptionsDialogProc);
bStopCheck=1;
csCheck.Lock();
csCheck.Unlock();
WaitForSingleObject(hStopEvent,1000);
CloseHandle(hStopEvent);
if(hCheckThread){
TerminateThread(hCheckThread,0);
}
CloseHandle(hCheckThread);
hCheckThread=0;
hStopEvent=0;
for(int i=0;i<sListOfImageDibs.GetSize();i++){
if(sListOfImageDibs[i]){
delete sListOfImageDibs[i];
}
}
sPathInLeft="";
sPathInRight="";
if(btLeft){
_bmpX()->ReleaseBmp(btLeft);
btLeft=0;
}
if(btRight){
_bmpX()->ReleaseBmp(btRight);
btRight=0;
}
return lDeletedFiles;
}
BOOL CalculateExpression_Ole(CString& sExpr, CString sLang, BOOL bInSilence, int iEntryPoint)
{
cs.Lock();
int iRes=0;
::CoInitialize(NULL);
BOOL bJScriptLang=(sLang=="JScript" || sLang=="");
BOOL bVBScriptLang=(sLang=="VBScript");
if(bJScriptLang || bVBScriptLang)
{// Создаем область видимости чтобы разрушение ком-объекта было нормальным
MSScriptControl::IScriptControlPtr ScriptEngine;
ScriptEngine.CreateInstance("MSScriptControl.ScriptControl");
if(bJScriptLang){
ScriptEngine->Language="JScript";
}else if(bVBScriptLang){
ScriptEngine->Language="VBScript";
}else{
ScriptEngine->Language=(const char*)sLang;
}
ScriptEngine->Timeout = -1;//No timeout
try {//RET_FAIL(spAS->AddNamedItem(OLESTR("MyObject"), SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE), "IActiveScript::AddNamedItem()");
_variant_t result;
if(!bJScriptLang){
sExpr=CString("Dim OUTPUT\r\n")+sExpr;
ScriptEngine->ExecuteStatement(bstr_t(sExpr));
sExpr="OUTPUT";
result=ScriptEngine->Eval(bstr_t(sExpr));
}else{
result=ScriptEngine->Eval(bstr_t(sExpr));
}
sExpr=(const char*)_bstr_t(result);
iRes=1;
}catch(_com_error err){
if(!bInSilence){
//FLOG1("Script error: \n%s\n",sExpr)
CString sErr((BSTR)err.Description());
CString sErrSource((BSTR)err.Source());
if(sErrSource!=""){
sErr+="\n";
sErr+=sErrSource;
}
if(sErr==""){
sErr=GetCOMError(err.Error());
}
AfxMessageBox(sErr);
}
iRes=-1;
};
}else
{// Загружаем дллку
iRes=FALSE;
}
::CoUninitialize();
cs.Unlock();
return iRes;
}
CManagerPool &CManagerPool::GetInitInstance()
{
CCriticalSection Mutex;
if(m_PtrInstance == NULL)
{
//mutex.Lock();
Mutex.Lock();
m_PtrInstance = new CManagerPool();
Mutex.Unlock();
}
return *m_PtrInstance;
}
//-----------------------------------------------------------------------------
// Name: Calculate()
// Desc:
//-----------------------------------------------------------------------------
void COscillDlg::Calculate( void )
{
// TRACE( ">>Enter Calculate\r\n" );
TRACE( " Ask->Calc\r\n" );
g_csRWData.Lock();
TRACE( " ->Calc\r\n" );
int nSampPerDiv = (int)( g_sMeasPara.nSampFreq * c_fTbScaleCoef[m_byTbScale] );
m_nSampPerFrame = 12 * nSampPerDiv;
// m_nXCnt %= m_nSampPerFrame;
m_nXCnt = g_psQueue->num % m_nSampPerFrame;
m_nNumOfDiv = ( g_psQueue->num - m_nXCnt ) / nSampPerDiv;
m_ctrlSbDrawFrame.SetScrollRange( 0, m_nNumOfDiv );
int nPosition = m_ctrlSbDrawFrame.GetScrollPos();
int ntmp = m_nNumOfDiv - nPosition - ( 12 - m_nXCnt / nSampPerDiv );
if ( 0 < ntmp )
{
m_nQueueRearOffset = - m_nXCnt % nSampPerDiv - nSampPerDiv * ntmp;
}
else
{
m_nQueueRearOffset = 0;
}
if ( nPosition == m_nNumOfDiv )
{
m_nQueueRearOffset = 0;
}
m_nXCntOffset = 0;
if ( 0 == m_nQueueRearOffset )
{
m_nXCntOffset = ( m_nNumOfDiv - nPosition ) * nSampPerDiv;
}
/*
TRACE( "SampPerFrame:%5d DivNum:%3d Pos:%3d NUM:%5d QueueRearOffset:%6d XCnt:%5d XCntOffset:%3d\r\n",
m_nSampPerFrame,
m_nNumOfDiv,
nPosition,
g_psQueue->num,
m_nQueueRearOffset,
m_nXCnt,
m_nXCntOffset
);
*/
TRACE( " <-Calc\r\n" );
g_csRWData.Unlock();
// TRACE( " >>Leave Calculate\r\n" );
}
void LogManager::Log(const std::string& tag, const std::string& msg, const char* funcName, const char* fileName, unsigned int lineNum)
{
m_CritSection.Lock();
Tags::iterator findIt = m_Tags.find(tag);
if (findIt != m_Tags.end())
{
std::string buffer;
GetOutputBuffer(buffer, tag, msg, funcName, fileName, lineNum);
OutputBufferToLogs(buffer, findIt->second);
}
m_CritSection.Unlock();
}
//Thread safe way to check the done flag, and update the dialog box
//appropriately
BOOL CLoadLTADlg::IsDone()
{
BOOL bDone = FALSE;
g_ThreadDoneCS.Lock(INFINITE);
bDone = sm_bLoadThreadDone;
g_ThreadDoneCS.Unlock();
return bDone;
}
UINT funcaoThread(LPVOID param) {
while (1) {
cs.Lock();
for (int i = 0; i < 10; i++) {
array[i] = (array[i] + 1) % 10;
Sleep(10);
}
cs.Unlock();
Sleep(100);
}
return 0;
}
long long SharedUtil::GetModuleTickCount64 ( void )
{
static CCriticalSection criticalSection;
criticalSection.Lock ();
if ( !gCurrentTickCount64 )
UpdateModuleTickCount64 ();
long long result = gCurrentTickCount64;
criticalSection.Unlock ();
return result;
}
// TEST 2: Assure that a double-enter in a CS will raise an exception
// ----------------------------------------------------------------------------
void my_CriticalSections_NoDoubleEnter()
{
CCriticalSection cs;
cs.enter();
try{
cs.enter(); // Must fail!
// Shouldn't reach here.
EXPECT_TRUE(false) << "Fail to detect a double 'enter()' into a critical section!\n";
}
catch(std::exception&)
{
// OK
}
}
void WriteLog (CString &pMessage, LPSTR pDebugMode)
{
mWriteLog.Lock();
char pFileName[MAX_PATH]= {0};
char path_buffer[_MAX_PATH] = {0};
char drive[_MAX_DRIVE]= {0};
char dir[_MAX_DIR]= {0};
char fname[_MAX_FNAME]= {0};
char ext[_MAX_EXT]= {0};
memset( path_buffer, 0, sizeof( path_buffer ) );
memset( drive, 0, sizeof( drive ) );
memset( dir, 0, sizeof( dir ) );
memset( fname, 0, sizeof( fname ) );
memset( ext, 0, sizeof( ext ) );
GetModuleFileName( 0, path_buffer, 1023 );
_splitpath ( path_buffer, drive, dir, fname, ext );
sprintf(pFileName,"%s%s%s",drive,dir,m_gLogFileName);
CFile f;
CFileException ex;
DWORD dwActual = 0;
if( f.Open( pFileName, CFile::modeRead | CFile::shareDenyWrite, &ex) !=0)
{
dwActual = f.SeekToEnd();
f.Close();
if ( dwActual >= 500000)
DeleteFile(pFileName);
}
FILE *fp = fopen(pFileName, "a");
if (fp)
{
CString strData;
CTime t = CTime::GetCurrentTime();
strData.Format("%s,%s,%s,%s\n",strModule, strVersion,t.Format("%c"),pMessage);
fputs(strData,fp);
fclose(fp);
}
mWriteLog.Unlock();
return;
}
void LogManager::SetDisplayFlags(const std::string& tag, unsigned char flag)
{
m_CritSection.Lock();
if (flag != 0)
{
Tags::iterator findIt = m_Tags.find(tag);
if (findIt == m_Tags.end())
m_Tags.insert(std::make_pair(tag, flag));
else
findIt->second = flag;
}
else
m_Tags.erase(tag);
m_CritSection.Unlock();
}
void launchTestWithTimeout(void (*func)(void), double timeout_secs, const std::string &fail_msg )
{
struct TAux
{
bool terminated;
void (*m_func)(void);
void run(int )
{
if (m_func) (*m_func)(); else throw std::runtime_error("functor is NULL!!");
terminated = true;
}
TAux( void (*func)(void) ) : terminated(false),m_func(func) {}
};
TAux obj(func);
mrpt::system::TThreadHandle th = mrpt::system::createThreadFromObjectMethod<TAux>( &obj, &TAux::run, 0 );
mrpt::utils::CTicTac tim;
tim.Tic();
while (!obj.terminated && tim.Tac()<timeout_secs) {
mrpt::system::sleep(1);
}
if (!obj.terminated)
EXPECT_TRUE(false) << "Thread didn't finished in timeout! While testing: " << fail_msg;
}
CRetakeLock(CSharedSection §ion, CCriticalSection &owned = g_graphicsContext)
: m_count(owned.exit())
, m_lock (section),
m_owned(owned)
{
m_owned.restore(m_count);
}
// ------------------------------------------------------
// MAIN
// ------------------------------------------------------
int main()
{
try
{
csTest.m_debugOut = &myOutStream;
cout << "Part 1: Normal usage, we'll lock, then unlock the critical section" << endl << endl;
{
synch::CCriticalSectionLocker locker(&csTest);
cout << "I possess the crit. section..." << endl;
}
cout << endl << "Part 2: Bad usage, we'll lock, then lock again the critical section" << endl << endl;
{
synch::CCriticalSectionLocker locker(&csTest);
csTest.enter();
cout << "This message shouldn't appear, an exception raised before instead!!" << endl;
}
return 0;
} catch (std::exception &e)
{
std::cout << "MRPT exception caught: " << e.what() << std::endl;
return -1;
}
catch (...)
{
printf("Untyped exception!!");
return -1;
}
}