PARAM -> URHO3D_PARAM

Source/Urho3D/Core/CoreEvents.h

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

Source/Urho3D/Core/Object.h

@@ -323,7 +323,7 @@ private:
 /// Describe an event's hash ID and begin a namespace in which to define its parameters.
 #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)
+#define URHO3D_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.
 #define HANDLER(className, function) (new Urho3D::EventHandlerImpl<className>(this, &className::function))
 /// Convenience macro to construct an EventHandler that points to a receiver object and its member function, and also defines a userdata pointer.

Source/Urho3D/Core/WorkQueue.h

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

Source/Urho3D/Database/DatabaseEvents.h

@@ -31,14 +31,14 @@ 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.
 URHO3D_EVENT(E_DBCURSOR, DbCursor)
 {
-    PARAM(P_DBCONNECTION, DbConnection);    // DbConnection pointer
-    PARAM(P_RESULTIMPL, ResultImpl);        // Underlying result object pointer (cannot be used in scripting)
-    PARAM(P_SQL, SQL);                      // String
-    PARAM(P_NUMCOLS, NumCols);              // unsigned
-    PARAM(P_COLVALUES, ColValues);          // VariantVector
-    PARAM(P_COLHEADERS, ColHeaders);        // StringVector
-    PARAM(P_FILTER, Filter);                // bool [in]
-    PARAM(P_ABORT, Abort);                  // bool [in]
+    URHO3D_PARAM(P_DBCONNECTION, DbConnection);    // DbConnection pointer
+    URHO3D_PARAM(P_RESULTIMPL, ResultImpl);        // Underlying result object pointer (cannot be used in scripting)
+    URHO3D_PARAM(P_SQL, SQL);                      // String
+    URHO3D_PARAM(P_NUMCOLS, NumCols);              // unsigned
+    URHO3D_PARAM(P_COLVALUES, ColValues);          // VariantVector
+    URHO3D_PARAM(P_COLHEADERS, ColHeaders);        // StringVector
+    URHO3D_PARAM(P_FILTER, Filter);                // bool [in]
+    URHO3D_PARAM(P_ABORT, Abort);                  // bool [in]
 }
 
 }

Source/Urho3D/Engine/EngineEvents.h

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

Source/Urho3D/Graphics/DrawableEvents.h

@@ -30,21 +30,21 @@ namespace Urho3D
 /// AnimatedModel bone hierarchy created.
 URHO3D_EVENT(E_BONEHIERARCHYCREATED, BoneHierarchyCreated)
 {
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// AnimatedModel animation trigger.
 URHO3D_EVENT(E_ANIMATIONTRIGGER, AnimationTrigger)
 {
-    PARAM(P_NODE, Node);                    // Node pointer
-    PARAM(P_NAME, Name);                    // String
-    PARAM(P_TIME, Time);                    // Float
-    PARAM(P_DATA, Data);                    // User-defined data type
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_NAME, Name);                    // String
+    URHO3D_PARAM(P_TIME, Time);                    // Float
+    URHO3D_PARAM(P_DATA, Data);                    // User-defined data type
 }
 /// Terrain geometry created.
 URHO3D_EVENT(E_TERRAINCREATED, TerrainCreated)
 {
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 }

Source/Urho3D/Graphics/GraphicsEvents.h

@@ -30,18 +30,18 @@ namespace Urho3D
 /// New screen mode set.
 URHO3D_EVENT(E_SCREENMODE, ScreenMode)
 {
-    PARAM(P_WIDTH, Width);                  // int
-    PARAM(P_HEIGHT, Height);                // int
-    PARAM(P_FULLSCREEN, Fullscreen);        // bool
-    PARAM(P_RESIZABLE, Resizable);          // bool
-    PARAM(P_BORDERLESS, Borderless);        // bool
+    URHO3D_PARAM(P_WIDTH, Width);                  // int
+    URHO3D_PARAM(P_HEIGHT, Height);                // int
+    URHO3D_PARAM(P_FULLSCREEN, Fullscreen);        // bool
+    URHO3D_PARAM(P_RESIZABLE, Resizable);          // bool
+    URHO3D_PARAM(P_BORDERLESS, Borderless);        // bool
 }
 
 /// Window position changed.
 URHO3D_EVENT(E_WINDOWPOS, WindowPos)
 {
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
 }
 
 /// Request for queuing autoupdated rendersurfaces.
@@ -62,41 +62,41 @@ URHO3D_EVENT(E_ENDRENDERING, EndRendering)
 /// Update of a view started.
 URHO3D_EVENT(E_BEGINVIEWUPDATE, BeginViewUpdate)
 {
-    PARAM(P_VIEW, View);                    // View pointer
-    PARAM(P_TEXTURE, Texture);              // Texture pointer
-    PARAM(P_SURFACE, Surface);              // RenderSurface pointer
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_CAMERA, Camera);                // Camera pointer
+    URHO3D_PARAM(P_VIEW, View);                    // View pointer
+    URHO3D_PARAM(P_TEXTURE, Texture);              // Texture pointer
+    URHO3D_PARAM(P_SURFACE, Surface);              // RenderSurface pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_CAMERA, Camera);                // Camera pointer
 }
 
 /// Update of a view ended.
 URHO3D_EVENT(E_ENDVIEWUPDATE, EndViewUpdate)
 {
-    PARAM(P_VIEW, View);                    // View pointer
-    PARAM(P_TEXTURE, Texture);              // Texture pointer
-    PARAM(P_SURFACE, Surface);              // RenderSurface pointer
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_CAMERA, Camera);                // Camera pointer
+    URHO3D_PARAM(P_VIEW, View);                    // View pointer
+    URHO3D_PARAM(P_TEXTURE, Texture);              // Texture pointer
+    URHO3D_PARAM(P_SURFACE, Surface);              // RenderSurface pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_CAMERA, Camera);                // Camera pointer
 }
 
 /// Render of a view started.
 URHO3D_EVENT(E_BEGINVIEWRENDER, BeginViewRender)
 {
-    PARAM(P_VIEW, View);                    // View pointer
-    PARAM(P_TEXTURE, Texture);              // Texture pointer
-    PARAM(P_SURFACE, Surface);              // RenderSurface pointer
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_CAMERA, Camera);                // Camera pointer
+    URHO3D_PARAM(P_VIEW, View);                    // View pointer
+    URHO3D_PARAM(P_TEXTURE, Texture);              // Texture pointer
+    URHO3D_PARAM(P_SURFACE, Surface);              // RenderSurface pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_CAMERA, Camera);                // Camera pointer
 }
 
 /// Render of a view ended.
 URHO3D_EVENT(E_ENDVIEWRENDER, EndViewRender)
 {
-    PARAM(P_VIEW, View);                    // View pointer
-    PARAM(P_TEXTURE, Texture);              // Texture pointer
-    PARAM(P_SURFACE, Surface);              // RenderSurface pointer
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_CAMERA, Camera);                // Camera pointer
+    URHO3D_PARAM(P_VIEW, View);                    // View pointer
+    URHO3D_PARAM(P_TEXTURE, Texture);              // Texture pointer
+    URHO3D_PARAM(P_SURFACE, Surface);              // RenderSurface pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_CAMERA, Camera);                // Camera pointer
 }
 
 /// Graphics context has been lost. Some or all (depending on the API) GPU objects have lost their contents.

