%% Purpose: wxNotificationMessage documentation
%% Author: Vadim Zeitlin
%% Created: 2007-11-24
-%% RCS-ID: $Id: cmdlpars.tex 49199 2007-10-17 17:32:16Z VZ $
+%% RCS-ID: $Id$
%% Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwidgets.org>
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
before showing it.
-\func{}{wxNotificationMessage}{\param{const wxString\& }{title}, \param{const wxString\& }{message = wxString()}, \param{wxWindow* }{parent = NULL}}
+\func{}{wxNotificationMessage}{\param{const wxString\& }{title}, \param{const wxString\& }{message = wxString()}, \param{wxWindow* }{parent = NULL}, \parent{int }{flags = \texttt{wxICON\_INFORMATION}}
-Create a notification object with the given title and message (the
-latter may be empty in which case only the title will be shown).
+Create a notification object with the given attributes.
+
+See \helpref{SetTitle}{wxnotificationmessagesettitle},
+\helpref{SetMessage}{wxnotificationmessagesetmessage},
+\helpref{SetParent}{wxnotificationmessagesetparent} and
+\helpref{SetFlags}{wxnotificationmessagesetflags} for the description of the
+corresponding parameters.
\membersection{wxNotificationMessage::Close}\label{wxnotificationmessageclose}
systems automatically hidden notifications can't be hidden manually)
+\membersection{wxNotificationMessage::SetFlags}\label{wxnotificationmessagesetflags}
+
+\func{void}{SetFlags}{\param{int }{flags}}
+
+This parameter can be currently used to specify the icon to show in the
+notification. Valid values are \texttt{wxICON\_INFORMATION},
+\texttt{wxICON\_WARNING} and \texttt{wxICON\_ERROR} (notice that
+\texttt{wxICON\_QUESTION} is not allowed here).
+
+Some implementations of this class may not support the icons.
+
+
\membersection{wxNotificationMessage::SetMessage}\label{wxnotificationmessagesetmessage}
\func{void}{SetMessage}{\param{const wxString\& }{message}}
-Set the main text of the notification.
+Set the main text of the notification. This should be a more detailed
+description than the title but still limited to reasonable length (not more
+than 256 characters).
\membersection{wxNotificationMessage::SetParent}\label{wxnotificationmessagesetparent}
\func{void}{SetTitle}{\param{const wxString\& }{title}}
-Set the title, it must be a concise string, use
+Set the title, it must be a concise string (not more than 64 characters), use
\helpref{SetMessage}{wxnotificationmessagesetmessage} to give the user more
details.
///////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/notifmsg.h
-// Purpose: generic implementation of wxNotificationMessage
+// Purpose: generic implementation of wxGenericNotificationMessage
// Author: Vadim Zeitlin
// Created: 2007-11-24
// RCS-ID: $Id$
class wxNotificationMessageDialog;
// ----------------------------------------------------------------------------
-// wxNotificationMessage
+// wxGenericNotificationMessage
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxNotificationMessage : public wxNotificationMessageBase
+class WXDLLIMPEXP_ADV wxGenericNotificationMessage : public wxNotificationMessageBase
{
public:
- wxNotificationMessage() { Init(); }
- wxNotificationMessage(const wxString& title,
- const wxString& message = wxString(),
- wxWindow *parent = NULL)
+ wxGenericNotificationMessage() { Init(); }
+ wxGenericNotificationMessage(const wxString& title,
+ const wxString& message = wxString(),
+ wxWindow *parent = NULL)
: wxNotificationMessageBase(title, message, parent)
{
Init();
}
- virtual ~wxNotificationMessage();
+ virtual ~wxGenericNotificationMessage();
virtual bool Show(int timeout = Timeout_Auto);
wxNotificationMessageDialog *m_dialog;
- DECLARE_NO_COPY_CLASS(wxNotificationMessage)
+ DECLARE_NO_COPY_CLASS(wxGenericNotificationMessage)
};
#endif // _WX_GENERIC_NOTIFMSG_H_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/msw/notifmsg.h
+// Purpose: implementation of wxNotificationMessage for Windows
+// Author: Vadim Zeitlin
+// Created: 2007-12-01
+// RCS-ID: $Id$
+// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MSW_NOTIFMSG_H_
+#define _WX_MSW_NOTIFMSG_H_
+
+class WXDLLIMPEXP_FWD_ADV wxTaskBarIcon;
+
+// ----------------------------------------------------------------------------
+// wxNotificationMessage
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_ADV wxNotificationMessage : public wxNotificationMessageBase
+{
+public:
+ wxNotificationMessage() { Init(); }
+ wxNotificationMessage(const wxString& title,
+ const wxString& message = wxString(),
+ wxWindow *parent = NULL)
+ : wxNotificationMessageBase(title, message, parent)
+ {
+ Init();
+ }
+
+ virtual ~wxNotificationMessage();
+
+
+ virtual bool Show(int timeout = Timeout_Auto);
+ virtual bool Close();
+
+ // MSW implementation-specific methods
+
+ // by default, wxNotificationMessage under MSW creates a temporary taskbar
+ // icon to which it attaches the notification, if there is an existing
+ // taskbar icon object in the application you may want to call this method
+ // to attach the notification to it instead (we won't take ownership of it
+ // and you can also pass NULL to not use the icon for notifications any
+ // more)
+ //
+ // returns the task bar icon which was used previously (may be NULL)
+ static wxTaskBarIcon *UseTaskBarIcon(wxTaskBarIcon *icon);
+
+private:
+ // common part of all ctors
+ void Init() { m_impl = NULL; }
+
+
+ // the real implementation of this class (selected during run-time because
+ // the balloon task bar icons are not available in all Windows versions)
+ class wxNotifMsgImpl *m_impl;
+
+
+ DECLARE_NO_COPY_CLASS(wxNotificationMessage)
+};
+
+#endif // _WX_MSW_NOTIFMSG_H_
+
// ----------------------
// default ctor, use setters below to initialize it later
- wxNotificationMessageBase() { }
+ wxNotificationMessageBase()
+ {
+ m_parent = NULL;
+ m_flags = wxICON_INFORMATION;
+ }
// create a notification object with the given title and message (the
// latter may be empty in which case only the title will be shown)
wxNotificationMessageBase(const wxString& title,
const wxString& message = wxString(),
- wxWindow *parent = NULL)
+ wxWindow *parent = NULL,
+ int flags = wxICON_INFORMATION)
: m_title(title),
m_message(message),
m_parent(parent)
{
+ SetFlags(flags);
}
// note that the setters must be called before Show()
// main application window by default
void SetParent(wxWindow *parent) { m_parent = parent; }
+ // this method can currently be used to choose a standard icon to use: the
+ // parameter may be one of wxICON_INFORMATION, wxICON_WARNING or
+ // wxICON_ERROR only (but not wxICON_QUESTION)
+ void SetFlags(int flags)
+ {
+ wxASSERT_MSG( flags == wxICON_INFORMATION ||
+ flags == wxICON_WARNING || flags == wxICON_ERROR,
+ "Invalid icon flags specified" );
+
+ m_flags = flags;
+ }
+
// showing and hiding
// ------------------
const wxString& GetTitle() const { return m_title; }
const wxString& GetMessage() const { return m_message; }
wxWindow *GetParent() const { return m_parent; }
+ int GetFlags() const { return m_flags; }
// return the concatenation of title and message separated by a new line,
// this is suitable for simple implementation which have no support for
wxWindow *m_parent;
+ int m_flags;
+
DECLARE_NO_COPY_CLASS(wxNotificationMessageBase)
};
-#define wxUSE_GENERIC_NOTIFICATION_MESSAGE 1
-
#if defined(__WXGTK__) && wxUSE_LIBHILDON
- // we always use the native implementation in Hildon while the other ports
- // will fall back to the generic one even if they have a native version too
- #undef wxUSE_GENERIC_NOTIFICATION_MESSAGE
- #define wxUSE_GENERIC_NOTIFICATION_MESSAGE 0
-
#include "wx/gtk/hildon/notifmsg.h"
/*
TODO: provide support for
- libnotify (Gnome)
- - Snarl (http://www.fullphat.net/, Win32)
- Growl (http://growl.info/, OS X)
*/
+#elif defined(__WXMSW__) && wxUSE_TASKBARICON
+ #include "wx/msw/notifmsg.h"
#else
#include "wx/generic/notifmsg.h"
+
+ class wxNotificationMessage : public wxGenericNotificationMessage
+ {
+ public:
+ wxNotificationMessage() { }
+ wxNotificationMessage(const wxString& title,
+ const wxString& message = wxString(),
+ wxWindow *parent = NULL,
+ int flags = wxICON_INFORMATION)
+ : wxGenericNotificationMessage(title, message, parent, flags)
+ {
+ }
+ };
#endif
#endif // wxUSE_NOTIFICATION_MESSAGE
///////////////////////////////////////////////////////////////////////////////
// Name: src/generic/notifmsgg.cpp
-// Purpose: generic implementation of wxNotificationMessage
+// Purpose: generic implementation of wxGenericNotificationMessage
// Author: Vadim Zeitlin
// Created: 2007-11-24
// RCS-ID: $Id$
#pragma hdrstop
#endif
-// include this before the test below, wxUSE_GENERIC_NOTIFICATION_MESSAGE is
-// defined in this header
-#include "wx/notifmsg.h"
+#ifndef wxUSE_LIBHILDON
+ #define wxUSE_LIBHILDON 0
+#endif
-#if wxUSE_GENERIC_NOTIFICATION_MESSAGE
+#if wxUSE_NOTIFICATION_MESSAGE && !wxUSE_LIBHILDON
#ifndef WX_PRECOMP
#include "wx/dialog.h"
#include "wx/timer.h"
#endif //WX_PRECOMP
+// even if the platform has the native implementation, we still normally want
+// to use the generic one (unless it's totally unsuitable for the target UI as
+// is the case of Hildon) because it may provide more features, so include
+// wx/generic/notifmsg.h to get wxGenericNotificationMessage declaration even
+// if wx/notifmsg.h only declares wxNotificationMessage itself (if it already
+// uses the generic version, the second inclusion will do no harm)
+#include "wx/notifmsg.h"
+#include "wx/generic/notifmsg.h"
+
// ----------------------------------------------------------------------------
// wxNotificationMessageDialog
// ----------------------------------------------------------------------------
wxSizer *sizer = CreateTextSizer(text);
SetSizerAndFit(sizer);
- if ( timeout != wxNotificationMessage::Timeout_Never )
+ if ( timeout != wxGenericNotificationMessage::Timeout_Never )
{
// wxTimer uses ms, timeout is in seconds
m_timer.Start(timeout*1000, true /* one shot only */);
}
// ============================================================================
-// wxNotificationMessage implementation
+// wxGenericNotificationMessage implementation
// ============================================================================
-int wxNotificationMessage::ms_timeout = 10;
+int wxGenericNotificationMessage::ms_timeout = 10;
-/* static */ void wxNotificationMessage::SetDefaultTimeout(int timeout)
+/* static */ void wxGenericNotificationMessage::SetDefaultTimeout(int timeout)
{
wxASSERT_MSG( timeout > 0,
"negative or zero default timeout doesn't make sense" );
ms_timeout = timeout;
}
-void wxNotificationMessage::Init()
+void wxGenericNotificationMessage::Init()
{
m_dialog = NULL;
}
-wxNotificationMessage::~wxNotificationMessage()
+wxGenericNotificationMessage::~wxGenericNotificationMessage()
{
if ( m_dialog->IsAutomatic() )
{
// we want to allow the user to create an automatically hidden
- // notification just by creating a local wxNotificationMessage object
+ // notification just by creating a local wxGenericNotificationMessage object
// and so we shouldn't hide the notification when this object goes out
// of scope
m_dialog->SetDeleteOnHide();
}
}
-bool wxNotificationMessage::Show(int timeout)
+bool wxGenericNotificationMessage::Show(int timeout)
{
if ( timeout == Timeout_Auto )
{
return true;
}
-bool wxNotificationMessage::Close()
+bool wxGenericNotificationMessage::Close()
{
if ( !m_dialog )
return false;
return true;
}
-#endif // wxUSE_GENERIC_NOTIFICATION_MESSAGE
+#endif // wxUSE_NOTIFICATION_MESSAGE && !wxUSE_LIBHILDON
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: src/msw/notifmsg.cpp
+// Purpose: implementation of wxNotificationMessage for Windows
+// Author: Vadim Zeitlin
+// Created: 2007-12-01
+// RCS-ID: $Id$
+// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+#if wxUSE_NOTIFICATION_MESSAGE && wxUSE_TASKBARICON
+
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+#endif // WX_PRECOMP
+
+#include "wx/notifmsg.h"
+#include "wx/generic/notifmsg.h"
+
+#include "wx/taskbar.h"
+
+// ----------------------------------------------------------------------------
+// different implementations used by wxNotificationMessage
+// ----------------------------------------------------------------------------
+
+// base class for all available implementations
+class wxNotifMsgImpl
+{
+public:
+ wxNotifMsgImpl() { }
+ virtual ~wxNotifMsgImpl() { }
+
+ virtual bool DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags) = 0;
+ virtual bool DoClose() = 0;
+
+private:
+ DECLARE_NO_COPY_CLASS(wxNotifMsgImpl)
+};
+
+// implementation which is simply a bridge to wxGenericNotificationMessage
+class wxGenericNotifMsgImpl : public wxNotifMsgImpl
+{
+public:
+ wxGenericNotifMsgImpl() : m_notif(new wxGenericNotificationMessage) { }
+ virtual ~wxGenericNotifMsgImpl() { delete m_notif; }
+
+ virtual bool DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags)
+ {
+ m_notif->SetTitle(title);
+ m_notif->SetMessage(message);
+ m_notif->SetFlags(flags);
+ return m_notif->Show(timeout);
+ }
+
+ virtual bool DoClose()
+ {
+ return m_notif->Close();
+ }
+
+private:
+ wxGenericNotificationMessage * const m_notif;
+};
+
+// common base class for implementations using a taskbar icon and balloons
+class wxBalloonNotifMsgImpl : public wxNotifMsgImpl
+{
+public:
+ // ctor sets up m_icon (using the icon of the top level parent of the given
+ // window) which can be used to show an attached balloon later by the
+ // derived classes
+ wxBalloonNotifMsgImpl(wxWindow *win) { SetUpIcon(win); }
+
+ // implementation of wxNotificationMessage method with the same name
+ static wxTaskBarIcon *UseTaskBarIcon(wxTaskBarIcon *icon);
+
+ virtual bool DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags);
+
+protected:
+ // sets up m_icon (doesn't do anything with the old value, caller beware)
+ void SetUpIcon(wxWindow *win);
+
+
+ static wxTaskBarIcon *ms_iconToUse;
+
+ // the icon we attach our notification to, either ms_iconToUse or a
+ // temporary one which we will destroy when done
+ wxTaskBarIcon *m_icon;
+
+ // should be only used if m_icon != NULL and indicates whether we should
+ // delete it
+ bool m_ownsIcon;
+};
+
+// implementation for automatically hidden notifications
+class wxAutoNotifMsgImpl : public wxBalloonNotifMsgImpl
+{
+public:
+ wxAutoNotifMsgImpl(wxWindow *win);
+
+ virtual bool DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags);
+
+ // can't close automatic notification [currently]
+ virtual bool DoClose() { return false; }
+
+private:
+ // custom event handler connected to m_icon which will receive the icon
+ // close event and delete it and itself when it happens
+ wxEvtHandler * const m_iconEvtHandler;
+};
+
+// implementation for manually closed notifications
+class wxManualNotifMsgImpl : public wxBalloonNotifMsgImpl
+{
+public:
+ wxManualNotifMsgImpl(wxWindow *win);
+ virtual ~wxManualNotifMsgImpl();
+
+ virtual bool DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags);
+ virtual bool DoClose();
+
+private:
+ // store ctor parameter as we need it to recreate the icon later if we're
+ // closed and shown again
+ wxWindow * const m_win;
+};
+
+// ----------------------------------------------------------------------------
+// custom event handler for task bar icons
+// ----------------------------------------------------------------------------
+
+// normally we'd just use a custom taskbar icon class but this is impossible
+// because we can be asked to attach the notifications to an existing icon
+// which we didn't create, hence we install a special event handler allowing us
+// to get the events we need (and, crucially, to delete the icon when it's not
+// needed any more) in any case
+
+class wxNotificationIconEvtHandler : public wxEvtHandler
+{
+public:
+ wxNotificationIconEvtHandler(wxTaskBarIcon *icon);
+
+private:
+ void OnTimeout(wxTaskBarIconEvent& event);
+ void OnClick(wxTaskBarIconEvent& event);
+
+ void OnIconHidden();
+
+
+ wxTaskBarIcon * const m_icon;
+
+ DECLARE_NO_COPY_CLASS(wxNotificationIconEvtHandler)
+};
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxNotificationIconEvtHandler
+// ----------------------------------------------------------------------------
+
+wxNotificationIconEvtHandler::wxNotificationIconEvtHandler(wxTaskBarIcon *icon)
+ : m_icon(icon)
+{
+ m_icon->Connect
+ (
+ wxEVT_TASKBAR_BALLOON_TIMEOUT,
+ wxTaskBarIconEventHandler(wxNotificationIconEvtHandler::OnTimeout),
+ NULL,
+ this
+ );
+
+ m_icon->Connect
+ (
+ wxEVT_TASKBAR_BALLOON_CLICK,
+ wxTaskBarIconEventHandler(wxNotificationIconEvtHandler::OnTimeout),
+ NULL,
+ this
+ );
+}
+
+void wxNotificationIconEvtHandler::OnIconHidden()
+{
+ delete m_icon;
+
+ delete this;
+}
+
+void
+wxNotificationIconEvtHandler::OnTimeout(wxTaskBarIconEvent& WXUNUSED(event))
+{
+ OnIconHidden();
+}
+
+void wxNotificationIconEvtHandler::OnClick(wxTaskBarIconEvent& WXUNUSED(event))
+{
+ // TODO: generate an event notifying the user code?
+
+ OnIconHidden();
+}
+
+// ----------------------------------------------------------------------------
+// wxBalloonNotifMsgImpl
+// ----------------------------------------------------------------------------
+
+wxTaskBarIcon *wxBalloonNotifMsgImpl::ms_iconToUse = NULL;
+
+/* static */
+wxTaskBarIcon *wxBalloonNotifMsgImpl::UseTaskBarIcon(wxTaskBarIcon *icon)
+{
+ wxTaskBarIcon * const iconOld = ms_iconToUse;
+ ms_iconToUse = icon;
+ return iconOld;
+}
+
+void wxBalloonNotifMsgImpl::SetUpIcon(wxWindow *win)
+{
+ if ( ms_iconToUse )
+ {
+ // use an existing icon
+ m_ownsIcon = false;
+ m_icon = ms_iconToUse;
+ }
+ else // no user-specified icon to attach to
+ {
+ // create our own one
+ m_ownsIcon = true;
+ m_icon = new wxTaskBarIcon;
+
+ // use the icon of the associated (or main, if none) frame
+ wxIcon icon;
+ if ( win )
+ win = wxGetTopLevelParent(win);
+ if ( !win )
+ win = wxTheApp->GetTopWindow();
+ if ( win )
+ {
+ const wxTopLevelWindow * const
+ tlw = wxDynamicCast(win, wxTopLevelWindow);
+ if ( tlw )
+ icon = tlw->GetIcon();
+ }
+
+ if ( !icon.IsOk() )
+ {
+ // we really must have some icon
+ icon = wxIcon(_T("wxICON_AAA"));
+ }
+
+ m_icon->SetIcon(icon);
+ }
+}
+
+bool
+wxBalloonNotifMsgImpl::DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags)
+{
+ timeout *= 1000; // Windows expresses timeout in milliseconds
+
+ return m_icon->ShowBalloon(title, message, timeout, flags);
+}
+
+// ----------------------------------------------------------------------------
+// wxManualNotifMsgImpl
+// ----------------------------------------------------------------------------
+
+wxManualNotifMsgImpl::wxManualNotifMsgImpl(wxWindow *win)
+ : wxBalloonNotifMsgImpl(win),
+ m_win(win)
+{
+}
+
+wxManualNotifMsgImpl::~wxManualNotifMsgImpl()
+{
+ if ( m_icon )
+ DoClose();
+}
+
+bool
+wxManualNotifMsgImpl::DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags)
+{
+ wxASSERT_MSG( timeout == wxNotificationMessage::Timeout_Never,
+ _T("shouldn't be used") );
+
+ // base class creates the icon for us initially but we could have destroyed
+ // it in DoClose(), recreate it if this was the case
+ if ( !m_icon )
+ SetUpIcon(m_win);
+
+ // use maximal (in current Windows versions) timeout (but it will still
+ // disappear on its own)
+ return wxBalloonNotifMsgImpl::DoShow(title, message, 30, flags);
+}
+
+bool wxManualNotifMsgImpl::DoClose()
+{
+ if ( m_ownsIcon )
+ {
+ // we don't need the icon any more
+ delete m_icon;
+ }
+ else // using an existing icon
+ {
+ // just hide the balloon
+ m_icon->ShowBalloon("", "");
+ }
+
+ m_icon = NULL;
+
+ return true;
+}
+
+// ----------------------------------------------------------------------------
+// wxAutoNotifMsgImpl
+// ----------------------------------------------------------------------------
+
+wxAutoNotifMsgImpl::wxAutoNotifMsgImpl(wxWindow *win)
+ : wxBalloonNotifMsgImpl(win),
+ m_iconEvtHandler(new wxNotificationIconEvtHandler(m_icon))
+{
+}
+
+bool
+wxAutoNotifMsgImpl::DoShow(const wxString& title,
+ const wxString& message,
+ int timeout,
+ int flags)
+{
+ wxASSERT_MSG( timeout != wxNotificationMessage::Timeout_Never,
+ _T("shouldn't be used") );
+
+ if ( timeout == wxNotificationMessage::Timeout_Auto )
+ {
+ // choose a value more or less in the middle of the allowed range
+ timeout = 1;
+ }
+
+ return wxBalloonNotifMsgImpl::DoShow(title, message, timeout, flags);
+}
+
+// ----------------------------------------------------------------------------
+// wxNotificationMessage
+// ----------------------------------------------------------------------------
+
+/* static */
+wxTaskBarIcon *wxNotificationMessage::UseTaskBarIcon(wxTaskBarIcon *icon)
+{
+ return wxBalloonNotifMsgImpl::UseTaskBarIcon(icon);
+}
+
+bool wxNotificationMessage::Show(int timeout)
+{
+ if ( !m_impl )
+ {
+ if ( wxTheApp->GetShell32Version() >= 500 )
+ {
+ if ( timeout == Timeout_Never )
+ m_impl = new wxManualNotifMsgImpl(GetParent());
+ else
+ m_impl = new wxAutoNotifMsgImpl(GetParent());
+ }
+ else // no support for balloon tooltips
+ {
+ m_impl = new wxGenericNotifMsgImpl;
+ }
+ }
+ //else: reuse the same implementation for the subsequent calls, it would
+ // be too confusing if it changed
+
+ return m_impl->DoShow(GetTitle(), GetMessage(), timeout, GetFlags());
+}
+
+bool wxNotificationMessage::Close()
+{
+ wxCHECK_MSG( m_impl, false, "must show the notification first" );
+
+ return m_impl->DoClose();
+}
+
+wxNotificationMessage::~wxNotificationMessage()
+{
+ delete m_impl;
+}
+
+#endif // wxUSE_NOTIFICATION_MESSAGE && wxUSE_TASKBARICON
projects / wxWidgets.git / commitdiff
