thunderbird-dev 1:52.8.0-1~deb8u1 / usr / include / thunderbird / nsIActivity.h

/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIActivity.idl
 */

#ifndef __gen_nsIActivity_h__
#define __gen_nsIActivity_h__


#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

#ifndef __gen_nsISupportsPrimitives_h__
#include "nsISupportsPrimitives.h"
#endif

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
class nsIActivityListener; /* forward declaration */

class nsIActivity; /* forward declaration */

class nsIActivityProcess; /* forward declaration */

class nsIActivityEvent; /* forward declaration */

class nsIActivityWarning; /* forward declaration */

class nsIVariant; /* forward declaration */

class nsISupportsPRTime; /* forward declaration */


/* starting interface:    nsIActivityRecoveryHandler */
#define NS_IACTIVITYRECOVERYHANDLER_IID_STR "30e0a76f-880a-4093-8f3c-af2239977a3d"

#define NS_IACTIVITYRECOVERYHANDLER_IID \
  {0x30e0a76f, 0x880a, 0x4093, \
    { 0x8f, 0x3c, 0xaf, 0x22, 0x39, 0x97, 0x7a, 0x3d }}

class NS_NO_VTABLE nsIActivityRecoveryHandler : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYRECOVERYHANDLER_IID)

  /* nsresult recover (in nsIActivityWarning aActivity); */
  NS_IMETHOD Recover(nsIActivityWarning *aActivity, nsresult *_retval) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityRecoveryHandler, NS_IACTIVITYRECOVERYHANDLER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYRECOVERYHANDLER \
  NS_IMETHOD Recover(nsIActivityWarning *aActivity, nsresult *_retval) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYRECOVERYHANDLER \
  NS_METHOD Recover(nsIActivityWarning *aActivity, nsresult *_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYRECOVERYHANDLER(_to) \
  NS_IMETHOD Recover(nsIActivityWarning *aActivity, nsresult *_retval) override { return _to Recover(aActivity, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYRECOVERYHANDLER(_to) \
  NS_IMETHOD Recover(nsIActivityWarning *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Recover(aActivity, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityRecoveryHandler : public nsIActivityRecoveryHandler
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYRECOVERYHANDLER

  nsActivityRecoveryHandler();

private:
  ~nsActivityRecoveryHandler();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityRecoveryHandler, nsIActivityRecoveryHandler)

nsActivityRecoveryHandler::nsActivityRecoveryHandler()
{
  /* member initializers and constructor code */
}

nsActivityRecoveryHandler::~nsActivityRecoveryHandler()
{
  /* destructor code */
}

/* nsresult recover (in nsIActivityWarning aActivity); */
NS_IMETHODIMP nsActivityRecoveryHandler::Recover(nsIActivityWarning *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityCancelHandler */
#define NS_IACTIVITYCANCELHANDLER_IID_STR "35ee2461-70db-4b3a-90d0-7a68c856e911"

#define NS_IACTIVITYCANCELHANDLER_IID \
  {0x35ee2461, 0x70db, 0x4b3a, \
    { 0x90, 0xd0, 0x7a, 0x68, 0xc8, 0x56, 0xe9, 0x11 }}

class NS_NO_VTABLE nsIActivityCancelHandler : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYCANCELHANDLER_IID)

  /* nsresult cancel (in nsIActivityProcess aActivity); */
  NS_IMETHOD Cancel(nsIActivityProcess *aActivity, nsresult *_retval) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityCancelHandler, NS_IACTIVITYCANCELHANDLER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYCANCELHANDLER \
  NS_IMETHOD Cancel(nsIActivityProcess *aActivity, nsresult *_retval) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYCANCELHANDLER \
  NS_METHOD Cancel(nsIActivityProcess *aActivity, nsresult *_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYCANCELHANDLER(_to) \
  NS_IMETHOD Cancel(nsIActivityProcess *aActivity, nsresult *_retval) override { return _to Cancel(aActivity, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYCANCELHANDLER(_to) \
  NS_IMETHOD Cancel(nsIActivityProcess *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Cancel(aActivity, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityCancelHandler : public nsIActivityCancelHandler
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYCANCELHANDLER

  nsActivityCancelHandler();

private:
  ~nsActivityCancelHandler();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityCancelHandler, nsIActivityCancelHandler)

nsActivityCancelHandler::nsActivityCancelHandler()
{
  /* member initializers and constructor code */
}

nsActivityCancelHandler::~nsActivityCancelHandler()
{
  /* destructor code */
}

/* nsresult cancel (in nsIActivityProcess aActivity); */
NS_IMETHODIMP nsActivityCancelHandler::Cancel(nsIActivityProcess *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityPauseHandler */
#define NS_IACTIVITYPAUSEHANDLER_IID_STR "9eee22bf-5378-460e-83a7-781cdcc9050b"

#define NS_IACTIVITYPAUSEHANDLER_IID \
  {0x9eee22bf, 0x5378, 0x460e, \
    { 0x83, 0xa7, 0x78, 0x1c, 0xdc, 0xc9, 0x05, 0x0b }}

class NS_NO_VTABLE nsIActivityPauseHandler : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYPAUSEHANDLER_IID)

  /* nsresult pause (in nsIActivityProcess aActivity); */
  NS_IMETHOD Pause(nsIActivityProcess *aActivity, nsresult *_retval) = 0;

  /* nsresult resume (in nsIActivityProcess aActivity); */
  NS_IMETHOD Resume(nsIActivityProcess *aActivity, nsresult *_retval) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityPauseHandler, NS_IACTIVITYPAUSEHANDLER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYPAUSEHANDLER \
  NS_IMETHOD Pause(nsIActivityProcess *aActivity, nsresult *_retval) override; \
  NS_IMETHOD Resume(nsIActivityProcess *aActivity, nsresult *_retval) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYPAUSEHANDLER \
  NS_METHOD Pause(nsIActivityProcess *aActivity, nsresult *_retval); \
  NS_METHOD Resume(nsIActivityProcess *aActivity, nsresult *_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYPAUSEHANDLER(_to) \
  NS_IMETHOD Pause(nsIActivityProcess *aActivity, nsresult *_retval) override { return _to Pause(aActivity, _retval); } \
  NS_IMETHOD Resume(nsIActivityProcess *aActivity, nsresult *_retval) override { return _to Resume(aActivity, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYPAUSEHANDLER(_to) \
  NS_IMETHOD Pause(nsIActivityProcess *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Pause(aActivity, _retval); } \
  NS_IMETHOD Resume(nsIActivityProcess *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Resume(aActivity, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityPauseHandler : public nsIActivityPauseHandler
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYPAUSEHANDLER

  nsActivityPauseHandler();

private:
  ~nsActivityPauseHandler();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityPauseHandler, nsIActivityPauseHandler)

nsActivityPauseHandler::nsActivityPauseHandler()
{
  /* member initializers and constructor code */
}

nsActivityPauseHandler::~nsActivityPauseHandler()
{
  /* destructor code */
}

/* nsresult pause (in nsIActivityProcess aActivity); */
NS_IMETHODIMP nsActivityPauseHandler::Pause(nsIActivityProcess *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsresult resume (in nsIActivityProcess aActivity); */
NS_IMETHODIMP nsActivityPauseHandler::Resume(nsIActivityProcess *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityRetryHandler */
#define NS_IACTIVITYRETRYHANDLER_IID_STR "8ec42517-951f-4bc0-aba5-fde7258b1705"

#define NS_IACTIVITYRETRYHANDLER_IID \
  {0x8ec42517, 0x951f, 0x4bc0, \
    { 0xab, 0xa5, 0xfd, 0xe7, 0x25, 0x8b, 0x17, 0x05 }}

class NS_NO_VTABLE nsIActivityRetryHandler : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYRETRYHANDLER_IID)

  /* nsresult retry (in nsIActivityProcess aActivity); */
  NS_IMETHOD Retry(nsIActivityProcess *aActivity, nsresult *_retval) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityRetryHandler, NS_IACTIVITYRETRYHANDLER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYRETRYHANDLER \
  NS_IMETHOD Retry(nsIActivityProcess *aActivity, nsresult *_retval) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYRETRYHANDLER \
  NS_METHOD Retry(nsIActivityProcess *aActivity, nsresult *_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYRETRYHANDLER(_to) \
  NS_IMETHOD Retry(nsIActivityProcess *aActivity, nsresult *_retval) override { return _to Retry(aActivity, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYRETRYHANDLER(_to) \
  NS_IMETHOD Retry(nsIActivityProcess *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Retry(aActivity, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityRetryHandler : public nsIActivityRetryHandler
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYRETRYHANDLER

  nsActivityRetryHandler();

private:
  ~nsActivityRetryHandler();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityRetryHandler, nsIActivityRetryHandler)

nsActivityRetryHandler::nsActivityRetryHandler()
{
  /* member initializers and constructor code */
}

nsActivityRetryHandler::~nsActivityRetryHandler()
{
  /* destructor code */
}

/* nsresult retry (in nsIActivityProcess aActivity); */
NS_IMETHODIMP nsActivityRetryHandler::Retry(nsIActivityProcess *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityUndoHandler */
#define NS_IACTIVITYUNDOHANDLER_IID_STR "b8632ac7-9d8b-4341-a349-ef000e8c89ac"

#define NS_IACTIVITYUNDOHANDLER_IID \
  {0xb8632ac7, 0x9d8b, 0x4341, \
    { 0xa3, 0x49, 0xef, 0x00, 0x0e, 0x8c, 0x89, 0xac }}

class NS_NO_VTABLE nsIActivityUndoHandler : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYUNDOHANDLER_IID)

  /* nsresult undo (in nsIActivityEvent aActivity); */
  NS_IMETHOD Undo(nsIActivityEvent *aActivity, nsresult *_retval) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityUndoHandler, NS_IACTIVITYUNDOHANDLER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYUNDOHANDLER \
  NS_IMETHOD Undo(nsIActivityEvent *aActivity, nsresult *_retval) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYUNDOHANDLER \
  NS_METHOD Undo(nsIActivityEvent *aActivity, nsresult *_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYUNDOHANDLER(_to) \
  NS_IMETHOD Undo(nsIActivityEvent *aActivity, nsresult *_retval) override { return _to Undo(aActivity, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYUNDOHANDLER(_to) \
  NS_IMETHOD Undo(nsIActivityEvent *aActivity, nsresult *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Undo(aActivity, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityUndoHandler : public nsIActivityUndoHandler
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYUNDOHANDLER

  nsActivityUndoHandler();

private:
  ~nsActivityUndoHandler();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityUndoHandler, nsIActivityUndoHandler)

nsActivityUndoHandler::nsActivityUndoHandler()
{
  /* member initializers and constructor code */
}

nsActivityUndoHandler::~nsActivityUndoHandler()
{
  /* destructor code */
}

/* nsresult undo (in nsIActivityEvent aActivity); */
NS_IMETHODIMP nsActivityUndoHandler::Undo(nsIActivityEvent *aActivity, nsresult *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivity */
#define NS_IACTIVITY_IID_STR "6cd33e65-b2d8-4634-9b6d-b80bf1273e99"

#define NS_IACTIVITY_IID \
  {0x6cd33e65, 0xb2d8, 0x4634, \
    { 0x9b, 0x6d, 0xb8, 0x0b, 0xf1, 0x27, 0x3e, 0x99 }}

class NS_NO_VTABLE nsIActivity : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITY_IID)

  enum {
    GROUPING_STYLE_STANDALONE = 1,
    GROUPING_STYLE_BYCONTEXT = 2
  };

  /* attribute unsigned long id; */
  NS_IMETHOD GetId(uint32_t *aId) = 0;
  NS_IMETHOD SetId(uint32_t aId) = 0;

  /* readonly attribute AString displayText; */
  NS_IMETHOD GetDisplayText(nsAString & aDisplayText) = 0;

  /* attribute AString iconClass; */
  NS_IMETHOD GetIconClass(nsAString & aIconClass) = 0;
  NS_IMETHOD SetIconClass(const nsAString & aIconClass) = 0;

  /* attribute AString bindingName; */
  NS_IMETHOD GetBindingName(nsAString & aBindingName) = 0;
  NS_IMETHOD SetBindingName(const nsAString & aBindingName) = 0;

  /* attribute short groupingStyle; */
  NS_IMETHOD GetGroupingStyle(int16_t *aGroupingStyle) = 0;
  NS_IMETHOD SetGroupingStyle(int16_t aGroupingStyle) = 0;

  /* attribute AString facet; */
  NS_IMETHOD GetFacet(nsAString & aFacet) = 0;
  NS_IMETHOD SetFacet(const nsAString & aFacet) = 0;

  /* readonly attribute nsIVariant initiator; */
  NS_IMETHOD GetInitiator(nsIVariant * *aInitiator) = 0;

  /* void addSubject (in nsIVariant aSubject); */
  NS_IMETHOD AddSubject(nsIVariant *aSubject) = 0;

  /* void getSubjects (out unsigned long length, [array, size_is (length), retval] out nsIVariant aSubjects); */
  NS_IMETHOD GetSubjects(uint32_t *length, nsIVariant * **aSubjects) = 0;

  /* attribute nsIVariant contextObj; */
  NS_IMETHOD GetContextObj(nsIVariant * *aContextObj) = 0;
  NS_IMETHOD SetContextObj(nsIVariant *aContextObj) = 0;

  /* attribute AString contextType; */
  NS_IMETHOD GetContextType(nsAString & aContextType) = 0;
  NS_IMETHOD SetContextType(const nsAString & aContextType) = 0;

  /* attribute AString contextDisplayText; */
  NS_IMETHOD GetContextDisplayText(nsAString & aContextDisplayText) = 0;
  NS_IMETHOD SetContextDisplayText(const nsAString & aContextDisplayText) = 0;

  /* void addListener (in nsIActivityListener aListener); */
  NS_IMETHOD AddListener(nsIActivityListener *aListener) = 0;

  /* void removeListener (in nsIActivityListener aListener); */
  NS_IMETHOD RemoveListener(nsIActivityListener *aListener) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivity, NS_IACTIVITY_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITY \
  NS_IMETHOD GetId(uint32_t *aId) override; \
  NS_IMETHOD SetId(uint32_t aId) override; \
  NS_IMETHOD GetDisplayText(nsAString & aDisplayText) override; \
  NS_IMETHOD GetIconClass(nsAString & aIconClass) override; \
  NS_IMETHOD SetIconClass(const nsAString & aIconClass) override; \
  NS_IMETHOD GetBindingName(nsAString & aBindingName) override; \
  NS_IMETHOD SetBindingName(const nsAString & aBindingName) override; \
  NS_IMETHOD GetGroupingStyle(int16_t *aGroupingStyle) override; \
  NS_IMETHOD SetGroupingStyle(int16_t aGroupingStyle) override; \
  NS_IMETHOD GetFacet(nsAString & aFacet) override; \
  NS_IMETHOD SetFacet(const nsAString & aFacet) override; \
  NS_IMETHOD GetInitiator(nsIVariant * *aInitiator) override; \
  NS_IMETHOD AddSubject(nsIVariant *aSubject) override; \
  NS_IMETHOD GetSubjects(uint32_t *length, nsIVariant * **aSubjects) override; \
  NS_IMETHOD GetContextObj(nsIVariant * *aContextObj) override; \
  NS_IMETHOD SetContextObj(nsIVariant *aContextObj) override; \
  NS_IMETHOD GetContextType(nsAString & aContextType) override; \
  NS_IMETHOD SetContextType(const nsAString & aContextType) override; \
  NS_IMETHOD GetContextDisplayText(nsAString & aContextDisplayText) override; \
  NS_IMETHOD SetContextDisplayText(const nsAString & aContextDisplayText) override; \
  NS_IMETHOD AddListener(nsIActivityListener *aListener) override; \
  NS_IMETHOD RemoveListener(nsIActivityListener *aListener) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITY \
  NS_METHOD GetId(uint32_t *aId); \
  NS_METHOD SetId(uint32_t aId); \
  NS_METHOD GetDisplayText(nsAString & aDisplayText); \
  NS_METHOD GetIconClass(nsAString & aIconClass); \
  NS_METHOD SetIconClass(const nsAString & aIconClass); \
  NS_METHOD GetBindingName(nsAString & aBindingName); \
  NS_METHOD SetBindingName(const nsAString & aBindingName); \
  NS_METHOD GetGroupingStyle(int16_t *aGroupingStyle); \
  NS_METHOD SetGroupingStyle(int16_t aGroupingStyle); \
  NS_METHOD GetFacet(nsAString & aFacet); \
  NS_METHOD SetFacet(const nsAString & aFacet); \
  NS_METHOD GetInitiator(nsIVariant * *aInitiator); \
  NS_METHOD AddSubject(nsIVariant *aSubject); \
  NS_METHOD GetSubjects(uint32_t *length, nsIVariant * **aSubjects); \
  NS_METHOD GetContextObj(nsIVariant * *aContextObj); \
  NS_METHOD SetContextObj(nsIVariant *aContextObj); \
  NS_METHOD GetContextType(nsAString & aContextType); \
  NS_METHOD SetContextType(const nsAString & aContextType); \
  NS_METHOD GetContextDisplayText(nsAString & aContextDisplayText); \
  NS_METHOD SetContextDisplayText(const nsAString & aContextDisplayText); \
  NS_METHOD AddListener(nsIActivityListener *aListener); \
  NS_METHOD RemoveListener(nsIActivityListener *aListener); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITY(_to) \
  NS_IMETHOD GetId(uint32_t *aId) override { return _to GetId(aId); } \
  NS_IMETHOD SetId(uint32_t aId) override { return _to SetId(aId); } \
  NS_IMETHOD GetDisplayText(nsAString & aDisplayText) override { return _to GetDisplayText(aDisplayText); } \
  NS_IMETHOD GetIconClass(nsAString & aIconClass) override { return _to GetIconClass(aIconClass); } \
  NS_IMETHOD SetIconClass(const nsAString & aIconClass) override { return _to SetIconClass(aIconClass); } \
  NS_IMETHOD GetBindingName(nsAString & aBindingName) override { return _to GetBindingName(aBindingName); } \
  NS_IMETHOD SetBindingName(const nsAString & aBindingName) override { return _to SetBindingName(aBindingName); } \
  NS_IMETHOD GetGroupingStyle(int16_t *aGroupingStyle) override { return _to GetGroupingStyle(aGroupingStyle); } \
  NS_IMETHOD SetGroupingStyle(int16_t aGroupingStyle) override { return _to SetGroupingStyle(aGroupingStyle); } \
  NS_IMETHOD GetFacet(nsAString & aFacet) override { return _to GetFacet(aFacet); } \
  NS_IMETHOD SetFacet(const nsAString & aFacet) override { return _to SetFacet(aFacet); } \
  NS_IMETHOD GetInitiator(nsIVariant * *aInitiator) override { return _to GetInitiator(aInitiator); } \
  NS_IMETHOD AddSubject(nsIVariant *aSubject) override { return _to AddSubject(aSubject); } \
  NS_IMETHOD GetSubjects(uint32_t *length, nsIVariant * **aSubjects) override { return _to GetSubjects(length, aSubjects); } \
  NS_IMETHOD GetContextObj(nsIVariant * *aContextObj) override { return _to GetContextObj(aContextObj); } \
  NS_IMETHOD SetContextObj(nsIVariant *aContextObj) override { return _to SetContextObj(aContextObj); } \
  NS_IMETHOD GetContextType(nsAString & aContextType) override { return _to GetContextType(aContextType); } \
  NS_IMETHOD SetContextType(const nsAString & aContextType) override { return _to SetContextType(aContextType); } \
  NS_IMETHOD GetContextDisplayText(nsAString & aContextDisplayText) override { return _to GetContextDisplayText(aContextDisplayText); } \
  NS_IMETHOD SetContextDisplayText(const nsAString & aContextDisplayText) override { return _to SetContextDisplayText(aContextDisplayText); } \
  NS_IMETHOD AddListener(nsIActivityListener *aListener) override { return _to AddListener(aListener); } \
  NS_IMETHOD RemoveListener(nsIActivityListener *aListener) override { return _to RemoveListener(aListener); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITY(_to) \
  NS_IMETHOD GetId(uint32_t *aId) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_IMETHOD SetId(uint32_t aId) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_IMETHOD GetDisplayText(nsAString & aDisplayText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDisplayText(aDisplayText); } \
  NS_IMETHOD GetIconClass(nsAString & aIconClass) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIconClass(aIconClass); } \
  NS_IMETHOD SetIconClass(const nsAString & aIconClass) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIconClass(aIconClass); } \
  NS_IMETHOD GetBindingName(nsAString & aBindingName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBindingName(aBindingName); } \
  NS_IMETHOD SetBindingName(const nsAString & aBindingName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetBindingName(aBindingName); } \
  NS_IMETHOD GetGroupingStyle(int16_t *aGroupingStyle) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetGroupingStyle(aGroupingStyle); } \
  NS_IMETHOD SetGroupingStyle(int16_t aGroupingStyle) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetGroupingStyle(aGroupingStyle); } \
  NS_IMETHOD GetFacet(nsAString & aFacet) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFacet(aFacet); } \
  NS_IMETHOD SetFacet(const nsAString & aFacet) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFacet(aFacet); } \
  NS_IMETHOD GetInitiator(nsIVariant * *aInitiator) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInitiator(aInitiator); } \
  NS_IMETHOD AddSubject(nsIVariant *aSubject) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AddSubject(aSubject); } \
  NS_IMETHOD GetSubjects(uint32_t *length, nsIVariant * **aSubjects) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSubjects(length, aSubjects); } \
  NS_IMETHOD GetContextObj(nsIVariant * *aContextObj) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContextObj(aContextObj); } \
  NS_IMETHOD SetContextObj(nsIVariant *aContextObj) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContextObj(aContextObj); } \
  NS_IMETHOD GetContextType(nsAString & aContextType) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContextType(aContextType); } \
  NS_IMETHOD SetContextType(const nsAString & aContextType) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContextType(aContextType); } \
  NS_IMETHOD GetContextDisplayText(nsAString & aContextDisplayText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContextDisplayText(aContextDisplayText); } \
  NS_IMETHOD SetContextDisplayText(const nsAString & aContextDisplayText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetContextDisplayText(aContextDisplayText); } \
  NS_IMETHOD AddListener(nsIActivityListener *aListener) override { return !_to ? NS_ERROR_NULL_POINTER : _to->AddListener(aListener); } \
  NS_IMETHOD RemoveListener(nsIActivityListener *aListener) override { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveListener(aListener); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivity : public nsIActivity
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITY

  nsActivity();

private:
  ~nsActivity();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivity, nsIActivity)

nsActivity::nsActivity()
{
  /* member initializers and constructor code */
}

nsActivity::~nsActivity()
{
  /* destructor code */
}

/* attribute unsigned long id; */
NS_IMETHODIMP nsActivity::GetId(uint32_t *aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetId(uint32_t aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString displayText; */
NS_IMETHODIMP nsActivity::GetDisplayText(nsAString & aDisplayText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString iconClass; */
NS_IMETHODIMP nsActivity::GetIconClass(nsAString & aIconClass)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetIconClass(const nsAString & aIconClass)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString bindingName; */
NS_IMETHODIMP nsActivity::GetBindingName(nsAString & aBindingName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetBindingName(const nsAString & aBindingName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute short groupingStyle; */
NS_IMETHODIMP nsActivity::GetGroupingStyle(int16_t *aGroupingStyle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetGroupingStyle(int16_t aGroupingStyle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString facet; */
NS_IMETHODIMP nsActivity::GetFacet(nsAString & aFacet)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetFacet(const nsAString & aFacet)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute nsIVariant initiator; */
NS_IMETHODIMP nsActivity::GetInitiator(nsIVariant * *aInitiator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addSubject (in nsIVariant aSubject); */
NS_IMETHODIMP nsActivity::AddSubject(nsIVariant *aSubject)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getSubjects (out unsigned long length, [array, size_is (length), retval] out nsIVariant aSubjects); */
NS_IMETHODIMP nsActivity::GetSubjects(uint32_t *length, nsIVariant * **aSubjects)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIVariant contextObj; */
NS_IMETHODIMP nsActivity::GetContextObj(nsIVariant * *aContextObj)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetContextObj(nsIVariant *aContextObj)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString contextType; */
NS_IMETHODIMP nsActivity::GetContextType(nsAString & aContextType)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetContextType(const nsAString & aContextType)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString contextDisplayText; */
NS_IMETHODIMP nsActivity::GetContextDisplayText(nsAString & aContextDisplayText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivity::SetContextDisplayText(const nsAString & aContextDisplayText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addListener (in nsIActivityListener aListener); */
NS_IMETHODIMP nsActivity::AddListener(nsIActivityListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeListener (in nsIActivityListener aListener); */
NS_IMETHODIMP nsActivity::RemoveListener(nsIActivityListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityProcess */
#define NS_IACTIVITYPROCESS_IID_STR "9dc7ca67-828d-4afd-a5c6-3ece091a98b8"

#define NS_IACTIVITYPROCESS_IID \
  {0x9dc7ca67, 0x828d, 0x4afd, \
    { 0xa5, 0xc6, 0x3e, 0xce, 0x09, 0x1a, 0x98, 0xb8 }}

class NS_NO_VTABLE nsIActivityProcess : public nsIActivity {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYPROCESS_IID)

  enum {
    STATE_NOTSTARTED = -1,
    STATE_INPROGRESS = 0,
    STATE_COMPLETED = 1,
    STATE_CANCELED = 2,
    STATE_PAUSED = 3,
    STATE_WAITINGFORINPUT = 4,
    STATE_WAITINGFORRETRY = 5
  };

  /* attribute short state; */
  NS_IMETHOD GetState(int16_t *aState) = 0;
  NS_IMETHOD SetState(int16_t aState) = 0;

  /* readonly attribute long percentComplete; */
  NS_IMETHOD GetPercentComplete(int32_t *aPercentComplete) = 0;

  /* readonly attribute AString lastStatusText; */
  NS_IMETHOD GetLastStatusText(nsAString & aLastStatusText) = 0;

  /* readonly attribute unsigned long workUnitComplete; */
  NS_IMETHOD GetWorkUnitComplete(uint32_t *aWorkUnitComplete) = 0;

  /* readonly attribute unsigned long totalWorkUnits; */
  NS_IMETHOD GetTotalWorkUnits(uint32_t *aTotalWorkUnits) = 0;

  /* readonly attribute long long startTime; */
  NS_IMETHOD GetStartTime(int64_t *aStartTime) = 0;

  /* attribute nsIActivityCancelHandler cancelHandler; */
  NS_IMETHOD GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler) = 0;
  NS_IMETHOD SetCancelHandler(nsIActivityCancelHandler *aCancelHandler) = 0;

  /* attribute nsIActivityPauseHandler pauseHandler; */
  NS_IMETHOD GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler) = 0;
  NS_IMETHOD SetPauseHandler(nsIActivityPauseHandler *aPauseHandler) = 0;

  /* attribute nsIActivityRetryHandler retryHandler; */
  NS_IMETHOD GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler) = 0;
  NS_IMETHOD SetRetryHandler(nsIActivityRetryHandler *aRetryHandler) = 0;

  /* void setProgress (in AString aStatusText, in unsigned long aWorkUnitComplete, in unsigned long aTotalWorkUnits); */
  NS_IMETHOD SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits) = 0;

  /* void init (in AString aDisplayText, in nsIVariant aInitiator); */
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityProcess, NS_IACTIVITYPROCESS_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYPROCESS \
  NS_IMETHOD GetState(int16_t *aState) override; \
  NS_IMETHOD SetState(int16_t aState) override; \
  NS_IMETHOD GetPercentComplete(int32_t *aPercentComplete) override; \
  NS_IMETHOD GetLastStatusText(nsAString & aLastStatusText) override; \
  NS_IMETHOD GetWorkUnitComplete(uint32_t *aWorkUnitComplete) override; \
  NS_IMETHOD GetTotalWorkUnits(uint32_t *aTotalWorkUnits) override; \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override; \
  NS_IMETHOD GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler) override; \
  NS_IMETHOD SetCancelHandler(nsIActivityCancelHandler *aCancelHandler) override; \
  NS_IMETHOD GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler) override; \
  NS_IMETHOD SetPauseHandler(nsIActivityPauseHandler *aPauseHandler) override; \
  NS_IMETHOD GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler) override; \
  NS_IMETHOD SetRetryHandler(nsIActivityRetryHandler *aRetryHandler) override; \
  NS_IMETHOD SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits) override; \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYPROCESS \
  NS_METHOD GetState(int16_t *aState); \
  NS_METHOD SetState(int16_t aState); \
  NS_METHOD GetPercentComplete(int32_t *aPercentComplete); \
  NS_METHOD GetLastStatusText(nsAString & aLastStatusText); \
  NS_METHOD GetWorkUnitComplete(uint32_t *aWorkUnitComplete); \
  NS_METHOD GetTotalWorkUnits(uint32_t *aTotalWorkUnits); \
  NS_METHOD GetStartTime(int64_t *aStartTime); \
  NS_METHOD GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler); \
  NS_METHOD SetCancelHandler(nsIActivityCancelHandler *aCancelHandler); \
  NS_METHOD GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler); \
  NS_METHOD SetPauseHandler(nsIActivityPauseHandler *aPauseHandler); \
  NS_METHOD GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler); \
  NS_METHOD SetRetryHandler(nsIActivityRetryHandler *aRetryHandler); \
  NS_METHOD SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits); \
  NS_METHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYPROCESS(_to) \
  NS_IMETHOD GetState(int16_t *aState) override { return _to GetState(aState); } \
  NS_IMETHOD SetState(int16_t aState) override { return _to SetState(aState); } \
  NS_IMETHOD GetPercentComplete(int32_t *aPercentComplete) override { return _to GetPercentComplete(aPercentComplete); } \
  NS_IMETHOD GetLastStatusText(nsAString & aLastStatusText) override { return _to GetLastStatusText(aLastStatusText); } \
  NS_IMETHOD GetWorkUnitComplete(uint32_t *aWorkUnitComplete) override { return _to GetWorkUnitComplete(aWorkUnitComplete); } \
  NS_IMETHOD GetTotalWorkUnits(uint32_t *aTotalWorkUnits) override { return _to GetTotalWorkUnits(aTotalWorkUnits); } \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override { return _to GetStartTime(aStartTime); } \
  NS_IMETHOD GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler) override { return _to GetCancelHandler(aCancelHandler); } \
  NS_IMETHOD SetCancelHandler(nsIActivityCancelHandler *aCancelHandler) override { return _to SetCancelHandler(aCancelHandler); } \
  NS_IMETHOD GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler) override { return _to GetPauseHandler(aPauseHandler); } \
  NS_IMETHOD SetPauseHandler(nsIActivityPauseHandler *aPauseHandler) override { return _to SetPauseHandler(aPauseHandler); } \
  NS_IMETHOD GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler) override { return _to GetRetryHandler(aRetryHandler); } \
  NS_IMETHOD SetRetryHandler(nsIActivityRetryHandler *aRetryHandler) override { return _to SetRetryHandler(aRetryHandler); } \
  NS_IMETHOD SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits) override { return _to SetProgress(aStatusText, aWorkUnitComplete, aTotalWorkUnits); } \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator) override { return _to Init(aDisplayText, aInitiator); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYPROCESS(_to) \
  NS_IMETHOD GetState(int16_t *aState) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetState(aState); } \
  NS_IMETHOD SetState(int16_t aState) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetState(aState); } \
  NS_IMETHOD GetPercentComplete(int32_t *aPercentComplete) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPercentComplete(aPercentComplete); } \
  NS_IMETHOD GetLastStatusText(nsAString & aLastStatusText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLastStatusText(aLastStatusText); } \
  NS_IMETHOD GetWorkUnitComplete(uint32_t *aWorkUnitComplete) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWorkUnitComplete(aWorkUnitComplete); } \
  NS_IMETHOD GetTotalWorkUnits(uint32_t *aTotalWorkUnits) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTotalWorkUnits(aTotalWorkUnits); } \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStartTime(aStartTime); } \
  NS_IMETHOD GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCancelHandler(aCancelHandler); } \
  NS_IMETHOD SetCancelHandler(nsIActivityCancelHandler *aCancelHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetCancelHandler(aCancelHandler); } \
  NS_IMETHOD GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPauseHandler(aPauseHandler); } \
  NS_IMETHOD SetPauseHandler(nsIActivityPauseHandler *aPauseHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPauseHandler(aPauseHandler); } \
  NS_IMETHOD GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRetryHandler(aRetryHandler); } \
  NS_IMETHOD SetRetryHandler(nsIActivityRetryHandler *aRetryHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRetryHandler(aRetryHandler); } \
  NS_IMETHOD SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetProgress(aStatusText, aWorkUnitComplete, aTotalWorkUnits); } \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aDisplayText, aInitiator); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityProcess : public nsIActivityProcess
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYPROCESS

  nsActivityProcess();

