1/*
2 * Copyright 2001-2014 Haiku, Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 *		Erik Jaesler, erik@cgsoftware.com
7 */
8#ifndef _HANDLER_H
9#define _HANDLER_H
10
11
12#include <Archivable.h>
13
14
15class BLooper;
16class BMessageFilter;
17class BMessage;
18class BMessenger;
19class BList;
20
21#define B_OBSERVE_WHAT_CHANGE "be:observe_change_what"
22#define B_OBSERVE_ORIGINAL_WHAT "be:observe_orig_what"
23const uint32 B_OBSERVER_OBSERVE_ALL = 0xffffffff;
24
25namespace BPrivate {
26	class ObserverList;
27}
28
29class BHandler : public BArchivable {
30public:
31							BHandler(const char* name = NULL);
32	virtual					~BHandler();
33
34	// Archiving
35							BHandler(BMessage* data);
36	static	BArchivable*	Instantiate(BMessage* data);
37	virtual	status_t		Archive(BMessage* data, bool deep = true) const;
38
39	// BHandler guts.
40	virtual	void			MessageReceived(BMessage* message);
41			BLooper*		Looper() const;
42			void			SetName(const char* name);
43			const char*		Name() const;
44	virtual	void			SetNextHandler(BHandler* handler);
45			BHandler*		NextHandler() const;
46
47	// Message filtering
48	virtual	void			AddFilter(BMessageFilter* filter);
49	virtual	bool			RemoveFilter(BMessageFilter* filter);
50	virtual	void			SetFilterList(BList* filters);
51			BList*			FilterList();
52
53			bool			LockLooper();
54			status_t		LockLooperWithTimeout(bigtime_t timeout);
55			void			UnlockLooper();
56
57	// Scripting
58	virtual BHandler*		ResolveSpecifier(BMessage* message, int32 index,
59								BMessage* specifier, int32 what,
60								const char* property);
61	virtual status_t		GetSupportedSuites(BMessage* data);
62
63	// Observer calls, inter-looper and inter-team
64			status_t		StartWatching(BMessenger target, uint32 what);
65			status_t		StartWatchingAll(BMessenger target);
66			status_t		StopWatching(BMessenger target, uint32 what);
67			status_t		StopWatchingAll(BMessenger target);
68
69	// Observer calls for observing targets in the local team
70			status_t		StartWatching(BHandler* observer, uint32 what);
71			status_t		StartWatchingAll(BHandler* observer);
72			status_t		StopWatching(BHandler* observer, uint32 what);
73			status_t		StopWatchingAll(BHandler* observer);
74
75
76	// Reserved
77	virtual status_t		Perform(perform_code d, void* arg);
78
79	// Notifier calls
80	virtual	void 			SendNotices(uint32 what,
81								const BMessage* notice = NULL);
82			bool			IsWatched() const;
83
84private:
85	typedef BArchivable		_inherited;
86	friend inline int32		_get_object_token_(const BHandler* );
87	friend class BLooper;
88	friend class BMessageFilter;
89
90	virtual	void			_ReservedHandler2();
91	virtual	void			_ReservedHandler3();
92	virtual	void			_ReservedHandler4();
93
94			void			_InitData(const char* name);
95			BPrivate::ObserverList* _ObserverList();
96
97							BHandler(const BHandler&);
98			BHandler&		operator=(const BHandler&);
99			void			SetLooper(BLooper* looper);
100
101			int32			fToken;
102			char*			fName;
103			BLooper*		fLooper;
104			BHandler*		fNextHandler;
105			BList*			fFilters;
106			BPrivate::ObserverList*	fObserverList;
107			uint32			_reserved[3];
108};
109
110#endif	// _HANDLER_H
111