Source/Urho3D/IO/IOEvents.h

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

Source/Urho3D/Input/InputEvents.h

@@ -35,186 +35,186 @@ namespace Urho3D
 /// Mouse button pressed.
 URHO3D_EVENT(E_MOUSEBUTTONDOWN, MouseButtonDown)
 {
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Mouse button released.
 URHO3D_EVENT(E_MOUSEBUTTONUP, MouseButtonUp)
 {
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Mouse moved.
 URHO3D_EVENT(E_MOUSEMOVE, MouseMove)
 {
-    PARAM(P_X, X);                          // int (only when mouse visible)
-    PARAM(P_Y, Y);                          // int (only when mouse visible)
-    PARAM(P_DX, DX);                        // int
-    PARAM(P_DY, DY);                        // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_X, X);                          // int (only when mouse visible)
+    URHO3D_PARAM(P_Y, Y);                          // int (only when mouse visible)
+    URHO3D_PARAM(P_DX, DX);                        // int
+    URHO3D_PARAM(P_DY, DY);                        // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Mouse wheel moved.
 URHO3D_EVENT(E_MOUSEWHEEL, MouseWheel)
 {
-    PARAM(P_WHEEL, Wheel);                  // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_WHEEL, Wheel);                  // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Key pressed.
 URHO3D_EVENT(E_KEYDOWN, KeyDown)
 {
-    PARAM(P_KEY, Key);                      // int
-    PARAM(P_SCANCODE, Scancode);            // int
-    PARAM(P_RAW, Raw);                      // uint
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
-    PARAM(P_REPEAT, Repeat);                // bool
+    URHO3D_PARAM(P_KEY, Key);                      // int
+    URHO3D_PARAM(P_SCANCODE, Scancode);            // int
+    URHO3D_PARAM(P_RAW, Raw);                      // uint
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_REPEAT, Repeat);                // bool
 }
 
 /// Key released.
 URHO3D_EVENT(E_KEYUP, KeyUp)
 {
-    PARAM(P_KEY, Key);                      // int
-    PARAM(P_SCANCODE, Scancode);            // int
-    PARAM(P_RAW, Raw);                      // uint
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_KEY, Key);                      // int
+    URHO3D_PARAM(P_SCANCODE, Scancode);            // int
+    URHO3D_PARAM(P_RAW, Raw);                      // uint
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Text input event.
 URHO3D_EVENT(E_TEXTINPUT, TextInput)
 {
-    PARAM(P_TEXT, Text);                    // String
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_TEXT, Text);                    // String
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Joystick connected.
 URHO3D_EVENT(E_JOYSTICKCONNECTED, JoystickConnected)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
 }
 
 /// Joystick disconnected.
 URHO3D_EVENT(E_JOYSTICKDISCONNECTED, JoystickDisconnected)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
 }
 
 /// Joystick button pressed.
 URHO3D_EVENT(E_JOYSTICKBUTTONDOWN, JoystickButtonDown)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
-    PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
 }
 
 /// Joystick button released.
 URHO3D_EVENT(E_JOYSTICKBUTTONUP, JoystickButtonUp)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
-    PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
 }
 
 /// Joystick axis moved.
 URHO3D_EVENT(E_JOYSTICKAXISMOVE, JoystickAxisMove)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
