C++ Event::GetTargetElement方法代码示例

void DebugOverlayHandler::ProcessEvent(Rocket::Core::Event& event, const Rocket::Core::String& value)
{
    if (value == "load_debug_overlay")
    {   
        gFpsField = event.GetTargetElement()->GetElementById("fps");
        gPos0Field = event.GetTargetElement()->GetElementById("pos0");
        gPos1Field = event.GetTargetElement()->GetElementById("pos1");
    }
}

// Processes an event coming through from Rocket.
void EventManager::ProcessEvent(Rocket::Core::Event& event, const Rocket::Core::String& value)
{
	Rocket::Core::StringList commands;
	Rocket::Core::StringUtilities::ExpandString(commands, value, ';');
	for (size_t i = 0; i < commands.size(); ++i)
	{
		// Check for a generic 'load' or 'exit' command.
		Rocket::Core::StringList values;
		Rocket::Core::StringUtilities::ExpandString(values, commands[i], ' ');

		if (values.empty())
			return;

		if (values[0] == "goto" &&
 			values.size() > 1)
		{
			// Load the window, and if successful close the old window.
			if (LoadWindow(values[1]))
				event.GetTargetElement()->GetOwnerDocument()->Close();
		}
		else if (values[0] == "load" &&
 			values.size() > 1)
		{
			// Load the window.
			LoadWindow(values[1]);
		}
		else if (values[0] == "close")
		{
			Rocket::Core::ElementDocument* target_document = NULL;

			if (values.size() > 1)
				target_document = context->GetDocument(values[1].CString());
			else
				target_document = event.GetTargetElement()->GetOwnerDocument();

			if (target_document != NULL)
				target_document->Close();
		}
		else if (values[0] == "exit")
		{
			Shell::RequestExit();
		}
		else if (values[0] == "pause")
		{
			GameDetails::SetPaused(true);
		}
		else if (values[0] == "unpause")
		{
			GameDetails::SetPaused(false);
		}
		else
		{
			if (event_handler != NULL)
				event_handler->ProcessEvent(event, commands[i]);
		}
	}
}

void EventHandlerHighScore::ProcessEvent(Rocket::Core::Event& event, const Rocket::Core::String& value)
{
	if (value == "add_score")
	{
		int score = GameDetails::GetScore();
		if (score > 0)
		{
			// Submit the score the player just got to the high scores chart.
			HighScores::SubmitScore(GameDetails::GetDefenderColour(), GameDetails::GetWave(), GameDetails::GetScore());
			// Reset the score so the chart won't get confused next time we enter.
			GameDetails::ResetScore();
		}
	}
	else if (value == "enter_name")
	{
		if (event.GetParameter< int >("key_identifier", Rocket::Core::Input::KI_UNKNOWN) == Rocket::Core::Input::KI_RETURN)
		{
			Rocket::Core::String name = event.GetCurrentElement()->GetAttribute< Rocket::Core::String >("value", "Anon.");
			HighScores::SubmitName(name);
		}
	}
	else if (value == "check_input")
	{
		Rocket::Core::Element* name_input_field = event.GetTargetElement()->GetElementById("player_input");
		if (name_input_field)
		{
			name_input_field->Focus();
		}
	}
	else if (value == "check_name")
	{
		/* TODO: Check if the player hasn't set their name first. */
		HighScores::SubmitName("Anon.");
	}
}

void ShortcutBar::shortcutClicked(Rocket::Core::Event& event)
{
   Rocket::Core::Element* shortcutElement = event.GetTargetElement();

   while(shortcutElement != nullptr && shortcutElement->GetParentNode() != m_shortcutContainer)
   {
      shortcutElement = shortcutElement->GetParentNode();
   }

   // Only handle the click if it went to a shortcut
   // (direct child of the shortcut bar container)
   if (shortcutElement != nullptr)
   {
      // Find the index of the shortcut
      int shortcutIndex = 0;

      for(;;)
      {
         shortcutElement = shortcutElement->GetPreviousSibling();
         if (shortcutElement == nullptr) break;
         ++shortcutIndex;
      }

      bool shortcutInvoked = invokeShortcut(shortcutIndex);
      if (shortcutInvoked)
      {
         refresh();
      }
   }
}

