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

#ifndef __gen_flockIPhotoUpload_h__
#define __gen_flockIPhotoUpload_h__


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

#ifndef __gen_nsIRDFDataSource_h__
#include "nsIRDFDataSource.h"
#endif

#ifndef __gen_nsIRDFRemoteDataSource_h__
#include "nsIRDFRemoteDataSource.h"
#endif

#ifndef __gen_nsIDOMNode_h__
#include "nsIDOMNode.h"
#endif

#ifndef __gen_nsISimpleEnumerator_h__
#include "nsISimpleEnumerator.h"
#endif

#ifndef __gen_nsIDOMDocument_h__
#include "nsIDOMDocument.h"
#endif

#ifndef __gen_flockIError_h__
#include "flockIError.h"
#endif

#ifndef __gen_flockIPoller_h__
#include "flockIPoller.h"
#endif

#ifndef __gen_nsIWritablePropertyBag2_h__
#include "nsIWritablePropertyBag2.h"
#endif

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

class flockIMediaItem; /* forward declaration */


/* starting interface:    flockIPhotoUpload */
#define FLOCKIPHOTOUPLOAD_IID_STR "416b0153-2376-4389-a199-a8a8f9069d4a"

#define FLOCKIPHOTOUPLOAD_IID \
  {0x416b0153, 0x2376, 0x4389, \
    { 0xa1, 0x99, 0xa8, 0xa8, 0xf9, 0x06, 0x9d, 0x4a }}

class NS_NO_VTABLE NS_SCRIPTABLE flockIPhotoUpload : public nsISupports {
 public: 