-    PARAM(P_AXIS, Button);                  // int
-    PARAM(P_POSITION, Position);            // float
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_AXIS, Button);                  // int
+    URHO3D_PARAM(P_POSITION, Position);            // float
 }
 
 /// Joystick POV hat moved.
 URHO3D_EVENT(E_JOYSTICKHATMOVE, JoystickHatMove)
 {
-    PARAM(P_JOYSTICKID, JoystickID);        // int
-    PARAM(P_HAT, Button);                   // int
-    PARAM(P_POSITION, Position);            // int
+    URHO3D_PARAM(P_JOYSTICKID, JoystickID);        // int
+    URHO3D_PARAM(P_HAT, Button);                   // int
+    URHO3D_PARAM(P_POSITION, Position);            // int
 }
 
 /// Finger pressed on the screen.
 URHO3D_EVENT(E_TOUCHBEGIN, TouchBegin)
 {
-    PARAM(P_TOUCHID, TouchID);              // int
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_PRESSURE, Pressure);            // float
+    URHO3D_PARAM(P_TOUCHID, TouchID);              // int
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_PRESSURE, Pressure);            // float
 }
 
 /// Finger released from the screen.
 URHO3D_EVENT(E_TOUCHEND, TouchEnd)
 {
-    PARAM(P_TOUCHID, TouchID);              // int
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_TOUCHID, TouchID);              // int
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
 }
 
 /// Finger moved on the screen.
 URHO3D_EVENT(E_TOUCHMOVE, TouchMove)
 {
-    PARAM(P_TOUCHID, TouchID);              // int
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_DX, DX);                        // int
-    PARAM(P_DY, DY);                        // int
-    PARAM(P_PRESSURE, Pressure);            // float
+    URHO3D_PARAM(P_TOUCHID, TouchID);              // int
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_DX, DX);                        // int
+    URHO3D_PARAM(P_DY, DY);                        // int
+    URHO3D_PARAM(P_PRESSURE, Pressure);            // float
 }
 
 /// A touch gesture finished recording.
 URHO3D_EVENT(E_GESTURERECORDED, GestureRecorded)
 {
-    PARAM(P_GESTUREID, GestureID);          // unsigned
+    URHO3D_PARAM(P_GESTUREID, GestureID);          // unsigned
 }
 
 /// A recognized touch gesture was input by the user.
 URHO3D_EVENT(E_GESTUREINPUT, GestureInput)
 {
-    PARAM(P_GESTUREID, GestureID);          // unsigned
-    PARAM(P_CENTERX, CenterX);              // int
-    PARAM(P_CENTERY, CenterY);              // int
-    PARAM(P_NUMFINGERS, NumFingers);        // int
-    PARAM(P_ERROR, Error);                  // float
+    URHO3D_PARAM(P_GESTUREID, GestureID);          // unsigned
+    URHO3D_PARAM(P_CENTERX, CenterX);              // int
+    URHO3D_PARAM(P_CENTERY, CenterY);              // int
+    URHO3D_PARAM(P_NUMFINGERS, NumFingers);        // int
+    URHO3D_PARAM(P_ERROR, Error);                  // float
 }
 
 /// Pinch/rotate multi-finger touch gesture motion update.
 URHO3D_EVENT(E_MULTIGESTURE, MultiGesture)
 {
-    PARAM(P_CENTERX, CenterX);              // int
-    PARAM(P_CENTERY, CenterY);              // int
-    PARAM(P_NUMFINGERS, NumFingers);        // int
-    PARAM(P_DTHETA, DTheta);                // float (degrees)
-    PARAM(P_DDIST, DDist);                  // float
+    URHO3D_PARAM(P_CENTERX, CenterX);              // int
+    URHO3D_PARAM(P_CENTERY, CenterY);              // int
+    URHO3D_PARAM(P_NUMFINGERS, NumFingers);        // int
+    URHO3D_PARAM(P_DTHETA, DTheta);                // float (degrees)
+    URHO3D_PARAM(P_DDIST, DDist);                  // float
 }
 
 /// A file was drag-dropped into the application window.
 URHO3D_EVENT(E_DROPFILE, DropFile)
 {
-    PARAM(P_FILENAME, FileName);            // String
+    URHO3D_PARAM(P_FILENAME, FileName);            // String
 }
 
 /// Application input focus or minimization changed.
 URHO3D_EVENT(E_INPUTFOCUS, InputFocus)
 {
-    PARAM(P_FOCUS, Focus);                  // bool
-    PARAM(P_MINIMIZED, Minimized);          // bool
+    URHO3D_PARAM(P_FOCUS, Focus);                  // bool
+    URHO3D_PARAM(P_MINIMIZED, Minimized);          // bool
 }
 
 /// OS mouse cursor visibility changed.
 URHO3D_EVENT(E_MOUSEVISIBLECHANGED, MouseVisibleChanged)
 {
-    PARAM(P_VISIBLE, Visible);              // bool
+    URHO3D_PARAM(P_VISIBLE, Visible);              // bool
 }
 
 /// Mouse mode changed.
 URHO3D_EVENT(E_MOUSEMODECHANGED, MouseModeChanged)
 {
-    PARAM(P_MODE, Mode);                    // MouseMode
+    URHO3D_PARAM(P_MODE, Mode);                    // MouseMode
 }
 
 /// Application exit requested.

Source/Urho3D/Navigation/NavigationEvents.h

@@ -30,80 +30,80 @@ namespace Urho3D
 /// Complete rebuild of navigation mesh.
 URHO3D_EVENT(E_NAVIGATION_MESH_REBUILT, NavigationMeshRebuilt)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_MESH, Mesh); // NavigationMesh pointer
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_MESH, Mesh); // NavigationMesh pointer
 }
 
 /// Partial bounding box rebuild of navigation mesh.
 URHO3D_EVENT(E_NAVIGATION_AREA_REBUILT, NavigationAreaRebuilt)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_MESH, Mesh); // NavigationMesh pointer
-    PARAM(P_BOUNDSMIN, BoundsMin); // Vector3
-    PARAM(P_BOUNDSMAX, BoundsMax); // Vector3
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_MESH, Mesh); // NavigationMesh pointer
+    URHO3D_PARAM(P_BOUNDSMIN, BoundsMin); // Vector3
+    URHO3D_PARAM(P_BOUNDSMAX, BoundsMax); // Vector3
 }
 
 /// Crowd agent formation.
 URHO3D_EVENT(E_CROWD_AGENT_FORMATION, CrowdAgentFormation)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
-    PARAM(P_INDEX, Index); // unsigned
-    PARAM(P_SIZE, Size); // unsigned
-    PARAM(P_POSITION, Position); // Vector3 [in/out]
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
+    URHO3D_PARAM(P_INDEX, Index); // unsigned
+    URHO3D_PARAM(P_SIZE, Size); // unsigned
+    URHO3D_PARAM(P_POSITION, Position); // Vector3 [in/out]
 }
 
 /// Crowd agent has been repositioned.
 URHO3D_EVENT(E_CROWD_AGENT_REPOSITION, CrowdAgentReposition)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
-    PARAM(P_POSITION, Position); // Vector3
-    PARAM(P_VELOCITY, Velocity); // Vector3
-    PARAM(P_ARRIVED, Arrived); // bool
-    PARAM(P_TIMESTEP, TimeStep); // float
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
+    URHO3D_PARAM(P_POSITION, Position); // Vector3
+    URHO3D_PARAM(P_VELOCITY, Velocity); // Vector3
+    URHO3D_PARAM(P_ARRIVED, Arrived); // bool
+    URHO3D_PARAM(P_TIMESTEP, TimeStep); // float
 }
 
 /// Crowd agent's internal state has become invalidated. This is a special case of CrowdAgentStateChanged event.
 URHO3D_EVENT(E_CROWD_AGENT_FAILURE, CrowdAgentFailure)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
