void SwitchViewManager::UpdateProperties(ShadowNodeBase* nodeToUpdate, const folly::dynamic& reactDiffMap)
{
auto toggleSwitch = nodeToUpdate->GetView().as<winrt::ToggleSwitch>();
if (toggleSwitch == nullptr)
return;
for (const auto& pair : reactDiffMap.items())
{
const std::string& propertyName = pair.first.getString();
const folly::dynamic& propertyValue = pair.second;
if (propertyName == "disabled")
{
if (propertyValue.isBool())
toggleSwitch.IsEnabled(!propertyValue.asBool());
else if (pair.second.isNull())
toggleSwitch.ClearValue(winrt::Control::IsEnabledProperty());
}
else if (propertyName == "value")
{
if (propertyValue.isBool())
toggleSwitch.IsOn(propertyValue.asBool());
else if (pair.second.isNull())
toggleSwitch.ClearValue(winrt::ToggleSwitch::IsOnProperty());
}
}
Super::UpdateProperties(nodeToUpdate, reactDiffMap);
}
void CheckBoxViewManager::UpdateProperties(ShadowNodeBase* nodeToUpdate, const folly::dynamic& reactDiffMap)
{
auto checkbox = nodeToUpdate->GetView().as<winrt::CheckBox>();
if (checkbox == nullptr)
return;
for (const auto& pair : reactDiffMap.items())
{
const std::string& propertyName = pair.first.getString();
const folly::dynamic& propertyValue = pair.second;
if (propertyName == "disabled")
{
if (propertyValue.isBool())
checkbox.IsEnabled(!propertyValue.asBool());
else if (pair.second.isNull())
checkbox.ClearValue(winrt::Control::IsEnabledProperty());
}
else if (propertyName == "checked")
{
if (propertyValue.isBool())
checkbox.IsChecked(propertyValue.asBool());
else if (pair.second.isNull())
checkbox.ClearValue(winrt::Primitives::ToggleButton::IsCheckedProperty());
}
}
Super::UpdateProperties(nodeToUpdate, reactDiffMap);
}
void
TaskCalculatorPanel::Refresh()
{
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
TCHAR buffer[32];
if (target_button != nullptr)
target_button->SetVisible(task_stats.has_targets);
SetRowVisible(AAT_TIME, task_stats.has_targets);
if (task_stats.has_targets) {
FormatTimespanSmart(buffer, (int)protected_task_manager->GetOrderedTaskSettings().aat_min_time, 2);
SetText(AAT_TIME, buffer);
}
FormatTimespanSmart(buffer, (int)task_stats.GetEstimatedTotalTime(), 2);
SetText(AAT_ESTIMATED, buffer);
fixed rPlanned = task_stats.total.solution_planned.IsDefined()
? task_stats.total.solution_planned.vector.distance
: fixed(0);
if (positive(rPlanned))
LoadValue(DISTANCE, rPlanned, UnitGroup::DISTANCE);
else
ClearValue(DISTANCE);
LoadValue(MC, CommonInterface::GetComputerSettings().polar.glide_polar_task.GetMC(),
UnitGroup::VERTICAL_SPEED);
LoadValue(EFFECTIVE_MC, emc, UnitGroup::VERTICAL_SPEED);
if (positive(rPlanned)) {
fixed rMax = task_stats.distance_max;
fixed rMin = task_stats.distance_min;
if (rMin < rMax) {
fixed range = Double((rPlanned - rMin) / (rMax - rMin)) - fixed(1);
LoadValue(RANGE, range * 100);
} else
ClearValue(RANGE);
} else
ClearValue(RANGE);
if (task_stats.total.remaining_effective.IsDefined())
LoadValue(SPEED_REMAINING, task_stats.total.remaining_effective.GetSpeed(),
UnitGroup::TASK_SPEED);
else
ClearValue(SPEED_REMAINING);
if (task_stats.total.travelled.IsDefined())
LoadValue(SPEED_ACHIEVED, task_stats.total.travelled.GetSpeed(),
UnitGroup::TASK_SPEED);
else
ClearValue(SPEED_ACHIEVED);
LoadValue(CRUISE_EFFICIENCY, task_stats.cruise_efficiency * 100);
}
void PopupShadowNode::updateProperties(const folly::dynamic&& props)
{
m_updating = true;
auto popup = GetView().as<winrt::Popup>();
if (popup == nullptr)
return;
for (auto& pair : props.items())
{
const std::string& propertyName = pair.first.getString();
const folly::dynamic& propertyValue = pair.second;
if (propertyName == "target")
{
if (propertyValue.isNumber())
m_targetTag = static_cast<int64_t>(propertyValue.asDouble());
else
m_targetTag = -1;
}
else if (propertyName == "isOpen")
{
if (propertyValue.isBool())
popup.IsOpen(propertyValue.getBool());
else if (propertyValue.isNull())
popup.ClearValue(winrt::Popup::IsOpenProperty());
}
else if (propertyName == "isLightDismissEnabled")
{
if (propertyValue.isBool())
popup.IsLightDismissEnabled(propertyValue.getBool());
else if (propertyValue.isNull())
popup.ClearValue(winrt::Popup::IsLightDismissEnabledProperty());
}
else if (propertyName == "horizontalOffset")
{
if (propertyValue.isNumber())
popup.HorizontalOffset(propertyValue.asDouble());
else if (propertyValue.isNull())
popup.ClearValue(winrt::Popup::HorizontalOffsetProperty());
}
else if (propertyName == "verticalOffset")
{
if (propertyValue.isNumber())
popup.VerticalOffset(propertyValue.asDouble());
else if (propertyValue.isNull())
popup.ClearValue(winrt::Popup::VerticalOffsetProperty());
}
}
Super::updateProperties(std::move(props));
m_updating = false;
}
void
RulesStatusPanel::Refresh()
{
TCHAR Temp[80];
const DerivedInfo &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const StartStats &start_stats = task_stats.start;
const ComputerSettings &settings = CommonInterface::GetComputerSettings();
/// @todo proper task validity check
SetText(ValidStart, start_stats.task_started
? _("Yes") : _T("No"));
SetText(ValidFinish, task_stats.task_finished
? _("Yes") : _T("No"));
if (start_stats.task_started) {
SetText(StartTime,
FormatLocalTimeHHMM((int)start_stats.time, settings.utc_offset));
SetText(StartSpeed,
FormatUserTaskSpeed(start_stats.ground_speed));
SetText(StartHeight, FormatUserAltitude(start_stats.altitude));
} else {
ClearValue(StartTime);
ClearValue(StartSpeed);
ClearValue(StartHeight);
}
Temp[0] = _T('\0');
double finish_height(0);
if (protected_task_manager != nullptr) {
ProtectedTaskManager::Lease task_manager(*protected_task_manager);
const OrderedTask &task = task_manager->GetOrderedTask();
const unsigned task_size = task.TaskSize();
if (task_size > 0) {
CopyString(Temp, task.GetTaskPoint(0).GetWaypoint().name.c_str(),
ARRAY_SIZE(Temp));
finish_height = task.GetTaskPoint(task_size - 1).GetElevation();
}
}
SetText(StartPoint, Temp);
SetText(FinishAlt, FormatUserAltitude(finish_height));
}
bool DropGrid::Key(dword k, int)
{
if(IsReadOnly()) return false;
if(drop_enter && k == K_ENTER)
k = K_ALT_DOWN;
switch(k)
{
case K_ALT_DOWN:
Drop();
break;
case K_DOWN:
case K_RIGHT:
Change(1);
break;
case K_UP:
case K_LEFT:
Change(-1);
break;
case K_DELETE:
ClearValue();
break;
default:
if(searching && k >= 32 && k < 65536)
{
if(!list.IsOpen())
Drop();
list.Search(k);
}
return false;
}
return true;
}
void DropGrid::CancelUpdate()
{
int prevrow = list.GetPrevCursor();
if(prevrow >= 0)
{
list.SetCursor(prevrow);
UpdateValue();
rowid = list.GetRowId(prevrow);
Refresh();
}
else
ClearValue();
}
void DropGrid::SetData(const Value& v)
{
int row = list.Find(v, key_col);
if(row >= 0)
{
list.SetCursor(row);
UpdateValue();
DoAction(row, data_action, false);
Refresh();
}
else
ClearValue();
}
void CVisProp::SetDefaultValue(const CVisDim& refdim, bool fShared)
{
ReleaseObj();
SetFObjReference(false);
SetFShared(fShared);
SetFPointerToObject(fShared || !(PropTypeInfo().CanCopyObjectBytes()));
if (refdim.CObj() > 1)
SetPvRefCntArray(PropTypeInfo().PRefCntArrayMake(refdim));
else if (!FPointerToObject())
ClearValue();
else
SetPvRefCntObj(PropTypeInfo().PvRefCntObjMakePvObj(0));
SetFInitialized(true);
}
~CTempEnvVar()
{
if ( m_bRestoreOriginalValue )
{
// Restore the original value.
if ( m_bExisted )
{
SetValue( "%s", m_OriginalValue.Base() );
}
else
{
ClearValue();
}
}
}
void CVisProp::ReleaseObj(void)
{
if (IsValid())
{
if (IsArray())
{
PropTypeInfo().ReleasePvRefCntArray(PRefCntArray());
}
else if (FPointerToObject())
{
if (IsObjReference())
((CVisRefCntObj<void *> *) PvRefCntObj())->Release();
else
PropTypeInfo().ReleasePvRefCntObj(PvRefCntObj());
}
}
ClearValue();
m_fArray = false;
SetFInitialized(false);
}
void DropGrid::Clear()
{
list.Clear();
ClearValue();
}
void DropGrid::Reset()
{
list.Reset();
ClearValue();
value_cols.Clear();
}
void DropGrid::DoClearValue()
{
ClearValue();
SetFocus();
}
Error Volumetric::init(const ConfigSet& config)
{
U width = m_r->getWidth() / VOLUMETRIC_FRACTION;
U height = m_r->getHeight() / VOLUMETRIC_FRACTION;
// Create RTs
m_r->createRenderTarget(width,
height,
IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
SamplingFilter::LINEAR,
1,
m_rt);
m_r->createRenderTarget(width,
height,
IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::CLEAR,
SamplingFilter::LINEAR,
1,
m_tmpRt);
m_r->clearRenderTarget(m_tmpRt, ClearValue(), TextureUsageBit::SAMPLED_FRAGMENT);
// Create shaders
ANKI_CHECK(m_r->createShader("shaders/Volumetric.frag.glsl",
m_frag,
"#define RPASS_SIZE uvec2(%uu, %uu)\n"
"#define CLUSTER_COUNT uvec3(%uu, %uu, %uu)\n",
width,
height,
m_r->getIs().getLightBin().getClusterer().getClusterCountX(),
m_r->getIs().getLightBin().getClusterer().getClusterCountY(),
m_r->getIs().getLightBin().getClusterer().getClusterCountZ()));
ANKI_CHECK(m_r->createShader("shaders/GaussianBlurGeneric.frag.glsl",
m_hblurFrag,
"#define HPASS\n"
"#define COL_RGB\n"
"#define TEXTURE_SIZE vec2(%f, %f)\n"
"#define KERNEL_SIZE 11\n",
F32(width),
F32(height)));
ANKI_CHECK(m_r->createShader("shaders/GaussianBlurGeneric.frag.glsl",
m_vblurFrag,
"#define VPASS\n"
"#define COL_RGB\n"
"#define TEXTURE_SIZE vec2(%f, %f)\n"
"#define KERNEL_SIZE 11\n",
F32(width),
F32(height)));
// Create pplines
ColorStateInfo state;
state.m_attachmentCount = 1;
state.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
m_r->createDrawQuadPipeline(m_frag->getGrShader(), state, m_ppline);
m_r->createDrawQuadPipeline(m_hblurFrag->getGrShader(), state, m_hblurPpline);
m_r->createDrawQuadPipeline(m_vblurFrag->getGrShader(), state, m_vblurPpline);
// Create the resource groups
ResourceGroupInitInfo rcInit;
rcInit.m_textures[0].m_texture = m_r->getHalfDepth().m_depthRt;
rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
rcInit.m_textures[1].m_texture = m_tmpRt;
rcInit.m_textures[2].m_texture = m_r->getSm().getSpotTextureArray();
rcInit.m_textures[3].m_texture = m_r->getSm().getOmniTextureArray();
rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[1].m_uploadedMemory = true;
rcInit.m_uniformBuffers[1].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[2].m_uploadedMemory = true;
rcInit.m_uniformBuffers[2].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[3].m_uploadedMemory = true;
rcInit.m_uniformBuffers[3].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_storageBuffers[0].m_uploadedMemory = true;
rcInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ;
rcInit.m_storageBuffers[1].m_uploadedMemory = true;
rcInit.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ;
m_rc = getGrManager().newInstance<ResourceGroup>(rcInit);
rcInit = ResourceGroupInitInfo();
rcInit.m_textures[0].m_texture = m_rt;
m_hblurRc = getGrManager().newInstance<ResourceGroup>(rcInit);
rcInit.m_textures[0].m_texture = m_tmpRt;
m_vblurRc = getGrManager().newInstance<ResourceGroup>(rcInit);
// Create FBs
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_tmpRt;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
fbInit.m_colorAttachments[0].m_usageInsideRenderPass = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
m_hblurFb = getGrManager().newInstance<Framebuffer>(fbInit);
fbInit.m_colorAttachments[0].m_texture = m_rt;
m_vblurFb = getGrManager().newInstance<Framebuffer>(fbInit);
return ErrorCode::NONE;
}
void
TaskStatusPanel::Refresh()
{
if (protected_task_manager == nullptr)
return;
const DerivedInfo &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
SetRowVisible(TaskTime, task_stats.has_targets);
if (task_stats.has_targets)
SetText(TaskTime,
FormatSignedTimeHHMM((int)protected_task_manager->GetOrderedTaskSettings().aat_min_time));
SetText(ETETime,
FormatSignedTimeHHMM((int)task_stats.GetEstimatedTotalTime()));
SetText(RemainingTime,
FormatSignedTimeHHMM((int)task_stats.total.time_remaining_now));
if (task_stats.total.planned.IsDefined())
SetText(TaskDistance,
FormatUserDistanceSmart(task_stats.total.planned.GetDistance()));
else
ClearText(TaskDistance);
if (task_stats.total.remaining.IsDefined())
SetText(RemainingDistance,
FormatUserDistanceSmart(task_stats.total.remaining.GetDistance()));
if (task_stats.total.planned.IsDefined())
SetText(EstimatedSpeed,
FormatUserTaskSpeed(task_stats.total.planned.GetSpeed()));
else
ClearText(EstimatedSpeed);
if (task_stats.total.travelled.IsDefined())
SetText(AverageSpeed,
FormatUserTaskSpeed(task_stats.total.travelled.GetSpeed()));
else
ClearText(AverageSpeed);
LoadValue(MC,
CommonInterface::GetComputerSettings().polar.glide_polar_task.GetMC(),
UnitGroup::VERTICAL_SPEED);
if (task_stats.total.planned.IsDefined()) {
auto rMax = task_stats.distance_max;
auto rMin = task_stats.distance_min;
if (rMin < rMax) {
auto range = 2 * (task_stats.total.planned.GetDistance() - rMin) / (rMax - rMin) - 1;
LoadValue(RANGE, range * 100);
} else
ClearValue(RANGE);
} else
ClearValue(RANGE);
if (task_stats.total.remaining_effective.IsDefined())
LoadValue(SPEED_REMAINING, task_stats.total.remaining_effective.GetSpeed(),
UnitGroup::TASK_SPEED);
else
ClearValue(SPEED_REMAINING);
LoadValue(EFFECTIVE_MC, task_stats.effective_mc, UnitGroup::VERTICAL_SPEED);
if (task_stats.total.travelled.IsDefined())
LoadValue(SPEED_ACHIEVED, task_stats.total.travelled.GetSpeed(),
UnitGroup::TASK_SPEED);
else
ClearValue(SPEED_ACHIEVED);
LoadValue(CRUISE_EFFICIENCY, task_stats.cruise_efficiency * 100);
}
