C++ Redo函数代码示例

void Scene_Order::UpdateConfirm() {
	if (Input::IsTriggered(Input::CANCEL)) {
		Redo();
	} else if (Input::IsTriggered(Input::DECISION)) {
		if (window_confirm->GetIndex() == 0) {
			Confirm();
			Scene::Pop();
		} else {
			Redo();
		}
	}
}

bool mitk::LimitedLinearUndo::Redo()
{
  if (m_RedoList.empty()) return false;

  int redoObjectEventId = m_RedoList.back()->GetObjectEventId();
  return Redo( redoObjectEventId );
}

void ImageGroundTruthPanelViewer::on_key_down(wxKeyEvent & event)
{
    if(event.ControlDown() && event.GetUnicodeKey() == 'O')
    {
        InitIO();
        return;
    }

    if(mp_ground_truth_manager->IsEmpty())
    {
        return ;
    }

    try
    {
        switch(event.GetKeyCode())
        {
            case WXK_PAGEUP: LoadNextImage(); break;
            case WXK_PAGEDOWN: LoadPreviousImage(); break;
        }
        if(event.ControlDown())
        {
            switch(event.GetUnicodeKey())
            {
                case 'S': Save(); break;
                case 'Z': Undo(); break;
                case 'Y': Redo(); break;
                case 'A': MarkAsBlind(); break;
                case 'I': MarkAsUnknown(); break;
                case 'R': Reject(); break;
            }
        }
    }
    JPB_wx_CATCH("échec de l'ajout d'une boîtes englobante d'occlusion");
}

void
MainWindow::InitEditMenu()
///
/// Initializes the edit menu and it's associated actions
///
/// @return
///  Nothing
///
{
	mUndoAction = new QAction( tr("&Undo"), this);
	mRedoAction = new QAction( tr("&Redo"), this);

	mEditMenu = menuBar()->addMenu( tr("&Edit") );
	mEditMenu->addAction( mUndoAction );
	mEditMenu->addAction( mRedoAction );

	// Connect the menu actions to their respective slots
	connect( mUndoAction, SIGNAL( triggered() ), this, SLOT( Undo() ) );
	connect( mRedoAction, SIGNAL( triggered() ), this, SLOT( Redo() ) );

	// Disable the actions until the main window broadcasts for them to be active
	mUndoAction->setDisabled( true );
	mRedoAction->setDisabled( true );

	connect( this, SIGNAL( UndoIsActive(bool) ), mUndoAction, SLOT( setEnabled(bool) ) );
	connect( this, SIGNAL( RedoIsActive(bool) ), mRedoAction, SLOT( setEnabled(bool) ) );
}

void MainWindow::CreateProjectNew(bool newProjectFile)
{
	if (newProject)
		delete newProject;

	if (newProjectFile)
	{
		newProject = new Project_new(this);
	} else {
		QStringList selections;
		QFileDialog dialog(0, "Open an ADCIRC Subdomain Project", QDir::homePath());
		dialog.setModal(true);
		dialog.setNameFilter("ADCIRC Subdomain Projects (*.spf)");
		dialog.setFileMode(QFileDialog::ExistingFile);
		if (dialog.exec())
		{
			selections = dialog.selectedFiles();
			if (!selections.isEmpty())
			{
				newProject = new Project_new(selections.first(), this);
			}
		} else {
			return;
		}
	}

	newProject->SetOpenGLPanel(ui->GLPanel);
	newProject->SetProgressBar(ui->progressBar);
	newProject->SetProjectTree(ui->projectTree);

	/* Subdomain Creation */
	connect(ui->createSubdomainButton, SIGNAL(clicked()), newProject, SLOT(CreateNewSubdomain()));

	/* Selection Tools */
	connect(ui->selectNodesCircle, SIGNAL(clicked()), newProject, SLOT(SelectFullDomainCircleElements()));
	connect(ui->selectElementSingle, SIGNAL(clicked()), newProject, SLOT(SelectFullDomainClickElements()));
	connect(ui->selectNodeSingle, SIGNAL(clicked()), newProject, SLOT(SelectFullDomainPolygonElements()));
	connect(ui->selectNodesSquare, SIGNAL(clicked()), newProject, SLOT(SelectFullDomainRectangleElements()));

	connect(ui->undoButton, SIGNAL(clicked()), newProject, SLOT(Undo()));
	connect(ui->redoButton, SIGNAL(clicked()), newProject, SLOT(Redo()));

	/* U/I Updates */
	connect(newProject, SIGNAL(mouseX(float)), this, SLOT(showMouseX(float)));
	connect(newProject, SIGNAL(mouseY(float)), this, SLOT(showMouseY(float)));
	connect(newProject, SIGNAL(undoAvailable(bool)), ui->undoButton, SLOT(setEnabled(bool)));
	connect(newProject, SIGNAL(redoAvailable(bool)), ui->redoButton, SLOT(setEnabled(bool)));
	connect(newProject, SIGNAL(numElements(int)), this, SLOT(showNumElements(int)));
	connect(newProject, SIGNAL(numNodes(int)), this, SLOT(showNumNodes(int)));
	connect(newProject, SIGNAL(numElementsSelected(int)), this, SLOT(showNumSelectedElements(int)));
	connect(newProject, SIGNAL(numNodesSelected(int)), this, SLOT(showNumSelectedNodes(int)));
	connect(newProject, SIGNAL(maxSelectedZ(float)), this, SLOT(showMaxSelectedZ(float)));
	connect(newProject, SIGNAL(minSelectedZ(float)), this, SLOT(showMinSelectedZ(float)));
	connect(newProject, SIGNAL(showProjectView()), this, SLOT(showProjectExplorerPane()));

	/* Running ADCIRC */
	connect(ui->actionFull_Domain, SIGNAL(triggered()), newProject, SLOT(RunFullDomain()));
}