-    PARAM(P_POSITION, Position); // Vector3
-    PARAM(P_VELOCITY, Velocity); // Vector3
-    PARAM(P_CROWD_AGENT_STATE, CrowdAgentState); // int
-    PARAM(P_CROWD_TARGET_STATE, CrowdTargetState); // int
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
+    URHO3D_PARAM(P_POSITION, Position); // Vector3
+    URHO3D_PARAM(P_VELOCITY, Velocity); // Vector3
+    URHO3D_PARAM(P_CROWD_AGENT_STATE, CrowdAgentState); // int
+    URHO3D_PARAM(P_CROWD_TARGET_STATE, CrowdTargetState); // int
 }
 
 /// Crowd agent's state has been changed.
 URHO3D_EVENT(E_CROWD_AGENT_STATE_CHANGED, CrowdAgentStateChanged)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
-    PARAM(P_POSITION, Position); // Vector3
-    PARAM(P_VELOCITY, Velocity); // Vector3
-    PARAM(P_CROWD_AGENT_STATE, CrowdAgentState); // int
-    PARAM(P_CROWD_TARGET_STATE, CrowdTargetState); // int
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_CROWD_AGENT, CrowdAgent); // CrowdAgent pointer
+    URHO3D_PARAM(P_POSITION, Position); // Vector3
+    URHO3D_PARAM(P_VELOCITY, Velocity); // Vector3
+    URHO3D_PARAM(P_CROWD_AGENT_STATE, CrowdAgentState); // int
+    URHO3D_PARAM(P_CROWD_TARGET_STATE, CrowdTargetState); // int
 }
 
 /// Addition of obstacle to dynamic navigation mesh.
 URHO3D_EVENT(E_NAVIGATION_OBSTACLE_ADDED, NavigationObstacleAdded)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer
-    PARAM(P_POSITION, Position); // Vector3
-    PARAM(P_RADIUS, Radius); // float
-    PARAM(P_HEIGHT, Height); // float
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer
+    URHO3D_PARAM(P_POSITION, Position); // Vector3
+    URHO3D_PARAM(P_RADIUS, Radius); // float
+    URHO3D_PARAM(P_HEIGHT, Height); // float
 }
 
 /// Removal of obstacle from dynamic navigation mesh.
 URHO3D_EVENT(E_NAVIGATION_OBSTACLE_REMOVED, NavigationObstacleRemoved)
 {
-    PARAM(P_NODE, Node); // Node pointer
-    PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer
-    PARAM(P_POSITION, Position); // Vector3
-    PARAM(P_RADIUS, Radius); // float
-    PARAM(P_HEIGHT, Height); // float
+    URHO3D_PARAM(P_NODE, Node); // Node pointer
+    URHO3D_PARAM(P_OBSTACLE, Obstacle); // Obstacle pointer
+    URHO3D_PARAM(P_POSITION, Position); // Vector3
+    URHO3D_PARAM(P_RADIUS, Radius); // float
+    URHO3D_PARAM(P_HEIGHT, Height); // float
 }
 
 }

Source/Urho3D/Network/NetworkEvents.h

@@ -45,34 +45,34 @@ URHO3D_EVENT(E_CONNECTFAILED, ConnectFailed)
 /// New client connection established.
 URHO3D_EVENT(E_CLIENTCONNECTED, ClientConnected)
 {
-    PARAM(P_CONNECTION, Connection);        // Connection pointer
+    URHO3D_PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Client connection disconnected.
 URHO3D_EVENT(E_CLIENTDISCONNECTED, ClientDisconnected)
 {
-    PARAM(P_CONNECTION, Connection);        // Connection pointer
+    URHO3D_PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Client has sent identity: identity map is in the event data.
 URHO3D_EVENT(E_CLIENTIDENTITY, ClientIdentity)
 {
-    PARAM(P_CONNECTION, Connection);        // Connection pointer
-    PARAM(P_ALLOW, Allow);                  // bool
+    URHO3D_PARAM(P_CONNECTION, Connection);        // Connection pointer
+    URHO3D_PARAM(P_ALLOW, Allow);                  // bool
 }
 
 /// Client has informed to have loaded the scene.
 URHO3D_EVENT(E_CLIENTSCENELOADED, ClientSceneLoaded)
 {
-    PARAM(P_CONNECTION, Connection);        // Connection pointer
+    URHO3D_PARAM(P_CONNECTION, Connection);        // Connection pointer
 }
 
 /// Unhandled network message received.
 URHO3D_EVENT(E_NETWORKMESSAGE, NetworkMessage)
 {
-    PARAM(P_CONNECTION, Connection);        // Connection pointer
-    PARAM(P_MESSAGEID, MessageID);          // int
-    PARAM(P_DATA, Data);                    // Buffer
+    URHO3D_PARAM(P_CONNECTION, Connection);        // Connection pointer
+    URHO3D_PARAM(P_MESSAGEID, MessageID);          // int
+    URHO3D_PARAM(P_DATA, Data);                    // Buffer
 }
 
 /// About to send network update on the client or server.
@@ -88,13 +88,13 @@ URHO3D_EVENT(E_NETWORKUPDATESENT, NetworkUpdateSent)
 /// Scene load failed, either due to file not found or checksum error.
 URHO3D_EVENT(E_NETWORKSCENELOADFAILED, NetworkSceneLoadFailed)
 {
-    PARAM(P_CONNECTION, Connection);      // Connection pointer
+    URHO3D_PARAM(P_CONNECTION, Connection);      // Connection pointer
 }
 
 /// Remote event: adds Connection parameter to the event data
 URHO3D_EVENT(E_REMOTEEVENTDATA, RemoteEventData)
 {
-    PARAM(P_CONNECTION, Connection);      // Connection pointer
+    URHO3D_PARAM(P_CONNECTION, Connection);      // Connection pointer
 }
 
 }

Source/Urho3D/Physics/PhysicsEvents.h

@@ -30,79 +30,79 @@ namespace Urho3D
 /// Physics world is about to be stepped.
 URHO3D_EVENT(E_PHYSICSPRESTEP, PhysicsPreStep)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics world has been stepped.
 URHO3D_EVENT(E_PHYSICSPOSTSTEP, PhysicsPostStep)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics collision started.
 URHO3D_EVENT(E_PHYSICSCOLLISIONSTART, PhysicsCollisionStart)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld pointer
-    PARAM(P_NODEA, NodeA);                  // Node pointer
-    PARAM(P_NODEB, NodeB);                  // Node pointer
-    PARAM(P_BODYA, BodyA);                  // RigidBody pointer
-    PARAM(P_BODYB, BodyB);                  // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
-    PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld pointer
+    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
+    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
+    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody pointer
+    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
 }
 
 /// Physics collision ongoing.
 URHO3D_EVENT(E_PHYSICSCOLLISION, PhysicsCollision)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld pointer
