EVENT -> URHO3D_EVENT

Source/Urho3D/Core/CoreEvents.h

@@ -28,38 +28,38 @@ namespace Urho3D
 {
 
 /// Frame begin event.
-EVENT(E_BEGINFRAME, BeginFrame)
+URHO3D_EVENT(E_BEGINFRAME, BeginFrame)
 {
     PARAM(P_FRAMENUMBER, FrameNumber);      // unsigned
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Application-wide logic update event.
-EVENT(E_UPDATE, Update)
+URHO3D_EVENT(E_UPDATE, Update)
 {
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Application-wide logic post-update event.
-EVENT(E_POSTUPDATE, PostUpdate)
+URHO3D_EVENT(E_POSTUPDATE, PostUpdate)
 {
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Render update event.
-EVENT(E_RENDERUPDATE, RenderUpdate)
+URHO3D_EVENT(E_RENDERUPDATE, RenderUpdate)
 {
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Post-render update event.
-EVENT(E_POSTRENDERUPDATE, PostRenderUpdate)
+URHO3D_EVENT(E_POSTRENDERUPDATE, PostRenderUpdate)
 {
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Frame end event.
-EVENT(E_ENDFRAME, EndFrame)
+URHO3D_EVENT(E_ENDFRAME, EndFrame)
 {
 }
 

Source/Urho3D/Core/Object.h

@@ -321,7 +321,7 @@ private:
 };
 
 /// Describe an event's hash ID and begin a namespace in which to define its parameters.
-#define EVENT(eventID, eventName) static const Urho3D::StringHash eventID(#eventName); namespace eventName
+#define URHO3D_EVENT(eventID, eventName) static const Urho3D::StringHash eventID(#eventName); namespace eventName
 /// Describe an event's parameter hash ID. Should be used inside an event namespace.
 #define PARAM(paramID, paramName) static const Urho3D::StringHash paramID(#paramName)
 /// Convenience macro to construct an EventHandler that points to a receiver object and its member function.

Source/Urho3D/Core/WorkQueue.h

@@ -30,7 +30,7 @@ namespace Urho3D
 {
 
 /// Work item completed event.
-EVENT(E_WORKITEMCOMPLETED, WorkItemCompleted)
+URHO3D_EVENT(E_WORKITEMCOMPLETED, WorkItemCompleted)
 {
     PARAM(P_ITEM, Item);                        // WorkItem ptr
 }

Source/Urho3D/Database/DatabaseEvents.h

@@ -29,7 +29,7 @@ namespace Urho3D
 {
 
 /// %Database cursor. Event handler could set P_FILTER to true to filter out a row from resultset and P_ABORT to true to stop further cursor events.
-EVENT(E_DBCURSOR, DbCursor)
+URHO3D_EVENT(E_DBCURSOR, DbCursor)
 {
     PARAM(P_DBCONNECTION, DbConnection);    // DbConnection pointer
     PARAM(P_RESULTIMPL, ResultImpl);        // Underlying result object pointer (cannot be used in scripting)

Source/Urho3D/Engine/EngineEvents.h

@@ -28,7 +28,7 @@ namespace Urho3D
 {
 
 /// A command has been entered on the console.
-EVENT(E_CONSOLECOMMAND, ConsoleCommand)
+URHO3D_EVENT(E_CONSOLECOMMAND, ConsoleCommand)
 {
     PARAM(P_COMMAND, Command);              // String
     PARAM(P_ID, Id);                        // String

Source/Urho3D/Graphics/DrawableEvents.h

@@ -28,13 +28,13 @@ namespace Urho3D
 {
 
 /// AnimatedModel bone hierarchy created.
-EVENT(E_BONEHIERARCHYCREATED, BoneHierarchyCreated)
+URHO3D_EVENT(E_BONEHIERARCHYCREATED, BoneHierarchyCreated)
 {
     PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// AnimatedModel animation trigger.
-EVENT(E_ANIMATIONTRIGGER, AnimationTrigger)
+URHO3D_EVENT(E_ANIMATIONTRIGGER, AnimationTrigger)
 {
     PARAM(P_NODE, Node);                    // Node pointer
     PARAM(P_NAME, Name);                    // String
@@ -42,7 +42,7 @@ EVENT(E_ANIMATIONTRIGGER, AnimationTrigger)
     PARAM(P_DATA, Data);                    // User-defined data type
 }
 /// Terrain geometry created.
-EVENT(E_TERRAINCREATED, TerrainCreated)
+URHO3D_EVENT(E_TERRAINCREATED, TerrainCreated)
 {
     PARAM(P_NODE, Node);                    // Node pointer
 }

Source/Urho3D/Graphics/GraphicsEvents.h

@@ -28,7 +28,7 @@ namespace Urho3D
 {
 
 /// New screen mode set.
-EVENT(E_SCREENMODE, ScreenMode)
+URHO3D_EVENT(E_SCREENMODE, ScreenMode)
 {
     PARAM(P_WIDTH, Width);                  // int
     PARAM(P_HEIGHT, Height);                // int
@@ -38,29 +38,29 @@ EVENT(E_SCREENMODE, ScreenMode)
 }
 
 /// Window position changed.
-EVENT(E_WINDOWPOS, WindowPos)
+URHO3D_EVENT(E_WINDOWPOS, WindowPos)
 {
     PARAM(P_X, X);                          // int
     PARAM(P_Y, Y);                          // int
 }
 
 /// Request for queuing autoupdated rendersurfaces.
-EVENT(E_RENDERSURFACEUPDATE, RenderSurfaceUpdate)
+URHO3D_EVENT(E_RENDERSURFACEUPDATE, RenderSurfaceUpdate)
 {
 }
 
 /// Frame rendering started.
-EVENT(E_BEGINRENDERING, BeginRendering)
+URHO3D_EVENT(E_BEGINRENDERING, BeginRendering)
 {
 }
 
 /// Frame rendering ended.
-EVENT(E_ENDRENDERING, EndRendering)
+URHO3D_EVENT(E_ENDRENDERING, EndRendering)
 {
 }
 
 /// Update of a view started.
-EVENT(E_BEGINVIEWUPDATE, BeginViewUpdate)
+URHO3D_EVENT(E_BEGINVIEWUPDATE, BeginViewUpdate)
 {
     PARAM(P_VIEW, View);                    // View pointer
     PARAM(P_TEXTURE, Texture);              // Texture pointer
@@ -70,7 +70,7 @@ EVENT(E_BEGINVIEWUPDATE, BeginViewUpdate)
 }
 
 /// Update of a view ended.
-EVENT(E_ENDVIEWUPDATE, EndViewUpdate)
+URHO3D_EVENT(E_ENDVIEWUPDATE, EndViewUpdate)
 {
     PARAM(P_VIEW, View);                    // View pointer
     PARAM(P_TEXTURE, Texture);              // Texture pointer
@@ -80,7 +80,7 @@ EVENT(E_ENDVIEWUPDATE, EndViewUpdate)
 }
 
 /// Render of a view started.
-EVENT(E_BEGINVIEWRENDER, BeginViewRender)
+URHO3D_EVENT(E_BEGINVIEWRENDER, BeginViewRender)
 {
     PARAM(P_VIEW, View);                    // View pointer
     PARAM(P_TEXTURE, Texture);              // Texture pointer
@@ -90,7 +90,7 @@ EVENT(E_BEGINVIEWRENDER, BeginViewRender)
 }
 
 /// Render of a view ended.
-EVENT(E_ENDVIEWRENDER, EndViewRender)
+URHO3D_EVENT(E_ENDVIEWRENDER, EndViewRender)
 {
     PARAM(P_VIEW, View);                    // View pointer
     PARAM(P_TEXTURE, Texture);              // Texture pointer
@@ -100,12 +100,12 @@ EVENT(E_ENDVIEWRENDER, EndViewRender)
 }
 
 /// Graphics context has been lost. Some or all (depending on the API) GPU objects have lost their contents.
-EVENT(E_DEVICELOST, DeviceLost)
+URHO3D_EVENT(E_DEVICELOST, DeviceLost)
 {
 }
 
 /// Graphics context has been recreated after being lost. GPU objects in the "data lost" state can be restored now.
-EVENT(E_DEVICERESET, DeviceReset)
+URHO3D_EVENT(E_DEVICERESET, DeviceReset)
 {
 }
 

Source/Urho3D/IO/IOEvents.h

@@ -28,14 +28,14 @@ namespace Urho3D
 {
 
 /// Log message event.
-EVENT(E_LOGMESSAGE, LogMessage)
+URHO3D_EVENT(E_LOGMESSAGE, LogMessage)
 {
     PARAM(P_MESSAGE, Message);              // String
     PARAM(P_LEVEL, Level);                  // int
 }
 
 /// Async system command execution finished.
-EVENT(E_ASYNCEXECFINISHED, AsyncExecFinished)
+URHO3D_EVENT(E_ASYNCEXECFINISHED, AsyncExecFinished)
 {
     PARAM(P_REQUESTID, RequestID);          // unsigned
     PARAM(P_EXITCODE, ExitCode);            // int

Source/Urho3D/Input/InputEvents.h

@@ -33,7 +33,7 @@ namespace Urho3D
 {
 
 /// Mouse button pressed.
-EVENT(E_MOUSEBUTTONDOWN, MouseButtonDown)
+URHO3D_EVENT(E_MOUSEBUTTONDOWN, MouseButtonDown)
 {
     PARAM(P_BUTTON, Button);                // int
     PARAM(P_BUTTONS, Buttons);              // int
@@ -41,7 +41,7 @@ EVENT(E_MOUSEBUTTONDOWN, MouseButtonDown)
 }
 
 /// Mouse button released.
-EVENT(E_MOUSEBUTTONUP, MouseButtonUp)
+URHO3D_EVENT(E_MOUSEBUTTONUP, MouseButtonUp)
 {
     PARAM(P_BUTTON, Button);                // int
     PARAM(P_BUTTONS, Buttons);              // int
@@ -49,7 +49,7 @@ EVENT(E_MOUSEBUTTONUP, MouseButtonUp)
 }
 
 /// Mouse moved.
-EVENT(E_MOUSEMOVE, MouseMove)
+URHO3D_EVENT(E_MOUSEMOVE, MouseMove)
 {
     PARAM(P_X, X);                          // int (only when mouse visible)
     PARAM(P_Y, Y);                          // int (only when mouse visible)
@@ -60,7 +60,7 @@ EVENT(E_MOUSEMOVE, MouseMove)
 }
 
 /// Mouse wheel moved.
-EVENT(E_MOUSEWHEEL, MouseWheel)
+URHO3D_EVENT(E_MOUSEWHEEL, MouseWheel)
 {
     PARAM(P_WHEEL, Wheel);                  // int
     PARAM(P_BUTTONS, Buttons);              // int
@@ -68,7 +68,7 @@ EVENT(E_MOUSEWHEEL, MouseWheel)
 }
 
 /// Key pressed.
-EVENT(E_KEYDOWN, KeyDown)
+URHO3D_EVENT(E_KEYDOWN, KeyDown)
 {
     PARAM(P_KEY, Key);                      // int
     PARAM(P_SCANCODE, Scancode);            // int
@@ -79,7 +79,7 @@ EVENT(E_KEYDOWN, KeyDown)
 }
 
 /// Key released.
-EVENT(E_KEYUP, KeyUp)
+URHO3D_EVENT(E_KEYUP, KeyUp)
 {
     PARAM(P_KEY, Key);                      // int
     PARAM(P_SCANCODE, Scancode);            // int
@@ -89,7 +89,7 @@ EVENT(E_KEYUP, KeyUp)
 }
 
 /// Text input event.
-EVENT(E_TEXTINPUT, TextInput)
+URHO3D_EVENT(E_TEXTINPUT, TextInput)
 {
     PARAM(P_TEXT, Text);                    // String
     PARAM(P_BUTTONS, Buttons);              // int
@@ -97,33 +97,33 @@ EVENT(E_TEXTINPUT, TextInput)
 }
 
 /// Joystick connected.
-EVENT(E_JOYSTICKCONNECTED, JoystickConnected)
+URHO3D_EVENT(E_JOYSTICKCONNECTED, JoystickConnected)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
 }
 
 /// Joystick disconnected.
-EVENT(E_JOYSTICKDISCONNECTED, JoystickDisconnected)
+URHO3D_EVENT(E_JOYSTICKDISCONNECTED, JoystickDisconnected)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
 }
 
 /// Joystick button pressed.
-EVENT(E_JOYSTICKBUTTONDOWN, JoystickButtonDown)
+URHO3D_EVENT(E_JOYSTICKBUTTONDOWN, JoystickButtonDown)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
     PARAM(P_BUTTON, Button);                // int
 }
 
 /// Joystick button released.
-EVENT(E_JOYSTICKBUTTONUP, JoystickButtonUp)
+URHO3D_EVENT(E_JOYSTICKBUTTONUP, JoystickButtonUp)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
     PARAM(P_BUTTON, Button);                // int
 }
 
 /// Joystick axis moved.
-EVENT(E_JOYSTICKAXISMOVE, JoystickAxisMove)
+URHO3D_EVENT(E_JOYSTICKAXISMOVE, JoystickAxisMove)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
     PARAM(P_AXIS, Button);                  // int
@@ -131,7 +131,7 @@ EVENT(E_JOYSTICKAXISMOVE, JoystickAxisMove)
 }
 
 /// Joystick POV hat moved.
-EVENT(E_JOYSTICKHATMOVE, JoystickHatMove)
+URHO3D_EVENT(E_JOYSTICKHATMOVE, JoystickHatMove)
 {
     PARAM(P_JOYSTICKID, JoystickID);        // int
     PARAM(P_HAT, Button);                   // int
@@ -139,7 +139,7 @@ EVENT(E_JOYSTICKHATMOVE, JoystickHatMove)
 }
 
 /// Finger pressed on the screen.
-EVENT(E_TOUCHBEGIN, TouchBegin)
+URHO3D_EVENT(E_TOUCHBEGIN, TouchBegin)
 {
     PARAM(P_TOUCHID, TouchID);              // int
     PARAM(P_X, X);                          // int
@@ -148,7 +148,7 @@ EVENT(E_TOUCHBEGIN, TouchBegin)
 }
 
 /// Finger released from the screen.
-EVENT(E_TOUCHEND, TouchEnd)
+URHO3D_EVENT(E_TOUCHEND, TouchEnd)
 {
     PARAM(P_TOUCHID, TouchID);              // int
     PARAM(P_X, X);                          // int
@@ -156,7 +156,7 @@ EVENT(E_TOUCHEND, TouchEnd)
 }
 
 /// Finger moved on the screen.
-EVENT(E_TOUCHMOVE, TouchMove)
+URHO3D_EVENT(E_TOUCHMOVE, TouchMove)
 {
     PARAM(P_TOUCHID, TouchID);              // int
     PARAM(P_X, X);                          // int
@@ -167,13 +167,13 @@ EVENT(E_TOUCHMOVE, TouchMove)
 }
 
 /// A touch gesture finished recording.
-EVENT(E_GESTURERECORDED, GestureRecorded)
+URHO3D_EVENT(E_GESTURERECORDED, GestureRecorded)
 {
     PARAM(P_GESTUREID, GestureID);          // unsigned
 }
 
 /// A recognized touch gesture was input by the user.
-EVENT(E_GESTUREINPUT, GestureInput)
+URHO3D_EVENT(E_GESTUREINPUT, GestureInput)
 {
     PARAM(P_GESTUREID, GestureID);          // unsigned
     PARAM(P_CENTERX, CenterX);              // int
@@ -183,7 +183,7 @@ EVENT(E_GESTUREINPUT, GestureInput)
 }
 
 /// Pinch/rotate multi-finger touch gesture motion update.
-EVENT(E_MULTIGESTURE, MultiGesture)
+URHO3D_EVENT(E_MULTIGESTURE, MultiGesture)
 {
     PARAM(P_CENTERX, CenterX);              // int
     PARAM(P_CENTERY, CenterY);              // int
@@ -193,32 +193,32 @@ EVENT(E_MULTIGESTURE, MultiGesture)
 }
 
 /// A file was drag-dropped into the application window.
-EVENT(E_DROPFILE, DropFile)
+URHO3D_EVENT(E_DROPFILE, DropFile)
 {
     PARAM(P_FILENAME, FileName);            // String
 }
 
 /// Application input focus or minimization changed.
-EVENT(E_INPUTFOCUS, InputFocus)
+URHO3D_EVENT(E_INPUTFOCUS, InputFocus)
 {
     PARAM(P_FOCUS, Focus);                  // bool
     PARAM(P_MINIMIZED, Minimized);          // bool
 }
 
 /// OS mouse cursor visibility changed.
-EVENT(E_MOUSEVISIBLECHANGED, MouseVisibleChanged)
+URHO3D_EVENT(E_MOUSEVISIBLECHANGED, MouseVisibleChanged)
 {
     PARAM(P_VISIBLE, Visible);              // bool
 }
 
 /// Mouse mode changed.
-EVENT(E_MOUSEMODECHANGED, MouseModeChanged)
+URHO3D_EVENT(E_MOUSEMODECHANGED, MouseModeChanged)
 {
     PARAM(P_MODE, Mode);                    // MouseMode
 }
 
 /// Application exit requested.
-EVENT(E_EXITREQUESTED, ExitRequested)
+URHO3D_EVENT(E_EXITREQUESTED, ExitRequested)
 {
 }
 

Source/Urho3D/Navigation/NavigationEvents.h

@@ -28,14 +28,14 @@ namespace Urho3D
 {
 
 /// Complete rebuild of navigation mesh.
-EVENT(E_NAVIGATION_MESH_REBUILT, NavigationMeshRebuilt)
+URHO3D_EVENT(E_NAVIGATION_MESH_REBUILT, NavigationMeshRebuilt)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_MESH, Mesh); // NavigationMesh pointer
 }
 
 /// Partial bounding box rebuild of navigation mesh.
-EVENT(E_NAVIGATION_AREA_REBUILT, NavigationAreaRebuilt)
+URHO3D_EVENT(E_NAVIGATION_AREA_REBUILT, NavigationAreaRebuilt)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_MESH, Mesh); // NavigationMesh pointer
@@ -44,7 +44,7 @@ EVENT(E_NAVIGATION_AREA_REBUILT, NavigationAreaRebuilt)
 }
 
 /// Crowd agent formation.
-EVENT(E_CROWD_AGENT_FORMATION, CrowdAgentFormation)
+URHO3D_EVENT(E_CROWD_AGENT_FORMATION, CrowdAgentFormation)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
@@ -54,7 +54,7 @@ EVENT(E_CROWD_AGENT_FORMATION, CrowdAgentFormation)
 }
 
 /// Crowd agent has been repositioned.
-EVENT(E_CROWD_AGENT_REPOSITION, CrowdAgentReposition)
+URHO3D_EVENT(E_CROWD_AGENT_REPOSITION, CrowdAgentReposition)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
@@ -65,7 +65,7 @@ EVENT(E_CROWD_AGENT_REPOSITION, CrowdAgentReposition)
 }
 
 /// Crowd agent's internal state has become invalidated. This is a special case of CrowdAgentStateChanged event.
-EVENT(E_CROWD_AGENT_FAILURE, CrowdAgentFailure)
+URHO3D_EVENT(E_CROWD_AGENT_FAILURE, CrowdAgentFailure)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
@@ -76,7 +76,7 @@ EVENT(E_CROWD_AGENT_FAILURE, CrowdAgentFailure)
 }
 
 /// Crowd agent's state has been changed.
-EVENT(E_CROWD_AGENT_STATE_CHANGED, CrowdAgentStateChanged)
+URHO3D_EVENT(E_CROWD_AGENT_STATE_CHANGED, CrowdAgentStateChanged)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
@@ -87,7 +87,7 @@ EVENT(E_CROWD_AGENT_STATE_CHANGED, CrowdAgentStateChanged)
 }
 
 /// Addition of obstacle to dynamic navigation mesh.
-EVENT(E_NAVIGATION_OBSTACLE_ADDED, NavigationObstacleAdded)
+URHO3D_EVENT(E_NAVIGATION_OBSTACLE_ADDED, NavigationObstacleAdded)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer
@@ -97,7 +97,7 @@ EVENT(E_NAVIGATION_OBSTACLE_ADDED, NavigationObstacleAdded)
 }
 
 /// Removal of obstacle from dynamic navigation mesh.
-EVENT(E_NAVIGATION_OBSTACLE_REMOVED, NavigationObstacleRemoved)
+URHO3D_EVENT(E_NAVIGATION_OBSTACLE_REMOVED, NavigationObstacleRemoved)
 {
     PARAM(P_NODE, Node); // Node pointer
     PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer

Source/Urho3D/Network/NetworkEvents.h

@@ -28,47 +28,47 @@ namespace Urho3D
 {
 
 /// Server connection established.
-EVENT(E_SERVERCONNECTED, ServerConnected)
+URHO3D_EVENT(E_SERVERCONNECTED, ServerConnected)
 {
 }
 
 /// Server connection disconnected.
-EVENT(E_SERVERDISCONNECTED, ServerDisconnected)
+URHO3D_EVENT(E_SERVERDISCONNECTED, ServerDisconnected)
 {
 }
 
 /// Server connection failed.
-EVENT(E_CONNECTFAILED, ConnectFailed)
+URHO3D_EVENT(E_CONNECTFAILED, ConnectFailed)
 {
 }
 
 /// New client connection established.
-EVENT(E_CLIENTCONNECTED, ClientConnected)
+URHO3D_EVENT(E_CLIENTCONNECTED, ClientConnected)
 {
     PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Client connection disconnected.
-EVENT(E_CLIENTDISCONNECTED, ClientDisconnected)
+URHO3D_EVENT(E_CLIENTDISCONNECTED, ClientDisconnected)
 {
     PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Client has sent identity: identity map is in the event data.
-EVENT(E_CLIENTIDENTITY, ClientIdentity)
+URHO3D_EVENT(E_CLIENTIDENTITY, ClientIdentity)
 {
     PARAM(P_CONNECTION, Connection);        // Connection pointer
     PARAM(P_ALLOW, Allow);                  // bool
 }
 
 /// Client has informed to have loaded the scene.
-EVENT(E_CLIENTSCENELOADED, ClientSceneLoaded)
+URHO3D_EVENT(E_CLIENTSCENELOADED, ClientSceneLoaded)
 {
     PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Unhandled network message received.
-EVENT(E_NETWORKMESSAGE, NetworkMessage)
+URHO3D_EVENT(E_NETWORKMESSAGE, NetworkMessage)
 {
     PARAM(P_CONNECTION, Connection);        // Connection pointer
     PARAM(P_MESSAGEID, MessageID);          // int
@@ -76,23 +76,23 @@ EVENT(E_NETWORKMESSAGE, NetworkMessage)
 }
 
 /// About to send network update on the client or server.
-EVENT(E_NETWORKUPDATE, NetworkUpdate)
+URHO3D_EVENT(E_NETWORKUPDATE, NetworkUpdate)
 {
 }
 
 /// Network update has been sent on the client or server.
-EVENT(E_NETWORKUPDATESENT, NetworkUpdateSent)
+URHO3D_EVENT(E_NETWORKUPDATESENT, NetworkUpdateSent)
 {
 }
 
 /// Scene load failed, either due to file not found or checksum error.
-EVENT(E_NETWORKSCENELOADFAILED, NetworkSceneLoadFailed)
+URHO3D_EVENT(E_NETWORKSCENELOADFAILED, NetworkSceneLoadFailed)
 {
     PARAM(P_CONNECTION, Connection);      // Connection pointer
 }
 
 /// Remote event: adds Connection parameter to the event data
-EVENT(E_REMOTEEVENTDATA, RemoteEventData)
+URHO3D_EVENT(E_REMOTEEVENTDATA, RemoteEventData)
 {
     PARAM(P_CONNECTION, Connection);      // Connection pointer
 }

Source/Urho3D/Physics/PhysicsEvents.h

@@ -28,21 +28,21 @@ namespace Urho3D
 {
 
 /// Physics world is about to be stepped.
-EVENT(E_PHYSICSPRESTEP, PhysicsPreStep)
+URHO3D_EVENT(E_PHYSICSPRESTEP, PhysicsPreStep)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics world has been stepped.
-EVENT(E_PHYSICSPOSTSTEP, PhysicsPostStep)
+URHO3D_EVENT(E_PHYSICSPOSTSTEP, PhysicsPostStep)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics collision started.
-EVENT(E_PHYSICSCOLLISIONSTART, PhysicsCollisionStart)
+URHO3D_EVENT(E_PHYSICSCOLLISIONSTART, PhysicsCollisionStart)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld pointer
     PARAM(P_NODEA, NodeA);                  // Node pointer
@@ -54,7 +54,7 @@ EVENT(E_PHYSICSCOLLISIONSTART, PhysicsCollisionStart)
 }
 
 /// Physics collision ongoing.
-EVENT(E_PHYSICSCOLLISION, PhysicsCollision)
+URHO3D_EVENT(E_PHYSICSCOLLISION, PhysicsCollision)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld pointer
     PARAM(P_NODEA, NodeA);                  // Node pointer
@@ -66,7 +66,7 @@ EVENT(E_PHYSICSCOLLISION, PhysicsCollision)
 }
 
 /// Physics collision ended.
-EVENT(E_PHYSICSCOLLISIONEND, PhysicsCollisionEnd)
+URHO3D_EVENT(E_PHYSICSCOLLISIONEND, PhysicsCollisionEnd)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld pointer
     PARAM(P_NODEA, NodeA);                  // Node pointer
@@ -77,7 +77,7 @@ EVENT(E_PHYSICSCOLLISIONEND, PhysicsCollisionEnd)
 }
 
 /// Physics collision started (sent to the participating scene nodes.)
-EVENT(E_NODECOLLISIONSTART, NodeCollisionStart)
+URHO3D_EVENT(E_NODECOLLISIONSTART, NodeCollisionStart)
 {
     PARAM(P_BODY, Body);                    // RigidBody pointer
     PARAM(P_OTHERNODE, OtherNode);          // Node pointer
@@ -87,7 +87,7 @@ EVENT(E_NODECOLLISIONSTART, NodeCollisionStart)
 }
 
 /// Physics collision ongoing (sent to the participating scene nodes.)
-EVENT(E_NODECOLLISION, NodeCollision)
+URHO3D_EVENT(E_NODECOLLISION, NodeCollision)
 {
     PARAM(P_BODY, Body);                    // RigidBody pointer
     PARAM(P_OTHERNODE, OtherNode);          // Node pointer
@@ -97,7 +97,7 @@ EVENT(E_NODECOLLISION, NodeCollision)
 }
 
 /// Physics collision ended (sent to the participating scene nodes.)
-EVENT(E_NODECOLLISIONEND, NodeCollisionEnd)
+URHO3D_EVENT(E_NODECOLLISIONEND, NodeCollisionEnd)
 {
     PARAM(P_BODY, Body);                    // RigidBody pointer
     PARAM(P_OTHERNODE, OtherNode);          // Node pointer

Source/Urho3D/Resource/ResourceEvents.h

@@ -28,47 +28,47 @@ namespace Urho3D
 {
 
 /// Resource reloading started.
-EVENT(E_RELOADSTARTED, ReloadStarted)
+URHO3D_EVENT(E_RELOADSTARTED, ReloadStarted)
 {
 }
 
 /// Resource reloading finished successfully.
-EVENT(E_RELOADFINISHED, ReloadFinished)
+URHO3D_EVENT(E_RELOADFINISHED, ReloadFinished)
 {
 }
 
 /// Resource reloading failed.
-EVENT(E_RELOADFAILED, ReloadFailed)
+URHO3D_EVENT(E_RELOADFAILED, ReloadFailed)
 {
 }
 
 /// Tracked file changed in the resource directories.
-EVENT(E_FILECHANGED, FileChanged)
+URHO3D_EVENT(E_FILECHANGED, FileChanged)
 {
     PARAM(P_FILENAME, FileName);                    // String
     PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Resource loading failed.
-EVENT(E_LOADFAILED, LoadFailed)
+URHO3D_EVENT(E_LOADFAILED, LoadFailed)
 {
     PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Resource not found.
-EVENT(E_RESOURCENOTFOUND, ResourceNotFound)
+URHO3D_EVENT(E_RESOURCENOTFOUND, ResourceNotFound)
 {
     PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Unknown resource type.
-EVENT(E_UNKNOWNRESOURCETYPE, UnknownResourceType)
+URHO3D_EVENT(E_UNKNOWNRESOURCETYPE, UnknownResourceType)
 {
     PARAM(P_RESOURCETYPE, ResourceType);            // StringHash
 }
 
 /// Resource background loading finished.
-EVENT(E_RESOURCEBACKGROUNDLOADED, ResourceBackgroundLoaded)
+URHO3D_EVENT(E_RESOURCEBACKGROUNDLOADED, ResourceBackgroundLoaded)
 {
     PARAM(P_RESOURCENAME, ResourceName);            // String
     PARAM(P_SUCCESS, Success);                      // bool
@@ -76,7 +76,7 @@ EVENT(E_RESOURCEBACKGROUNDLOADED, ResourceBackgroundLoaded)
 }
 
 /// Language changed.
-EVENT(E_CHANGELANGUAGE, ChangeLanguage)
+URHO3D_EVENT(E_CHANGELANGUAGE, ChangeLanguage)
 {
 }
 

Source/Urho3D/Scene/SceneEvents.h

@@ -28,73 +28,73 @@ namespace Urho3D
 {
 
 /// Variable timestep scene update.
-EVENT(E_SCENEUPDATE, SceneUpdate)
+URHO3D_EVENT(E_SCENEUPDATE, SceneUpdate)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Scene subsystem update.
-EVENT(E_SCENESUBSYSTEMUPDATE, SceneSubsystemUpdate)
+URHO3D_EVENT(E_SCENESUBSYSTEMUPDATE, SceneSubsystemUpdate)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Scene transform smoothing update.
-EVENT(E_UPDATESMOOTHING, UpdateSmoothing)
+URHO3D_EVENT(E_UPDATESMOOTHING, UpdateSmoothing)
 {
     PARAM(P_CONSTANT, Constant);            // float
     PARAM(P_SQUAREDSNAPTHRESHOLD, SquaredSnapThreshold);  // float
 }
 
 /// Scene drawable update finished. Custom animation (eg. IK) can be done at this point.
-EVENT(E_SCENEDRAWABLEUPDATEFINISHED, SceneDrawableUpdateFinished)
+URHO3D_EVENT(E_SCENEDRAWABLEUPDATEFINISHED, SceneDrawableUpdateFinished)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// SmoothedTransform target position changed.
-EVENT(E_TARGETPOSITION, TargetPositionChanged)
+URHO3D_EVENT(E_TARGETPOSITION, TargetPositionChanged)
 {
 }
 
 /// SmoothedTransform target position changed.
-EVENT(E_TARGETROTATION, TargetRotationChanged)
+URHO3D_EVENT(E_TARGETROTATION, TargetRotationChanged)
 {
 }
 
 /// Scene attribute animation update.
-EVENT(E_ATTRIBUTEANIMATIONUPDATE, AttributeAnimationUpdate)
+URHO3D_EVENT(E_ATTRIBUTEANIMATIONUPDATE, AttributeAnimationUpdate)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Attribute animation added to object animation.
-EVENT(E_ATTRIBUTEANIMATIONADDED, AttributeAnimationAdded)
+URHO3D_EVENT(E_ATTRIBUTEANIMATIONADDED, AttributeAnimationAdded)
 {
     PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
     PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
 }
 
 /// Attribute animation removed from object animation.
-EVENT(E_ATTRIBUTEANIMATIONREMOVED, AttributeAnimationRemoved)
+URHO3D_EVENT(E_ATTRIBUTEANIMATIONREMOVED, AttributeAnimationRemoved)
 {
     PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
     PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
 }
 
 /// Variable timestep scene post-update.
-EVENT(E_SCENEPOSTUPDATE, ScenePostUpdate)
+URHO3D_EVENT(E_SCENEPOSTUPDATE, ScenePostUpdate)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Asynchronous scene loading progress.
-EVENT(E_ASYNCLOADPROGRESS, AsyncLoadProgress)
+URHO3D_EVENT(E_ASYNCLOADPROGRESS, AsyncLoadProgress)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_PROGRESS, Progress);            // float
@@ -105,13 +105,13 @@ EVENT(E_ASYNCLOADPROGRESS, AsyncLoadProgress)
 };
 
 /// Asynchronous scene loading finished.
-EVENT(E_ASYNCLOADFINISHED, AsyncLoadFinished)
+URHO3D_EVENT(E_ASYNCLOADFINISHED, AsyncLoadFinished)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
 };
 
 /// A child node has been added to a parent node.
-EVENT(E_NODEADDED, NodeAdded)
+URHO3D_EVENT(E_NODEADDED, NodeAdded)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_PARENT, Parent);                // Node pointer
@@ -119,7 +119,7 @@ EVENT(E_NODEADDED, NodeAdded)
 }
 
 /// A child node is about to be removed from a parent node.
-EVENT(E_NODEREMOVED, NodeRemoved)
+URHO3D_EVENT(E_NODEREMOVED, NodeRemoved)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_PARENT, Parent);                // Node pointer
@@ -127,7 +127,7 @@ EVENT(E_NODEREMOVED, NodeRemoved)
 }
 
 /// A component has been created to a node.
-EVENT(E_COMPONENTADDED, ComponentAdded)
+URHO3D_EVENT(E_COMPONENTADDED, ComponentAdded)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_NODE, Node);                    // Node pointer
@@ -135,7 +135,7 @@ EVENT(E_COMPONENTADDED, ComponentAdded)
 }
 
 /// A component is about to be removed from a node.
-EVENT(E_COMPONENTREMOVED, ComponentRemoved)
+URHO3D_EVENT(E_COMPONENTREMOVED, ComponentRemoved)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_NODE, Node);                    // Node pointer
@@ -143,21 +143,21 @@ EVENT(E_COMPONENTREMOVED, ComponentRemoved)
 }
 
 /// A node's name has changed.
-EVENT(E_NODENAMECHANGED, NodeNameChanged)
+URHO3D_EVENT(E_NODENAMECHANGED, NodeNameChanged)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A node's enabled state has changed.
-EVENT(E_NODEENABLEDCHANGED, NodeEnabledChanged)
+URHO3D_EVENT(E_NODEENABLEDCHANGED, NodeEnabledChanged)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A component's enabled state has changed.
-EVENT(E_COMPONENTENABLEDCHANGED, ComponentEnabledChanged)
+URHO3D_EVENT(E_COMPONENTENABLEDCHANGED, ComponentEnabledChanged)
 {
     PARAM(P_SCENE, Scene);                  // Scene pointer
     PARAM(P_NODE, Node);                    // Node pointer
@@ -165,13 +165,13 @@ EVENT(E_COMPONENTENABLEDCHANGED, ComponentEnabledChanged)
 }
 
 /// A serializable's temporary state has changed.
-EVENT(E_TEMPORARYCHANGED, TemporaryChanged)
+URHO3D_EVENT(E_TEMPORARYCHANGED, TemporaryChanged)
 {
     PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
 }
 
 /// A network attribute update from the server has been intercepted.
-EVENT(E_INTERCEPTNETWORKUPDATE, InterceptNetworkUpdate)
+URHO3D_EVENT(E_INTERCEPTNETWORKUPDATE, InterceptNetworkUpdate)
 {
     PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
     PARAM(P_TIMESTAMP, TimeStamp);          // unsigned (0-255)

Source/Urho3D/UI/UIEvents.h

@@ -28,7 +28,7 @@ namespace Urho3D
 {
 
 /// Mouse click in the UI.
-EVENT(E_UIMOUSECLICK, UIMouseClick)
+URHO3D_EVENT(E_UIMOUSECLICK, UIMouseClick)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -39,7 +39,7 @@ EVENT(E_UIMOUSECLICK, UIMouseClick)
 }
 
 /// Mouse click end in the UI.
-EVENT(E_UIMOUSECLICKEND, UIMouseClickEnd)
+URHO3D_EVENT(E_UIMOUSECLICKEND, UIMouseClickEnd)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_BEGINELEMENT, BeginElement);    // UIElement pointer
@@ -51,7 +51,7 @@ EVENT(E_UIMOUSECLICKEND, UIMouseClickEnd)
 }
 
 /// Mouse double click in the UI.
