//
// 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