-    PARAM(P_NODEA, NodeA);                  // Node pointer
-    PARAM(P_NODEB, NodeB);                  // Node pointer
-    PARAM(P_BODYA, BodyA);                  // RigidBody pointer
-    PARAM(P_BODYB, BodyB);                  // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
-    PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld pointer
+    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
+    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
+    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody pointer
+    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
 }
 
 /// Physics collision ended.
 URHO3D_EVENT(E_PHYSICSCOLLISIONEND, PhysicsCollisionEnd)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld pointer
-    PARAM(P_NODEA, NodeA);                  // Node pointer
-    PARAM(P_NODEB, NodeB);                  // Node pointer
-    PARAM(P_BODYA, BodyA);                  // RigidBody pointer
-    PARAM(P_BODYB, BodyB);                  // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld pointer
+    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
+    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
+    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody pointer
+    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
 }
 
 /// Physics collision started (sent to the participating scene nodes.)
 URHO3D_EVENT(E_NODECOLLISIONSTART, NodeCollisionStart)
 {
-    PARAM(P_BODY, Body);                    // RigidBody pointer
-    PARAM(P_OTHERNODE, OtherNode);          // Node pointer
-    PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
-    PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
+    URHO3D_PARAM(P_BODY, Body);                    // RigidBody pointer
+    URHO3D_PARAM(P_OTHERNODE, OtherNode);          // Node pointer
+    URHO3D_PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
 }
 
 /// Physics collision ongoing (sent to the participating scene nodes.)
 URHO3D_EVENT(E_NODECOLLISION, NodeCollision)
 {
-    PARAM(P_BODY, Body);                    // RigidBody pointer
-    PARAM(P_OTHERNODE, OtherNode);          // Node pointer
-    PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
-    PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
+    URHO3D_PARAM(P_BODY, Body);                    // RigidBody pointer
+    URHO3D_PARAM(P_OTHERNODE, OtherNode);          // Node pointer
+    URHO3D_PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_CONTACTS, Contacts);            // Buffer containing position (Vector3), normal (Vector3), distance (float), impulse (float) for each contact
 }
 
 /// Physics collision ended (sent to the participating scene nodes.)
 URHO3D_EVENT(E_NODECOLLISIONEND, NodeCollisionEnd)
 {
-    PARAM(P_BODY, Body);                    // RigidBody pointer
-    PARAM(P_OTHERNODE, OtherNode);          // Node pointer
-    PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
-    PARAM(P_TRIGGER, Trigger);              // bool
+    URHO3D_PARAM(P_BODY, Body);                    // RigidBody pointer
+    URHO3D_PARAM(P_OTHERNODE, OtherNode);          // Node pointer
+    URHO3D_PARAM(P_OTHERBODY, OtherBody);          // RigidBody pointer
+    URHO3D_PARAM(P_TRIGGER, Trigger);              // bool
 }
 
 }

Source/Urho3D/Resource/ResourceEvents.h