-EVENT(E_UIMOUSEDOUBLECLICK, UIMouseDoubleClick)
+URHO3D_EVENT(E_UIMOUSEDOUBLECLICK, UIMouseDoubleClick)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -62,7 +62,7 @@ EVENT(E_UIMOUSEDOUBLECLICK, UIMouseDoubleClick)
 }
 
 /// Drag and drop test.
-EVENT(E_DRAGDROPTEST, DragDropTest)
+URHO3D_EVENT(E_DRAGDROPTEST, DragDropTest)
 {
     PARAM(P_SOURCE, Source);                // UIElement pointer
     PARAM(P_TARGET, Target);                // UIElement pointer
@@ -70,7 +70,7 @@ EVENT(E_DRAGDROPTEST, DragDropTest)
 };
 
 /// Drag and drop finish.
-EVENT(E_DRAGDROPFINISH, DragDropFinish)
+URHO3D_EVENT(E_DRAGDROPFINISH, DragDropFinish)
 {
     PARAM(P_SOURCE, Source);                // UIElement pointer
     PARAM(P_TARGET, Target);                // UIElement pointer
@@ -78,20 +78,20 @@ EVENT(E_DRAGDROPFINISH, DragDropFinish)
 };
 
 /// Focus element changed.
-EVENT(E_FOCUSCHANGED, FocusChanged)
+URHO3D_EVENT(E_FOCUSCHANGED, FocusChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_CLICKEDELEMENT, ClickedElement); // UIElement pointer
 }
 
 /// UI element name changed.
