Format cpp code

src/cpp/include/nodegui/QtCore/QAbstractItemModel/nabstractitemmodel.hpp

@@ -2,115 +2,142 @@
 #include <QAbstractItemModel>
 
 #include "Extras/Export/export.h"
+#include "QtCore/QModelIndex/qmodelindex_wrap.h"
 #include "QtCore/QObject/qobject_macro.h"
 #include "core/NodeWidget/nodewidget.h"
-#include "QtCore/QModelIndex/qmodelindex_wrap.h"
-
 #include "napi.h"
 
-class DLL_EXPORT NAbstractItemModel : public QAbstractItemModel, public EventWidget {
+class DLL_EXPORT NAbstractItemModel : public QAbstractItemModel,
+                                      public EventWidget {
   Q_OBJECT
   EVENTWIDGET_IMPLEMENTATIONS(QAbstractItemModel)
  public:
   Napi::FunctionReference dispatchOnNode;
 
-  void connectSignalsToEventEmitter() {
+  void connectSignalsToEventEmitter(){
-    // Qt Connects: Implement all signal connects here
+      // Qt Connects: Implement all signal connects here
-    QOBJECT_SIGNALS
+      QOBJECT_SIGNALS}
-  }
 
-  QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override {
+  QModelIndex index(int row, int column,
+                    const QModelIndex& parent = QModelIndex()) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto parentModelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
+    auto parentModelIndexWrap = QModelIndexWrap::constructor.New(
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
     Napi::Value modelIndexNapiWrap = this->dispatchOnNode.Call(
-        {Napi::String::New(env, "index"), Napi::Value::From(env, row), Napi::Value::From(env, column), parentModelIndexWrap});
+        {Napi::String::New(env, "index"), Napi::Value::From(env, row),
+         Napi::Value::From(env, column), parentModelIndexWrap});
 
-    QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(modelIndexNapiWrap.As<Napi::Object>());
+    QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(
+        modelIndexNapiWrap.As<Napi::Object>());
     QModelIndex* newIndex = modelIndexWrap->getInternalInstance();
     return *newIndex;
   }
 
-  QModelIndex parent(const QModelIndex &child) const override {
+  QModelIndex parent(const QModelIndex& child) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto childModelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(child))});
+    auto childModelIndexWrap = QModelIndexWrap::constructor.New(
-    Napi::Value modelIndexNapiWrap = this->dispatchOnNode.Call({Napi::String::New(env, "parent"), childModelIndexWrap});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(child))});
+    Napi::Value modelIndexNapiWrap = this->dispatchOnNode.Call(
+        {Napi::String::New(env, "parent"), childModelIndexWrap});
 
-    QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(modelIndexNapiWrap.As<Napi::Object>());
+    QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(
+        modelIndexNapiWrap.As<Napi::Object>());
     QModelIndex* parentIndex = modelIndexWrap->getInternalInstance();
     return *parentIndex;
   }
 
-  int rowCount(const QModelIndex &parent = QModelIndex()) const override {
+  int rowCount(const QModelIndex& parent = QModelIndex()) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto modelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
+    auto modelIndexWrap = QModelIndexWrap::constructor.New(
-    Napi::Value result = this->dispatchOnNode.Call({Napi::String::New(env, "rowCount"), modelIndexWrap});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
+    Napi::Value result = this->dispatchOnNode.Call(
+        {Napi::String::New(env, "rowCount"), modelIndexWrap});
 
     return result.As<Napi::Number>().Int32Value();
   }
 
-  int columnCount(const QModelIndex &parent = QModelIndex()) const override {
+  int columnCount(const QModelIndex& parent = QModelIndex()) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto modelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
+    auto modelIndexWrap = QModelIndexWrap::constructor.New(
-    Napi::Value result = this->dispatchOnNode.Call({Napi::String::New(env, "columnCount"), modelIndexWrap});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(parent))});
+    Napi::Value result = this->dispatchOnNode.Call(
+        {Napi::String::New(env, "columnCount"), modelIndexWrap});
     return result.As<Napi::Number>().Int32Value();
   }
 
-  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
+  QVariant data(const QModelIndex& index,
+                int role = Qt::DisplayRole) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto modelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    auto modelIndexWrap = QModelIndexWrap::constructor.New(
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
     auto roleValue = Napi::Value::From(env, role);
-    Napi::Value variantJsObject = this->dispatchOnNode.Call({Napi::String::New(env, "data"), modelIndexWrap, roleValue});
+    Napi::Value variantJsObject = this->dispatchOnNode.Call(
+        {Napi::String::New(env, "data"), modelIndexWrap, roleValue});
 
-    QVariantWrap* variantWrap = Napi::ObjectWrap<QVariantWrap>::Unwrap(variantJsObject.As<Napi::Object>());
+    QVariantWrap* variantWrap = Napi::ObjectWrap<QVariantWrap>::Unwrap(
+        variantJsObject.As<Napi::Object>());
     QVariant* variant = variantWrap->getInternalInstance();
     return *variant;
   }
 