void CEditWnd::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	CTextWnd::OnSysKeyDown(nChar, nRepCnt, nFlags);
	bool isAlt = (GetKeyState(VK_MENU) & 0xF0) != 0;
	bool isShift = (GetKeyState(VK_SHIFT) & 0xF0) != 0;
	bool isCtrl = (GetKeyState(VK_CONTROL) & 0xF0) != 0;
	if (nChar == VK_BACK && isShift && isAlt)
		Redo();
	if ((nChar == VK_BACK && isAlt)) 
		Undo();
}

SInt32 CDXUndoStack::GoTo(SInt32 index, bool doUpdate)
{
	SInt32 result = -1;
	SInt32 amount = index - m_index;

	if (amount == 0)
		return m_index;

	for (UInt32 i = 0; i < abs(amount); i++) {
		result = amount < 0 ? Undo(doUpdate) : Redo(doUpdate);
	}
	
	return result;
}

bool DeleteMap::HandleAction(QString &action, uint64_t frame, uint64_t played)
{
    bool handled = true;
    if (action == ACTION_UP)
        UpdateSeekAmount(1);
    else if (action == ACTION_DOWN)
        UpdateSeekAmount(-1);
    else if (action == ACTION_CLEARMAP)
        Clear(tr("Clear Cuts"));
    else if (action == ACTION_INVERTMAP)
        ReverseAll();
    else if (action == "MOVEPREV")
        MoveRelative(frame, false);
    else if (action == "MOVENEXT")
        MoveRelative(frame, true);
    else if (action == "CUTTOBEGINNING")
    {
        Push(tr("Cut to Beginning"));
        AddMark(frame, MARK_CUT_END);
    }
    else if (action == "CUTTOEND")
    {
        Push(tr("Cut to End"));
        AddMark(frame, MARK_CUT_START);
        // If the recording is still in progress, add an explicit end
        // mark at the end.
        if (m_ctx->player && m_ctx->player->IsWatchingInprogress())
            AddMark(m_ctx->player->GetTotalFrameCount() - 1, MARK_CUT_END);
    }
    else if (action == "NEWCUT")
        NewCut(frame);
    else if (action == "DELETE")
        //: Delete the current cut or preserved region
        Delete(frame, tr("Delete"));
    else if (action == "UNDO")
        Undo();
    else if (action == "REDO")
        Redo();
    else
        handled = false;
    return handled;
}

void  Engine::input(sf::Event *event)
{
    bool a = sf::Keyboard::isKeyPressed(sf::Keyboard::A);
    bool b = sf::Keyboard::isKeyPressed(sf::Keyboard::S);
    if (a && !b) setMode(EDITOR_1);
    else if (!a && b) setMode(EDITOR_2);
    else
        setMode(DEFAULT);

    bool n1 = false;
    bool n2 = false;
    if (event->type == sf::Event::KeyReleased)
    {
        if (event->key.code == sf::Keyboard::Num1) n1 = true;
        if (event->key.code == sf::Keyboard::Num2) n2 = true;

        if (event->key.code == sf::Keyboard::Z) Undo();
        if (event->key.code == sf::Keyboard::Y) Redo();
        if (event->key.code == sf::Keyboard::Space) saveConfig();

        if (event->key.code == sf::Keyboard::Return) renderToFile();

        if (event->key.code == sf::Keyboard::P)  fullOrWindowScreen();
    }


    if (a && !b) setMode(EDITOR_1);
    else if (!a && b) setMode(EDITOR_2);
    else
        setMode(DEFAULT);

    if (n1 && !n2) setTool(LINE);
    else if (!n1 && n2) setTool(CIRCLE);


    if (mode == EDITOR_1)
        editor1->input(event, window);

    if (mode == EDITOR_2)
        editor2->input(event, window);
}