-EVENT(E_NAMECHANGED, NameChanged)
+URHO3D_EVENT(E_NAMECHANGED, NameChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI element resized.
-EVENT(E_RESIZED, Resized)
+URHO3D_EVENT(E_RESIZED, Resized)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_WIDTH, Width);                  // int
@@ -99,7 +99,7 @@ EVENT(E_RESIZED, Resized)
 }
 
 /// UI element positioned.
-EVENT(E_POSITIONED, Positioned)
+URHO3D_EVENT(E_POSITIONED, Positioned)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -107,59 +107,59 @@ EVENT(E_POSITIONED, Positioned)
 }
 
 /// UI element visibility changed.
-EVENT(E_VISIBLECHANGED, VisibleChanged)
+URHO3D_EVENT(E_VISIBLECHANGED, VisibleChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_VISIBLE, Visible);              // bool
 }
 
 /// UI element focused.
-EVENT(E_FOCUSED, Focused)
+URHO3D_EVENT(E_FOCUSED, Focused)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_BYKEY, ByKey);                  // bool
 }
 
 /// UI element defocused.
-EVENT(E_DEFOCUSED, Defocused)
+URHO3D_EVENT(E_DEFOCUSED, Defocused)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI element layout updated.
-EVENT(E_LAYOUTUPDATED, LayoutUpdated)
+URHO3D_EVENT(E_LAYOUTUPDATED, LayoutUpdated)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI button pressed.
-EVENT(E_PRESSED, Pressed)
+URHO3D_EVENT(E_PRESSED, Pressed)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI button was pressed, then released.
-EVENT(E_RELEASED, Released)
+URHO3D_EVENT(E_RELEASED, Released)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI checkbox toggled.
-EVENT(E_TOGGLED, Toggled)
+URHO3D_EVENT(E_TOGGLED, Toggled)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_STATE, State);                  // bool
 }
 
 /// UI slider value changed
