イグトランスの頭の中（のかけら）

#define _WIN32_WINNT _WIN32_WINNT_VISTA
 
#define _ATL_NO_AUTOMATIC_NAMESPACE
#define _WTL_NO_AUTOMATIC_NAMESPACE
 
#include <string>
#include <windows.h>
#include <wtsapi32.h>
#include <UIAnimation.h>
 
#include <comdef.h>
 
#include <atlbase.h>
#include <atlcom.h>
#include <atlutil.h>
#include <atlwin.h>
 
#include <atlapp.h>
#include <atlmisc.h>
#include <atlcrack.h>
#include <atlctrls.h>
 
#pragma comment(lib, "wtsapi32.lib")
 
_COM_SMARTPTR_TYPEDEF(IUIAnimationManager, __uuidof(IUIAnimationManager));
_COM_SMARTPTR_TYPEDEF(IUIAnimationTimer, __uuidof(IUIAnimationTimer));
_COM_SMARTPTR_TYPEDEF(IUIAnimationTransitionLibrary, __uuidof(IUIAnimationTransitionLibrary));
_COM_SMARTPTR_TYPEDEF(IUIAnimationVariable, __uuidof(IUIAnimationVariable));
_COM_SMARTPTR_TYPEDEF(IUIAnimationStoryboard, __uuidof(IUIAnimationStoryboard));
_COM_SMARTPTR_TYPEDEF(IUIAnimationTransition, __uuidof(IUIAnimationTransition));
_COM_SMARTPTR_TYPEDEF(IUIAnimationTimerUpdateHandler, __uuidof(IUIAnimationTimerUpdateHandler));
 
static const int WIDTH_CHECK_OFF = 100;
static const int WIDTH_CHECK_ON = 300;
 
static const int HEIGHT_CHECK_OFF = 100;
static const int HEIGHT_CHECK_ON = 300;
 
