Before reading this article, I highly recommend reading the previous parts of the series.

DispatcherTimer

DispatcherTimer is a timer control that is integrated into the Dispatcher queue. A Timer event is called in a specific time interval. The main advantage of a DispatcherTimer is that it can run the code on the same UI thread.

Let us see how to implement this feature and important properties.

Interval - How frequently an event should be triggered (i.e. amount of time between ticks)

TimeSpan as an input for the Interval - Actually, it is std::Chrono in C++ ( C++/WinRT is typecast into the TimeSpan type).
Given below is the sample code how to define the TimeSpan ( It's specified as1 second).
  1. DispatcherTimer dispatchTimer;
  2. std::chrono::seconds sec(1);
  3. dispatchTimer.Interval(sec);
  4. dispatchTimer.Start();

Tick

Occurs when the timer interval has elapsed (based on the interval set by the user).

  1. DispatcherTimer dispatchTimer;
  3. dispatchTimer.Tick({ this,&App::dispatch_tick });
  5. void dispatch_tick(IInspectable const & sender, Windows::Foundation::IUnknown const& from)
  6. {
  7. }

Start

Start function is used to start the Timer. If the timer is already running, call the start method because it restarts the process.

  1. DispatcherTimer dispatchTimer;
  2. dispatchTimer.Start();

Stop

Stop function is used to stop the time if it is running.

  1. DispatcherTimer dispatchTimer;
  2. dispatchTimer.Stop();
Let us see one example.

Call the DispatcherTimer every second and automatically increase the ProgressBar value.
  1. #include "pch.h"
  3. using namespace winrt;
  4. using namespace Windows::ApplicationModel;
  5. using namespace Windows::ApplicationModel::Activation;
  6. using namespace Windows::Foundation;
  7. using namespace Windows::UI;
  8. using namespace Windows::UI::Xaml;
  9. using namespace Windows::UI::Xaml::Controls;
  10. using namespace Windows::UI::Xaml::Controls::Primitives;
  11. using namespace Windows::UI::Xaml::Interop;
  12. using namespace Windows::UI::Xaml::Navigation;
  13. using namespace Windows::UI::Xaml::Media;
  14. using namespace Windows::Media;
  15. using namespace Windows::Media::Core;
  16. using namespace Windows::Storage;
  17. using namespace Windows::Storage::Pickers;
  20. struct App :ApplicationT<App>
  21. {
  22. TextBlock txtStatus;
  23. DispatcherTimer dispatchTimer;
  24. ProgressBar pBar;
  25. int value = 20;
  27. IInspectable CreateInspectable(hstring strCaption)
  28. {
  29. return PropertyValue::CreateString(strCaption);
  30. }
  32. void dispatch_tick(IInspectable const & sender, Windows::Foundation::IUnknown const& from)
  33. {
  35. auto CtlValue = pBar.Value();
  37. CtlValue += 10;
  39. if (CtlValue > 100)
  40. CtlValue = 0;
  41. else if (CtlValue <= 0)
  42. CtlValue += 10;
  44. if (CtlValue <= 40)
  45. pBar.Foreground(SolidColorBrush(Colors::Red()));
  47. else if (CtlValue <= 80)
  48. pBar.Foreground(SolidColorBrush(Colors::Yellow()));
  49. else if (CtlValue <= 100)
  50. pBar.Foreground(SolidColorBrush(Colors::Green()));
  52. pBar.Value(CtlValue);
  54. }
  56. TextBlock CreateTextBlock(hstring text)
  57. {
  58. TextBlock txtBlock;
  59. txtBlock.Text(text);
  60. txtBlock.FontFamily(FontFamily(L"Segoe UI Semibold"));
  61. txtBlock.TextAlignment(TextAlignment::Left);
  62. txtBlock.FontSize(35);
  63. txtBlock.Foreground(SolidColorBrush(Colors::Brown()));
  64. txtBlock.Margin(CreateThickness(10, 10, 0, 0));
  65. return txtBlock;
  66. }
  68. Thickness CreateThickness(int left, int top, int right, int bottom)
  69. {
  70. Thickness thick;
  71. thick.Left = left;
  72. thick.Top = top;
  73. thick.Right = right;
  74. thick.Bottom = bottom;
  75. return thick;
  76. }
  79. void OnLaunched(LaunchActivatedEventArgs const&)
  80. {
  81. auto txtheader = CreateTextBlock(L"DispatcherTimer Sample(Modern C++/WinRT)");
  82. txtheader.FontSize(25);
  84. StackPanel btnPanel;
  85. btnPanel.Orientation(Orientation::Horizontal);
  86. btnPanel.Children().Append(BtnIncrease);
  87. btnPanel.Children().Append(BtnDecrease);
  90. StackPanel sContentPanel;
  91. sContentPanel.Orientation(Orientation::Vertical);
  92. sContentPanel.VerticalAlignment(VerticalAlignment::Top);
  94. dispatchTimer.Tick({ this,&App::dispatch_tick });
  96. std::chrono::seconds sec(1);
  97. dispatchTimer.Interval(sec);
  98. dispatchTimer.Start();
  101. pBar.Minimum(0);
  102. pBar.Maximum(100);
  103. pBar.Value(value);
  104. pBar.Height(100);
  105. pBar.Margin(CreateThickness(5, 20, 10, 0));
  106. pBar.IsIndeterminate(false);
  107. pBar.Foreground(SolidColorBrush(Colors::Red()));
  109. StackPanel mainPanel;
  110. mainPanel.Children().Append(sContentPanel);
  111. mainPanel.Children().Append(txtheader);
  112. mainPanel.Children().Append(pBar);
  116. Window window = Window::Current();
  117. window.Content(mainPanel);
  118. window.Activate();
  123. }
  124. };
  126. int __stdcall wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
  127. {
  128. Application::Start([](auto &&) {make<App>(); });
  129. return 0;
  130. }
Output

Conclusion

I hope, you understood how to use the DispatcherTimer control.