-EVENT(E_SLIDERCHANGED, SliderChanged)
+URHO3D_EVENT(E_SLIDERCHANGED, SliderChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_VALUE, Value);                  // float
 }
 
 /// UI slider being paged.
-EVENT(E_SLIDERPAGED, SliderPaged)
+URHO3D_EVENT(E_SLIDERPAGED, SliderPaged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_OFFSET, Offset);                // int
@@ -167,14 +167,14 @@ EVENT(E_SLIDERPAGED, SliderPaged)
 }
 
 /// UI scrollbar value changed.
-EVENT(E_SCROLLBARCHANGED, ScrollBarChanged)
+URHO3D_EVENT(E_SCROLLBARCHANGED, ScrollBarChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_VALUE, Value);                  // float
 }
 
 /// UI scrollview position changed.
-EVENT(E_VIEWCHANGED, ViewChanged)
+URHO3D_EVENT(E_VIEWCHANGED, ViewChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -182,14 +182,14 @@ EVENT(E_VIEWCHANGED, ViewChanged)
 }
 
 /// UI modal changed (currently only Window has modal flag).
-EVENT(E_MODALCHANGED, ModalChanged)
+URHO3D_EVENT(E_MODALCHANGED, ModalChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_MODAL, Modal);                  // bool
 }
 
 /// Text entry into a LineEdit. The char can be modified in the event data.
