#pragma once

#include "qobject_wrapper.h"

namespace shelllet {

namespace gui {

template<typename T, bool> class QWindowPrivate;

template<typename T, typename U, bool C>

class QWindowWrapper : public core::QObjectWrapper<T, U, C>

{

public:

template<bool M>

QWindowWrapper(QWindowPrivate<T, M>& d, const v8::FunctionCallbackInfo<v8::Value>& args)

: QObjectWrapper(d, args) {

}

QWindowWrapper(v8::Isolate* isolate, const v8::Local<v8::FunctionTemplate>& tpl) : QObjectWrapper(isolate, tpl) {}

QWindowWrapper(v8::Isolate* isolate, const v8::Local<v8::ObjectTemplate>& proto) : QObjectWrapper(isolate, proto) {

tpl->PrototypeTemplate()->Set(isolate, "setSurfaceType", v8::FunctionTemplate::New(isolate, SetSurfaceType));

tpl->PrototypeTemplate()->Set(isolate, "surfaceType", v8::FunctionTemplate::New(isolate, SurfaceType));

tpl->PrototypeTemplate()->Set(isolate, "create", v8::FunctionTemplate::New(isolate, Create));

tpl->PrototypeTemplate()->Set(isolate, "winId", v8::FunctionTemplate::New(isolate, WinId));

tpl->PrototypeTemplate()->Set(isolate, "parent", v8::FunctionTemplate::New(isolate, Parent));

tpl->PrototypeTemplate()->Set(isolate, "setParent", v8::FunctionTemplate::New(isolate, SetParent));

tpl->PrototypeTemplate()->Set(isolate, "isTopLevel", v8::FunctionTemplate::New(isolate, IsTopLevel));

tpl->PrototypeTemplate()->Set(isolate, "isModal", v8::FunctionTemplate::New(isolate, IsModal));

tpl->PrototypeTemplate()->Set(isolate, "setFormat", v8::FunctionTemplate::New(isolate, SetFormat));

tpl->PrototypeTemplate()->Set(isolate, "format", v8::FunctionTemplate::New(isolate, Format));

tpl->PrototypeTemplate()->Set(isolate, "requestedFormat", v8::FunctionTemplate::New(isolate, RequestedFormat));

tpl->PrototypeTemplate()->Set(isolate, "setFlag", v8::FunctionTemplate::New(isolate, SetFlag));

tpl->PrototypeTemplate()->Set(isolate, "type", v8::FunctionTemplate::New(isolate, Type));

tpl->PrototypeTemplate()->Set(isolate, "setMask", v8::FunctionTemplate::New(isolate, SetMask));

tpl->PrototypeTemplate()->Set(isolate, "mask", v8::FunctionTemplate::New(isolate, Mask));

tpl->PrototypeTemplate()->Set(isolate, "contentOrientation", v8::FunctionTemplate::New(isolate, ContentOrientation));

tpl->PrototypeTemplate()->Set(isolate, "devicePixelRatio", v8::FunctionTemplate::New(isolate, DevicePixelRatio));

tpl->PrototypeTemplate()->Set(isolate, "windowState", v8::FunctionTemplate::New(isolate, WindowState));

tpl->PrototypeTemplate()->Set(isolate, "windowStates", v8::FunctionTemplate::New(isolate, WindowStates));

tpl->PrototypeTemplate()->Set(isolate, "setWindowState", v8::FunctionTemplate::New(isolate, SetWindowState));

tpl->PrototypeTemplate()->Set(isolate, "setWindowStates", v8::FunctionTemplate::New(isolate, SetWindowStates));

tpl->PrototypeTemplate()->Set(isolate, "setTransientParent", v8::FunctionTemplate::New(isolate, SetTransientParent));

tpl->PrototypeTemplate()->Set(isolate, "transientParent", v8::FunctionTemplate::New(isolate, TransientParent));

tpl->PrototypeTemplate()->Set(isolate, "isAncestorOf", v8::FunctionTemplate::New(isolate, IsAncestorOf));

tpl->PrototypeTemplate()->Set(isolate, "isExposed", v8::FunctionTemplate::New(isolate, IsExposed));

tpl->PrototypeTemplate()->Set(isolate, "baseSize", v8::FunctionTemplate::New(isolate, BaseSize));

tpl->PrototypeTemplate()->Set(isolate, "sizeIncrement", v8::FunctionTemplate::New(isolate, SizeIncrement));

tpl->PrototypeTemplate()->Set(isolate, "setBaseSize", v8::FunctionTemplate::New(isolate, SetBaseSize));

tpl->PrototypeTemplate()->Set(isolate, "setSizeIncrement", v8::FunctionTemplate::New(isolate, SetSizeIncrement));

tpl->PrototypeTemplate()->Set(isolate, "geometry", v8::FunctionTemplate::New(isolate, Geometry));

tpl->PrototypeTemplate()->Set(isolate, "frameMargins", v8::FunctionTemplate::New(isolate, FrameMargins));

tpl->PrototypeTemplate()->Set(isolate, "frameGeometry", v8::FunctionTemplate::New(isolate, FrameGeometry));

tpl->PrototypeTemplate()->Set(isolate, "framePosition", v8::FunctionTemplate::New(isolate, FramePosition));

tpl->PrototypeTemplate()->Set(isolate, "setFramePosition", v8::FunctionTemplate::New(isolate, SetFramePosition));

tpl->PrototypeTemplate()->Set(isolate, "position", v8::FunctionTemplate::New(isolate, Position));

tpl->PrototypeTemplate()->Set(isolate, "setPosition", v8::FunctionTemplate::New(isolate, SetPosition));

tpl->PrototypeTemplate()->Set(isolate, "resize", v8::FunctionTemplate::New(isolate, Resize));

tpl->PrototypeTemplate()->Set(isolate, "setFilePath", v8::FunctionTemplate::New(isolate, SetFilePath));

tpl->PrototypeTemplate()->Set(isolate, "filePath", v8::FunctionTemplate::New(isolate, FilePath));

tpl->PrototypeTemplate()->Set(isolate, "setIcon", v8::FunctionTemplate::New(isolate, SetIcon));

tpl->PrototypeTemplate()->Set(isolate, "icon", v8::FunctionTemplate::New(isolate, Icon));

tpl->PrototypeTemplate()->Set(isolate, "destroy", v8::FunctionTemplate::New(isolate, Destroy));

tpl->PrototypeTemplate()->Set(isolate, "setKeyboardGrabEnabled", v8::FunctionTemplate::New(isolate, SetKeyboardGrabEnabled));

tpl->PrototypeTemplate()->Set(isolate, "setMouseGrabEnabled", v8::FunctionTemplate::New(isolate, SetMouseGrabEnabled));

tpl->PrototypeTemplate()->Set(isolate, "screen", v8::FunctionTemplate::New(isolate, Screen));

tpl->PrototypeTemplate()->Set(isolate, "setScreen", v8::FunctionTemplate::New(isolate, SetScreen));

tpl->PrototypeTemplate()->Set(isolate, "mapToGlobal", v8::FunctionTemplate::New(isolate, MapToGlobal));

tpl->PrototypeTemplate()->Set(isolate, "mapFromGlobal", v8::FunctionTemplate::New(isolate, MapFromGlobal));

tpl->PrototypeTemplate()->Set(isolate, "cursor", v8::FunctionTemplate::New(isolate, Cursor));

tpl->PrototypeTemplate()->Set(isolate, "setCursor", v8::FunctionTemplate::New(isolate, SetCursor));

tpl->PrototypeTemplate()->Set(isolate, "unsetCursor", v8::FunctionTemplate::New(isolate, UnsetCursor));

tpl->PrototypeTemplate()->Set(isolate, "setVulkanInstance", v8::FunctionTemplate::New(isolate, SetVulkanInstance));

tpl->PrototypeTemplate()->Set(isolate, "vulkanInstance", v8::FunctionTemplate::New(isolate, VulkanInstance));

tpl->PrototypeTemplate()->Set(isolate, "show", v8::FunctionTemplate::New(isolate, Show));

tpl->PrototypeTemplate()->Set(isolate, "hide", v8::FunctionTemplate::New(isolate, Hide));

tpl->PrototypeTemplate()->Set(isolate, "showMinimized", v8::FunctionTemplate::New(isolate, ShowMinimized));

tpl->PrototypeTemplate()->Set(isolate, "showMaximized", v8::FunctionTemplate::New(isolate, ShowMaximized));

tpl->PrototypeTemplate()->Set(isolate, "showFullScreen", v8::FunctionTemplate::New(isolate, ShowFullScreen));

tpl->PrototypeTemplate()->Set(isolate, "showNormal", v8::FunctionTemplate::New(isolate, ShowNormal));

tpl->PrototypeTemplate()->Set(isolate, "close", v8::FunctionTemplate::New(isolate, Close));

tpl->PrototypeTemplate()->Set(isolate, "raise", v8::FunctionTemplate::New(isolate, Raise));

tpl->PrototypeTemplate()->Set(isolate, "lower", v8::FunctionTemplate::New(isolate, Lower));

tpl->PrototypeTemplate()->Set(isolate, "setGeometry", v8::FunctionTemplate::New(isolate, SetGeometry));

tpl->PrototypeTemplate()->Set(isolate, "reportContentOrientationChange", v8::FunctionTemplate::New(isolate, ReportContentOrientationChange));

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "isVisible"), IsVisible, SetVisible);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "visibility"), Visibility, SetVisibility);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "modality"), Modality, SetModality);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "flags"), Flags, SetFlags);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "title"), Title, SetTitle);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "isActive"), IsActive, SetActive);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "minimumWidth"), MinimumWidth, SetMinimumWidth);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "minimumHeight"), MinimumHeight, SetMinimumHeight);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "maximumWidth"), MaximumWidth, SetMaximumWidth);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "maximumHeight"), MaximumHeight, SetMaximumHeight);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "width"), Width, SetWidth);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "height"), Height, SetHeight);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "x"), X, SetX);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "y"), Y, SetY);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "screenChanged"), nullptr, ScreenChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "modalityChanged"), nullptr, ModalityChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "windowStateChanged"), nullptr, WindowStateChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "xChanged"), nullptr, XChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "yChanged"), nullptr, YChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "widthChanged"), nullptr, WidthChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "heightChanged"), nullptr, HeightChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "minimumWidthChanged"), nullptr, MinimumWidthChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "minimumHeightChanged"), nullptr, MinimumHeightChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "maximumWidthChanged"), nullptr, MaximumWidthChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "maximumHeightChanged"), nullptr, MaximumHeightChanged);

