Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PDocAccessible_h
#define PDocAccessible_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "mozilla/a11y/IPCTypes.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/a11y/DocAccessibleTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct AccessibleData|
//
namespace mozilla {
namespace a11y {
class AccessibleData final
{
private:
typedef ::uint64_t uint64_t;
typedef ::mozilla::a11y::role role;
typedef ::uint32_t uint32_t;
typedef ::mozilla::a11y::AccType AccType;
typedef ::mozilla::a11y::AccGenericType AccGenericType;
typedef ::uint8_t uint8_t;
typedef ::mozilla::a11y::AccAttributes AccAttributes;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
AccessibleData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT AccessibleData(
const uint64_t& _ID,
const role& _Role,
const uint64_t& _ParentID,
const uint32_t& _IndexInParent,
const AccType& _Type,
const AccGenericType& _GenericTypes,
const uint8_t& _RoleMapEntryIndex,
AccAttributes* _CacheFields) :
Role_(_Role),
Type_(_Type),
GenericTypes_(_GenericTypes),
CacheFields_(_CacheFields),
ID_(_ID),
ParentID_(_ParentID),
IndexInParent_(_IndexInParent),
RoleMapEntryIndex_(_RoleMapEntryIndex)
{
}
MOZ_IMPLICIT AccessibleData(
uint64_t&& _ID,
role&& _Role,
uint64_t&& _ParentID,
uint32_t&& _IndexInParent,
AccType&& _Type,
AccGenericType&& _GenericTypes,
uint8_t&& _RoleMapEntryIndex,
RefPtr<AccAttributes>&& _CacheFields) :
Role_(std::move(_Role)),
Type_(std::move(_Type)),
GenericTypes_(std::move(_GenericTypes)),
CacheFields_(std::move(_CacheFields)),
ID_(std::move(_ID)),
ParentID_(std::move(_ParentID)),
IndexInParent_(std::move(_IndexInParent)),
RoleMapEntryIndex_(std::move(_RoleMapEntryIndex))
{
}
uint64_t&
ID()
{
return ID_;
}
const uint64_t&
ID() const
{
return ID_;
}
role&
Role()
{
return Role_;
}
const role&
Role() const
{
return Role_;
}
uint64_t&
ParentID()
{
return ParentID_;
}
const uint64_t&
ParentID() const
{
return ParentID_;
}
uint32_t&
IndexInParent()
{
return IndexInParent_;
}
const uint32_t&
IndexInParent() const
{
return IndexInParent_;
}
AccType&
Type()
{
return Type_;
}
const AccType&
Type() const
{
return Type_;
}
AccGenericType&
GenericTypes()
{
return GenericTypes_;
}
const AccGenericType&
GenericTypes() const
{
return GenericTypes_;
}
uint8_t&
RoleMapEntryIndex()
{
return RoleMapEntryIndex_;
}
const uint8_t&
RoleMapEntryIndex() const
{
return RoleMapEntryIndex_;
}
RefPtr<AccAttributes>&
CacheFields()
{
return CacheFields_;
}
AccAttributes*
CacheFields() const
{
return CacheFields_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<role> Role_;
::mozilla::ipc::IPDLStructMember<AccType> Type_;
::mozilla::ipc::IPDLStructMember<AccGenericType> GenericTypes_;
::mozilla::ipc::IPDLStructMember<RefPtr<AccAttributes>> CacheFields_;
::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
::mozilla::ipc::IPDLStructMember<uint64_t> ParentID_;
::mozilla::ipc::IPDLStructMember<uint32_t> IndexInParent_;
::mozilla::ipc::IPDLStructMember<uint8_t> RoleMapEntryIndex_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::AccessibleData>
{
typedef ::mozilla::a11y::AccessibleData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CacheEventData|
//
namespace mozilla {
namespace a11y {
class CacheEventData final
{
private:
typedef ::mozilla::a11y::CacheUpdateType CacheUpdateType;
typedef ::mozilla::a11y::CacheData CacheData;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CacheEventData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CacheEventData(
const CacheUpdateType& _UpdateType,
const nsTArray<CacheData>& _aData) :
UpdateType_(_UpdateType),
aData_(_aData)
{
}
MOZ_IMPLICIT CacheEventData(
CacheUpdateType&& _UpdateType,
nsTArray<CacheData>&& _aData) :
UpdateType_(std::move(_UpdateType)),
aData_(std::move(_aData))
{
}
CacheUpdateType&
UpdateType()
{
return UpdateType_;
}
const CacheUpdateType&
UpdateType() const
{
return UpdateType_;
}
nsTArray<CacheData>&
aData()
{
return aData_;
}
const nsTArray<CacheData>&
aData() const
{
return aData_;
}
private:
::mozilla::ipc::IPDLStructMember<CacheUpdateType> UpdateType_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<CacheData>> aData_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::CacheEventData>
{
typedef ::mozilla::a11y::CacheEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ShowEventData|
//
namespace mozilla {
namespace a11y {
class ShowEventData final
{
private:
typedef ::mozilla::a11y::AccessibleData AccessibleData;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ShowEventData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ShowEventData(
const nsTArray<AccessibleData>& _NewTree,
const bool& _EventSuppressed,
const bool& _Complete,
const bool& _FromUser) :
NewTree_(_NewTree),
EventSuppressed_(_EventSuppressed),
Complete_(_Complete),
FromUser_(_FromUser)
{
}
MOZ_IMPLICIT ShowEventData(
nsTArray<AccessibleData>&& _NewTree,
bool&& _EventSuppressed,
bool&& _Complete,
bool&& _FromUser) :
NewTree_(std::move(_NewTree)),
EventSuppressed_(std::move(_EventSuppressed)),
Complete_(std::move(_Complete)),
FromUser_(std::move(_FromUser))
{
}
nsTArray<AccessibleData>&
NewTree()
{
return NewTree_;
}
const nsTArray<AccessibleData>&
NewTree() const
{
return NewTree_;
}
bool&
EventSuppressed()
{
return EventSuppressed_;
}
const bool&
EventSuppressed() const
{
return EventSuppressed_;
}
bool&
Complete()
{
return Complete_;
}
const bool&
Complete() const
{
return Complete_;
}
bool&
FromUser()
{
return FromUser_;
}
const bool&
FromUser() const
{
return FromUser_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<AccessibleData>> NewTree_;
::mozilla::ipc::IPDLStructMember<bool> EventSuppressed_;
::mozilla::ipc::IPDLStructMember<bool> Complete_;
::mozilla::ipc::IPDLStructMember<bool> FromUser_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::ShowEventData>
{
typedef ::mozilla::a11y::ShowEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HideEventData|
//
namespace mozilla {
namespace a11y {
class HideEventData final
{
private:
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
HideEventData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT HideEventData(
const uint64_t& _ID,
const bool& _IsFromUserInput) :
IsFromUserInput_(_IsFromUserInput),
ID_(_ID)
{
}
MOZ_IMPLICIT HideEventData(
uint64_t&& _ID,
bool&& _IsFromUserInput) :
IsFromUserInput_(std::move(_IsFromUserInput)),
ID_(std::move(_ID))
{
}
uint64_t&
ID()
{
return ID_;
}
const uint64_t&
ID() const
{
return ID_;
}
bool&
IsFromUserInput()
{
return IsFromUserInput_;
}
const bool&
IsFromUserInput() const
{
return IsFromUserInput_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> IsFromUserInput_;
::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::HideEventData>
{
typedef ::mozilla::a11y::HideEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ReorderEventData|
//
namespace mozilla {
namespace a11y {
class ReorderEventData final
{
private:
typedef ::uint64_t uint64_t;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ReorderEventData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ReorderEventData(
const uint64_t& _ID,
const uint32_t& _Type) :
ID_(_ID),
Type_(_Type)
{
}
MOZ_IMPLICIT ReorderEventData(
uint64_t&& _ID,
uint32_t&& _Type) :
ID_(std::move(_ID)),
Type_(std::move(_Type))
{
}
uint64_t&
ID()
{
return ID_;
}
const uint64_t&
ID() const
{
return ID_;
}
uint32_t&
Type()
{
return Type_;
}
const uint32_t&
Type() const
{
return Type_;
}
private:
::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
::mozilla::ipc::IPDLStructMember<uint32_t> Type_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::ReorderEventData>
{
typedef ::mozilla::a11y::ReorderEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct TextChangeEventData|
//
namespace mozilla {
namespace a11y {
class TextChangeEventData final
{
private:
typedef ::uint64_t uint64_t;
typedef ::nsString nsString;
typedef ::int32_t int32_t;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
TextChangeEventData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT TextChangeEventData(
const uint64_t& _ID,
const nsString& _Str,
const int32_t& _Start,
const uint32_t& _Len,
const bool& _IsInsert,
const bool& _FromUser) :
Str_(_Str),
IsInsert_(_IsInsert),
FromUser_(_FromUser),
ID_(_ID),
Start_(_Start),
Len_(_Len)
{
}
MOZ_IMPLICIT TextChangeEventData(
uint64_t&& _ID,
nsString&& _Str,
int32_t&& _Start,
uint32_t&& _Len,
bool&& _IsInsert,
bool&& _FromUser) :
Str_(std::move(_Str)),
IsInsert_(std::move(_IsInsert)),
FromUser_(std::move(_FromUser)),
ID_(std::move(_ID)),
Start_(std::move(_Start)),
Len_(std::move(_Len))
{
}
uint64_t&
ID()
{
return ID_;
}
const uint64_t&
ID() const
{
return ID_;
}
nsString&
Str()
{
return Str_;
}
const nsString&
Str() const
{
return Str_;
}
int32_t&
Start()
{
return Start_;
}
const int32_t&
Start() const
{
return Start_;
}
uint32_t&
Len()
{
return Len_;
}
const uint32_t&
Len() const
{
return Len_;
}
bool&
IsInsert()
{
return IsInsert_;
}
const bool&
IsInsert() const
{
return IsInsert_;
}
bool&
FromUser()
{
return FromUser_;
}
const bool&
FromUser() const
{
return FromUser_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsString> Str_;
::mozilla::ipc::IPDLStructMember<bool> IsInsert_;
::mozilla::ipc::IPDLStructMember<bool> FromUser_;
::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
::mozilla::ipc::IPDLStructMember<int32_t> Start_;
::mozilla::ipc::IPDLStructMember<uint32_t> Len_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::TextChangeEventData>
{
typedef ::mozilla::a11y::TextChangeEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union MutationEventData|
//
namespace mozilla {
namespace a11y {
class MutationEventData final
{
public:
enum Type {
T__None,
TCacheEventData = 1,
TShowEventData,
THideEventData,
TReorderEventData,
TTextChangeEventData,
T__Last = TTextChangeEventData
};
private:
typedef ::mozilla::a11y::CacheEventData CacheEventData;
typedef ::mozilla::a11y::ShowEventData ShowEventData;
typedef ::mozilla::a11y::HideEventData HideEventData;
typedef ::mozilla::a11y::ReorderEventData ReorderEventData;
typedef ::mozilla::a11y::TextChangeEventData TextChangeEventData;
typedef CacheEventData CacheEventData__tdef;
typedef ShowEventData ShowEventData__tdef;
typedef HideEventData HideEventData__tdef;
typedef ReorderEventData ReorderEventData__tdef;
typedef TextChangeEventData TextChangeEventData__tdef;
CacheEventData*
ptr_CacheEventData()
{
return (&(mVCacheEventData));
}
const CacheEventData*
constptr_CacheEventData() const
{
return (&(mVCacheEventData));
}
ShowEventData*
ptr_ShowEventData()
{
return (&(mVShowEventData));
}
const ShowEventData*
constptr_ShowEventData() const
{
return (&(mVShowEventData));
}
HideEventData*
ptr_HideEventData()
{
return (&(mVHideEventData));
}
const HideEventData*
constptr_HideEventData() const
{
return (&(mVHideEventData));
}
ReorderEventData*
ptr_ReorderEventData()
{
return (&(mVReorderEventData));
}
const ReorderEventData*
constptr_ReorderEventData() const
{
return (&(mVReorderEventData));
}
TextChangeEventData*
ptr_TextChangeEventData()
{
return (&(mVTextChangeEventData));
}
const TextChangeEventData*
constptr_TextChangeEventData() const
{
return (&(mVTextChangeEventData));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT MutationEventData() :
mType(T__None)
{
}
MOZ_IMPLICIT MutationEventData(const CacheEventData& aOther);
MOZ_IMPLICIT MutationEventData(CacheEventData&& aOther);
MOZ_IMPLICIT MutationEventData(const ShowEventData& aOther);
MOZ_IMPLICIT MutationEventData(ShowEventData&& aOther);
MOZ_IMPLICIT MutationEventData(const HideEventData& aOther);
MOZ_IMPLICIT MutationEventData(HideEventData&& aOther);
MOZ_IMPLICIT MutationEventData(const ReorderEventData& aOther);
MOZ_IMPLICIT MutationEventData(ReorderEventData&& aOther);
MOZ_IMPLICIT MutationEventData(const TextChangeEventData& aOther);
MOZ_IMPLICIT MutationEventData(TextChangeEventData&& aOther);
MOZ_IMPLICIT MutationEventData(const MutationEventData& aOther);
MOZ_IMPLICIT MutationEventData(MutationEventData&& aOther);
~MutationEventData();
Type
type() const
{
return mType;
}
MutationEventData&
operator=(const CacheEventData& aRhs);
MutationEventData&
operator=(CacheEventData&& aRhs);
MutationEventData&
operator=(const ShowEventData& aRhs);
MutationEventData&
operator=(ShowEventData&& aRhs);
MutationEventData&
operator=(const HideEventData& aRhs);
MutationEventData&
operator=(HideEventData&& aRhs);
MutationEventData&
operator=(const ReorderEventData& aRhs);
MutationEventData&
operator=(ReorderEventData&& aRhs);
MutationEventData&
operator=(const TextChangeEventData& aRhs);
MutationEventData&
operator=(TextChangeEventData&& aRhs);
MutationEventData&
operator=(const MutationEventData& aRhs);
MutationEventData&
operator=(MutationEventData&& aRhs);
CacheEventData&
get_CacheEventData()
{
AssertSanity(TCacheEventData);
return (*(ptr_CacheEventData()));
}
const CacheEventData&
get_CacheEventData() const
{
AssertSanity(TCacheEventData);
return (*(constptr_CacheEventData()));
}
operator CacheEventData&()
{
return get_CacheEventData();
}
operator const CacheEventData&() const
{
return get_CacheEventData();
}
ShowEventData&
get_ShowEventData()
{
AssertSanity(TShowEventData);
return (*(ptr_ShowEventData()));
}
const ShowEventData&
get_ShowEventData() const
{
AssertSanity(TShowEventData);
return (*(constptr_ShowEventData()));
}
operator ShowEventData&()
{
return get_ShowEventData();
}
operator const ShowEventData&() const
{
return get_ShowEventData();
}
HideEventData&
get_HideEventData()
{
AssertSanity(THideEventData);
return (*(ptr_HideEventData()));
}
const HideEventData&
get_HideEventData() const
{
AssertSanity(THideEventData);
return (*(constptr_HideEventData()));
}
operator HideEventData&()
{
return get_HideEventData();
}
operator const HideEventData&() const
{
return get_HideEventData();
}
ReorderEventData&
get_ReorderEventData()
{
AssertSanity(TReorderEventData);
return (*(ptr_ReorderEventData()));
}
const ReorderEventData&
get_ReorderEventData() const
{
AssertSanity(TReorderEventData);
return (*(constptr_ReorderEventData()));
}
operator ReorderEventData&()
{
return get_ReorderEventData();
}
operator const ReorderEventData&() const
{
return get_ReorderEventData();
}
TextChangeEventData&
get_TextChangeEventData()
{
AssertSanity(TTextChangeEventData);
return (*(ptr_TextChangeEventData()));
}
const TextChangeEventData&
get_TextChangeEventData() const
{
AssertSanity(TTextChangeEventData);
return (*(constptr_TextChangeEventData()));
}
operator TextChangeEventData&()
{
return get_TextChangeEventData();
}
operator const TextChangeEventData&() const
{
return get_TextChangeEventData();
}
private:
union {
CacheEventData mVCacheEventData;
ShowEventData mVShowEventData;
HideEventData mVHideEventData;
ReorderEventData mVReorderEventData;
TextChangeEventData mVTextChangeEventData;
};
Type mType;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::MutationEventData>
{
typedef ::mozilla::a11y::MutationEventData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct TextRangeData|
//
namespace mozilla {
namespace a11y {
class TextRangeData final
{
private:
typedef ::uint64_t uint64_t;
typedef ::int32_t int32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
TextRangeData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT TextRangeData(
const uint64_t& _StartID,
const uint64_t& _EndID,
const int32_t& _StartOffset,
const int32_t& _EndOffset) :
StartID_(_StartID),
EndID_(_EndID),
StartOffset_(_StartOffset),
EndOffset_(_EndOffset)
{
}
MOZ_IMPLICIT TextRangeData(
uint64_t&& _StartID,
uint64_t&& _EndID,
int32_t&& _StartOffset,
int32_t&& _EndOffset) :
StartID_(std::move(_StartID)),
EndID_(std::move(_EndID)),
StartOffset_(std::move(_StartOffset)),
EndOffset_(std::move(_EndOffset))
{
}
uint64_t&
StartID()
{
return StartID_;
}
const uint64_t&
StartID() const
{
return StartID_;
}
uint64_t&
EndID()
{
return EndID_;
}
const uint64_t&
EndID() const
{
return EndID_;
}
int32_t&
StartOffset()
{
return StartOffset_;
}
const int32_t&
StartOffset() const
{
return StartOffset_;
}
int32_t&
EndOffset()
{
return EndOffset_;
}
const int32_t&
EndOffset() const
{
return EndOffset_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<uint64_t> StartID_;
::mozilla::ipc::IPDLStructMember<uint64_t> EndID_;
::mozilla::ipc::IPDLStructMember<int32_t> StartOffset_;
::mozilla::ipc::IPDLStructMember<int32_t> EndOffset_;
};
} // namespace a11y
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::TextRangeData>
{
typedef ::mozilla::a11y::TextRangeData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace a11y {
class PDocAccessibleParent;
} // namespace a11y
} // namespace mozilla
namespace mozilla {
namespace a11y {
class PDocAccessibleChild;
} // namespace a11y
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PDocAccessibleChild and PDocAccessibleParent
//
namespace mozilla {
namespace a11y {
namespace PDocAccessible {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::a11y::PDocAccessibleParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::a11y::PDocAccessibleChild>* aChild);
enum MessageType {
PDocAccessibleStart = PDocAccessibleMsgStart << 16,
Msg_Shutdown__ID,
Msg_Event__ID,
Msg_StateChangeEvent__ID,
Msg_CaretMoveEvent__ID,
Msg_MutationEvents__ID,
Msg_RequestAckMutationEvents__ID,
Msg_SelectionEvent__ID,
Msg_RoleChangedEvent__ID,
Msg_FocusEvent__ID,
Msg_ScrollingEvent__ID,
Msg_AnnouncementEvent__ID,
Msg_TextSelectionChangeEvent__ID,
Msg_BindChildDoc__ID,
Msg_Cache__ID,
Msg_SelectedAccessiblesChanged__ID,
Msg_AccessiblesWillMove__ID,
Msg___delete____ID,
Reply___delete____ID,
Msg_RestoreFocus__ID,
Msg_ScrollTo__ID,
Msg_ScrollToPoint__ID,
Msg_SetTextSelection__ID,
Msg_RemoveTextSelection__ID,
Msg_ScrollTextLeafRangeIntoView__ID,
Msg_ScrollSubstringToPoint__ID,
Msg_ReplaceText__ID,
Msg_InsertText__ID,
Msg_CopyText__ID,
Msg_CutText__ID,
Msg_DeleteText__ID,
Msg_PasteText__ID,
Msg_TakeSelection__ID,
Msg_SetSelected__ID,
Msg_DoActionAsync__ID,
Msg_SetCurValue__ID,
Msg_TakeFocus__ID,
Msg_VerifyCache__ID,
Msg_AckMutationEvents__ID,
PDocAccessibleEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_Shutdown(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Event(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_StateChangeEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CaretMoveEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_MutationEvents(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestAckMutationEvents(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SelectionEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RoleChangedEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_FocusEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ScrollingEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_AnnouncementEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_TextSelectionChangeEvent(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_BindChildDoc(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Cache(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SelectedAccessiblesChanged(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_AccessiblesWillMove(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RestoreFocus(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ScrollTo(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ScrollToPoint(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetTextSelection(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RemoveTextSelection(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ScrollTextLeafRangeIntoView(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ScrollSubstringToPoint(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ReplaceText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_InsertText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CopyText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_CutText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_DeleteText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_PasteText(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_TakeSelection(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetSelected(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_DoActionAsync(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetCurValue(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_TakeFocus(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_VerifyCache(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_AckMutationEvents(IPC::Message::routeid_t routingId);
} // namespace PDocAccessible
} // namespace a11y
} // namespace mozilla
#endif // ifndef PDocAccessible_h