void Player::UpdateBlockPercentage()
{
// No block
float value = 0.0f;
if (CanBlock())
{
// Base value
value = 5.0f;
// Increase from SPELL_AURA_MOD_BLOCK_PERCENT aura
value += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT);
// Custom MoP Script
// 76671 - Mastery : Divine Bulwark - Block Percentage
if (GetTypeId() == TYPEID_PLAYER && HasAura(76671))
value += GetFloatValue(PLAYER_MASTERY);
// Custom MoP Script
// 76857 - Mastery : Critical Block - Block Percentage
if (GetTypeId() == TYPEID_PLAYER && HasAura(76857))
value += GetFloatValue(PLAYER_MASTERY) / 2.0f;
// Increase from rating
value += GetRatingBonusValue(CR_BLOCK);
if (sWorld->getBoolConfig(CONFIG_STATS_LIMITS_ENABLE))
value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_BLOCK) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_BLOCK) : value;
value = value < 0.0f ? 0.0f : value;
}
SetStatFloatValue(PLAYER_BLOCK_PERCENTAGE, value);
}
void GameObject::SaveToFile(std::stringstream & name)
{
std::stringstream ss;
ss << "REPLACE INTO gameobject_spawns VALUES("
<< ((m_spawn == NULL) ? 0 : m_spawn->id) << ","
<< GetEntry() << ","
<< GetMapId() << ","
<< GetPositionX() << ","
<< GetPositionY() << ","
<< GetPositionZ() << ","
<< GetOrientation() << ","
<< GetFloatValue(GAMEOBJECT_ROTATION) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_01) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_02) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_03) << ","
<< GetUInt32Value(GAMEOBJECT_STATE) << ","
<< GetUInt32Value(GAMEOBJECT_FLAGS) << ","
<< GetUInt32Value(GAMEOBJECT_FACTION) << ","
<< GetFloatValue(OBJECT_FIELD_SCALE_X) << ","
<< "0)";
FILE * OutFile;
OutFile = fopen(name.str().c_str(), "wb");
if (!OutFile) return;
fwrite(ss.str().c_str(),1,ss.str().size(),OutFile);
fclose(OutFile);
}
void GameObject::SaveToDB()
{
std::ostringstream ss;
sDatabase.BeginTransaction();
sDatabase.PExecute("DELETE FROM `gameobject` WHERE `guid` = '%u'", m_DBTableGuid);
const GameObjectInfo *goI = GetGOInfo();
if (goI)
{
ss << "INSERT INTO `gameobject` VALUES ( "
<< m_DBTableGuid << ", "
<< GetUInt32Value (OBJECT_FIELD_ENTRY) << ", "
<< GetMapId() << ", "
<< GetFloatValue(GAMEOBJECT_POS_X) << ", "
<< GetFloatValue(GAMEOBJECT_POS_Y) << ", "
<< GetFloatValue(GAMEOBJECT_POS_Z) << ", "
<< GetFloatValue(GAMEOBJECT_FACING) << ", "
<< GetFloatValue(GAMEOBJECT_ROTATION) << ", "
<< GetFloatValue(GAMEOBJECT_ROTATION+1) << ", "
<< GetFloatValue(GAMEOBJECT_ROTATION+2) << ", "
<< GetFloatValue(GAMEOBJECT_ROTATION+3) << ", "
<< lootid <<", "
<< m_respawnDelayTime << ", "
<< GetUInt32Value (GAMEOBJECT_ANIMPROGRESS) << ", "
<< GetUInt32Value (GAMEOBJECT_DYN_FLAGS) << ")";;
sDatabase.Execute( ss.str( ).c_str( ) );
}
sDatabase.CommitTransaction();
}
void Player::UpdateArmor()
{
float value = 0.0f;
UnitMods unitMod = UNIT_MOD_ARMOR;
value = GetModifierValue(unitMod, BASE_VALUE); // base armor (from items)
value *= GetModifierValue(unitMod, BASE_PCT); // armor percent from items
value += GetModifierValue(unitMod, TOTAL_VALUE);
// Custom MoP Script
// 77494 - Mastery : Nature's Guardian
if (GetTypeId() == TYPEID_PLAYER && HasAura(77494))
{
float Mastery = 1.0f + GetFloatValue(PLAYER_MASTERY) * 1.25f / 100.0f;
value *= Mastery;
}
//add dynamic flat mods
AuraEffectList const& mResbyIntellect = GetAuraEffectsByType(SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT);
for (AuraEffectList::const_iterator i = mResbyIntellect.begin(); i != mResbyIntellect.end(); ++i)
{
if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
value += CalculatePct(GetStat(Stats((*i)->GetMiscValueB())), (*i)->GetAmount());
}
value *= GetModifierValue(unitMod, TOTAL_PCT);
SetArmor(int32(value));
UpdateAttackPowerAndDamage(); // armor dependent auras update for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR
}
void Player::UpdateManaRegen()
{
if(getPowerType() != POWER_MANA && getClass() != CLASS_DRUID)
return;
// Mana regen from spirit
float spirit_regen = OCTRegenMPPerSpirit();
// Apply PCT bonus from SPELL_AURA_MOD_POWER_REGEN_PERCENT aura on spirit base regen
spirit_regen *= GetTotalAuraMultiplierByMiscValue(SPELL_AURA_MOD_POWER_REGEN_PERCENT, POWER_MANA);
// SpiritRegen(SPI, INT, LEVEL) = (0.001 + (SPI x sqrt(INT) x BASE_REGEN[LEVEL])) x 5
if (GetStat(STAT_INTELLECT) > 0.0f)
spirit_regen *= sqrt(GetStat(STAT_INTELLECT));
// CombatRegen = 5% of Base Mana
float base_regen = GetCreateMana() * 0.01f + GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) / 5.0f;
// Set regen rate in cast state apply only on spirit based regen
int32 modManaRegenInterrupt = GetTotalAuraModifier(SPELL_AURA_MOD_MANA_REGEN_INTERRUPT);
SetStatFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER, base_regen + CalculatePct(spirit_regen, modManaRegenInterrupt));
if (getClass() == CLASS_HUNTER)
SetStatFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER, (6.0 * ((1.0f - GetFloatValue(PLAYER_FIELD_MOD_RANGED_HASTE)) + 1)) - 5.0f );
else
SetStatFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER, 0.001f + spirit_regen + base_regen);
}
wxGISTask::wxGISTask(const wxXmlNode* pIniNode)
{
//load
m_nId = GetDecimalValue(pIniNode, wxT("id"), wxNOT_FOUND);
m_sName = pIniNode->GetAttribute(wxT("name"), NONAME);
m_sDescription = pIniNode->GetAttribute(wxT("desc"), NONAME);
m_sCat = pIniNode->GetAttribute(wxT("cat"), NONAME);
m_nState = (wxGISEnumTaskStateType)GetDecimalValue(pIniNode, wxT("state"), enumGISTaskUnk);
m_nPriority = GetDecimalValue(pIniNode, wxT("prio"), wxNOT_FOUND);
m_dtBeg = GetDateValue(pIniNode, wxT("beg"), wxDateTime::Now());
m_dtEnd = GetDateValue(pIniNode, wxT("end"), wxDateTime::Now());
long nVolumeHi = GetDecimalValue(pIniNode, wxT("vol_hi"), 0);
long nVolumeLo = GetDecimalValue(pIniNode, wxT("vol_lo"), 0);
m_nVolume = wxULongLong(nVolumeHi, nVolumeLo);
m_dfDone = GetFloatValue(pIniNode, wxT("done"), 0.0);
m_pParams = NULL;
wxXmlNode *Children = pIniNode->GetChildren();
while(Children)
{
if(Children->GetName().IsSameAs(wxT("params"), false))
{
if(m_pParams)
wxDELETE(m_pParams);
m_pParams = new wxXmlNode(*Children);
}
//else if(Children->GetName().IsSameAs(wxT("messages"), false))
//{
// LoadMessages(Children);
//}
Children = Children->GetNext();
}
}
void wxGISTask::ChangeTask(const wxXmlNode* pTaskNode)
{
//load
m_sName = pTaskNode->GetAttribute(wxT("name"), m_sName);
m_sDescription = pTaskNode->GetAttribute(wxT("desc"), m_sDescription);
m_sCat = pTaskNode->GetAttribute(wxT("cat"), m_sCat);
m_nState = (wxGISEnumTaskStateType)GetDecimalValue(pTaskNode, wxT("state"), m_nState);
m_nPriority = GetDecimalValue(pTaskNode, wxT("prio"), m_nPriority);
m_dtBeg = GetDateValue(pTaskNode, wxT("beg"), m_dtBeg);
m_dtEnd = GetDateValue(pTaskNode, wxT("end"), m_dtEnd);
long nVolHi = GetDecimalValue(pTaskNode, wxT("vol_hi"), (long)m_nVolume.GetHi());
long nVolLo = GetDecimalValue(pTaskNode, wxT("vol_lo"), (long)m_nVolume.GetLo());
m_nVolume = wxULongLong(nVolHi, nVolLo);
m_dfDone = GetFloatValue(pTaskNode, wxT("done"), m_dfDone);
wxXmlNode *Children = pTaskNode->GetChildren();
while(Children)
{
if(Children->GetName().IsSameAs(wxT("params"), false))
{
if(m_pParams)
wxDELETE(m_pParams);
m_pParams = new wxXmlNode(*Children);
}
//else if(Children->GetName().IsSameAs(wxT("messages"), false))
//{
// LoadMessages(Children);
//}
Children = Children->GetNext();
}
}
bool Var::Equals(Var* rvalue) {
switch(type) {
case vtInt: {
return GetIntValue() == rvalue->GetIntValue();
}
case vtFloat: {
return GetFloatValue() == rvalue->GetFloatValue();
}
case vtString: {
char* lvaluetext = GetStringValue();
char* rvaluetext = rvalue->GetStringValue();
bool result = !strcmp(lvaluetext,rvaluetext);
delete[] lvaluetext;
delete[] rvaluetext;
return result;
}
case vtFloat3: {
return float3value == rvalue->float3value;
}
case vtObject: {
return objectvalue == rvalue->objectvalue; // compare pointers...
}
default: {
return false;
}
}
}
void GameObject::SaveToDB()
{
std::stringstream ss;
ss << "INSERT INTO gameobject_spawns VALUES("
<< spawnid << ","
<< GetEntry() << ","
<< GetMapId() << ","
<< GetPositionX() << ","
<< GetPositionY() << ","
<< GetPositionZ() << ","
<< GetOrientation() << ","
<< GetFloatValue(GAMEOBJECT_ROTATION) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_01) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_02) << ","
<< GetFloatValue(GAMEOBJECT_ROTATION_03) << ","
<< GetUInt32Value(GAMEOBJECT_STATE) << ","
<< GetUInt32Value(GAMEOBJECT_FLAGS) << ","
<< GetUInt32Value(GAMEOBJECT_FACTION) << ","
<< GetFloatValue(OBJECT_FIELD_SCALE_X) << ","
<< "0)";
WorldDatabase.Execute(ss.str().c_str());
/* std::stringstream ss;
if (!m_sqlid)
m_sqlid = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
ss << "DELETE FROM gameobjects WHERE id=" << m_sqlid;
sDatabase.Execute(ss.str().c_str());
ss.rdbuf()->str("");
ss << "INSERT INTO gameobjects VALUES ( "
<< m_sqlid << ", "
<< m_position.x << ", "
<< m_position.y << ", "
<< m_position.z << ", "
<< m_position.o << ", "
<< GetZoneId() << ", "
<< GetMapId() << ", '";
for( uint32 index = 0; index < m_valuesCount; index ++ )
ss << GetUInt32Value(index) << " ";
ss << "', ";
ss << GetEntry() << ", 0, 0)";
sDatabase.Execute( ss.str( ).c_str( ) );*/
}
void Player::UpdateManaRegen()
{
if (GetPowerIndex(POWER_MANA) == MAX_POWERS)
return;
// Mana regen from spirit
float spirit_regen = OCTRegenMPPerSpirit();
float pctPerSec = 0.004f;
float netherBonus = 1.0f;
float regenRate = 1.0f;
uint32 baseMana = GetCreateMana();
// CombatRegen = 2-5% of Base Mana depending on class
// Warlock and Mage have 5% default regen
switch (getClass())
{
case CLASS_MAGE:
// According to reports by QA, Nether Attunement should give a 65% regen boost
if (HasAura(117957))
netherBonus = 1.13f;
case CLASS_WARLOCK:
// Base percent per second is higher for mages and warlocks
pctPerSec = 0.01f;
// Additionally add haste to the mana regen for Warlocks and Mages
if (HasAuraType(SPELL_AURA_MOD_MANA_REGEN_BY_HASTE))
regenRate = GetFloatValue(UNIT_MOD_HASTE_REGEN);
break;
case CLASS_DRUID:
// Druids should be calculated based off their mana pool after they gain Natural Insight
if (HasAura(112857))
baseMana *= 5;
break;
case CLASS_PALADIN:
// Paladins should be calculated based off their mana pool after they gain Holy Insight
if (HasAura(112859))
baseMana *= 5;
break;
case CLASS_SHAMAN:
// Shamans should be calculated based off their mana pool after they gain Spiritual Insight (also elemental shamans)
if (HasAura(112858) || HasAura(123099))
baseMana *= 5;
break;
default:
break;
}
float base_regen = (baseMana * pctPerSec * netherBonus) / regenRate + (GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) / 5.0f);
// Set regen rate in cast state apply only on spirit based regen
int32 modManaRegenInterrupt = GetTotalAuraModifier(SPELL_AURA_MOD_MANA_REGEN_INTERRUPT);
// Questionable
base_regen *= GetTotalAuraMultiplierByMiscValue(SPELL_AURA_MOD_POWER_REGEN_PERCENT, POWER_MANA);
SetStatFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER + GetPowerIndex(POWER_MANA), base_regen + CalculatePct(spirit_regen, modManaRegenInterrupt));
SetStatFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER + GetPowerIndex(POWER_MANA), 0.001f + spirit_regen + base_regen);
}
void UARAttributeBaseComponent::ChangeAttribute(float ModValue, FName AttributeName, TEnumAsByte<EAttrOp> OpType)
{
float attrValue = GetFloatValue(AttributeName);
ModifiedAttribute.ActuallDamage = ModValue;
ModifiedAttribute.AttributeName = AttributeName;
SetAttributeModified(ModValue, AttributeName);
SetFloatValue(AttributeOp(ModValue, attrValue, OpType), AttributeName);
}
float CGUISliderControl::GetProportion(RangeSelector selector /* = RangeSelectorLower */) const
{
if (m_iType == SPIN_CONTROL_TYPE_FLOAT)
return (GetFloatValue(selector) - m_fStart) / (m_fEnd - m_fStart);
else if (m_iType == SPIN_CONTROL_TYPE_INT)
return (float)(GetIntValue(selector) - m_iStart) / (float)(m_iEnd - m_iStart);
return 0.01f * GetPercentage(selector);
}
void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bool addTotalPct, float& min_damage, float& max_damage)
{
UnitMods unitMod;
switch (attType)
{
case BASE_ATTACK:
default:
unitMod = UNIT_MOD_DAMAGE_MAINHAND;
break;
case OFF_ATTACK:
unitMod = UNIT_MOD_DAMAGE_OFFHAND;
break;
case RANGED_ATTACK:
unitMod = UNIT_MOD_DAMAGE_RANGED;
break;
}
float att_speed = GetAPMultiplier(attType, normalized);
float base_value = GetModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType)/ 14.0f * att_speed;
float base_pct = GetModifierValue(unitMod, BASE_PCT);
float total_value = GetModifierValue(unitMod, TOTAL_VALUE);
float total_pct = addTotalPct ? GetModifierValue(unitMod, TOTAL_PCT) * GetFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT) : 1.0f;
float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);
float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);
if (IsInFeralForm()) //check if player is druid and in cat or bear forms
{
uint8 lvl = getLevel();
if (lvl > 60)
lvl = 60;
weapon_mindamage = lvl*0.85f*att_speed;
weapon_maxdamage = lvl*1.25f*att_speed;
}
else if (!CanUseAttackType(attType)) //check if player not in form but still can't use (disarm case)
{
//cannot use ranged/off attack, set values to 0
if (attType != BASE_ATTACK)
{
min_damage = 0;
max_damage = 0;
return;
}
weapon_mindamage = BASE_MINDAMAGE;
weapon_maxdamage = BASE_MAXDAMAGE;
}
else if (attType == RANGED_ATTACK) //add ammo DPS to ranged damage
{
weapon_mindamage += GetAmmoDPS() * att_speed;
weapon_maxdamage += GetAmmoDPS() * att_speed;
}
min_damage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;
max_damage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;
}
void QCmdParser::GetLedTemperature( QByteArray& data, QString& strInfo )
{
if ( 3 > data.length( ) ) {
return;
}
GetFloatValue( data, strInfo );
qDebug( ) << Q_FUNC_INFO << endl;
}
float UGAAttributesBase::AttributeOperation(const FGAAttribute& AttributeIn, float ValueIn, EGAAttributeMod Operation)
{
switch (Operation)
{
case EGAAttributeMod::Add:
return AddAttributeFloat(GetFloatValue(AttributeIn), ValueIn); //don't want to set.
case EGAAttributeMod::Subtract:
return SubtractAttributeFloat(GetFloatValue(AttributeIn), ValueIn);
case EGAAttributeMod::Multiply:
return MultiplyAttributeFloat(GetFloatValue(AttributeIn), ValueIn);
case EGAAttributeMod::Divide:
return DivideAttributeFloat(GetFloatValue(AttributeIn), ValueIn);
case EGAAttributeMod::Set:
return SetFloatValue(AttributeIn, ValueIn);
default:
return 0;
}
return 0;
}
bool Var::Less(Var* rvalue) {
switch(type) {
case vtInt: {
return GetIntValue() < rvalue->GetIntValue();
}
case vtFloat: {
return GetFloatValue() < rvalue->GetFloatValue();
}
default: {
return false;
}
}
}
double nsCSSValue::GetAngleValueInRadians() const
{
double angle = GetFloatValue();
switch (GetUnit()) {
case eCSSUnit_Radian: return angle;
case eCSSUnit_Degree: return angle * M_PI / 180.0;
case eCSSUnit_Grad: return angle * M_PI / 200.0;
default:
NS_ABORT_IF_FALSE(false, "unrecognized angular unit");
return 0.0;
}
}
void GameObject::SaveToDB()
{
std::stringstream ss;
ss << "REPLACE INTO gameobject_spawns VALUES("
<< ((m_spawn == NULL) ? 0 : m_spawn->id) << ","
<< GetEntry() << ","
<< GetMapId() << ","
<< GetPositionX() << ","
<< GetPositionY() << ","
<< GetPositionZ() << ","
<< GetOrientation() << ","
<< GetUInt64Value(GAMEOBJECT_ROTATION) << ","
<< GetFloatValue(GAMEOBJECT_PARENTROTATION) << ","
<< GetFloatValue(GAMEOBJECT_PARENTROTATION + 2) << ","
<< GetFloatValue(GAMEOBJECT_PARENTROTATION + 3) << ","
<< ( GetByte(GAMEOBJECT_BYTES_1, 0)? 1 : 0 ) << ","
<< GetUInt32Value(GAMEOBJECT_FLAGS) << ","
<< GetUInt32Value(GAMEOBJECT_FACTION) << ","
<< GetFloatValue(OBJECT_FIELD_SCALE_X) << ","
<< m_phaseMode << ","
<< m_phaseMode << ")";
WorldDatabase.Execute(ss.str().c_str());
}
float Creature::GetAttackDistance(Unit *pl)
{
uint16 playlevel = (uint16)pl->GetUInt32Value(UNIT_FIELD_LEVEL);
uint16 creaturelevel = (uint16)this->GetUInt32Value(UNIT_FIELD_LEVEL);
int16 leveldif = playlevel - creaturelevel;
float RetDistance=10.0;
if ( leveldif > 9 )
{
RetDistance = 3;
}
else
{
if (leveldif > 0)
RetDistance = 10 * GetFloatValue(UNIT_FIELD_COMBATREACH) - 2*(float)leveldif;
else
RetDistance = 10 * GetFloatValue(UNIT_FIELD_COMBATREACH);
RetDistance = RetDistance>50?50:RetDistance;
RetDistance = RetDistance<3?3:RetDistance;
}
return RetDistance;
}
void Unit::UpdateMovementVector()
{
// every fifth state (0000, 0101, 1010, 1111) cancels the movement
if (m_moveMask % 5 == 0)
{
m_moveVector.x = 0;
m_moveVector.y = 0;
}
else
{
// update vecotr using polar coordinates
m_moveVector.SetFromPolar(movementAngles[m_moveMask], GetFloatValue(UNIT_FIELD_MOVEMENT_SPEED));
m_moveVector.x *= MOVEMENT_UPDATE_UNIT_FRACTION;
m_moveVector.y *= MOVEMENT_UPDATE_UNIT_FRACTION;
}
}
float Player::GetTotalSpellCritChanceOnTarget(SpellSchoolMask schoolMask, Unit* victim)
{
// For normal school set zero crit chance
if (schoolMask == SPELL_SCHOOL_MASK_NORMAL || victim == NULL)
{
return 0.0f;
}
float crit_chance = GetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1 + GetFirstSchoolInMask(schoolMask));
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
crit_chance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
crit_chance += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
return crit_chance;
}
char *ldl_attribute::GetValueText()
{
static char buf[1024];
switch(m_type) {
case ATTRIBUTE_TYPE_BOOL:
sprintf(buf, "%s", GetBoolValue() ? "true" : "false");
break;
case ATTRIBUTE_TYPE_INT:
sprintf(buf, "%d", GetIntValue());
break;
case ATTRIBUTE_TYPE_DOUBLE:
sprintf(buf, "%lf", GetFloatValue());
break;
case ATTRIBUTE_TYPE_STRING:
sprintf(buf, "%s", GetStringValue());
break;
}
return buf;
}
double gxConfig::GetDFPValue(const gxString &Name, int fn)
{
return GetFloatValue(Name, fn);
}
void *Asc2Bin(const char *source, int &count, const char *spec)
{
char *dest = 0;
count = 0;
int cnt = 0;
int size = 0;
Atype types[MAXARG];
const char *ctype = spec;
while (*ctype)
{
switch (ToLower(*ctype))
{
case 'f':
size += sizeof(float);
types[cnt] = AT_FLOAT;
cnt++;
break;
case 'd':
size += sizeof(int);
types[cnt] = AT_INT;
cnt++;
break;
case 'c':
size += sizeof(char);
types[cnt] = AT_CHAR;
cnt++;
break;
case 'b':
size += sizeof(char);
types[cnt] = AT_BYTE;
cnt++;
break;
case 'h':
size += sizeof(short);
types[cnt] = AT_SHORT;
cnt++;
break;
case 'p':
size += sizeof(const char*);
types[cnt] = AT_STR;
cnt++;
break;
case 'x':
if (1)
{
Atype type = AT_HEX4;
int sz = 4;
switch (ctype[1])
{
case '1':
type = AT_HEX1;
sz = 1;
ctype++;
break;
case '2':
type = AT_HEX2;
sz = 2;
ctype++;
break;
case '4':
type = AT_HEX4;
sz = 4;
ctype++;
break;
}
types[cnt] = type;
size += sz;
cnt++;
}
break;
}
if (cnt == MAXARG)
{
return 0;
}
// over flowed the maximum specification!
ctype++;
}
int reserve_count = 16;
dest = new char[reserve_count *size];
memset(dest, 0, reserve_count *size); // zero out memory
char *dst = (char*)dest; // where we are storing the results
while (1)
{
for (int j = 0; j < cnt; j++)
{
source = SkipWhitespace(source); // skip white spaces.
if (*source == 0)
// we hit the end of the input data before we successfully parsed all input!
{
return dest;
}
switch (types[j])
{
case AT_FLOAT:
if (1)
{
float *v = (float*)dst;
*v = GetFloatValue(source, &source);
dst += sizeof(float);
}
break;
case AT_INT:
if (1)
{
int *v = (int*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(int);
}
break;
case AT_CHAR:
if (1)
{
*dst++ = *source++;
}
break;
case AT_BYTE:
if (1)
{
char *v = (char*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(char);
}
break;
case AT_SHORT:
if (1)
{
short *v = (short*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(short);
}
break;
case AT_STR:
if (1)
{
const char **ptr = (const char **)dst;
*ptr = source;
dst += sizeof(const char*);
while (*source && !IsWhitespace(*source))
{
source++;
}
}
break;
case AT_HEX1:
if (1)
{
unsigned int hex = GetHEX1(source, &source);
unsigned char *v = (unsigned char*)dst;
*v = hex;
dst += sizeof(unsigned char);
}
break;
case AT_HEX2:
if (1)
{
unsigned int hex = GetHEX2(source, &source);
unsigned short *v = (unsigned short*)dst;
*v = hex;
dst += sizeof(unsigned short);
}
break;
case AT_HEX4:
if (1)
{
unsigned int hex = GetHEX4(source, &source);
unsigned int *v = (unsigned int*)dst;
*v = hex;
dst += sizeof(unsigned int);
}
break;
default: /*nothing*/ break;
}
}
count++;
if (count >= reserve_count)
{
char *old_dest = (char*)dest;
reserve_count *= 2;
dest = new char[reserve_count *size];
memset(dest, 0, reserve_count *size); // zero out memory
memcpy(dest, old_dest, reserve_count / 2 * size); // copy the old data.
int dist = (int)(dst - old_dest);
dst = &dest[dist]; // the new destination.
delete old_dest; // free up the old data.
}
}
return dest;
}
void ReadConfigFile()
{
struct stat buf;
FILE *in;
char t[256];
int size;
//int len;
char * pB, * p;
if(pConfigFile)
strcpy(t,pConfigFile);
else
{
strcpy(t,"cfg/gpuPeopsSoftX.cfg");
in = fopen(t,"rb");
if (!in)
{
strcpy(t,"gpuPeopsSoftX.cfg");
in = fopen(t,"rb");
if(!in) sprintf(t,"%s/gpuPeopsSoftX.cfg",getenv("HOME"));
else fclose(in);
}
else fclose(in);
}
if (stat(t, &buf) == -1) return;
size = buf.st_size;
in = fopen(t,"rb");
if (!in) return;
pB=(char *)malloc(size);
memset(pB,0,size);
//len =
fread(pB, 1, size, in);
fclose(in);
GetValue("ResX", iResX);
if(iResX<20) iResX=20;
iResX=(iResX/4)*4;
GetValue("ResY", iResY);
if(iResY<20) iResY=20;
iResY=(iResY/4)*4;
iWinSize=MAKELONG(iResX,iResY);
GetValue("NoStretch", iUseNoStretchBlt);
GetValue("Dithering", iUseDither);
GetValue("FullScreen", iWindowMode);
if(iWindowMode!=0) iWindowMode=0;
else iWindowMode=1;
GetValue("ShowFPS", iShowFPS);
if(iShowFPS<0) iShowFPS=0;
if(iShowFPS>1) iShowFPS=1;
GetValue("SSSPSXLimit", bSSSPSXLimit);
if(iShowFPS<0) iShowFPS=0;
if(iShowFPS>1) iShowFPS=1;
GetValue("ScanLines", iUseScanLines);
if(iUseScanLines<0) iUseScanLines=0;
if(iUseScanLines>1) iUseScanLines=1;
GetValue("UseFrameLimit", UseFrameLimit);
if(UseFrameLimit<0) UseFrameLimit=0;
if(UseFrameLimit>1) UseFrameLimit=1;
GetValue("UseFrameSkip", UseFrameSkip);
if(UseFrameSkip<0) UseFrameSkip=0;
if(UseFrameSkip>1) UseFrameSkip=1;
GetValue("FPSDetection", iFrameLimit);
if(iFrameLimit<1) iFrameLimit=1;
if(iFrameLimit>2) iFrameLimit=2;
GetFloatValue("FrameRate", fFrameRate);
if(fFrameRate<10.0f) fFrameRate=10.0f;
if(fFrameRate>1000.0f) fFrameRate=1000.0f;
GetValue("CfgFixes", dwCfgFixes);
GetValue("UseFixes", iUseFixes);
if(iUseFixes<0) iUseFixes=0;
if(iUseFixes>1) iUseFixes=1;
free(pB);
}
void *Asc2Bin(const char *source, const int count, const char *spec, void *dest)
{
if ( !source || !spec )
return 0;
int cnt = 0;
int size = 0;
Atype types[MAXARG];
const char *ctype = spec;
while (*ctype)
{
switch (ToLower(*ctype))
{
case 'f':
size += sizeof(float);
types[cnt] = AT_FLOAT;
cnt++;
break;
case 'd':
size += sizeof(int);
types[cnt] = AT_INT;
cnt++;
break;
case 'c':
size += sizeof(char);
types[cnt] = AT_CHAR;
cnt++;
break;
case 'b':
size += sizeof(char);
types[cnt] = AT_BYTE;
cnt++;
break;
case 'h':
size += sizeof(short);
types[cnt] = AT_SHORT;
cnt++;
break;
case 'p':
size += sizeof(const char*);
types[cnt] = AT_STR;
cnt++;
break;
case 'x':
if (1)
{
Atype type = AT_HEX4;
int sz = 4;
switch (ctype[1])
{
case '1':
type = AT_HEX1;
sz = 1;
ctype++;
break;
case '2':
type = AT_HEX2;
sz = 2;
ctype++;
break;
case '4':
type = AT_HEX4;
sz = 4;
ctype++;
break;
}
types[cnt] = type;
size += sz;
cnt++;
}
break;
}
if (cnt == MAXARG)
{
return 0;
}
// over flowed the maximum specification!
ctype++;
}
bool myalloc = false;
if (dest == 0)
{
myalloc = true;
dest = (char*)new char[count *size];
}
// ok...ready to parse lovely data....
memset(dest, 0, count *size); // zero out memory
char *dst = (char*)dest; // where we are storing the results
for (int i = 0; i < count && source; i++)
{
for (int j = 0; j < cnt && source; j++)
{
source = SkipWhitespace(source); // skip white spaces.
if (*source == 0)
// we hit the end of the input data before we successfully parsed all input!
{
if (myalloc)
{
delete (char*)dest;
}
return 0;
}
switch (types[j])
{
case AT_FLOAT:
if (1)
{
float *v = (float*)dst;
*v = GetFloatValue(source, &source);
dst += sizeof(float);
}
break;
case AT_INT:
if (1)
{
int *v = (int*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(int);
}
break;
case AT_CHAR:
if (1)
{
*dst++ = *source++;
}
break;
case AT_BYTE:
if (1)
{
char *v = (char*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(char);
}
break;
case AT_SHORT:
if (1)
{
short *v = (short*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(short);
}
break;
case AT_STR:
if (1)
{
const char **ptr = (const char **)dst;
*ptr = source;
dst += sizeof(const char*);
while (*source && !IsWhitespace(*source))
{
source++;
}
}
break;
case AT_HEX1:
if (1)
{
unsigned int hex = GetHEX1(source, &source);
unsigned char *v = (unsigned char*)dst;
*v = hex;
dst += sizeof(unsigned char);
}
break;
case AT_HEX2:
if (1)
{
unsigned int hex = GetHEX2(source, &source);
unsigned short *v = (unsigned short*)dst;
*v = hex;
dst += sizeof(unsigned short);
}
break;
case AT_HEX4:
if (1)
{
unsigned int hex = GetHEX4(source, &source);
unsigned int *v = (unsigned int*)dst;
*v = hex;
dst += sizeof(unsigned int);
}
break;
default:
break;
}
}
}
return dest;
}
void GameObject::SaveToDB(uint32 mapid, uint8 spawnMask)
{
const GameObjectInfo *goI = GetGOInfo();
if (!goI)
return;
if (!m_DBTableGuid)
m_DBTableGuid = GetGUIDLow();
// update in loaded data (changing data only in this place)
GameObjectData& data = objmgr.NewGOData(m_DBTableGuid);
// data->guid = guid don't must be update at save
data.id = GetEntry();
data.mapid = mapid;
data.posX = GetFloatValue(GAMEOBJECT_POS_X);
data.posY = GetFloatValue(GAMEOBJECT_POS_Y);
data.posZ = GetFloatValue(GAMEOBJECT_POS_Z);
data.orientation = GetFloatValue(GAMEOBJECT_FACING);
data.rotation0 = GetFloatValue(GAMEOBJECT_PARENTROTATION+0);
data.rotation1 = GetFloatValue(GAMEOBJECT_PARENTROTATION+1);
data.rotation2 = GetFloatValue(GAMEOBJECT_PARENTROTATION+2);
data.rotation3 = GetFloatValue(GAMEOBJECT_PARENTROTATION+3);
data.spawntimesecs = m_spawnedByDefault ? m_respawnDelayTime : -(int32)m_respawnDelayTime;
data.animprogress = GetGoAnimProgress();
data.go_state = GetGoState();
data.spawnMask = spawnMask;
// updated in DB
std::ostringstream ss;
ss << "INSERT INTO gameobject VALUES ( "
<< m_DBTableGuid << ", "
<< GetEntry() << ", "
<< mapid << ", "
<< (uint32)spawnMask << ", "
<< GetFloatValue(GAMEOBJECT_POS_X) << ", "
<< GetFloatValue(GAMEOBJECT_POS_Y) << ", "
<< GetFloatValue(GAMEOBJECT_POS_Z) << ", "
<< GetFloatValue(GAMEOBJECT_FACING) << ", "
<< GetFloatValue(GAMEOBJECT_PARENTROTATION) << ", "
<< GetFloatValue(GAMEOBJECT_PARENTROTATION+1) << ", "
<< GetFloatValue(GAMEOBJECT_PARENTROTATION+2) << ", "
<< GetFloatValue(GAMEOBJECT_PARENTROTATION+3) << ", "
<< m_respawnDelayTime << ", "
<< (uint32)GetGoAnimProgress() << ", "
<< (uint32)GetGoState() << ")";
WorldDatabase.BeginTransaction();
WorldDatabase.PExecuteLog("DELETE FROM gameobject WHERE guid = '%u'", m_DBTableGuid);
WorldDatabase.PExecuteLog( ss.str( ).c_str( ) );
WorldDatabase.CommitTransaction();
}
void Pet::CreateAsSummon(uint32 entry, CreatureInfo *ci, Creature* created_from_creature, Unit* owner, SpellEntry* created_by_spell, uint32 type, uint32 expiretime)
{
if(ci == NULL)
return;
SetIsPet(true);
m_OwnerGuid = owner->GetGUID();
m_Owner = TO_PLAYER(owner);
m_OwnerGuid = m_Owner->GetGUID();
creature_info = ci;
myFamily = dbcCreatureFamily.LookupEntry(creature_info->Family);
//m_name = objmgr.GetCreatureFamilyName(myFamily->ID);
if( myFamily->name == NULL )
m_name = "Pet";
else
m_name.assign( myFamily->name );
// Create ourself
Create(m_name.c_str(), owner->GetMapId(), owner->GetPositionX(), owner->GetPositionY(), owner->GetPositionZ(), owner->GetOrientation());
SetUInt32Value(OBJECT_FIELD_ENTRY, entry);
SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f); // better set this one
// Fields common to both lock summons and pets
uint32 level = (m_Owner->GetUInt32Value( UNIT_FIELD_LEVEL ) - 5);
if( type & 0x2 && created_from_creature != NULL && created_from_creature->getLevel() > level)
{
level = created_from_creature->getLevel();
}
SetUInt32Value(UNIT_FIELD_LEVEL, level);
SetUInt32Value(UNIT_FIELD_DISPLAYID, ci->Male_DisplayID);
SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, ci->Male_DisplayID);
SetSummonedByGUID(owner->GetGUID());
SetCreatedByGUID(owner->GetGUID());
if(type & 0x1 && created_by_spell != NULL)
SetUInt64Value(UNIT_CREATED_BY_SPELL, created_by_spell->Id);
if(type & 0x1 || created_from_creature == NULL)
{
Summon = true;
SetUInt32Value(UNIT_FIELD_BYTES_0, 2048 | (0 << 24));
SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
SetUInt32Value(UNIT_FIELD_BASEATTACKTIME, 2000);
SetUInt32Value(UNIT_FIELD_RANGEDATTACKTIME, 2000);
SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 0.5f);
SetFloatValue(UNIT_FIELD_COMBATREACH, 0.75f);
SetUInt32Value(UNIT_FIELD_BYTES_2, (0x01 | (0x2 << 24)));
SetUInt32Value(UNIT_FIELD_PETNUMBER, GetUIdFromGUID());
SetPowerType(POWER_TYPE_MANA);
if(entry == WATER_ELEMENTAL)
m_name = "Water Elemental";
else if( entry == 19668)
m_name = "Shadowfiend";
else
m_name = sWorld.GenerateName();
}
else
{
SetUInt32Value(UNIT_FIELD_BYTES_0, 2048 | (0 << 24));
SetUInt32Value(UNIT_FIELD_BASEATTACKTIME, 2000);
SetUInt32Value(UNIT_FIELD_RANGEDATTACKTIME, 2000); // Supalosa: 2.00 normalized attack speed
// hacks D: allow correct creation of hunter pets via gm command
if(created_from_creature == this)
{
SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, 0.5f);
SetFloatValue(UNIT_FIELD_COMBATREACH, 0.75f);
}
else
{
SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, created_from_creature->GetFloatValue(UNIT_FIELD_BOUNDINGRADIUS));
SetFloatValue(UNIT_FIELD_COMBATREACH, created_from_creature->GetFloatValue(UNIT_FIELD_COMBATREACH));
}
// These need to be checked.
SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED | UNIT_FLAG_COMBAT); // why combat ??
SetHappiness(PET_HAPPINESS_UPDATE_VALUE >> 1); // happiness
SetUInt32Value(UNIT_FIELD_MAXPOWER5, 1000000);
SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, 0);
SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP, GetNextLevelXP(getLevel()));
SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
// Focus
SetUInt32Value(UNIT_FIELD_POWER3, 100);
SetUInt32Value(UNIT_FIELD_MAXPOWER3, 100);
// 0x3 -> Enable pet rename.
SetUInt32Value(UNIT_FIELD_BYTES_2, 1 | (0x3 << 16));
// Change the power type to FOCUS
SetPowerType(POWER_TYPE_FOCUS);
// create our spells
SetDefaultSpells();
InitTalentsForLevel(true);
}
// Apply stats.
ApplyStatsForLevel();
BaseDamage[0]=GetFloatValue(UNIT_FIELD_MINDAMAGE);
BaseDamage[1]=GetFloatValue(UNIT_FIELD_MAXDAMAGE);
BaseOffhandDamage[0]=GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE);
BaseOffhandDamage[1]=GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE);
BaseRangedDamage[0]=GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
BaseRangedDamage[1]=GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, owner->GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE));
m_PartySpellsUpdateTimer = 0;
m_PetNumber = TO_PLAYER(owner)->GeneratePetNumber();
SetUInt32Value(UNIT_FIELD_PETNUMBER, GetUIdFromGUID());
m_ExpireTime = expiretime;
bExpires = m_ExpireTime > 0 ? true : false;
if(!bExpires)
{
// Create PlayerPet struct (Rest done by UpdatePetInfo)
PlayerPet *pp = new PlayerPet;
pp->number = m_PetNumber;
pp->stablestate = STABLE_STATE_ACTIVE;
TO_PLAYER(owner)->AddPlayerPet(pp, pp->number);
}
//maybe we should use speed from the template we created the creature ?
m_base_runSpeed = m_runSpeed = owner->m_base_runSpeed; //should we be able to keep up with master ?
m_base_walkSpeed = m_walkSpeed = owner->m_base_walkSpeed; //should we be able to keep up with master ?
InitializeMe(true);
}
void
nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult) const
{
// eCSSProperty_UNKNOWN gets used for some recursive calls below.
NS_ABORT_IF_FALSE((0 <= aProperty &&
aProperty <= eCSSProperty_COUNT_no_shorthands) ||
aProperty == eCSSProperty_UNKNOWN,
"property ID out of range");
nsCSSUnit unit = GetUnit();
if (unit == eCSSUnit_Null) {
return;
}
if (eCSSUnit_String <= unit && unit <= eCSSUnit_Attr) {
if (unit == eCSSUnit_Attr) {
aResult.AppendLiteral("attr(");
}
nsAutoString buffer;
GetStringValue(buffer);
if (unit == eCSSUnit_String) {
nsStyleUtil::AppendEscapedCSSString(buffer, aResult);
} else if (unit == eCSSUnit_Families) {
// XXX We really need to do *some* escaping.
aResult.Append(buffer);
} else {
nsStyleUtil::AppendEscapedCSSIdent(buffer, aResult);
}
}
else if (eCSSUnit_Array <= unit && unit <= eCSSUnit_Steps) {
switch (unit) {
case eCSSUnit_Counter: aResult.AppendLiteral("counter("); break;
case eCSSUnit_Counters: aResult.AppendLiteral("counters("); break;
case eCSSUnit_Cubic_Bezier: aResult.AppendLiteral("cubic-bezier("); break;
case eCSSUnit_Steps: aResult.AppendLiteral("steps("); break;
default: break;
}
nsCSSValue::Array *array = GetArrayValue();
bool mark = false;
for (size_t i = 0, i_end = array->Count(); i < i_end; ++i) {
if (mark && array->Item(i).GetUnit() != eCSSUnit_Null) {
if (unit == eCSSUnit_Array &&
eCSSProperty_transition_timing_function != aProperty)
aResult.AppendLiteral(" ");
else
aResult.AppendLiteral(", ");
}
if (unit == eCSSUnit_Steps && i == 1) {
NS_ABORT_IF_FALSE(array->Item(i).GetUnit() == eCSSUnit_Enumerated &&
(array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START ||
array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END),
"unexpected value");
if (array->Item(i).GetIntValue() ==
NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START) {
aResult.AppendLiteral("start");
} else {
aResult.AppendLiteral("end");
}
continue;
}
nsCSSProperty prop =
((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) &&
i == array->Count() - 1)
? eCSSProperty_list_style_type : aProperty;
if (array->Item(i).GetUnit() != eCSSUnit_Null) {
array->Item(i).AppendToString(prop, aResult);
mark = true;
}
}
if (eCSSUnit_Array == unit &&
aProperty == eCSSProperty_transition_timing_function) {
aResult.AppendLiteral(")");
}
}
/* Although Function is backed by an Array, we'll handle it separately
* because it's a bit quirky.
*/
else if (eCSSUnit_Function == unit) {
const nsCSSValue::Array* array = GetArrayValue();
NS_ABORT_IF_FALSE(array->Count() >= 1,
"Functions must have at least one element for the name.");
/* Append the function name. */
const nsCSSValue& functionName = array->Item(0);
if (functionName.GetUnit() == eCSSUnit_Enumerated) {
// We assume that the first argument is always of nsCSSKeyword type.
const nsCSSKeyword functionId =
static_cast<nsCSSKeyword>(functionName.GetIntValue());
nsStyleUtil::AppendEscapedCSSIdent(
NS_ConvertASCIItoUTF16(nsCSSKeywords::GetStringValue(functionId)),
aResult);
} else {
functionName.AppendToString(aProperty, aResult);
}
aResult.AppendLiteral("(");
/* Now, step through the function contents, writing each of them as we go. */
for (size_t index = 1; index < array->Count(); ++index) {
array->Item(index).AppendToString(aProperty, aResult);
/* If we're not at the final element, append a comma. */
if (index + 1 != array->Count())
aResult.AppendLiteral(", ");
}
/* Finally, append the closing parenthesis. */
aResult.AppendLiteral(")");
}
else if (IsCalcUnit()) {
NS_ABORT_IF_FALSE(GetUnit() == eCSSUnit_Calc, "unexpected unit");
CSSValueSerializeCalcOps ops(aProperty, aResult);
css::SerializeCalc(*this, ops);
}
else if (eCSSUnit_Integer == unit) {
aResult.AppendInt(GetIntValue(), 10);
}
else if (eCSSUnit_Enumerated == unit) {
if (eCSSProperty_text_decoration_line == aProperty) {
PRInt32 intValue = GetIntValue();
if (NS_STYLE_TEXT_DECORATION_LINE_NONE == intValue) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
// Ignore the "override all" internal value.
// (It doesn't have a string representation.)
intValue &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERRIDE_ALL;
nsStyleUtil::AppendBitmaskCSSValue(
aProperty, intValue,
NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE,
NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS,
aResult);
}
}
else if (eCSSProperty_marks == aProperty) {
PRInt32 intValue = GetIntValue();
if (intValue == NS_STYLE_PAGE_MARKS_NONE) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
NS_STYLE_PAGE_MARKS_CROP,
NS_STYLE_PAGE_MARKS_REGISTER,
aResult);
}
}
else if (eCSSProperty_unicode_bidi == aProperty) {
PR_STATIC_ASSERT(NS_STYLE_UNICODE_BIDI_NORMAL == 0);
PRInt32 intValue = GetIntValue();
if (NS_STYLE_UNICODE_BIDI_NORMAL == intValue) {
AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
aResult);
} else {
nsStyleUtil::AppendBitmaskCSSValue(
aProperty, intValue,
NS_STYLE_UNICODE_BIDI_EMBED,
NS_STYLE_UNICODE_BIDI_PLAINTEXT,
aResult);
}
}
else {
const nsAFlatCString& name = nsCSSProps::LookupPropertyValue(aProperty, GetIntValue());
AppendASCIItoUTF16(name, aResult);
}
}
else if (eCSSUnit_EnumColor == unit) {
// we can lookup the property in the ColorTable and then
// get a string mapping the name
nsCAutoString str;
if (nsCSSProps::GetColorName(GetIntValue(), str)){
AppendASCIItoUTF16(str, aResult);
} else {
NS_ABORT_IF_FALSE(false, "bad color value");
}
}
else if (eCSSUnit_Color == unit) {
nscolor color = GetColorValue();
if (color == NS_RGBA(0, 0, 0, 0)) {
// Use the strictest match for 'transparent' so we do correct
// round-tripping of all other rgba() values.
aResult.AppendLiteral("transparent");
} else {
PRUint8 a = NS_GET_A(color);
if (a < 255) {
aResult.AppendLiteral("rgba(");
} else {
aResult.AppendLiteral("rgb(");
}
NS_NAMED_LITERAL_STRING(comma, ", ");
aResult.AppendInt(NS_GET_R(color), 10);
aResult.Append(comma);
aResult.AppendInt(NS_GET_G(color), 10);
aResult.Append(comma);
aResult.AppendInt(NS_GET_B(color), 10);
if (a < 255) {
aResult.Append(comma);
aResult.AppendFloat(nsStyleUtil::ColorComponentToFloat(a));
}
aResult.Append(PRUnichar(')'));
}
}
else if (eCSSUnit_URL == unit || eCSSUnit_Image == unit) {
aResult.Append(NS_LITERAL_STRING("url("));
nsStyleUtil::AppendEscapedCSSString(
nsDependentString(GetOriginalURLValue()), aResult);
aResult.Append(NS_LITERAL_STRING(")"));
}
else if (eCSSUnit_Element == unit) {
aResult.Append(NS_LITERAL_STRING("-moz-element(#"));
nsAutoString tmpStr;
GetStringValue(tmpStr);
nsStyleUtil::AppendEscapedCSSIdent(tmpStr, aResult);
aResult.Append(NS_LITERAL_STRING(")"));
}
else if (eCSSUnit_Percent == unit) {
aResult.AppendFloat(GetPercentValue() * 100.0f);
}
else if (eCSSUnit_Percent < unit) { // length unit
aResult.AppendFloat(GetFloatValue());
}
else if (eCSSUnit_Gradient == unit) {
nsCSSValueGradient* gradient = GetGradientValue();
if (gradient->mIsRepeating) {
if (gradient->mIsRadial)
aResult.AppendLiteral("-moz-repeating-radial-gradient(");
else
aResult.AppendLiteral("-moz-repeating-linear-gradient(");
} else {
if (gradient->mIsRadial)
aResult.AppendLiteral("-moz-radial-gradient(");
else
aResult.AppendLiteral("-moz-linear-gradient(");
}
if (gradient->mIsToCorner) {
aResult.AppendLiteral("to");
NS_ABORT_IF_FALSE(gradient->mBgPos.mXValue.GetUnit() == eCSSUnit_Enumerated &&
gradient->mBgPos.mYValue.GetUnit() == eCSSUnit_Enumerated,
"unexpected unit");
if (!(gradient->mBgPos.mXValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) {
aResult.AppendLiteral(" ");
gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position,
aResult);
}
if (!(gradient->mBgPos.mYValue.GetIntValue() & NS_STYLE_BG_POSITION_CENTER)) {
aResult.AppendLiteral(" ");
gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position,
aResult);
}
aResult.AppendLiteral(", ");
} else if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None ||
gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None ||
gradient->mAngle.GetUnit() != eCSSUnit_None) {
if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) {
gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position,
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) {
gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position,
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mAngle.GetUnit() != eCSSUnit_None) {
gradient->mAngle.AppendToString(aProperty, aResult);
}
aResult.AppendLiteral(", ");
}
if (gradient->mIsRadial &&
(gradient->mRadialShape.GetUnit() != eCSSUnit_None ||
gradient->mRadialSize.GetUnit() != eCSSUnit_None)) {
if (gradient->mRadialShape.GetUnit() != eCSSUnit_None) {
NS_ABORT_IF_FALSE(gradient->mRadialShape.GetUnit() ==
eCSSUnit_Enumerated,
"bad unit for radial gradient shape");
PRInt32 intValue = gradient->mRadialShape.GetIntValue();
NS_ABORT_IF_FALSE(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR,
"radial gradient with linear shape?!");
AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
nsCSSProps::kRadialGradientShapeKTable),
aResult);
aResult.AppendLiteral(" ");
}
if (gradient->mRadialSize.GetUnit() != eCSSUnit_None) {
NS_ABORT_IF_FALSE(gradient->mRadialSize.GetUnit() ==
eCSSUnit_Enumerated,
"bad unit for radial gradient size");
PRInt32 intValue = gradient->mRadialSize.GetIntValue();
AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
nsCSSProps::kRadialGradientSizeKTable),
aResult);
}
aResult.AppendLiteral(", ");
}
for (PRUint32 i = 0 ;;) {
gradient->mStops[i].mColor.AppendToString(aProperty, aResult);
if (gradient->mStops[i].mLocation.GetUnit() != eCSSUnit_None) {
aResult.AppendLiteral(" ");
gradient->mStops[i].mLocation.AppendToString(aProperty, aResult);
}
if (++i == gradient->mStops.Length()) {
break;
}
aResult.AppendLiteral(", ");
}
aResult.AppendLiteral(")");
} else if (eCSSUnit_Pair == unit) {
GetPairValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_Triplet == unit) {
GetTripletValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_Rect == unit) {
GetRectValue().AppendToString(aProperty, aResult);
} else if (eCSSUnit_List == unit || eCSSUnit_ListDep == unit) {
GetListValue()->AppendToString(aProperty, aResult);
} else if (eCSSUnit_PairList == unit || eCSSUnit_PairListDep == unit) {
GetPairListValue()->AppendToString(aProperty, aResult);
}
switch (unit) {
case eCSSUnit_Null: break;
case eCSSUnit_Auto: aResult.AppendLiteral("auto"); break;
case eCSSUnit_Inherit: aResult.AppendLiteral("inherit"); break;
case eCSSUnit_Initial: aResult.AppendLiteral("-moz-initial"); break;
case eCSSUnit_None: aResult.AppendLiteral("none"); break;
case eCSSUnit_Normal: aResult.AppendLiteral("normal"); break;
case eCSSUnit_System_Font: aResult.AppendLiteral("-moz-use-system-font"); break;
case eCSSUnit_All: aResult.AppendLiteral("all"); break;
case eCSSUnit_Dummy:
case eCSSUnit_DummyInherit:
NS_ABORT_IF_FALSE(false, "should never serialize");
break;
case eCSSUnit_String: break;
case eCSSUnit_Ident: break;
case eCSSUnit_Families: break;
case eCSSUnit_URL: break;
case eCSSUnit_Image: break;
case eCSSUnit_Element: break;
case eCSSUnit_Array: break;
case eCSSUnit_Attr:
case eCSSUnit_Cubic_Bezier:
case eCSSUnit_Steps:
case eCSSUnit_Counter:
case eCSSUnit_Counters: aResult.Append(PRUnichar(')')); break;
case eCSSUnit_Local_Font: break;
case eCSSUnit_Font_Format: break;
case eCSSUnit_Function: break;
case eCSSUnit_Calc: break;
case eCSSUnit_Calc_Plus: break;
case eCSSUnit_Calc_Minus: break;
case eCSSUnit_Calc_Times_L: break;
case eCSSUnit_Calc_Times_R: break;
case eCSSUnit_Calc_Divided: break;
case eCSSUnit_Integer: break;
case eCSSUnit_Enumerated: break;
case eCSSUnit_EnumColor: break;
case eCSSUnit_Color: break;
case eCSSUnit_Percent: aResult.Append(PRUnichar('%')); break;
case eCSSUnit_Number: break;
case eCSSUnit_Gradient: break;
case eCSSUnit_Pair: break;
case eCSSUnit_Triplet: break;
case eCSSUnit_Rect: break;
case eCSSUnit_List: break;
case eCSSUnit_ListDep: break;
case eCSSUnit_PairList: break;
case eCSSUnit_PairListDep: break;
case eCSSUnit_Inch: aResult.AppendLiteral("in"); break;
case eCSSUnit_Millimeter: aResult.AppendLiteral("mm"); break;
case eCSSUnit_PhysicalMillimeter: aResult.AppendLiteral("mozmm"); break;
case eCSSUnit_Centimeter: aResult.AppendLiteral("cm"); break;
case eCSSUnit_Point: aResult.AppendLiteral("pt"); break;
case eCSSUnit_Pica: aResult.AppendLiteral("pc"); break;
case eCSSUnit_EM: aResult.AppendLiteral("em"); break;
case eCSSUnit_XHeight: aResult.AppendLiteral("ex"); break;
case eCSSUnit_Char: aResult.AppendLiteral("ch"); break;
case eCSSUnit_RootEM: aResult.AppendLiteral("rem"); break;
case eCSSUnit_Pixel: aResult.AppendLiteral("px"); break;
case eCSSUnit_Degree: aResult.AppendLiteral("deg"); break;
case eCSSUnit_Grad: aResult.AppendLiteral("grad"); break;
case eCSSUnit_Radian: aResult.AppendLiteral("rad"); break;
case eCSSUnit_Hertz: aResult.AppendLiteral("Hz"); break;
case eCSSUnit_Kilohertz: aResult.AppendLiteral("kHz"); break;
case eCSSUnit_Seconds: aResult.Append(PRUnichar('s')); break;
case eCSSUnit_Milliseconds: aResult.AppendLiteral("ms"); break;
}
}
double gxConfig::GetDFPValue(const char *Name, int fn)
{
gxString buf(Name);
return GetFloatValue(buf, fn);
}
