void EvaporativeFluidCoolerSingleSpeed_Impl::resetPerformanceInputMethod() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::PerformanceInputMethod, "");
   BOOST_ASSERT(result);
 }
Exemple #2
0
void ShopBuyLayer::initInterface()
{
	_widgetLayer = CSLoader::createNode( Ccs_ShopLayer_FilePath );

	if ( !_widgetLayer )
	{
		return;
	}

	addChild( _widgetLayer );

	do 
	{
		//返回
		auto ButtonBack = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, "ButtonBack" );
		setEventForNode( ButtonBack, Tag_Back );

		//金币
		auto ButtonGold = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, "ButtonGold" );
		setEventForNode( ButtonGold, Tag_LabelGold );
		//宝石
		auto ButtonGem = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, "ButtonGem" );
		setEventForNode( ButtonGem, Tag_LabelGem );
		//翅膀
		auto ButtonWing = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, "ButtonWing" );
		setEventForNode( ButtonWing, Tag_LabelWing );
		
		auto PageViewBuy = (PageView*)GameMainLayer::seekNodeByName(_widgetLayer, "PageViewBuy" );
		PageViewBuy->addEventListener( CC_CALLBACK_2(ShopBuyLayer::callFuncViewPage, this) );

		for ( int i = 1, j = 1, m = 1, n = 1; i<=CSV_MGR()->GetCsvShopList()->GetAll()->size(); i++ )
		{
			auto item =  NewDataMgr::getInstance()->getShopListWithID(i);

			switch ( item->BuyType )
			{
			case GoodsType_Gold:
				{
					auto ButtonGoldItem = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ButtonGoldItem%d", j)->getCString() );
					if ( ButtonGoldItem )
					{
						ButtonGoldItem->setTag( i );
						ButtonGoldItem->addTouchEventListener(CC_CALLBACK_2(ShopBuyLayer::callFuncBuyGoods, this));

						auto ALNumGoldItem		= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALNumGoldItem%d", j)->getCString() );
						auto ALGemNumGoldItem	= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALGemNumGoldItem%d", j)->getCString() );

						ALNumGoldItem->setString( __String::createWithFormat("%d", item->BuyNumber)->getCString() );
						ALGemNumGoldItem->setString( __String::createWithFormat("%d", item->BuyPrice)->getCString() );

						j++;
					}
				}
				break;
			case GoodsType_Gem:
				{
					auto ButtonGemItem = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ButtonGemItem%d", m)->getCString() );
					if ( ButtonGemItem )
					{
						ButtonGemItem->setTag( i );
						ButtonGemItem->addTouchEventListener(CC_CALLBACK_2(ShopBuyLayer::callFuncBuyGoods, this));

						auto ALNumGemItem		= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALNumGemItem%d", m)->getCString() );
						auto ALMonNumGoldItem	= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALMonNumGoldItem%d", m)->getCString() );

						ALNumGemItem->setString( __String::createWithFormat("%d", item->BuyNumber)->getCString() );
						ALMonNumGoldItem->setString( __String::createWithFormat("%d", item->BuyPrice)->getCString() );

						m++;
					}
				}
				break;
			case GoodsType_Life:
				{
					auto ButtonLifeItem = (Button*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ButtonLifeItem%d", n)->getCString() );
					if ( ButtonLifeItem )
					{
						ButtonLifeItem->setTag( i );
						ButtonLifeItem->addTouchEventListener(CC_CALLBACK_2(ShopBuyLayer::callFuncBuyGoods, this));

						auto ALNumLifeItem		= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALNumLifeItem%d", n)->getCString() );
						auto ALGemNumLifeItem	= (TextAtlas*)GameMainLayer::seekNodeByName(_widgetLayer, __String::createWithFormat("ALGemNumLifeItem%d", n)->getCString() );

						ALNumLifeItem->setString( __String::createWithFormat("%d", item->BuyNumber)->getCString() );
						ALGemNumLifeItem->setString( __String::createWithFormat("%d", item->BuyPrice)->getCString() );

						n++;
					}
				}
				break;
			default:
				break;
			}
			
		}

		runAction( CCSequence::create( DelayTime::create(0.1f), CallFunc::create(this, callfunc_selector(ShopBuyLayer::delayOptionLabel) ), nullptr));
		//optionLabel( (ButtonTag)getoptionLabel() );

	} while (0);
}
void UtilityCost_Ratchet_Impl::setTariffName(const std::string& str)
{
  setString(OS_UtilityCost_RatchetFields::TariffName,str);
}
Exemple #4
0
void cConfig::setDefaultServerList()
{
	setString( "LoginServer", "Shard 1", "Your Shard Name=127.0.0.1,2592" );
	flush(); // save.
}
Exemple #5
0
void cConfig::setLogPath( const QString& data )
{
	logPath_ = data;
	setString( "General", "LogPath", data );
	flush();
}
 void CoilCoolingDXVariableRefrigerantFlow_Impl::autosizeRatedAirFlowRate() {
   bool result = setString(OS_Coil_Cooling_DX_VariableRefrigerantFlowFields::RatedAirFlowRate, "autosize");
   OS_ASSERT(result);
 }
