Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef LookAndFeelTypes_h
#define LookAndFeelTypes_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/ipc/IPDLStructMember.h"
#include "nsColor.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct LookAndFeelFont|
//
namespace mozilla {
namespace widget {
class LookAndFeelFont final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LookAndFeelFont() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LookAndFeelFont(
const bool& _haveFont,
const nsString& _name,
const float& _size,
const float& _weight,
const bool& _italic) :
haveFont_(_haveFont),
name_(_name),
italic_(_italic),
size_(_size),
weight_(_weight)
{
}
MOZ_IMPLICIT LookAndFeelFont(
bool&& _haveFont,
nsString&& _name,
float&& _size,
float&& _weight,
bool&& _italic) :
haveFont_(std::move(_haveFont)),
name_(std::move(_name)),
italic_(std::move(_italic)),
size_(std::move(_size)),
weight_(std::move(_weight))
{
}
bool
operator==(const LookAndFeelFont& _o) const;
bool
operator!=(const LookAndFeelFont& _o) const;
bool&
haveFont()
{
return haveFont_;
}
const bool&
haveFont() const
{
return haveFont_;
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
float&
size()
{
return size_;
}
const float&
size() const
{
return size_;
}
float&
weight()
{
return weight_;
}
const float&
weight() const
{
return weight_;
}
bool&
italic()
{
return italic_;
}
const bool&
italic() const
{
return italic_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<bool> haveFont_;
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<bool> italic_;
::mozilla::ipc::IPDLStructMember<float> size_;
::mozilla::ipc::IPDLStructMember<float> weight_;
};
} // namespace widget
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::widget::LookAndFeelFont>
{
typedef ::mozilla::widget::LookAndFeelFont 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 LookAndFeelTables|
//
namespace mozilla {
namespace widget {
class LookAndFeelTables final
{
private:
typedef ::int32_t int32_t;
typedef ::mozilla::widget::LookAndFeelFont LookAndFeelFont;
typedef ::nscolor nscolor;
typedef ::uint8_t uint8_t;
typedef ::uint16_t uint16_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LookAndFeelTables() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LookAndFeelTables(
const nsTArray<int32_t>& _ints,
const nsTArray<float>& _floats,
const nsTArray<LookAndFeelFont>& _fonts,
const nsTArray<nscolor>& _lightColors,
const nsTArray<nscolor>& _darkColors,
const nsTArray<uint8_t>& _intMap,
const nsTArray<uint8_t>& _floatMap,
const nsTArray<uint8_t>& _fontMap,
const nsTArray<uint8_t>& _lightColorMap,
const nsTArray<uint8_t>& _darkColorMap,
const uint16_t& _passwordChar,
const bool& _passwordEcho) :
ints_(_ints),
floats_(_floats),
fonts_(_fonts),
lightColors_(_lightColors),
darkColors_(_darkColors),
intMap_(_intMap),
floatMap_(_floatMap),
fontMap_(_fontMap),
lightColorMap_(_lightColorMap),
darkColorMap_(_darkColorMap),
passwordEcho_(_passwordEcho),
passwordChar_(_passwordChar)
{
}
MOZ_IMPLICIT LookAndFeelTables(
nsTArray<int32_t>&& _ints,
nsTArray<float>&& _floats,
nsTArray<LookAndFeelFont>&& _fonts,
nsTArray<nscolor>&& _lightColors,
nsTArray<nscolor>&& _darkColors,
nsTArray<uint8_t>&& _intMap,
nsTArray<uint8_t>&& _floatMap,
nsTArray<uint8_t>&& _fontMap,
nsTArray<uint8_t>&& _lightColorMap,
nsTArray<uint8_t>&& _darkColorMap,
uint16_t&& _passwordChar,
bool&& _passwordEcho) :
ints_(std::move(_ints)),
floats_(std::move(_floats)),
fonts_(std::move(_fonts)),
lightColors_(std::move(_lightColors)),
darkColors_(std::move(_darkColors)),
intMap_(std::move(_intMap)),
floatMap_(std::move(_floatMap)),
fontMap_(std::move(_fontMap)),
lightColorMap_(std::move(_lightColorMap)),
darkColorMap_(std::move(_darkColorMap)),
passwordEcho_(std::move(_passwordEcho)),
passwordChar_(std::move(_passwordChar))
{
}
nsTArray<int32_t>&
ints()
{
return ints_;
}
const nsTArray<int32_t>&
ints() const
{
return ints_;
}
nsTArray<float>&
floats()
{
return floats_;
}
const nsTArray<float>&
floats() const
{
return floats_;
}
nsTArray<LookAndFeelFont>&
fonts()
{
return fonts_;
}
const nsTArray<LookAndFeelFont>&
fonts() const
{
return fonts_;
}
nsTArray<nscolor>&
lightColors()
{
return lightColors_;
}
const nsTArray<nscolor>&
lightColors() const
{
return lightColors_;
}
nsTArray<nscolor>&
darkColors()
{
return darkColors_;
}
const nsTArray<nscolor>&
darkColors() const
{
return darkColors_;
}
nsTArray<uint8_t>&
intMap()
{
return intMap_;
}
const nsTArray<uint8_t>&
intMap() const
{
return intMap_;
}
nsTArray<uint8_t>&
floatMap()
{
return floatMap_;
}
const nsTArray<uint8_t>&
floatMap() const
{
return floatMap_;
}
nsTArray<uint8_t>&
fontMap()
{
return fontMap_;
}
const nsTArray<uint8_t>&
fontMap() const
{
return fontMap_;
}
nsTArray<uint8_t>&
lightColorMap()
{
return lightColorMap_;
}
const nsTArray<uint8_t>&
lightColorMap() const
{
return lightColorMap_;
}
nsTArray<uint8_t>&
darkColorMap()
{
return darkColorMap_;
}
const nsTArray<uint8_t>&
darkColorMap() const
{
return darkColorMap_;
}
uint16_t&
passwordChar()
{
return passwordChar_;
}
const uint16_t&
passwordChar() const
{
return passwordChar_;
}
bool&
passwordEcho()
{
return passwordEcho_;
}
const bool&
passwordEcho() const
{
return passwordEcho_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<int32_t>> ints_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<float>> floats_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<LookAndFeelFont>> fonts_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nscolor>> lightColors_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nscolor>> darkColors_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> intMap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> floatMap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> fontMap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> lightColorMap_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> darkColorMap_;
::mozilla::ipc::IPDLStructMember<bool> passwordEcho_;
::mozilla::ipc::IPDLStructMember<uint16_t> passwordChar_;
};
} // namespace widget
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::widget::LookAndFeelTables>
{
typedef ::mozilla::widget::LookAndFeelTables 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 FullLookAndFeel|
//
namespace mozilla {
namespace widget {
class FullLookAndFeel final
{
private:
typedef ::mozilla::widget::LookAndFeelTables LookAndFeelTables;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
FullLookAndFeel() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FullLookAndFeel(const LookAndFeelTables& _tables) :
tables_(_tables)
{
}
MOZ_IMPLICIT FullLookAndFeel(LookAndFeelTables&& _tables) :
tables_(std::move(_tables))
{
}
LookAndFeelTables&
tables()
{
return tables_;
}
const LookAndFeelTables&
tables() const
{
return tables_;
}
private:
::mozilla::ipc::IPDLStructMember<LookAndFeelTables> tables_;
};
} // namespace widget
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::widget::FullLookAndFeel>
{
typedef ::mozilla::widget::FullLookAndFeel paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef LookAndFeelTypes_h