Instruktaż: Dodawanie animacji do projektu MFC

Artykuł
02/27/2013

W tym instruktażu uczy, jak dodać podstawowe animowanego obiektu w Visual C++, Microsoft Foundation klasy biblioteki (MFC) projektu.

Instruktaż przedstawia sposób tych zadań:

Tworzenie aplikacji MFC.
Dodawanie menu, a następnie dodać polecenia, aby uruchomić i zatrzymać animację.
Tworzenie programów obsługi dla polecenia start i stop.
Dodać animowany obiekt w projekcie.
Centrum animowany obiekt w oknie.
Sprawdź, czy wyniki.

[!UWAGA]

Na danym komputerze mogą być używane inne nazwy lub lokalizacje pewnych elementów interfejsu użytkownika programu Visual Studio, które są używane w poniższych instrukcjach. Używana wersja programu Visual Studio oraz jej ustawienia określają te elementy. Aby uzyskać więcej informacji, zobacz Visual Studio, ustawienia.

Wymagania wstępne

Do przeprowadzenia tego instruktażu, musi mieć Visual Studio.

Aby utworzyć aplikację MFC

Na pliku menu, wskaż Nowy i kliknij przycisk Projekt.
W Nowy projekt okno dialogowe, w lewym okienku w obszarze Szablonów, rozwiń węzeł Visual C++ i zaznacz MFC.W środkowym okienku wybierz Aplikacja MFC.W Nazwa wpisz MFCAnimationWalkthrough.Click OK.
W Kreatora aplikacji MFC okno dialogowe upewnij się, że Typ aplikacji jest Wielu dokumentów, Styl projektu jest Programu Visual Studioi obsługują architektury/widok dokumentu jest zaznaczona opcja.Kliknij Zakończ.

Na widoku menu, wskaż Other Windows i kliknij przycisk Widok zasobów.
W Widok zasobów, przejdź do Menu folder i otwórz go.Kliknij dwukrotnie IDR_MFCAnimationWalTYPE zasobów, aby go otworzyć do modyfikacji.
Na pasku menu w Tutaj typ wpisz A & nimation do tworzenia animacji menu.
W obszarze animacji, Tutaj typ wpisz Start & do przodu utworzyć polecenie Start do przodu.
W obszarze Start do przodu, Tutaj typ wpisz Start & Wstecz.
W obszarze Start wstecz, Tutaj typ wpisz S & góry utworzyć polecenie Zatrzymaj.
MFCAnimationWalkthrough.rc Zapisz i zamknij go.
W Solution Explorer, kliknij dwukrotnie MainFrm.cpp, aby go otworzyć do modyfikacji.W CMainFrame::OnCreate metodę, zlokalizować sekcji, który ma kilka wywołań do lstBasicCommands.AddTail.Zaraz po tej sekcji Dodaj następujący kod.
```
    lstBasicCommands.AddTail(ID_ANIMATION_STARTFORWARD);
    lstBasicCommands.AddTail(ID_ANIMATION_STARTBACKWARD);
    lstBasicCommands.AddTail(ID_ANIMATION_STOP);
```
Zapisz plik i zamknij go.

Aby utworzyć obsługi rozpoczęcia i zatrzymać poleceń

Na Projekt menu, kliknij Kreatora klasy.
W Kreator klas MFC, w Nazwa klasy, wybierz opcję CMFCAnimationWalkthroughView.
Na polecenia kartę w Identyfikatory obiektów wybierz pozycję ID_ANIMATION_STARTFORWARD, a następnie w wiadomości wybierz pozycję COMMAND.Kliknij Dodawanie obsługi.
W Dodawanie funkcji składowej okno dialogowe, kliknij przycisk OK.
W Identyfikatory obiektów wybierz pozycję ID_ANIMATION_STARTBACKWARD, a następnie w wiadomości wybierz pozycję COMMAND.Kliknij Dodawanie obsługi.
W Dodawanie funkcji składowej okno dialogowe, kliknij przycisk OK.
W Identyfikatory obiektów wybierz pozycję ID_ANIMATION_STOP, a następnie w wiadomości wybierz pozycję COMMAND.Kliknij Dodawanie obsługi i kliknij przycisk OK.
W Dodawanie funkcji składowej okno dialogowe, kliknij przycisk OK.
W Kreator klas MFC, kliknij OK.
Zapisz MFCAnimationWalkthroughView.cpp, który jest otwarty w edytorze, ale nie należy zamykać.

Aby dodać obiekt animowany w projekcie

W oknie Solution Explorer kliknij dwukrotnie MFCAnimationWalkthroughView.h, aby go otworzyć do modyfikacji.Tuż przed definicji CMFCAnimationWalkthroughView klasy, Dodaj następujący kod do utworzenia kontrolera animacji niestandardowej, który będzie obsługiwał konflikty planowania z obiektu animacji.
```
class CCustomAnimationController : public CAnimationController
{
public:
    CCustomAnimationController()
    {
    }

    virtual BOOL OnHasPriorityTrim(CAnimationGroup* pGroupScheduled, CAnimationGroup* pGroupNew, UI_ANIMATION_PRIORITY_EFFECT priorityEffect)
    {
        return TRUE;
    }
};
```

