void TSensorView::CmViewer(WPARAM nId)
{
  if(!m_pSim)
    return;
  int nType = nId - CM_LINE;
  switch(nType)
  {
    case 0:
      if(m_nDimSize[0] == 1)
        return;
    case 1:
    case 2:
    case 4:
      if(m_nDim > 2)
        return;
      break;
    case 3:
      if(!m_nDim || m_nDimSize[m_nDim-1] > 3)
        return;
      break;
    case 5:
      if(m_nDimSize[0] == 1 || m_nDimSize[1] != 2)
        return;
  }
  m_nType = nType;
  OnSuccess();
  Invalidate();
}
示例#2
0
xUnitFailure Assert::True(bool b, LineInfo &&lineInfo) const
{
    if (!b)
    {
        return OnFailure(std::move(xUnitAssert(callPrefix + "True", std::move(lineInfo)).Expected("true").Actual("false")));
    }

    return OnSuccess();
}
示例#3
0
xUnitFailure Assert::Contains(const std::string &actualString, const std::string &value, LineInfo &&lineInfo) const
{
    if (actualString.find(value) == std::string::npos)
    {
        return OnFailure(std::move(xUnitAssert(callPrefix + "Contains", std::move(lineInfo))
            .Expected(std::string(value))    // can't assume actualString or value can be moved
            .Actual(std::string(actualString))));
    }

    return OnSuccess();
}
示例#4
0
xUnitFailure Assert::DoesNotContain(const std::string &actualString, const std::string &value, LineInfo &&lineInfo) const
{
    auto found = actualString.find(value);
    if (found != std::string::npos)
    {
        return OnFailure(std::move(xUnitAssert(callPrefix + "DoesNotContain", std::move(lineInfo))
            .CustomMessage("Found: \"" + value + "\" at position " + ToString(found) + ".")));
    }

    return OnSuccess();
}
示例#5
0
xUnitFailure Assert::NotEqual(const std::string &expected, const std::string &actual, LineInfo &&lineInfo) const
{
    if (expected == actual)
    {
        return OnFailure(std::move(xUnitAssert(callPrefix + "NotEqual", std::move(lineInfo))
            .Expected(std::string(expected))    // can't assume expected or actual are allowed to be moved
            .Actual(std::string(actual))));
    }

    return OnSuccess();
}
void DatabaseJobContext::OnResult()
{
	//done: 이 함수는 반드시 IO스레드풀에서 수행되어야 한다. 그렇지 않으면 CRASH시키기
	CRASH_ASSERT(LThreadType == THREAD_IO_WORKER);
	CRASH_ASSERT(LWorkerThreadId >= MAX_DB_THREAD);

	if (mSuccess)
		OnSuccess();
	else
		OnFail();
}
示例#7
0
文件: GameView.cpp 项目: astroluj/MFC
// 카드 맞추는 도중
void CGameView::OnMatching(void)
{
	CGameDoc* pDoc = GetDocument();

	// 그림이 같으면
	if(pDoc->gd_nBmpFirstID == pDoc->gd_nBmpSecondID && pDoc->gd_bMouse == FALSE){
		PlaySound (L"C:\\image\\키스쪽.wav", NULL, SND_ASYNC) ;		// 그림이 맞았을 때 나는 소리
		
		// 클릭 이벤트 초기화
		pDoc->gd_bShow[gv_nRowTempIndex][gv_nColTempIndex] 
		= pDoc->gd_bShow[pDoc->gd_nRowIndex][pDoc->gd_nColIndex] = TRUE;
		pDoc->gd_nBmpFirstID = pDoc->gd_nBmpSecondID 
		= gv_nRowTempIndex = gv_nColTempIndex = 0;

		gv_nMatchCount ++;
		gv_point+= 10 ;		// 그림을 맞추었을 때 10점 추가
	}
	else if(pDoc->gd_nBmpFirstID != pDoc->gd_nBmpSecondID && pDoc->gd_bMouse == FALSE){
		// 다른 그림이어도 보여주긴함
		CDC* pDC = GetDC();
		CDC memDC;
		CBitmap bmp;

		memDC.CreateCompatibleDC(pDC);
		bmp.LoadBitmapW(IDB_BITMAP1 + pDoc->gd_nBmpSecondID);

		CRect rect;
		GetClientRect(&rect);

		CBitmap* pOldBmp = memDC.SelectObject(&bmp);
		pDC->StretchBlt(rect.right/(pDoc->gd_nCol+2)*(pDoc->gd_nColIndex + 1),
			rect.bottom/(pDoc->gd_nRow+2)*(pDoc->gd_nRowIndex + 1),
			rect.right/(pDoc->gd_nCol+2), rect.bottom/(pDoc->gd_nRow+2), 
			&memDC, 0, 0, pDoc->gd_bmCell.cx, pDoc->gd_bmCell.cy, SRCCOPY);

		bmp.DeleteObject();
		memDC.SelectObject(pOldBmp);
		// 카드 보여주는 시간
		Sleep(400);

		// 클릭 이벤트 초기화
		pDoc->gd_bShow[gv_nRowTempIndex][gv_nColTempIndex] = FALSE;
		pDoc->gd_bShow[pDoc->gd_nRowIndex][pDoc->gd_nColIndex] = FALSE;
		pDoc->gd_nBmpFirstID = pDoc->gd_nBmpSecondID = 0;
		gv_nRowTempIndex = gv_nColTempIndex = 0;
	}

	Invalidate();
	if(gv_nMatchCount == (pDoc->gd_nRow*pDoc->gd_nCol)/2) OnSuccess() ;
}
void MifareSendCommand(uint8_t arg0, uint8_t arg1, uint8_t *datain){
	
	/* ARG0 contains flags.
		0x01 = init card.
		0x02 = Disconnect
		0x03
	*/
	uint8_t flags = arg0;
	size_t datalen = arg1;
	uint8_t resp[RECEIVE_SIZE];
	memset(resp,0,sizeof(resp));
	
	if (MF_DBGLEVEL >= 4) {
		Dbprintf(" flags : %02X", flags);
		Dbprintf(" len   : %02X", datalen);
		print_result(" RX    : ", datain, datalen);
	}
	
	if ( flags & CLEARTRACE )
		clear_trace();
	
	if ( flags & INIT ){
		if ( !InitDesfireCard() )
			return;
	}
	
	int len = DesfireAPDU(datain, datalen, resp);
	if (MF_DBGLEVEL >= 4)
		print_result("ERR <--: ", resp, len);

	if ( !len ) {
		OnError(2);
		return;
	}
	
	// reset the pcb_blocknum,
	pcb_blocknum = 0;
	
	if ( flags & DISCONNECT )
		OnSuccess();
	
	cmd_send(CMD_ACK,1,len,0,resp,len);
}
void MifareDesfireGetInformation(){
		
	int len = 0;
	uint8_t resp[USB_CMD_DATA_SIZE] = {0x00};
	uint8_t dataout[USB_CMD_DATA_SIZE] = {0x00};
	byte_t cardbuf[USB_CMD_DATA_SIZE] = {0x00};
	
	/*
		1 = PCB					1
		2 = cid					2
		3 = desfire command		3 
		4-5 = crc				4  key
								5-6 crc								
		PCB == 0x0A because sending CID byte.
		CID == 0x00 first card?		
	*/
	clear_trace();
	set_tracing(TRUE);
	iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);

	// card select - information
	iso14a_card_select_t *card = (iso14a_card_select_t*)cardbuf;
	byte_t isOK = iso14443a_select_card(NULL, card, NULL, true, 0);
	if ( isOK == 0) {
		if (MF_DBGLEVEL >= MF_DBG_ERROR) {
			Dbprintf("Can't select card");
		}
		OnError(1);
		return;
	}

	memcpy(dataout,card->uid,7);

	LED_A_ON();
	LED_B_OFF();
	LED_C_OFF();
	
	uint8_t cmd[] = {GET_VERSION};	
	size_t cmd_len = sizeof(cmd);
	
	len =  DesfireAPDU(cmd, cmd_len, resp);
	if ( !len ) {
		print_result("ERROR <--: ", resp, len);	
		OnError(2);
		return;
	}
	
	LED_A_OFF();
	LED_B_ON();
	memcpy(dataout+7,resp+3,7);
	
	// ADDITION_FRAME 1
	cmd[0] = ADDITIONAL_FRAME;
	len =  DesfireAPDU(cmd, cmd_len, resp);
	if ( !len ) {
		print_result("ERROR <--: ", resp, len);	
		OnError(2);
		return;
	}	
	
	LED_B_OFF();
	LED_C_ON();
	memcpy(dataout+7+7,resp+3,7);

	// ADDITION_FRAME 2
	len =  DesfireAPDU(cmd, cmd_len, resp);
	if ( !len ) {
		print_result("ERROR <--: ", resp, len);	
		OnError(2);
		return;
	}
	
	memcpy(dataout+7+7+7,resp+3,14);
	
	cmd_send(CMD_ACK,1,0,0,dataout,sizeof(dataout));
		
	// reset the pcb_blocknum,
	pcb_blocknum = 0;
	OnSuccess();
}
void OnError(uint8_t reason){
	cmd_send(CMD_ACK,0,reason,0,0,0);
	OnSuccess();
}
void MifareDES_Auth1(uint8_t mode, uint8_t algo, uint8_t keyno,  uint8_t *datain){

	int len = 0;
	//uint8_t PICC_MASTER_KEY8[8] = { 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47};
	uint8_t PICC_MASTER_KEY16[16] = { 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f };
	uint8_t null_key_data8[8] = {0x00};
	//uint8_t null_key_data16[16] = {0x00};	
	//uint8_t new_key_data8[8]  = { 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
	//uint8_t new_key_data16[16]  = { 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};

	uint8_t resp[256] = {0x00};
	uint8_t IV[16] = {0x00};

	size_t datalen = datain[0];
	
	uint8_t cmd[40] = {0x00};
	uint8_t encRndB[16] = {0x00};
	uint8_t decRndB[16] = {0x00};
	uint8_t nonce[16] = {0x00};
	uint8_t both[32] = {0x00};
	uint8_t encBoth[32] = {0x00};

	InitDesfireCard();
	
	LED_A_ON();
	LED_B_OFF();
	LED_C_OFF();
	
	// 3 olika sätt att authenticera.   AUTH (CRC16) , AUTH_ISO (CRC32) , AUTH_AES (CRC32)
	// 4 olika crypto algo   DES, 3DES, 3K3DES, AES
	// 3 olika kommunikations sätt,   PLAIN,MAC,CRYPTO
	
	// des, nyckel 0, 
	switch (mode){
        case 1:{
            uint8_t keybytes[16];
            uint8_t RndA[8] = {0x00};
            uint8_t RndB[8] = {0x00};
            
            if (algo == 2) {
            if (datain[1] == 0xff){
                    memcpy(keybytes,PICC_MASTER_KEY16,16);
                } else {
                    memcpy(keybytes, datain+1, datalen);
                }
            } else {
                if (algo == 1) {
                    if (datain[1] == 0xff){
                memcpy(keybytes,null_key_data8,8);
            } else{
                memcpy(keybytes, datain+1, datalen);
            }
                }
            }
            
            struct desfire_key defaultkey = {0};
            desfirekey_t key = &defaultkey;
            
            if (algo == 2)
                Desfire_3des_key_new_with_version(keybytes, key);
            else if (algo ==1)
            Desfire_des_key_new(keybytes, key);
            
            cmd[0] = AUTHENTICATE;
            cmd[1] = keyno;  //keynumber
            len = DesfireAPDU(cmd, 2, resp);
            if ( !len ) {
                if (MF_DBGLEVEL >= MF_DBG_ERROR) {
                    DbpString("Authentication failed. Card timeout.");
                }
                OnError(3);
                return;
            }
            
            if ( resp[2] == 0xaf ){
            } else {
                DbpString("Authetication failed. Invalid key number.");
                OnError(3);
                return;
            }
            
            memcpy( encRndB, resp+3, 8);
            if (algo == 2)
                tdes_dec(&decRndB, &encRndB, key->data);
            else if (algo == 1)
            des_dec(&decRndB, &encRndB, key->data);
            
            memcpy(RndB, decRndB, 8);
            rol(decRndB,8);
            
            // This should be random
            uint8_t decRndA[8] = {0x00};
            memcpy(RndA, decRndA, 8);
            uint8_t encRndA[8] = {0x00};
            
            if (algo == 2)
                tdes_dec(&encRndA, &decRndA, key->data);
            else if (algo == 1)
            des_dec(&encRndA, &decRndA, key->data);
            
            memcpy(both, encRndA, 8);
            
            for (int x = 0; x < 8; x++) {
                decRndB[x] = decRndB[x] ^ encRndA[x];
                
            }
            
            if (algo == 2)
                tdes_dec(&encRndB, &decRndB, key->data);
            else if (algo == 1)
            des_dec(&encRndB, &decRndB, key->data);
            
            memcpy(both + 8, encRndB, 8);
            
            cmd[0] = ADDITIONAL_FRAME;
            memcpy(cmd+1, both, 16 );
            
            len = DesfireAPDU(cmd, 17, resp);
            if ( !len ) {
                if (MF_DBGLEVEL >= MF_DBG_ERROR) {
                    DbpString("Authentication failed. Card timeout.");
                }
                OnError(3);
                return;
            }
            
            if ( resp[2] == 0x00 ){
                
                struct desfire_key sessionKey = {0};
                desfirekey_t skey = &sessionKey;
                Desfire_session_key_new( RndA, RndB , key, skey );
                //print_result("SESSION : ", skey->data, 8);
                
                memcpy(encRndA, resp+3, 8);
                
                if (algo == 2)
                    tdes_dec(&encRndA, &encRndA, key->data);
                else if (algo == 1)
                des_dec(&encRndA, &encRndA, key->data);
                
                rol(decRndA,8);
                for (int x = 0; x < 8; x++) {
                    if (decRndA[x] != encRndA[x]) {
                        DbpString("Authetication failed. Cannot varify PICC.");
                        OnError(4);
                        return;
                    }
                }
                
                //Change the selected key to a new value.
                /*
                 
                 // Current key is a 3DES key, change it to a DES key
                 if (algo == 2) {
                cmd[0] = CHANGE_KEY;
                cmd[1] = keyno;
                
                uint8_t newKey[16] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
                
                uint8_t first, second;
                uint8_t buff1[8] = {0x00};
                uint8_t buff2[8] = {0x00};
                uint8_t buff3[8] = {0x00};
                
                memcpy(buff1,newKey, 8);
                memcpy(buff2,newKey + 8, 8);
                
                ComputeCrc14443(CRC_14443_A, newKey, 16, &first, &second);
                memcpy(buff3, &first, 1);
                memcpy(buff3 + 1, &second, 1);
                
                 tdes_dec(&buff1, &buff1, skey->data);
                 memcpy(cmd+2,buff1,8);
                 
                 for (int x = 0; x < 8; x++) {
                 buff2[x] = buff2[x] ^ buff1[x];
                 }
                 tdes_dec(&buff2, &buff2, skey->data);
                 memcpy(cmd+10,buff2,8);
                 
                 for (int x = 0; x < 8; x++) {
                 buff3[x] = buff3[x] ^ buff2[x];
                 }
                 tdes_dec(&buff3, &buff3, skey->data);
                 memcpy(cmd+18,buff3,8);
                 
                 // The command always times out on the first attempt, this will retry until a response
                 // is recieved.
                 len = 0;
                 while(!len) {
                 len = DesfireAPDU(cmd,26,resp);
                 }
                 
                 } else {
                    // Current key is a DES key, change it to a 3DES key
                    if (algo == 1) {
                        cmd[0] = CHANGE_KEY;
                        cmd[1] = keyno;
                        
                        uint8_t newKey[16] = {0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f};
                        
                        uint8_t first, second;
                        uint8_t buff1[8] = {0x00};
                        uint8_t buff2[8] = {0x00};
                        uint8_t buff3[8] = {0x00};
                        
                        memcpy(buff1,newKey, 8);
                        memcpy(buff2,newKey + 8, 8);
                        
                        ComputeCrc14443(CRC_14443_A, newKey, 16, &first, &second);
                        memcpy(buff3, &first, 1);
                        memcpy(buff3 + 1, &second, 1);
                        
                des_dec(&buff1, &buff1, skey->data);
                memcpy(cmd+2,buff1,8);
                
                for (int x = 0; x < 8; x++) {
                    buff2[x] = buff2[x] ^ buff1[x];
                }
                des_dec(&buff2, &buff2, skey->data);
                memcpy(cmd+10,buff2,8);
                
                for (int x = 0; x < 8; x++) {
                    buff3[x] = buff3[x] ^ buff2[x];
                }
                des_dec(&buff3, &buff3, skey->data);
                memcpy(cmd+18,buff3,8);
                
                // The command always times out on the first attempt, this will retry until a response
                // is recieved.
                len = 0;
                while(!len) {
                    len = DesfireAPDU(cmd,26,resp);
                }
                    }
                 }
                */
                
                OnSuccess();
                if (algo == 2)
                    cmd_send(CMD_ACK,1,0,0,skey->data,16);
                else if (algo == 1)
                cmd_send(CMD_ACK,1,0,0,skey->data,8);
            } else {
                DbpString("Authetication failed.");
                OnError(6);
                return;
            }
            }
			break;
		case 2:
			//SendDesfireCommand(AUTHENTICATE_ISO, &keyno, resp);
			break;
		case 3:{
		
			//defaultkey
			uint8_t keybytes[16] = {0x00};
			if (datain[1] == 0xff){
				memcpy(keybytes,PICC_MASTER_KEY16,16); 
			} else{
				memcpy(keybytes, datain+1, datalen);
			}
			
			struct desfire_key defaultkey = {0x00};
			desfirekey_t key = &defaultkey;
			Desfire_aes_key_new( keybytes, key);
		
			AesCtx ctx;
			if ( AesCtxIni(&ctx, IV, key->data, KEY128, CBC) < 0 ){
				if( MF_DBGLEVEL >= 4) {
					Dbprintf("AES context failed to init");
				}
				OnError(7);
				return;
			}
			
			cmd[0] = AUTHENTICATE_AES;
			cmd[1] = 0x00;  //keynumber
			len = DesfireAPDU(cmd, 2, resp);
			if ( !len ) {
				if (MF_DBGLEVEL >= MF_DBG_ERROR) {
					DbpString("Authentication failed. Card timeout.");
				}
				OnError(3);
				return;
			}
			
			memcpy( encRndB, resp+3, 16);
		
			// dekryptera tagnonce.
			AesDecrypt(&ctx, encRndB, decRndB, 16);
			rol(decRndB,16);
			memcpy(both, nonce,16);
			memcpy(both+16, decRndB ,16 );
			AesEncrypt(&ctx, both, encBoth, 32 );
			
			cmd[0] = ADDITIONAL_FRAME;
			memcpy(cmd+1, encBoth, 32 );
			
			len = DesfireAPDU(cmd, 33, resp);  // 1 + 32 == 33
			if ( !len ) {
				if (MF_DBGLEVEL >= MF_DBG_ERROR) {
					DbpString("Authentication failed. Card timeout.");
				}
                OnError(3);
				return;
			}
			
			if ( resp[2] == 0x00 ){
				// Create AES Session key		
				struct desfire_key sessionKey = {0};
				desfirekey_t skey = &sessionKey;
				Desfire_session_key_new( nonce, decRndB , key, skey );
				print_result("SESSION : ", skey->data, 16);
			} else {
				DbpString("Authetication failed.");
				OnError(7);
				return;
			}
			
			break;
		}	
	}
	
	OnSuccess();
	cmd_send(CMD_ACK,1,len,0,resp,len);
}
NS_IMETHODIMP
AsyncConnectionHelper::Run()
{
  if (NS_IsMainThread()) {
    if (mTransaction &&
        mTransaction->IsAborted()) {
      // Always fire a "error" event with ABORT_ERR if the transaction was
      // aborted, even if the request succeeded or failed with another error.
      mResultCode = NS_ERROR_DOM_INDEXEDDB_ABORT_ERR;
    }

    IDBTransaction* oldTransaction = gCurrentTransaction;
    gCurrentTransaction = mTransaction;

    if (mRequest) {
      nsresult rv = mRequest->NotifyHelperCompleted(this);
      if (NS_SUCCEEDED(mResultCode) && NS_FAILED(rv)) {
        mResultCode = rv;
      }
    }

    // Call OnError if the database had an error or if the OnSuccess handler
    // has an error.
    if (NS_FAILED(mResultCode) ||
        NS_FAILED((mResultCode = OnSuccess()))) {
      OnError();
    }

    NS_ASSERTION(gCurrentTransaction == mTransaction, "Should be unchanged!");
    gCurrentTransaction = oldTransaction;

    if (mDispatched && mTransaction) {
      mTransaction->OnRequestFinished();
    }

    ReleaseMainThreadObjects();

    NS_ASSERTION(!(mDatabase || mTransaction || mRequest), "Subclass didn't "
                 "call AsyncConnectionHelper::ReleaseMainThreadObjects!");

    return NS_OK;
  }

  nsresult rv = NS_OK;
  nsCOMPtr<mozIStorageConnection> connection;

  if (mTransaction) {
    rv = mTransaction->GetOrCreateConnection(getter_AddRefs(connection));
    if (NS_SUCCEEDED(rv)) {
      NS_ASSERTION(connection, "This should never be null!");
    }
  }

  bool setProgressHandler = false;
  if (connection) {
    rv = connection->SetProgressHandler(kProgressHandlerGranularity, this,
                                        getter_AddRefs(mOldProgressHandler));
    NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "SetProgressHandler failed!");
    if (NS_SUCCEEDED(rv)) {
      setProgressHandler = true;
    }
  }

  if (NS_SUCCEEDED(rv)) {
    bool hasSavepoint = false;
    if (mDatabase) {
      IndexedDatabaseManager::SetCurrentDatabase(mDatabase);

      // Make the first savepoint.
      if (mTransaction) {
        if (!(hasSavepoint = mTransaction->StartSavepoint())) {
          NS_WARNING("Failed to make savepoint!");
        }
      }
    }

    mResultCode = DoDatabaseWork(connection);

    if (mDatabase) {
      IndexedDatabaseManager::SetCurrentDatabase(nsnull);

      // Release or roll back the savepoint depending on the error code.
      if (hasSavepoint) {
        NS_ASSERTION(mTransaction, "Huh?!");
        if (NS_SUCCEEDED(mResultCode)) {
          mTransaction->ReleaseSavepoint();
        }
        else {
          mTransaction->RollbackSavepoint();
        }
      }
    }
  }
  else {
    // NS_ERROR_NOT_AVAILABLE is our special code for "database is invalidated"
    // and we should fail with RECOVERABLE_ERR.
    if (rv == NS_ERROR_NOT_AVAILABLE) {
      mResultCode = NS_ERROR_DOM_INDEXEDDB_RECOVERABLE_ERR;
    }
    else {
      mResultCode = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
    }
  }

  if (setProgressHandler) {
    nsCOMPtr<mozIStorageProgressHandler> handler;
    rv = connection->RemoveProgressHandler(getter_AddRefs(handler));
    NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "RemoveProgressHandler failed!");