@@ -45,34 +45,34 @@ URHO3D_EVENT(E_RELOADFAILED, ReloadFailed)
 /// Tracked file changed in the resource directories.
 URHO3D_EVENT(E_FILECHANGED, FileChanged)
 {
-    PARAM(P_FILENAME, FileName);                    // String
-    PARAM(P_RESOURCENAME, ResourceName);            // String
+    URHO3D_PARAM(P_FILENAME, FileName);                    // String
+    URHO3D_PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Resource loading failed.
 URHO3D_EVENT(E_LOADFAILED, LoadFailed)
 {
-    PARAM(P_RESOURCENAME, ResourceName);            // String
+    URHO3D_PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Resource not found.
 URHO3D_EVENT(E_RESOURCENOTFOUND, ResourceNotFound)
 {
-    PARAM(P_RESOURCENAME, ResourceName);            // String
+    URHO3D_PARAM(P_RESOURCENAME, ResourceName);            // String
 }
 
 /// Unknown resource type.
 URHO3D_EVENT(E_UNKNOWNRESOURCETYPE, UnknownResourceType)
 {
-    PARAM(P_RESOURCETYPE, ResourceType);            // StringHash
+    URHO3D_PARAM(P_RESOURCETYPE, ResourceType);            // StringHash
 }
 
 /// Resource background loading finished.
 URHO3D_EVENT(E_RESOURCEBACKGROUNDLOADED, ResourceBackgroundLoaded)
 {
-    PARAM(P_RESOURCENAME, ResourceName);            // String
-    PARAM(P_SUCCESS, Success);                      // bool
-    PARAM(P_RESOURCE, Resource);                    // Resource pointer
+    URHO3D_PARAM(P_RESOURCENAME, ResourceName);            // String
+    URHO3D_PARAM(P_SUCCESS, Success);                      // bool
+    URHO3D_PARAM(P_RESOURCE, Resource);                    // Resource pointer
 }
 
 /// Language changed.

Source/Urho3D/Scene/SceneEvents.h

@@ -30,29 +30,29 @@ namespace Urho3D
 /// Variable timestep scene update.
 URHO3D_EVENT(E_SCENEUPDATE, SceneUpdate)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Scene subsystem update.
 URHO3D_EVENT(E_SCENESUBSYSTEMUPDATE, SceneSubsystemUpdate)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Scene transform smoothing update.
 URHO3D_EVENT(E_UPDATESMOOTHING, UpdateSmoothing)
 {
-    PARAM(P_CONSTANT, Constant);            // float
-    PARAM(P_SQUAREDSNAPTHRESHOLD, SquaredSnapThreshold);  // float
+    URHO3D_PARAM(P_CONSTANT, Constant);            // float
+    URHO3D_PARAM(P_SQUAREDSNAPTHRESHOLD, SquaredSnapThreshold);  // float
 }
 
 /// Scene drawable update finished. Custom animation (eg. IK) can be done at this point.
 URHO3D_EVENT(E_SCENEDRAWABLEUPDATEFINISHED, SceneDrawableUpdateFinished)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// SmoothedTransform target position changed.
@@ -68,116 +68,116 @@ URHO3D_EVENT(E_TARGETROTATION, TargetRotationChanged)
 /// Scene attribute animation update.
 URHO3D_EVENT(E_ATTRIBUTEANIMATIONUPDATE, AttributeAnimationUpdate)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Attribute animation added to object animation.
 URHO3D_EVENT(E_ATTRIBUTEANIMATIONADDED, AttributeAnimationAdded)
 {
-    PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
-    PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
+    URHO3D_PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
+    URHO3D_PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
 }
 
 /// Attribute animation removed from object animation.
 URHO3D_EVENT(E_ATTRIBUTEANIMATIONREMOVED, AttributeAnimationRemoved)
 {
-    PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
-    PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
+    URHO3D_PARAM(P_OBJECTANIMATION, ObjectAnimation);               // Object animation pointer
+    URHO3D_PARAM(P_ATTRIBUTEANIMATIONNAME, AttributeAnimationName); // String
 }
 
 /// Variable timestep scene post-update.
 URHO3D_EVENT(E_SCENEPOSTUPDATE, ScenePostUpdate)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Asynchronous scene loading progress.
 URHO3D_EVENT(E_ASYNCLOADPROGRESS, AsyncLoadProgress)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_PROGRESS, Progress);            // float
-    PARAM(P_LOADEDNODES, LoadedNodes);      // int
-    PARAM(P_TOTALNODES, TotalNodes);        // int
-    PARAM(P_LOADEDRESOURCES, LoadedResources); // int
-    PARAM(P_TOTALRESOURCES, TotalResources);   // int
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_PROGRESS, Progress);            // float
+    URHO3D_PARAM(P_LOADEDNODES, LoadedNodes);      // int
+    URHO3D_PARAM(P_TOTALNODES, TotalNodes);        // int
+    URHO3D_PARAM(P_LOADEDRESOURCES, LoadedResources); // int
+    URHO3D_PARAM(P_TOTALRESOURCES, TotalResources);   // int
 };
 
 /// Asynchronous scene loading finished.
 URHO3D_EVENT(E_ASYNCLOADFINISHED, AsyncLoadFinished)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
 };
 
 /// A child node has been added to a parent node.
 URHO3D_EVENT(E_NODEADDED, NodeAdded)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_PARENT, Parent);                // Node pointer
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_PARENT, Parent);                // Node pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A child node is about to be removed from a parent node.
 URHO3D_EVENT(E_NODEREMOVED, NodeRemoved)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_PARENT, Parent);                // Node pointer
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_PARENT, Parent);                // Node pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A component has been created to a node.
 URHO3D_EVENT(E_COMPONENTADDED, ComponentAdded)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_NODE, Node);                    // Node pointer
-    PARAM(P_COMPONENT, Component);          // Component pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_COMPONENT, Component);          // Component pointer
 }
 
 /// A component is about to be removed from a node.
 URHO3D_EVENT(E_COMPONENTREMOVED, ComponentRemoved)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_NODE, Node);                    // Node pointer
-    PARAM(P_COMPONENT, Component);          // Component pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_COMPONENT, Component);          // Component pointer
 }
 
 /// A node's name has changed.
 URHO3D_EVENT(E_NODENAMECHANGED, NodeNameChanged)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A node's enabled state has changed.
 URHO3D_EVENT(E_NODEENABLEDCHANGED, NodeEnabledChanged)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
 }
 
 /// A component's enabled state has changed.
 URHO3D_EVENT(E_COMPONENTENABLEDCHANGED, ComponentEnabledChanged)
 {
-    PARAM(P_SCENE, Scene);                  // Scene pointer
-    PARAM(P_NODE, Node);                    // Node pointer
-    PARAM(P_COMPONENT, Component);          // Component pointer
+    URHO3D_PARAM(P_SCENE, Scene);                  // Scene pointer
+    URHO3D_PARAM(P_NODE, Node);                    // Node pointer
+    URHO3D_PARAM(P_COMPONENT, Component);          // Component pointer
 }
 
 /// A serializable's temporary state has changed.
 URHO3D_EVENT(E_TEMPORARYCHANGED, TemporaryChanged)
 {
-    PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
+    URHO3D_PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
 }
 
 /// A network attribute update from the server has been intercepted.
 URHO3D_EVENT(E_INTERCEPTNETWORKUPDATE, InterceptNetworkUpdate)
 {
-    PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
-    PARAM(P_TIMESTAMP, TimeStamp);          // unsigned (0-255)
-    PARAM(P_INDEX, Index);                  // unsigned
-    PARAM(P_NAME, Name);                    // String
-    PARAM(P_VALUE, Value);                  // Variant
+    URHO3D_PARAM(P_SERIALIZABLE, Serializable);    // Serializable pointer
+    URHO3D_PARAM(P_TIMESTAMP, TimeStamp);          // unsigned (0-255)
+    URHO3D_PARAM(P_INDEX, Index);                  // unsigned
+    URHO3D_PARAM(P_NAME, Name);                    // String
+    URHO3D_PARAM(P_VALUE, Value);                  // Variant
 }
 
 }

Source/Urho3D/UI/UIEvents.h