void CommandManager::DoCommand(Command* pCommand, std::string& feedback){
	if(pCommand->getType() == UNDO){
		Undo(feedback);
	} else if(pCommand->getType() == REDO){
		Redo();
	} else {
		// Clear redo list
		if(pCommand->getType() != DISPLAY){
			ClearRedoList();
		}
		// Execute the command and add it to undo list if succeeded
		if (pCommand->execute(_taskList,feedback)){
			if(undoable(pCommand)){
				AddUndo(pCommand);
			} else {
				delete pCommand;
				pCommand = NULL;
			}
		}
	}
}

void SceneStructureWindow::SetShownScene(const ScenePtr &newScene)
{
    if (!scene.expired() && newScene == scene.lock())
        return;

    ScenePtr previous = ShownScene();
    if (previous)
    {
        disconnect(previous.get());
        Clear();
    }

    scene = newScene;
    treeWidget->SetScene(newScene);

    if (newScene)
    {
        // Now that treeWidget has scene, it also has UndoManager.
        UndoManager *undoMgr = treeWidget->GetUndoManager();
        undoButton_->setMenu(undoMgr->UndoMenu());
        redoButton_->setMenu(undoMgr->RedoMenu());
        connect(undoMgr, SIGNAL(CanUndoChanged(bool)), this, SLOT(SetUndoEnabled(bool)), Qt::UniqueConnection);
        connect(undoMgr, SIGNAL(CanRedoChanged(bool)), this, SLOT(SetRedoEnabled(bool)), Qt::UniqueConnection);
        connect(undoButton_, SIGNAL(clicked()), undoMgr, SLOT(Undo()), Qt::UniqueConnection);
        connect(redoButton_, SIGNAL(clicked()), undoMgr, SLOT(Redo()), Qt::UniqueConnection);

        Scene* s = ShownScene().get();
        connect(s, SIGNAL(EntityAcked(Entity *, entity_id_t)), SLOT(AckEntity(Entity *, entity_id_t)));
        connect(s, SIGNAL(EntityCreated(Entity *, AttributeChange::Type)), SLOT(AddEntity(Entity *)));
        connect(s, SIGNAL(EntityTemporaryStateToggled(Entity *, AttributeChange::Type)), SLOT(UpdateEntityTemporaryState(Entity *)));
        connect(s, SIGNAL(EntityRemoved(Entity *, AttributeChange::Type)), SLOT(RemoveEntity(Entity *)));
        connect(s, SIGNAL(ComponentAdded(Entity *, IComponent *, AttributeChange::Type)), SLOT(AddComponent(Entity *, IComponent *)));
        connect(s, SIGNAL(ComponentRemoved(Entity *, IComponent *, AttributeChange::Type)), SLOT(RemoveComponent(Entity *, IComponent *)));
        connect(s, SIGNAL(SceneCleared(Scene*)), SLOT(Clear()));

        Populate();
    }
}

String DisplayDirector::FunctionCall(String function, String arg, StyleScriptable* target)
{
	if (function == "actionAllowed") {
		bool result = false;
		arg = target->Eval(arg).trim();
		if (arg == "Save()")
			result = IsDirty();
		else if (arg == "Undo()")
			result = (lastAction != sentinalAction);
		else if (arg == "Redo()")
			result = (lastAction->NextAction() != NULL);
		else if (arg == "Copy()" || arg == "Cut()")
			result = (selection && selection->CanCopy());
		else if (arg == "Paste()")
			result = (selection && selection->CanPaste() && !System::GetClipboardText().empty());
		else if (arg.startsWith("doc-source.")) {
			arg = arg.substr(11, arg.length() - 11);
			return docSource->FunctionCall("actionAllowed", arg, target);
			}
		return (result ? "true" : "");
		}
	else if (function == "Undo")
		Undo();
	else if (function == "Redo")
		Redo();
	else if (function == "Save")
		Save();
	else if (function == "Copy")
		CopyToClipboard();
	else if (function == "Paste")
		Paste();
	else
		return StyleScriptable::FunctionCall(function, arg, target);

	return String();
}

