C++ IAction类代码示例

void CGeorgesEditDoc::OnEditUndo() 
{
	if (!_UndoBuffer.empty ())
	{
		// Get an action
		IAction *action = _UndoBuffer.back ();
		_UndoBuffer.pop_back ();

		// Undo it
		bool modified;
		action->doAction (*this, false, modified, false);

		// Put in the redo list
		_RedoBuffer.push_back (action);

		CMDIFrameWnd* pMainWnd = (CMDIFrameWnd*)AfxGetMainWnd();

		// Get the active MDI child window.
		CMDIChildWnd* pChild = (CMDIChildWnd*)pMainWnd->MDIGetActive();
		pChild->RecalcLayout();
		pChild->UpdateWindow();

		_UndoModify--;
		if ( (_UndoModify == 0) && IsModified () )
		{
			setModifiedState (false);
		}
		else if ( (_UndoModify != 0) && !IsModified () )
		{
			setModifiedState (true);
		}
	}
}

void CGeorgesEditDoc::OnEditRedo() 
{
	if (!_RedoBuffer.empty ())
	{
		// Get an action
		IAction *action = _RedoBuffer.back ();
		_RedoBuffer.pop_back ();

		// Undo it
		bool modified;
		action->doAction (*this, true, modified, false);

		// Put in the redo list
		_UndoBuffer.push_back (action);

		((CMainFrame*)(theApp.m_pMainWnd))->RecalcLayout ();

		_UndoModify++;
		if ( (_UndoModify == 0) && IsModified () )
		{
			setModifiedState (false);
		}
		else if ( (_UndoModify != 0) && !IsModified () )
		{
			setModifiedState (true);
		}
	}
}

void ActionList::LoadFromS11nBlock(const ActionListS11nBlock& block)
{
	block.guid.GetValueIfExists(m_guid);

	if (block.name.Exists())
		m_name = pfc::stringcvt::string_wide_from_utf8(block.name.GetValue()).get_ptr();

	if (block.actions.Exists())
	{
		for (int i = 0; i < block.actions.GetSize(); ++i)
		{
			const ActionS11nBlock& actionBlock = block.actions.GetAt(i);

			// actionGUID is a required field, unnecessary to check if it exists.
			IAction* pPrototype = ServiceManager::Instance().GetActionPrototypesManager().
				GetPrototypeByGUID(actionBlock.actionGUID.GetValue());

			if (!pPrototype)
				continue;

			std::auto_ptr<IAction> pAction(pPrototype->Clone());
			pAction->LoadFromS11nBlock(actionBlock);

			m_actions.push_back(pAction);
		}
	}
}

	void IToolBar::actionTriggeredSlot(bool checked)
	{
		IAction* action = dynamic_cast<IAction*> (sender());
		if(action)
		{
			action->execute();
		}					
	}

int main()
{
   std::cout << "action hello" << std::endl;
   Printer p;
   boost::function<void(std::string)> f = boost::bind(&Printer::printString, &p, _1);

   f(std::string("hello"));

   //boost::function<void(std::string)> f = boost::bind(&Printer::printString, &p);
   IAction* action = new TSingleArgAction<std::string>(ActionType::PRINT_STRING, f);

   TSingleArg<std::string> args("hello");
   action->call(args);
}

void QtMenu::destroyQAction(IAction& action)
{
	auto it = actions_.find(&action);
	if (it != actions_.end())
	{
		const std::string groupID(action.group());
		if (!groupID.empty())
		{
			auto groupItr = groups_.find(groupID);
			if (groupItr != groups_.end())
			{
				groupItr->second->removeAction(it->second.data());
				if (groupItr->second->actions().empty())
				{
					groups_.erase(groupItr);
				}
			}
		}
		actions_.erase(it);
	}

	auto findIt = connections_.find(&action);
	if (findIt != connections_.end())
	{
		connections_.erase(findIt);
	}
}

void QtMenuBar::addAction(IAction& action, const char* path)
{
	auto qAction = getQAction(action);
	if (qAction == nullptr)
	{
		qAction = createQAction(action);
	}
	assert(qAction != nullptr);

	path = relativePath(path);
	if (path == nullptr || strlen(path) == 0)
	{
		path = action.text();
	}

	auto tok = strchr(path, '.');
	auto menuPath = tok != nullptr ? QString::fromUtf8(path, tok - path) : path;
	QMenu* menu = qMenuBar_.findChild<QMenu*>(menuPath, Qt::FindDirectChildrenOnly);
	if (menu == nullptr)
	{
		menu = qMenuBar_.addMenu(menuPath);
		menu->setObjectName(menuPath);
	}
	path = tok != nullptr ? tok + 1 : nullptr;

	QtMenu::addMenuAction(*menu, *qAction, path);
	qMenuBar_.repaint();
}

void TestStoryboard() {
    List<Point> points;
    points.Add(Point(0, 0, 0));
    points.Add(Point(1, 1, 1));
    points.Add(Point(2, 2, 2));
    points.Add(Point(3, 3, 3));

    Shape shape(points);
    IAction* a = new TranslateAction(3, 3 , 3);
    IAction* b = new TranslateAction(2, 2 , 2);
    IAction* c = new TranslateAction(5, 5 , 5);
    a->SetSteps(3);
    b->SetSteps(3);
    c->SetSteps(4);
    b->SetWithPrevious(true);

    Storyboard sb;
    sb.Actions().Add(a);
    sb.Actions().Add(b);
    sb.Actions().Add(c);
    sb.SetShapeObject(shape);

    assert(sb.TotalSteps() == 10);
    assert(sb.CurrentAction() == NULL);

    sb.Play();
    for(size_t i = 0; i < sb.TotalSteps(); i++) {
        sb.NextStep();
    }
}

