void HTMLImportChild::stateWillChange()
{
toHTMLImportTreeRoot(root())->scheduleRecalcState();
}
void HTMLImportChild::ownerInserted()
{
if (!m_loader->isDone())
return;
root()->document()->styleResolverChanged();
}
void updateRootWeight(int a) {
int r = root(a);
if ((weight[a] >= 0 && weight[r] < 0) || (weight[a] >= 0 && weight[a] < weight[r])) {
weight[r] = weight[a];
}
}
NodeIterator::~NodeIterator()
{
root().document().detachNodeIterator(this);
}
NodeIterator::NodeIterator(Node& rootNode, unsigned long whatToShow, RefPtr<NodeFilter>&& filter)
: NodeIteratorBase(rootNode, whatToShow, WTFMove(filter))
, m_referenceNode(root(), true)
{
root().document().attachNodeIterator(this);
}
void NodeIterator::updateForNodeRemoval(Node& removedNode, NodePointer& referenceNode) const
{
ASSERT(&root().document() == &removedNode.document());
// Iterator is not affected if the removed node is the reference node and is the root.
// or if removed node is not the reference node, or the ancestor of the reference node.
if (!removedNode.isDescendantOf(&root()))
return;
bool willRemoveReferenceNode = &removedNode == referenceNode.node;
bool willRemoveReferenceNodeAncestor = referenceNode.node && referenceNode.node->isDescendantOf(&removedNode);
if (!willRemoveReferenceNode && !willRemoveReferenceNodeAncestor)
return;
if (referenceNode.isPointerBeforeNode) {
Node* node = NodeTraversal::next(removedNode, &root());
if (node) {
// Move out from under the node being removed if the new reference
// node is a descendant of the node being removed.
while (node && node->isDescendantOf(&removedNode))
node = NodeTraversal::next(*node, &root());
if (node)
referenceNode.node = node;
} else {
node = NodeTraversal::previous(removedNode);
if (node) {
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isDescendantOf(&removedNode))
node = NodeTraversal::previous(*node);
}
if (node) {
// Removing last node.
// Need to move the pointer after the node preceding the
// new reference node.
referenceNode.node = node;
referenceNode.isPointerBeforeNode = false;
}
}
}
} else {
Node* node = NodeTraversal::previous(removedNode);
if (node) {
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isDescendantOf(&removedNode))
node = NodeTraversal::previous(*node);
}
if (node)
referenceNode.node = node;
} else {
// FIXME: This branch doesn't appear to have any LayoutTests.
node = NodeTraversal::next(removedNode, &root());
// Move out from under the node being removed if the reference node is
// a descendant of the node being removed.
if (willRemoveReferenceNodeAncestor) {
while (node && node->isDescendantOf(&removedNode))
node = NodeTraversal::previous(*node);
}
if (node)
referenceNode.node = node;
}
}
}
ChallengeData::ChallengeData(const std::string& filename)
{
m_filename = filename;
m_mode = CM_SINGLE_RACE;
m_minor = RaceManager::MINOR_MODE_NORMAL_RACE;
m_num_laps = -1;
m_track_id = "";
m_gp_id = "";
m_version = 0;
m_num_trophies = 0;
m_is_ghost_replay = false;
for (int d=0; d<RaceManager::DIFFICULTY_COUNT; d++)
{
m_num_karts[d] = -1;
m_position[d] = -1;
m_time[d] = -1.0f;
m_energy[d] = -1;
m_ai_superpower[d] = RaceManager::SUPERPOWER_NONE;
}
// we are using auto_ptr to make sure the XML node is released when leaving
// the scope
std::unique_ptr<XMLNode> root(new XMLNode( filename ));
if(root.get() == NULL || root->getName()!="challenge")
{
std::ostringstream msg;
msg << "Couldn't load challenge '" << filename
<< "': no challenge node.";
throw std::runtime_error(msg.str());
}
setId(StringUtils::removeExtension(StringUtils::getBasename(filename)));
root->get("version", &m_version);
// No need to get the rest of the data if this challenge
// is not supported anyway (id is needed for warning message)
if(!unlock_manager->isSupportedVersion(*this))
{
Log::warn("ChallengeData", "Challenge <%s> is older "
"or newer than this version of STK, will be ignored.\n",
filename.c_str());
return;
}
const XMLNode* mode_node = root->getNode("mode");
if (mode_node == NULL)
{
throw std::runtime_error("Challenge file " + filename +
" has no <mode> node!");
}
std::string mode;
mode_node->get("major", &mode);
if(mode=="grandprix")
m_mode = CM_GRAND_PRIX;
else if(mode=="single")
m_mode = CM_SINGLE_RACE;
else if(mode=="any")
m_mode = CM_ANY;
else
error("major");
mode_node->get("minor", &mode);
if(mode=="timetrial")
m_minor = RaceManager::MINOR_MODE_TIME_TRIAL;
else if(mode=="quickrace")
m_minor = RaceManager::MINOR_MODE_NORMAL_RACE;
else if(mode=="followtheleader")
m_minor = RaceManager::MINOR_MODE_FOLLOW_LEADER;
else
error("minor");
const XMLNode* track_node = root->getNode("track");
const XMLNode* gp_node = root->getNode("grandprix");
if (m_mode == CM_SINGLE_RACE && track_node == NULL)
{
throw std::runtime_error("Challenge file " + filename +
" has no <track> node!");
}
if (m_mode == CM_GRAND_PRIX && gp_node == NULL)
{
throw std::runtime_error("Challenge file " + filename +
" has no <grandprix> node!");
}
if (track_node != NULL)
{
if (!track_node->get("id", &m_track_id ))
{
error("track");
}
if (track_manager->getTrack(m_track_id) == NULL)
{
error("track");
}
if (!track_node->get("laps", &m_num_laps) &&
m_minor != RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
error("laps");
}
}
else if (gp_node != NULL)
{
if (!gp_node->get("id", &m_gp_id ))
{
error("grandprix");
}
}
const XMLNode* requirements_node = root->getNode("requirements");
if (requirements_node == NULL)
{
throw std::runtime_error("Challenge file " + filename +
" has no <requirements> node!");
}
requirements_node->get("trophies", &m_num_trophies);
const XMLNode* difficulties[RaceManager::DIFFICULTY_COUNT];
difficulties[0] = root->getNode("easy");
difficulties[1] = root->getNode("medium");
difficulties[2] = root->getNode("hard");
// Note that the challenges can only be done in three difficulties
if (difficulties[0] == NULL || difficulties[1] == NULL ||
difficulties[2] == NULL)
{
error("<easy> or <medium> or <hard>");
}
for (int d=0; d<=RaceManager::DIFFICULTY_HARD; d++)
{
const XMLNode* karts_node = difficulties[d]->getNode("karts");
if (karts_node == NULL) error("<karts .../>");
int num_karts = -1;
if (!karts_node->get("number", &num_karts)) error("karts");
m_num_karts[d] = num_karts;
std::string replay_file;
if (karts_node->get("replay_file", &replay_file))
{
m_is_ghost_replay = true;
m_replay_files[d] = replay_file;
}
std::string ai_kart_ident;
if (karts_node->get("aiIdent", &ai_kart_ident))
m_ai_kart_ident[d] = ai_kart_ident;
std::string superPower;
if (karts_node->get("superPower", &superPower))
{
if (superPower == "nolokBoss")
{
m_ai_superpower[d] = RaceManager::SUPERPOWER_NOLOK_BOSS;
}
else
{
Log::warn("ChallengeData", "Unknown superpower '%s'",
superPower.c_str());
}
}
const XMLNode* requirements_node =
difficulties[d]->getNode("requirements");
if (requirements_node == NULL) error("<requirements .../>");
int position = -1;
if (!requirements_node->get("position", &position) &&
(m_minor == RaceManager::MINOR_MODE_FOLLOW_LEADER ||
m_mode == CM_GRAND_PRIX))
{
error("position");
}
else
{
m_position[d] = position;
}
int time = -1;
if (requirements_node->get("time", &time)) m_time[d] = (float)time;
if (m_time[d] < 0 && m_position[d] < 0) error("position/time");
// This is optional
int energy = -1;
if (requirements_node->get("energy", &energy)) m_energy[d] = energy;
}
std::vector<XMLNode*> unlocks;
root->getNodes("unlock", unlocks);
for(unsigned int i=0; i<unlocks.size(); i++)
{
std::string s;
if(unlocks[i]->get("kart", &s))
setUnlocks(s, ChallengeData::UNLOCK_KART);
else if(unlocks[i]->get("track", &s))
addUnlockTrackReward(s);
else if(unlocks[i]->get("gp", &s))
setUnlocks(s, ChallengeData::UNLOCK_GP);
else if(unlocks[i]->get("mode", &s))
setUnlocks(s, ChallengeData::UNLOCK_MODE);
else if(unlocks[i]->get("difficulty", &s))
setUnlocks(s, ChallengeData::UNLOCK_DIFFICULTY);
else
{
Log::warn("ChallengeData", "Unknown unlock entry. Must be one of kart, track, gp, mode, difficulty.");
throw std::runtime_error("Unknown unlock entry");
}
}
} // ChallengeData