void SolarCollectorIntegralCollectorStorage_Impl::resetSurface() {
    bool result = setString(OS_SolarCollector_IntegralCollectorStorageFields::SurfaceName, "");
    OS_ASSERT(result);
}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetCapacityControl() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::CapacityControl, "");
   BOOST_ASSERT(result);
 }
 bool EvaporativeFluidCoolerSingleSpeed_Impl::setEvaporationLossMode(std::string evaporationLossMode) {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossMode, evaporationLossMode);
   return result;
 }
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetDesignEnteringAirWetbulbTemperature() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::DesignEnteringAirWetbulbTemperature, "");
   BOOST_ASSERT(result);
 }
 bool EvaporativeFluidCoolerSingleSpeed_Impl::setCapacityControl(std::string capacityControl) {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::CapacityControl, capacityControl);
   return result;
 }
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetUserSpecifiedDesignCapacity() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::UserSpecifiedDesignCapacity, "");
   BOOST_ASSERT(result);
 }
 void EvaporativeFluidCoolerSingleSpeed_Impl::autosizeDesignWaterFlowRate() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::DesignWaterFlowRate, "autosize");
   BOOST_ASSERT(result);
 }
 void EvaporativeFluidCoolerSingleSpeed_Impl::autosizeUfactorTimesAreaValueatDesignAirFlowRate() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::UfactorTimesAreaValueatDesignAirFlowRate, "autosize");
   BOOST_ASSERT(result);
 }
Exemple #15
0
void DoubleLabel::setPrecision(int v)
{
	_precision = v;
	setString(val);
}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetEvaporationLossFactor() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::EvaporationLossFactor, "");
   BOOST_ASSERT(result);
 }
Exemple #17
0
void DoubleLabel::setOff(double v)
{
	_off = v;
	setString(val);
}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetDriftLossPercent() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::DriftLossPercent, "");
   BOOST_ASSERT(result);
 }
