void
Profile::Load(TaskBehaviour &settings)
{
Load(settings.glide);
Get(ProfileKeys::AATTimeMargin, settings.optimise_targets_margin);
Get(ProfileKeys::AutoMc, settings.auto_mc);
GetEnum(ProfileKeys::AutoMcMode, settings.auto_mc_mode);
unsigned Temp;
if (Get(ProfileKeys::RiskGamma, Temp))
settings.risk_gamma = fixed(Temp) / 10;
if (Get(ProfileKeys::SafetyMacCready, Temp))
settings.safety_mc = fixed(Temp) / 10;
Get(ProfileKeys::SafetyAltitudeArrival, settings.safety_height_arrival);
GetEnum(ProfileKeys::TaskType, settings.task_type_default);
Load(settings.start_margins);
Load(settings.sector_defaults);
Load(settings.ordered_defaults);
GetEnum(ProfileKeys::AbortTaskMode, settings.abort_task_mode);
Load(settings.route_planner);
}
void
Profile::Load(UISettings &settings)
{
Load(settings.display);
Get(szProfileMenuTimeout, settings.menu_timeout);
Get(szProfileUseCustomFonts, settings.custom_fonts);
Get(szProfileEnableTAGauge, settings.enable_thermal_assistant_gauge);
Get(szProfileEnableFinalGlideBarMC0, settings.final_glide_bar_mc0_enabled);
GetEnum(szProfileAppStatusMessageAlignment, settings.popup_message_position);
GetEnum(szProfileHapticFeedback, settings.haptic_feedback);
GetEnum(szProfileLatLonUnits, settings.coordinate_format);
LoadUnits(settings.units);
Load(settings.map);
Load(settings.info_boxes);
Load(settings.vario);
Load(settings.traffic);
Load(settings.pages);
Load(settings.dialog);
}
void
Profile::Load(TaskBehaviour &settings)
{
Load((TaskStartMargins &)settings);
Load(settings.glide);
Get(szProfileAATTimeMargin, settings.optimise_targets_margin);
Get(szProfileAutoMc, settings.auto_mc);
GetEnum(szProfileAutoMcMode, settings.auto_mc_mode);
unsigned Temp;
if (Get(szProfileRiskGamma, Temp))
settings.risk_gamma = fixed(Temp) / 10;
if (GetEnum(szProfileOLCRules, settings.contest)) {
/* handle out-dated Sprint rule in profile */
if (settings.contest == OLC_Sprint)
settings.contest = OLC_League;
}
if (Get(szProfileSafetyMacCready, Temp))
settings.safety_mc = fixed(Temp) / 10;
Get(szProfileSafetyAltitudeArrival, settings.safety_height_arrival);
GetEnum(szProfileTaskType, settings.task_type_default);
Load(settings.sector_defaults);
Load(settings.ordered_defaults);
GetEnum(szProfileAbortTaskMode, settings.abort_task_mode);
Load(settings.route_planner);
}
void
Profile::Load(UISettings &settings)
{
Load(settings.display);
Get(ProfileKeys::MenuTimeout, settings.menu_timeout);
#ifndef GNAV
Get(ProfileKeys::UseCustomFonts, settings.custom_fonts);
#endif
Get(ProfileKeys::EnableTAGauge, settings.enable_thermal_assistant_gauge);
GetEnum(ProfileKeys::AppStatusMessageAlignment, settings.popup_message_position);
GetEnum(ProfileKeys::HapticFeedback, settings.haptic_feedback);
Load(settings.format);
Load(settings.map);
Load(settings.info_boxes);
Load(settings.vario);
Load(settings.traffic);
Load(settings.pages);
Load(settings.dialog);
Load(settings.sound);
}
void
Profile::Load(DialogSettings &settings)
{
GetEnum(ProfileKeys::AppTextInputStyle, settings.text_input_style);
GetEnum(ProfileKeys::AppDialogTabStyle, settings.tab_style);
Get(ProfileKeys::UserLevel, settings.expert);
}
void
Profile::Load(DialogSettings &settings)
{
GetEnum(szProfileAppDialogStyle, settings.dialog_style);
GetEnum(szProfileAppTextInputStyle, settings.text_input_style);
GetEnum(szProfileAppDialogTabStyle, settings.tab_style);
Get(szProfileUserLevel, settings.expert);
}
void
Profile::Load(TrailSettings &settings)
{
Get(ProfileKeys::TrailDrift, settings.wind_drift_enabled);
Get(ProfileKeys::SnailWidthScale, settings.scaling_enabled);
GetEnum(ProfileKeys::SnailType, settings.type);
GetEnum(ProfileKeys::SnailTrail, settings.length);
}
void
Profile::Load(OrderedTaskBehaviour &settings)
{
GetEnum(szProfileFinishHeightRef, settings.finish_min_height_ref);
Get(szProfileFinishMinHeight, settings.finish_min_height);
GetEnum(szProfileStartHeightRef, settings.start_max_height_ref);
Get(szProfileStartMaxHeight, settings.start_max_height);
Get(szProfileStartMaxSpeed, settings.start_max_speed);
Get(szProfileAATMinTime, settings.aat_min_time);
}
void
Profile::Load(SectorDefaults &settings)
{
GetEnum(ProfileKeys::StartType, settings.start_type);
Get(ProfileKeys::StartRadius, settings.start_radius);
GetEnum(ProfileKeys::TurnpointType, settings.turnpoint_type);
Get(ProfileKeys::TurnpointRadius, settings.turnpoint_radius);
GetEnum(ProfileKeys::FinishType, settings.finish_type);
Get(ProfileKeys::FinishRadius, settings.finish_radius);
}
void
Profile::Load(RoutePlannerConfig &settings)
{
Get(ProfileKeys::SafetyAltitudeTerrain, settings.safety_height_terrain);
GetEnum(ProfileKeys::RoutePlannerMode, settings.mode);
Get(ProfileKeys::RoutePlannerAllowClimb, settings.allow_climb);
Get(ProfileKeys::RoutePlannerUseCeiling, settings.use_ceiling);
GetEnum(ProfileKeys::TurningReach, settings.reach_calc_mode);
GetEnum(ProfileKeys::ReachPolarMode, settings.reach_polar_mode);
}
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
void __stdcall AMD::OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
{
#if !AMD_SDK_PREBUILT_RELEASE_EXE
if( g_pHUD == NULL || g_pShaderCache == NULL )
return;
ShaderCache& r_ShaderCache = *g_pShaderCache;
HUD& r_HUD = *g_pHUD;
if( nControlID == GetEnum(AMD_IDC_BUTTON_RECOMPILESHADERS_CHANGED) )
{
// Errors will post during compile, don't need them right now
const bool bOldShaderErrorsFlag = r_ShaderCache.ShowShaderErrors();
r_ShaderCache.SetShowShaderErrorsFlag( false );
r_ShaderCache.GenerateShaders( AMD::ShaderCache::CREATE_TYPE_COMPILE_CHANGES, true );
r_ShaderCache.SetShowShaderErrorsFlag( bOldShaderErrorsFlag );
}
else if( nControlID == GetEnum(AMD_IDC_BUTTON_RECOMPILESHADERS_GLOBAL) )
{
// Errors will post during compile, don't need them right now
const bool bOldShaderErrorsFlag = r_ShaderCache.ShowShaderErrors();
r_ShaderCache.SetShowShaderErrorsFlag( false );
r_ShaderCache.GenerateShaders( AMD::ShaderCache::CREATE_TYPE_FORCE_COMPILE, true );
r_ShaderCache.SetShowShaderErrorsFlag( bOldShaderErrorsFlag );
}
#if AMD_SDK_INTERNAL_BUILD
else if( nControlID == GetEnum(AMD_IDC_BUTTON_RECREATE_SHADERS) )
{
assert( r_ShaderCache.GenerateISAGPRPressure() ); // Shouldn't call this if we aren't using ISA
const bool k_bOK = r_ShaderCache.CloneShaders();
assert( k_bOK );
if( k_bOK )
{
// Errors won't post using this method... Should find a better one!
// Need to somehow toggle error rendering off and then on again next frame...
const bool bOldShaderErrorsFlag = r_ShaderCache.ShowShaderErrors();
r_ShaderCache.SetShowShaderErrorsFlag( false );
r_ShaderCache.GenerateShaders( AMD::ShaderCache::CREATE_TYPE_USE_CACHED, true );
r_ShaderCache.SetShowShaderErrorsFlag( bOldShaderErrorsFlag );
}
}
else if( nControlID == GetEnum(AMD_IDC_COMBOBOX_TARGET_ISA) )
{
assert( r_ShaderCache.GenerateISAGPRPressure() ); // Shouldn't call this if we aren't using ISA
r_ShaderCache.SetTargetISA( (AMD::ISA_TARGET)((CDXUTComboBox*)pControl)->GetSelectedIndex() );
}
#endif
else if( nControlID == GetEnum(AMD_IDC_BUTTON_SHOW_SHADERCACHE_UI) )
{
// Toggle Render of ShaderCache GUI
g_bAdvancedShaderCacheGUI_IsVisible = !g_bAdvancedShaderCacheGUI_IsVisible;
SetHUDVisibility( r_HUD, g_bAdvancedShaderCacheGUI_IsVisible );
}
#endif
}
static int GetVertexAttrib(lua_State *L)
{
GLuint index = luaL_checkinteger(L, 1);
GLenum pname = checkvertexpname(L,2);
switch(pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
case GL_VERTEX_ATTRIB_ARRAY_LONG:
return GetBoolean(L, index, pname);
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
case GL_VERTEX_ATTRIB_ARRAY_SIZE:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
case GL_VERTEX_ATTRIB_BINDING:
return GetInt(L, index, pname);
case GL_VERTEX_ATTRIB_ARRAY_TYPE:
return GetEnum(L, index, pname);
// case GL_VERTEX_BINDING_OFFSET: //@@
default:
return luaL_argerror(L, 2, "invalid pname");
}
CheckError(L);
return 0;
}
QVariant ParamWidget::SaveState() {
QMap<QString, QVariant> data;
for (auto& item : widgets_) {
const QString& name = item.first;
const QString qname = name;
QWidget* widget = item.second;
QVariant param_type = widget->property("param_widget_type");
assert(param_type.isValid());
switch (param_type.toInt()) {
case kParamEnum:
data[qname] = GetEnum(name);
break;
case kParamBool:
data[qname] = GetBool(name);
break;
case kParamInt:
data[qname] = GetInt(name);
break;
case kParamDouble:
data[qname] = GetDouble(name);
break;
case kParamButton:
default:
assert(false);
break;
}
}
return data;
}
void
Profile::Load(StartConstraints &constraints)
{
GetEnum(ProfileKeys::StartHeightRef, constraints.max_height_ref);
Get(ProfileKeys::StartMaxHeight, constraints.max_height);
Get(ProfileKeys::StartMaxSpeed, constraints.max_speed);
}
void
Profile::Load(FeaturesSettings &settings)
{
GetEnum(szProfileFinalGlideTerrain, settings.final_glide_terrain);
Get(szProfileBlockSTF, settings.block_stf_enabled);
Get(szProfileEnableNavBaroAltitude, settings.nav_baro_altitude_enabled);
}
void
Profile::Load(AirspaceRendererSettings &settings)
{
Get(ProfileKeys::AirspaceBlackOutline, settings.black_outline);
GetEnum(ProfileKeys::AltMode, settings.altitude_mode);
Get(ProfileKeys::ClipAlt, settings.clip_altitude);
#ifndef ENABLE_OPENGL
Get(ProfileKeys::AirspaceTransparency, settings.transparency);
#endif
GetEnum(ProfileKeys::AirspaceFillMode, settings.fill_mode);
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; i++)
Load(i, settings.classes[i]);
}
hashcode_t HashCode::hashcodeByUnRepeatedField(const Message* msg, const FieldDescriptor* field) {
auto reflect = msg->GetReflection();
switch (field->cpp_type()) {
case FieldDescriptor::CPPTYPE_UINT64:
return stl_hashcode(reflect->GetUInt64(*msg, field));
case FieldDescriptor::CPPTYPE_INT64:
return stl_hashcode(reflect->GetInt64(*msg, field));
case FieldDescriptor::CPPTYPE_UINT32:
return stl_hashcode(reflect->GetUInt32(*msg, field));
case FieldDescriptor::CPPTYPE_INT32:
return stl_hashcode(reflect->GetInt32(*msg, field));
case FieldDescriptor::CPPTYPE_STRING:
return stl_hashcode(reflect->GetString(*msg, field));
case FieldDescriptor::CPPTYPE_DOUBLE:
return stl_hashcode(reflect->GetDouble(*msg, field));
case FieldDescriptor::CPPTYPE_FLOAT:
return stl_hashcode(reflect->GetFloat(*msg, field));
case FieldDescriptor::CPPTYPE_BOOL:
return stl_hashcode(reflect->GetBool(*msg, field));
case FieldDescriptor::CPPTYPE_ENUM:
return stl_hashcode(reflect->GetEnum(*msg, field)->number());
case FieldDescriptor::CPPTYPE_MESSAGE:
return stl_hashcode(reflect->GetMessage(*msg, field));
default:
LOG(ERROR)<< "The type of protobuf is not supported";
return 0;
}
}
void
Profile::Load(TrackingSettings &settings)
{
Get(ProfileTrackingInterval, settings.interval);
GetEnum(ProfileTrackingVehicleType, settings.vehicleType);
Load(settings.livetrack24);
}
void UK2Node_GetEnumeratorName::EarlyValidation(class FCompilerResultsLog& MessageLog) const
{
const UEnum* Enum = GetEnum();
if (NULL == Enum)
{
MessageLog.Error(*NSLOCTEXT("K2Node", "GetNumEnumEntries_NoIntput_Error", "@@ Must have non-default Enum input").ToString(), this);
}
}
void
Profile::Load(TrafficSettings &settings)
{
Get(ProfileKeys::EnableFLARMGauge, settings.enable_gauge);
Get(ProfileKeys::AutoCloseFlarmDialog, settings.auto_close_dialog);
Get(ProfileKeys::FlarmAutoZoom, settings.auto_zoom);
Get(ProfileKeys::FlarmNorthUp, settings.north_up);
GetEnum(ProfileKeys::FlarmLocation, settings.gauge_location);
}
void UK2Node_GetEnumeratorName::UpdatePinType()
{
UEdGraphPin* EnumPin = FindPinChecked(EnumeratorPinName);
UEnum* Enum = GetEnum();
if (EnumPin->PinType.PinSubCategoryObject != Enum)
{
EnumPin->PinType.PinSubCategoryObject = Enum;
PinTypeChanged(EnumPin);
}
}
void
Profile::Use()
{
LogStartUp(_T("Read registry settings"));
Load(CommonInterface::SetComputerSettings());
Load(CommonInterface::SetUISettings());
GetEnum(szProfileAppDialogStyle, dialog_style_setting);
}
HRESULT SymFuncType::GetDef( CString &Info )
{
#ifdef DEBUG_PRINT
SymbolInfoTable InfoTableDebug;
SymBase::GetInfoTable(InfoTableDebug);
#endif
CComPtr<IDiaSymbol> FuncBaseType;
HRESULT hr = Self()->get_type(&FuncBaseType);
ATLASSERT(HR_OK(hr));
if (HR_NOK(hr)) {
return hr;
}
CAutoPtr<SymBase> SubSym(SymBase::SymNew(FuncBaseType));
hr = SubSym->GetDecl(Info);
ATLASSERT(HR_OK(hr));
if (HR_NOK(hr)) {
return hr;
}
Info += L" (";
ULONG CallConv;
hr = Self()->get_callingConvention(&CallConv);
ATLASSERT(HR_OK(hr));
if (HR_NOK(hr)) {
return hr;
}
Info += GetCallingConventionStr(CallConv);
Info += L" *)";
IDiaEnumSymbols *SymChildren = GetEnum(SymTagFunctionArgType);
Info += L"(";
if (SymChildren != NULL) {
SymEnumTool SymEnumInst(SymChildren);
int i;
for (i = 0; i < SymEnumInst.GetCount(); i++) {
if (i != 0) {
Info += L", ";
}
CString Tmp;
CAutoPtr<SymBase> p(SymBase::SymNew(SymEnumInst.Item(i)));
p->GetDecl(Tmp);
Info += Tmp;
}
}
Info += L")";
return S_OK;
}
void SymBase::EnumEveryChild()
{
CString Info;
IDiaEnumSymbols *SymChildren = GetEnum(SymTagNull);
if (SymChildren != NULL) {
SymEnumTool SymEnumInst(SymChildren);
int i;
for (i = 0; i < SymEnumInst.GetCount(); i++) {
CAutoPtr<SymBase> p(SymBase::SymNew(SymEnumInst.Item(i)));
p->GetDecl(Info);
}
}
}
HRESULT SWLPRVenusCameraParameter::InitONVIF(VOID)
{
SW_TRACE_NORMAL(" HRESULT SWLPRVenusCameraParameter::InitONVIF(VOID)");
GetEnum("\\ONVIF"
, "OnvifEnable"
, &Get().cOnvifParam.iOnvifEnable
, Get().cOnvifParam.iOnvifEnable
, "0:不使能;1:使能"
, "开关"
, ""
, CUSTOM_LEVEL);
GetEnum("\\ONVIF"
, "AuthenticateEnable"
, &Get().cOnvifParam.iAuthenticateEnable
, Get().cOnvifParam.iAuthenticateEnable
, "0:不使能;1:使能"
, "鉴权"
, "使能时需要用户密码才能进行操作"
, CUSTOM_LEVEL);
//为了统一，RTSP的鉴权和ONVIF的保持一致
Get().cRtspParam.iAuthenticateEnable = Get().cOnvifParam.iAuthenticateEnable;
Get().cRtspParam.iRTSPStreamNum = 2;
GetEnum("\\ONVIF"
, "AutoControlBitrateEnable"
, &Get().cRtspParam.iAutoControlBitrateEnable
, Get().cRtspParam.iAutoControlBitrateEnable
, "0:不使能;1:使能"
, "自动控制码率开关"
, "当网络出现拥塞会自动控制码率适应网络"
, CUSTOM_LEVEL);
SW_TRACE_NORMAL(" HRESULT SWLPRVenusCameraParameter::InitONVIF(VOID) End");
}
void AMD::ProcessUIChanges()
{
#if !AMD_SDK_PREBUILT_RELEASE_EXE
if( g_pHUD == NULL || g_pShaderCache == NULL )
return;
ShaderCache& r_ShaderCache = *g_pShaderCache;
HUD& r_HUD = *g_pHUD;
r_ShaderCache.SetRecompileTouchedShadersFlag( r_HUD.m_GUI.GetCheckBox( GetEnum(AMD_IDC_CHECKBOX_AUTORECOMPILE_SHADERS) )->GetChecked() );
if( r_ShaderCache.ShaderErrorDisplayType() == ShaderCache::ERROR_DISPLAY_ON_SCREEN )
{
r_ShaderCache.SetShowShaderErrorsFlag( r_HUD.m_GUI.GetCheckBox( GetEnum(AMD_IDC_CHECKBOX_SHOW_SHADER_ERRORS) )->GetChecked() );
}
#if AMD_SDK_INTERNAL_BUILD
if( r_ShaderCache.GenerateISAGPRPressure() )
{
r_ShaderCache.SetShowShaderISAFlag( r_HUD.m_GUI.GetCheckBox( GetEnum(AMD_IDC_CHECKBOX_SHOW_ISA_GPR_PRESSURE) )->GetChecked() );
}
#endif
#endif
}
HRESULT SymFunc::GetDecl(CString &Info)
{
#ifdef DEBUG_PRINT
SymbolInfoTable InfoTableDebug;
SymBase::GetInfoTable(InfoTableDebug);
#endif
BSTR Name;
HRESULT hr = Self()->get_name(&Name);
ATLASSERT(HR_OK(hr));
if (HR_NOK(hr)) {
return hr;
}
CComPtr<IDiaSymbol> FuncType;
hr = Self()->get_type(&FuncType);
ATLASSERT(HR_OK(hr));
if (HR_NOK(hr)) {
return hr;
}
CString FuncTypeStr;
CAutoPtr<SymBase> SubSym(SymBase::SymNew(FuncType));
hr = SubSym->GetDecl(FuncTypeStr);
ATLASSERT(HR_OK(hr));
CString ArgsStr = L"(";
IDiaEnumSymbols *SymChildren = GetEnum(SymTagData);
if (SymChildren != NULL) {
SymEnumTool SymEnumInst(SymChildren);
int i;
for (i = 0; i < SymEnumInst.GetCount(); i++) {
CAutoPtr<SymBase> p(SymBase::SymNew(SymEnumInst.Item(i)));
ULONG DataKind;
CString ArgStr;
hr = p->Self()->get_dataKind(&DataKind);
if (HR_OK(hr) && DataKind == DataIsParam) {
if (i != 0) {
ArgsStr += L", ";
}
p->GetDecl(ArgStr);
ArgsStr += ArgStr;
}
}
}
ArgsStr += L")";
Info = FuncTypeStr + L" " + Name + L" " + ArgsStr + L";";
return hr;
}
ENUMTYPE CSequence::GetEnumType()
{
// this check done first to cope with sequences named (eg) "TORSO_" but not having an entry in anims.h
// to match this (which a strcmp won't detect). This shouldn't really be necessary since the menu system only
// allows you to pick valid ones from anims.h, but it copes with people editing ascii files by hand (or alerts
// people to entries being subsequently deleted from anims.h after use)
//
if (ValidEnum())
{
return GetEnumTypeFromString(GetEnum());
}
return ET_INVALID;
}
uint64 MDFN_GetSettingUI(const char *name)
{
const MDFNCS *setting = FindSetting(name);
const char *value = GetSetting(setting);
if(setting->desc->type == MDFNST_ENUM)
return(GetEnum(setting, value));
else
{
unsigned long long ret;
TranslateSettingValueUI(value, ret);
return(ret);
}
}
void
Profile::Load(UISettings &settings)
{
Get(szProfileUseCustomFonts, settings.custom_fonts);
Get(szProfileAutoBlank, settings.enable_auto_blank);
Get(szProfileEnableFLARMGauge, settings.enable_flarm_gauge);
Get(szProfileAutoCloseFlarmDialog, settings.auto_close_flarm_dialog);
Get(szProfileEnableTAGauge, settings.enable_thermal_assistant_gauge);
GetEnum(szProfileAppStatusMessageAlignment, settings.popup_message_position);
Load(settings.map);
Load(settings.info_boxes);
Load(settings.dialog);
}
