hxmon.h

linux下的一款播放器

     */
    STDMETHOD_(UINT32, DeleteByName)	(THIS_
					const char*	pName) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::DeleteById
     *  Purpose:
     *      Delete a Property from the registry using its id "ulId".
     *
     *  ulId - IN - unique id of the Property that is going to be deleted
     */
    STDMETHOD_(UINT32, DeleteById)	(THIS_
					const UINT32	ulId) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetTypeByName
     *  Purpose:
     *      Returns the datatype of the Property given its name "pName".
     *
     *  pName - IN - name of the Property whose type is to be retreived
     */
    STDMETHOD_(HXPropType, GetTypeByName)	(THIS_
						const char* pName) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetTypeById
     *  Purpose:
     *      Returns the datatype of the Property given its its id "ulId".
     *
     *  ulId - IN - unique id of the Property whose type is to be retreived
     */
    STDMETHOD_(HXPropType, GetTypeById)	(THIS_
						const UINT32 ulId) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::FindParentIdByName
     *  Purpose:
     *      Returns the id value of the parent node of the Property whose 
     *  name "pName" has been passed in. If it fails, a ZERO value is 
     *  returned.
     *
     *  pName - IN - name of the Property whose parent's unique id is to be
     *               retreived
     */
    STDMETHOD_(UINT32, FindParentIdByName)	(THIS_
						const char* pName) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::FindParentIdById
     *  Purpose:
     *      Returns the id value of the parent node of the Property whose 
     *  id "ulId" has been passed in. If it fails, a ZERO value is returned.
     *
     *  ulId - IN - unique id of the Property whose parent's id is to be
     *              retreived
     */
    STDMETHOD_(UINT32, FindParentIdById)	(THIS_
						const UINT32 ulId) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetPropName
     *  Purpose:
     *      Returns the Property name in the pName char buffer passed
     *  as a parameter, given the Property's id "ulId".
     *
     *  ulId - IN - unique id of the Property whose name is to be retreived
     *  pName - OUT - parameter into which the Property name is going to be
     *                returned
     */
    STDMETHOD(GetPropName)		(THIS_
					const UINT32 ulId,
					REF(IHXBuffer*) pName) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetId
     *  Purpose:
     *      Returns the Property's id given the Property name.
     *
     *  pName - IN - name of the Property whose unique id is to be 
     *               retreived
     */
    STDMETHOD_(UINT32, GetId)		(THIS_
					const char* pName) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetPropListOfRoot
     *  Purpose:
     *      Returns an array of a Properties under the root level of the 
     *  registry's hierarchy.
     *
     *  pValues - OUT - list of property name and unique id at the 
     *                  highest level (root) in the registry
     */
    STDMETHOD(GetPropListOfRoot) 	(THIS_
					REF(IHXValues*) pValues) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetPropListByName
     *  Purpose:
     *      Returns an array of Properties immediately under the one whose
     *  name is passed in "pName".
     *
     *  pName - IN - name of the Property whose child property list is to be
     *               retreived
     *  pValues - OUT - list of property name and unique id under the 
     *                  Property whose name is in "pName"
     */
    STDMETHOD(GetPropListByName) 	(THIS_
					 const char* pName,
					 REF(IHXValues*) pValues) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetPropListById
     *  Purpose:
     *      Returns an array of Properties immediately under the one whose
     *  id is passed in "ulId".
     *
     *  ulId - IN - unique id of the Property whose child property list is 
     *              to be retreived
     *  pValues - OUT - list of property name and unique id under the 
     *                  Property whose is is in "ulId"
     */
    STDMETHOD(GetPropListById) 	 	(THIS_
					 const UINT32 ulId,
					 REF(IHXValues*) pValues) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetNumPropsAtRoot
     *  Purpose:
     *      Returns the number of Properties at the root of the registry. 
     *
     */
    STDMETHOD_(INT32, GetNumPropsAtRoot)	(THIS) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetNumPropsByName
     *  Purpose:
     *      Returns the count of the number of Properties under the one 
     *  whose name is specified in "pName".
     *
     *  pName - IN - name of the Property whose number of children is to be
     *               retreived
     */
    STDMETHOD_(INT32, GetNumPropsByName)	(THIS_
						const char* pName) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetNumPropsById
     *  Purpose:
     *      Returns the count of the number of Properties under the one 
     *  whose unique id is specified in "ulId".
     *
     *  ulId - IN - unique id of the Property whose number of children is 
     *              to be retreived
     */
    STDMETHOD_(INT32, GetNumPropsById)		(THIS_
						const UINT32 ulId) const PURE;


    /************************************************************************
     *  Method:
     *      IHXRegistry2::ModifyIntByName
     *  Purpose:
     *      Changes the INTEGER value in the registry given its Property
     *  name "pName" and an amount to change it by.  Modifies the value
     *  of the integer in the registry by the amount specified by "nDelta",
     *  setting nValue equal to the value after modification.  If the
     *  Property is found, it will return HXR_OK, otherwise it
     *  returns HXR_FAIL.
     *  
     *  pName - IN - name of the Property whose value is to be retrieved
     *  nDelta - IN - amount to modify the named property by
     *  nValue - OUT - parameter into which the value of the Property is
     *                 going to be returned, after modification
     */
    STDMETHOD(ModifyIntByName)         (THIS_
                                        const char*     pName,
					INT32           nDelta,
                                        REF(INT32)      nValue) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::ModifyIntById
     *  Purpose:
     *      Changes the INTEGER value in the registry given its id "ulID"
     *  and an amount to change it by.  Modifies the value of the
     *  integer in the registry by the amount specified by "nDelta",
     *  setting nValue equal to the value after modification.  If the
     *  Property is found, it will return HXR_OK, otherwise it
     *  returns HXR_FAIL.
     *
     *  ulId - IN - unique id of the Property whose value is to be modified
     *  nDelta - IN - amount to modify the specified property by
     *  nValue - OUT - parameter into which the value of the Property is
     *                 going to be returned, after modification
     */
    STDMETHOD(ModifyIntById)           (THIS_
                                        const UINT32    id,
					INT32           nDelta,
                                        REF(INT32)      nValue) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::BoundedModifyIntByName
     *  Purpose:
     *      Changes the INTEGER value in the registry given its Property name
     *  "pName" and an amount to change it by and keeps the modified value 
     *  within the bounds of the nMin and nMax values. Modifies the value 
     *  of the integer in the registry by the amount specified by "nDelta",
     *  setting nValue equal to the value after modification, if the modified 
     *  value is >= nMin and <= nMax. If either of these limits are violated 
     *  the the resulting value stored in the registry is the value of the 
     *  limit just violated. If the Property is found, it will return HXR_OK, 
     *  otherwise it returns HXR_FAIL.
     *  
     *  pName - IN - name of the Property whose value is to be retrieved
     *  nDelta - IN - amount to modify the named property by
     *  nMin - IN - min value that the modified registry prop can have
     *              if the modified registry value < nMin then
     *                  registry value = nMin
     *  nMax - IN - min value that the modified registry prop can have
     *              if the modified registry value > nMax then
     *                  registry value = nMax
     *  nValue - OUT - parameter into which the value of the Property is
     *                 going to be returned, after modification
     */
    STDMETHOD(BoundedModifyIntByName)   (THIS_
                                        const char*     pName,
					INT32           nDelta,
                                        REF(INT32)      nValue,
					INT32           nMin=INT_MIN,
					INT32           nMax=INT_MAX) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::BoundedModifyIntById
     *  Purpose:
     *      Changes the INTEGER value in the registry given its id "ulID"
     *  and an amount to change it by and keeps the modified value within
     *  the bounds of the nMin and nMax values. Modifies the value of the
     *  integer in the registry by the amount specified by "nDelta",
     *  setting nValue equal to the value after modification, if the modified
     *  value is >= nMin and <= nMax. If either of these limits are violated
     *  the the resulting value stored in the registry is the value of the
     *  limit just violated. If the Property is found, it will return HXR_OK, 
     *  otherwise it returns HXR_FAIL.
     *
     *  ulId - IN - unique id of the Property whose value is to be modified
     *  nDelta - IN - amount to modify the specified property by
     *  nMin - IN - min value that the modified registry prop can have
     *              if the modified registry value < nMin then
     *                  registry value = nMin
     *  nMax - IN - min value that the modified registry prop can have
     *              if the modified registry value > nMax then
     *                  registry value = nMax
     *  nValue - OUT - parameter into which the value of the Property is
     *                 going to be returned, after modification
     */
    STDMETHOD(BoundedModifyIntById)     (THIS_
                                        const UINT32    id,
					INT32           nDelta,
                                        REF(INT32)      nValue,
					INT32           nMin=INT_MIN,
					INT32           nMax=INT_MAX) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::SetAndReturnIntByName
     *  Purpose:
     *      Modify a Property's INTEGER value in the registry given the
     *  Property's name "pName". If the Property is found, the previous
     *  value, prior to setting it, will be assigned to nOldValue.
     *  If the Property is found, it will return HXR_OK, otherwise it
     *  returns HXR_FAIL.
     *
     *  pName - IN - name of the Property whose value is to be retrieved
     *  nValue - IN - the new value of the Property which is going to be set
     *  nOldValue - OUT - parameter into which the previous value of the
     *                    Property is returned
     */
    STDMETHOD(SetAndReturnIntByName)   (THIS_
                                        const char*     pName,
					INT32           nValue,
                                        REF(INT32)      nOldValue) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::SetAndReturnIntById
     *  Purpose:
     *      Modify a Property's INTEGER value in the registry given the
     *  Property's id "ulId". If the id is found, the previous
     *  value, prior to setting it, will be assigned to nOldValue.
     *  If the Property is found, it will return HXR_OK, otherwise it
     *  returns HXR_FAIL.
     *  
     *  pName - IN - name of the Property whose value is to be retrieved
     *  nValue - IN - the new value of the Property which is going to be set
     *  nOldValue - OUT - parameter into which the previous value of the
     *                    Property is returned
     */
    STDMETHOD(SetAndReturnIntById)     (THIS_
                                        const UINT32    id,
					INT32           nValue,
                                        REF(INT32)      nOldValue) PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetIntRefByName
     *  Purpose:
     *      Retrieve an INTEGER REFERENCE property from the registry given
     *  its Property name "pName".  If the Property is found it will return
     *  HXR_OK and pValue will be assigned the address of the integer
     *  (not the value of the integer, which can be obtained even for
     *  INTREFs via the GetIntByxxx methods.)  Otherwise, it returns HXR_FAIL.
     *  
     *  pName - IN - name of the Property whose value is to be retrieved
     *  pValue - OUT - the address of the integer value 
     */
    STDMETHOD(GetIntRefByName)         (THIS_
                                        const char*     pName,
                                        REF(INT32*)     pValue) const PURE;

    /************************************************************************
     *  Method:
     *      IHXRegistry2::GetIntRefById
     *  Purpose:
     *      Retrieve an INTEGER REFERENCE property from the registry given
     *  its id "ulId".  If the Property is found it will return
     *  HXR_OK and pValue will be assigned the address of the integer
     *  (not the value of the integer, which can be obtained even for
     *  INTREFs via the GetIntByxxx methods.)  Otherwise, it returns HXR_FAIL.
     *  
     *  pName - IN - name of the Property whose value is to be retrieved
     *  pValue - OUT - the address of the integer value 
     */
    STDMETHOD(GetIntRefById)           (THIS_
                                        const UINT32    id,
                                        REF(INT32*)     pValue) const PURE;



    /************************************************************************
     *  Method:
     *      IHXRegistry2::AddInt64
     *  Purpose:
     *      Add an INTEGER property with name in "pName" and value in
     *  "iValue" to the registry. The return value is the id to
     *  the newly added Property or ZERO if there was an error.
     *
     *  pName - IN - name of the Property that is going to be added to
     *               the registry
     *  nValue - IN - integer value of the Property that is going to be
     *                added to the registry
     */
    STDMETHOD_(UINT32, AddInt64)       (THIS_