-EVENT(E_TEXTENTRY, CharEntry)
+URHO3D_EVENT(E_TEXTENTRY, CharEntry)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_TEXT, Text);                    // String
@@ -198,14 +198,14 @@ EVENT(E_TEXTENTRY, CharEntry)
 }
 
 /// Editable text changed
-EVENT(E_TEXTCHANGED, TextChanged)
+URHO3D_EVENT(E_TEXTCHANGED, TextChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_TEXT, Text);                    // String
 }
 
 /// Text editing finished (enter pressed on a LineEdit)
-EVENT(E_TEXTFINISHED, TextFinished)
+URHO3D_EVENT(E_TEXTFINISHED, TextFinished)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_TEXT, Text);                    // String
@@ -213,33 +213,33 @@ EVENT(E_TEXTFINISHED, TextFinished)
 }
 
 /// Menu selected.
-EVENT(E_MENUSELECTED, MenuSelected)
+URHO3D_EVENT(E_MENUSELECTED, MenuSelected)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Listview or DropDownList item selected.
-EVENT(E_ITEMSELECTED, ItemSelected)
+URHO3D_EVENT(E_ITEMSELECTED, ItemSelected)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_SELECTION, Selection);          // int
 }
 
 /// Listview item deselected.
-EVENT(E_ITEMDESELECTED, ItemDeselected)
+URHO3D_EVENT(E_ITEMDESELECTED, ItemDeselected)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_SELECTION, Selection);          // int
 }
 
 /// Listview selection change finished.