#ifdef DEBUG
    if (NS_SUCCEEDED(rv)) {
      NS_ASSERTION(SameCOMIdentity(handler, static_cast<nsIRunnable*>(this)),
                   "Mismatch!");
    }
#endif
  }

  return NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL);
}
示例#13
0
	virtual void OnFinished()
	{
		m_custom_apps.Give(g_DOM_jilUtils->GetApplicationNames());
		OnSuccess();
	}
示例#14
0
文件: GameView.cpp 项目: astroluj/MFC
void CGameView::OnTimer(UINT_PTR nIDEvent)
{
	// 심장소리 음악
	if (!gv_min && gv_sec < 10 && !gv_timeDV){	// 분이 0이고 초가 10초 미만일 때 시간제한 음악 켬
		StopSounds (gv_bgDV) ;
		PlaySounds (gv_timeDV) ;
	}

	CClientDC dc (this) ;
	CRect rect ;
	GetClientRect (&rect) ;
	CFont myFont, *pOldFont ;
	CString str;
	
	// Text 설정 Part
	myFont.CreateFont (25, 0, 0, 0, FW_BOLD, true, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, gv_font) ;
	pOldFont =dc.SelectObject (&myFont) ;
	dc.SetBkColor (gv_bgColor) ;		// 글자의 배경은 바탕과 같이 
	dc.SetTextColor (0x00FFFFFF & ~gv_bgColor) ;		// 글자 색을 바탕화면의 반대 색으로

	// 시간에 따른 출력부
	if (!gv_scoreTF) {
		if (gv_min < 10 && gv_min) gv_minStr.Format (_T(" 0%d"), gv_min) ;
		else if (!gv_min) gv_minStr.Format (_T (" 00")) ;
		else gv_minStr.Format (_T (" %d"), gv_min) ;
		
		if (gv_sec < 10 && gv_sec) gv_secStr.Format (_T("0%d"), gv_sec) ;
		else if (!gv_sec) gv_secStr.Format (_T ("00")) ;
		else gv_secStr.Format (_T ("%d"), gv_sec) ;

		if (gv_csec < 10 && gv_csec) gv_csecStr.Format (_T("0%d"), gv_csec) ;
		else if (!gv_csec) gv_csecStr.Format (_T ("00")) ;
		else gv_csecStr.Format (_T ("%d"), gv_csec) ;

		str.Format (_T (" %s : %s : %s "), gv_minStr, gv_secStr, gv_csecStr) ;
		dc.SetTextAlign (TA_RIGHT) ;
		dc.TextOutW (rect.Width () -20, rect.top +45, str) ;

		// 초계산
		if (--gv_csec < 0) {
			if (!gv_min && !gv_sec) OnSuccess () ;
			gv_csec =99 ;
			gv_sec-- ;
			pTimeDlg ->timeCtrl.StepIt () ;		// 초가 줄때마다 실행
		}
		if (gv_sec < 0 && gv_min) {
			gv_sec =59 ;
			gv_min-- ;
		}

		// 카운트 출력
		str.Format (_T (" CLICK COUNT : %u "), gv_cnt) ;
		dc.TextOutW (rect.Width () -20, rect.top +20, str) ;

		// 점수 출력
		dc.SetTextAlign (TA_CENTER) ;
		str.Format (_T (" Score : %u "), gv_point) ;
		dc.TextOutW (rect.Width () /2, rect.top +25, str) ;
	}
	else {
		while (gv_tempMin-- > 0) gv_tempSec +=60 ;		// 분이 남아 있다면 초로 옮김
		// 시간 감소 및 포인트 증가
		if (gv_tempSec > 0) {					// 초가 0보다 클때까지
			gv_point+=3 ; gv_tempSec-- ;			// 점수는 3증가 초는 1증감
			pTimeDlg ->timeCtrl.StepIt () ;
			dc.SetTextAlign (TA_CENTER) ;
			str.Format (_T (" Score :%u "), gv_point) ;	
			dc.TextOutW (rect.Width () /2 , rect.top +25, str) ;
		}
	}
	dc.SelectObject (myFont) ;
	myFont.DeleteObject () ;
	CView::OnTimer(nIDEvent);
}
示例#15
0
void Ve1Req::HandleResult()
{
  m_errorStr.clear();

  bool success = false;

  const HttpResult& res = GetResult();
  if (res.GetSuccess())
  {
    const std::string& str = res.GetString();
    m_xml = ParseXml(str.c_str());

    // For all responses, Child 0 is current server time

    PXml p = m_xml.getChildNode(0);
    if (SafeStrCmp(p.getName(), "now"))
    {
      m_timestamp = p.getText();

      // TODO More checking
      success = true;
    }
    else
    {
      // TODO Get HTTP code
      m_errorStr = m_name + ": Didn't get time stamp in result: " + str;
    }

    if (m_xml.nChildNode() > 1) 
    {
      p = m_xml.getChildNode(1);
      if (SafeStrCmp(p.getName(), "error"))
      {
        m_errorStr = p.getText();
        success = false;
      }
      m_errorCode = "";
      // Check for <errorcode>
      if (m_xml.nChildNode() > 2)
      {
        p = m_xml.getChildNode(1);
        if (SafeStrCmp(p.getName(), "errorcode"))
        {
          m_errorCode = p.getText();
        }
      }
    }
  }
  else
  {
    //m_errorStr = res.GetErrorString();
    m_errorStr = "I don't seem to be able to go online. Is your internet connection working?";
  }

  if (success)
  {
    OnSuccess();
  }
  else
  {
    OnFailure();
  }
}