bool CWeaponMagazinedWGrenade::Action(s32 cmd, u32 flags)
{
if(m_bGrenadeMode && cmd==kWPN_FIRE)
{
if(IsPending())
return false;
if(flags&CMD_START)
{
if(iAmmoElapsed)
LaunchGrenade ();
else
Reload ();
if(GetState() == eIdle)
OnEmptyClick ();
}
return true;
}
if(inherited::Action(cmd, flags))
return true;
switch(cmd)
{
case kWPN_FUNC:
{
if(flags&CMD_START && !IsPending())
SwitchState(eSwitch);
return true;
}
}
return false;
}
BOOL CHttpRequest::Execute(BOOL bBackground)
{
if ( IsPending() ) return FALSE;
Cancel();
ASSERT( m_sURL.GetLength() > 0 );
ASSERT( m_pPost == NULL );
m_bCancel = FALSE;
m_nStatusCode = 0;
m_pResponseHeaders.RemoveAll();
if ( m_pResponse != NULL ) delete m_pResponse;
m_pResponse = NULL;
if ( bBackground )
{
m_hThread = AfxBeginThread( (AFX_THREADPROC)ThreadStart, this, THREAD_PRIORITY_NORMAL, 0, 0, NULL )->m_hThread;
return TRUE;
}
else
{
Run();
ASSERT( ! IsPending() );
return ( m_nStatusCode >= 200 && m_nStatusCode < 300 );
}
}
// 非同期通信を開始する
// すでに開始しているときは失敗するが、name==NULLのときは開いているソケットに送信データを追加する
bool CAsyncSocket::Send(HWND hwnd, UINT msg, const char *name, unsigned short port, const char *buf, int len, bool bKeepSession)
{
if (len < 0) {
len = lstrlenA(buf);
}
if (len > 0) {
// 前のデータを送信済みのときだけ送信データを追加できる
if (IsPending() && !name && bKeepSession_ && sendBuf_.empty()) {
sendBuf_.assign(&buf[0], &buf[len]);
bKeepSession_ = bKeepSession;
PostMessage(hwnd_, msg_, (WPARAM)soc_, WSAMAKESELECTREPLY(FD_WRITE, 0));
return true;
} else if (!IsPending() && name) {
sendBuf_.assign(&buf[0], &buf[len]);
hwnd_ = hwnd;
msg_ = msg;
delete [] name_;
name_ = new char[lstrlenA(name) + 1];
lstrcpyA(name_, name);
port_ = port;
bKeepSession_ = bKeepSession;
// キューにたまっているかもしれないメッセージを流すため待機
bReady_ = true;
PostMessage(hwnd, msg, 0, 0);
return true;
}
}
return false;
}
NS_IMETHODIMP
nsNDNChannel::IsPending(bool *result) {
// NS_NOTREACHED("nsNDNChannel::IsPending");
// return NS_ERROR_NOT_IMPLEMENTED;
*result = IsPending();
return NS_OK;
}
HRESULT CLR_RT_HeapBlock_I2CXAction::PrepareXAction( I2C_USER_CONFIGURATION& config, size_t numXActions )
{
NATIVE_PROFILE_CLR_I2C();
TINYCLR_HEADER();
_ASSERTE(numXActions > 0);
if(IsPending())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
if(m_HalXAction == NULL || m_HalXActionUnits == NULL)
{
TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE);
}
I2C_InitializeTransaction(
m_HalXAction,
config,
m_HalXActionUnits,
numXActions
);
TINYCLR_NOCLEANUP();
}
void EventHandler::Get(Event &ev)
{
// Sleep until there are events available
while(!m_pending)
{
Timer tmp;
IsPending();
if (!m_pending)
tmp.WaitMs(1);
}
// Return first queued event if applicable
Event *ep = (Event *)m_events.first();
if(ep)
{
ev = *ep;
m_events.unlink(ep);
delete ep;
m_pending = m_events.first() != NULL;
return;
}
// Return an event from the platform-specific system
SysEvent(ev);
}
HRESULT CLR_RT_HeapBlock_I2CXAction::PrepareXActionUnit( CLR_UINT8* src, size_t length, size_t unit, bool fRead )
{
NATIVE_PROFILE_CLR_I2C();
TINYCLR_HEADER();
_ASSERTE(src != NULL);
_ASSERTE(length > 0);
if(IsPending())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
if(m_HalXActionUnits == NULL || m_dataBuffers == NULL)
{
TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE);
}
if(unit > m_xActionUnits-1)
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER);
}
m_dataBuffers[ unit ] = (I2C_WORD*)CLR_RT_Memory::Allocate_And_Erase( length * sizeof(I2C_WORD) ); CHECK_ALLOCATION(m_dataBuffers[ unit ]);
I2C_InitializeTransactionUnit(
m_HalXActionUnits[ unit ],
src,
m_dataBuffers[ unit ],
length,
fRead ? TRUE : FALSE
);
TINYCLR_NOCLEANUP();
}
bool CWeapon::SwitchAmmoType( u32 flags )
{
if ( IsPending() || OnClient() )
return false;
if ( !(flags & CMD_START) )
return false;
u8 l_newType = m_ammoType;
bool b1, b2;
do
{
l_newType = u8( (u32(l_newType+1)) % m_ammoTypes.size() );
b1 = (l_newType != m_ammoType);
b2 = unlimited_ammo() ? false : ( !m_pInventory->GetAny( m_ammoTypes[l_newType].c_str() ) );
} while( b1 && b2 );
if ( l_newType != m_ammoType )
{
m_set_next_ammoType_on_reload = l_newType;
if ( OnServer() )
{
Reload();
}
}
return true;
}
bool CWeaponMagazined::Action(s32 cmd, u32 flags)
{
if(inherited::Action(cmd, flags)) return true;
//если оружие чем-то занято, то ничего не делать
if(IsPending()) return false;
switch(cmd)
{
case kWPN_RELOAD:
{
if(flags&CMD_START)
if(iAmmoElapsed < iMagazineSize || IsMisfire())
Reload();
}
return true;
case kWPN_FIREMODE_PREV:
{
if(flags&CMD_START)
{
OnPrevFireMode();
return true;
};
}break;
case kWPN_FIREMODE_NEXT:
{
if(flags&CMD_START)
{
OnNextFireMode();
return true;
};
}break;
}
return false;
}
// ------------------------------------------------
// SetupForCallback
// ------------------------------------------------
//
void CMdSNotifier::TEntry::SetupForCallback(
RMessage2 aMessage, TInt aRemoteSizeMsgSlot )
{
__ASSERT_DEBUG( !IsPending(), MMdCCommon::Panic( KErrCorrupt ) );
iMessage = aMessage;
iRemoteSizeMsgSlot = aRemoteSizeMsgSlot;
}
void CMailBox::WaitForCall()
{
std::unique_lock<std::mutex> callLock(m_callMutex);
while(!IsPending())
{
m_waitCondition.wait(callLock);
}
}
BOOL CHttpRequest::SetURL(LPCTSTR pszURL)
{
CSingleLock pLock( &m_pSection );
if ( IsPending() ) return FALSE;
if ( pszURL == NULL || _tcsncmp( pszURL, _T("http"), 4 ) ) return FALSE;
m_sURL = pszURL;
return TRUE;
}
IDBRequestReadyState
IDBRequest::ReadyState() const
{
AssertIsOnOwningThread();
return IsPending() ?
IDBRequestReadyState::Pending :
IDBRequestReadyState::Done;
}
NS_IMETHODIMP
nsFtpChannel::ResumeAt(PRUint64 aStartPos, const nsACString& aEntityID)
{
NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS);
mEntityID = aEntityID;
mStartPos = aStartPos;
mResumeRequested = (mStartPos || !mEntityID.IsEmpty());
return NS_OK;
}
void CHttpRequest::AddHeader(LPCTSTR pszKey, LPCTSTR pszValue)
{
CSingleLock pLock( &m_pSection );
if ( IsPending() ) return;
m_sRequestHeaders += pszKey;
m_sRequestHeaders += _T(": ");
m_sRequestHeaders += pszValue;
m_sRequestHeaders += _T("\r\n");
}
// 送受信停止を要求する
// 呼び出し後ProcessRecv()が負値を返すと完了(ソケットも閉じられる)
bool CAsyncSocket::Shutdown()
{
if (IsPending() && !bShutdown_) {
if (soc_ != INVALID_SOCKET) {
shutdown(soc_, SD_BOTH);
}
bShutdown_ = true;
}
return bShutdown_;
}
void CWeaponKnife::switch2_Attacking (u32 state)
{
if(IsPending()) return;
if(state==eFire)
PlayHUDMotion("anm_attack", FALSE, this, state);
else //eFire2
PlayHUDMotion("anm_attack2", FALSE, this, state);
SetPending (TRUE);
}
CString CHttpRequest::GetResponseString(UINT nCodePage)
{
CSingleLock pLock( &m_pSection );
CString str;
if ( ! IsPending() && m_pResponse != NULL )
{
str = m_pResponse->ReadString( m_pResponse->m_nLength, nCodePage );
}
return str;
}
void
AbortablePromise::Abort()
{
if (IsPending()) {
return;
}
MaybeReject(NS_ERROR_ABORT);
nsCOMPtr<nsIRunnable> runnable =
NS_NewRunnableMethod(this, &AbortablePromise::DoAbort);
Promise::DispatchToMicroTask(runnable);
}
NS_IMETHODIMP
nsFtpChannel::SetUploadStream(nsIInputStream *stream,
const nsACString &contentType,
PRInt32 contentLength)
{
NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS);
mUploadStream = stream;
// NOTE: contentLength is intentionally ignored here.
return NS_OK;
}
//переключение режимов стрельбы одиночными и очередями
bool CWeaponMagazined::SwitchMode()
{
if (eIdle != GetState() || IsPending()) return false;
if (SingleShotMode())
m_iQueueSize = WEAPON_ININITE_QUEUE;
else
m_iQueueSize = 1;
PlaySound(sndEmptyClick, get_LastFP());
return true;
}
NS_IMETHODIMP
IDBRequest::GetReadyState(nsAString& aReadyState)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (IsPending()) {
aReadyState.AssignLiteral("pending");
}
else {
aReadyState.AssignLiteral("done");
}
return NS_OK;
}
void CHttpRequest::SetPostData(LPCVOID pBody, DWORD nBody)
{
CSingleLock pLock( &m_pSection );
if ( IsPending() ) return;
if ( m_pPost != NULL ) delete m_pPost;
m_pPost = NULL;
if ( pBody != NULL && nBody > 0 )
{
m_pPost = new CBuffer();
m_pPost->Add( pBody, nBody );
}
}
CString CHttpRequest::GetHeader(LPCTSTR pszName)
{
CSingleLock pLock( &m_pSection );
CString strIn, strOut;
if ( IsPending() ) return strOut;
strIn = pszName;
CharLower( strIn.GetBuffer() );
strIn.ReleaseBuffer();
m_pResponseHeaders.Lookup( strIn, strOut );
return strOut;
}
HRESULT CLR_RT_HeapBlock_I2CXAction::Enqueue()
{
NATIVE_PROFILE_CLR_I2C();
TINYCLR_HEADER();
if(!m_HalXAction || IsPending())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
if(!::I2C_Enqueue( m_HalXAction ))
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
TINYCLR_NOCLEANUP();
}
void CMailBox::ReceiveCall()
{
MESSAGE message;
{
std::lock_guard<std::mutex> waitLock(m_callMutex);
if(!IsPending()) return;
message = std::move(m_calls.front());
m_calls.pop_front();
}
message.function();
if(message.sync)
{
std::lock_guard<std::mutex> waitLock(m_callMutex);
m_callDone = true;
m_callFinished.notify_all();
}
}
BOOL CHttpRequest::InflateResponse()
{
CSingleLock pLock( &m_pSection, TRUE );
if ( IsPending() || m_pResponse == NULL ) return FALSE;
CString strEncoding = GetHeader( _T("Content-Encoding") );
if ( strEncoding.CompareNoCase( _T("deflate") ) == 0 )
{
return m_pResponse->Inflate();
}
if ( strEncoding.CompareNoCase( _T("gzip") ) == 0 )
{
return m_pResponse->Ungzip();
}
return TRUE;
}
HRESULT CLR_RT_HeapBlock_I2CXAction::AllocateXAction( CLR_UINT32 numXActionUnits )
{
NATIVE_PROFILE_CLR_I2C();
TINYCLR_HEADER();
CLR_UINT32 index;
if(IsPending())
{
TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION);
}
m_xActionUnits = numXActionUnits;
// allocate memory for the transaction
m_HalXAction = (I2C_HAL_XACTION*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION) ); CHECK_ALLOCATION(m_HalXAction);
((HAL_CONTINUATION*)m_HalXAction)->Initialize();
::I2C_XAction_SetState( m_HalXAction, I2C_HAL_XACTION::c_Status_Idle );
// initialize pointers to data buffers
m_dataBuffers = (I2C_WORD**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_WORD*) * numXActionUnits ); CHECK_ALLOCATION(m_dataBuffers);
// allocate memory for the transaction units
m_HalXActionUnits = (I2C_HAL_XACTION_UNIT**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT*) * numXActionUnits ); CHECK_ALLOCATION(m_HalXActionUnits);
for(index = 0; index < numXActionUnits; ++index)
{
m_HalXActionUnits[ index ] = (I2C_HAL_XACTION_UNIT*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT) ); CHECK_ALLOCATION(m_HalXActionUnits[ index ]);
}
TINYCLR_CLEANUP();
if(FAILED(hr))
{
ReleaseBuffers();
}
TINYCLR_CLEANUP_END();
}
nsresult
ProcessUpdates(nsIFile *greDir, nsIFile *appDir, nsIFile *updRootDir,
int argc, char **argv, const char *&appVersion)
{
nsresult rv;
nsCOMPtr<nsIFile> updatesDir;
rv = updRootDir->Clone(getter_AddRefs(updatesDir));
if (NS_FAILED(rv))
return rv;
rv = updatesDir->AppendNative(NS_LITERAL_CSTRING("updates"));
if (NS_FAILED(rv))
return rv;
rv = updatesDir->AppendNative(NS_LITERAL_CSTRING("0"));
if (NS_FAILED(rv))
return rv;
PRBool exists;
rv = updatesDir->Exists(&exists);
if (NS_FAILED(rv) || !exists)
return rv;
nsCOMPtr<nsILocalFile> statusFile;
if (GetStatusFile(updatesDir, statusFile) && IsPending(statusFile)) {
nsCOMPtr<nsILocalFile> versionFile;
// Remove the update if the update application version file doesn't exist
// or if the update's application version is less than the current
// application version.
if (!GetVersionFile(updatesDir, versionFile) ||
IsOlderVersion(versionFile, appVersion)) {
updatesDir->Remove(PR_TRUE);
} else {
ApplyUpdate(greDir, updatesDir, statusFile, appDir, argc, argv);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsFileChannel::SetUploadStream(nsIInputStream *stream,
const nsACString &contentType,
PRInt32 contentLength)
{
NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS);
if ((mUploadStream = stream)) {
mUploadLength = contentLength;
if (mUploadLength < 0) {
// Make sure we know how much data we are uploading.
PRUint32 avail;
nsresult rv = mUploadStream->Available(&avail);
if (NS_FAILED(rv))
return rv;
mUploadLength = avail;
}
} else {
mUploadLength = -1;
}
return NS_OK;
}