Na koniec CMFCAnimationWalkthroughView klasy, Dodaj następujący kod.

    CCustomAnimationController m_animationController;
    CAnimationColor m_animationColor; 
    CAnimationRect m_animationRect;

Po DECLARE_MESSAGE_MAP() linii, Dodaj następujący kod.
```
    void Animate(BOOL bDirection);
```
Zapisz plik i zamknij go.
W MFCAnimationWalkthroughView.cpp u góry pliku po #include sprawozdania ale zanim dowolne klasy metod, Dodaj następujący kod.
```
static int nAnimationGroup = 0;
static int nInfoAreaHeight = 40;
```

Na końcu konstruktora dla CMFCAnimationWalkthroughView, Dodaj następujący kod.

    m_animationController.EnableAnimationTimerEventHandler();
    m_animationController.EnablePriorityComparisonHandler(UI_ANIMATION_PHT_TRIM);

    m_animationColor = RGB(255, 255, 255);
    m_animationRect = CRect(0, 0, 0, 0);

    m_animationColor.SetID(-1, nAnimationGroup);
    m_animationRect.SetID(-1, nAnimationGroup);

    m_animationController.AddAnimationObject(&m_animationColor);
    m_animationController.AddAnimationObject(&m_animationRect);

Zlokalizuj CAnimationWalthroughView::PreCreateWindow metody i zastąp je następujący kod.

BOOL CMFCAnimationWalkthroughView::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Modify the Window class or styles here by modifying
    //  the CREATESTRUCT cs

    m_animationController.SetRelatedWnd(this);
    return CView::PreCreateWindow(cs);
}

Zlokalizuj CAnimationWalkthroughView::OnDraw metody i zastąp je następujący kod.

void CMFCAnimationWalkthroughView::OnDraw(CDC* pDC)
{
    CMFCAnimationWalkthroughDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if (!pDoc)
        return;

    // TODO: add draw code for native data here
    CMemDC dcMem(*pDC, this);
    CDC& dc = dcMem.GetDC();

    CRect rect;
    GetClientRect(rect);

    dc.FillSolidRect(rect, GetSysColor(COLOR_WINDOW));

    CString strRGB;
    strRGB.Format(_T("Fill Color is: %d; %d; %d"), GetRValue(m_animationColor), GetGValue(m_animationColor), GetBValue(m_animationColor));

    dc.DrawText(strRGB, rect, DT_CENTER);
    rect.top += nInfoAreaHeight;

    CBrush br;

    br.CreateSolidBrush(m_animationColor);
    CBrush* pBrushOld = dc.SelectObject(&br);

    dc.Rectangle((CRect)m_animationRect);
    dc.SelectObject(pBrushOld);
}

Na końcu pliku Dodaj następujący kod.

void CMFCAnimationWalkthroughView::Animate(BOOL bDirection)
{
    static UI_ANIMATION_SECONDS duration = 3;
    static DOUBLE dblSpeed = 35.;
    static BYTE nStartColor = 50;
    static BYTE nEndColor = 255;

    BYTE nRedColorFinal = bDirection ? nStartColor : nEndColor;
    BYTE nGreenColorFinal = bDirection ? nStartColor : nEndColor;
    BYTE nBlueColorFinal = bDirection ? nStartColor : nEndColor;

    CLinearTransition* pRedTransition = new CLinearTransition(duration, (DOUBLE)nRedColorFinal);
    CSmoothStopTransition* pGreenTransition = new CSmoothStopTransition(duration, (DOUBLE)nGreenColorFinal);
    CLinearTransitionFromSpeed* pBlueTransition = new CLinearTransitionFromSpeed(dblSpeed, (DOUBLE)nBlueColorFinal);

    m_animationColor.AddTransition(pRedTransition, pGreenTransition, pBlueTransition);

    CRect rectClient;
    GetClientRect(rectClient);
    rectClient.top += nInfoAreaHeight;

    int nLeftFinal = bDirection ? rectClient.left : rectClient.CenterPoint().x;
    int nTopFinal = bDirection ? rectClient.top : rectClient.CenterPoint().y;
    int nRightFinal = bDirection ? rectClient.right : rectClient.CenterPoint().x;
    int nBottomFinal = bDirection ? rectClient.bottom : rectClient.CenterPoint().y;

    CLinearTransition* pLeftTransition = new CLinearTransition(duration, nLeftFinal);
    CLinearTransition* pTopTransition = new CLinearTransition(duration, nTopFinal);
    CLinearTransition* pRightTransition = new CLinearTransition(duration, nRightFinal);
    CLinearTransition* pBottomTransition = new CLinearTransition(duration, nBottomFinal);

    m_animationRect.AddTransition(pLeftTransition, pTopTransition, pRightTransition, pBottomTransition);

    CBaseKeyFrame* pKeyframeStart = CAnimationController::GetKeyframeStoryboardStart();
    CKeyFrame* pKeyFrameEnd = m_animationController.CreateKeyframe(nAnimationGroup, pBlueTransition);

    pLeftTransition->SetKeyframes(pKeyframeStart, pKeyFrameEnd);
    pTopTransition->SetKeyframes(pKeyframeStart, pKeyFrameEnd);
    pRightTransition->SetKeyframes(pKeyframeStart, pKeyFrameEnd);
    pBottomTransition->SetKeyframes(pKeyframeStart, pKeyFrameEnd);

    m_animationController.AnimateGroup(nAnimationGroup);
}