boost::optional<IdfObject> ForwardTranslator::translateCoilCoolingDXMultiSpeed( CoilCoolingDXMultiSpeed & modelObject )
{
  boost::optional<std::string> s;
  boost::optional<double> value;

  // Name
  IdfObject idfObject = createRegisterAndNameIdfObject(openstudio::IddObjectType::Coil_Cooling_DX_MultiSpeed, modelObject);

  // AvailabilityScheduleName
  if( auto schedule = modelObject.availabilitySchedule() ) {
    if( auto _schedule = translateAndMapModelObject(schedule.get()) ) {
      idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::AvailabilityScheduleName,_schedule->name().get());
    }
  }

  // AirInletNodeName
  if( auto node = modelObject.inletModelObject() ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::AirInletNodeName,node->name().get());
  }  

  // AirOutletNodeName
  if( auto node = modelObject.outletModelObject() ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::AirOutletNodeName,node->name().get());
  }
  
  // CondenserAirInletNodeName

  // CondenserType
  if( (s = modelObject.condenserType()) ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::CondenserType,s.get());
  }

  // SupplyWaterStorageTankName
  
  // CondensateCollectionWaterStorageTankName
  
  // ApplyPartLoadFractiontoSpeedsGreaterthan1
  
  if( modelObject.applyPartLoadFractiontoSpeedsGreaterthan1() ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::ApplyPartLoadFractiontoSpeedsGreaterthan1,"Yes");
  } else {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::ApplyPartLoadFractiontoSpeedsGreaterthan1,"No");
  }
  
  // ApplyLatentDegradationtoSpeedsGreaterthan1
  if( modelObject.applyLatentDegradationtoSpeedsGreaterthan1() ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::ApplyLatentDegradationtoSpeedsGreaterthan1,"Yes");
  } else {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::ApplyLatentDegradationtoSpeedsGreaterthan1,"No");
  }
  
  // CrankcaseHeaterCapacity
  if( (value = modelObject.crankcaseHeaterCapacity()) ) {
    idfObject.setDouble(Coil_Cooling_DX_MultiSpeedFields::CrankcaseHeaterCapacity,value.get());
  }
  
  // MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation
  if( (value = modelObject.maximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation()) ) {
    idfObject.setDouble(Coil_Cooling_DX_MultiSpeedFields::MaximumOutdoorDryBulbTemperatureforCrankcaseHeaterOperation,value.get());
  }
  
  // BasinHeaterCapacity
  if( (value = modelObject.basinHeaterCapacity()) ) {
    idfObject.setDouble(Coil_Cooling_DX_MultiSpeedFields::BasinHeaterCapacity,value.get());
  }
  
  // BasinHeaterSetpointTemperature
  if( (value = modelObject.basinHeaterSetpointTemperature()) ) {
    idfObject.setDouble(Coil_Cooling_DX_MultiSpeedFields::BasinHeaterSetpointTemperature,value.get());
  }
  
  // BasinHeaterOperatingScheduleName
  if( auto schedule = modelObject.basinHeaterOperatingSchedule() ) {
    if( auto _schedule = translateAndMapModelObject(schedule.get()) ) {
      idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::BasinHeaterOperatingScheduleName,_schedule->name().get());
    }
  }
  
  // FuelType
  if( (s = modelObject.fuelType()) ) {
    idfObject.setString(Coil_Cooling_DX_MultiSpeedFields::FuelType,s.get());
  }
  
  // NumberofSpeeds
  if( auto num = modelObject.stages().size() ) {
    idfObject.setInt(Coil_Cooling_DX_MultiSpeedFields::NumberofSpeeds,num);
  }

  for( auto stage: modelObject.stages() ) {
    auto eg = idfObject.pushExtensibleGroup();
  
    // SpeedGrossRatedTotalCoolingCapacity
    if( stage.isGrossRatedTotalCoolingCapacityAutosized() ) {
      eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedGrossRatedTotalCoolingCapacity,"AutoSize");
    } else if( (value = stage.grossRatedTotalCoolingCapacity()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedGrossRatedTotalCoolingCapacity,value.get());
    }
  
    // SpeedGrossRatedSensibleHeatRatio
    if( stage.isGrossRatedSensibleHeatRatioAutosized() ) {
      eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedGrossRatedSensibleHeatRatio,"AutoSize");
    } else if( (value = stage.grossRatedSensibleHeatRatio()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedGrossRatedSensibleHeatRatio,value.get());
    }
  
    // SpeedGrossRatedCoolingCOP
    if( (value = stage.grossRatedCoolingCOP()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedGrossRatedCoolingCOP,value.get());
    }
  
    // SpeedRatedAirFlowRate
    if( stage.isRatedAirFlowRateAutosized() ) {
      eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatedAirFlowRate,"AutoSize");
    } else if( (value = stage.ratedAirFlowRate()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatedAirFlowRate,value.get());
    }
  
    // RatedEvaporatorFanPowerPerVolumeFlowRate
    if( (value = stage.ratedEvaporatorFanPowerPerVolumeFlowRate()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::RatedEvaporatorFanPowerPerVolumeFlowRate,value.get());
    }
  
    // SpeedTotalCoolingCapacityFunctionofTemperatureCurveName
    { 
      auto curve = stage.totalCoolingCapacityFunctionofTemperatureCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedTotalCoolingCapacityFunctionofTemperatureCurveName,_curve->name().get());
      }
    }
  
    // SpeedTotalCoolingCapacityFunctionofFlowFractionCurveName
    { 
      auto curve = stage.totalCoolingCapacityFunctionofFlowFractionCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedTotalCoolingCapacityFunctionofFlowFractionCurveName,_curve->name().get());
      }
    }
  
    // SpeedEnergyInputRatioFunctionofTemperatureCurveName
    { 
      auto curve = stage.energyInputRatioFunctionofTemperatureCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedEnergyInputRatioFunctionofTemperatureCurveName,_curve->name().get());
      }
    }
  
    // SpeedEnergyInputRatioFunctionofFlowFractionCurveName
    { 
      auto curve = stage.energyInputRatioFunctionofFlowFractionCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedEnergyInputRatioFunctionofFlowFractionCurveName,_curve->name().get());
      }
    }
  
    // SpeedPartLoadFractionCorrelationCurveName
    { 
      auto curve = stage.partLoadFractionCorrelationCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedPartLoadFractionCorrelationCurveName,_curve->name().get());
      }
    }
  
    // SpeedNominalTimeforCondensateRemovaltoBegin
    if( (value = stage.nominalTimeforCondensateRemovaltoBegin()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedNominalTimeforCondensateRemovaltoBegin,value.get());
    }
  
    // SpeedRatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity
    if( (value = stage.ratioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatioofInitialMoistureEvaporationRateandSteadyStateLatentCapacity,value.get()); 
    }
  
    // SpeedMaximumCyclingRate
    if( (value = stage.maximumCyclingRate()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedMaximumCyclingRate,value.get());
    }
  
    // SpeedLatentCapacityTimeConstant
    if( (value = stage.latentCapacityTimeConstant()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedLatentCapacityTimeConstant,value.get());
    }
  
    // SpeedRatedWasteHeatFractionofPowerInput
    if( (value = stage.ratedWasteHeatFractionofPowerInput()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatedWasteHeatFractionofPowerInput,value.get());
    }
  
    // SpeedWasteHeatFunctionofTemperatureCurveName
    {
      auto curve = stage.wasteHeatFunctionofTemperatureCurve();
      if( auto _curve = translateAndMapModelObject(curve) ) {
        eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedWasteHeatFunctionofTemperatureCurveName,_curve->name().get());
      }
    }
  
    // SpeedEvaporativeCondenserEffectiveness
    if( (value = stage.evaporativeCondenserEffectiveness()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedEvaporativeCondenserEffectiveness,value.get());
    }
  
    // SpeedEvaporativeCondenserAirFlowRate
    if( stage.isEvaporativeCondenserAirFlowRateAutosized() ) {
      eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedEvaporativeCondenserAirFlowRate,"AutoSize");
    } else if( (value = stage.evaporativeCondenserAirFlowRate()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedEvaporativeCondenserAirFlowRate,value.get());
    }
  
    // SpeedRatedEvaporativeCondenserPumpPowerConsumption
    if( stage.isRatedEvaporativeCondenserPumpPowerConsumptionAutosized() ) {
      eg.setString(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatedEvaporativeCondenserPumpPowerConsumption,"AutoSize");
    } else if( (value = stage.ratedEvaporativeCondenserPumpPowerConsumption()) ) {
      eg.setDouble(Coil_Cooling_DX_MultiSpeedExtensibleFields::SpeedRatedEvaporativeCondenserPumpPowerConsumption,value.get());
    }
  }

  return idfObject;
}
 bool EvaporativeFluidCoolerSingleSpeed_Impl::setBlowdownCalculationMode(std::string blowdownCalculationMode) {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::BlowdownCalculationMode, blowdownCalculationMode);
   return result;
 }
