src/msw/timer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/timer.cpp
   3 // Purpose:     wxTimer implementation
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin (use hash map instead of list, global rewrite)
   6 // Created:     04/01/98
   7 // Copyright:   (c) Julian Smart
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_TIMER
  19
  20 #include "wx/msw/private/timer.h"
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/list.h"
  24     #include "wx/event.h"
  25     #include "wx/app.h"
  26     #include "wx/intl.h"
  27     #include "wx/log.h"
  28     #include "wx/hashmap.h"
  29     #include "wx/module.h"
  30 #endif
  31
  32 #include "wx/msw/private.h"
  33 #include "wx/msw/private/hiddenwin.h"
  34
  35 // ----------------------------------------------------------------------------
  36 // private globals
  37 // ----------------------------------------------------------------------------
  38
  39 // define a hash containing all the timers: it is indexed by timer id and
  40 // contains the corresponding timer
  41 WX_DECLARE_HASH_MAP(WPARAM, wxMSWTimerImpl *, wxIntegerHash, wxIntegerEqual,
  42                     wxTimerMap);
  43
  44 // instead of using a global here, wrap it in a static function as otherwise it
  45 // could have been used before being initialized if a timer object were created
  46 // globally
  47 static wxTimerMap& TimerMap()
  48 {
  49     static wxTimerMap s_timerMap;
  50
  51     return s_timerMap;
  52 }
  53
  54 // This gets a unique, non-zero timer ID and creates an entry in the TimerMap
  55 UINT_PTR GetNewTimerId(wxMSWTimerImpl *t)
  56 {
  57     static UINT_PTR lastTimerId = 0;
  58
  59     while (lastTimerId == 0 ||
  60             TimerMap().find(lastTimerId) != TimerMap().end())
  61     {
  62         lastTimerId = lastTimerId + 1;
  63     }
  64
  65     TimerMap()[lastTimerId] = t;
  66
  67     return lastTimerId;
  68 }
  69
  70
  71
  72 // ----------------------------------------------------------------------------
  73 // private functions
  74 // ----------------------------------------------------------------------------
  75
  76 LRESULT APIENTRY _EXPORT wxTimerWndProc(HWND hWnd, UINT message,
  77                                         WPARAM wParam, LPARAM lParam);
  78
  79 // ----------------------------------------------------------------------------
  80 // wxTimerHiddenWindowModule: used to manage the hidden window used for
  81 // catching timer messages (we need a module to ensure that the window is
  82 // always deleted)
  83 // ----------------------------------------------------------------------------
  84
  85 class wxTimerHiddenWindowModule : public wxModule
  86 {
  87 public:
  88     // module init/finalize
  89     virtual bool OnInit();
  90     virtual void OnExit();
  91
  92     // get the hidden window (creates on demand)
  93     static HWND GetHWND();
  94
  95 private:
  96     // the HWND of the hidden window
  97     static HWND ms_hwnd;
  98
  99     // the class used to create it
 100     static const wxChar *ms_className;
 101
 102     DECLARE_DYNAMIC_CLASS(wxTimerHiddenWindowModule)
 103 };
 104
 105 IMPLEMENT_DYNAMIC_CLASS(wxTimerHiddenWindowModule, wxModule)
 106
 107 // ============================================================================
 108 // implementation
 109 // ============================================================================
 110
 111
 112 // ----------------------------------------------------------------------------
 113 // wxMSWTimerImpl class
 114 // ----------------------------------------------------------------------------
 115
 116 bool wxMSWTimerImpl::Start(int milliseconds, bool oneShot)
 117 {
 118     if ( !wxTimerImpl::Start(milliseconds, oneShot) )
 119         return false;
 120
 121     m_id = GetNewTimerId(this);
 122     // SetTimer() normally returns just idTimer but this might change in the
 123     // future so use its return value to be safe
 124     UINT_PTR ret = ::SetTimer
 125              (
 126               wxTimerHiddenWindowModule::GetHWND(),  // window for WM_TIMER
 127               m_id,                                  // timer ID to create
 128               (UINT)m_milli,                         // delay
 129               NULL                                   // timer proc (unused)
 130              );
 131
 132     if ( ret == 0 )
 133     {
 134         wxLogSysError(_("Couldn't create a timer"));
 135
 136         return false;
 137     }
 138
 139     return true;
 140 }
 141
 142 void wxMSWTimerImpl::Stop()
 143 {
 144     ::KillTimer(wxTimerHiddenWindowModule::GetHWND(), m_id);
 145     TimerMap().erase(m_id);
 146     m_id = 0;
 147 }
 148
 149 // ----------------------------------------------------------------------------
 150 // private functions
 151 // ----------------------------------------------------------------------------
 152
 153 void wxProcessTimer(wxMSWTimerImpl& timer)
 154 {
 155     wxASSERT_MSG( timer.IsRunning(), wxT("bogus timer id") );
 156
 157     if ( timer.IsOneShot() )
 158         timer.Stop();
 159
 160     timer.Notify();
 161 }
 162
 163
 164 LRESULT APIENTRY _EXPORT wxTimerWndProc(HWND hWnd, UINT message,
 165                                         WPARAM wParam, LPARAM lParam)
 166 {
 167     if ( message == WM_TIMER )
 168     {
 169         wxTimerMap::iterator node = TimerMap().find(wParam);
 170
 171         if ( node != TimerMap().end() )
 172         {
 173             wxProcessTimer(*(node->second));
 174
 175             return 0;
 176         }
 177         //else: Unknown timer, probably one of our timers that had fired just
 178         //      before being removed from the timers map by Stop().
 179     }
 180
 181     return ::DefWindowProc(hWnd, message, wParam, lParam);
 182 }
 183
 184 // ----------------------------------------------------------------------------
 185 // wxTimerHiddenWindowModule functions
 186 // ----------------------------------------------------------------------------
 187
 188
 189 HWND wxTimerHiddenWindowModule::ms_hwnd = NULL;
 190
 191 const wxChar *wxTimerHiddenWindowModule::ms_className = NULL;
 192
 193 bool wxTimerHiddenWindowModule::OnInit()
 194 {
 195     // do not initialize ms_hwnd to ms_className to NULL here: it may happen
 196     // that our GetHWND() is called before the modules are initialized if a
 197     // timer is created from wxApp-derived class ctor and in this case we
 198     // shouldn't overwrite it
 199
 200     return true;
 201 }
 202
 203 void wxTimerHiddenWindowModule::OnExit()
 204 {
 205     if ( ms_hwnd )
 206     {
 207         if ( !::DestroyWindow(ms_hwnd) )
 208         {
 209             wxLogLastError(wxT("DestroyWindow(wxTimerHiddenWindow)"));
 210         }
 211
 212         ms_hwnd = NULL;
 213     }
 214
 215     if ( ms_className )
 216     {
 217         if ( !::UnregisterClass(ms_className, wxGetInstance()) )
 218         {
 219             wxLogLastError(wxT("UnregisterClass(\"wxTimerHiddenWindow\")"));
 220         }
 221
 222         ms_className = NULL;
 223     }
 224 }
 225
 226 /* static */
 227 HWND wxTimerHiddenWindowModule::GetHWND()
 228 {
 229     static const wxChar *HIDDEN_WINDOW_CLASS = wxT("wxTimerHiddenWindow");
 230     if ( !ms_hwnd )
 231     {
 232         ms_hwnd = wxCreateHiddenWindow(&ms_className, HIDDEN_WINDOW_CLASS,
 233                                      wxTimerWndProc);
 234     }
 235
 236     return ms_hwnd;
 237 }
 238
 239 #endif // wxUSE_TIMER