src/msw/notifmsg.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/notifmsg.cpp
   3 // Purpose:     implementation of wxNotificationMessage for Windows
   4 // Author:      Vadim Zeitlin
   5 // Created:     2007-12-01
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 // we can only use the native implementation if we have a working
  27 // wxTaskBarIcon::ShowBalloon() method
  28 #if wxUSE_NOTIFICATION_MESSAGE && \
  29         wxUSE_TASKBARICON && wxUSE_TASKBARICON_BALLOONS
  30
  31 #include "wx/notifmsg.h"
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/toplevel.h"
  35     #include "wx/app.h"
  36     #include "wx/string.h"
  37 #endif // WX_PRECOMP
  38
  39 #include "wx/generic/notifmsg.h"
  40
  41 #include "wx/taskbar.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // different implementations used by wxNotificationMessage
  45 // ----------------------------------------------------------------------------
  46
  47 // base class for all available implementations
  48 class wxNotifMsgImpl
  49 {
  50 public:
  51     wxNotifMsgImpl() { }
  52     virtual ~wxNotifMsgImpl() { }
  53
  54     virtual bool DoShow(const wxString& title,
  55                         const wxString& message,
  56                         int timeout,
  57                         int flags) = 0;
  58     virtual bool DoClose() = 0;
  59
  60 private:
  61     wxDECLARE_NO_COPY_CLASS(wxNotifMsgImpl);
  62 };
  63
  64 // implementation which is simply a bridge to wxGenericNotificationMessage
  65 class wxGenericNotifMsgImpl : public wxNotifMsgImpl
  66 {
  67 public:
  68     wxGenericNotifMsgImpl() : m_notif(new wxGenericNotificationMessage) { }
  69     virtual ~wxGenericNotifMsgImpl() { delete m_notif; }
  70
  71     virtual bool DoShow(const wxString& title,
  72                         const wxString& message,
  73                         int timeout,
  74                         int flags)
  75     {
  76         m_notif->SetTitle(title);
  77         m_notif->SetMessage(message);
  78         m_notif->SetFlags(flags);
  79         return m_notif->Show(timeout);
  80     }
  81
  82     virtual bool DoClose()
  83     {
  84         return m_notif->Close();
  85     }
  86
  87 private:
  88     wxGenericNotificationMessage * const m_notif;
  89 };
  90
  91 // common base class for implementations using a taskbar icon and balloons
  92 class wxBalloonNotifMsgImpl : public wxNotifMsgImpl
  93 {
  94 public:
  95     // ctor sets up m_icon (using the icon of the top level parent of the given
  96     // window) which can be used to show an attached balloon later by the
  97     // derived classes
  98     wxBalloonNotifMsgImpl(wxWindow *win) { SetUpIcon(win); }
  99
 100     // implementation of wxNotificationMessage method with the same name
 101     static wxTaskBarIcon *UseTaskBarIcon(wxTaskBarIcon *icon);
 102
 103     virtual bool DoShow(const wxString& title,
 104                         const wxString& message,
 105                         int timeout,
 106                         int flags);
 107
 108 protected:
 109     // sets up m_icon (doesn't do anything with the old value, caller beware)
 110     void SetUpIcon(wxWindow *win);
 111
 112
 113     static wxTaskBarIcon *ms_iconToUse;
 114
 115     // the icon we attach our notification to, either ms_iconToUse or a
 116     // temporary one which we will destroy when done
 117     wxTaskBarIcon *m_icon;
 118
 119     // should be only used if m_icon != NULL and indicates whether we should
 120     // delete it
 121     bool m_ownsIcon;
 122 };
 123
 124 // implementation for automatically hidden notifications
 125 class wxAutoNotifMsgImpl : public wxBalloonNotifMsgImpl
 126 {
 127 public:
 128     wxAutoNotifMsgImpl(wxWindow *win);
 129
 130     virtual bool DoShow(const wxString& title,
 131                         const wxString& message,
 132                         int timeout,
 133                         int flags);
 134
 135     // can't close automatic notification [currently]
 136     virtual bool DoClose() { return false; }
 137 };
 138
 139 // implementation for manually closed notifications
 140 class wxManualNotifMsgImpl : public wxBalloonNotifMsgImpl
 141 {
 142 public:
 143     wxManualNotifMsgImpl(wxWindow *win);
 144     virtual ~wxManualNotifMsgImpl();
 145
 146     virtual bool DoShow(const wxString& title,
 147                         const wxString& message,
 148                         int timeout,
 149                         int flags);
 150     virtual bool DoClose();
 151
 152 private:
 153     // store ctor parameter as we need it to recreate the icon later if we're
 154     // closed and shown again
 155     wxWindow * const m_win;
 156 };
 157
 158 // ----------------------------------------------------------------------------
 159 // custom event handler for task bar icons
 160 // ----------------------------------------------------------------------------
 161
 162 // normally we'd just use a custom taskbar icon class but this is impossible
 163 // because we can be asked to attach the notifications to an existing icon
 164 // which we didn't create, hence we install a special event handler allowing us
 165 // to get the events we need (and, crucially, to delete the icon when it's not
 166 // needed any more) in any case
 167
 168 class wxNotificationIconEvtHandler : public wxEvtHandler
 169 {
 170 public:
 171     wxNotificationIconEvtHandler(wxTaskBarIcon *icon);
 172
 173 private:
 174     void OnTimeout(wxTaskBarIconEvent& event);
 175     void OnClick(wxTaskBarIconEvent& event);
 176
 177     void OnIconHidden();
 178
 179
 180     wxTaskBarIcon * const m_icon;
 181
 182     wxDECLARE_NO_COPY_CLASS(wxNotificationIconEvtHandler);
 183 };
 184
 185 // ============================================================================
 186 // implementation
 187 // ============================================================================
 188
 189 // ----------------------------------------------------------------------------
 190 // wxNotificationIconEvtHandler
 191 // ----------------------------------------------------------------------------
 192
 193 wxNotificationIconEvtHandler::wxNotificationIconEvtHandler(wxTaskBarIcon *icon)
 194                             : m_icon(icon)
 195 {
 196     m_icon->Connect
 197             (
 198               wxEVT_TASKBAR_BALLOON_TIMEOUT,
 199               wxTaskBarIconEventHandler(wxNotificationIconEvtHandler::OnTimeout),
 200               NULL,
 201               this
 202             );
 203
 204     m_icon->Connect
 205             (
 206               wxEVT_TASKBAR_BALLOON_CLICK,
 207               wxTaskBarIconEventHandler(wxNotificationIconEvtHandler::OnClick),
 208               NULL,
 209               this
 210             );
 211 }
 212
 213 void wxNotificationIconEvtHandler::OnIconHidden()
 214 {
 215     delete m_icon;
 216
 217     delete this;
 218 }
 219
 220 void
 221 wxNotificationIconEvtHandler::OnTimeout(wxTaskBarIconEvent& WXUNUSED(event))
 222 {
 223     OnIconHidden();
 224 }
 225
 226 void wxNotificationIconEvtHandler::OnClick(wxTaskBarIconEvent& WXUNUSED(event))
 227 {
 228     // TODO: generate an event notifying the user code?
 229
 230     OnIconHidden();
 231 }
 232
 233 // ----------------------------------------------------------------------------
 234 // wxBalloonNotifMsgImpl
 235 // ----------------------------------------------------------------------------
 236
 237 wxTaskBarIcon *wxBalloonNotifMsgImpl::ms_iconToUse = NULL;
 238
 239 /* static */
 240 wxTaskBarIcon *wxBalloonNotifMsgImpl::UseTaskBarIcon(wxTaskBarIcon *icon)
 241 {
 242     wxTaskBarIcon * const iconOld = ms_iconToUse;
 243     ms_iconToUse = icon;
 244     return iconOld;
 245 }
 246
 247 void wxBalloonNotifMsgImpl::SetUpIcon(wxWindow *win)
 248 {
 249     if ( ms_iconToUse )
 250     {
 251         // use an existing icon
 252         m_ownsIcon = false;
 253         m_icon = ms_iconToUse;
 254     }
 255     else // no user-specified icon to attach to
 256     {
 257         // create our own one
 258         m_ownsIcon = true;
 259         m_icon = new wxTaskBarIcon;
 260
 261         // use the icon of the associated (or main, if none) frame
 262         wxIcon icon;
 263         if ( win )
 264             win = wxGetTopLevelParent(win);
 265         if ( !win )
 266             win = wxTheApp->GetTopWindow();
 267         if ( win )
 268         {
 269             const wxTopLevelWindow * const
 270                 tlw = wxDynamicCast(win, wxTopLevelWindow);
 271             if ( tlw )
 272                 icon = tlw->GetIcon();
 273         }
 274
 275         if ( !icon.IsOk() )
 276         {
 277             // we really must have some icon
 278             icon = wxIcon(wxT("wxICON_AAA"));
 279         }
 280
 281         m_icon->SetIcon(icon);
 282     }
 283 }
 284
 285 bool
 286 wxBalloonNotifMsgImpl::DoShow(const wxString& title,
 287                               const wxString& message,
 288                               int timeout,
 289                               int flags)
 290 {
 291     timeout *= 1000; // Windows expresses timeout in milliseconds
 292
 293     return m_icon->ShowBalloon(title, message, timeout, flags);
 294 }
 295
 296 // ----------------------------------------------------------------------------
 297 // wxManualNotifMsgImpl
 298 // ----------------------------------------------------------------------------
 299
 300 wxManualNotifMsgImpl::wxManualNotifMsgImpl(wxWindow *win)
 301                     : wxBalloonNotifMsgImpl(win),
 302                       m_win(win)
 303 {
 304 }
 305
 306 wxManualNotifMsgImpl::~wxManualNotifMsgImpl()
 307 {
 308     if ( m_icon )
 309         DoClose();
 310 }
 311
 312 bool
 313 wxManualNotifMsgImpl::DoShow(const wxString& title,
 314                              const wxString& message,
 315                              int WXUNUSED_UNLESS_DEBUG(timeout),
 316                              int flags)
 317 {
 318     wxASSERT_MSG( timeout == wxNotificationMessage::Timeout_Never,
 319                     wxT("shouldn't be used") );
 320
 321     // base class creates the icon for us initially but we could have destroyed
 322     // it in DoClose(), recreate it if this was the case
 323     if ( !m_icon )
 324         SetUpIcon(m_win);
 325
 326     // use maximal (in current Windows versions) timeout (but it will still
 327     // disappear on its own)
 328     return wxBalloonNotifMsgImpl::DoShow(title, message, 30, flags);
 329 }
 330
 331 bool wxManualNotifMsgImpl::DoClose()
 332 {
 333     if ( m_ownsIcon )
 334     {
 335         // we don't need the icon any more
 336         delete m_icon;
 337     }
 338     else // using an existing icon
 339     {
 340         // just hide the balloon
 341         m_icon->ShowBalloon("", "");
 342     }
 343
 344     m_icon = NULL;
 345
 346     return true;
 347 }
 348
 349 // ----------------------------------------------------------------------------
 350 // wxAutoNotifMsgImpl
 351 // ----------------------------------------------------------------------------
 352
 353 wxAutoNotifMsgImpl::wxAutoNotifMsgImpl(wxWindow *win)
 354                   : wxBalloonNotifMsgImpl(win)
 355 {
 356     if ( m_ownsIcon )
 357     {
 358         // This object will self-destruct and also delete the icon when the
 359         // notification is hidden.
 360         new wxNotificationIconEvtHandler(m_icon);
 361     }
 362 }
 363
 364 bool
 365 wxAutoNotifMsgImpl::DoShow(const wxString& title,
 366                            const wxString& message,
 367                            int timeout,
 368                            int flags)
 369 {
 370     wxASSERT_MSG( timeout != wxNotificationMessage::Timeout_Never,
 371                     wxT("shouldn't be used") );
 372
 373     if ( timeout == wxNotificationMessage::Timeout_Auto )
 374     {
 375         // choose a value more or less in the middle of the allowed range
 376         timeout = 1;
 377     }
 378
 379     return wxBalloonNotifMsgImpl::DoShow(title, message, timeout, flags);
 380 }
 381
 382 // ----------------------------------------------------------------------------
 383 // wxNotificationMessage
 384 // ----------------------------------------------------------------------------
 385
 386 /* static */
 387 bool wxNotificationMessage::ms_alwaysUseGeneric = false;
 388
 389 /* static */
 390 wxTaskBarIcon *wxNotificationMessage::UseTaskBarIcon(wxTaskBarIcon *icon)
 391 {
 392     return wxBalloonNotifMsgImpl::UseTaskBarIcon(icon);
 393 }
 394
 395 bool wxNotificationMessage::Show(int timeout)
 396 {
 397     if ( !m_impl )
 398     {
 399         if ( !ms_alwaysUseGeneric && wxTheApp->GetShell32Version() >= 500 )
 400         {
 401             if ( timeout == Timeout_Never )
 402                 m_impl = new wxManualNotifMsgImpl(GetParent());
 403             else
 404                 m_impl = new wxAutoNotifMsgImpl(GetParent());
 405         }
 406         else // no support for balloon tooltips
 407         {
 408             m_impl = new wxGenericNotifMsgImpl;
 409         }
 410     }
 411     //else: reuse the same implementation for the subsequent calls, it would
 412     //      be too confusing if it changed
 413
 414     return m_impl->DoShow(GetTitle(), GetMessage(), timeout, GetFlags());
 415 }
 416
 417 bool wxNotificationMessage::Close()
 418 {
 419     wxCHECK_MSG( m_impl, false, "must show the notification first" );
 420
 421     return m_impl->DoClose();
 422 }
 423
 424 wxNotificationMessage::~wxNotificationMessage()
 425 {
 426     delete m_impl;
 427 }
 428
 429 #endif // wxUSE_NOTIFICATION_MESSAGE && wxUSE_TASKBARICON