tpl->PrototypeTemplate()->SetAccessor(convert::String::New(isolate, "visibleChanged"), nullptr, VisibleChanged);

{

v8::Local<v8::ObjectTemplate> visibility = v8::ObjectTemplate::New(isolate);

visibility->Set(isolate, "Hidden", v8::Int32::New(isolate, QWindow::Visibility::Hidden));

visibility->Set(isolate, "AutomaticVisibility", v8::Int32::New(isolate, QWindow::Visibility::AutomaticVisibility));

visibility->Set(isolate, "Windowed", v8::Int32::New(isolate, QWindow::Visibility::Windowed));

visibility->Set(isolate, "Minimized", v8::Int32::New(isolate, QWindow::Visibility::Minimized));

visibility->Set(isolate, "Maximized", v8::Int32::New(isolate, QWindow::Visibility::Maximized));

visibility->Set(isolate, "FullScreen", v8::Int32::New(isolate, QWindow::Visibility::FullScreen));

tpl->Set(isolate, "Visibility", visibility);

v8::Local<v8::ObjectTemplate> ancestorMode = v8::ObjectTemplate::New(isolate);

ancestorMode->Set(isolate, "ExcludeTransients", v8::Int32::New(isolate, QWindow::AncestorMode::ExcludeTransients));

ancestorMode->Set(isolate, "IncludeTransients", v8::Int32::New(isolate, QWindow::AncestorMode::IncludeTransients));

tpl->Set(isolate, "AncestorMode", ancestorMode);

tpl->Set(isolate, "fromWinId", v8::FunctionTemplate::New(isolate, FromWinId));

}

}