void UI_ScriptDocument::ProcessEvent( Rocket::Core::Event &event )
{
	if( event.GetType() == "afterLoad" && event.GetTargetElement() == this ) {
		if( module ) {
			owner = event.GetParameter<void *>( "owner", NULL );

			as->finishBuilding( module );
			as->setModuleUserData( module, owner );
		}

		isLoading = false;

		// handle postponed onload events (HOWTO handle these in cached documents?)
		for( PostponedList::iterator it = onloads.begin(); it != onloads.end(); ++it ) {
			Rocket::Core::Event *load = *it;
			this->DispatchEvent( load->GetType(), *(load->GetParameters()), true );
			load->RemoveReference();
		}

		// and clear the events
		onloads.clear();
		return;
	}

	if( event.GetType() == "beforeUnload" && event.GetTargetElement() == this ) {
		if( module ) {
			// FIXME: destroy script event listeners here somehow!

			// destroy the AS module by name to prevent crashes in case multiple document instances share the same module pointer
			as->buildReset( GetSourceURL().CString() );
			module = NULL;
		}
		return;
	}

	if( isLoading ) {
		Rocket::Core::Event *instanced = Rocket::Core::Factory::InstanceEvent( event.GetTargetElement(),
			event.GetType(), *event.GetParameters(), true );
		onloads.push_back( instanced );
		event.StopPropagation();
		return;
	}

	Rocket::Core::ElementDocument::ProcessEvent( event );
}

// Regenerates the element's geometry.
void ElementImage::ProcessEvent(Rocket::Core::Event& event)
{
	Element::ProcessEvent(event);

	if (event.GetTargetElement() == this &&
		event == "resize")
	{
		GenerateGeometry();
	}
}

void ChatHandler::ProcessEvent(Rocket::Core::Event& event, const Rocket::Core::String& value)
{
    if (value == "load_chat")
    {   
        gChatLogField = event.GetTargetElement()->GetElementById("chatlog");
    }

    if (value == "enter_key")
    {
        if (event.GetParameter< int >("key_identifier", Rocket::Core::Input::KI_UNKNOWN) == Rocket::Core::Input::KI_RETURN)
        {
            DoChat(event);
        }
    }
}

void ChatHandler::DoChat(Rocket::Core::Event& event)
{
    auto chatline = event.GetTargetElement()->GetElementById("chatline");
    if (chatline)
    {
        auto line = chatline->GetAttribute<Rocket::Core::String>("value", "");
        if (line.Length() > 0)
        {
            cl_player_chat(line.CString());
        }
    }
    else
    {
        // ASSERT
    }
    
}

void DragListener::ProcessEvent(Rocket::Core::Event& event)
{
	if (event == "dragdrop")
	{
		Rocket::Core::Element* dest_container = event.GetCurrentElement();
		Rocket::Core::Element* dest_element = event.GetTargetElement();
		Rocket::Core::Element* drag_element = static_cast< Rocket::Core::Element* >(event.GetParameter< void* >("drag_element", NULL));

		if (dest_container == dest_element)
		{
			// The dragged element was dragged directly onto a container.
			drag_element->GetParentNode()->RemoveChild(drag_element);
			dest_container->AppendChild(drag_element);
		}
		else
		{
			// The dragged element was dragged onto an item inside a container. In order to get the
			// element in the right place, it will be inserted into the container before the item
			// it was dragged on top of.
			Rocket::Core::Element* insert_before = dest_element;

			// Unless of course if it was dragged on top of an item in its own container; we need
			// to check then if it was moved up or down with the container.
			if (drag_element->GetParentNode() == dest_container)
			{
				// Check whether we're moving this icon from the left or the right.

				Rocket::Core::Element* previous_icon = insert_before->GetPreviousSibling();
				while (previous_icon != NULL)
				{
					if (previous_icon == drag_element)
					{
						insert_before = insert_before->GetNextSibling();
						break;
					}

					previous_icon = previous_icon->GetPreviousSibling();
				}
			}

			drag_element->GetParentNode()->RemoveChild(drag_element);
			dest_container->InsertBefore(drag_element, insert_before);
		}
	}
}