void SolarCollectorIntegralCollectorStorage_Impl::resetMaximumFlowRate() {
    bool result = setString(OS_SolarCollector_IntegralCollectorStorageFields::MaximumFlowRate, "");
    OS_ASSERT(result);
}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetBlowdownCalculationMode() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::BlowdownCalculationMode, "");
   BOOST_ASSERT(result);
 }
Exemple #23
0
void cConfig::setMulPath( const QString& data )
{
	mulPath_ = data;
	setString( "General", "MulPath", data );
	flush();
}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetBlowdownConcentrationRatio() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::BlowdownConcentrationRatio, "");
   BOOST_ASSERT(result);
 }
	TString TString::operator= (TString inp)
		{
			setString(inp.Str);
			return Str;
		}
 void EvaporativeFluidCoolerSingleSpeed_Impl::resetBlowdownMakeupWaterUsageSchedule() {
   bool result = setString(OS_EvaporativeFluidCooler_SingleSpeedFields::BlowdownMakeupWaterUsageScheduleName, "");
   BOOST_ASSERT(result);
 }
void UtilityCost_Ratchet_Impl::setOffsetValueOrVariableName(const std::string& str)
{
  setString(OS_UtilityCost_RatchetFields::OffsetValueorVariableName,str);
}
Exemple #28
0
void CYahooProto::ext_got_picture(const char *me, const char *who, const char *pic_url, int cksum, int type)
{
	MCONTACT hContact = 0;

	LOG(("[ext_yahoo_got_picture] for %s with url %s (checksum: %d) type: %d", who, pic_url, cksum, type));

	/*
	  Type:

	  1 - Send Avatar Info
	  2 - Got Avatar Info
	  3 - YIM6 didn't like my avatar? Expired? We need to invalidate and re-load
	  */
	switch (type) {
	case 1:
		{
			int cksum = 0;
			DBVARIANT dbv;

			/* need to send avatar info */
			if (!getByte("ShowAvatars", 1)) {
				LOG(("[ext_yahoo_got_picture] We are not using/showing avatars!"));
				yahoo_send_picture_update(m_id, who, 0); // no avatar (disabled)
				return;
			}

			LOG(("[ext_yahoo_got_picture] Getting ready to send info!"));
			/* need to read CheckSum */
			cksum = getDword("AvatarHash", 0);
			if (cksum) {
				if (!getString("AvatarURL", &dbv)) {
					LOG(("[ext_yahoo_got_picture] Sending url: %s checksum: %d to '%s'!", dbv.pszVal, cksum, who));
					//void yahoo_send_picture_info(int id, const char *me, const char *who, const char *pic_url, int cksum)
					yahoo_send_picture_info(m_id, who, 2, dbv.pszVal, cksum);
					db_free(&dbv);
					break;
				}
				else
					LOG(("No AvatarURL???"));

				/*
				 * Try to re-upload the avatar
				 */
				if (getByte("AvatarUL", 0) != 1) {
					// NO avatar URL??
					if (!getTString("AvatarFile", &dbv)) {
						struct _stat statbuf;

						if (_tstat(dbv.ptszVal, &statbuf) != 0) {
							LOG(("[ext_yahoo_got_picture] Avatar File Missing? Can't find file: %s", dbv.ptszVal));
						}
						else {
							setString("AvatarInv", who);
							SendAvatar(dbv.ptszVal);
						}

						db_free(&dbv);
					}
					else {
						LOG(("[ext_yahoo_got_picture] No Local Avatar File??? "));
					}
				}
				else
					LOG(("[ext_yahoo_got_picture] Another avatar upload in progress?"));
			}
		}
		break;
	case 2: /*
			  * We got Avatar Info for our buddy.
			  */
		if (!getByte("ShowAvatars", 1)) {
			LOG(("[ext_yahoo_got_picture] We are not using/showing avatars!"));
			return;
		}

		/* got avatar info, so set miranda up */
		hContact = getbuddyH(who);
		if (!hContact) {
			LOG(("[ext_yahoo_got_picture] Buddy not on my buddy list?."));
			return;
		}

		if (!cksum && pic_url) {
			const char *chk = strstr(pic_url, "chksum=");
			if (chk)
				cksum = strtol(chk + 7, NULL, 10);
		}

		if (!cksum || cksum == -1) {
			LOG(("[ext_yahoo_got_picture] Resetting avatar."));
			setDword(hContact, "PictCK", 0);
			reset_avatar(hContact);
		}
		else {
			if (pic_url == NULL) {
				LOG(("[ext_yahoo_got_picture] WARNING: Empty URL for avatar?"));
				return;
			}

			TCHAR z[1024];
			GetAvatarFileName(hContact, z, 1024, getByte(hContact, "AvatarType", 0));

			if (getDword(hContact, "PictCK", 0) != cksum || _taccess(z, 0) != 0) {

				debugLogA("[ext_yahoo_got_picture] Checksums don't match or avatar file is missing. Current: %d, New: %d",
					getDword(hContact, "PictCK", 0), cksum);

				struct avatar_info *avt = (avatar_info*)malloc(sizeof(struct avatar_info));
				avt->who = strdup(who);
				avt->pic_url = strdup(pic_url);
				avt->cksum = cksum;

				ForkThread(&CYahooProto::recv_avatarthread, avt);
			}
		}

		break;
	case 3:
		// Our Avatar is not good anymore? Need to re-upload??
		/* who, pic_url, cksum */
		{
			int mcksum = 0;
			DBVARIANT dbv;

			/* need to send avatar info */
			if (!getByte("ShowAvatars", 1)) {
				LOG(("[ext_yahoo_got_picture] We are not using/showing avatars!"));
				yahoo_send_picture_update(m_id, who, 0); // no avatar (disabled)
				return;
			}

			LOG(("[ext_yahoo_got_picture] Getting ready to send info!"));
			/* need to read CheckSum */
			mcksum = getDword("AvatarHash", 0);
			if (mcksum == 0) {
				/* this should NEVER Happen??? */
				LOG(("[ext_yahoo_got_picture] No personal checksum? and Invalidate?!"));
				yahoo_send_picture_update(m_id, who, 0); // no avatar (disabled)
				return;
			}

			LOG(("[ext_yahoo_got_picture] My Checksum: %d", mcksum));

			if (!getString("AvatarURL", &dbv)) {
				if (mir_strcmpi(pic_url, dbv.pszVal) == 0) {
					DBVARIANT dbv2;
					/*time_t  ts;
					DWORD	ae;*/

					if (mcksum != cksum)
						LOG(("[ext_yahoo_got_picture] WARNING: Checksums don't match!"));

					/*time(&ts);
					ae = getDword("AvatarExpires", 0);

					if (ae != 0 && ae > (ts - 300)) {
					LOG(("[ext_yahoo_got_picture] Current Time: %lu Expires: %lu ", ts, ae));
					LOG(("[ext_yahoo_got_picture] We just reuploaded! Stop screwing with Yahoo FT. "));

					// don't leak stuff
					db_free(&dbv);

					break;
					}*/

					LOG(("[ext_yahoo_got_picture] Buddy: %s told us this is bad??Expired??. Re-uploading", who));
					delSetting("AvatarURL");

					if (!getTString("AvatarFile", &dbv2)) {
						setString("AvatarInv", who);
						SendAvatar(dbv2.ptszVal);
						db_free(&dbv2);
					}
					else {
						LOG(("[ext_yahoo_got_picture] No Local Avatar File??? "));
					}
				}
				else {
					LOG(("[ext_yahoo_got_picture] URL doesn't match? Tell them the right thing!!!"));
					yahoo_send_picture_info(m_id, who, 2, dbv.pszVal, mcksum);
				}
				// don't leak stuff
				db_free(&dbv);
			}
			else {
				LOG(("[ext_yahoo_got_picture] no AvatarURL?"));
			}
		}
		break;
	default:
		LOG(("[ext_yahoo_got_picture] Unknown request/packet type exiting!"));
	}

	LOG(("ext_yahoo_got_picture exiting"));
}
void UtilityCost_Ratchet_Impl::setBaselineSourceVariable(const std::string& str)
{
  setString(OS_UtilityCost_RatchetFields::BaselineSourceVariable,str);
}
 void SiteWaterMainsTemperature_Impl::resetMaximumDifferenceInMonthlyAverageOutdoorAirTemperatures() {
   bool result = setString(OS_Site_WaterMainsTemperatureFields::MaximumDifferenceInMonthlyAverageOutdoorAirTemperatures, "");
   OS_ASSERT(result);
 }