bool Layout::IsEnabled()
{
for (int i = 0; i < m_nWins; i++) {
if(m_sub_wins[i]->IsEnabled()){
if(!IWindow::IsEnabled())
Enable();
return true;
}
}
if(IWindow::IsEnabled())
Disable();
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::GatherConditions( void )
{
BaseClass::GatherConditions();
// Mapmaker may have removed our goal while we're running our schedule
if ( !m_hPoliceGoal )
{
Disable();
return;
}
ClearCondition( COND_POLICE_TARGET_TOO_CLOSE_HARASS );
ClearCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );
CBaseEntity *pTarget = m_hPoliceGoal->GetTarget();
if ( pTarget == NULL )
{
DevMsg( "ai_goal_police with NULL target entity!\n" );
return;
}
// See if we need to knock out our target immediately
if ( ShouldKnockOutTarget( pTarget ) )
{
SetCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );
}
float flDistSqr = ( m_hPoliceGoal->WorldSpaceCenter() - pTarget->WorldSpaceCenter() ).Length2DSqr();
float radius = ( m_hPoliceGoal->GetRadius() * PATROL_RADIUS_RATIO );
float zDiff = fabs( m_hPoliceGoal->WorldSpaceCenter().z - pTarget->WorldSpaceCenter().z );
// If we're too far away, don't bother
if ( flDistSqr < (radius*radius) && zDiff < 32.0f )
{
SetCondition( COND_POLICE_TARGET_TOO_CLOSE_HARASS );
if ( flDistSqr < (m_hPoliceGoal->GetRadius()*m_hPoliceGoal->GetRadius()) )
{
SetCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );
}
}
// If we're supposed to stop chasing (aggression over), return
if ( m_bTargetIsHostile && m_flAggressiveTime < gpGlobals->curtime && IsCurSchedule(SCHED_CHASE_ENEMY) )
{
// Force me to re-evaluate my schedule
GetOuter()->ClearSchedule( "Stopped chasing, aggression over" );
}
}
void FieldTrial::UseOneTimeRandomization()
{
DCHECK_EQ(group_, kNotFinalized);
DCHECK_EQ(kDefaultGroupNumber + 1, next_group_number_);
if(!FieldTrialList::IsOneTimeRandomizationEnabled())
{
NOTREACHED();
Disable();
return;
}
random_ = static_cast<Probability>(
divisor_ * HashClientId(FieldTrialList::client_id(), name_));
}
NS_IMETHODIMP
TaskbarPreview::SetVisible(bool visible) {
if (mVisible == visible) return NS_OK;
mVisible = visible;
// If the nsWindow has already been destroyed but the caller is still trying
// to use it then just pretend that everything succeeded. The caller doesn't
// actually have a way to detect this since it's the same case as when we
// CanMakeTaskbarCalls returns false.
if (!mWnd)
return NS_OK;
return visible ? Enable() : Disable();
}
/* DoAvailable()
* ===================================================================
*/
void
DoAvailable( void )
{
PrevTree = ad_front;
Reset_Tree( ad_inactive );
NoExit( IINSTALL );
Disable( IINSTALL );
NoExit( ICONFIG );
Disable( ICONFIG );
/* Read in the UnUsed fonts, if necessary */
if( !Fonts_Loaded )
{
MF_Save();
Scan_Message( ad_scan, TRUE );
read_fonts( TRUE, FALSE );
Scan_Message( ad_scan, FALSE );
MF_Restore();
}
CheckSelectAll( FALSE );
mover_setup( available_list, available_count,
IBASE, ISLIDER, IUP, IDOWN,
ILINE0, ILINE13, ILINE, 0, INACTIVE_HEIGHT );
HideObj( ILINE );
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
ShowObj( ILINE );
RedrawBase( tree, ILINE );
}
void Bird::HandleUpdate(StringHash eventType, VariantMap &eventData)
{
if (dead_ && GetPosition().y_ < -5.0f) Disable();
float timeStep = eventData[SceneUpdate::P_TIMESTEP].GetFloat();
if (sinceSpeciesSet_ < morphTime_){
Morph();
}
sinceSpeciesSet_ += timeStep;
if (sinceStateChange_ > stateDuration_){
switch (state_) {
case BirdState::Flying: {
SetState(BirdState::Landing);
} break;
case BirdState::Standing: {
SetState(BirdState::Flying);
} break;
default:
break;
}
}
if(!(first_ && state_ == BirdState::Standing)) sinceStateChange_ += timeStep;
switch (state_) {
case BirdState::Flying: {
Fly(timeStep);
} break;
case BirdState::Landing: {
Land(timeStep);
} break;
case BirdState::Standing: {
Stand(timeStep);
} break;
default:
break;
}
//Move bird
rootNode_->Translate(velocity_*timeStep, TS_WORLD);
//Update rotation in accordance with the birds movement.
if (velocity_.Length() > 0.01f){
Quaternion rotation = rootNode_->GetWorldRotation();
Quaternion aimRotation = rotation;
aimRotation.FromLookRotation(velocity_);
rootNode_->SetRotation(rotation.Slerp(aimRotation, 2.0f * timeStep * velocity_.Length()));
}
}
CMemLeakDetector::~CMemLeakDetector()
{
#if defined(AUTO_ENABLE_MEMLEAKDETECTOR)
// report leaks
Disable();
ReportLeaks();
#endif
#if defined(PLATFORM_WINDOWS)
for(std::size_t i = 0; i < m_ModuleInfoVector.size(); ++i)
_free_dbg(m_ModuleInfoVector[i].m_ModuleName, _CRT_BLOCK);
#endif
delete m_Reporter;
}
MythUICheckBox::MythUICheckBox(MythUIType *parent, const QString &name)
: MythUIType(parent, name)
{
m_currentCheckState = MythUIStateType::Off;
m_state = "active";
m_BackgroundState = m_CheckState = NULL;
connect(this, SIGNAL(TakingFocus()), this, SLOT(Select()));
connect(this, SIGNAL(LosingFocus()), this, SLOT(Deselect()));
connect(this, SIGNAL(Enabling()), this, SLOT(Enable()));
connect(this, SIGNAL(Disabling()), this, SLOT(Disable()));
SetCanTakeFocus(true);
}
void CIP2Country::Enable()
{
Disable();
if (m_CountryDataMap.empty()) {
LoadFlags();
}
if (!CPath::FileExists(m_DataBasePath)) {
Update();
return;
}
m_geoip = GeoIP_open(unicode2char(m_DataBasePath), GEOIP_STANDARD);
}
void opengl_texture_state::SetTarget(GLenum tex_target)
{
if (units[active_texture_unit].texture_target != tex_target) {
Disable();
if (units[active_texture_unit].texture_id) {
glBindTexture(units[active_texture_unit].texture_target, 0);
units[active_texture_unit].texture_id = 0;
}
// reset modes, since those were only valid for the previous texture target
default_values(active_texture_unit, tex_target);
units[active_texture_unit].texture_target = tex_target;
}
}
WorldLog::WorldLog()
{
bEnabled = false;
m_file = NULL;
if (Config.MainConfig.GetBoolDefault("LogLevel", "World", false))
{
Log.Notice("WorldLog", "Enabling packetlog output to \"world.log\"");
Enable();
}
else
{
Disable();
}
}
static void
/*FCN*/UpdateDlgControls (
void
){
if ( totalFeatures == 0 ){
Disable ( featGroup );
Enable ( groupDelButton );
} else {
if ( curFeatureInd < nHideFeatures ) Enable ( featHideButton );
else Disable ( featHideButton );
Enable ( featGroup );
Disable ( groupDelButton );
}
if ( totalGroups < 6 ){
Enable ( newButton );
} else {
Disable ( newButton );
}
if ( curGroupInd < nHideGroups ) Enable (groupHideButton);
else Disable ( groupHideButton );
if ( (Int2)Nlm_GetMuskCParamEd(MSM_GROUPS,groupAr[curGroupInd],MSM_STYLE)
== MSM_SPREAD ) SetStatus (groupCompBox,FALSE);
else SetStatus (groupCompBox,TRUE);
}
void AddDelay(TimerBase *TimerBase, struct IORequest *ioreq)
{
DPrintF("Inside AddDelay!\n");
UINT32 ipl;
ipl = Disable();
timer_AddTime(TimerBase, &TimerBase->Elapsed, &((struct TimeRequest*)ioreq)->tr_time);
INTERN_QueueRequest(TimerBase, ioreq);
Enable(ipl);
DPrintF("Delay added!\n");
//CLEAR_BITS(((struct TimeRequest*)ioreq)->tr_node.io_Flags, IOF_QUICK);
((struct TimeRequest*)ioreq)->tr_node.io_Flags &= ~IOF_QUICK;
}
void CCustomZone::OnStateSwitch (EZoneState new_state)
{
if (new_state==eZoneStateDisabled)
Disable();
else
Enable();
if(new_state==eZoneStateAccumulate)
PlayAccumParticles();
if(new_state==eZoneStateAwaking)
PlayAwakingParticles();
m_eZoneState = new_state;
m_iPreviousStateTime = m_iStateTime = 0;
};
bool
RasterTile::CheckTileVisibility(int view_x, int view_y, unsigned view_radius)
{
if (!width || !height) {
Disable();
return false;
}
const unsigned int dx1 = abs(view_x - (int)xstart);
const unsigned int dx2 = abs((int)xend - view_x);
const unsigned int dy1 = abs(view_y - (int)ystart);
const unsigned int dy2 = abs((int)yend - view_y);
distance = std::max(std::min(dx1, dx2), std::min(dy1, dy2));
return distance <= view_radius || IsEnabled();
}
__regargs BOOL PopEvent(EventT *event) {
BOOL present = FALSE;
Disable();
if (used > 0) {
present = TRUE;
*event = queue[head];
head = (head + 1) & (QUEUELEN - 1);
used--;
}
Enable();
return present;
}
void CIP2Country::DownloadFinished(uint32 result)
{
if (result == HTTP_Success) {
Disable();
// download succeeded. Switch over to new database.
wxString newDat = m_DataBasePath + wxT(".download");
// Try to unpack the file, might be an archive
wxWCharBuffer dataBaseName = m_DataBaseName.wc_str();
const wxChar* geoip_files[] = {
dataBaseName,
NULL
};
if (UnpackArchive(CPath(newDat), geoip_files).second == EFT_Error) {
AddLogLineC(_("Download of GeoIP.dat file failed, aborting update."));
return;
}
if (wxFileExists(m_DataBasePath)) {
if (!wxRemoveFile(m_DataBasePath)) {
AddLogLineC(CFormat(_("Failed to remove %s file, aborting update.")) % m_DataBaseName);
return;
}
}
if (!wxRenameFile(newDat, m_DataBasePath)) {
AddLogLineC(CFormat(_("Failed to rename %s file, aborting update.")) % m_DataBaseName);
return;
}
Enable();
if (m_geoip) {
AddLogLineN(CFormat(_("Successfully updated %s")) % m_DataBaseName);
} else {
AddLogLineC(_("Error updating GeoIP.dat"));
}
} else if (result == HTTP_Skipped) {
AddLogLineN(CFormat(_("Skipped download of %s, because requested file is not newer.")) % m_DataBaseName);
} else {
AddLogLineC(CFormat(_("Failed to download %s from %s")) % m_DataBaseName % thePrefs::GetGeoIPUpdateUrl());
// if it failed and there is no database, turn it off
if (!wxFileExists(m_DataBasePath)) {
thePrefs::SetGeoIPEnabled(false);
}
}
}
static BOOL CmdUntrackType(struct IOSana2Req *request,
struct DevBase *base)
{
struct DevUnit *unit;
struct Opener *opener;
ULONG packet_type;
struct TypeTracker *tracker;
struct TypeStats *initial_stats;
unit = (APTR)request->ios2_Req.io_Unit;
packet_type = request->ios2_PacketType;
if(packet_type <= ETH_MTU)
packet_type = ETH_MTU;
/* Get global tracker and initial figures */
tracker = (struct TypeTracker *)
FindTypeStats(unit, &unit->type_trackers, packet_type, base);
opener = request->ios2_BufferManagement;
initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
base);
/* Decrement tracker usage and free unused structures */
if(initial_stats != NULL)
{
if((--tracker->user_count) == 0)
{
Disable();
Remove((APTR)tracker);
Enable();
FreeMem(tracker, sizeof(struct TypeTracker));
}
Remove((APTR)initial_stats);
FreeMem(initial_stats, sizeof(struct TypeStats));
}
else
{
request->ios2_Req.io_Error = S2ERR_BAD_STATE;
request->ios2_WireError = S2WERR_NOT_TRACKED;
}
/* Return */
return TRUE;
}
void SeriesTool::SetSelectedSeries(plot::Series * series)
{
m_series = series;
if (m_series != nullptr)
{
Enable();
m_checkBox_name->SetLabel(m_series->GetSeriesName());
m_checkBox_name->SetValue(m_series->GetRenderer()->GetVisible());
m_slider_line_weight->SetValue(m_series->GetRenderer()->GetLine()->GetThickness());
m_checkBox_line_visible->SetValue(m_series->GetRenderer()->GetLine()->GetVisible());
m_combo_line_colour->SetColorSelection(m_series->GetRenderer()->GetLine()->GetColourIndex());
m_slider_marks_size->SetValue(m_series->GetRenderer()->GetMarker()->GetSize());
m_checkBox_marks_visible->SetValue(m_series->GetRenderer()->GetMarker()->GetVisible());
m_combo_marks_colour->SetColorSelection(m_series->GetRenderer()->GetMarker()->GetFillColourIndex());
m_combo_marks_style->SetMarkStyleSelection((plot::wxMarker *)(m_series->GetRenderer()->GetMarker()));
Refresh();
}
else
{
Disable();
m_checkBox_name->SetLabel("NA");
m_checkBox_name->SetValue(false);
m_slider_line_weight->SetValue(0);
m_checkBox_line_visible->SetValue(false);
m_combo_line_colour->SetColorSelection(0);
m_slider_marks_size->SetValue(1);
m_checkBox_marks_visible->SetValue(false);
m_combo_marks_colour->SetColorSelection(0);
Refresh();
}
}
void Arm::EnablePID(bool enable)
{
if (enable && !isEnabled)
{
Enable();
isEnabled = true;
}
else if(!enable && isEnabled)
{
Disable();
isEnabled = false;
}
else
{
// DO NOTHING
}
}
/******* SerialUnit::Dispose() ***********************************/
OOP_Object *PCSerUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
{
struct HIDDSerialUnitData * data;
EnterFunc(bug("SerialUnit::Dispose()\n"));
data = OOP_INST_DATA(cl, obj);
Disable();
CSD(cl->UserData)->units[data->unitnum] = NULL;
Enable();
/* stop all interrupts */
serial_outp(data, UART_IER, 0);
OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj);
}
static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
{
struct SiS900Unit *unit;
struct Opener *opener;
ULONG packet_type;
struct TypeTracker *tracker;
struct TypeStats *initial_stats;
unit = (APTR)request->ios2_Req.io_Unit;
D(bug("[%s]: S2CmdUntrackType()\n", unit->sis900u_name));
packet_type = request->ios2_PacketType;
/* Get global tracker and initial figures */
tracker = (struct TypeTracker *)
FindTypeStats(LIBBASE, unit, &unit->sis900u_type_trackers, packet_type);
opener = request->ios2_BufferManagement;
initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
/* Decrement tracker usage and free unused structures */
if(initial_stats != NULL)
{
if((--tracker->user_count) == 0)
{
Disable();
Remove((APTR)tracker);
Enable();
FreeMem(tracker, sizeof(struct TypeTracker));
}
Remove((APTR)initial_stats);
FreeMem(initial_stats, sizeof(struct TypeStats));
}
else
{
request->ios2_Req.io_Error = S2ERR_BAD_STATE;
request->ios2_WireError = S2WERR_NOT_TRACKED;
}
/* Return */
return TRUE;
}
void Render(Gwen::Skin::Base* skin)
{
// Sanity.
assert(skin != nullptr);
if (skin == nullptr)
{
return;
}
if (_tooltip == nullptr)
{
return;
}
assert(_tooltip->GetTooltip() != nullptr);
if (_tooltip->GetTooltip() == nullptr)
{
Disable(_tooltip);
return;
}
Renderer::Base* render = skin->GetRender();
assert(render != nullptr);
if (render != nullptr)
{
Point old_offset = render->GetRenderOffset();
Point mouse_position = Input::GetMousePosition();
Rectangle bounds = _tooltip->GetTooltip()->GetBounds();
Rectangle offset = Gwen::Rectangle(mouse_position._x - bounds._width / 2,
mouse_position._y - bounds._height - 10,
bounds._width,
bounds._height);
offset = Utility::ClampRectangleToRectangle(offset, _tooltip->GetCanvas()->GetBounds());
// Calculate the offset on screen bounds.
render->AddRenderOffset(Point(offset._x, offset._y));
render->EndClipping();
skin->DrawTooltip(_tooltip->GetTooltip());
_tooltip->GetTooltip()->DoRender(skin);
render->SetRenderOffset(old_offset);
}
}
void Ship::SetDockedWith(SpaceStation *s, int port)
{
if (s) {
m_dockedWith = s;
m_dockedWithPort = port;
m_wheelState = 1.0f;
m_flightState = DOCKED;
SetVelocity(vector3d(0,0,0));
SetAngVelocity(vector3d(0,0,0));
Disable();
ClearThrusterState();
m_dockedWith->SetDocked(this, port);
onDock.emit();
} else {
Undock();
}
}
void LaserFence::Toggle ()
{
switch( m_mode )
{
case ModeDisabled:
case ModeDisabling:
Enable();
break;
case ModeEnabled:
case ModeEnabling:
Disable();
break;
}
m_nextToggled = false;
}
void ShooterArm::TestPID(float setpoint,float p, float stage1I, float stage2I, float stage1D,float stage2D, float stage1Tol, float stage2Tol)
{
//_maxFeedForward = 0.0;
//float newFeedForward = 0.0;//_maxFeedForward * cos(GetCurrentRadians());
//GetPIDController()->SetPID(p,i,d, newFeedForward);
Disable();
_bothStage_P = p;
_stage_1_I = stage1I;
_stage_2_I = stage2I;
_stage_1_D = stage1D;
_stage_2_D = stage2D;
_stage_1_tolerance = stage1Tol;
_stage_2_tolerance = stage2Tol;
GetPIDController()->SetPID(_bothStage_P,_stage_1_I,_stage_1_D);
SetAngle(setpoint);
}
BOOL CWinWow64FsRedirectionGuard::Enable()
{
if (!m_bChanged)
{
BOOL br = Disable();
if (br)
return br;
}
BOOL br = CWinModule_kernel32::Wow64EnableWow64FsRedirection(TRUE);
if (!br)
return FALSE;
m_bChanged = TRUE;
return TRUE;
}
void Metrobot::DisabledPeriodic(){
UpdateOI();
if( joystick->GetButtonDown( 4 ) ){
autonScript = NO_SCRIPT;
}
if( joystick->GetButtonDown( 3 ) ){
autonScript = SCRIPT_1;
}
if( joystick->GetButtonDown( 5 ) ){
autonScript = SCRIPT_2;
}
Disable();
GetWatchdog().Feed();
}
CKilobotCommunicationEntity::CKilobotCommunicationEntity(CComposableEntity* pc_parent,
const std::string& str_id,
size_t un_msg_size,
Real f_range,
SAnchor& s_anchor,
CEmbodiedEntity& c_entity_body) :
CPositionalEntity(pc_parent,
str_id),
m_psAnchor(&s_anchor),
m_fTxRange(f_range),
m_pcEntityBody(&c_entity_body),
m_eTxStatus(TX_NONE) {
Disable();
SetInitPosition(s_anchor.Position);
SetPosition(GetInitPosition());
SetInitOrientation(s_anchor.Orientation);
SetOrientation(GetInitOrientation());
}
FSceneViewExtension(const TArray<FString>& InRenderPasses, bool bInCaptureFramesInHDR, int32 InHDRCompressionQuality, int32 InCaptureGamut, UMaterialInterface* InPostProcessingMaterial)
: RenderPasses(InRenderPasses)
, bNeedsCapture(true)
, bCaptureFramesInHDR(bInCaptureFramesInHDR)
, HDRCompressionQuality(InHDRCompressionQuality)
, CaptureGamut(InCaptureGamut)
, PostProcessingMaterial(InPostProcessingMaterial)
, RestoreDumpHDR(0)
, RestoreHDRCompressionQuality(0)
, RestoreDumpGamut(HCGM_Rec709)
{
CVarDumpFrames = IConsoleManager::Get().FindConsoleVariable(TEXT("r.BufferVisualizationDumpFrames"));
CVarDumpFramesAsHDR = IConsoleManager::Get().FindConsoleVariable(TEXT("r.BufferVisualizationDumpFramesAsHDR"));
CVarHDRCompressionQuality = IConsoleManager::Get().FindConsoleVariable(TEXT("r.SaveEXR.CompressionQuality"));
CVarDumpGamut = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TonemapperOutputGamut"));
Disable();
}