void SaveMenu::saveGameClicked(Rocket::Core::Event& event)
{
   Rocket::Core::Element* target = event.GetTargetElement();

   // Move up the DOM to the datagridrow item holding this element
   while(target->GetParentNode() != nullptr && target->GetTagName() != "datagridrow")
   {
      target = target->GetParentNode();
   }

   if(target != nullptr)
   {
      // If we found a row element, cast it and get its index
      Rocket::Controls::ElementDataGridRow* rowElement = dynamic_cast<Rocket::Controls::ElementDataGridRow*>(target);
      if(rowElement != nullptr)
      {
         int saveGameIndex = rowElement->GetParentRelativeIndex();
         showConfirmDialog(saveGameIndex);
      }
   }
}

  void UI::processEvent(const Rocket::Core::Event& event) {
    Rocket::Core::String type = event.GetType();
    event_count_++;

    //if (event == "resize") {
    //  if (renderer_content_ != NULL && renderer_content_->HasChildNodes()) {
    //    renderer_content_->GetLastChild()->ScrollIntoView();
    //  }
    //  return;
    //}

    if (type == "mouseover" || type == "dragstart") {
      mouse_over_count_++;
    } else if (type == "mouseout" || type == "dragend") {
      mouse_over_count_--;
    } else if (type == "change") {
      // An input element changed:
      Element* target = event.GetTargetElement();
      if (target != NULL) {
        // All our "changable" elements need to have a type attribute (we
        // need to put them there).  Make sure this one has one and that
        // it is of type string.
        if (target->GetAttribute("type") == NULL || 
          target->GetAttribute("type")->GetType() != Variant::Type::STRING) {
            std::wstringstream ss;
            ss << L"UI::processEvent() - ERROR: the current target element";
            ss << L" either does not have an attribute named type or that";
            ss << L" attribute is not of type string";
            throw wruntime_error(ss.str());
        }
        String elem_type = target->GetAttribute("type")->Get<String>();
        // Do the same for the value element (which stores the setting string)
        if (target->GetAttribute("value") == NULL || 
          target->GetAttribute("value")->GetType() != Variant::Type::STRING) {
            std::wstringstream ss;
            ss << L"UI::processEvent() - ERROR: the current target element";
            ss << L" either does not have an attribute named value or that";
            ss << L" attribute is not of type string";
            throw wruntime_error(ss.str());
        }
        String val_str = target->GetAttribute("value")->Get<String>();

        // Now handle the different types of elements
        if (elem_type == "checkbox") {  // Handle checkbox
          bool old_value = false;
          GET_SETTING(val_str.CString(), bool, old_value);

          // Set the internal setting (in the setting manager)
          bool value = false;
          if (target->GetAttribute("checked")) {
            value = true;
          }
          SET_SETTING(val_str.CString(), bool, value);

          // Handle special cases (that need to do something immediately)
          if (val_str == "fullscreen") {
            if (old_value != value) {
              Renderer::requestReloadRenderer();
              return;
            }
          }

          // Handle special cases that require the app to do something after 
          // the variable has been set.
          if (val_str == "render_ui") {
            setVisibility(value, renderer_doc_);
          }
        } else if (elem_type == "selectbox") {

// Processes an event coming through from Rocket.
void EventManager::ProcessEvent(Rocket::Core::Event& event, const Rocket::Core::String& value)
{
    Rocket::Core::StringList commands;
    Rocket::Core::StringUtilities::ExpandString(commands, value, ';');

    if(commands.size() == 0)
    {
        //send only the event to event handlers
        for(EventHandlerMap::iterator it = event_handlers.begin(); it != event_handlers.end(); it++)
            if(it->second != NULL)
                it->second->ProcessEvent(event, "");
    }
    else
    {
        for (size_t i = 0; i < commands.size(); ++i)
        {
            // Check for a generic 'load' or 'exit' command.
            Rocket::Core::StringList values;
            Rocket::Core::StringUtilities::ExpandString(values, commands[i], ' ');

            //if (values.empty())
            //	return;

            if (values[0] == "goto" &&
                    values.size() > 1)
            {
                // Load the window, and if successful close the old window.
                if (LoadWindow(values[1]))
                    event.GetTargetElement()->GetOwnerDocument()->Close();
            }
            else if (values[0] == "load" &&
                     values.size() > 1)
            {
                // Load the window.
                LoadWindow(values[1]);
            }
            else if (values[0] == "close")
            {
                Rocket::Core::ElementDocument* target_document = NULL;

                if (values.size() > 1)
                    target_document = Context->GetDocument(values[1].CString());
                else
                    target_document = event.GetTargetElement()->GetOwnerDocument();

                if (target_document != NULL)
                    target_document->Close();
            }
            else if (values[0] == "exit")
            {
                Shell::RequestExit();
            }
            /*
            		else if (values[0] == "pause")
            		{
            			GameDetails::SetPaused(true);
            		}
            		else if (values[0] == "unpause")
            		{
            			GameDetails::SetPaused(false);
            		}
            */
            else
            {
                //send the event to all windows
                for(EventHandlerMap::iterator it = event_handlers.begin(); it != event_handlers.end(); it++)
                    if(it->second != NULL)
                        it->second->ProcessEvent(event, commands[i]);

                /*
                if (event_handler != NULL)
                {
                	event_handler->ProcessEvent(event, commands[i]);
                }
                */
            }
        }
    }
}

void ShortcutBar::usableDropped(Rocket::Core::Event& event)
{
   Rocket::Core::Element* dragElement = static_cast<Rocket::Core::Element*>(event.GetParameter< void* >("drag_element", nullptr));
   if (dragElement != nullptr)
   {
      const bool isItem = dragElement->HasAttribute("itemId");
      const bool isSkill = dragElement->HasAttribute("skillId") && dragElement->HasAttribute("characterId");

      UsableId usableId = 0;

      if(isItem)
      {
         usableId = static_cast<UsableId>(dragElement->GetAttribute<int>("itemId", 0));
      }
      else if(isSkill)
      {
         usableId = static_cast<UsableId>(dragElement->GetAttribute<int>("skillId", 0));
      }

      if(usableId > 0)
      {
         Rocket::Core::Element* dropElement = event.GetTargetElement();

         // Only drops on direct children of the shortcut container count as
         // shortcut drops
         if(dropElement->GetParentNode() == m_shortcutContainer)
         {
            // Find the index of the shortcut
            int dropTargetIndex = 0;

            for(;;)
            {
               dropElement = dropElement->GetPreviousSibling();
               if (dropElement == nullptr) break;
               ++dropTargetIndex;
            }

            bool isShortcutSet = false;
            if(isItem)
            {
               DEBUG("Dropping item %d on shortcut index %d.", usableId, dropTargetIndex);
               m_playerData.setShortcut(dropTargetIndex, usableId);
               isShortcutSet = true;
            }
            else if(isSkill)
            {
               const std::string characterId = dragElement->GetAttribute<Rocket::Core::String>("characterId", "").CString();
               Character* character = m_playerData.getRoster()->getCharacter(characterId);

               if(character != nullptr)
               {
                  DEBUG("Dropping skill %d on shortcut index %d.", usableId, dropTargetIndex);
                  m_playerData.setShortcut(dropTargetIndex, usableId, characterId);
                  isShortcutSet = true;
               }
            }

            if(isShortcutSet)
            {
               // If the drag was initiated from the shortcut bar, then
               // clear out the shortcut's original slot
               if (dragElement->GetParentNode() == m_shortcutContainer)
               {
                  int dragTargetIndex = 0;
                  for(;;)
                  {
                     dragElement = dragElement->GetPreviousSibling();
                     if (dragElement == nullptr) break;
                     ++dragTargetIndex;
                  }

                  m_playerData.clearShortcut(dragTargetIndex);
               }
            }

            refresh();
         }
      }
   }
}

/// \brief Event listener callback for "mouseup" events generated by libRocket.
///
/// \param ev     The object containing event info.
/// \param store  The UIDataViewList widget to use.
/// \param db     The cards database to use for comparison against model
///               (table) data.
/// \param model  The data source model to use.
/// \param player_hand  The mock player hand object to use for holding card
///                     data, such as totals on number of cards of a type.
void on_mouseup(  Rocket::Core::Event& ev,
                  UIDataViewList* store,
                  const std::shared_ptr<CardCollection> db,
                  std::shared_ptr<CardsPageDataSource> model,
                  std::map<int,Card>& player_hand )
{
  EXPECT_TRUE( store != nullptr );
  EXPECT_TRUE( db != nullptr );
  EXPECT_TRUE( model != nullptr );

  // ID of card selection
  int selection = 0;
  Rocket::Core::Element* target = ev.GetTargetElement();

  if( ev == "mouseup" )
  {
    Rocket::Core::Input::KeyIdentifier button =
      (Rocket::Core::Input::KeyIdentifier) ev.GetParameter<int>("button", 3);

    EXPECT_TRUE( model->per_page() == model->GetNumRows("cards") );
    EXPECT_EQ( 57, model->num_rows() );

    if( target ) {

      Card card = model->lookup_by_name( target->GetInnerRML().CString() );
      selection = card.id();

      if( target->GetTagName() == "card" && button == 0 ) // Left click
      {
        // Card selection logic; player hand receives a card
        //
        // 1. Decrease available card count by one
        // 2. Sync the cards model to reflect modified card count (-1)
        // 3. Update player hand w/ a copy of the reference card
        if( card.num() > 0 )
        {
          card.set_num( card.num() - 1 );
          model->insert_card(selection, card);
          player_hand[card.id()] = card;
        }

      } // end if button == 0
      else if( target->GetTagName() == "card" && button == 1 )  // Right click
      {
        // Compare the selected card from the current model with the game
        // database; we rely on the game database to be the "safe" -- read-only.
        Card ref_card = db->lookup_by_id(selection);

        // Card selection logic; player hand removes a card
        //
        // 1. Increase available card count by one
        // 2. Sync the cards model to reflect modified card count (+1)
        // 3. Remove the card from the player's hand
        if( card.num() < ref_card.num() )
        {
          card.set_num( card.num() + 1 );
          model->insert_card(selection, card);
          player_hand.erase( card.id() );
        }
      } // end if button == 1

      NOM_LOG_INFO( NOM_LOG_CATEGORY_TEST, "Card ID:", selection );
      NOM_LOG_INFO( NOM_LOG_CATEGORY_TEST, "Card name:", target->GetInnerRML().CString() );

    } // end if target

  } // end if click
} // end func on_mouseup