@@ -30,350 +30,350 @@ namespace Urho3D
 /// Mouse click in the UI.
 URHO3D_EVENT(E_UIMOUSECLICK, UIMouseClick)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Mouse click end in the UI.
 URHO3D_EVENT(E_UIMOUSECLICKEND, UIMouseClickEnd)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_BEGINELEMENT, BeginElement);    // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_BEGINELEMENT, BeginElement);    // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Mouse double click in the UI.
 URHO3D_EVENT(E_UIMOUSEDOUBLECLICK, UIMouseDoubleClick)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Drag and drop test.
 URHO3D_EVENT(E_DRAGDROPTEST, DragDropTest)
 {
-    PARAM(P_SOURCE, Source);                // UIElement pointer
-    PARAM(P_TARGET, Target);                // UIElement pointer
-    PARAM(P_ACCEPT, Accept);                // bool
+    URHO3D_PARAM(P_SOURCE, Source);                // UIElement pointer
+    URHO3D_PARAM(P_TARGET, Target);                // UIElement pointer
+    URHO3D_PARAM(P_ACCEPT, Accept);                // bool
 };
 
 /// Drag and drop finish.
 URHO3D_EVENT(E_DRAGDROPFINISH, DragDropFinish)
 {
-    PARAM(P_SOURCE, Source);                // UIElement pointer
-    PARAM(P_TARGET, Target);                // UIElement pointer
-    PARAM(P_ACCEPT, Accept);                // bool
+    URHO3D_PARAM(P_SOURCE, Source);                // UIElement pointer
+    URHO3D_PARAM(P_TARGET, Target);                // UIElement pointer
+    URHO3D_PARAM(P_ACCEPT, Accept);                // bool
 };
 
 /// Focus element changed.
 URHO3D_EVENT(E_FOCUSCHANGED, FocusChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_CLICKEDELEMENT, ClickedElement); // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_CLICKEDELEMENT, ClickedElement); // UIElement pointer
 }
 
 /// UI element name changed.
 URHO3D_EVENT(E_NAMECHANGED, NameChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI element resized.
 URHO3D_EVENT(E_RESIZED, Resized)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_WIDTH, Width);                  // int
-    PARAM(P_HEIGHT, Height);                // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_WIDTH, Width);                  // int
+    URHO3D_PARAM(P_HEIGHT, Height);                // int
 }
 
 /// UI element positioned.
 URHO3D_EVENT(E_POSITIONED, Positioned)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
 }
 
 /// UI element visibility changed.
 URHO3D_EVENT(E_VISIBLECHANGED, VisibleChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_VISIBLE, Visible);              // bool
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_VISIBLE, Visible);              // bool
 }
 
 /// UI element focused.
 URHO3D_EVENT(E_FOCUSED, Focused)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_BYKEY, ByKey);                  // bool
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_BYKEY, ByKey);                  // bool
 }
 
 /// UI element defocused.
 URHO3D_EVENT(E_DEFOCUSED, Defocused)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI element layout updated.
 URHO3D_EVENT(E_LAYOUTUPDATED, LayoutUpdated)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI button pressed.
 URHO3D_EVENT(E_PRESSED, Pressed)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI button was pressed, then released.
 URHO3D_EVENT(E_RELEASED, Released)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// UI checkbox toggled.
 URHO3D_EVENT(E_TOGGLED, Toggled)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_STATE, State);                  // bool
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_STATE, State);                  // bool
 }
 
 /// UI slider value changed
 URHO3D_EVENT(E_SLIDERCHANGED, SliderChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_VALUE, Value);                  // float
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_VALUE, Value);                  // float
 }
 
 /// UI slider being paged.
 URHO3D_EVENT(E_SLIDERPAGED, SliderPaged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_OFFSET, Offset);                // int
-    PARAM(P_PRESSED, Pressed);              // bool
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_OFFSET, Offset);                // int
+    URHO3D_PARAM(P_PRESSED, Pressed);              // bool
 }
 
 /// UI scrollbar value changed.
 URHO3D_EVENT(E_SCROLLBARCHANGED, ScrollBarChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_VALUE, Value);                  // float
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_VALUE, Value);                  // float
 }
 
 /// UI scrollview position changed.
 URHO3D_EVENT(E_VIEWCHANGED, ViewChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
 }
 
 /// UI modal changed (currently only Window has modal flag).
 URHO3D_EVENT(E_MODALCHANGED, ModalChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_MODAL, Modal);                  // bool
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_MODAL, Modal);                  // bool
 }
 
 /// Text entry into a LineEdit. The char can be modified in the event data.
 URHO3D_EVENT(E_TEXTENTRY, CharEntry)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_TEXT, Text);                    // String
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_TEXT, Text);                    // String
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Editable text changed
 URHO3D_EVENT(E_TEXTCHANGED, TextChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_TEXT, Text);                    // String
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_TEXT, Text);                    // String
 }
 
 /// Text editing finished (enter pressed on a LineEdit)
 URHO3D_EVENT(E_TEXTFINISHED, TextFinished)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_TEXT, Text);                    // String
-    PARAM(P_VALUE, Value);                 // Float
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_TEXT, Text);                    // String
+    URHO3D_PARAM(P_VALUE, Value);                 // Float
 }
 
 /// Menu selected.
 URHO3D_EVENT(E_MENUSELECTED, MenuSelected)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Listview or DropDownList item selected.
 URHO3D_EVENT(E_ITEMSELECTED, ItemSelected)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_SELECTION, Selection);          // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_SELECTION, Selection);          // int
 }
 
 /// Listview item deselected.
 URHO3D_EVENT(E_ITEMDESELECTED, ItemDeselected)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_SELECTION, Selection);          // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_SELECTION, Selection);          // int
 }
 
 /// Listview selection change finished.
 URHO3D_EVENT(E_SELECTIONCHANGED, SelectionChanged)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_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.
 URHO3D_EVENT(E_ITEMCLICKED, ItemClicked)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_ITEM, Item);                    // UIElement pointer
-    PARAM(P_SELECTION, Selection);          // int
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ITEM, Item);                    // UIElement pointer
+    URHO3D_PARAM(P_SELECTION, Selection);          // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Listview item double clicked.
 URHO3D_EVENT(E_ITEMDOUBLECLICKED, ItemDoubleClicked)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_ITEM, Item);                    // UIElement pointer