private:
  ~nsActivityProcess();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityProcess, nsIActivityProcess)

nsActivityProcess::nsActivityProcess()
{
  /* member initializers and constructor code */
}

nsActivityProcess::~nsActivityProcess()
{
  /* destructor code */
}

/* attribute short state; */
NS_IMETHODIMP nsActivityProcess::GetState(int16_t *aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityProcess::SetState(int16_t aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long percentComplete; */
NS_IMETHODIMP nsActivityProcess::GetPercentComplete(int32_t *aPercentComplete)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString lastStatusText; */
NS_IMETHODIMP nsActivityProcess::GetLastStatusText(nsAString & aLastStatusText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute unsigned long workUnitComplete; */
NS_IMETHODIMP nsActivityProcess::GetWorkUnitComplete(uint32_t *aWorkUnitComplete)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute unsigned long totalWorkUnits; */
NS_IMETHODIMP nsActivityProcess::GetTotalWorkUnits(uint32_t *aTotalWorkUnits)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long long startTime; */
NS_IMETHODIMP nsActivityProcess::GetStartTime(int64_t *aStartTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIActivityCancelHandler cancelHandler; */
NS_IMETHODIMP nsActivityProcess::GetCancelHandler(nsIActivityCancelHandler * *aCancelHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityProcess::SetCancelHandler(nsIActivityCancelHandler *aCancelHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIActivityPauseHandler pauseHandler; */
NS_IMETHODIMP nsActivityProcess::GetPauseHandler(nsIActivityPauseHandler * *aPauseHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityProcess::SetPauseHandler(nsIActivityPauseHandler *aPauseHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIActivityRetryHandler retryHandler; */
NS_IMETHODIMP nsActivityProcess::GetRetryHandler(nsIActivityRetryHandler * *aRetryHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityProcess::SetRetryHandler(nsIActivityRetryHandler *aRetryHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setProgress (in AString aStatusText, in unsigned long aWorkUnitComplete, in unsigned long aTotalWorkUnits); */
NS_IMETHODIMP nsActivityProcess::SetProgress(const nsAString & aStatusText, uint32_t aWorkUnitComplete, uint32_t aTotalWorkUnits)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void init (in AString aDisplayText, in nsIVariant aInitiator); */
NS_IMETHODIMP nsActivityProcess::Init(const nsAString & aDisplayText, nsIVariant *aInitiator)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityEvent */
#define NS_IACTIVITYEVENT_IID_STR "5b1b0d03-2820-4e37-8bf8-102afde4fc45"

#define NS_IACTIVITYEVENT_IID \
  {0x5b1b0d03, 0x2820, 0x4e37, \
    { 0x8b, 0xf8, 0x10, 0x2a, 0xfd, 0xe4, 0xfc, 0x45 }}

class NS_NO_VTABLE nsIActivityEvent : public nsIActivity {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYEVENT_IID)

  /* readonly attribute AString statusText; */
  NS_IMETHOD GetStatusText(nsAString & aStatusText) = 0;

  /* readonly attribute long long startTime; */
  NS_IMETHOD GetStartTime(int64_t *aStartTime) = 0;

  /* readonly attribute long long completionTime; */
  NS_IMETHOD GetCompletionTime(int64_t *aCompletionTime) = 0;

  /* attribute nsIActivityUndoHandler undoHandler; */
  NS_IMETHOD GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler) = 0;
  NS_IMETHOD SetUndoHandler(nsIActivityUndoHandler *aUndoHandler) = 0;

  /* void init (in AString aDisplayText, in nsIVariant aInitiator, in AString aStatusText, in long long aStartTime, in long long aCompletionTime); */
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityEvent, NS_IACTIVITYEVENT_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYEVENT \
  NS_IMETHOD GetStatusText(nsAString & aStatusText) override; \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override; \
  NS_IMETHOD GetCompletionTime(int64_t *aCompletionTime) override; \
  NS_IMETHOD GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler) override; \
  NS_IMETHOD SetUndoHandler(nsIActivityUndoHandler *aUndoHandler) override; \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYEVENT \
  NS_METHOD GetStatusText(nsAString & aStatusText); \
  NS_METHOD GetStartTime(int64_t *aStartTime); \
  NS_METHOD GetCompletionTime(int64_t *aCompletionTime); \
  NS_METHOD GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler); \
  NS_METHOD SetUndoHandler(nsIActivityUndoHandler *aUndoHandler); \
  NS_METHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYEVENT(_to) \
  NS_IMETHOD GetStatusText(nsAString & aStatusText) override { return _to GetStatusText(aStatusText); } \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override { return _to GetStartTime(aStartTime); } \
  NS_IMETHOD GetCompletionTime(int64_t *aCompletionTime) override { return _to GetCompletionTime(aCompletionTime); } \
  NS_IMETHOD GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler) override { return _to GetUndoHandler(aUndoHandler); } \
  NS_IMETHOD SetUndoHandler(nsIActivityUndoHandler *aUndoHandler) override { return _to SetUndoHandler(aUndoHandler); } \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime) override { return _to Init(aDisplayText, aInitiator, aStatusText, aStartTime, aCompletionTime); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYEVENT(_to) \
  NS_IMETHOD GetStatusText(nsAString & aStatusText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStatusText(aStatusText); } \
  NS_IMETHOD GetStartTime(int64_t *aStartTime) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStartTime(aStartTime); } \
  NS_IMETHOD GetCompletionTime(int64_t *aCompletionTime) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCompletionTime(aCompletionTime); } \
  NS_IMETHOD GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUndoHandler(aUndoHandler); } \
  NS_IMETHOD SetUndoHandler(nsIActivityUndoHandler *aUndoHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetUndoHandler(aUndoHandler); } \
  NS_IMETHOD Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aDisplayText, aInitiator, aStatusText, aStartTime, aCompletionTime); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityEvent : public nsIActivityEvent
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYEVENT

  nsActivityEvent();

private:
  ~nsActivityEvent();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityEvent, nsIActivityEvent)

nsActivityEvent::nsActivityEvent()
{
  /* member initializers and constructor code */
}

nsActivityEvent::~nsActivityEvent()
{
  /* destructor code */
}

/* readonly attribute AString statusText; */
NS_IMETHODIMP nsActivityEvent::GetStatusText(nsAString & aStatusText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long long startTime; */
NS_IMETHODIMP nsActivityEvent::GetStartTime(int64_t *aStartTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long long completionTime; */
NS_IMETHODIMP nsActivityEvent::GetCompletionTime(int64_t *aCompletionTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIActivityUndoHandler undoHandler; */
NS_IMETHODIMP nsActivityEvent::GetUndoHandler(nsIActivityUndoHandler * *aUndoHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityEvent::SetUndoHandler(nsIActivityUndoHandler *aUndoHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void init (in AString aDisplayText, in nsIVariant aInitiator, in AString aStatusText, in long long aStartTime, in long long aCompletionTime); */
NS_IMETHODIMP nsActivityEvent::Init(const nsAString & aDisplayText, nsIVariant *aInitiator, const nsAString & aStatusText, int64_t aStartTime, int64_t aCompletionTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityWarning */
#define NS_IACTIVITYWARNING_IID_STR "8265833e-c604-4585-a43c-a76bd8ed3a8c"

#define NS_IACTIVITYWARNING_IID \
  {0x8265833e, 0xc604, 0x4585, \
    { 0xa4, 0x3c, 0xa7, 0x6b, 0xd8, 0xed, 0x3a, 0x8c }}

class NS_NO_VTABLE nsIActivityWarning : public nsIActivity {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYWARNING_IID)

  /* readonly attribute AString warningText; */
  NS_IMETHOD GetWarningText(nsAString & aWarningText) = 0;

  /* readonly attribute long long time; */
  NS_IMETHOD GetTime(int64_t *aTime) = 0;

  /* readonly attribute AString recoveryTipText; */
  NS_IMETHOD GetRecoveryTipText(nsAString & aRecoveryTipText) = 0;

  /* attribute nsIActivityRecoveryHandler recoveryHandler; */
  NS_IMETHOD GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler) = 0;
  NS_IMETHOD SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler) = 0;

  /* void init (in AString aWarningText, in nsIVariant aInitiator, in AString aRecoveryTip); */
  NS_IMETHOD Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityWarning, NS_IACTIVITYWARNING_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYWARNING \
  NS_IMETHOD GetWarningText(nsAString & aWarningText) override; \
  NS_IMETHOD GetTime(int64_t *aTime) override; \
  NS_IMETHOD GetRecoveryTipText(nsAString & aRecoveryTipText) override; \
  NS_IMETHOD GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler) override; \
  NS_IMETHOD SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler) override; \
  NS_IMETHOD Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYWARNING \
  NS_METHOD GetWarningText(nsAString & aWarningText); \
  NS_METHOD GetTime(int64_t *aTime); \
  NS_METHOD GetRecoveryTipText(nsAString & aRecoveryTipText); \
  NS_METHOD GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler); \
  NS_METHOD SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler); \
  NS_METHOD Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYWARNING(_to) \
  NS_IMETHOD GetWarningText(nsAString & aWarningText) override { return _to GetWarningText(aWarningText); } \
  NS_IMETHOD GetTime(int64_t *aTime) override { return _to GetTime(aTime); } \
  NS_IMETHOD GetRecoveryTipText(nsAString & aRecoveryTipText) override { return _to GetRecoveryTipText(aRecoveryTipText); } \
  NS_IMETHOD GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler) override { return _to GetRecoveryHandler(aRecoveryHandler); } \
  NS_IMETHOD SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler) override { return _to SetRecoveryHandler(aRecoveryHandler); } \
  NS_IMETHOD Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip) override { return _to Init(aWarningText, aInitiator, aRecoveryTip); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYWARNING(_to) \
  NS_IMETHOD GetWarningText(nsAString & aWarningText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWarningText(aWarningText); } \
  NS_IMETHOD GetTime(int64_t *aTime) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTime(aTime); } \
  NS_IMETHOD GetRecoveryTipText(nsAString & aRecoveryTipText) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRecoveryTipText(aRecoveryTipText); } \
  NS_IMETHOD GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRecoveryHandler(aRecoveryHandler); } \
  NS_IMETHOD SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRecoveryHandler(aRecoveryHandler); } \
  NS_IMETHOD Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip) override { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aWarningText, aInitiator, aRecoveryTip); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityWarning : public nsIActivityWarning
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYWARNING

  nsActivityWarning();

