Add signal support to QClipboard (#894)

* Add signal support to `QClipboard`

issue ##713

src/cpp/include/nodegui/QtGui/QClipboard/qclipboard_wrap.h

@@ -3,21 +3,29 @@
 #include <napi.h>
 
 #include <QClipboard>
+#include <QPointer>
 
 #include "Extras/Export/export.h"
-#include "core/Component/component_macro.h"
+#include "QtCore/QObject/qobject_macro.h"
 
-class DLL_EXPORT QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap> {
-  COMPONENT_WRAPPED_METHODS_DECLARATION
+class DLL_EXPORT QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap>,
+                                  public EventWidget {
+  QOBJECT_WRAPPED_METHODS_DECLARATION_WITH_EVENT_SOURCE(this)
+  // Note: We don't use EVENTWIDGET_IMPLEMENTATIONS() here because this class
+  // doesn't handle any QEvents.
 
  private:
-  QClipboard* instance;
+  QPointer<QClipboard> instance;
 
  public:
   static Napi::FunctionReference constructor;
+
   static Napi::Object init(Napi::Env env, Napi::Object exports);
   QClipboardWrap(const Napi::CallbackInfo& info);
   QClipboard* getInternalInstance();
+
+  virtual void connectSignalsToEventEmitter();
+
   // Wrapped methods
   Napi::Value clear(const Napi::CallbackInfo& info);
   Napi::Value setText(const Napi::CallbackInfo& info);

src/cpp/lib/QtGui/QApplication/qapplication_wrap.cpp

@@ -125,10 +125,13 @@ Napi::Value StaticQApplicationWrapMethods::instance(
 Napi::Value StaticQApplicationWrapMethods::clipboard(
     const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
   QClipboard* clipboard = QApplication::clipboard();
-  return QClipboardWrap::constructor.New(
-      {Napi::External<QClipboard>::New(env, clipboard)});
+  if (clipboard) {
+    return WrapperCache::instance.get<QClipboard, QClipboardWrap>(env,
+                                                                  clipboard);
+  } else {
+    return env.Null();
+  }
 }
 
 Napi::Value StaticQApplicationWrapMethods::setStyle(

src/cpp/lib/QtGui/QClipboard/qclipboard_wrap.cpp

@@ -16,7 +16,7 @@ Napi::Object QClipboardWrap::init(Napi::Env env, Napi::Object exports) {
                    InstanceMethod("pixmap", &QClipboardWrap::pixmap),
                    InstanceMethod("setText", &QClipboardWrap::setText),
                    InstanceMethod("text", &QClipboardWrap::text),
-                   COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QClipboardWrap)});
+                   QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(QClipboardWrap)});
   constructor = Napi::Persistent(func);
   exports.Set(CLASSNAME, func);
   return exports;
@@ -37,6 +37,39 @@ QClipboardWrap::QClipboardWrap(const Napi::CallbackInfo& info)
 
 QClipboard* QClipboardWrap::getInternalInstance() { return this->instance; }
 
+void QClipboardWrap::connectSignalsToEventEmitter() {
+  QOBJECT_SIGNALS_ON_TARGET(this->instance.data());
+
+  QObject::connect(this->instance.data(), &QClipboard::changed,
+                   [=](const QClipboard::Mode mode) {
+
+                     Napi::Env env = this->emitOnNode.Env();
+                     Napi::HandleScope scope(env);
+                     this->emitOnNode.Call(
+                         {Napi::String::New(env, "changed"),
+                          Napi::Value::From(env, static_cast<uint>(mode))});
+                   });
+
+  QObject::connect(this->instance.data(), &QClipboard::dataChanged, [=]() {
+    Napi::Env env = this->emitOnNode.Env();
+    Napi::HandleScope scope(env);
+    this->emitOnNode.Call({Napi::String::New(env, "dataChanged")});
+  });
+
+  QObject::connect(
+      this->instance.data(), &QClipboard::findBufferChanged, [=]() {
+        Napi::Env env = this->emitOnNode.Env();
+        Napi::HandleScope scope(env);
+        this->emitOnNode.Call({Napi::String::New(env, "findBufferChanged")});
+      });
+
+  QObject::connect(this->instance.data(), &QClipboard::selectionChanged, [=]() {
+    Napi::Env env = this->emitOnNode.Env();
+    Napi::HandleScope scope(env);
+    this->emitOnNode.Call({Napi::String::New(env, "selectionChanged")});
+  });
+}
+
 Napi::Value QClipboardWrap::clear(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);

src/lib/QtGui/QApplication.ts

@@ -71,8 +71,12 @@ export class QApplication extends NodeObject<QApplicationSignals> {
         const preparedSheet = StyleSheet.create(styleSheet);
         this.native.setStyleSheet(preparedSheet);
     }
-    static clipboard(): QClipboard {
-        return new QClipboard(addon.QApplication.clipboard());
+    static clipboard(): QClipboard | null {
+        const clipboardNative = addon.QApplication.clipboard();
+        if (clipboardNative == null) {
+            return null;
+        }
+        return wrapperCache.get<QClipboard>(QClipboard, clipboardNative);
     }
     static instance(): QApplication {
         const nativeQApp = addon.QApplication.instance();

src/lib/QtGui/QClipboard.ts

@@ -1,6 +1,8 @@
-import { Component, NativeElement } from '../core/Component';
-import { checkIfNativeElement } from '../utils/helpers';
+import { NativeElement } from '../core/Component';
+import { checkIfNativeElement, registerNativeWrapFunction } from '../utils/helpers';
+import { NodeObject, QObjectSignals } from '../QtCore/QObject';
 import { QPixmap } from './QPixmap';
+import { wrapperCache } from '../core/WrapperCache';
 
 /**
 
@@ -21,10 +23,10 @@ const clipboard = QApplication.clipboard();
 const text = clipboard.text(QClipboardMode.Clipboard);
 ```
  */
-export class QClipboard extends Component {
+export class QClipboard extends NodeObject<QClipboardSignals> {
     native: NativeElement;
     constructor(native: NativeElement) {
-        super();
+        super(native);
         if (checkIfNativeElement(native)) {
             this.native = native;
         } else {
@@ -49,7 +51,18 @@ export class QClipboard extends Component {
 }
 
 export enum QClipboardMode {
-    Clipboard,
-    Selection,
-    FindBuffer,
+    Clipboard = 0,
+    Selection = 1,
+    FindBuffer = 2,
 }
+
+export interface QClipboardSignals extends QObjectSignals {
+    changed: (mode: QClipboardMode) => void;
+    dataChanged: () => void;
+    findBufferChanged: () => void;
+    selectionChanged: () => void;
+}
+
+registerNativeWrapFunction('QClipboardWrap', (native: any) => {
+    return wrapperCache.get<QClipboard>(QClipboard, native);
+});