-  Qt::ItemFlags flags(const QModelIndex &index) const override {
+  Qt::ItemFlags flags(const QModelIndex& index) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto modelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    auto modelIndexWrap = QModelIndexWrap::constructor.New(
-    Napi::Value numberJs = this->dispatchOnNode.Call({Napi::String::New(env, "flags"), modelIndexWrap});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    Napi::Value numberJs = this->dispatchOnNode.Call(
+        {Napi::String::New(env, "flags"), modelIndexWrap});
 
-    auto result = static_cast<Qt::ItemFlags>(numberJs.As<Napi::Number>().Uint32Value());
+    auto result =
+        static_cast<Qt::ItemFlags>(numberJs.As<Napi::Number>().Uint32Value());
     return result;
   }
 
-  QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override {
+  QVariant headerData(int section, Qt::Orientation orientation,
+                      int role = Qt::DisplayRole) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
     auto sectionValue = Napi::Value::From(env, static_cast<int>(section));
-    auto orientationValue = Napi::Value::From(env, static_cast<int>(orientation));
+    auto orientationValue =
+        Napi::Value::From(env, static_cast<int>(orientation));
     auto roleValue = Napi::Value::From(env, static_cast<int>(role));
 
-    Napi::Value variantJsObject = this->dispatchOnNode.Call({Napi::String::New(env, "headerData"), sectionValue, orientationValue, roleValue});
+    Napi::Value variantJsObject =
+        this->dispatchOnNode.Call({Napi::String::New(env, "headerData"),
+                                   sectionValue, orientationValue, roleValue});
 
-    QVariantWrap* variantWrap = Napi::ObjectWrap<QVariantWrap>::Unwrap(variantJsObject.As<Napi::Object>());
+    QVariantWrap* variantWrap = Napi::ObjectWrap<QVariantWrap>::Unwrap(
+        variantJsObject.As<Napi::Object>());
     QVariant* variant = variantWrap->getInternalInstance();
     return *variant;
   }
 
-  bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override {
+  bool setData(const QModelIndex& index, const QVariant& value,
+               int role = Qt::EditRole) override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto modelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    auto modelIndexWrap = QModelIndexWrap::constructor.New(
-    auto valueWrap = QVariantWrap::constructor.New({Napi::External<QVariant>::New(env, new QVariant(value))});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    auto valueWrap = QVariantWrap::constructor.New(
+        {Napi::External<QVariant>::New(env, new QVariant(value))});
     auto roleValue = Napi::Value::From(env, role);
 
-    Napi::Value booleanJs = this->dispatchOnNode.Call({Napi::String::New(env, "setData"), modelIndexWrap, valueWrap, roleValue});
+    Napi::Value booleanJs =
+        this->dispatchOnNode.Call({Napi::String::New(env, "setData"),
+                                   modelIndexWrap, valueWrap, roleValue});
 
     return booleanJs.As<Napi::Boolean>().Value();
   }
@@ -119,14 +146,17 @@ class DLL_EXPORT NAbstractItemModel : public QAbstractItemModel, public EventWid
     return createIndex(row, column);
   }
 
-  QModelIndex buddy(const QModelIndex &index) const override {
+  QModelIndex buddy(const QModelIndex& index) const override {
     Napi::Env env = this->dispatchOnNode.Env();
     Napi::HandleScope scope(env);
 
-    auto indexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    auto indexWrap = QModelIndexWrap::constructor.New(
-    Napi::Value buddyIndexNapiWrap = this->dispatchOnNode.Call({Napi::String::New(env, "buddy"), indexWrap});
+        {Napi::External<QModelIndex>::New(env, new QModelIndex(index))});
+    Napi::Value buddyIndexNapiWrap =
+        this->dispatchOnNode.Call({Napi::String::New(env, "buddy"), indexWrap});
 
-    QModelIndexWrap* buddyIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(buddyIndexNapiWrap.As<Napi::Object>());
+    QModelIndexWrap* buddyIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(
+        buddyIndexNapiWrap.As<Napi::Object>());
     QModelIndex* buddyIndex = buddyIndexWrap->getInternalInstance();
     return *buddyIndex;
   }

src/cpp/include/nodegui/QtCore/QAbstractItemModel/qabstractitemmodel_wrap.h

@@ -8,12 +8,13 @@
 #include "QtCore/QObject/qobject_macro.h"
 #include "nabstractitemmodel.hpp"
 
-
+class DLL_EXPORT QAbstractItemModelWrap
-class DLL_EXPORT QAbstractItemModelWrap : public Napi::ObjectWrap<QAbstractItemModelWrap> {
+    : public Napi::ObjectWrap<QAbstractItemModelWrap> {
   QOBJECT_WRAPPED_METHODS_DECLARATION
 
  private:
   QPointer<NAbstractItemModel> instance;
+
  public:
   static Napi::Object init(Napi::Env env, Napi::Object exports);
   QAbstractItemModelWrap(const Napi::CallbackInfo& info);

src/cpp/include/nodegui/QtWidgets/QAbstractItemView/qabstractitemview_macro.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "QtCore/QModelIndex/qmodelindex_wrap.h"
 #include "QtCore/QAbstractItemModel/qabstractitemmodel_wrap.h"
+#include "QtCore/QModelIndex/qmodelindex_wrap.h"
 #include "QtWidgets/QAbstractScrollArea/qabstractscrollarea_macro.h"
 #include "QtWidgets/QWidget/qwidget_wrap.h"
 
@@ -96,7 +96,7 @@
     Napi::Object modelObject = info[0].As<Napi::Object>();                  \
     QAbstractItemModelWrap* modelWrap =                                     \
         Napi::ObjectWrap<QAbstractItemModelWrap>::Unwrap(modelObject);      \
-    QAbstractItemView* instance=  this->instance;                           \
+    QAbstractItemView* instance = this->instance;                           \
     instance->setModel(modelWrap->getInternalInstance());                   \
     return env.Null();                                                      \
   }

src/cpp/lib/QtCore/QAbstractItemModel/qabstractitemmodel_wrap.cpp

@@ -3,7 +3,6 @@
 
 #include "Extras/Utils/nutils.h"
 
-
 Napi::FunctionReference QAbstractItemModelWrap::constructor;
 
 Napi::Object QAbstractItemModelWrap::init(Napi::Env env, Napi::Object exports) {
@@ -11,21 +10,27 @@ Napi::Object QAbstractItemModelWrap::init(Napi::Env env, Napi::Object exports) {
   char CLASSNAME[] = "QAbstractItemModel";
   Napi::Function func = DefineClass(
       env, CLASSNAME,
-      {InstanceMethod("initNodeDispatcher", &QAbstractItemModelWrap::initNodeDispatcher),
+      {InstanceMethod("initNodeDispatcher",
-      InstanceMethod("hasIndex", &QAbstractItemModelWrap::hasIndex),
+                      &QAbstractItemModelWrap::initNodeDispatcher),
-      InstanceMethod("createIndex", &QAbstractItemModelWrap::createIndex),
+       InstanceMethod("hasIndex", &QAbstractItemModelWrap::hasIndex),
-      InstanceMethod("_super_flags", &QAbstractItemModelWrap::_super_flags),
+       InstanceMethod("createIndex", &QAbstractItemModelWrap::createIndex),
-      InstanceMethod("emitDataChanged", &QAbstractItemModelWrap::emitDataChanged),
+       InstanceMethod("_super_flags", &QAbstractItemModelWrap::_super_flags),
-      InstanceMethod("checkIndex", &QAbstractItemModelWrap::checkIndex),
+       InstanceMethod("emitDataChanged",
-      InstanceMethod("_super_buddy", &QAbstractItemModelWrap::_super_buddy),
+                      &QAbstractItemModelWrap::emitDataChanged),
-      QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(QAbstractItemModelWrap)});
+       InstanceMethod("checkIndex", &QAbstractItemModelWrap::checkIndex),
+       InstanceMethod("_super_buddy", &QAbstractItemModelWrap::_super_buddy),
+       QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(QAbstractItemModelWrap)});
   constructor = Napi::Persistent(func);
   exports.Set(CLASSNAME, func);
   return exports;
 }
 
-NAbstractItemModel* QAbstractItemModelWrap::getInternalInstance() { return this->instance; }
+NAbstractItemModel* QAbstractItemModelWrap::getInternalInstance() {
-QAbstractItemModelWrap::~QAbstractItemModelWrap() { extrautils::safeDelete(this->instance); }
+  return this->instance;
+}
+QAbstractItemModelWrap::~QAbstractItemModelWrap() {
+  extrautils::safeDelete(this->instance);
+}
 
 QAbstractItemModelWrap::QAbstractItemModelWrap(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<QAbstractItemModelWrap>(info) {
@@ -35,9 +40,11 @@ QAbstractItemModelWrap::QAbstractItemModelWrap(const Napi::CallbackInfo& info)
   this->instance = new NAbstractItemModel();
 }
 
-Napi::Value QAbstractItemModelWrap::initNodeDispatcher(const Napi::CallbackInfo& info) {
+Napi::Value QAbstractItemModelWrap::initNodeDispatcher(
+    const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  this->instance->dispatchOnNode = Napi::Persistent(info[0].As<Napi::Function>());
+  this->instance->dispatchOnNode =
+      Napi::Persistent(info[0].As<Napi::Function>());
   return env.Null();
 }
 
@@ -47,14 +54,17 @@ Napi::Value QAbstractItemModelWrap::hasIndex(const Napi::CallbackInfo& info) {
 
   int row = info[0].As<Napi::Number>().Int32Value();
   int column = info[1].As<Napi::Number>().Int32Value();
-  QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[2].As<Napi::Object>());
+  QModelIndexWrap* modelIndexWrap =
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[2].As<Napi::Object>());
   QModelIndex* parentIndex = modelIndexWrap->getInternalInstance();
 
-  auto result = Napi::Value::From(env, this->instance->hasIndex(row, column, *parentIndex));
+  auto result = Napi::Value::From(
+      env, this->instance->hasIndex(row, column, *parentIndex));
   return result;
 }
 
-Napi::Value QAbstractItemModelWrap::createIndex(const Napi::CallbackInfo& info) {
+Napi::Value QAbstractItemModelWrap::createIndex(
+    const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
 
@@ -63,30 +73,39 @@ Napi::Value QAbstractItemModelWrap::createIndex(const Napi::CallbackInfo& info)
 
   QModelIndex resultIndex = this->instance->_protected_createIndex(row, column);
 
-  auto resultModelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(resultIndex))});
+  auto resultModelIndexWrap = QModelIndexWrap::constructor.New(
+      {Napi::External<QModelIndex>::New(env, new QModelIndex(resultIndex))});
   return resultModelIndexWrap;
 }
 
-Napi::Value QAbstractItemModelWrap::_super_flags(const Napi::CallbackInfo& info) {
+Napi::Value QAbstractItemModelWrap::_super_flags(
+    const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
 
-  QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
+  QModelIndexWrap* modelIndexWrap =
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
   QModelIndex* index = modelIndexWrap->getInternalInstance();
 
-  auto result = Napi::Value::From(env, static_cast<uint>(this->instance->QAbstractItemModel::flags(*index)));
+  auto result = Napi::Value::From(
+      env,
+      static_cast<uint>(this->instance->QAbstractItemModel::flags(*index)));
   return result;
 }
 
-Napi::Value QAbstractItemModelWrap::emitDataChanged(const Napi::CallbackInfo& info) {
+Napi::Value QAbstractItemModelWrap::emitDataChanged(
+    const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
 
-  QModelIndexWrap* topLeftModelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
+  QModelIndexWrap* topLeftModelIndexWrap =
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
   QModelIndex* topLeftIndex = topLeftModelIndexWrap->getInternalInstance();
 
-  QModelIndexWrap* bottomRightModelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[1].As<Napi::Object>());
+  QModelIndexWrap* bottomRightModelIndexWrap =
-  QModelIndex* bottomRightIndex = bottomRightModelIndexWrap->getInternalInstance();
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[1].As<Napi::Object>());
+  QModelIndex* bottomRightIndex =
+      bottomRightModelIndexWrap->getInternalInstance();
 
   Napi::Array rolesNapi = info[2].As<Napi::Array>();
   QVector<int> roles(rolesNapi.Length());
@@ -104,22 +123,27 @@ Napi::Value QAbstractItemModelWrap::checkIndex(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
 
-  QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
+  QModelIndexWrap* modelIndexWrap =
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
   QModelIndex* index = modelIndexWrap->getInternalInstance();
 
-  auto result = Napi::Value::From(env, static_cast<uint>(this->instance->checkIndex(*index)));
+  auto result = Napi::Value::From(
+      env, static_cast<uint>(this->instance->checkIndex(*index)));
   return result;
 }
 
-Napi::Value QAbstractItemModelWrap::_super_buddy(const Napi::CallbackInfo& info) {
+Napi::Value QAbstractItemModelWrap::_super_buddy(
+    const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
 
-  QModelIndexWrap* modelIndexWrap = Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
+  QModelIndexWrap* modelIndexWrap =
+      Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
   QModelIndex* index = modelIndexWrap->getInternalInstance();
 
   auto resultIndex = this->instance->QAbstractItemModel::buddy(*index);
 
-  auto resultModelIndexWrap = QModelIndexWrap::constructor.New({Napi::External<QModelIndex>::New(env, new QModelIndex(resultIndex))});
+  auto resultModelIndexWrap = QModelIndexWrap::constructor.New(
+      {Napi::External<QModelIndex>::New(env, new QModelIndex(resultIndex))});
   return resultModelIndexWrap;
 }