protected:

QObject* focusObject() const

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> result = call(isolate, context, "focusObject", 0, {});

if (!result->IsObject()) {

throw std::logic_error("!return type error.");

}

auto* p = convert::Object::UnWrap<core::Object>(result->ToObject(context).ToLocalChecked());

if (p)

return **p;

return nullptr;

}

V8_CREATE_LOCAL_CONTEXT_END

}

void exposeEvent(QExposeEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "ExposeEvent", std::size(argv), argv);

}) };

call(isolate, context, "exposeEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void resizeEvent(QResizeEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "ResizeEvent", std::size(argv), argv);

}) };

call(isolate, context, "resizeEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void moveEvent(QMoveEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "MoveEvent", std::size(argv), argv);

}) };

call(isolate, context, "QMoveEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void focusInEvent(QFocusEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "FocusEvent", std::size(argv), argv);

}) };

call(isolate, context, "focusInEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void focusOutEvent(QFocusEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "FocusEvent", std::size(argv), argv);

}) };

call(isolate, context, "focusOutEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void showEvent(QShowEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "ShowEvent", std::size(argv), argv);

}) };

call(isolate, context, "showEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void hideEvent(QHideEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "HideEvent", std::size(argv), argv);

}) };

call(isolate, context, "hideEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void keyPressEvent(QKeyEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "KeyEvent", std::size(argv), argv);

}) };