-EVENT(E_SELECTIONCHANGED, SelectionChanged)
+URHO3D_EVENT(E_SELECTIONCHANGED, SelectionChanged)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Listview item clicked. If this is a left-click, also ItemSelected event will be sent. If this is a right-click, only this event is sent.
-EVENT(E_ITEMCLICKED, ItemClicked)
+URHO3D_EVENT(E_ITEMCLICKED, ItemClicked)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_ITEM, Item);                    // UIElement pointer
@@ -250,7 +250,7 @@ EVENT(E_ITEMCLICKED, ItemClicked)
 }
 
 /// Listview item double clicked.
-EVENT(E_ITEMDOUBLECLICKED, ItemDoubleClicked)
+URHO3D_EVENT(E_ITEMDOUBLECLICKED, ItemDoubleClicked)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_ITEM, Item);                    // UIElement pointer
@@ -261,7 +261,7 @@ EVENT(E_ITEMDOUBLECLICKED, ItemDoubleClicked)
 }
 
 /// LineEdit or ListView unhandled key pressed.
-EVENT(E_UNHANDLEDKEY, UnhandledKey)
+URHO3D_EVENT(E_UNHANDLEDKEY, UnhandledKey)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_KEY, Key);                      // int
@@ -270,7 +270,7 @@ EVENT(E_UNHANDLEDKEY, UnhandledKey)
 }
 
 /// Fileselector choice.