-    PARAM(P_SELECTION, Selection);          // int
-    PARAM(P_BUTTON, Button);                // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ITEM, Item);                    // UIElement pointer
+    URHO3D_PARAM(P_SELECTION, Selection);          // int
+    URHO3D_PARAM(P_BUTTON, Button);                // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// LineEdit or ListView unhandled key pressed.
 URHO3D_EVENT(E_UNHANDLEDKEY, UnhandledKey)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_KEY, Key);                      // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_QUALIFIERS, Qualifiers);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_KEY, Key);                      // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_QUALIFIERS, Qualifiers);        // int
 }
 
 /// Fileselector choice.
 URHO3D_EVENT(E_FILESELECTED, FileSelected)
 {
-    PARAM(P_FILENAME, FileName);            // String
-    PARAM(P_FILTER, Filter);                // String
-    PARAM(P_OK, Ok);                        // bool
+    URHO3D_PARAM(P_FILENAME, FileName);            // String
+    URHO3D_PARAM(P_FILTER, Filter);                // String
+    URHO3D_PARAM(P_OK, Ok);                        // bool
 }
 
 /// MessageBox acknowlegement.
 URHO3D_EVENT(E_MESSAGEACK, MessageACK)
 {
-    PARAM(P_OK, Ok);                        // bool
+    URHO3D_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.
 URHO3D_EVENT(E_ELEMENTADDED, ElementAdded)
 {
-    PARAM(P_ROOT, Root);                    // UIElement pointer
-    PARAM(P_PARENT, Parent);                // UIElement pointer
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ROOT, Root);                    // UIElement pointer
+    URHO3D_PARAM(P_PARENT, Parent);                // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// A child element is about to be removed from an element. Sent by the UI root element, or element-event-sender if set.
 URHO3D_EVENT(E_ELEMENTREMOVED, ElementRemoved)
 {
-    PARAM(P_ROOT, Root);                    // UIElement pointer
-    PARAM(P_PARENT, Parent);                // UIElement pointer
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ROOT, Root);                    // UIElement pointer
+    URHO3D_PARAM(P_PARENT, Parent);                // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Hovering on an UI element has started
 URHO3D_EVENT(E_HOVERBEGIN, HoverBegin)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_ELEMENTX, ElementX);            // int
-    PARAM(P_ELEMENTY, ElementY);            // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int
 }
 
 /// Hovering on an UI element has ended
 URHO3D_EVENT(E_HOVEREND, HoverEnd)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
 }
 
 /// Drag behavior of a UI Element has started
 URHO3D_EVENT(E_DRAGBEGIN, DragBegin)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_ELEMENTX, ElementX);            // int
-    PARAM(P_ELEMENTY, ElementY);            // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_NUMBUTTONS, NumButtons);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_NUMBUTTONS, NumButtons);        // int
 }
 
 /// Drag behavior of a UI Element when the input device has moved
 URHO3D_EVENT(E_DRAGMOVE, DragMove)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_DX, DX);                        // int
-    PARAM(P_DY, DY);                        // int
-    PARAM(P_ELEMENTX, ElementX);            // int
-    PARAM(P_ELEMENTY, ElementY);            // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_NUMBUTTONS, NumButtons);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_DX, DX);                        // int
+    URHO3D_PARAM(P_DY, DY);                        // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_NUMBUTTONS, NumButtons);        // int
 }
 
 /// Drag behavior of a UI Element has finished
 URHO3D_EVENT(E_DRAGEND, DragEnd)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_ELEMENTX, ElementX);            // int
-    PARAM(P_ELEMENTY, ElementY);            // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_NUMBUTTONS, NumButtons);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_NUMBUTTONS, NumButtons);        // int
 }
 
 /// Drag of a UI Element was canceled by pressing ESC
 URHO3D_EVENT(E_DRAGCANCEL, DragCancel)
 {
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_ELEMENTX, ElementX);            // int
-    PARAM(P_ELEMENTY, ElementY);            // int
-    PARAM(P_BUTTONS, Buttons);              // int
-    PARAM(P_NUMBUTTONS, NumButtons);        // int
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int
+    URHO3D_PARAM(P_BUTTONS, Buttons);              // int
+    URHO3D_PARAM(P_NUMBUTTONS, NumButtons);        // int
 }
 
 /// A file was drag-dropped into the application window. Includes also coordinates and UI element if applicable
 URHO3D_EVENT(E_UIDROPFILE, UIDropFile)
 {
-    PARAM(P_FILENAME, FileName);            // String
-    PARAM(P_ELEMENT, Element);              // UIElement pointer
-    PARAM(P_X, X);                          // int
-    PARAM(P_Y, Y);                          // int
-    PARAM(P_ELEMENTX, ElementX);            // int (only if element is non-null)
-    PARAM(P_ELEMENTY, ElementY);            // int (only if element is non-null)
+    URHO3D_PARAM(P_FILENAME, FileName);            // String
+    URHO3D_PARAM(P_ELEMENT, Element);              // UIElement pointer
+    URHO3D_PARAM(P_X, X);                          // int
+    URHO3D_PARAM(P_Y, Y);                          // int
+    URHO3D_PARAM(P_ELEMENTX, ElementX);            // int (only if element is non-null)
+    URHO3D_PARAM(P_ELEMENTY, ElementY);            // int (only if element is non-null)
 }
 
 }

Source/Urho3D/Urho2D/PhysicsEvents2D.h

@@ -30,35 +30,35 @@ namespace Urho3D
 /// Physics world is about to be stepped.
 URHO3D_EVENT(E_PHYSICSPRESTEP2D, PhysicsPreStep2D)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics world has been stepped.
 URHO3D_EVENT(E_PHYSICSPOSTSTEP2D, PhysicsPostStep2D)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    PARAM(P_TIMESTEP, TimeStep);            // float
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    URHO3D_PARAM(P_TIMESTEP, TimeStep);            // float
 }
 
 /// Physics begin contact.
 URHO3D_EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
-    PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
-    PARAM(P_NODEA, NodeA);                  // Node pointer
-    PARAM(P_NODEB, NodeB);                  // Node pointer
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
+    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
+    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
+    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
 }
 
 /// Physics end contact.
 URHO3D_EVENT(E_PHYSICSENDCONTACT2D, PhysicsEndContact2D)
 {
-    PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
-    PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
-    PARAM(P_NODEA, NodeA);                  // Node pointer
-    PARAM(P_NODEB, NodeB);                  // Node pointer
+    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
+    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
+    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
+    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
 }
 
 }