  NS_DECLARE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOAD_IID)

  /* attribute string id; */
  NS_SCRIPTABLE NS_IMETHOD GetId(char * *aId) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetId(const char * aId) = 0;

  /* attribute AString fileName; */
  NS_SCRIPTABLE NS_IMETHOD GetFileName(nsAString & aFileName) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetFileName(const nsAString & aFileName) = 0;

  /* attribute string originalFileSpec; */
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) = 0;

  /* attribute string originalFilePath; */
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) = 0;

  /* attribute string workingFilePath; */
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) = 0;

  /* attribute string workingFileSpec; */
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) = 0;

  /* attribute string previewFileSpec; */
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) = 0;

  /* attribute string previewFilePath; */
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) = 0;

  /* attribute string thumbFileSpec; */
  NS_SCRIPTABLE NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) = 0;

  /* attribute string thumbFilePath; */
  NS_SCRIPTABLE NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) = 0;

  /* attribute string mimetype; */
  NS_SCRIPTABLE NS_IMETHOD GetMimetype(char * *aMimetype) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetMimetype(const char * aMimetype) = 0;

  /* attribute AString title; */
  NS_SCRIPTABLE NS_IMETHOD GetTitle(nsAString & aTitle) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetTitle(const nsAString & aTitle) = 0;

  /* attribute AString tags; */
  NS_SCRIPTABLE NS_IMETHOD GetTags(nsAString & aTags) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetTags(const nsAString & aTags) = 0;

  /* attribute AString notes; */
  NS_SCRIPTABLE NS_IMETHOD GetNotes(nsAString & aNotes) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetNotes(const nsAString & aNotes) = 0;

  /* attribute AString description; */
  NS_SCRIPTABLE NS_IMETHOD GetDescription(nsAString & aDescription) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetDescription(const nsAString & aDescription) = 0;

  /* attribute AString privacy_use_batch; */
  NS_SCRIPTABLE NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) = 0;

  /* attribute string is_public; */
  NS_SCRIPTABLE NS_IMETHOD GetIs_public(char * *aIs_public) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetIs_public(const char * aIs_public) = 0;

  /* attribute string is_friend; */
  NS_SCRIPTABLE NS_IMETHOD GetIs_friend(char * *aIs_friend) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetIs_friend(const char * aIs_friend) = 0;

  /* attribute string is_family; */
  NS_SCRIPTABLE NS_IMETHOD GetIs_family(char * *aIs_family) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetIs_family(const char * aIs_family) = 0;

  /* attribute AString album; */
  NS_SCRIPTABLE NS_IMETHOD GetAlbum(nsAString & aAlbum) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetAlbum(const nsAString & aAlbum) = 0;

  /* attribute string state; */
  NS_SCRIPTABLE NS_IMETHOD GetState(char * *aState) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetState(const char * aState) = 0;

  /* attribute string rotation; */
  NS_SCRIPTABLE NS_IMETHOD GetRotation(char * *aRotation) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetRotation(const char * aRotation) = 0;

  /* attribute string crop; */
  NS_SCRIPTABLE NS_IMETHOD GetCrop(char * *aCrop) = 0;
  NS_SCRIPTABLE NS_IMETHOD SetCrop(const char * aCrop) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(flockIPhotoUpload, FLOCKIPHOTOUPLOAD_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOAD \
  NS_SCRIPTABLE NS_IMETHOD GetId(char * *aId); \
  NS_SCRIPTABLE NS_IMETHOD SetId(const char * aId); \
  NS_SCRIPTABLE NS_IMETHOD GetFileName(nsAString & aFileName); \
  NS_SCRIPTABLE NS_IMETHOD SetFileName(const nsAString & aFileName); \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath); \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath); \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath); \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath); \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath); \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath); \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec); \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath); \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath); \
  NS_SCRIPTABLE NS_IMETHOD GetMimetype(char * *aMimetype); \
  NS_SCRIPTABLE NS_IMETHOD SetMimetype(const char * aMimetype); \
  NS_SCRIPTABLE NS_IMETHOD GetTitle(nsAString & aTitle); \
  NS_SCRIPTABLE NS_IMETHOD SetTitle(const nsAString & aTitle); \
  NS_SCRIPTABLE NS_IMETHOD GetTags(nsAString & aTags); \
  NS_SCRIPTABLE NS_IMETHOD SetTags(const nsAString & aTags); \
  NS_SCRIPTABLE NS_IMETHOD GetNotes(nsAString & aNotes); \
  NS_SCRIPTABLE NS_IMETHOD SetNotes(const nsAString & aNotes); \
  NS_SCRIPTABLE NS_IMETHOD GetDescription(nsAString & aDescription); \
  NS_SCRIPTABLE NS_IMETHOD SetDescription(const nsAString & aDescription); \
  NS_SCRIPTABLE NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch); \
  NS_SCRIPTABLE NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch); \
  NS_SCRIPTABLE NS_IMETHOD GetIs_public(char * *aIs_public); \
  NS_SCRIPTABLE NS_IMETHOD SetIs_public(const char * aIs_public); \
  NS_SCRIPTABLE NS_IMETHOD GetIs_friend(char * *aIs_friend); \
  NS_SCRIPTABLE NS_IMETHOD SetIs_friend(const char * aIs_friend); \
  NS_SCRIPTABLE NS_IMETHOD GetIs_family(char * *aIs_family); \
  NS_SCRIPTABLE NS_IMETHOD SetIs_family(const char * aIs_family); \
  NS_SCRIPTABLE NS_IMETHOD GetAlbum(nsAString & aAlbum); \
  NS_SCRIPTABLE NS_IMETHOD SetAlbum(const nsAString & aAlbum); \
  NS_SCRIPTABLE NS_IMETHOD GetState(char * *aState); \
  NS_SCRIPTABLE NS_IMETHOD SetState(const char * aState); \
  NS_SCRIPTABLE NS_IMETHOD GetRotation(char * *aRotation); \
  NS_SCRIPTABLE NS_IMETHOD SetRotation(const char * aRotation); \
  NS_SCRIPTABLE NS_IMETHOD GetCrop(char * *aCrop); \
  NS_SCRIPTABLE NS_IMETHOD SetCrop(const char * aCrop); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOAD(_to) \
  NS_SCRIPTABLE NS_IMETHOD GetId(char * *aId) { return _to GetId(aId); } \
  NS_SCRIPTABLE NS_IMETHOD SetId(const char * aId) { return _to SetId(aId); } \
  NS_SCRIPTABLE NS_IMETHOD GetFileName(nsAString & aFileName) { return _to GetFileName(aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD SetFileName(const nsAString & aFileName) { return _to SetFileName(aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) { return _to GetOriginalFileSpec(aOriginalFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) { return _to SetOriginalFileSpec(aOriginalFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) { return _to GetOriginalFilePath(aOriginalFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) { return _to SetOriginalFilePath(aOriginalFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) { return _to GetWorkingFilePath(aWorkingFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) { return _to SetWorkingFilePath(aWorkingFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) { return _to GetWorkingFileSpec(aWorkingFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) { return _to SetWorkingFileSpec(aWorkingFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) { return _to GetPreviewFileSpec(aPreviewFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) { return _to SetPreviewFileSpec(aPreviewFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) { return _to GetPreviewFilePath(aPreviewFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) { return _to SetPreviewFilePath(aPreviewFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) { return _to GetThumbFileSpec(aThumbFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) { return _to SetThumbFileSpec(aThumbFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) { return _to GetThumbFilePath(aThumbFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) { return _to SetThumbFilePath(aThumbFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetMimetype(char * *aMimetype) { return _to GetMimetype(aMimetype); } \
  NS_SCRIPTABLE NS_IMETHOD SetMimetype(const char * aMimetype) { return _to SetMimetype(aMimetype); } \
  NS_SCRIPTABLE NS_IMETHOD GetTitle(nsAString & aTitle) { return _to GetTitle(aTitle); } \
  NS_SCRIPTABLE NS_IMETHOD SetTitle(const nsAString & aTitle) { return _to SetTitle(aTitle); } \
  NS_SCRIPTABLE NS_IMETHOD GetTags(nsAString & aTags) { return _to GetTags(aTags); } \
  NS_SCRIPTABLE NS_IMETHOD SetTags(const nsAString & aTags) { return _to SetTags(aTags); } \
  NS_SCRIPTABLE NS_IMETHOD GetNotes(nsAString & aNotes) { return _to GetNotes(aNotes); } \
  NS_SCRIPTABLE NS_IMETHOD SetNotes(const nsAString & aNotes) { return _to SetNotes(aNotes); } \
  NS_SCRIPTABLE NS_IMETHOD GetDescription(nsAString & aDescription) { return _to GetDescription(aDescription); } \
  NS_SCRIPTABLE NS_IMETHOD SetDescription(const nsAString & aDescription) { return _to SetDescription(aDescription); } \
  NS_SCRIPTABLE NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) { return _to GetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_SCRIPTABLE NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) { return _to SetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_public(char * *aIs_public) { return _to GetIs_public(aIs_public); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_public(const char * aIs_public) { return _to SetIs_public(aIs_public); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_friend(char * *aIs_friend) { return _to GetIs_friend(aIs_friend); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_friend(const char * aIs_friend) { return _to SetIs_friend(aIs_friend); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_family(char * *aIs_family) { return _to GetIs_family(aIs_family); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_family(const char * aIs_family) { return _to SetIs_family(aIs_family); } \
  NS_SCRIPTABLE NS_IMETHOD GetAlbum(nsAString & aAlbum) { return _to GetAlbum(aAlbum); } \
  NS_SCRIPTABLE NS_IMETHOD SetAlbum(const nsAString & aAlbum) { return _to SetAlbum(aAlbum); } \
  NS_SCRIPTABLE NS_IMETHOD GetState(char * *aState) { return _to GetState(aState); } \
  NS_SCRIPTABLE NS_IMETHOD SetState(const char * aState) { return _to SetState(aState); } \
  NS_SCRIPTABLE NS_IMETHOD GetRotation(char * *aRotation) { return _to GetRotation(aRotation); } \
  NS_SCRIPTABLE NS_IMETHOD SetRotation(const char * aRotation) { return _to SetRotation(aRotation); } \
  NS_SCRIPTABLE NS_IMETHOD GetCrop(char * *aCrop) { return _to GetCrop(aCrop); } \
  NS_SCRIPTABLE NS_IMETHOD SetCrop(const char * aCrop) { return _to SetCrop(aCrop); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOAD(_to) \
  NS_SCRIPTABLE NS_IMETHOD GetId(char * *aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetId(aId); } \
  NS_SCRIPTABLE NS_IMETHOD SetId(const char * aId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetId(aId); } \
  NS_SCRIPTABLE NS_IMETHOD GetFileName(nsAString & aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFileName(aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD SetFileName(const nsAString & aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFileName(aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFileSpec(char * *aOriginalFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOriginalFileSpec(aOriginalFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFileSpec(const char * aOriginalFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOriginalFileSpec(aOriginalFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetOriginalFilePath(char * *aOriginalFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOriginalFilePath(aOriginalFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetOriginalFilePath(const char * aOriginalFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetOriginalFilePath(aOriginalFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFilePath(char * *aWorkingFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWorkingFilePath(aWorkingFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFilePath(const char * aWorkingFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWorkingFilePath(aWorkingFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetWorkingFileSpec(char * *aWorkingFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWorkingFileSpec(aWorkingFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetWorkingFileSpec(const char * aWorkingFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWorkingFileSpec(aWorkingFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFileSpec(char * *aPreviewFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPreviewFileSpec(aPreviewFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFileSpec(const char * aPreviewFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPreviewFileSpec(aPreviewFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetPreviewFilePath(char * *aPreviewFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPreviewFilePath(aPreviewFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetPreviewFilePath(const char * aPreviewFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPreviewFilePath(aPreviewFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFileSpec(char * *aThumbFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThumbFileSpec(aThumbFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFileSpec(const char * aThumbFileSpec) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetThumbFileSpec(aThumbFileSpec); } \
  NS_SCRIPTABLE NS_IMETHOD GetThumbFilePath(char * *aThumbFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThumbFilePath(aThumbFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD SetThumbFilePath(const char * aThumbFilePath) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetThumbFilePath(aThumbFilePath); } \
  NS_SCRIPTABLE NS_IMETHOD GetMimetype(char * *aMimetype) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMimetype(aMimetype); } \
  NS_SCRIPTABLE NS_IMETHOD SetMimetype(const char * aMimetype) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetMimetype(aMimetype); } \
  NS_SCRIPTABLE NS_IMETHOD GetTitle(nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTitle(aTitle); } \
  NS_SCRIPTABLE NS_IMETHOD SetTitle(const nsAString & aTitle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTitle(aTitle); } \
  NS_SCRIPTABLE NS_IMETHOD GetTags(nsAString & aTags) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTags(aTags); } \
  NS_SCRIPTABLE NS_IMETHOD SetTags(const nsAString & aTags) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTags(aTags); } \
  NS_SCRIPTABLE NS_IMETHOD GetNotes(nsAString & aNotes) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNotes(aNotes); } \
  NS_SCRIPTABLE NS_IMETHOD SetNotes(const nsAString & aNotes) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetNotes(aNotes); } \
  NS_SCRIPTABLE NS_IMETHOD GetDescription(nsAString & aDescription) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDescription(aDescription); } \
  NS_SCRIPTABLE NS_IMETHOD SetDescription(const nsAString & aDescription) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDescription(aDescription); } \
  NS_SCRIPTABLE NS_IMETHOD GetPrivacy_use_batch(nsAString & aPrivacy_use_batch) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_SCRIPTABLE NS_IMETHOD SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPrivacy_use_batch(aPrivacy_use_batch); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_public(char * *aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_public(aIs_public); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_public(const char * aIs_public) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_public(aIs_public); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_friend(char * *aIs_friend) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_friend(aIs_friend); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_friend(const char * aIs_friend) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_friend(aIs_friend); } \
  NS_SCRIPTABLE NS_IMETHOD GetIs_family(char * *aIs_family) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIs_family(aIs_family); } \
  NS_SCRIPTABLE NS_IMETHOD SetIs_family(const char * aIs_family) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIs_family(aIs_family); } \
  NS_SCRIPTABLE NS_IMETHOD GetAlbum(nsAString & aAlbum) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlbum(aAlbum); } \
  NS_SCRIPTABLE NS_IMETHOD SetAlbum(const nsAString & aAlbum) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAlbum(aAlbum); } \
  NS_SCRIPTABLE NS_IMETHOD GetState(char * *aState) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetState(aState); } \
  NS_SCRIPTABLE NS_IMETHOD SetState(const char * aState) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetState(aState); } \
  NS_SCRIPTABLE NS_IMETHOD GetRotation(char * *aRotation) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRotation(aRotation); } \
  NS_SCRIPTABLE NS_IMETHOD SetRotation(const char * aRotation) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRotation(aRotation); } \
  NS_SCRIPTABLE NS_IMETHOD GetCrop(char * *aCrop) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCrop(aCrop); } \
  NS_SCRIPTABLE NS_IMETHOD SetCrop(const char * aCrop) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetCrop(aCrop); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUpload
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOAD

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUpload)

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

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

/* attribute string id; */
NS_IMETHODIMP _MYCLASS_::GetId(char * *aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetId(const char * aId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString fileName; */
NS_IMETHODIMP _MYCLASS_::GetFileName(nsAString & aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetFileName(const nsAString & aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string originalFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetOriginalFileSpec(char * *aOriginalFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetOriginalFileSpec(const char * aOriginalFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string originalFilePath; */
NS_IMETHODIMP _MYCLASS_::GetOriginalFilePath(char * *aOriginalFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetOriginalFilePath(const char * aOriginalFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string workingFilePath; */
NS_IMETHODIMP _MYCLASS_::GetWorkingFilePath(char * *aWorkingFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetWorkingFilePath(const char * aWorkingFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string workingFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetWorkingFileSpec(char * *aWorkingFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetWorkingFileSpec(const char * aWorkingFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string previewFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetPreviewFileSpec(char * *aPreviewFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPreviewFileSpec(const char * aPreviewFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string previewFilePath; */
NS_IMETHODIMP _MYCLASS_::GetPreviewFilePath(char * *aPreviewFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPreviewFilePath(const char * aPreviewFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string thumbFileSpec; */
NS_IMETHODIMP _MYCLASS_::GetThumbFileSpec(char * *aThumbFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetThumbFileSpec(const char * aThumbFileSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string thumbFilePath; */
NS_IMETHODIMP _MYCLASS_::GetThumbFilePath(char * *aThumbFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetThumbFilePath(const char * aThumbFilePath)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string mimetype; */
NS_IMETHODIMP _MYCLASS_::GetMimetype(char * *aMimetype)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetMimetype(const char * aMimetype)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString title; */
NS_IMETHODIMP _MYCLASS_::GetTitle(nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTitle(const nsAString & aTitle)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString tags; */
NS_IMETHODIMP _MYCLASS_::GetTags(nsAString & aTags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetTags(const nsAString & aTags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString notes; */
NS_IMETHODIMP _MYCLASS_::GetNotes(nsAString & aNotes)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetNotes(const nsAString & aNotes)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString description; */
NS_IMETHODIMP _MYCLASS_::GetDescription(nsAString & aDescription)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetDescription(const nsAString & aDescription)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString privacy_use_batch; */
NS_IMETHODIMP _MYCLASS_::GetPrivacy_use_batch(nsAString & aPrivacy_use_batch)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetPrivacy_use_batch(const nsAString & aPrivacy_use_batch)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_public; */
NS_IMETHODIMP _MYCLASS_::GetIs_public(char * *aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_public(const char * aIs_public)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_friend; */
NS_IMETHODIMP _MYCLASS_::GetIs_friend(char * *aIs_friend)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_friend(const char * aIs_friend)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string is_family; */
NS_IMETHODIMP _MYCLASS_::GetIs_family(char * *aIs_family)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetIs_family(const char * aIs_family)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute AString album; */
NS_IMETHODIMP _MYCLASS_::GetAlbum(nsAString & aAlbum)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetAlbum(const nsAString & aAlbum)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string state; */
NS_IMETHODIMP _MYCLASS_::GetState(char * *aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetState(const char * aState)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string rotation; */
NS_IMETHODIMP _MYCLASS_::GetRotation(char * *aRotation)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetRotation(const char * aRotation)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string crop; */
NS_IMETHODIMP _MYCLASS_::GetCrop(char * *aCrop)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP _MYCLASS_::SetCrop(const char * aCrop)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIUploadObserver */
#define FLOCKIUPLOADOBSERVER_IID_STR "0524f570-ec8d-4463-b828-bb611c9705ba"

#define FLOCKIUPLOADOBSERVER_IID \
  {0x0524f570, 0xec8d, 0x4463, \
    { 0xb8, 0x28, 0xbb, 0x61, 0x1c, 0x97, 0x05, 0xba }}

/**
 * An observer to be set on the flockPhotoUploadService, an be notified
 * of upload-related events.
 *
 * @see flockIPhotoUploadService#addObserver
 * @see flockIPhotoUploadService#removeObserver
 */
class NS_NO_VTABLE NS_SCRIPTABLE flockIUploadObserver : public nsISupports {
 public: 

  NS_DECLARE_STATIC_IID_ACCESSOR(FLOCKIUPLOADOBSERVER_IID)

  /**
   * Called each time we receive progress information from the server.
   *
   * @param aCurrentProgress (in) the progress for the current photo.
   */
  /* void onUploadProgress (in PRUint32 aCurrentProgress); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress) = 0;

  /**
   * Called right before the actual upload of a photo starts.
   *
   * @param aUpload (in) the photo being uploaded (metadata sent to the server)
   * @param aCount (in) how many photos have been uploaded in this batch (including this one)
   * @param aMax (in) the total number of photos in this batch
   */
  /* void onUploadStart (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) = 0;

  /**
   * Called after a photo has been successfully uploaded. Note that the metadata
   * may not be completely set; onUploadFinalized will be called at that time.
   *
   * @param aUpload (in) the photo successfully uploaded
   *    (metadata sent to the server)
   * @param aCount (in) how many photos have been uploaded in this batch (including this one)
   * @param aMax (in) the total number of photos in this batch
   */
  /* void onUpload (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
  NS_SCRIPTABLE NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) = 0;

  /**
   * Called when an error is caught during upload of a photo
   *
   * @param aUpload (in) the photo being uploaded when the error happened
   * @param aCount (in) how many photos have been uploaded in this batch (including this one)
   * @param aMax (in) the total number of photos in this batch
   * @param aError (in) the error returned
   */
  /* void onUploadError (in flockIPhotoUpload aUpload, in long aCount, in long aMax, in flockIError aError); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) = 0;

  /**
   * Called when the current batch operation is finished. The end of the process
   * may be due to a success, an error or the operation being cancelled by the
   * user.
   */
  /* void onUploadComplete (); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(void) = 0;

  /**
   * Called after a photo is finalized. Finalized means that not only the photo
   * is uploaded, but the metadata has been set. For example, for Flickr the
   * album is set at that stage.
   *
   * @param aUpload (in) the metadata sent to the server
   * @param aMediaItem (in) the item newly created on the server,
   *    including the URL on the server, id as recognized by the server...
   */
  /* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) = 0;

  /**
   * Called when a photo already imported is added to the upload queue.
   * This includes reorder (a reorder is a "remove" then an "add").
   * This method is called with aUpload == null before the photo is added,
   * then with aUpload != null after the photo is added.
   *
   * @param aUpload (in) the newly added photo upload (or null)
   */
  /* void onUploadAdd (in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) = 0;

  /**
   * Called when a photo is removed from the upload queue.
   * This includes reorder (a reorder is a "remove" then an "add").
   */
  /* void onUploadRemove (); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadRemove(void) = 0;

  /**
   * Called when an error happen when importing a photo from the disk to the
   * upload queue; for example, the photo file was corrupted and couldn't be
   * read.
   *
   * @param aFilename (in) the filename that caused an error at import
   */
  /* void onMediaImportError (in AString aFilename); */
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportError(const nsAString & aFilename) = 0;

  /* void onError (in flockIError aError); */
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) = 0;

  /**
   * Called at the beginning of the process of importing a photo
   * from the disk to the upload queue.
   *
   * @param filename (in) the filename of the image file to import.
   * @param aNumInBatch (in) the number of the current photo in the import batch
   */
  /* void onMediaImportStart (in AString filename, in long aNumInBatch); */
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) = 0;

  /**
   * Called after a photo has been successfully imported
   * from the disk to the upload queue.
   *
   * @param aPhotoUpload (in) the metadata of the photo in the queue.
   * @param aCount (in) the number photos already imported in the current batch
   *    (including this one)
   */
  /* void onMediaImportFinish (in flockIPhotoUpload aPhotoUpload, in long aCount); */
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) = 0;

  /**
   * Called at the beginning of the process of importing a batch of photos
   * from the disk to the upload queue.
   *
   * @param aBatchSize (in) the number photos in the batch.
   */
  /* void onMediaBatchImportStart (in long aBatchSize); */
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) = 0;

  /**
   * Called at the end of the process of importing a batch of photos
   * from the disk to the upload queue.
   */
  /* void onMediaBatchImportFinish (); */
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportFinish(void) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(flockIUploadObserver, FLOCKIUPLOADOBSERVER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIUPLOADOBSERVER \
  NS_SCRIPTABLE NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax); \
  NS_SCRIPTABLE NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(void); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadRemove(void); \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportError(const nsAString & aFilename); \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError); \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch); \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount); \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize); \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportFinish(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIUPLOADOBSERVER(_to) \
  NS_SCRIPTABLE NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress) { return _to OnUploadProgress(aCurrentProgress); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return _to OnUploadStart(aUpload, aCount, aMax); } \
  NS_SCRIPTABLE NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return _to OnUpload(aUpload, aCount, aMax); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) { return _to OnUploadError(aUpload, aCount, aMax, aError); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(void) { return _to OnUploadComplete(); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return _to OnUploadFinalized(aUpload, aMediaItem); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) { return _to OnUploadAdd(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadRemove(void) { return _to OnUploadRemove(); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportError(const nsAString & aFilename) { return _to OnMediaImportError(aFilename); } \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) { return _to OnMediaImportStart(filename, aNumInBatch); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) { return _to OnMediaImportFinish(aPhotoUpload, aCount); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) { return _to OnMediaBatchImportStart(aBatchSize); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportFinish(void) { return _to OnMediaBatchImportFinish(); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIUPLOADOBSERVER(_to) \
  NS_SCRIPTABLE NS_IMETHOD OnUploadProgress(PRUint32 aCurrentProgress) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadProgress(aCurrentProgress); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadStart(aUpload, aCount, aMax); } \
  NS_SCRIPTABLE NS_IMETHOD OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUpload(aUpload, aCount, aMax); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadError(aUpload, aCount, aMax, aError); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadComplete(); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadFinalized(aUpload, aMediaItem); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadAdd(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadAdd(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadRemove(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadRemove(); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportError(const nsAString & aFilename) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportError(aFilename); } \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportStart(filename, aNumInBatch); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaImportFinish(aPhotoUpload, aCount); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportStart(PRInt32 aBatchSize) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaBatchImportStart(aBatchSize); } \
  NS_SCRIPTABLE NS_IMETHOD OnMediaBatchImportFinish(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnMediaBatchImportFinish(); } 

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

/* Header file */
class _MYCLASS_ : public flockIUploadObserver
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIUPLOADOBSERVER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIUploadObserver)

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

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

/* void onUploadProgress (in PRUint32 aCurrentProgress); */
NS_IMETHODIMP _MYCLASS_::OnUploadProgress(PRUint32 aCurrentProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadStart (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
NS_IMETHODIMP _MYCLASS_::OnUploadStart(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUpload (in flockIPhotoUpload aUpload, in long aCount, in long aMax); */
NS_IMETHODIMP _MYCLASS_::OnUpload(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadError (in flockIPhotoUpload aUpload, in long aCount, in long aMax, in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnUploadError(flockIPhotoUpload *aUpload, PRInt32 aCount, PRInt32 aMax, flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadComplete (); */
NS_IMETHODIMP _MYCLASS_::OnUploadComplete()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
NS_IMETHODIMP _MYCLASS_::OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadAdd (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::OnUploadAdd(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadRemove (); */
NS_IMETHODIMP _MYCLASS_::OnUploadRemove()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaImportError (in AString aFilename); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportError(const nsAString & aFilename)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaImportStart (in AString filename, in long aNumInBatch); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportStart(const nsAString & filename, PRInt32 aNumInBatch)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaImportFinish (in flockIPhotoUpload aPhotoUpload, in long aCount); */
NS_IMETHODIMP _MYCLASS_::OnMediaImportFinish(flockIPhotoUpload *aPhotoUpload, PRInt32 aCount)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaBatchImportStart (in long aBatchSize); */
NS_IMETHODIMP _MYCLASS_::OnMediaBatchImportStart(PRInt32 aBatchSize)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onMediaBatchImportFinish (); */
NS_IMETHODIMP _MYCLASS_::OnMediaBatchImportFinish()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUploadAPIListener */
#define FLOCKIPHOTOUPLOADAPILISTENER_IID_STR "2a470693-5a07-4a7a-bca9-3bf7b6841348"

#define FLOCKIPHOTOUPLOADAPILISTENER_IID \
  {0x2a470693, 0x5a07, 0x4a7a, \
    { 0xbc, 0xa9, 0x3b, 0xf7, 0xb6, 0x84, 0x13, 0x48 }}

/**
 * A listener to use as callback about the upload of one photo.
 *
 * @see flockIMediaUploadWebService#upload
 * @see flockIFacebookAPI#uploadPhotosViaUploader
 */
class NS_NO_VTABLE NS_SCRIPTABLE flockIPhotoUploadAPIListener : public nsISupports {
 public: 

  NS_DECLARE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOADAPILISTENER_IID)

  /* void onProgress (in PRUint32 aCurrentProgress); */
  NS_SCRIPTABLE NS_IMETHOD OnProgress(PRUint32 aCurrentProgress) = 0;

  /* void onUploadComplete (in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) = 0;

  /* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) = 0;

  /* void onError (in flockIError aError); */
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(flockIPhotoUploadAPIListener, FLOCKIPHOTOUPLOADAPILISTENER_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADAPILISTENER \
  NS_SCRIPTABLE NS_IMETHOD OnProgress(PRUint32 aCurrentProgress); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem); \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADAPILISTENER(_to) \
  NS_SCRIPTABLE NS_IMETHOD OnProgress(PRUint32 aCurrentProgress) { return _to OnProgress(aCurrentProgress); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return _to OnUploadComplete(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return _to OnUploadFinalized(aUpload, aMediaItem); } \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) { return _to OnError(aError); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOADAPILISTENER(_to) \
  NS_SCRIPTABLE NS_IMETHOD OnProgress(PRUint32 aCurrentProgress) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnProgress(aCurrentProgress); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadComplete(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadComplete(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnUploadFinalized(aUpload, aMediaItem); } \
  NS_SCRIPTABLE NS_IMETHOD OnError(flockIError *aError) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aError); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUploadAPIListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOADAPILISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUploadAPIListener)

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

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

/* void onProgress (in PRUint32 aCurrentProgress); */
NS_IMETHODIMP _MYCLASS_::OnProgress(PRUint32 aCurrentProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadComplete (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::OnUploadComplete(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onUploadFinalized (in flockIPhotoUpload aUpload, in flockIMediaItem aMediaItem); */
NS_IMETHODIMP _MYCLASS_::OnUploadFinalized(flockIPhotoUpload *aUpload, flockIMediaItem *aMediaItem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in flockIError aError); */
NS_IMETHODIMP _MYCLASS_::OnError(flockIError *aError)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIPhotoUploadService */
#define FLOCKIPHOTOUPLOADSERVICE_IID_STR "17f76f3c-57bd-4ba6-9c9c-a906c499c791"

#define FLOCKIPHOTOUPLOADSERVICE_IID \
  {0x17f76f3c, 0x57bd, 0x4ba6, \
    { 0x9c, 0x9c, 0xa9, 0x06, 0xc4, 0x99, 0xc7, 0x91 }}

class NS_NO_VTABLE NS_SCRIPTABLE flockIPhotoUploadService : public nsISupports {
 public: 

  NS_DECLARE_STATIC_IID_ACCESSOR(FLOCKIPHOTOUPLOADSERVICE_IID)

  /* boolean hasOnePhotoAccount (); */
  NS_SCRIPTABLE NS_IMETHOD HasOnePhotoAccount(PRBool *_retval) = 0;

  /* string getDefaultService (); */
  NS_SCRIPTABLE NS_IMETHOD GetDefaultService(char **_retval) = 0;

  /* void setDefaultService (in string aServiceId); */
  NS_SCRIPTABLE NS_IMETHOD SetDefaultService(const char *aServiceId) = 0;

  /* void promptForAccount (); */
  NS_SCRIPTABLE NS_IMETHOD PromptForAccount(void) = 0;

  /* void launchUploader (); */
  NS_SCRIPTABLE NS_IMETHOD LaunchUploader(void) = 0;

  /* void importSingleMediaItem (in flockIUploadObserver aUploadObserver, in AString aFileName); */
  NS_SCRIPTABLE NS_IMETHOD ImportSingleMediaItem(flockIUploadObserver *aUploadObserver, const nsAString & aFileName) = 0;

  /* void addMediaToImportQueue (in AString aUrl); */
  NS_SCRIPTABLE NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl) = 0;

  /* void startImportQueue (); */
  NS_SCRIPTABLE NS_IMETHOD StartImportQueue(void) = 0;

  /* void cancelImport (); */
  NS_SCRIPTABLE NS_IMETHOD CancelImport(void) = 0;

  /* void upload (in flockIMediaWebService aAPI); */
  NS_SCRIPTABLE NS_IMETHOD Upload(flockIMediaWebService *aAPI) = 0;

  /* void singleUpload (in flockIPhotoUploadAPIListener aUploadListener, in flockIMediaWebService aAPI, in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aUploadListener, flockIMediaWebService *aAPI, flockIPhotoUpload *aUpload) = 0;

  /* void cancelUpload (); */
  NS_SCRIPTABLE NS_IMETHOD CancelUpload(void) = 0;

  /* void addPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) = 0;

  /* void savePhotoUpload (in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void removePhotoUpload (in string aUploadId); */
  NS_SCRIPTABLE NS_IMETHOD RemovePhotoUpload(const char *aUploadId) = 0;

  /* flockIPhotoUpload getPhotoUpload (in AString aURI); */
  NS_SCRIPTABLE NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) = 0;

  /* void addObserver (in flockIUploadObserver aUploadObserver); */
  NS_SCRIPTABLE NS_IMETHOD AddObserver(flockIUploadObserver *aUploadObserver) = 0;

  /* void removeObserver (in flockIUploadObserver aUploadObserver); */
  NS_SCRIPTABLE NS_IMETHOD RemoveObserver(flockIUploadObserver *aUploadObserver) = 0;

  /* void cropPhotoUpload (in flockIPhotoUpload aUpload, in double aX1, in double aY1, in double aX2, in double aY2); */
  NS_SCRIPTABLE NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) = 0;

  /* void revertPhotoUpload (in flockIPhotoUpload aUpload); */
  NS_SCRIPTABLE NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) = 0;

  /* void rotatePhotoUpload (in flockIPhotoUpload aUpload, in PRInt32 aDegrees); */
  NS_SCRIPTABLE NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) = 0;

  /* void cleanPhotoUploadCache (); */
  NS_SCRIPTABLE NS_IMETHOD CleanPhotoUploadCache(void) = 0;

  /* readonly attribute boolean isUploading; */
  NS_SCRIPTABLE NS_IMETHOD GetIsUploading(PRBool *aIsUploading) = 0;

  /* readonly attribute boolean isImporting; */
  NS_SCRIPTABLE NS_IMETHOD GetIsImporting(PRBool *aIsImporting) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(flockIPhotoUploadService, FLOCKIPHOTOUPLOADSERVICE_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIPHOTOUPLOADSERVICE \
  NS_SCRIPTABLE NS_IMETHOD HasOnePhotoAccount(PRBool *_retval); \
  NS_SCRIPTABLE NS_IMETHOD GetDefaultService(char **_retval); \
  NS_SCRIPTABLE NS_IMETHOD SetDefaultService(const char *aServiceId); \
  NS_SCRIPTABLE NS_IMETHOD PromptForAccount(void); \
  NS_SCRIPTABLE NS_IMETHOD LaunchUploader(void); \
  NS_SCRIPTABLE NS_IMETHOD ImportSingleMediaItem(flockIUploadObserver *aUploadObserver, const nsAString & aFileName); \
  NS_SCRIPTABLE NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl); \
  NS_SCRIPTABLE NS_IMETHOD StartImportQueue(void); \
  NS_SCRIPTABLE NS_IMETHOD CancelImport(void); \
  NS_SCRIPTABLE NS_IMETHOD Upload(flockIMediaWebService *aAPI); \
  NS_SCRIPTABLE NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aUploadListener, flockIMediaWebService *aAPI, flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD CancelUpload(void); \
  NS_SCRIPTABLE NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD RemovePhotoUpload(const char *aUploadId); \
  NS_SCRIPTABLE NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval); \
  NS_SCRIPTABLE NS_IMETHOD AddObserver(flockIUploadObserver *aUploadObserver); \
  NS_SCRIPTABLE NS_IMETHOD RemoveObserver(flockIUploadObserver *aUploadObserver); \
  NS_SCRIPTABLE NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2); \
  NS_SCRIPTABLE NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload); \
  NS_SCRIPTABLE NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees); \
  NS_SCRIPTABLE NS_IMETHOD CleanPhotoUploadCache(void); \
  NS_SCRIPTABLE NS_IMETHOD GetIsUploading(PRBool *aIsUploading); \
  NS_SCRIPTABLE NS_IMETHOD GetIsImporting(PRBool *aIsImporting); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIPHOTOUPLOADSERVICE(_to) \
  NS_SCRIPTABLE NS_IMETHOD HasOnePhotoAccount(PRBool *_retval) { return _to HasOnePhotoAccount(_retval); } \
  NS_SCRIPTABLE NS_IMETHOD GetDefaultService(char **_retval) { return _to GetDefaultService(_retval); } \
  NS_SCRIPTABLE NS_IMETHOD SetDefaultService(const char *aServiceId) { return _to SetDefaultService(aServiceId); } \
  NS_SCRIPTABLE NS_IMETHOD PromptForAccount(void) { return _to PromptForAccount(); } \
  NS_SCRIPTABLE NS_IMETHOD LaunchUploader(void) { return _to LaunchUploader(); } \
  NS_SCRIPTABLE NS_IMETHOD ImportSingleMediaItem(flockIUploadObserver *aUploadObserver, const nsAString & aFileName) { return _to ImportSingleMediaItem(aUploadObserver, aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl) { return _to AddMediaToImportQueue(aUrl); } \
  NS_SCRIPTABLE NS_IMETHOD StartImportQueue(void) { return _to StartImportQueue(); } \
  NS_SCRIPTABLE NS_IMETHOD CancelImport(void) { return _to CancelImport(); } \
  NS_SCRIPTABLE NS_IMETHOD Upload(flockIMediaWebService *aAPI) { return _to Upload(aAPI); } \
  NS_SCRIPTABLE NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aUploadListener, flockIMediaWebService *aAPI, flockIPhotoUpload *aUpload) { return _to SingleUpload(aUploadListener, aAPI, aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD CancelUpload(void) { return _to CancelUpload(); } \
  NS_SCRIPTABLE NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return _to AddPhotoUpload(aReference, aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) { return _to SavePhotoUpload(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD RemovePhotoUpload(const char *aUploadId) { return _to RemovePhotoUpload(aUploadId); } \
  NS_SCRIPTABLE NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) { return _to GetPhotoUpload(aURI, _retval); } \
  NS_SCRIPTABLE NS_IMETHOD AddObserver(flockIUploadObserver *aUploadObserver) { return _to AddObserver(aUploadObserver); } \
  NS_SCRIPTABLE NS_IMETHOD RemoveObserver(flockIUploadObserver *aUploadObserver) { return _to RemoveObserver(aUploadObserver); } \
  NS_SCRIPTABLE NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) { return _to CropPhotoUpload(aUpload, aX1, aY1, aX2, aY2); } \
  NS_SCRIPTABLE NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) { return _to RevertPhotoUpload(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) { return _to RotatePhotoUpload(aUpload, aDegrees); } \
  NS_SCRIPTABLE NS_IMETHOD CleanPhotoUploadCache(void) { return _to CleanPhotoUploadCache(); } \
  NS_SCRIPTABLE NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return _to GetIsUploading(aIsUploading); } \
  NS_SCRIPTABLE NS_IMETHOD GetIsImporting(PRBool *aIsImporting) { return _to GetIsImporting(aIsImporting); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIPHOTOUPLOADSERVICE(_to) \
  NS_SCRIPTABLE NS_IMETHOD HasOnePhotoAccount(PRBool *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->HasOnePhotoAccount(_retval); } \
  NS_SCRIPTABLE NS_IMETHOD GetDefaultService(char **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDefaultService(_retval); } \
  NS_SCRIPTABLE NS_IMETHOD SetDefaultService(const char *aServiceId) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetDefaultService(aServiceId); } \
  NS_SCRIPTABLE NS_IMETHOD PromptForAccount(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->PromptForAccount(); } \
  NS_SCRIPTABLE NS_IMETHOD LaunchUploader(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LaunchUploader(); } \
  NS_SCRIPTABLE NS_IMETHOD ImportSingleMediaItem(flockIUploadObserver *aUploadObserver, const nsAString & aFileName) { return !_to ? NS_ERROR_NULL_POINTER : _to->ImportSingleMediaItem(aUploadObserver, aFileName); } \
  NS_SCRIPTABLE NS_IMETHOD AddMediaToImportQueue(const nsAString & aUrl) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddMediaToImportQueue(aUrl); } \
  NS_SCRIPTABLE NS_IMETHOD StartImportQueue(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->StartImportQueue(); } \
  NS_SCRIPTABLE NS_IMETHOD CancelImport(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelImport(); } \
  NS_SCRIPTABLE NS_IMETHOD Upload(flockIMediaWebService *aAPI) { return !_to ? NS_ERROR_NULL_POINTER : _to->Upload(aAPI); } \
  NS_SCRIPTABLE NS_IMETHOD SingleUpload(flockIPhotoUploadAPIListener *aUploadListener, flockIMediaWebService *aAPI, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->SingleUpload(aUploadListener, aAPI, aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD CancelUpload(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelUpload(); } \
  NS_SCRIPTABLE NS_IMETHOD AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddPhotoUpload(aReference, aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD SavePhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->SavePhotoUpload(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD RemovePhotoUpload(const char *aUploadId) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemovePhotoUpload(aUploadId); } \
  NS_SCRIPTABLE NS_IMETHOD GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPhotoUpload(aURI, _retval); } \
  NS_SCRIPTABLE NS_IMETHOD AddObserver(flockIUploadObserver *aUploadObserver) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddObserver(aUploadObserver); } \
  NS_SCRIPTABLE NS_IMETHOD RemoveObserver(flockIUploadObserver *aUploadObserver) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveObserver(aUploadObserver); } \
  NS_SCRIPTABLE NS_IMETHOD CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->CropPhotoUpload(aUpload, aX1, aY1, aX2, aY2); } \
  NS_SCRIPTABLE NS_IMETHOD RevertPhotoUpload(flockIPhotoUpload *aUpload) { return !_to ? NS_ERROR_NULL_POINTER : _to->RevertPhotoUpload(aUpload); } \
  NS_SCRIPTABLE NS_IMETHOD RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees) { return !_to ? NS_ERROR_NULL_POINTER : _to->RotatePhotoUpload(aUpload, aDegrees); } \
  NS_SCRIPTABLE NS_IMETHOD CleanPhotoUploadCache(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CleanPhotoUploadCache(); } \
  NS_SCRIPTABLE NS_IMETHOD GetIsUploading(PRBool *aIsUploading) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsUploading(aIsUploading); } \
  NS_SCRIPTABLE NS_IMETHOD GetIsImporting(PRBool *aIsImporting) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsImporting(aIsImporting); } 

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

/* Header file */
class _MYCLASS_ : public flockIPhotoUploadService
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIPHOTOUPLOADSERVICE

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIPhotoUploadService)

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

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

/* boolean hasOnePhotoAccount (); */
NS_IMETHODIMP _MYCLASS_::HasOnePhotoAccount(PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* string getDefaultService (); */
NS_IMETHODIMP _MYCLASS_::GetDefaultService(char **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setDefaultService (in string aServiceId); */
NS_IMETHODIMP _MYCLASS_::SetDefaultService(const char *aServiceId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void promptForAccount (); */
NS_IMETHODIMP _MYCLASS_::PromptForAccount()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void launchUploader (); */
NS_IMETHODIMP _MYCLASS_::LaunchUploader()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void importSingleMediaItem (in flockIUploadObserver aUploadObserver, in AString aFileName); */
NS_IMETHODIMP _MYCLASS_::ImportSingleMediaItem(flockIUploadObserver *aUploadObserver, const nsAString & aFileName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addMediaToImportQueue (in AString aUrl); */
NS_IMETHODIMP _MYCLASS_::AddMediaToImportQueue(const nsAString & aUrl)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void startImportQueue (); */
NS_IMETHODIMP _MYCLASS_::StartImportQueue()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cancelImport (); */
NS_IMETHODIMP _MYCLASS_::CancelImport()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void upload (in flockIMediaWebService aAPI); */
NS_IMETHODIMP _MYCLASS_::Upload(flockIMediaWebService *aAPI)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void singleUpload (in flockIPhotoUploadAPIListener aUploadListener, in flockIMediaWebService aAPI, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::SingleUpload(flockIPhotoUploadAPIListener *aUploadListener, flockIMediaWebService *aAPI, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cancelUpload (); */
NS_IMETHODIMP _MYCLASS_::CancelUpload()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addPhotoUpload (in flockIPhotoUpload aReference, in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::AddPhotoUpload(flockIPhotoUpload *aReference, flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void savePhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::SavePhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removePhotoUpload (in string aUploadId); */
NS_IMETHODIMP _MYCLASS_::RemovePhotoUpload(const char *aUploadId)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIPhotoUpload getPhotoUpload (in AString aURI); */
NS_IMETHODIMP _MYCLASS_::GetPhotoUpload(const nsAString & aURI, flockIPhotoUpload **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void addObserver (in flockIUploadObserver aUploadObserver); */
NS_IMETHODIMP _MYCLASS_::AddObserver(flockIUploadObserver *aUploadObserver)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void removeObserver (in flockIUploadObserver aUploadObserver); */
NS_IMETHODIMP _MYCLASS_::RemoveObserver(flockIUploadObserver *aUploadObserver)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cropPhotoUpload (in flockIPhotoUpload aUpload, in double aX1, in double aY1, in double aX2, in double aY2); */
NS_IMETHODIMP _MYCLASS_::CropPhotoUpload(flockIPhotoUpload *aUpload, double aX1, double aY1, double aX2, double aY2)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void revertPhotoUpload (in flockIPhotoUpload aUpload); */
NS_IMETHODIMP _MYCLASS_::RevertPhotoUpload(flockIPhotoUpload *aUpload)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void rotatePhotoUpload (in flockIPhotoUpload aUpload, in PRInt32 aDegrees); */
NS_IMETHODIMP _MYCLASS_::RotatePhotoUpload(flockIPhotoUpload *aUpload, PRInt32 aDegrees)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void cleanPhotoUploadCache (); */
NS_IMETHODIMP _MYCLASS_::CleanPhotoUploadCache()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isUploading; */
NS_IMETHODIMP _MYCLASS_::GetIsUploading(PRBool *aIsUploading)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean isImporting; */
NS_IMETHODIMP _MYCLASS_::GetIsImporting(PRBool *aIsImporting)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


#endif /* __gen_flockIPhotoUpload_h__ */