private:
  ~nsActivityWarning();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityWarning, nsIActivityWarning)

nsActivityWarning::nsActivityWarning()
{
  /* member initializers and constructor code */
}

nsActivityWarning::~nsActivityWarning()
{
  /* destructor code */
}

/* readonly attribute AString warningText; */
NS_IMETHODIMP nsActivityWarning::GetWarningText(nsAString & aWarningText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long long time; */
NS_IMETHODIMP nsActivityWarning::GetTime(int64_t *aTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString recoveryTipText; */
NS_IMETHODIMP nsActivityWarning::GetRecoveryTipText(nsAString & aRecoveryTipText)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsIActivityRecoveryHandler recoveryHandler; */
NS_IMETHODIMP nsActivityWarning::GetRecoveryHandler(nsIActivityRecoveryHandler * *aRecoveryHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsActivityWarning::SetRecoveryHandler(nsIActivityRecoveryHandler *aRecoveryHandler)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void init (in AString aWarningText, in nsIVariant aInitiator, in AString aRecoveryTip); */
NS_IMETHODIMP nsActivityWarning::Init(const nsAString & aWarningText, nsIVariant *aInitiator, const nsAString & aRecoveryTip)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIActivityListener */
#define NS_IACTIVITYLISTENER_IID_STR "bd11519f-b297-4b34-a793-1861dc90d5e9"

#define NS_IACTIVITYLISTENER_IID \
  {0xbd11519f, 0xb297, 0x4b34, \
    { 0xa7, 0x93, 0x18, 0x61, 0xdc, 0x90, 0xd5, 0xe9 }}

class NS_NO_VTABLE nsIActivityListener : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACTIVITYLISTENER_IID)

  /* void onStateChanged (in nsIActivity aActivity, in short aOldState); */
  NS_IMETHOD OnStateChanged(nsIActivity *aActivity, int16_t aOldState) = 0;

  /* void onProgressChanged (in nsIActivity aActivity, in AString aStatusText, in unsigned long aWorkUnitsCompleted, in unsigned long aTotalWorkUnits); */
  NS_IMETHOD OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits) = 0;

  /* void onHandlerChanged (in nsIActivity aActivity); */
  NS_IMETHOD OnHandlerChanged(nsIActivity *aActivity) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIActivityListener, NS_IACTIVITYLISTENER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIACTIVITYLISTENER \
  NS_IMETHOD OnStateChanged(nsIActivity *aActivity, int16_t aOldState) override; \
  NS_IMETHOD OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits) override; \
  NS_IMETHOD OnHandlerChanged(nsIActivity *aActivity) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIACTIVITYLISTENER \
  NS_METHOD OnStateChanged(nsIActivity *aActivity, int16_t aOldState); \
  NS_METHOD OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits); \
  NS_METHOD OnHandlerChanged(nsIActivity *aActivity); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIACTIVITYLISTENER(_to) \
  NS_IMETHOD OnStateChanged(nsIActivity *aActivity, int16_t aOldState) override { return _to OnStateChanged(aActivity, aOldState); } \
  NS_IMETHOD OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits) override { return _to OnProgressChanged(aActivity, aStatusText, aWorkUnitsCompleted, aTotalWorkUnits); } \
  NS_IMETHOD OnHandlerChanged(nsIActivity *aActivity) override { return _to OnHandlerChanged(aActivity); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIACTIVITYLISTENER(_to) \
  NS_IMETHOD OnStateChanged(nsIActivity *aActivity, int16_t aOldState) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnStateChanged(aActivity, aOldState); } \
  NS_IMETHOD OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnProgressChanged(aActivity, aStatusText, aWorkUnitsCompleted, aTotalWorkUnits); } \
  NS_IMETHOD OnHandlerChanged(nsIActivity *aActivity) override { return !_to ? NS_ERROR_NULL_POINTER : _to->OnHandlerChanged(aActivity); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsActivityListener : public nsIActivityListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIACTIVITYLISTENER

  nsActivityListener();

private:
  ~nsActivityListener();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsActivityListener, nsIActivityListener)

nsActivityListener::nsActivityListener()
{
  /* member initializers and constructor code */
}

nsActivityListener::~nsActivityListener()
{
  /* destructor code */
}

/* void onStateChanged (in nsIActivity aActivity, in short aOldState); */
NS_IMETHODIMP nsActivityListener::OnStateChanged(nsIActivity *aActivity, int16_t aOldState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onProgressChanged (in nsIActivity aActivity, in AString aStatusText, in unsigned long aWorkUnitsCompleted, in unsigned long aTotalWorkUnits); */
NS_IMETHODIMP nsActivityListener::OnProgressChanged(nsIActivity *aActivity, const nsAString & aStatusText, uint32_t aWorkUnitsCompleted, uint32_t aTotalWorkUnits)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onHandlerChanged (in nsIActivity aActivity); */
NS_IMETHODIMP nsActivityListener::OnHandlerChanged(nsIActivity *aActivity)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


#endif /* __gen_nsIActivity_h__ */