Пример #1
0
void
FlightSetupPanel::SetBallast()
{
  const bool ballastable = polar_settings.glide_polar_task.IsBallastable();
  SetRowVisible(Ballast, ballastable);
  if (ballastable)
    LoadValue(Ballast, polar_settings.glide_polar_task.GetBallastLitres());

  const fixed wl = polar_settings.glide_polar_task.GetWingLoading();
  SetRowVisible(WingLoading, positive(wl));
  if (positive(wl))
    LoadValue(WingLoading, wl);

  if (device_blackboard != NULL) {
    const Plane &plane = CommonInterface::GetComputerSettings().plane;
    if (positive(plane.dry_mass)) {
      fixed fraction = polar_settings.glide_polar_task.GetBallast();
      fixed overload = (plane.dry_mass + fraction * plane.max_ballast) /
        plane.dry_mass;

      MessageOperationEnvironment env;
      device_blackboard->SetBallast(fraction, overload, env);
    }
  }
}
Пример #2
0
 void Update(const SwitchState &switches) {
   LoadValueEnum(AIRBRAKE_STATE, switches.airbrake_state);
   LoadValueEnum(FLAP_POSITION, (unsigned)switches.flap_position);
   LoadValue(GEAR_DOWN, switches.vega.GetGearExtended());
   LoadValue(ACKNOWLEDGE, switches.vega.GetAcknowledge());
   LoadValue(SPEED_COMMAND, switches.vega.GetSpeedCommand());
 }
