llevent.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:6k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llevent.h
  3.  * @author Tom Yedwab
  4.  * @brief LLEvent and LLEventListener base classes.
  5.  *
  6.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2001-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. #ifndef LL_EVENT_H
  34. #define LL_EVENT_H
  35. #include "llsd.h"
  36. #include "llpointer.h"
  37. #include "llthread.h"
  38. namespace LLOldEvents
  39. {
  40. class LLEventListener;
  41. class LLEvent;
  42. class LLEventDispatcher;
  43. class LLObservable;
  44. // Abstract event. All events derive from LLEvent
  45. class LL_COMMON_API LLEvent : public LLThreadSafeRefCount
  46. {
  47. protected:
  48. virtual ~LLEvent();
  49. public:
  50. LLEvent(LLObservable* source, const std::string& desc = "") : mSource(source), mDesc(desc) { }
  51. LLObservable* getSource() { return mSource; }
  52. virtual LLSD getValue() { return LLSD(); }
  53. // Determines whether this particular listener
  54. //   should be notified of this event.
  55. // If this function returns true, handleEvent is
  56. //   called on the listener with this event as the
  57. //   argument.
  58. // Defaults to handling all events. Override this
  59. //   if associated with an Observable with many different listeners
  60. virtual bool accept(LLEventListener* listener);
  61. // return a string describing the event
  62. virtual const std::string& desc();
  63. private:
  64. LLObservable* mSource;
  65. std::string mDesc;
  66. };
  67. // Abstract listener. All listeners derive from LLEventListener
  68. class LL_COMMON_API LLEventListener : public LLThreadSafeRefCount
  69. {
  70. protected:
  71. virtual ~LLEventListener();
  72. public:
  73. // Processes the event.
  74. // TODO: Make the return value less ambiguous?
  75. virtual bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata) = 0;
  76. // Called when an dispatcher starts/stops listening
  77. virtual bool handleAttach(LLEventDispatcher *dispatcher) = 0;
  78. virtual bool handleDetach(LLEventDispatcher *dispatcher) = 0;
  79. };
  80. // A listener which tracks references to it and cleans up when it's deallocated
  81. class LL_COMMON_API LLSimpleListener : public LLEventListener
  82. {
  83. public:
  84. void clearDispatchers();
  85. virtual bool handleAttach(LLEventDispatcher *dispatcher);
  86. virtual bool handleDetach(LLEventDispatcher *dispatcher);
  87. protected:
  88. ~LLSimpleListener();
  89. std::vector<LLEventDispatcher *> mDispatchers;
  90. };
  91. class LLObservable; // defined below
  92. // A structure which stores a Listener and its metadata
  93. struct LLListenerEntry
  94. {
  95. LLEventListener* listener;
  96. LLSD filter;
  97. LLSD userdata;
  98. };
  99. // Base class for a dispatcher - an object which listens
  100. // to events being fired and relays them to their
  101. // appropriate destinations.
  102. class LL_COMMON_API LLEventDispatcher : public LLThreadSafeRefCount
  103. {
  104. protected:
  105. virtual ~LLEventDispatcher();
  106. public:
  107. // The default constructor creates a default simple dispatcher implementation.
  108. // The simple implementation has an array of listeners and fires every event to
  109. // all of them.
  110. LLEventDispatcher();
  111. // This dispatcher is being attached to an observable object.
  112. // If we return false, the attach fails.
  113. bool engage(LLObservable* observable);
  114. // This dispatcher is being detached from an observable object.
  115. void disengage(LLObservable* observable);
  116. // Adds a listener to this dispatcher, with a given user data
  117. // that will be passed to the listener when an event is fired.
  118. // Duplicate pointers are removed on addtion.
  119. void addListener(LLEventListener *listener, LLSD filter, const LLSD& userdata);
  120. // Removes a listener from this dispatcher
  121. void removeListener(LLEventListener *listener);
  122. // Gets a list of interested listeners
  123. std::vector<LLListenerEntry> getListeners() const;
  124. // Handle an event that has just been fired by communicating it
  125. // to listeners, passing it across a network, etc.
  126. bool fireEvent(LLPointer<LLEvent> event, LLSD filter);
  127. public:
  128. class Impl;
  129. private:
  130. Impl* impl;
  131. };
  132. // Interface for observable data (data that fires events)
  133. // In order for this class to work properly, it needs
  134. // an instance of an LLEventDispatcher to route events to their
  135. // listeners.
  136. class LL_COMMON_API LLObservable
  137. {
  138. public:
  139. // Initialize with the default Dispatcher
  140. LLObservable();
  141. virtual ~LLObservable();
  142. // Replaces the existing dispatcher pointer to the new one,
  143. // informing the dispatcher of the change.
  144. virtual bool setDispatcher(LLPointer<LLEventDispatcher> dispatcher);
  145. // Returns the current dispatcher pointer.
  146. virtual LLEventDispatcher* getDispatcher();
  147. void addListener(LLEventListener *listener, LLSD filter = "", const LLSD& userdata = "")
  148. {
  149. if (mDispatcher.notNull()) mDispatcher->addListener(listener, filter, userdata);
  150. }
  151. void removeListener(LLEventListener *listener)
  152. {
  153. if (mDispatcher.notNull()) mDispatcher->removeListener(listener);
  154. }
  155. // Notifies the dispatcher of an event being fired.
  156. void fireEvent(LLPointer<LLEvent> event, LLSD filter = LLSD());
  157. protected:
  158. LLPointer<LLEventDispatcher> mDispatcher;
  159. };
  160. class LLValueChangedEvent : public LLEvent
  161. {
  162. public:
  163. LLValueChangedEvent(LLObservable* source, LLSD value) : LLEvent(source, "value_changed"), mValue(value) { }
  164. LLSD getValue() { return mValue; }
  165. LLSD mValue;
  166. };
  167. } // LLOldEvents
  168. #endif // LL_EVENT_H