ECEditorWindow::ECEditorWindow(Framework* fw, QWidget *parent) :
    QWidget(parent),
    framework(fw),
    ecBrowser(0),
    hasFocus(true)
{
    /// @todo Create UI fully in code (very simple UI file).
    setupUi(this);
    installEventFilter(this);

    Scene *scene = fw->Scene()->MainCameraScene();
    assert(scene);
    undoManager_ = new UndoManager(scene->shared_from_this(), this);
    transformEditor = new TransformEditor(scene->shared_from_this(), undoManager_);

    undoButton->setDisabled(true);
    redoButton->setDisabled(true);

    undoButton->setIcon(QIcon(Application::InstallationDirectory() + "data/ui/images/icon/undo-icon.png"));
    redoButton->setIcon(QIcon(Application::InstallationDirectory() + "data/ui/images/icon/redo-icon.png"));

    undoButton->setMenu(undoManager_->UndoMenu());
    redoButton->setMenu(undoManager_->RedoMenu());

    entityWidget->hide();

    ecBrowser = new ECBrowser(framework, this, browserWidget);
    ecBrowser->setMinimumWidth(100);
    browserWidget->layout()->addWidget(ecBrowser);

    // signals from attribute browser to editor window.
    connect(ecBrowser, SIGNAL(ShowXmlEditorForComponent(const QString &)), SLOT(ShowXmlEditorForComponent(const QString &)));
    connect(ecBrowser, SIGNAL(CreateNewComponent()), SLOT(CreateComponent()));
    connect(ecBrowser, SIGNAL(SelectionChanged(const QString&, const QString &, const QString&, const QString&)),
        SLOT(HighlightEntities(const QString&, const QString&)));
    connect(ecBrowser, SIGNAL(SelectionChanged(const QString&, const QString &, const QString&, const QString&)),
        SIGNAL(SelectionChanged(const QString&, const QString&, const QString&, const QString&)), Qt::UniqueConnection);

    ECEditorModule *ecEditorModule = framework->Module<ECEditorModule>();
    ecBrowser->SetItemExpandMemory(ecEditorModule->ExpandMemory());

    entityList->setSelectionMode(QAbstractItemView::ExtendedSelection);
    connect(entityList, SIGNAL(itemSelectionChanged()), this, SLOT(Refresh()));
    connect(entityList, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(ShowEntityContextMenu(const QPoint &)));

    connect(toggleEntitiesButton, SIGNAL(pressed()), this, SLOT(ToggleEntityList()));
    connect(expandOrCollapseButton, SIGNAL(clicked()), ecBrowser, SLOT(ExpandOrCollapseAll()));

    connect(scene, SIGNAL(EntityRemoved(Entity*, AttributeChange::Type)), SLOT(RemoveEntity(Entity*)), Qt::UniqueConnection);
    connect(scene, SIGNAL(ActionTriggered(Entity *, const QString &, const QStringList &, EntityAction::ExecTypeField)),
        SLOT(OnActionTriggered(Entity *, const QString &, const QStringList &)), Qt::UniqueConnection);

    connect(this, SIGNAL(FocusChanged(ECEditorWindow *)), ecEditorModule, SLOT(ECEditorFocusChanged(ECEditorWindow*)));
    connect(this, SIGNAL(EditEntityXml(const QList<EntityPtr> &)), ecEditorModule, SLOT(CreateXmlEditor(const QList<EntityPtr> &)));
    connect(this, SIGNAL(EditComponentXml(const QList<ComponentPtr> &)), ecEditorModule, SLOT(CreateXmlEditor(const QList<ComponentPtr> &)));
    //connect(this, SIGNAL(AttributeAboutToBeEdited(IAttribute *)), this, SLOT(OnAboutToEditAttribute(IAttribute* )));
    connect(undoManager_, SIGNAL(CanUndoChanged(bool)), this, SLOT(OnUndoChanged(bool)));
    connect(undoManager_, SIGNAL(CanRedoChanged(bool)), this, SLOT(OnRedoChanged(bool)));
    connect(undoButton, SIGNAL(clicked()), undoManager_, SLOT(Undo()));
    connect(redoButton, SIGNAL(clicked()), undoManager_, SLOT(Redo()));

    connect(framework->Input()->TopLevelInputContext(), SIGNAL(KeyPressed(KeyEvent*)), SLOT(OnKeyEvent(KeyEvent*)));

    // Make sure the editor is cleared if the scene is cleared or removed.
    connect(scene, SIGNAL(SceneCleared(Scene *)), SLOT(OnSceneRemoved(Scene *)));
    connect(framework->Scene(), SIGNAL(SceneAboutToBeRemoved(Scene *, AttributeChange::Type)), SLOT(OnSceneRemoved(Scene *)));
}

