summaryrefslogtreecommitdiff
path: root/indra/newview/llnotificationhandler.h
blob: a259a4b248632d0e98a3976e6a35ef266742f413 (plain)
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
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
/**
 * @file llnotificationhandler.h
 * @brief Here are implemented Notification Handling Classes.
 *
 * $LicenseInfo:firstyear=2003&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLNOTIFICATIONHANDLER_H
#define LL_LLNOTIFICATIONHANDLER_H

#include <boost/intrusive_ptr.hpp>

#include "llwindow.h"

#include "llnotifications.h"
#include "llchannelmanager.h"
#include "llchat.h"
#include "llinstantmessage.h"
#include "llnotificationptr.h"

class LLFloaterIMSession;

namespace LLNotificationsUI
{

/**
 * 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() {};

protected:
    virtual void onDeleteToast(LLToast* toast) {}

    // 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;

    LLHandle<LLScreenChannelBase>   mChannel;
};

// 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 LLNotificationHandler : public LLEventHandler, public LLNotificationChannel
{
public:
    LLNotificationHandler(const std::string& name, const std::string& notification_type, const std::string& parentName);
    virtual ~LLNotificationHandler() {};

    // base interface functions
    virtual void onAdd(LLNotificationPtr p) { processNotification(p); }
    virtual void onChange(LLNotificationPtr p) { processNotification(p); }
    virtual void onLoad(LLNotificationPtr p) { processNotification(p, false); }
    virtual void onDelete(LLNotificationPtr p) { if (mChannel.get()) mChannel.get()->removeToastByNotificationID(p->getID());}

    virtual bool processNotification(const LLNotificationPtr& notify, bool should_log = true) = 0;
};

class LLSystemNotificationHandler : public LLNotificationHandler
{
public:
    LLSystemNotificationHandler(const std::string& name, const std::string& notification_type);
    virtual ~LLSystemNotificationHandler() {};
};

class LLCommunicationNotificationHandler : public LLNotificationHandler
{
public:
    LLCommunicationNotificationHandler(const std::string& name, const std::string& notification_type);
    virtual ~LLCommunicationNotificationHandler() {};
};

/**
 * Handler for chat message notifications.
 */
class LLChatHandler : public LLEventHandler
{
public:
    virtual ~LLChatHandler() {};

    virtual void processChat(const LLChat& chat_msg, const LLSD &args)=0;
};

/**
 * Handler for IM notifications.
 * It manages life time of IMs, group messages.
 */
class LLIMHandler : public LLCommunicationNotificationHandler
{
public:
    LLIMHandler();
    virtual ~LLIMHandler();
    bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel();
};

/**
 * Handler for system informational notices.
 * It manages life time of tip notices.
 */
class LLTipHandler : public LLSystemNotificationHandler
{
public:
    LLTipHandler();
    virtual ~LLTipHandler();

    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel();
};

/**
 * Handler for system informational notices.
 * It manages life time of script notices.
 */
class LLScriptHandler : public LLSystemNotificationHandler
{
public:
    LLScriptHandler();
    virtual ~LLScriptHandler();

    virtual void onDelete(LLNotificationPtr p);
    virtual void onChange(LLNotificationPtr p);
    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);
    virtual void addToastWithNotification(const LLNotificationPtr& p);

protected:
    virtual void onDeleteToast(LLToast* toast);
    virtual void initChannel();
};


/**
 * Handler for group system notices.
 */
class LLGroupHandler : public LLCommunicationNotificationHandler
{
public:
    LLGroupHandler();
    virtual ~LLGroupHandler();

    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel();
};

/**
 * Handler for alert system notices.
 */
class LLAlertHandler : public LLSystemNotificationHandler
{
public:
    LLAlertHandler(const std::string& name, const std::string& notification_type, bool is_modal);
    virtual ~LLAlertHandler();

    virtual void onChange(LLNotificationPtr p);
    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel();

    bool    mIsModal;
};

class LLViewerAlertHandler  : public LLSystemNotificationHandler
{
    LOG_CLASS(LLViewerAlertHandler);
public:
    LLViewerAlertHandler(const std::string& name, const std::string& notification_type);
    virtual ~LLViewerAlertHandler() {};

    virtual void onDelete(LLNotificationPtr p) {};
    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel() {};
};

/**
 * Handler for offers notices.
 * It manages life time of offer notices.
 */
class LLOfferHandler : public LLCommunicationNotificationHandler
{
public:
    LLOfferHandler();
    virtual ~LLOfferHandler();

    virtual void onChange(LLNotificationPtr p);
    virtual void onDelete(LLNotificationPtr notification);
    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel();
};

/**
 * Handler for UI hints.
 */
class LLHintHandler : public LLSystemNotificationHandler
{
public:
    LLHintHandler();
    virtual ~LLHintHandler() {}

    virtual void onAdd(LLNotificationPtr p);
    virtual void onLoad(LLNotificationPtr p);
    virtual void onDelete(LLNotificationPtr p);
    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel() {};
};

/**
 * Handler for browser notifications
 */
class LLBrowserNotification : public LLSystemNotificationHandler
{
public:
    LLBrowserNotification();
    virtual ~LLBrowserNotification() {}

    virtual bool processNotification(const LLNotificationPtr& p, bool should_log = true);

protected:
    virtual void initChannel() {};
};

class LLHandlerUtil
{
public:
    /**
     * Determines whether IM floater is opened.
     */
    static bool isIMFloaterOpened(const LLNotificationPtr& notification);

    /**
     * Writes notification message to IM session.
     */
    static void logToIM(const EInstantMessage& session_type,
            const std::string& session_name, const std::string& from_name,
            const std::string& message, const LLUUID& session_owner_id,
            const LLUUID& from_id);

    /**
     * Writes notification message to IM  p2p session.
     */
    static void logToIMP2P(const LLNotificationPtr& notification, bool to_file_only = false);
    static void logToIMP2P(const LLUUID& from_id, const std::string& message, bool to_file_only = false);

    /**
     * Writes group notice notification message to IM  group session.
     */
    static void logGroupNoticeToIMGroup(const LLNotificationPtr& notification);

    /**
     * Writes notification message to nearby chat.
     */
    static void logToNearbyChat(const LLNotificationPtr& notification, EChatSourceType type);

    /**
     * Spawns IM session.
     */
    static LLUUID spawnIMSession(const std::string& name, const LLUUID& from_id);

    /**
     * Returns name from the notification's substitution.
     *
     * Methods gets "NAME" or "[NAME]" from the substitution map.
     *
     * @param notification - Notification which substitution's name will be returned.
     */
    static std::string getSubstitutionName(const LLNotificationPtr& notification);

    static std::string getSubstitutionOriginalName(const LLNotificationPtr& notification);

    /**
     * Adds notification panel to the IM floater.
     */
    static void addNotifPanelToIM(const LLNotificationPtr& notification);

    /**
     * Updates messages of IM floater.
     */
    static void updateIMFLoaterMesages(const LLUUID& session_id);

    /**
     * Updates messages of visible IM floater.
     */
    static void updateVisibleIMFLoaterMesages(const LLNotificationPtr& notification);

    /**
     * Decrements counter of IM messages.
     */
    static void decIMMesageCounter(const LLNotificationPtr& notification);

};

}
#endif