Na Projekt menu, kliknij Kreatora klasy.
W Kreator klas MFC, w Nazwa klasy, wybierz opcję CMFCAnimationWalkthroughView.
Na wiadomości kartę w wiadomości wybierz pozycję WM_ERASEBKGND, kliknij Dodawanie obsługi, a następnie kliknij przycisk OK.
W MFCAnimationWalkthroughView.cpp, Zastąp wykonania OnEraseBkgnd z następujący kod w celu zmniejszenia migotanie obrazu animowanego obiektu, gdy zostanie narysowany ponownie.
```
BOOL CMFCAnimationWalkthroughView::OnEraseBkgnd(CDC* /*pDC*/)
{
    return TRUE;
}
```

Zamień implementacje z CMFCAnimationWalkthroughView::OnAnimationStartforward, CMFCAnimationWalkthroughView::OnAnimationStartbackward, i CMFCAnimationWalkthroughView::OnAnimationStop z następującego kodu.

void CMFCAnimationWalkthroughView::OnAnimationStartforward()
{
    Animate(TRUE);
}

void CMFCAnimationWalkthroughView::OnAnimationStartbackward()
{
    Animate(FALSE);
}

void CMFCAnimationWalkthroughView::OnAnimationStop()
{
    IUIAnimationManager* pManager = m_animationController.GetUIAnimationManager();
    if (pManager != NULL)
    {
        pManager->AbandonAllStoryboards();
    }
}

Zapisz plik i zamknij go.

Aby wyśrodkować animowany obiekt w oknie

W Solution Explorer, kliknij dwukrotnie MFCAnimationWalkthroughView.h, aby go otworzyć do modyfikacji.Na koniec CMFCAnimationWalkthroughView klasy tuż po definicji m_animationRect, Dodaj następujący kod.
```
    BOOL m_bCurrentDirection;
```
Zapisz plik i zamknij go.
Na Projekt menu, kliknij Kreatora klasy.
W Kreator klas MFC, w Nazwa klasy, wybierz opcję CMFCAnimationWalkthroughView.
Na wiadomości kartę w wiadomości wybierz pozycję WM_SIZE, kliknij Dodawanie obsługi, a następnie kliknij przycisk OK.

W MFCAnimationWalkthroughView.cpp, Zastąp kod CMFCAnimationWalkthroughView::OnSize z następujący kod.

void CMFCAnimationWalkthroughView::OnSize(UINT nType, int cx, int cy)
{
    CView::OnSize(nType, cx, cy);

    CRect rect;
    GetClientRect(rect);
    rect.top += nInfoAreaHeight;

    CRect rectAnim = m_animationRect;
    m_animationRect = CRect(CPoint(rect.CenterPoint().x - rectAnim.Width() / 2, 
                            rect.CenterPoint().y - rectAnim.Height() / 2), 
                            rectAnim.Size());

    if (m_animationController.IsAnimationInProgress())
    {
        Animate(m_bCurrentDirection);
    }
}

Na początku konstruktora dla CMFCAnimationWalkthroughView, Dodaj następujący kod.
```
    m_bCurrentDirection = TRUE;
```
Na początku CMFCAnimationWalkthroughView::Animate metody, Dodaj następujący kod.
```
    m_bCurrentDirection = bDirection;
```
Zapisz plik i zamknij go.

Aby sprawdzić wyniki

Tworzenie i uruchamianie aplikacji.Na animacji menu, kliknij Start do przodu.Prostokąt powinien są wyświetlane, a następnie wypełnienie obszaru roboczego.Po kliknięciu Start wstecz, należy odwrócić animacji i kliknięcie Stop, powinno zostać zatrzymane.Należy zmienić kolor wypełnienia prostokąta, w miarę postępu animacji, a bieżący kolor powinny być wyświetlane w górnej części okna animacji.

Zobacz też

Inne zasoby

Instruktaże (MFC)

Udostępnij za pośrednictwem