Пример #3
0
void
FlightSetupPanel::SetBallast()
{
  const bool ballastable = polar_settings.glide_polar_task.IsBallastable();
  SetRowVisible(Ballast, ballastable);
  if (ballastable)
    LoadValue(Ballast, polar_settings.glide_polar_task.GetBallastLitres());

  const auto wl = polar_settings.glide_polar_task.GetWingLoading();
  SetRowVisible(WingLoading, wl > 0);
  if (wl > 0)
    LoadValue(WingLoading, wl, UnitGroup::WING_LOADING);

  if (device_blackboard != NULL) {
    const Plane &plane = CommonInterface::GetComputerSettings().plane;
    if (plane.dry_mass > 0) {
      auto fraction = polar_settings.glide_polar_task.GetBallast();
      auto overload = (plane.dry_mass + fraction * plane.max_ballast) /
        plane.dry_mass;

      MessageOperationEnvironment env;
      device_blackboard->SetBallast(fraction, overload, env);
    }
  }
}
Пример #4
0
void
PlanePolarWidget::Update()
{
  LoadPolarShape(plane.polar_shape);
  UpdatePolarLabel();

  LoadValue(REFERENCE_MASS, plane.reference_mass);
  LoadValue(DRY_MASS, plane.dry_mass);
}
Пример #5
0
inline void
PlaneEditWidget::PolarButtonClicked()
{
  bool changed = false;
  if (!Save(changed))
    return;

  dlgPlanePolarShowModal(plane);
  UpdatePolarButton();

  /* reload attributes that may have been modified */
  LoadValue(WING_AREA, plane.wing_area);
  LoadValue(MAX_BALLAST, plane.max_ballast);
  LoadValue(MAX_SPEED, plane.max_speed, UnitGroup::HORIZONTAL_SPEED);
}
Пример #6
0
void
WindSettingsPanel::UpdateVector()
{
  if (!edit_manual_wind)
    return;

  const DerivedInfo &calculated = CommonInterface::Calculated();
  const WindSettings &settings = CommonInterface::SetComputerSettings().wind;

  const TCHAR *source = nullptr;
  switch (manual_modified
          ? DerivedInfo::WindSource::MANUAL
          : calculated.wind_source) {
  case DerivedInfo::WindSource::NONE:
    source = _("None");
    break;

  case DerivedInfo::WindSource::MANUAL:
    source = _("Manual");
    break;

  case DerivedInfo::WindSource::CIRCLING:
    source = _("Circling");
    break;

  case DerivedInfo::WindSource::EKF:
    source = _("ZigZag");
    break;

  case DerivedInfo::WindSource::EXTERNAL:
    source = _("External");
    break;
  }

  SetText(SOURCE, source);

  if (!manual_modified && !settings.manual_wind_available) {
    SpeedVector wind = CommonInterface::Calculated().GetWindOrZero();
    LoadValue(Speed, Units::ToUserWindSpeed(wind.norm));
    LoadValue(Direction, wind.bearing);
  }

  const bool visible = settings.manual_wind_available;
  if (clear_manual_button)
    SetRowVisible(CLEAR_MANUAL_BUTTON, visible);
  else if (clear_manual_window != nullptr)
    clear_manual_window->SetVisible(visible);
}
Пример #7
0
void
FontEditWidget::Load()
{
#ifdef USE_GDI
  {
    DataFieldEnum &df = (DataFieldEnum &)GetDataField(FACE);
    df.SetStringAutoAdd(data.lfFaceName);
    GetControl(FACE).RefreshDisplay();
  }
#endif

  LoadValue(HEIGHT, (int)data.lfHeight);
  LoadValue(WEIGHT, data.lfWeight > 500);
  LoadValue(ITALIC, !!data.lfItalic);

  UpdatePreview();
}
Пример #8
0
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);
}
Пример #9
0
void
FlightSetupPanel::ShowAltitude(fixed altitude)
{
  if (fabs(altitude - last_altitude) >= fixed(1)) {
    last_altitude = altitude;
    LoadValue(Altitude, altitude, UnitGroup::ALTITUDE);
  }

  ShowRow(Altitude);
}
Пример #10
0
void
WindSettingsPanel::UpdateVector()
{
  if (!edit_manual_wind)
    return;

  const DerivedInfo &calculated = CommonInterface::Calculated();
  const WindSettings &settings = CommonInterface::SetComputerSettings().wind;

  const TCHAR *source = nullptr;
  switch (manual_modified
          ? DerivedInfo::WindSource::MANUAL
          : calculated.wind_source) {
  case DerivedInfo::WindSource::NONE:
    source = _("None");
    break;

  case DerivedInfo::WindSource::MANUAL:
    source = _("Manual");
    break;

  case DerivedInfo::WindSource::AUTO:
    source = _("Auto");
    break;

  case DerivedInfo::WindSource::EXTERNAL:
    source = _("External");
    break;
  }

  SetText(SOURCE, source);

  if (!manual_modified && !settings.manual_wind_available) {
    SpeedVector wind = CommonInterface::Calculated().GetWindOrZero();
    LoadValue(Speed, Units::ToUserWindSpeed(wind.norm));
    LoadValue(Direction, wind.bearing);
  }
}
Пример #11
0
void
TaskPropertiesPanel::RefreshView()
{
  const TaskFactoryType ftype = ordered_task->GetFactoryType();
  const OrderedTaskBehaviour &p = ordered_task->GetOrderedTaskBehaviour();

  bool aat_types = (ftype == TaskFactoryType::AAT);
  bool fai_start_finish = p.fai_finish;

  SetRowVisible(MIN_TIME, aat_types);
  LoadValueTime(MIN_TIME, (int)p.aat_min_time);

  SetRowVisible(START_MAX_SPEED, !fai_start_finish);
  LoadValue(START_MAX_SPEED, p.start_max_speed, UnitGroup::HORIZONTAL_SPEED);

  SetRowVisible(START_MAX_HEIGHT, !fai_start_finish);
  LoadValue(START_MAX_HEIGHT, fixed(p.start_max_height), UnitGroup::ALTITUDE);

  SetRowVisible(START_HEIGHT_REF, !fai_start_finish);
  LoadValueEnum(START_HEIGHT_REF, p.start_max_height_ref);

  SetRowVisible(FINISH_MIN_HEIGHT, !fai_start_finish);
  LoadValue(FINISH_MIN_HEIGHT, fixed(p.finish_min_height),
            UnitGroup::ALTITUDE);

  SetRowVisible(FINISH_HEIGHT_REF, !fai_start_finish);
  LoadValueEnum(FINISH_HEIGHT_REF, p.finish_min_height_ref);

  LoadValue(FAI_FINISH_HEIGHT, p.fai_finish);

  LoadValueEnum(TASK_TYPE, ftype);

  if (wTaskView != NULL)
    wTaskView->Invalidate();

  // fixed aat_min_time
  // finish_min_height
}
Пример #12
0
void TSession::LoadValue(
	const TStr &Cookie,
	const TStr &Name,
	TSessionValue *p)
{
	TStr s;
	if( LoadValue(Cookie,Name,s) ) {
		m_ssi::TStringList sl;
		while( s.Length() > 0 )
		{
			int Len = s.GetBefore("-").ToIntDef(0);
			TStr n(s.GetBefore(Len));
			sl.Add(n.CopyBefore("="),n.CopyAfter("="));
		}
		p->LoadValues(sl);
	}
}
Пример #13
0
bool PListFile::LoadArray(PListValueVector& array, const XMLElement& arrayElem)
{
    if (!arrayElem)
        return false;

    for (XMLElement valueElem = arrayElem.GetChild(); valueElem; valueElem = valueElem.GetNext())
    {
        PListValue value;

        if (!LoadValue(value, valueElem))
            return false;

        array.Push(value);
    }

    return true;
}
Пример #14
0
	bool Shader::Load(const void* wrapper)
	{
		EntityManager::Ptr entityMgr = EntityManager::Instance();
		std::string str;

		if (!LoadMemberValue(wrapper, "type", str))
		{
			FURYE << "Shader param 'type' not found!";
			return false;
		}
		m_Type = EnumUtil::ShaderTypeFromString(str);

		// read shader texture flags

		std::vector<ShaderTexture> textures;

		m_TextureFlags = 0;
		if (LoadArray(wrapper, "textures", [&](const void* node) -> bool
		{
			if (!LoadValue(node, str))
			{
				FURYE << "Shader's texture flag not found!";
				return false;
			}
			textures.push_back(EnumUtil::ShaderTextureFromString(str));
			return true;
		}))
		{
			for (auto texture : textures)
				m_TextureFlags = m_TextureFlags | (unsigned int)texture;
		}

		// end: read shader texture flags

		if (!LoadMemberValue(wrapper, "path", str))
		{
			FURYE << "Shader param 'path' not found!";
			return false;
		}
		LoadAndCompile(FileUtil::GetAbsPath() + str);

		return true;
	}
