Safe Win32 Timer

Environment: Win32, C++

Hello guys. This article presents some Win32 timer-related stuff. It consists of two classes:

  1. CTimerHost -- that class is the source of "safe" timers. That means you can kill timer and be sure that you will not receive any timer notification from already dead timer. That timer should be used and destroyed only from the thread it was created.
  2. CTimerThunk<...> -- represents thunk for receiving timer notifications.

These classes uses dynamic thunking technology. That means total absence of any static maps or lists. Enjoy.

Example of usage:

#include "sf_timer.h"

// for example in your CApp
CTimerHost g_TimerHost;

class CMyClass
{
public:
    CMyClass() : m_Timer(g_TimerHost, this, OnTimer)
    {
        timer.SetTimer(500);
    }

    void Stop()
    {
        timer.KillTimer();
    }

    void OnTimer(DWORD dwTime) {}

protected:
    CTimerThunk<CMyClass>   m_Timer;
};

Downloads

Download source - 5.17 Kb


Comments

  • No portability...

    Posted by Legacy on 08/01/2001 12:00am

    Originally posted by: Paul

    While this method is certainly a nice trick, it is not easily portable to other operating systems or other processor architectures.  When I am dealing with one of the Windows function that requires the use of a callback, I favor using a map from the standard C++ library.  For example, if you were setting up a WndProc callback function, you could make the map reference the hWnd parameter, and the stored information the address of the class instance:
    
    


    class Window
    {
    public:

    Window( );
    virtual ~Window( );

    // Register the window class...
    void Register( )
    {
    WNDCLASSEX wc;
    wc.lpfnWndProc = Window::WndProc;
    ::RegisterClassEx( &wc );
    }

    // Create the window...
    HWND Create( )
    {
    g_window = this;
    m_hWnd = ::CreateWindowEx( ... );
    ::ShowWindow( m_hWnd, SW_SHOW );
    ::UpdateWindow( m_hWnd );
    return( m_hWnd );
    }

    // The class callback...
    LRESULT Switch( UINT uMsg, WPARAM wParam, LPARAM lParam )
    {
    switch( uMsg )
    {
    case WM_CREATE:

    return( 0 );
    break;

    case WM_DESTROY:

    return( 0 );
    break;

    default:

    return( DefWindowProc( m_hWnd, uMsg, wParam, lParam ) );
    }
    }

    private:

    HWND m_hWnd;
    std::map< Window* > m_map;

    static Window* m_window = 0;

    // The real callback
    static LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
    {
    //
    if( ( uMsg == WM_CREATE ) && ( Window::m_window != 0 ) )
    {
    m_map[hWnd] = Window::m_window;
    Window::m_window = 0;
    }
    }

    return( ( m_map[hWnd] )->Switch( uMsg, wParam, lParam ) );
    };

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Live Event Date: May 11, 2015 @ 1:00 p.m. ET / 10:00 a.m. PT One of the languages that have always been supported with the Intel® RealSense™ SDK (Software Developer Kit) is JavaScript, specifically so that web-enabled apps could be created. Come hear from Intel Expert Bob Duffy as he reviews his own little "space shooting" game where the orientation of your face controls the aiming reticle to help teach developers how to write apps and games in JavaScript that can use facial and gesture …

  • You may not realize the complexity you could be creating when developing mobile apps – many companies don't initially. You could be doubling your IT costs for development and delivery; not to mention, risking sales, productivity and brand satisfaction. Read this IBM-commissioned Forrester Study to understand the key cost drivers of mobile app delivery -- for both customer-facing and enterprise applications. Find out how you could lower costs and increase success with the right strategy and investment.

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date