/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Static general reusable methods.
*
*/


#ifndef AMMSUTIL_H
#define AMMSUTIL_H

//  INCLUDES
#include <e32base.h>
#include "ammsconstants.h"

// FORWARD DECLARATIONS
class CMMAPlayer;
class CMMAControl;

// CLASS DECLARATION

/**
*  Static general reusable methods.
*
*  This class contains only static method which can be used in many classes.
*
*  @since 3.0
*/
NONSHARABLE_CLASS(AMMSUtil)
{
public: // New functions
    /**
     * Finds the control of a corresponding type that
     * belongs to the player given as a parameter
     *
     * @param aPlayer The Player where to find the Control
     * @param aControlName Name of the control to look for
     * @param aControlType Special AMMS type of the Control
     * @return Control of type aControlName or NULL if not found
     */
    static CMMAControl* FindControl(
        CMMAPlayer* aPlayer,
        const TDesC& aControlName,
        TAMMSControlTypes aControlType = EAMMSBaseControl);

    /**
      * Converts vector from spherical to cartesian.
      *
      * @param aSphericalVector Spherical vector to be converted
      * @param aCartesianVector Result cartesian vector
      */
    static void FromSphericalToCartesianL(
        TInt aSphericalVector[ KAMMSVectorComponents ],
        TInt aCartesianVector[ KAMMSVectorComponents ]);

    /*
     * Rotates a vector round the given axis. The starting point of each
     * vectors is in the origo, and thus, only coordinates of the ending
     * point should be given.
     *
     * @param aVector X, Y, and Z value of a vector to be rotated
     * @param aAxisVector X, Y, and Z value of an axis vector
     * @param aAngle Rotation angle in degrees
     * @param aRotatedVector X, Y, and Z value of the rotated vector
     */
    static void RotateVectorL(TReal aVector[ KAMMSVectorComponents ],
                              TReal aAxisVector[ KAMMSVectorComponents ],
                              TInt aAngle,
                              TReal aRotatedVector[ KAMMSVectorComponents ]);

    /**
     * Rounds each component in the given vector.
     *
     * @param aVector A vector to be rounded
     * @param aRoundedVector Rounded vector
     */
    static void RoundVectorL(TReal aVector[ KAMMSVectorComponents ],
                             TInt aRoundedVector[ KAMMSVectorComponents ]);

    /**
     * Multiplies the given vector by the given scalar value.
     *
     * @param aVector A vector to be rounded
     * @param aMultiplier A multiplier
     */
    static void MultiplyVector(TReal aVector[ KAMMSVectorComponents ],
                               TReal aMultiplier);

    /**
     * Calculates vector cross product.
     * @param aA A vector having KAMMSVectorComponents elements
     * @param aB A vector having KAMMSVectorComponents elements
     * @param aResultVector Result of the cross product
     */
    static void CrossProduct(TReal aA[ KAMMSVectorComponents ],
                             TReal aB[ KAMMSVectorComponents ],
                             TReal aResultVector[ KAMMSVectorComponents ]);

    /**
     * Calculates the length of the given vector.
     *
     * @param aVector A vector whose length is calculated
     */
    static TReal VectorLengthL(TReal aVector[ KAMMSVectorComponents ]);

    /**
     * Converts the given vector to the unit vector. The original vector
     * is replaced by the result vector.
     *
     * @param aVector A vector that is converted to the unit vector and is
     * replaced by the result vector
     */
    static void ConvertToUnitVectorL(TReal aVector[ KAMMSVectorComponents ]);

    /**
     * Checks whether two given vectors are similar according to the given
     * maximum error percentage. The function compares each component in
     * aA to the corresponding component in aB.
     *
     * @param aA A vector
     * @param aB A vector
     * @param aMaxComponentErrorPercentage Maximum error percentage between
     * a component in aA and the corresponding component in aB
     * @return ETrue if difference between each component pair is lower
     * than the given error, else ETrue is returned
     */
    static TBool AreVectorsSimilar(TReal aA[ KAMMSVectorComponents ],
                                   TInt aB[ KAMMSVectorComponents ],
                                   TInt aMaxComponentErrorPercentage);

    /**
     * Returns the maximum component value in the given vector.
     *
     * @param aVector A vector
     * @return Maximum component value in aVector
     */
    static TReal MaxVectorComponent(TReal aVector[ KAMMSVectorComponents ]);

    /**
     * Returns the minimum component value in the given vector.
     *
     * @param aVector A vector
     * @return Minimum component value in aVector
     */
    static TReal MinVectorComponent(TReal aVector[ KAMMSVectorComponents ]);

private:
    /**
    * C++ default constructor. Private to not allow construction.
    */
    AMMSUtil();
};

#endif // AMMSUTIL_H