bool Game::PollEvents()
{
	SDL_Event event;
	
	/* Poll for events. SDL_PollEvent() returns 0 when there are no  */
	/* more events on the event queue, our while loop will exit when */
	/* that occurs.                                                  */
	while( SDL_PollEvent( &event ) )
	{
		/* We are only worried about SDL_KEYDOWN and SDL_KEYUP events */
		switch( event.type )
		{
			case SDL_KEYDOWN:
				switch (event.key.keysym.sym) 
				{
					case SDLK_ESCAPE:
						fprintf(stderr, "Hit Escape!n");
						m_bShouldQuit = true;
					return false;
					break;

					case SDLK_UP:
                                        case SDLK_8:
                                                Move(Up);
        	                                break;
                                        
                                        case SDLK_DOWN:
                                        case SDLK_2:
                                                Move(Down);
	                                        break;

					case SDLK_RIGHT:
					case SDLK_6:
						Move(Right);
						break;
					
					case SDLK_LEFT:
					case SDLK_4:
						Move(Left);
						break;

					case SDLK_PLUS:
						Redo();
						break;

					case SDLK_MINUS:
						Undo();
						break;

					default:
						break;
				}
				break;
			
			//Called when the mouse moves
			case SDL_MOUSEMOTION:
				break;
			
			case SDL_KEYUP:
				break;
			
			default:
				break;
		}
	}
	return true;
}

LRESULT CALLBACK HWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
		//case WM_ACTIVE:
		//break;
		case WM_KEYDOWN:
		case WM_KEYUP:
			CallWindowProc((WNDPROC)GetWindowLong(hGLWnd, GWL_WNDPROC), hGLWnd, msg, wParam, lParam);
			return TRUE;//オリジナルのメッセージ処理を行わないとLayouterWindow.cppが機能しない
		case WM_COMMAND:
		{
			switch(LOWORD(wParam))
			{
				case ID_FILE_NEW_LAYOUT:
				{
					//long nUndoBuffer = GetUndoBufferNum();
					//if(dwLastSaveTime){
					//	if(MBQ("This document has been modified. Save?")){
					//		CallWindowProc((WNDPROC)GetWindowLong(hWnd, GWL_WNDPROC), hWnd, WM_COMMAND, ID_FILE_SAVE_OW, 0);
					//	}
					//}
					FreeAll();
					RefreshAllView();
					break;
				}
				case ID_FILE_OPEN_LAYOUT:
				{
					char* szFile = (char*)GlobalAlloc(GPTR, sizeof(char) * 1024);
						if(GetOpenFileNameSingle(hGLWnd, "kdf", szFile, FALSE))
						{
							lstrcpy(g_szFileName, szFile);
							FreeAll();
							demo.Load(szFile);
							RefreshAllView();
						}
					GlobalFree(szFile);
					break;
				}
				case ID_FILE_SAVE_OW:
				{
					if(g_szFileName[0] == '\0')
					{
						char* szFile = (char*)GlobalAlloc(GPTR, sizeof(char) * 1024);
							if(GetSaveFileNameSingle(hGLWnd, "kdf", szFile, FALSE))
							{
								lstrcpy(g_szFileName, szFile);
							}else return TRUE;
						GlobalFree(szFile);
					}
					
					demo.Save(g_szFileName);
					RefreshAllView();
					break;
				}
				case ID_FILE_SAVE_AS:
				{
					char* szFile = (char*)GlobalAlloc(GPTR, sizeof(char) * 1024);
						if(GetSaveFileNameSingle(hGLWnd, "kdf", szFile, FALSE))
						{
							lstrcpy(g_szFileName, szFile);
							demo.Save(szFile);
							RefreshAllView();
						}
					GlobalFree(szFile);
					break;
				}
				case ID_FILE_EXPORT:
				{
					char* szFile = (char*)GlobalAlloc(GPTR, sizeof(char) * 1024);
						if(GetSaveFileNameSingle(hGLWnd, "kdb", szFile, FALSE))
						{
							//lstrcpy(g_szFileName, szFile);
							demo.BinarySave(szFile);
							MessageBox(hWnd, "Export done", "", MB_ICONINFORMATION|MB_OK|MB_TOPMOST);
							RefreshAllView();
						}
					GlobalFree(szFile);
					break;
				}
				case ID_FILE_EXIT:
				{
					VerifyOnExit();	
					break;
				}
				case ID_EDIT_UNDO:
				{
					Undo();	
					break;
				}
				case ID_EDIT_REDO:
				{
					Redo();	
					break;
				}
				case ID_MODE_LAYOUTER:
				{
					StopPlaying();

					nCurrentMode = LAYOUTER;
//.........这里部分代码省略.........