-EVENT(E_FILESELECTED, FileSelected)
+URHO3D_EVENT(E_FILESELECTED, FileSelected)
 {
     PARAM(P_FILENAME, FileName);            // String
     PARAM(P_FILTER, Filter);                // String
@@ -278,13 +278,13 @@ EVENT(E_FILESELECTED, FileSelected)
 }
 
 /// MessageBox acknowlegement.
-EVENT(E_MESSAGEACK, MessageACK)
+URHO3D_EVENT(E_MESSAGEACK, MessageACK)
 {
     PARAM(P_OK, Ok);                        // bool
 }
 
 /// A child element has been added to an element. Sent by the UI root element, or element-event-sender if set.
-EVENT(E_ELEMENTADDED, ElementAdded)
+URHO3D_EVENT(E_ELEMENTADDED, ElementAdded)
 {
     PARAM(P_ROOT, Root);                    // UIElement pointer
     PARAM(P_PARENT, Parent);                // UIElement pointer
@@ -292,7 +292,7 @@ EVENT(E_ELEMENTADDED, ElementAdded)
 }
 
 /// A child element is about to be removed from an element. Sent by the UI root element, or element-event-sender if set.
-EVENT(E_ELEMENTREMOVED, ElementRemoved)
+URHO3D_EVENT(E_ELEMENTREMOVED, ElementRemoved)
 {
     PARAM(P_ROOT, Root);                    // UIElement pointer
     PARAM(P_PARENT, Parent);                // UIElement pointer
@@ -300,7 +300,7 @@ EVENT(E_ELEMENTREMOVED, ElementRemoved)
 }
 
 /// Hovering on an UI element has started