class TestWindow
  : public ATL::CWindowImpl<TestWindow>
  , public ATL::CComObjectRootEx<ATL::CComSingleThreadModel>
  , public IUIAnimationTimerEventHandler
  , public IUIAnimationStoryboardEventHandler
{
public:
  DECLARE_WND_CLASS(TEXT("Test Window Class"));
 
public:
  // IUIAnimationTimerEventHandler実装
 
  IFACEMETHOD(OnPreUpdate)() override
  {
    return S_OK;
  }
  IFACEMETHOD(OnPostUpdate)() override
  {
    try
    {
      INT32 width, height;
      ATLENSURE_SUCCEEDED(m_animationWidth->GetIntegerValue(&width));
      ATLENSURE_SUCCEEDED(m_animationHeight->GetIntegerValue(&height));
      RECT rc;
      GetWindowRect(&rc);
      rc.right = rc.left + width;
      rc.bottom = rc.top + height;
      MoveWindow(&rc, FALSE);
    }
    catch(const ATL::CAtlException& e)
    {
      return e;
    }
 
    return S_OK;
  }
  IFACEMETHOD(OnRenderingTooSlow)(UINT) override
  {
    return S_OK;
  }
 
  // IUIAnimationStoryboardEventHandler実装
 
  IFACEMETHOD(OnStoryboardStatusChanged)(
    _In_ IUIAnimationStoryboard* /*storyboard*/,
    _In_ UI_ANIMATION_STORYBOARD_STATUS newStatus,
    _In_ UI_ANIMATION_STORYBOARD_STATUS /*previousStatus*/) override
  {
    if (newStatus == UI_ANIMATION_STORYBOARD_FINISHED)
    {
      // OnPostUpdateのMoveWindowでは再描画を抑制しているので、
      // ここで再描画を要求している。
      Invalidate();
    }
    return S_OK;
  }
 
  IFACEMETHOD(OnStoryboardUpdated)(
    _In_ IUIAnimationStoryboard* /*storyboard*/) override
  {
    return S_OK;
  }
 
  TestWindow()
    : m_animationManager(__uuidof(UIAnimationManager))
    , m_animationTimer(__uuidof(UIAnimationTimer))
    , m_transitionLibrary(__uuidof(UIAnimationTransitionLibrary))
  {
  }
 
  HRESULT FinalConstruct()
  {
    try
    {
      ATLENSURE_SUCCEEDED(m_animationManager->CreateAnimationVariable(
        WIDTH_CHECK_OFF, &m_animationWidth));
      ATLENSURE_SUCCEEDED(m_animationManager->CreateAnimationVariable(
        HEIGHT_CHECK_OFF, &m_animationHeight));
    }
    catch (const ATL::CAtlException& e)
    {
      return e;
    }
    return S_OK;
  }
 
  BEGIN_COM_MAP(TestWindow)
    COM_INTERFACE_ENTRY(IUIAnimationTimerEventHandler)
    COM_INTERFACE_ENTRY(IUIAnimationStoryboardEventHandler)
  END_COM_MAP()
 
private:
  static const int IDC_CHECK = 1;
 
  BEGIN_MSG_MAP(TestWindow)
    COMMAND_ID_HANDLER_EX(IDC_CHECK, OnCheckClick)
    MESSAGE_HANDLER_EX(WM_SETTINGCHANGE, OnUpdateAnimationEnabled)
    MESSAGE_HANDLER_EX(WM_WTSSESSION_CHANGE, OnUpdateAnimationEnabled)
    MSG_WM_CREATE(OnCreate)
    MSG_WM_DESTROY(OnDestroy)
  END_MSG_MAP()
 
private:
  void OnCheckClick(UINT /*notifyCode*/, int /*id*/, HWND /*hwndCtl*/)
  {
    try
    {
      auto finalValue = m_check.GetCheck()
        ? SIZE{WIDTH_CHECK_ON, HEIGHT_CHECK_ON}
        : SIZE{WIDTH_CHECK_OFF, HEIGHT_CHECK_OFF};
 
      IUIAnimationStoryboardPtr storyboard;
      ATLENSURE_SUCCEEDED(m_animationManager->CreateStoryboard(&storyboard));
      ATLENSURE_SUCCEEDED(storyboard->SetStoryboardEventHandler(this));
 
      IUIAnimationTransitionPtr animationTransitionWidth;
      IUIAnimationTransitionPtr animationTransitionHeight;
      ATLENSURE_SUCCEEDED(m_transitionLibrary->CreateLinearTransition(
        0.08, finalValue.cx, &animationTransitionWidth));
      ATLENSURE_SUCCEEDED(m_transitionLibrary->CreateLinearTransition(
        0.08, finalValue.cy, &animationTransitionHeight));
 
#if 1
      // 横→縦の順で動かす
      UI_ANIMATION_KEYFRAME keyframeAfterWidth;
      ATLENSURE_SUCCEEDED(storyboard->AddTransition(
        m_animationWidth, animationTransitionWidth));
      ATLENSURE_SUCCEEDED(storyboard->AddKeyframeAfterTransition(
        animationTransitionWidth, &keyframeAfterWidth));
      ATLENSURE_SUCCEEDED(storyboard->AddTransitionAtKeyframe(
        m_animationHeight, animationTransitionHeight, keyframeAfterWidth));
#else
      // 同時に動かす
      ATLENSURE_SUCCEEDED(storyboard->AddTransition(
        m_animationWidth, animationTransitionWidth));
      ATLENSURE_SUCCEEDED(storyboard->AddTransition(
        m_animationHeight, animationTransitionHeight));
#endif
 
      IUIAnimationTimerUpdateHandlerPtr tiemrUpdaterHandler
        = m_animationManager;
      ATLENSURE_SUCCEEDED(m_animationTimer->SetTimerUpdateHandler(
        tiemrUpdaterHandler, UI_ANIMATION_IDLE_BEHAVIOR_DISABLE));
      ATLENSURE_SUCCEEDED(m_animationTimer->SetTimerEventHandler(this));
 
      UI_ANIMATION_SECONDS secondsNow;
      ATLENSURE_SUCCEEDED(m_animationTimer->GetTime(&secondsNow));
      ATLENSURE_SUCCEEDED(storyboard->Schedule(secondsNow));
    }
    catch(const ATL::CAtlException& e)
    {
      try
      {
        OutputDebugString(ATL::AtlGetErrorDescription(e));
      }
      catch(...)
      {
      }
    }
  }
 
  LRESULT OnUpdateAnimationEnabled(UINT, WPARAM, LPARAM)
  {
    BOOL isAnimationEnabled = FALSE;
    SystemParametersInfo(
      SPI_GETCLIENTAREAANIMATION, 0, &isAnimationEnabled, 0);
    m_animationManager->SetAnimationMode(
      isAnimationEnabled && !GetSystemMetrics(SM_REMOTESESSION)
      ? UI_ANIMATION_MODE_SYSTEM_DEFAULT
      : UI_ANIMATION_MODE_DISABLED);
    return 0;
  }
 
  LRESULT OnCreate(const CREATESTRUCT*)
  {
    SetWindowPos(nullptr, 0, 0, WIDTH_CHECK_OFF, HEIGHT_CHECK_OFF,
      SWP_NOZORDER | SWP_NOMOVE);
 
    RECT rcCheck{0, 0, 80, 20};
    if (m_check.Create(*this, rcCheck, nullptr,
      BS_AUTOCHECKBOX | WS_VISIBLE | WS_CHILD, 0, IDC_CHECK) == nullptr)
    {
      return -1;
    }
    WTSRegisterSessionNotification(*this, NOTIFY_FOR_THIS_SESSION);
    OnUpdateAnimationEnabled(0, 0, 0);
    return 0;
  }
 
  void OnDestroy()
  {
    WTSUnRegisterSessionNotification(*this);
    PostQuitMessage(0);
  }
 
  IUIAnimationManagerPtr m_animationManager;
  IUIAnimationTimerPtr m_animationTimer;
  IUIAnimationTransitionLibraryPtr m_transitionLibrary;
  IUIAnimationVariablePtr m_animationWidth;
  IUIAnimationVariablePtr m_animationHeight;
 
  WTL::CButton m_check;
};
 
class Module : public ATL::CAtlExeModuleT<Module> {};
Module module;
 
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int cmdShow)
{
  auto hr = CoInitialize(nullptr);
  if (FAILED(hr))
    return hr;
 
  try
  {
    ATL::CComObjectStackEx<TestWindow> wnd;
    if (!wnd.Create(nullptr, nullptr,
      TEXT("Animation sample"),
      WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME))
    {
      return -1;
    }
    wnd.ShowWindow(cmdShow);
    wnd.UpdateWindow();
 
    WTL::CMessageLoop msgLoop;
    auto result = msgLoop.Run();
    CoUninitialize();
    return result;
  }
  catch(...)
  {
    return -1;
  }
}