Пример #15
0
bool PListFile::LoadDict(PListValueMap& dict, const XMLElement& dictElem)
{
    if (!dictElem)
        return false;

    XMLElement keyElem = dictElem.GetChild("key");
    XMLElement valueElem = keyElem.GetNext();
    while (keyElem && valueElem)
    {
        String key = keyElem.GetValue();
        valueElem = keyElem.GetNext();

        PListValue value;
        if (!LoadValue(value, valueElem))
            return false;

        dict[key] = value;

        keyElem = valueElem.GetNext("key");
        valueElem = keyElem.GetNext();
    }

    return true;
}
Пример #16
0
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);
}
Пример #17
0
	int32_t Consensus::LoadValue(const std::string &name, int64_t &value) {
		std::string strvalue;
		int32_t ret = LoadValue(name, strvalue);
		if (ret > 0) value = utils::String::Stoi64(strvalue);
		return ret;
	}
Пример #18
0
nsresult nsMsgFilterList::LoadTextFilters(nsIInputStream *aStream)
{
  nsresult  err = NS_OK;
  uint64_t bytesAvailable;

  nsCOMPtr<nsIInputStream> bufStream;
  err = NS_NewBufferedInputStream(getter_AddRefs(bufStream), aStream, 10240);
  NS_ENSURE_SUCCESS(err, err);

  nsMsgFilterFileAttribValue attrib;
  nsCOMPtr<nsIMsgRuleAction> currentFilterAction;
  // We'd really like to move lot's of these into the objects that they refer to.
  do
  {
    nsAutoCString value;
    nsresult intToStringResult;

    char curChar;
    curChar = LoadAttrib(attrib, bufStream);
    if (curChar == (char) -1)  //reached eof
      break;
    err = LoadValue(value, bufStream);
    if (NS_FAILED(err))
      break;

    switch(attrib)
    {
    case nsIMsgFilterList::attribNone:
      if (m_curFilter)
        m_curFilter->SetUnparseable(true);
      break;
    case nsIMsgFilterList::attribVersion:
      m_fileVersion = value.ToInteger(&intToStringResult);
      if (NS_FAILED(intToStringResult))
      {
        attrib = nsIMsgFilterList::attribNone;
        NS_ASSERTION(false, "error parsing filter file version");
      }
      break;
    case nsIMsgFilterList::attribLogging:
      m_loggingEnabled = StrToBool(value);
      m_unparsedFilterBuffer.Truncate(); //we are going to buffer each filter as we read them, make sure no garbage is there
      m_startWritingToBuffer = true; //filters begin now
      break;
    case nsIMsgFilterList::attribName:  //every filter starts w/ a name
      {
        if (m_curFilter)
        {
          int32_t nextFilterStartPos = m_unparsedFilterBuffer.RFind("name");

          nsAutoCString nextFilterPart;
          nextFilterPart = Substring(m_unparsedFilterBuffer, nextFilterStartPos, m_unparsedFilterBuffer.Length());
          m_unparsedFilterBuffer.SetLength(nextFilterStartPos);

          bool unparseableFilter;
          m_curFilter->GetUnparseable(&unparseableFilter);
          if (unparseableFilter)
          {
            m_curFilter->SetUnparsedBuffer(m_unparsedFilterBuffer);
            m_curFilter->SetEnabled(false); //disable the filter because we don't know how to apply it
          }
          m_unparsedFilterBuffer = nextFilterPart;
        }
        nsMsgFilter *filter = new nsMsgFilter;
        if (filter == nullptr)
        {
          err = NS_ERROR_OUT_OF_MEMORY;
          break;
        }
        filter->SetFilterList(static_cast<nsIMsgFilterList*>(this));
        if (m_fileVersion == k45Version)
        {
          nsAutoString unicodeStr;
          err = nsMsgI18NConvertToUnicode(nsMsgI18NFileSystemCharset(),
                                          value, unicodeStr);
          if (NS_FAILED(err))
              break;

          filter->SetFilterName(unicodeStr);
        }
        else
        {
          // ### fix me - this is silly.
          PRUnichar *unicodeString =
            nsTextFormatter::smprintf(unicodeFormatter, value.get());
          filter->SetFilterName(nsDependentString(unicodeString));
          nsTextFormatter::smprintf_free(unicodeString);
        }
        m_curFilter = filter;
        m_filters.AppendElement(filter);
      }
      break;
    case nsIMsgFilterList::attribEnabled:
      if (m_curFilter)
        m_curFilter->SetEnabled(StrToBool(value));
      break;
    case nsIMsgFilterList::attribDescription:
      if (m_curFilter)
        m_curFilter->SetFilterDesc(value);
      break;
    case nsIMsgFilterList::attribType:
      if (m_curFilter)
      {
        // Older versions of filters didn't have the ability to turn on/off the
        // manual filter context, so default manual to be on in that case
        int32_t filterType = value.ToInteger(&intToStringResult);
        if (m_fileVersion < kManualContextVersion)
          filterType |= nsMsgFilterType::Manual;
        m_curFilter->SetType((nsMsgFilterTypeType) filterType);
      }
      break;
    case nsIMsgFilterList::attribScriptFile:
      if (m_curFilter)
        m_curFilter->SetFilterScript(&value);
      break;
    case nsIMsgFilterList::attribAction:
      if (m_curFilter)
      {
        nsMsgRuleActionType actionType = nsMsgFilter::GetActionForFilingStr(value);
        if (actionType == nsMsgFilterAction::None)
          m_curFilter->SetUnparseable(true);
        else
        {
          err = m_curFilter->CreateAction(getter_AddRefs(currentFilterAction));
          NS_ENSURE_SUCCESS(err, err);
          currentFilterAction->SetType(actionType);
          m_curFilter->AppendAction(currentFilterAction);
        }
      }
      break;
    case nsIMsgFilterList::attribActionValue:
      if (m_curFilter && currentFilterAction)
      {
        nsMsgRuleActionType type;
        currentFilterAction->GetType(&type);
        if (type == nsMsgFilterAction::MoveToFolder ||
              type == nsMsgFilterAction::CopyToFolder)
          err = m_curFilter->ConvertMoveOrCopyToFolderValue(currentFilterAction, value);
        else if (type == nsMsgFilterAction::ChangePriority)
        {
          nsMsgPriorityValue outPriority;
          nsresult res = NS_MsgGetPriorityFromString(value.get(), outPriority);
          if (NS_SUCCEEDED(res))
            currentFilterAction->SetPriority(outPriority);
          else
            NS_ASSERTION(false, "invalid priority in filter file");
        }
        else if (type == nsMsgFilterAction::Label)
        {
          // upgrade label to corresponding tag/keyword
          nsresult res;
          int32_t labelInt = value.ToInteger(&res);
          if (NS_SUCCEEDED(res))
          {
            nsAutoCString keyword("$label");
            keyword.Append('0' + labelInt);
            currentFilterAction->SetType(nsMsgFilterAction::AddTag);
            currentFilterAction->SetStrValue(keyword);
          }
        }
        else if (type == nsMsgFilterAction::JunkScore)
        {
          nsresult res;
          int32_t junkScore = value.ToInteger(&res);
          if (NS_SUCCEEDED(res))
            currentFilterAction->SetJunkScore(junkScore);
        }
        else if (type == nsMsgFilterAction::Forward ||
                 type == nsMsgFilterAction::Reply ||
                 type == nsMsgFilterAction::AddTag ||
                 type == nsMsgFilterAction::Custom)
        {
          currentFilterAction->SetStrValue(value);
        }
      }
      break;
    case nsIMsgFilterList::attribCondition:
      if (m_curFilter)
      {
        if (m_fileVersion == k45Version)
        {
          nsAutoString unicodeStr;
          err = nsMsgI18NConvertToUnicode(nsMsgI18NFileSystemCharset(),
                                          value, unicodeStr);
          if (NS_FAILED(err))
              break;

          char *utf8 = ToNewUTF8String(unicodeStr);
          value.Assign(utf8);
          nsMemory::Free(utf8);
        }
        err = ParseCondition(m_curFilter, value.get());
        if (err == NS_ERROR_INVALID_ARG)
          err = m_curFilter->SetUnparseable(true);
        NS_ENSURE_SUCCESS(err, err);
      }
      break;
    case nsIMsgFilterList::attribCustomId:
      if (m_curFilter && currentFilterAction)
      {
        err = currentFilterAction->SetCustomId(value);
        NS_ENSURE_SUCCESS(err, err);
      }
      break;

    }
  } while (NS_SUCCEEDED(bufStream->Available(&bytesAvailable)));

  if (m_curFilter)
  {
    bool unparseableFilter;
    m_curFilter->GetUnparseable(&unparseableFilter);
    if (unparseableFilter)
    {
      m_curFilter->SetUnparsedBuffer(m_unparsedFilterBuffer);
      m_curFilter->SetEnabled(false);  //disable the filter because we don't know how to apply it
    }
  }

  return err;
}
Пример #19
0
static void
LoadPoint(PolarShapeEditWidget::PointEditor &pe, const PolarPoint &point)
{
  LoadValue(*pe.v, point.v, UnitGroup::HORIZONTAL_SPEED);
  LoadValue(*pe.w, point.w, UnitGroup::VERTICAL_SPEED);
}
Пример #20
0
/*********************************************************************
*
* FUNCTION:			WebApiRead
*
* ARGUMENTS:		fat_index   Index of the file system table entry
*               wLen        Lenght of the request string from the web page
*               bSession    Http session
*
* RETURNS:			None
*
* DESCRIPTION:	
*
*********************************************************************/
void WebApiRead (BYTE fat_index, UINT16 wLen, BYTE bSession)
{

  	USR_DYNAMIC_FIELDS* StringFieldPtr;
    UINT16 ValuePairEnd;
  	BYTE tmpbuf [100];
    char szName [32];
    char szValue[32];
  	
  	fat_index++;      // evitar warning
 	
	  (void)strcpy((char*)sndbuf, scsHeader);

    do
    {
        ValuePairEnd = GetNameValuePair(wLen, szName, szValue);
        StringFieldPtr = FindTableName(szName, (USR_DYNAMIC_FIELDS *)(StringFields));
        if(StringFieldPtr != NULL)
        {
            if ( StringFieldPtr->fieldDataSource != NULL ) 
            {
        		    LoadValue((char*)tmpbuf, sizeof(tmpbuf),StringFieldPtr);
	              if ( (sizeof(sndbuf) - strlen((char*)sndbuf)) > strlen((char*)tmpbuf)) 
	              {
                    (void)strcat((char*)sndbuf, (char*)tmpbuf);
	              } 
	              else
	              {
                	  https[bSession].fstart    = (UINT32)https_ack_page_Bad;
                	  https[bSession].flen      = strlen((char *)https_ack_page_Bad);
                  	https[bSession].fstart   |= (UINT32)0xF0000000;
                  	https[bSession].fpoint   = 0;
                  	https[bSession].funacked = 0;
                  	return;
	              }
            } 
            else if ( StringFieldPtr->GetVarFunction != NULL ) 
            {
                (void)memset ((char*)tmpbuf, 0x00, sizeof(tmpbuf) );
                StringFieldPtr->GetVarFunction(StringFieldPtr->FunctionParam, StringFieldPtr->FunctionLen, (void*)tmpbuf);
	              if ( (sizeof(sndbuf) - strlen((char*)sndbuf)) > strlen((char*)tmpbuf)) 
	              {
                    (void)strcat((char*)sndbuf, (char*)tmpbuf);
	              } 
	              else
	              {
                	  https[bSession].fstart    = (UINT32)https_ack_page_Bad;
                	  https[bSession].flen      = strlen((char *)https_ack_page_Bad);
                  	https[bSession].fstart   |= (UINT32)0xF0000000;
                  	https[bSession].fpoint   = 0;
                  	https[bSession].funacked = 0;
                  	return;
	              }
            }
        }
        wLen -= ValuePairEnd;
        
    }while(ValuePairEnd);
    
	  (void)strcpy((char*)tmpbuf, scsTrailer);    // para poder obtener la longitud del string
  	if ( (sizeof(sndbuf) - strlen((char*)sndbuf)) > strlen((char*)tmpbuf)) 
  	{
  	    (void)strcat((char*)sndbuf, scsTrailer);
      	https[bSession].fstart   = (UINT32)sndbuf;
      	https[bSession].flen     = strlen((char*)sndbuf);
  	}
    else
    {
#if DEBUG_AT(DBG_LEVEL_3)
  if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_3)
  {                    
		  (void)sprintf((char *)udp_buf,"WebRead: buf:%d, used:%d, need:%d \n",
		                sizeof(sndbuf) ,
		                strlen((char*)sndbuf),
		                strlen((char*)tmpbuf) );
      udp_data_to_send = TRUE;
  }
#endif  		
    	  https[bSession].fstart    = (UINT32)https_ack_page_Bad;
    	  https[bSession].flen      = strlen((char *)https_ack_page_Bad);
    }
  	
  	https[bSession].fstart   |= (UINT32)0xF0000000;
  	https[bSession].fpoint   = 0;
  	https[bSession].funacked = 0;
   	
   	return;  

}
Пример #21
0
 void Update(const SwitchState &switches) {
   LoadValueEnum(USER_SWITCH, switches.user_switch);
   LoadValue(FLIGHT_MODE,
             switches.flight_mode == SwitchState::FlightMode::CIRCLING);
 }