call(isolate, context, "keyPressEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void keyReleaseEvent(QKeyEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "KeyEvent", std::size(argv), argv);

}) };

call(isolate, context, "keyReleaseEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void mousePressEvent(QMouseEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "MouseEvent", std::size(argv), argv);

}) };

call(isolate, context, "mousePressEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void mouseReleaseEvent(QMouseEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "MouseEvent", std::size(argv), argv);

}) };

call(isolate, context, "mouseReleaseEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void mouseDoubleClickEvent(QMouseEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "MouseEvent", std::size(argv), argv);

}) };

call(isolate, context, "mouseDoubleClickEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void mouseMoveEvent(QMouseEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "MouseEvent", std::size(argv), argv);

}) };

call(isolate, context, "mouseMoveEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void wheelEvent(QWheelEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "WheelEvent", std::size(argv), argv);

}) };

call(isolate, context, "wheelEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void touchEvent(QTouchEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "TouchEvent", std::size(argv), argv);

}) };

call(isolate, context, "touchEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

void tabletEvent(QTabletEvent* e)

{

v8::Isolate* isolate = v8::Isolate::GetCurrent();

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_ISOLATE(isolate)

{

v8::Local<v8::Value> argv[] = { std::invoke([&]() {

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, e) };

return convert::Object::Wrap(isolate, context, "TabletEvent", std::size(argv), argv);

}) };

call(isolate, context, "tabletEvent", std::size(argv), argv);

}

V8_CREATE_LOCAL_CONTEXT_END

}

protected:

static void SetSurfaceType(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto surfaceType = std::invoke([&]() {

if (!args[0]->IsInt32())

throw std::invalid_argument("!`Int32` required at [0].");

return static_cast<QSurface::SurfaceType>(args[0]->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setSurfaceType>(std::move(surfaceType));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SurfaceType(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::surfaceType>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void IsVisible(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Boolean::New(isolate, p->d_func()->invoke<&QWindow::isVisible>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetVisible(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto visible = std::invoke([&]() {

if (!value->IsBoolean())

throw std::invalid_argument("!`Boolean` required.");

return value->BooleanValue(isolate);

});

p->d_func()->invoke<&QWindow::setVisible>(std::move(visible));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Visibility(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::visibility>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetVisibility(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto visibility = std::invoke([&]() {

if (!value->IsInt32())

throw std::invalid_argument("!`Object` required.");

return static_cast<QWindow::Visibility>(value->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setVisibility>(std::move(visibility));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Create(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

p->d_func()->invoke<&QWindow::create>();

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void WinId(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::winId>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Parent(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

QWindow* w = nullptr;

if (args.Length() > 0) {

auto mode = std::invoke([&]() {

if (!args[0]->IsInt32())

throw std::invalid_argument("!`Object` required at [0].");

return static_cast<QWindow::AncestorMode>(args[0]->Int32Value(context).FromJust());

});

w = p->d_func()->invoke<qOverload<QWindow::AncestorMode>(&QWindow::parent)>(std::move(mode));

}

else {

w = p->d_func()->invoke<qOverload<>(&QWindow::parent)>();

}

v8::Local<v8::Value>argv[] = { v8::External::New(isolate, w) };

args.GetReturnValue().Set(convert::Object::Wrap(isolate, context, "Window", std::size(argv), argv));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetParent(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

p->d_func()->setParent(**Window::FromValue(isolate, args[0]));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void IsTopLevel(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Boolean::New(isolate, p->d_func()->invoke<&QWindow::isTopLevel>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void IsModal(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Boolean::New(isolate, p->d_func()->invoke<&QWindow::isModal>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Modality(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::modality>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetModality(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto modality = std::invoke([&]() {

if (!value->IsInt32())

throw std::invalid_argument("!`Object` required.");

return static_cast<Qt::WindowModality>(value->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setModality>(std::move(modality));

}

V8_CREATE_LOCAL_CONTEXT_END

}

// TODO:

static void SetFormat(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto format = std::invoke([&]() {

if (!args[0]->IsObject())

throw std::invalid_argument("!`Object` required at [0].");

return args[0]->Int32Value(context).FromJust();

});

//p->d_func()->invoke2<&QWindow::setFormat>( format);

}

V8_CREATE_LOCAL_CONTEXT_END

}

// TODO:

static void Format(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

}

V8_CREATE_LOCAL_CONTEXT_END

}

// TODO:

static void RequestedFormat(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Flags(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::flags>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetFlags(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto flags = std::invoke([&]() {

if (!value->IsObject())

throw std::invalid_argument("!`Object` required.");

return static_cast<Qt::WindowFlags>(value->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setFlags>(std::move(flags));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Flags(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::flags>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetFlag(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto flag = std::invoke([&]() {

if (!args[0]->IsInt32())

throw std::invalid_argument("!`Int32` required at [0].");

return static_cast<Qt::WindowType>(args[0]->Int32Value(context).FromJust());

});

auto on = std::invoke([&]() {

if (args[1]->IsBoolean())

return args[1]->BooleanValue(isolate);

return true;

});

p->d_func()->setFlag(flag, on);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Type(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::type>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Title(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = convert::String::New(isolate, p->d_func()->title());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetTitle(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto title = std::invoke([&]() {

if (!value->IsString())

throw std::invalid_argument("!`String` required.");

return convert::String::To(isolate, value);

});

p->d_func()->invoke<&QWindow::setTitle>(std::move(title));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetOpacity(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto opacity = std::invoke([&]() {

if (!value->IsNumber())

throw std::invalid_argument("!`Object` required.");

return value->NumberValue(context).FromJust();

});

p->d_func()->invoke<&QWindow::setOpacity>(std::move(opacity));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void Opacity(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Number::New(isolate, p->d_func()->invoke<&QWindow::opacity>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

// TODO:

static void SetMask(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

/*auto region = std::invoke([&]() {

if (!args[0]->IsObject())

throw std::invalid_argument("!`Object` required at [0].");

return convert::Object::UnWrap<QRegion>(args[0]);

});

p->d_func()->setMask(*region);*/

}

V8_CREATE_LOCAL_CONTEXT_END

}

// TODO:

static void Mask(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto region = p->d_func()->invoke<&QWindow::mask>();

v8::Local<v8::Value> argv[] = { v8::External::New(isolate, &region) };

args.GetReturnValue().Set(convert::Object::Wrap(isolate, context, "Region", std::size(argv), argv));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void IsActive(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto result = v8::Boolean::New(isolate, p->d_func()->invoke<&QWindow::isActive>());

info.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetActive(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(info)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(info.This());

if (!p) {

return;

}

auto title = std::invoke([&]() {

if (!value->IsString())

throw std::invalid_argument("!`String` required.");

return convert::String::To(isolate, value);

});

p->d_func()->invoke<&QWindow::setTitle>(std::move(title));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void ContentOrientation(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::contentOrientation>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void DevicePixelRatio(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Number::New(isolate, p->d_func()->invoke<&QWindow::devicePixelRatio>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void WindowState(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::windowState>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void WindowStates(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto result = v8::Int32::New(isolate, p->d_func()->invoke<&QWindow::windowStates>());

args.GetReturnValue().Set(result);

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetWindowState(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto state = std::invoke([&]() {

if (!args[0]->IsInt32())

throw std::invalid_argument("!`Object` required at [0].");

return static_cast<Qt::WindowState>(args[0]->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setWindowState>(std::move(state));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetWindowStates(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto states = std::invoke([&]() {

if (!args[0]->IsObject())

throw std::invalid_argument("!`Object` required at [0].");

return static_cast<Qt::WindowStates>(args[0]->Int32Value(context).FromJust());

});

p->d_func()->invoke<&QWindow::setWindowStates>(std::move(states));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void SetTransientParent(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

p->d_func()->setTransientParent(**Window::FromValue(isolate, args[0]));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void TransientParent(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

QWindow* w = p->d_func()->invoke<&QWindow::transientParent>();

v8::Local<v8::Value>argv[] = { v8::External::New(isolate, w) };

args.GetReturnValue().Set(convert::Object::Wrap(isolate, context, "Window", std::size(argv), argv));

}

V8_CREATE_LOCAL_CONTEXT_END

}

static void IsAncestorOf(const v8::FunctionCallbackInfo<v8::Value>& args)

{

V8_CREATE_LOCAL_CONTEXT_WITHOUT_LOCKER_BY_CALLBACK_INFO(args)

{

auto* p = convert::Object::UnWrap<QWindowWrapper<T, U, C>>(args.This());

if (!p) {

return;

}

auto child = Window::FromValue(isolate, args[0]);

auto mode = QWindow::IncludeTransients;

if (args[1]->IsNumber())

mode = static_cast<QWindow::AncestorMode>(args[1]->Int32Value(context).FromJust());

auto result = v8::Boolean::New(isolate, p->d_func()->invoke<&QWindow::isAncestorOf>(**child, mode));

args.GetReturnValue().Set(result);