headers/os/app/Handler.h

   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
  15 class BLooper;
  16 class BMessageFilter;
  17 class BMessage;
  18 class BMessenger;
  19 class BList;
  20
  21 #define B_OBSERVE_WHAT_CHANGE "be:observe_change_what"
  22 #define B_OBSERVE_ORIGINAL_WHAT "be:observe_orig_what"
  23 const uint32 B_OBSERVER_OBSERVE_ALL = 0xffffffff;
  24
  25 namespace BPrivate {
  26         class ObserverList;
  27 }
  28
  29 class BHandler : public BArchivable {
  30 public:
  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
  84 private:
  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