Пример #22
0
bool Pass::Load(const void* wrapper)
{
    EntityUtil::Ptr entityUtil = EntityUtil::Instance();
    EnumUtil::Ptr enumUtil = EnumUtil::Instance();

    std::string str;

    if (!IsObject(wrapper)) return false;

    if (!LoadMemberValue(wrapper, "camera", str))
    {
        LOGE << "Pass param 'camera' not found!";
        return false;
    }
    if (auto camNode = entityUtil->FindEntity<SceneNode>(str))
        SetCameraNode(camNode);

    if (!LoadMemberValue(wrapper, "blendMode", str))
    {
        LOGE << "Pass param 'blendMode' not found!";
        return false;
    }
    SetBlendMode(enumUtil->BlendModeFromString(str));

    if (!LoadMemberValue(wrapper, "compareMode", str))
    {
        LOGE << "Pass param 'compareMode' not found!";
        return false;
    }
    SetCompareMode(enumUtil->CompareModeFromString(str));

    if (!LoadMemberValue(wrapper, "cullMode", str))
    {
        LOGE << "Pass param 'cullMode' not found!";
        return false;
    }
    SetCullMode(enumUtil->CullModeFromString(str));

    if (!LoadMemberValue(wrapper, "drawMode", str))
    {
        LOGE << "Pass param 'drawMode' not found!";
        return false;
    }
    SetDrawMode(enumUtil->DrawModeFromString(str));

    if (!LoadMemberValue(wrapper, "index", (int&)m_RenderIndex))
    {
        LOGE << "Pass param 'index' not found!";
        return false;
    }

    if (!LoadArray(wrapper, "shaders", [&](const void* node) -> bool
{
    if (!LoadValue(node, str))
        {
            LOGE << "Pass's shader name not found!";
            return false;
        }
        if (auto shader = entityUtil->FindEntity<Shader>(str))
        {
            AddShader(shader);
            return true;
        }
        else
        {
            LOGW << "Shader " << str << " not found!";
            return false;
        }
    })) return false;

    if (!LoadArray(wrapper, "input", [&](const void* node) -> bool
{
    if (!LoadValue(node, str))
        {
            LOGE << "Pass's inputTexture name not found!";
            return false;
        }
        if (auto texture = entityUtil->FindEntity<Texture>(str))
        {
            AddTexture(texture, true);
            return true;
        }
        else
        {
            LOGW << "Input Texture " << str << " not found!";
            return false;
        }
    })) return false;

    if (!LoadArray(wrapper, "output", [&](const void* node) -> bool
{
    if (!LoadValue(node, str))
        {
            LOGE << "Pass's outputTexture name not found!";
            return false;
        }
        if (auto texture = entityUtil->FindEntity<Texture>(str))
        {
            AddTexture(texture, false);
            return true;
        }
        else
        {
            LOGW << "Output Texture " << str << " not found!";
            return false;
        }
    })) return false;

    return true;
}
Пример #23
0
void
RowFormWidget::LoadValue(unsigned i, Angle value)
{
  LoadValue(i, value.Degrees());
}
Пример #24
0
/*********************************************************************
*
* FUNCTION:			DemoXML
*
* ARGUMENTS:		fat_index   Index of the file system table entry
*                   wLen        Lenght of the request string from the web page
*                   bSession    Http session
*
* RETURNS:			None
*
* DESCRIPTION:		Builds the XML tags and send it to the web page to populate the page
*              
* RESTRICTIONS:		
*
*********************************************************************/
void DemoXML(BYTE fat_index, WORD wLen, BYTE bSession)
{
//  static BYTE sndbuf[512];
  static BYTE sndbuf[450];
	BYTE tmpbuf[100];
	WORD i = 0;
	USR_DYNAMIC_INITIALIZE *  StringFieldPtr;
	
//  fat_index++;  //not used - stops compiler warning
  wLen++;				//not used - stops compiler warning
  
  
 	(void)strcpy((char*)sndbuf, scsHeader);
 	
 	switch (fat_index){
 	  case 1:
 	    StringFieldPtr = (USR_DYNAMIC_INITIALIZE *)StringStatistic;
 	    break;
 
 	  case 3:					// DataObs.xml =  Campo de observaciones
      (void)strcat((char*)sndbuf, (char*)"<par_HW_obs>");
     	eeprom_read_buffer(EE_ADDR_VER_TEXT,(UINT8*)tmpbuf,30);
      (void)strcat((char*)sndbuf, (char*)tmpbuf);
      (void)strcat((char*)sndbuf, (char*)"</par_HW_obs>\n");
      
 	    (void)strcat((char*)sndbuf, scsTrailer);
	    https[bSession].fstart   = (UINT32)sndbuf;
	    https[bSession].fstart   |= (UINT32)0xF0000000;
	    https[bSession].flen     = strlen((char*)sndbuf);
	    https[bSession].fpoint   = 0;
	    https[bSession].funacked = 0;
			return;
 	    break; 	    
 	    
#ifdef   DNP_MASTER_MODE
 	  case 4:
 	    StringFieldPtr = (USR_DYNAMIC_INITIALIZE *)Socket_01;
 	    break;

 	  case 5:
 	    StringFieldPtr = (USR_DYNAMIC_INITIALIZE *)Socket_02;
 	    break;

 	  case 6:
 	    StringFieldPtr = (USR_DYNAMIC_INITIALIZE *)Socket_03;
 	    break;
#endif

 	  default:
 	    StringFieldPtr = (USR_DYNAMIC_INITIALIZE *)StringFields;
 	    break;
 	    
 	}


	while (StringFieldPtr[i].fieldDataSource != NULL)
	{
		LoadValue((char*)tmpbuf, sizeof(tmpbuf),(USR_DYNAMIC_INITIALIZE *)&StringFieldPtr[i]);
        (void)strcat((char*)sndbuf, (char*)tmpbuf);
		i++;
	}

	(void)strcat((char*)sndbuf, scsTrailer);
	
	// ABR: agregar verificación de longitud máxima.. (ToDo)

	/* Modify structure	*/
	https[bSession].fstart   = (UINT32)sndbuf;
	https[bSession].fstart   |= (UINT32)0xF0000000;
	https[bSession].flen     = strlen((char*)sndbuf);
	https[bSession].fpoint   = 0;
	https[bSession].funacked = 0;

}