void Console::execute(const string& line) {
  vector<string> parts = StringUtil::split(line, ' ');
  if(parts.size() > 0) {
    string command = parts[0];
    IAction* action = basicLanguage[command];
    if(action) {
      string param;
      if(parts.size() > 1) {
        param = parts[1];
      }
      else {
        param = "";
      }

      action->execute(param);
    }
  }
}

  void ActionGroup::DoActions(IEntity* theEntity)
  {
    // Make sure clear all of our IAction classes
    std::map<const typeActionID, IAction*>::iterator anActionIter;

    // Start at the beginning of the list of IAction classes
    anActionIter = mActive.begin();
    while(anActionIter != mActive.end())
    {
      // Get the IAction to execute
      IAction* anAction = anActionIter->second;

      // Move on to the next iterator
      anActionIter++;

      // Call the IAction DoAction method and provide theEntity to it
      anAction->DoAction(theEntity);
    }
  }

void CInteractiveObjectRegistry::ApplyInteractionToObject(IEntity *pEntity, const TagID interactionTypeTag, const int interactionIndex) const
{
	if (m_pDatabaseObject && m_pControllerDef)
	{
		IMannequin &mannequinSys = gEnv->pGame->GetIGameFramework()->GetMannequinInterface();
		SAnimationContext animContext(*m_pControllerDef);

		IActionController *pActionController = mannequinSys.CreateActionController(pEntity, animContext);

		int scopeContextID = m_pControllerDef->m_scopeContexts.Find("SlaveObject");
		pActionController->SetScopeContext(scopeContextID, *pEntity, pEntity->GetCharacter(0), m_pDatabaseObject);
		TagState fragTags = TAG_STATE_EMPTY;
		const CTagDefinition *pTagDef = m_pControllerDef->GetFragmentTagDef(m_interactFragID);
		if (pTagDef)
		{
			pTagDef->Set(fragTags, interactionTypeTag, true);
		}
		IAction *pAction = new TAction<SAnimationContext>(0, m_interactFragID, fragTags);
		pAction->SetOptionIdx(interactionIndex);
		pActionController->Queue(pAction);

		// Set the time increments to non-zero to force the ActionController::Update() to drive the animation to the end.
		// When time increment is zero, animation position will not update. This will be changed to a simpler process by Tom Berry at some point.
		const uint32 totalScopes = pActionController->GetTotalScopes();
		for(uint32 s=0; s<totalScopes; ++s)
		{
			pActionController->GetScope(s)->IncrementTime(0.001f);
		}
		pActionController->Update(1000.0f);
		// "false" here leaves the anim on the transition queue in the animation system so it isn't cleared on pActionController->Release().
		pActionController->ClearScopeContext(scopeContextID, false);

		pActionController->Release();

		CRecordingSystem* pRecordingSystem = g_pGame->GetRecordingSystem();
		if (pRecordingSystem)
		{
			pRecordingSystem->OnInteractiveObjectFinishedUse(pEntity->GetId(), interactionTypeTag, interactionIndex);
		}

	}
}

EPriorityComparison CReplayObjectAction::ComparePriority( const IAction &actionCurrent ) const
{
	if (m_trumpsPrevious)
	{
		return ((IAction::Installed == actionCurrent.GetStatus() && IAction::Installing & ~actionCurrent.GetFlags()) ? Higher : BaseClass::ComparePriority(actionCurrent));
	}
	else
	{
		return Equal;
	}
}

void LayoutManager::addAction(IAction& action)
{
	actions_.push_back(&action);

	auto window = getWindow(action.windowId());
	if (window == nullptr)
	{
		return;
	}

	addAction(actions_.back(), *window);
}

void ActionChain::update(Time delta) {
    if(m_isAlive) {
        // Store currently used action for convenience
        IAction* action = m_actions[m_currentIndex];

        // Update the action
        action->update(delta);

        // Check if action is finished
        if(action->isFinished()) {
            action->close();

            // Iterate to the next action
            m_currentIndex++;

            // If the action was last one in the chain
            if(m_currentIndex == m_actions.size()) {
                // If the chain is looping, start over
                if(m_isLooping) {
                    for(IAction* action : m_actions) {
                        action->reset();
                    }

                    m_currentIndex = 0;

                    // Initialize first action
                    m_actions[m_currentIndex]->init();
                }
                // Otherwise destroy the chain
                else {
                    m_isAlive = false;
                }
            }
            else {
                // Initialize next action
                m_actions[m_currentIndex]->init();
            }
        }
    }
}

void QtMenuBar::removeAction(IAction& action)
{
	auto qAction = getQAction(action);
	if (qAction == nullptr)
	{
		NGT_ERROR_MSG("Target action '%s' '%s' does not exist\n", action.text(),
		              StringUtils::join(action.paths(), ';').c_str());
		return;
	}

	auto menus = qMenuBar_.findChildren<QMenu*>(QString(), Qt::FindDirectChildrenOnly);
	for (auto& menu : menus)
	{
		QtMenu::removeMenuAction(*menu, *qAction);
		if (menu->isEmpty())
		{
			delete menu;
		}
	}

	destroyQAction(action);
}