1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
/**
* @file llnotificationhandler.h
* @brief Here are implemented Notification Handling Classes.
*
* $LicenseInfo:firstyear=2003&license=viewergpl$
*
* Copyright (c) 2003-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLNOTIFICATIONHANDLER_H
#define LL_LLNOTIFICATIONHANDLER_H
#include "llwindow.h"
//#include "llnotifications.h"
#include "llchannelmanager.h"
#include "llchat.h"
namespace LLNotificationsUI
{
// ENotificationType enumerates all possible types of notifications that could be met
//
typedef enum e_notification_type
{
NT_NOTIFY,
NT_NOTIFYTIP,
NT_GROUPNOTIFY,
NT_IMCHAT,
NT_GROUPCHAT,
NT_NEARBYCHAT,
NT_ALERT,
NT_ALERTMODAL,
NT_OFFER
} ENotificationType;
/**
* Handler of notification events.
* This handler manages events related to toasts and chicklets. This is base class
* for chat and system notification handlers.
*/
// LLEventHandler is a base class that specifies a common interface for all
// notification handlers. It states, that every handler must react on the follofing
// events:
// - deleting of a toast;
// - initialization of a corresponding channel;
// Also every handler must have the following attributes:
// - type of the notification that this handler is responsible to;
// - pointer to a correspondent screen channel, in which all toasts of the handled notification's
// type should be displayed
// This class also provides the following signald:
// - increment counter signal
// - decrement counter signal
// - update counter signal
// - signal, that emits ID of the notification that is being processed
//
class LLEventHandler
{
public:
virtual ~LLEventHandler() {};
// callbacks for counters
typedef boost::function<void (void)> notification_callback_t;
typedef boost::signals2::signal<void (void)> notification_signal_t;
notification_signal_t mNewNotificationSignal;
notification_signal_t mDelNotificationSignal;
boost::signals2::connection setNewNotificationCallback(notification_callback_t cb) { return mNewNotificationSignal.connect(cb); }
boost::signals2::connection setDelNotification(notification_callback_t cb) { return mDelNotificationSignal.connect(cb); }
// callback for notification/toast
typedef boost::function<void (const LLUUID id)> notification_id_callback_t;
typedef boost::signals2::signal<void (const LLUUID id)> notification_id_signal_t;
notification_id_signal_t mNotificationIDSignal;
boost::signals2::connection setNotificationIDCallback(notification_id_callback_t cb) { return mNotificationIDSignal.connect(cb); }
protected:
virtual void onDeleteToast(LLToast* toast)=0;
// arrange handler's channel on a screen
// is necessary to unbind a moment of creation of a channel and a moment of positioning of it
// it is useful when positioning depends on positions of other controls, that could not be created
// at the moment, when a handlers creates a channel.
virtual void initChannel()=0;
LLScreenChannelBase* mChannel;
e_notification_type mType;
};
// LLSysHandler and LLChatHandler are more specific base classes
// that divide all notification handlers on to groups:
// - handlers for different system notifications (script dialogs, tips, group notices, alerts and IMs);
// - handlers for different messaging notifications (nearby chat)
/**
* Handler for system notifications.
*/
class LLSysHandler : public LLEventHandler
{
public:
virtual ~LLSysHandler() {};
virtual bool processNotification(const LLSD& notify)=0;
};
/**
* Handler for chat message notifications.
*/
class LLChatHandler : public LLEventHandler
{
public:
virtual ~LLChatHandler() {};
virtual void processChat(const LLChat& chat_msg)=0;
};
/**
* Handler for IM notifications.
* It manages life time of IMs, group messages.
*/
class LLIMHandler : public LLSysHandler
{
public:
LLIMHandler(e_notification_type type, const LLSD& id);
virtual ~LLIMHandler();
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
};
/**
* Handler for system informational notices.
* It manages life time of tip notices.
*/
class LLTipHandler : public LLSysHandler
{
public:
LLTipHandler(e_notification_type type, const LLSD& id);
virtual ~LLTipHandler();
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
};
/**
* Handler for system informational notices.
* It manages life time of script notices.
*/
class LLScriptHandler : public LLSysHandler
{
public:
LLScriptHandler(e_notification_type type, const LLSD& id);
virtual ~LLScriptHandler();
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
// own handlers
void onRejectToast(LLUUID& id);
};
/**
* Handler for group system notices.
*/
class LLGroupHandler : public LLSysHandler
{
public:
LLGroupHandler(e_notification_type type, const LLSD& id);
virtual ~LLGroupHandler();
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
// own handlers
void onRejectToast(LLUUID& id);
};
/**
* Handler for alert system notices.
*/
class LLAlertHandler : public LLSysHandler
{
public:
LLAlertHandler(e_notification_type type, const LLSD& id);
virtual ~LLAlertHandler();
void setAlertMode(bool is_modal) { mIsModal = is_modal; }
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
bool mIsModal;
};
/**
* Handler for offers notices.
* It manages life time of offer notices.
*/
class LLOfferHandler : public LLSysHandler
{
public:
LLOfferHandler(e_notification_type type, const LLSD& id);
virtual ~LLOfferHandler();
// base interface functions
virtual bool processNotification(const LLSD& notify);
protected:
virtual void onDeleteToast(LLToast* toast);
virtual void initChannel();
// own handlers
void onRejectToast(LLUUID& id);
};
}
#endif
|