-EVENT(E_HOVERBEGIN, HoverBegin)
+URHO3D_EVENT(E_HOVERBEGIN, HoverBegin)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -310,13 +310,13 @@ EVENT(E_HOVERBEGIN, HoverBegin)
 }
 
 /// Hovering on an UI element has ended
-EVENT(E_HOVEREND, HoverEnd)
+URHO3D_EVENT(E_HOVEREND, HoverEnd)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Drag behavior of a UI Element has started
-EVENT(E_DRAGBEGIN, DragBegin)
+URHO3D_EVENT(E_DRAGBEGIN, DragBegin)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -328,7 +328,7 @@ EVENT(E_DRAGBEGIN, DragBegin)
 }
 
 /// Drag behavior of a UI Element when the input device has moved
-EVENT(E_DRAGMOVE, DragMove)
+URHO3D_EVENT(E_DRAGMOVE, DragMove)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -342,7 +342,7 @@ EVENT(E_DRAGMOVE, DragMove)
 }
 
 /// Drag behavior of a UI Element has finished
-EVENT(E_DRAGEND, DragEnd)
+URHO3D_EVENT(E_DRAGEND, DragEnd)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -354,7 +354,7 @@ EVENT(E_DRAGEND, DragEnd)
 }
 
 /// Drag of a UI Element was canceled by pressing ESC
-EVENT(E_DRAGCANCEL, DragCancel)
+URHO3D_EVENT(E_DRAGCANCEL, DragCancel)
 {
     PARAM(P_ELEMENT, Element);              // UIElement pointer
     PARAM(P_X, X);                          // int
@@ -366,7 +366,7 @@ EVENT(E_DRAGCANCEL, DragCancel)
 }
 
 /// A file was drag-dropped into the application window. Includes also coordinates and UI element if applicable
-EVENT(E_UIDROPFILE, UIDropFile)
+URHO3D_EVENT(E_UIDROPFILE, UIDropFile)
 {
     PARAM(P_FILENAME, FileName);            // String
     PARAM(P_ELEMENT, Element);              // UIElement pointer

Source/Urho3D/Urho2D/PhysicsEvents2D.h

@@ -28,21 +28,21 @@ namespace Urho3D
 {
 
 /// Physics world is about to be stepped.
-EVENT(E_PHYSICSPRESTEP2D, PhysicsPreStep2D)
+URHO3D_EVENT(E_PHYSICSPRESTEP2D, PhysicsPreStep2D)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics world has been stepped.
-EVENT(E_PHYSICSPOSTSTEP2D, PhysicsPostStep2D)
+URHO3D_EVENT(E_PHYSICSPOSTSTEP2D, PhysicsPostStep2D)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
     PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics begin contact.
-EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
+URHO3D_EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
     PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
@@ -52,7 +52,7 @@ EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
 }
 
 /// Physics end contact.
-EVENT(E_PHYSICSENDCONTACT2D, PhysicsEndContact2D)
+URHO3D_EVENT(E_PHYSICSENDCONTACT2D, PhysicsEndContact2D)
 {
     PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
     PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer