BOOL
CNdasDevice::Enable(BOOL bEnable)
{
ximeta::CAutoLock autolock(this);
if (bEnable)
{
//
// To enable this device
//
if (NDAS_DEVICE_STATUS_DISABLED != m_status)
{
return TRUE;
}
//
// DISABLED -> DISCONNECTED
//
ChangeStatus(NDAS_DEVICE_STATUS_DISCONNECTED);
}
else
{
//
// To disable this device
//
if (NDAS_DEVICE_STATUS_DISABLED == m_status)
{
return TRUE;
}
//
// You cannot disable this device when a unit device is mounted
//
if (IsAnyUnitDevicesMounted())
{
::SetLastError(NDASHLPSVC_ERROR_CANNOT_DISABLE_MOUNTED_DEVICE);
return FALSE;
}
//
// DISCONNECTED/CONNECTED -> DISABLED
//
ChangeStatus(NDAS_DEVICE_STATUS_DISABLED);
}
BOOL fSuccess = _NdasSystemCfg.SetValueEx(
m_szCfgContainer,
TEXT("Enabled"),
bEnable);
if (!fSuccess)
{
DBGPRT_WARN_EX(
_FT("%s: Writing device enable status to the registry failed at %s:"),
ToString(), m_szCfgContainer);
}
return TRUE;
}
BOOL
CNdasDevice::Enable(BOOL bEnable)
{
ximeta::CAutoLock autolock(this);
if (bEnable)
{
//
// To enable this device
//
if (NDAS_DEVICE_STATUS_DISABLED != m_status)
{
return TRUE;
}
//
// DISABLED -> DISCONNECTED
//
ChangeStatus(NDAS_DEVICE_STATUS_DISCONNECTED);
}
else
{
//
// To disable this device
//
if (NDAS_DEVICE_STATUS_DISABLED == m_status)
{
return TRUE;
}
//
// You cannot disable this device when a unit device is mounted
//
if (IsAnyUnitDevicesMounted())
{
::SetLastError(NDASHLPSVC_ERROR_CANNOT_DISABLE_MOUNTED_DEVICE);
return FALSE;
}
//
// DISCONNECTED/CONNECTED -> DISABLED
//
ChangeStatus(NDAS_DEVICE_STATUS_DISABLED);
}
(VOID) SetConfigValue(_T("Enabled"), bEnable);
//
// Clear Device Error
//
SetLastDeviceError(NDAS_DEVICE_ERROR_NONE);
return TRUE;
}
void CSmsLockEngine::Start()
{
ChangeStatus(EReadSMS);
//ChangeStatus(EDeleteSMS);
// Close the socket as it may already be open.
iSocketServer.Close();
iSocket.Close();
User::LeaveIfError(iSocketServer.Connect());
// Open a socket
User::LeaveIfError(iSocket.Open(iSocketServer, KSMSAddrFamily, KSockDatagram, KSMSDatagramProtocol));
// Set the pattern to search for in incoming SMS messages. Messages which do not have our
// signature will be consumed by the Messaging Application.
TSmsAddr smsAddr;
smsAddr.SetSmsAddrFamily(ESmsAddrMatchText);
smsAddr.SetTextMatch(KGdpSmsHeaderTag);
User::LeaveIfError(iSocket.Bind(smsAddr));
// Wait for incoming messages
iOctlResult()= KSockSelectRead;
iSocket.Ioctl(KIOctlSelect, iStatus, &(iOctlResult), KSOLSocket);
SetActive();
}
// -----------------------------------------------------------------------------
// CTBCPTest::SetLocalPort
// -----------------------------------------------------------------------------
//
void CTBCPTest::SetLocalPort(TUint aPort)
{
//iRemoteAddr.SetPort(aPort);
iLocalPort=aPort;
ChangeStatus(EPortSet);
}
void CTBCPTest::TestDataReceived(HBufC8* data)
{
if(iData)
iData=0;
iData=data;
ChangeStatus(EDataReceived);
}
BOOL
CNdasDevice::UpdateDeviceInfo()
{
ximeta::CAutoLock autolock(this);
if (NDAS_DEVICE_STATUS_CONNECTED != m_status) {
return FALSE;
}
BOOL fSuccess = GetDeviceInfo(
m_localLpxAddress,
m_remoteLpxAddress,
GetHWType(),
GetHWVersion());
if (!fSuccess)
{
BOOL fDisconnectable = DestroyAllUnitDevices();
if (fDisconnectable)
{
DBGPRT_INFO(_FT("%s: Changing to DISCONNECTED.\n"), ToString());
ChangeStatus(NDAS_DEVICE_STATUS_DISCONNECTED);
}
else
{
DBGPRT_INFO(_T("%s: Some unit devices are mounted!\n"), ToString());
}
return FALSE;
}
return TRUE;
}
// -----------------------------------------------------------------------------
// CTBCPTest::SendToNetL
// -----------------------------------------------------------------------------
//
void CTBCPTest::SendToNetL(HBufC8* aData)
{
if(iData)
iData=0;
iData=aData;
ChangeStatus(EDataReceived);
}
// -----------------------------------------------------------------------------
// CTBCPTest::SetAddress
// -----------------------------------------------------------------------------
//
void CTBCPTest::SetAddressL(const TDesC& aAddr, TUint aPort)
{
iRemotePort=aPort;
iRemoteAddr=aAddr;
ChangeStatus(ERemoteAddrSet);
}
XZProcessExecute::XZProcessExecute(void *mwindow)
{
XZOUTPUT
this->setTerminationEnabled(true);
stop_flag = 0;
xzconfig.Log(LOG_INFO,"Create instance of XZProcessExecute");
cssh = new XZSSh(this);
this->lisExecute = 0;
this->lisHostInfo = 0;
connect(this,SIGNAL(ChangeStatus(QString)),(MainWindow*)mwindow,SLOT(setStatusBarTip(QString)));
}
void AWalkerAIController::OnPawnTookDamage(
AActor *DamagedActor,
float Damage,
const UDamageType *DamageType,
AController *InstigatedBy,
AActor *DamageCauser)
{
LOG_AI_WALKER(Warning, "has been run over");
constexpr bool bItWasRunOver = true;
TryPauseMovement(bItWasRunOver);
ChangeStatus(EWalkerStatus::RunOver);
}
void CSprocketsEngine::Disconnect()
{
DBG("Disconnect() this:%p", (void*)this);
if (IsActive()) {
Cancel();
}
if(iToNav2) {
iToNav2->disconnect();
}
ChangeStatus(ENotConnected);
DBG("Disconnect done");
}
// cTimerCallback virtual functions
void cTest::TimerEvent()
{
cLocker<cHandler> al( &m_handler );
SaHpiDimiTestRunStatusT status;
if ( m_next.err == SAHPI_DIMITEST_STATUSERR_NOERR ) {
status = SAHPI_DIMITEST_STATUS_FINISHED_NO_ERRORS;
} else {
status = SAHPI_DIMITEST_STATUS_FINISHED_ERRORS;
}
ChangeStatus( status );
}
void AWalkerAIController::OnMoveCompleted(
const FAIRequestID RequestID,
const FPathFollowingResult &Result)
{
Super::OnMoveCompleted(RequestID, Result);
#ifdef CARLA_AI_WALKERS_EXTRA_LOG
UE_LOG(LogCarla, Log, TEXT("Walker %s completed move at (%s)"),
*GetPawn()->GetName(),
*GetPawn()->GetActorLocation().ToString())
;
#endif // CARLA_AI_WALKERS_EXTRA_LOG
ChangeStatus(EWalkerStatus::MoveCompleted);
}
//
// status check event handler
// to reconcile the status
//
// to be connected status, broadcast packet
// should be received within MAX_ALLOWED_HEARTBEAT_INTERVAL
//
// returns TRUE to detach from the monitor
// FALSE otherwise.
//
BOOL
CNdasDevice::OnStatusCheck()
{
ximeta::CAutoLock autolock(this);
//
// Only when the device is connected!
//
if (NDAS_DEVICE_STATUS_CONNECTED != m_status) {
// _ASSERTE(FALSE && "OnStatusCheck should be called when connected!");
DBGPRT_WARN(_FT("OnStatusCheck is called on connected. Detaching.\n"));
// Detach from the monitor
return TRUE;
}
DWORD dwCurrentTick = ::GetTickCount();
DWORD dwElapsed = dwCurrentTick - m_dwLastHeartbeatTick;
if (dwElapsed > MAX_ALLOWED_HEARTBEAT_INTERVAL) {
//
// When just a single unit device is mounted,
// status will not be changed to DISCONNECTED!
//
if (IsAnyUnitDevicesMounted()) {
return FALSE;
}
//
// Do not disconnect the device when the debugger is attached
//
if (!NdasServiceConfig::Get(nscDisconnectOnDebug) &&
::IsDebuggerPresent())
{
return FALSE;
}
BOOL fSuccess = DestroyAllUnitDevices();
if (!fSuccess) {
return FALSE;
}
ChangeStatus(NDAS_DEVICE_STATUS_DISCONNECTED);
return TRUE;
}
return FALSE;
}
void CMapEdit::KeyDown()
{
switch(m_nCurrentStatus)
{
case MapEdit_Status_Free:
{
//to select status
ChangeStatus(MapEdit_Status_Select);
}
break;
case MapEdit_Status_Select:
{
//
ChangeStatus(MapEdit_Status_Selected);
}
break;
case MapEdit_Status_Selected:
{
ChangeStatus(MapEdit_Status_Free);
}
break;
}
}
SaErrorT cTest::Cancel()
{
if ( m_status != SAHPI_DIMITEST_STATUS_RUNNING ) {
return SA_ERR_HPI_INVALID_STATE;
}
if ( ( m_info.TestCapabilities & SAHPI_DIMITEST_CAPABILITY_TESTCANCEL ) == 0 ) {
return SA_ERR_HPI_INVALID_REQUEST;
}
m_handler.CancelTimer( this );
ChangeStatus( SAHPI_DIMITEST_STATUS_CANCELED );
return SA_OK;
}
void CSprocketsEngine::ConnectL()
{
DBG("ConnectL()");
// Initiate connection process
DBG("iToNav2: %p iEngineStatus %c= Enotconnected",
iToNav2, iEngineStatus == ENotConnected ? '=' : '!');
if(iToNav2 && iEngineStatus == ENotConnected){
iToNav2->connect();
DBG("Called Nav2::Channel->connect()");
ChangeStatus(EConnected);
iToNav2->armReader(&iStatus);
iConsole->ConnectedL();
SetActive();
}
}
void AWalkerAIController::TryPauseMovement(const bool bItWasRunOver)
{
if ((Status != EWalkerStatus::Paused) && (Status != EWalkerStatus::RunOver)) {
auto MoveRequestID = GetCurrentMoveRequestID();
if (MoveRequestID == FAIRequestID()) { // equals invalid request.
LOG_AI_WALKER(Error, "has invalid move ID");
} else {
if (!PauseMove(MoveRequestID)) {
LOG_AI_WALKER(Error, "is unable to pause movement");
} else {
LOG_AI_WALKER(Log, "paused");
ChangeStatus(bItWasRunOver ? EWalkerStatus::RunOver : EWalkerStatus::Paused);
}
}
}
}
void AWalkerAIController::TryResumeMovement()
{
if (Status != EWalkerStatus::Moving) {
auto MoveRequestID = GetCurrentMoveRequestID();
if (MoveRequestID == FAIRequestID()) { // equals invalid request.
LOG_AI_WALKER(Error, "has invalid move ID");
} else {
if (!ResumeMove(MoveRequestID)) {
LOG_AI_WALKER(Error, "is unable to resume movement");
} else {
LOG_AI_WALKER(Log, "resuming movement");
ChangeStatus(EWalkerStatus::Moving);
}
}
}
}
FPathFollowingRequestResult AWalkerAIController::MoveTo(
const FAIMoveRequest& MoveRequest,
FNavPathSharedPtr* OutPath)
{
#ifdef CARLA_AI_WALKERS_EXTRA_LOG
UE_LOG(LogCarla, Log, TEXT("Walker %s requested move from (%s) to (%s)"),
*GetPawn()->GetName(),
*GetPawn()->GetActorLocation().ToString(),
*MoveRequest.GetGoalLocation().ToString())
;
#endif // CARLA_AI_WALKERS_EXTRA_LOG
ChangeStatus(EWalkerStatus::Moving);
return Super::MoveTo(MoveRequest, OutPath);
}
void GameEngine::setMainTank(Tank *tank)
{
MainWindow *mainwindow = reinterpret_cast<MainWindow *>(parent());
camera->setCentralizeObject(tank);
connect(mainwindow, SIGNAL(MoveTankAction(int)), tank, SLOT(MoveVehicle(int)));
connect(mainwindow, SIGNAL(TankFire()), tank, SLOT(Fire()));
connect(tank, SIGNAL(sigFireValue(int)), mainwindow, SLOT(setFireProgress(int)));
connect(tank, SIGNAL(sigLifeValue(int)), mainwindow, SLOT(setLifeProgress(int)));
connect(camera, SIGNAL(Click()), tank, SLOT(Fire()));
camera->setCentralizeObject(tank);
tank->setFireValue(100);
tank->setLifeValue(100);
connect(tank, SIGNAL(ChangeStatus()), protocol, SLOT(SendMovement()));
connect(tank, SIGNAL(ChangeStatus(bool)), protocol, SLOT(SendMovement(bool)));
my_tank = tank;
tank->setLifeValue(100);
}
SaErrorT cTest::Start( SaHpiUint8T nparams,
const SaHpiDimiTestVariableParamsT * params )
{
SaHpiDimiReadyT ready;
SaErrorT rv = GetReadiness( ready );
if ( rv != SA_OK ) {
return rv;
}
if ( ready != SAHPI_DIMI_READY ) {
return SA_ERR_HPI_INVALID_STATE;
}
bool rc= CheckParams( nparams, params );
if ( !rc ) {
return SA_ERR_HPI_INVALID_DATA;
}
ChangeStatus( SAHPI_DIMITEST_STATUS_RUNNING );
m_handler.SetTimer( this, m_next.run_duration );
return SA_OK;
}
void AWalkerAIController::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
TimeInState+=DeltaSeconds;
if (Status != EWalkerStatus::RunOver)
{
switch (GetMoveStatus())
{
default: break;
case EPathFollowingStatus::Idle:
//case EPathFollowingStatus::Waiting: //<-- incomplete path
LOG_AI_WALKER(Warning, "is stuck!");
ChangeStatus(EWalkerStatus::Stuck);
break;
case EPathFollowingStatus::Paused:
if(TimeInState>WALKER_MAX_TIME_PAUSED){
LOG_AI_WALKER(Log, "is paused, trying resume movement");
TryResumeMovement();
}
break;
};
}
}
int PSPSaveDialog::Update(int animSpeed)
{
if (GetStatus() != SCE_UTILITY_STATUS_RUNNING)
return SCE_ERROR_UTILITY_INVALID_STATUS;
if (!param.GetPspParam()) {
ChangeStatusShutdown(SAVEDATA_SHUTDOWN_DELAY_US);
return 0;
}
if (pendingStatus != SCE_UTILITY_STATUS_RUNNING) {
// We're actually done, we're just waiting to tell the game that.
return 0;
}
// The struct may have been updated by the game. This happens in "Where Is My Heart?"
// Check if it has changed, reload it.
// TODO: Cut down on preloading? This rebuilds the list from scratch.
int size = Memory::Read_U32(requestAddr);
if (memcmp(Memory::GetPointer(requestAddr), &originalRequest, size) != 0) {
memset(&request, 0, sizeof(request));
Memory::Memcpy(&request, requestAddr, size);
Memory::Memcpy(&originalRequest, requestAddr, size);
lock_guard guard(paramLock);
param.SetPspParam(&request);
}
UpdateButtons();
UpdateFade(animSpeed);
okButtonImg = I_CIRCLE;
cancelButtonImg = I_CROSS;
okButtonFlag = CTRL_CIRCLE;
cancelButtonFlag = CTRL_CROSS;
if (param.GetPspParam()->common.buttonSwap == 1) {
okButtonImg = I_CROSS;
cancelButtonImg = I_CIRCLE;
okButtonFlag = CTRL_CROSS;
cancelButtonFlag = CTRL_CIRCLE;
}
I18NCategory *di = GetI18NCategory("Dialog");
switch (display)
{
case DS_SAVE_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
// Save exist, ask user confirm
if (param.GetFileInfo(currentSelectedSave).size > 0) {
yesnoChoice = 0;
display = DS_SAVE_CONFIRM_OVERWRITE;
} else {
display = DS_SAVE_SAVING;
StartIOThread();
}
}
EndDraw();
break;
case DS_SAVE_CONFIRM:
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Confirm Save", "Do you want to save this data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_SAVE_SAVING;
StartIOThread();
}
EndDraw();
break;
case DS_SAVE_CONFIRM_OVERWRITE:
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Confirm Overwrite","Do you want to overwrite the data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_SAVE)
display = DS_SAVE_LIST_CHOICE;
else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_SAVE_SAVING;
StartIOThread();
}
EndDraw();
break;
case DS_SAVE_SAVING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Saving","Saving\nPlease Wait..."));
DisplayBanner(DB_SAVE);
EndDraw();
break;
case DS_SAVE_FAILED:
JoinIOThread();
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("SavingFailed", "Unable to save data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
// Go back to the list so they can try again.
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_SAVE) {
display = DS_SAVE_LIST_CHOICE;
} else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
}
EndDraw();
break;
case DS_SAVE_DONE:
if (ioThread) {
JoinIOThread();
param.SetPspParam(param.GetPspParam());
}
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Save completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_SAVE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_SUCCESS;
// Set the save to use for autosave and autoload
param.SetSelectedSave(param.GetFileInfo(currentSelectedSave).idx);
StartFade(false);
}
EndDraw();
break;
case DS_LOAD_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_LOAD_LOADING;
StartIOThread();
}
EndDraw();
break;
case DS_LOAD_CONFIRM:
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("ConfirmLoad", "Load this data?"), true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag) || (IsButtonPressed(okButtonFlag) && yesnoChoice == 0)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
display = DS_LOAD_LOADING;
StartIOThread();
}
EndDraw();
break;
case DS_LOAD_LOADING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Loading","Loading\nPlease Wait..."));
DisplayBanner(DB_LOAD);
EndDraw();
break;
case DS_LOAD_FAILED:
JoinIOThread();
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("LoadingFailed", "Unable to load data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
// Go back to the list so they can try again.
if (param.GetPspParam()->mode != SCE_UTILITY_SAVEDATA_TYPE_LOAD) {
display = DS_LOAD_LIST_CHOICE;
} else {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
}
}
EndDraw();
break;
case DS_LOAD_DONE:
JoinIOThread();
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("Load completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
// Allow OK to be pressed as well to confirm the save.
// The PSP only allows cancel, but that's generally not great UX.
// Allowing this here makes it quicker for most users to get into the actual game.
if (IsButtonPressed(cancelButtonFlag) || IsButtonPressed(okButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_SUCCESS;
// Set the save to use for autosave and autoload
param.SetSelectedSave(param.GetFileInfo(currentSelectedSave).idx);
StartFade(false);
}
EndDraw();
break;
case DS_LOAD_NODATA:
StartDraw();
DisplayMessage(di->T("There is no data"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_LOAD);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_SAVEDATA_ERROR_LOAD_NO_DATA;
StartFade(false);
}
EndDraw();
break;
case DS_DELETE_LIST_CHOICE:
StartDraw();
DisplaySaveList();
DisplaySaveDataInfo1();
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_DIALOG_RESULT_CANCEL;
StartFade(false);
} else if (IsButtonPressed(okButtonFlag)) {
yesnoChoice = 0;
display = DS_DELETE_CONFIRM;
}
EndDraw();
break;
case DS_DELETE_CONFIRM:
StartDraw();
DisplaySaveIcon();
DisplaySaveDataInfo2();
DisplayMessage(di->T("DeleteConfirm",
"This save data will be deleted.\nAre you sure you want to continue?"),
true);
DisplayButtons(DS_BUTTON_OK | DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag))
display = DS_DELETE_LIST_CHOICE;
else if (IsButtonPressed(okButtonFlag)) {
if (yesnoChoice == 0)
display = DS_DELETE_LIST_CHOICE;
else {
display = DS_DELETE_DELETING;
StartIOThread();
}
}
EndDraw();
break;
case DS_DELETE_DELETING:
if (ioThreadStatus != SAVEIO_PENDING) {
JoinIOThread();
}
StartDraw();
DisplayMessage(di->T("Deleting","Deleting\nPlease Wait..."));
DisplayBanner(DB_DELETE);
EndDraw();
break;
case DS_DELETE_FAILED:
JoinIOThread();
StartDraw();
DisplayMessage(di->T("DeleteFailed", "Unable to delete data."));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
display = DS_DELETE_LIST_CHOICE;
}
EndDraw();
break;
case DS_DELETE_DONE:
if (ioThread) {
JoinIOThread();
param.SetPspParam(param.GetPspParam());
}
StartDraw();
DisplayMessage(di->T("Delete completed"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
if (param.GetFilenameCount() == 0)
display = DS_DELETE_NODATA;
else
display = DS_DELETE_LIST_CHOICE;
}
EndDraw();
break;
case DS_DELETE_NODATA:
StartDraw();
DisplayMessage(di->T("There is no data"));
DisplayButtons(DS_BUTTON_CANCEL);
DisplayBanner(DB_DELETE);
if (IsButtonPressed(cancelButtonFlag)) {
param.GetPspParam()->common.result = SCE_UTILITY_SAVEDATA_ERROR_DELETE_NO_DATA;
StartFade(false);
}
EndDraw();
break;
case DS_NONE: // For action which display nothing
switch (ioThreadStatus) {
case SAVEIO_NONE:
StartIOThread();
break;
case SAVEIO_PENDING:
case SAVEIO_DONE:
// To make sure there aren't any timing variations, we sync the next frame.
JoinIOThread();
ChangeStatus(SCE_UTILITY_STATUS_FINISHED, 0);
break;
}
break;
default:
ChangeStatus(SCE_UTILITY_STATUS_FINISHED, 0);
break;
}
if (status == SCE_UTILITY_STATUS_FINISHED || pendingStatus == SCE_UTILITY_STATUS_FINISHED)
Memory::Memcpy(requestAddr, &request, request.common.size);
return 0;
}
BOOL
CNdasDevice::OnDiscovered(
const LPX_ADDRESS& localAddress,
const LPX_ADDRESS& remoteAddress,
UCHAR ucType,
UCHAR ucVersion)
{
ximeta::CAutoLock autolock(this);
if (NDAS_DEVICE_STATUS_DISABLED == m_status)
{
return FALSE;
}
//
// If the local address is different, ignore it.
// because we may be receiving from multiple interfaces.
//
// In case of interface change, as we don't update the heartbeat tick
// here, device will be disconnected and re-discovered.
//
// So, it's safe to ignore non-bound local address
//
// However, we can assume the local address is valid
// only if the status is CONNECTED.
//
if (NDAS_DEVICE_STATUS_CONNECTED == m_status)
{
if (!IsEqualLpxAddress(m_localLpxAddress, localAddress))
{
return FALSE;
}
}
//
// Version Checking
//
if (!IsSupportedHardwareVersion(ucType, ucVersion))
{
DBGPRT_ERR(
_FT("Unsupported NDAS device detected - Type %d, Version %d.\n"),
ucType,
ucVersion);
//
// TODO: EVENTLOG unsupported version detected!
//
SetLastDeviceError(NDAS_DEVICE_ERROR_UNSUPPORTED_VERSION);
return FALSE;
}
// Update heartbeat tick
m_dwLastHeartbeatTick = ::GetTickCount();
// Connected status ignores this heartbeat
// We only updates Last Heartbeat Tick
if (NDAS_DEVICE_STATUS_CONNECTED == m_status)
{
//
//BUGBUG!!!
//
// TODO: Dangling case not handled!
//
for (DWORD i = 0; i < MAX_NDAS_UNITDEVICE_COUNT; i++)
{
if(NULL != m_pUnitDevices[i])
{
m_pUnitDevices[i]->SetFault(FALSE);
m_pUnitDevices[i]->m_pLogicalDevice->Recover();
}
}
return FALSE;
}
DWORD maxFailure = ndascfg::sys::MaxHeartbeatFailure::GetValue();
// Now the device is in DISCONNECTED status
// Failure Count to prevent possible locking of the service
// because of the discover failure timeout
static const DWORD MAX_HEARTBEAT_FAILURE_DEFAULT = 10;
static const DWORD MAX_HEARTBEAT_FAILURE_MIN = 1;
static const DWORD MAX_HEARTBEAT_FAILURE_MAX = 0xFFFF;
DWORD dwMaxHeartbeatFailure = MAX_HEARTBEAT_FAILURE_DEFAULT;
BOOL fSuccess = _NdasSystemCfg.GetValueEx(
_T("ndassvc"),
_T("MaxHeartbeatFailure"),
&dwMaxHeartbeatFailure);
if (!fSuccess ||
MAX_HEARTBEAT_FAILURE_MIN < dwMaxHeartbeatFailure ||
dwMaxHeartbeatFailure > MAX_HEARTBEAT_FAILURE_MAX)
{
dwMaxHeartbeatFailure = MAX_HEARTBEAT_FAILURE_DEFAULT;
}
if (m_dwCommFailureCount >= dwMaxHeartbeatFailure)
{
//
// TODO: EVENTLOG NDAS_DEVICE_ERROR_DISCOVER_TOO_MANY_FAILURE
//
SetLastDeviceError(NDAS_DEVICE_ERROR_DISCOVER_TOO_MANY_FAILURE);
return FALSE;
}
DBGPRT_INFO(_FT("Discovered %s at local %s.\n"),
CLpxAddress(remoteAddress).ToString(),
CLpxAddress(localAddress).ToString());
fSuccess = GetDeviceInfo(
localAddress,
remoteAddress,
ucType,
ucVersion);
if (!fSuccess)
{
//
// TODO: EVENTLOG NDAS_DEVICE_ERROR_DISCOVER_FAILED
//
SetLastDeviceError(NDAS_DEVICE_ERROR_DISCOVER_FAILED);
++m_dwCommFailureCount;
return FALSE;
}
SetLastDeviceError(NDAS_DEVICE_ERROR_NONE);
m_dwCommFailureCount = 0;
// Status should be changed to CONNECTED before creating Unit Devices
ChangeStatus(NDAS_DEVICE_STATUS_CONNECTED);
// Not necessary, but just to make sure that there is no instances
fSuccess = DestroyAllUnitDevices();
_ASSERTE(fSuccess);
for (DWORD i = 0; i < MAX_NDAS_UNITDEVICE_COUNT; i++)
{
// we can ignore unit device creation errors here
(VOID) CreateUnitDevice(i);
}
return TRUE;
}
// -----------------------------------------------------------------------------
// CTBCPTest::Stop
// -----------------------------------------------------------------------------
//
void CTBCPTest::Stop()
{
ChangeStatus(ESocketStop);
}
void CTBCPTest::TestErrorNotify(TInt aError)
{
iErr=aError;
ChangeStatus(EErrorNotify);
}
//
// After the adapter parameter is changed, should call this function to active it.
//
BOOL ControlAdapter( DWORD dwStatus, CONST TCHAR* GUIDString) // _T("4D36E972-E325-11CE-BFC1-08002BE10318");
{
BOOL bRet = FALSE;
if ( 0 == dwStatus )
{
return FALSE;
}
//TCHAR* GUIDString = _T("4D36E972-E325-11CE-BFC1-08002BE10318");
GUID guid;
ZeroMemory( &guid, sizeof( GUID ) );
if ( RPC_S_OK != UuidFromString( (unsigned char*)GUIDString, &guid ) )
{
bRet = FALSE;
}
else
{
HDEVINFO hDevInfo = NULL;
hDevInfo = SetupDiGetClassDevs( &guid, REGSTR_KEY_PCIENUM, NULL, DIGCF_PRESENT );
if ( INVALID_HANDLE_VALUE == hDevInfo )
{
bRet = FALSE;
}
else
{
DWORD i = 0;
SP_DEVINFO_DATA DeviceInfoData;
ZeroMemory( &DeviceInfoData, sizeof( SP_DEVINFO_DATA ) );
DeviceInfoData.cbSize = sizeof( SP_DEVINFO_DATA );
for ( i = 0; SetupDiEnumDeviceInfo( hDevInfo, i, &DeviceInfoData ); ++i )
{
// 获得设备的状态
DWORD dwProblem = 0, dwDeviceStatus = 0;
if ( CR_SUCCESS != CM_Get_DevNode_Status( &dwDeviceStatus, &dwProblem, DeviceInfoData.DevInst, 0 ) )
{
continue;
}
// 获取设备注册表项描述
CString strText;
if ( !GetDeviceRegistryProperty( hDevInfo, &DeviceInfoData, SPDRP_CLASS, strText ) )
{
continue;
}
TRACE( _T("\n The %d device instance handle : %d, Class : %s\n"), i, DeviceInfoData.DevInst, strText );
if ( 0 == lstrcmp( strText, _T("Net") ) )
{
TRACE( _T("This is the adapter device that I want.\n") );
//////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
if ( GetDeviceRegistryProperty( hDevInfo, &DeviceInfoData, SPDRP_DEVICEDESC, strText ) )
{
TRACE( _T("SPDRP_DEVICEDESC : %s\n"), strText );
}
#endif
//////////////////////////////////////////////////////////////////////////
if ( ChangeStatus( dwStatus, i, hDevInfo ) )
{
bRet = TRUE;
}
}
}
// 释放 device information set
bRet = SetupDiDestroyDeviceInfoList( hDevInfo );
}
}
return bRet;
}
Ouroboros::Ouroboros(QWidget *parent) :
QMainWindow(parent),
PlayStatus(PLAYSTATUS_STOPPED),
AnimeProgressStyle(this), //assign this as parent so that stylesheet get inherited
ui(new Ui::Ouroboros)
{
ui->setupUi(this);\
setMouseTracking(true);
//setup main window
QString Title = QString(APP_NAME) + " " + QString::number(APP_MAJOR_VERSION) + "." + QString::number(APP_MINOR_VERSION);
if(APP_DEBUG) Title.append(" Debug");
this->setWindowTitle(Title);
//Generate a random seed for other classes
QTime CurrentTime = QTime::currentTime();
qsrand((uint)CurrentTime.msec());
//setup views
SetViewLayouts();
//setup tray icon
SetupTrayIcon();
//Load settings
Settings.Load();
//Load the style
Theme_Manager.LoadThemeList();
Theme_Manager.LoadTheme(Settings.Application.Stylesheet);
this->setStyleSheet(QString(Theme_Manager.GetTheme()));
//Set the ui for the manager
GUI_Manager.SetMainWindow(this);
//Setup Detection
//Only detects on windows currently
#ifdef WIN32
File_Manager.SaveMedia();
//Load Media
File_Manager.LoadMedia();
if(Media_Manager.MediaListLoaded)
{
DetectionTimer.setInterval(RECOGNITION_TIMEDELAY);
connect(&DetectionTimer,SIGNAL(timeout()),&Media_Manager,SLOT(DetectAnime()));
connect(this,SIGNAL(StopDetectionTimer()),&DetectionTimer,SLOT(stop()));
DetectionTimer.start();
}
#endif
//Setup a timer to run the queue every 5 minutes
QTimer *RunTimer = new QTimer(this);
connect(RunTimer,SIGNAL(timeout()),&Queue_Manager,SLOT(Run()));
connect(RunTimer,SIGNAL(timeout()),&Theme_Manager,SLOT(LoadThemeList()));
RunTimer->start(30000);
//Connect signals and slots
connect(RunTimer,SIGNAL(timeout()),&Queue_Manager,SLOT(StartRunning()));
connect(&Api_Manager,SIGNAL(ChangeStatus(QString,int)),this,SLOT(ChangeStatus(QString,int)));
connect(&GUI_Manager,SIGNAL(ShowTrayMessage(QString,QString,int)),this,SLOT(ShowTrayMessage(QString,QString,int)));
connect(&Media_Manager,SIGNAL(ShowTrayMessage(QString,QString,int)),this,SLOT(ShowTrayMessage(QString,QString,int)));
connect(&Theme_Manager,SIGNAL(ThemeChanged(QString)),this,SLOT(setStyleSheet(QString)));
//Load user info
File_Manager.LoadUserInformation();
//Load history
File_Manager.LoadHistory();
//Load local database
File_Manager.LoadAnimeDatabase();
GUI_Manager.PopulateModel();
//Sync anime
if(CurrentUser.isValid())
{
emit ChangeStatus("Syncing ...", 3000);
Queue_Manager.Sync(true);
}
}
// -----------------------------------------------------------------------------
// CTBCPTest::ConnectL
// -----------------------------------------------------------------------------
//
void CTBCPTest::ConnectL(TBool /*aReceiver*/)
{
ChangeStatus(EConnected);
}
