DSWaylandInputPanel: add methods for control input_panel window

Change-Id: Id513347571867882061d3f4b48befcffdafad12b

diff --git a/src/DSTextInput/DSTextInput.cpp b/src/DSTextInput/DSTextInput.cpp
index abe6cc4..b418406 100644 (file)
--- a/src/DSTextInput/DSTextInput.cpp
+++ b/src/DSTextInput/DSTextInput.cpp
@@ -26,6 +26,7 @@
 #include "DSWaylandCompositor.h"
 #include "DSWaylandTextInputManager.h"
 #include "DSWaylandInputMethod.h"
+#include "DSWaylandInputPanel.h"
 
 namespace display_server
 {
@@ -35,14 +36,16 @@ DSTextInputPrivate::DSTextInputPrivate(DSTextInput *p_ptr)
     __inputPanelState(InputPanelStateDidHide)
 {
        __wlCompositor = DSWaylandCompositor::getInstance();
-       __wlTextInputManager = new DSWaylandTextInputManager(__wlCompositor, this);
        __wlInputMethod = new DSWaylandInputMethod(__wlCompositor, this);
+       __wlInputPanel = new DSWaylandInputPanel(__wlCompositor, this);
+       __wlTextInputManager = new DSWaylandTextInputManager(__wlCompositor, this);
 }
 
 DSTextInputPrivate::~DSTextInputPrivate()
 {
-       delete __wlInputMethod;
        delete __wlTextInputManager;
+       delete __wlInputPanel;
+       delete __wlInputMethod;
        DSWaylandCompositor::releaseInstance();
 }
 
@@ -272,6 +275,21 @@ void DSTextInputPrivate::contextCommitContent(unsigned int serial, std::string c
        __wlTextInputManager->contextCommitContent(serial, content, description, mimeTypes);
 }
 
+void DSTextInputPrivate::updateInputPanelState(bool waitUpdate)
+{
+       __wlInputPanel->updateInputPanelState(waitUpdate);
+}
+
+void DSTextInputPrivate::setInputPanelTransientFor(DSWindow *window)
+{
+       __wlInputPanel->setTransientFor(window);
+}
+
+void DSTextInputPrivate::changeInputPanelVisibility(bool visible)
+{
+       __wlInputPanel->changeVisibility(visible);
+}
+
 
 DSTextInput::DSTextInput()
   : DS_INIT_PRIVATE_PTR(DSTextInput)

diff --git a/src/DSTextInput/DSTextInputPrivate.h b/src/DSTextInput/DSTextInputPrivate.h
index f742054..969bf14 100644 (file)
--- a/src/DSTextInput/DSTextInputPrivate.h
+++ b/src/DSTextInput/DSTextInputPrivate.h
@@ -104,10 +104,16 @@ public:
        void contextInputPanelEvent(unsigned int serial, unsigned int eventType, unsigned int value);
        void contextCommitContent(unsigned int serial, std::string content, std::string description, std::string mimeTypes);
 
+       /* DSWaylandInputPanel */
+       void updateInputPanelState(bool waitUpdate);
+       void setInputPanelTransientFor(DSWindow *window);
+       void changeInputPanelVisibility(bool visible);
+
 private:
        DSWaylandCompositor *__wlCompositor;
-       DSWaylandTextInputManager *__wlTextInputManager;
        DSWaylandInputMethod *__wlInputMethod;
+       DSWaylandInputPanel *__wlInputPanel;
+       DSWaylandTextInputManager *__wlTextInputManager;
        InputPanelState __inputPanelState;
 };
 

diff --git a/src/DSWaylandServer/DSWaylandInputPanel.cpp b/src/DSWaylandServer/DSWaylandInputPanel.cpp
index 8c604d4..8133842 100644 (file)
--- a/src/DSWaylandServer/DSWaylandInputPanel.cpp
+++ b/src/DSWaylandServer/DSWaylandInputPanel.cpp
@@ -37,6 +37,9 @@ public:
                  beforePos({0,0}), startPortraitPos({0,0}), startLandscapePos({0,0}), __inputPanel(inputPanel) {}
        ~DSWaylandInputPanelFloating() {}
 
+       void setPortraitPos(int x, int y) { startPortraitPos.x = x; startPortraitPos.y = y; initPortraitPos = true; }
+       void setLandscapePos(int x, int y) { startLandscapePos.x = x; startLandscapePos.y = y; initLandscapePos = true; }
+
        bool movingRequest;
        bool mousePressed;
        bool initPortraitPos;
@@ -53,7 +56,7 @@ class DSWaylandInputPanelSurfaceData
 {
 public:
        DSWaylandInputPanelSurfaceData(DSWaylandServer::wl_input_panel_surface::Resource *resource, void *inputPanelResource, void *surfaceResource)
-               : panel(false), showing(false), needShow(false),
+               : panel(false), showing(false), needShow(false), resizing(false),
                  __resource(resource), __inputPanelResource(inputPanelResource), __surfaceResource(surfaceResource) {}
        ~DSWaylandInputPanelSurfaceData() {}
 
@@ -63,6 +66,7 @@ public:
        bool panel;
        bool showing;
        bool needShow;
+       bool resizing;
 
 private:
        DSWaylandServer::wl_input_panel_surface::Resource *__resource;
@@ -125,8 +129,25 @@ void DSWaylandInputPanelPrivate::input_panel_get_input_panel_surface(Resource *r
 DSWaylandInputPanel::DSWaylandInputPanel(DSWaylandCompositor *compositor)
        : DSObject(), _d_ptr(std::make_unique<DSWaylandInputPanelPrivate>(this, compositor)),
          __compositor(compositor),
+         __dsTextInputPrivate(nullptr),
+         __eventLoop(nullptr),
+         __waitUpdate(false),
+         __rerunPanelShow(false)
+{
+       __inputPanelSurface = new DSWaylandInputPanelSurface(__compositor, this);
+       __inputPanelFloating = new DSWaylandInputPanelFloating(this);
+
+       __eventLoop = DSEventLoop::getInstance();
+       __eventLoop->registerCallbackIdleEnterer(this, std::bind(&DSWaylandInputPanel::__onEventIdleEnterer, this, std::placeholders::_1));
+}
+
+DSWaylandInputPanel::DSWaylandInputPanel(DSWaylandCompositor *compositor, DSTextInputPrivate *dsTextInputPrivate)
+       : DSObject(), _d_ptr(std::make_unique<DSWaylandInputPanelPrivate>(this, compositor)),
+         __compositor(compositor),
+         __dsTextInputPrivate(dsTextInputPrivate),
          __eventLoop(nullptr),
-         __waitUpdate(false)
+         __waitUpdate(false),
+         __rerunPanelShow(false)
 {
        __inputPanelSurface = new DSWaylandInputPanelSurface(__compositor, this);
        __inputPanelFloating = new DSWaylandInputPanelFloating(this);
@@ -135,6 +156,7 @@ DSWaylandInputPanel::DSWaylandInputPanel(DSWaylandCompositor *compositor)
        __eventLoop->registerCallbackIdleEnterer(this, std::bind(&DSWaylandInputPanel::__onEventIdleEnterer, this, std::placeholders::_1));
 }
 
+
 DSWaylandInputPanel::~DSWaylandInputPanel()
 {
        DSEventLoop::releaseInstance();
@@ -180,6 +202,16 @@ void DSWaylandInputPanel::updateInputPanelState(bool waitUpdate)
        }
 }
 
+bool DSWaylandInputPanel::getRerunPanelShow()
+{
+       return __rerunPanelShow;
+}
+
+void DSWaylandInputPanel::setRerunPanelShow(bool needShow)
+{
+       __rerunPanelShow = needShow;
+}
+
 void DSWaylandInputPanel::setFloatingMovingRequest(bool enabled)
 {
        if (!__inputPanelFloating) return;
@@ -187,6 +219,47 @@ void DSWaylandInputPanel::setFloatingMovingRequest(bool enabled)
        __inputPanelFloating->movingRequest = enabled;
 }
 
+void DSWaylandInputPanel::setTransientFor(DSWindow *parent)
+{
+       DSWindow *curParent = parent;
+       if (curParent)
+       {
+               /* TODO:
+                * if curParent->remoteSurface.onScreenParent
+                *  curParent = curParent->remoteSurface.onScreenParent
+                */
+       }
+
+       __inputPanelSurface->setTransientForSurface(curParent);
+}
+
+void DSWaylandInputPanel::changeVisibility(bool visible)
+{
+       __rerunPanelShow = visible;
+       //vconf_set_int (VCONFKEY_ISF_INPUT_PANEL_STATE, visible ? VCONFKEY_ISF_INPUT_PANEL_STATE_SHOW : VCONFKEY_ISF_INPUT_PANEL_STATE_HIDE);
+       __inputPanelSurface->updateSurfaceVisibility(visible);
+       /* TODO: delete waitTimer */
+}
+
+bool DSWaylandInputPanel::isEffectRunning(DSWindow *window)
+{
+       /* TODO:
+        * if window is animating
+        *  return true
+        */
+       return false;
+}
+
+void DSWaylandInputPanel::setFloatingPosition(int x, int y)
+{
+       __inputPanelSurface->setFloatingPosition(x, y);
+}
+
+DSWaylandInputPanelFloating* DSWaylandInputPanel::getFloatingData()
+{
+       return __inputPanelFloating;
+}
+
 void DSWaylandInputPanel::__onEventIdleEnterer(void *data)
 {
 }
@@ -273,6 +346,111 @@ void DSWaylandInputPanelSurfacePrivate::show(DSWaylandInputPanelSurfaceData *sur
        }
 }
 
+void DSWaylandInputPanelSurfacePrivate::directShow(DSWaylandInputPanelSurfaceData *surfaceData)
+{
+       DS_GET_PUB(DSWaylandInputPanelSurface);
+
+       pub->setPosition(nullptr, 0, 0); /* FIXME: set correct value */
+
+       /* TODO: change window geometry */
+}
+
+void DSWaylandInputPanelSurfacePrivate::setTransientForSurface(DSWindow *parent)
+{
+       for (auto it = __dataMap.begin();  it != __dataMap.end(); it++)
+       {
+               //DSWaylandInputPanelSurfaceData *surfaceData = (*it).second;
+               /* TODO:
+                * child = surfaceData->getSurfaceResource();
+                * if child->parent
+                * {
+                *  if child->parent != parent
+                *  {
+                *   remove child in child->parent->transients list
+                *   child->parent = nullptr
+                *  }
+                * }
+                * if parent != child && parent != child->parent
+                * {
+                *  add child in child->parent->transients list
+                *  child->parent = parent;
+                * }
+                * if (parent)
+                * {
+                *  child->icccm.fetch.transientFor = true;
+                *  child->icccm.transientFor = parent->id;
+                * }
+                * else
+                * {
+                *  child->icccm.fetch.transientFor = false;
+                *  child->icccm.transientFor = 0;
+                * }
+                * mark window changedr
+                */
+       }
+}
+
+void DSWaylandInputPanelSurfacePrivate::updateSurfaceVisibility(bool visible)
+{
+       for (auto it = __dataMap.begin();  it != __dataMap.end(); it++)
+       {
+               DSWaylandInputPanelSurfaceData *surfaceData = (*it).second;
+               surfaceData->showing = visible;
+               __updateSurfaceVisibility(surfaceData);
+       }
+}
+
+void DSWaylandInputPanelSurfacePrivate::setFloatingPosition(int x, int y)
+{
+       DS_GET_PUB(DSWaylandInputPanelSurface);
+       DSWaylandInputPanelSurfaceData *floatingData = nullptr;
+       DSWaylandInputPanelFloating *inputPanelFloating;
+       int curAngle = 0;
+
+       for (auto it = __dataMap.begin();  it != __dataMap.end(); it++)
+       {
+               //DSWaylandInputPanelSurfaceData *surfaceData = (*it).second;
+               
+               /* TODO:
+                * if vkbd.floating
+                *  floatingData = surfaceData
+                */
+       }
+
+       inputPanelFloating = pub->__inputPanel->getFloatingData();
+
+       if (!floatingData || !inputPanelFloating) return;
+
+       /* TODO:
+        * if (floatingData->showing)
+        *  curAngle = get ec angle
+        * else
+        *  curAngle = get zone angle
+        */
+
+       switch (curAngle)
+       {
+               case 90:
+               case 270:
+                       inputPanelFloating->setLandscapePos(x, y);
+                       //__inputPanelFloating->startLandscapePos.x = x;
+                       //__inputPanelFloating->startLandscapePos.y = y;
+                       //__inputPanelFloating->initLandscapePos = true;
+                       break;
+//             case 0:
+//             case 180:
+               default:
+                       inputPanelFloating->setPortraitPos(x, y);
+                       //__inputPanelFloating->startPortraitPos.x = x;
+                       //__inputPanelFloating->startPortraitPos.y = y;
+                       //__inputPanelFloating->initPortraitPos = true;
+                       break;
+       }
+
+       if (floatingData->showing)
+               pub->setPosition(nullptr, 0, 0); /* FIXME: set correct window and data */
+}
+
 void DSWaylandInputPanelSurfacePrivate::input_panel_surface_destroy_resource(Resource *resource)
 {
        auto it = __dataMap.find(resource);
@@ -314,7 +492,7 @@ void DSWaylandInputPanelSurfacePrivate::input_panel_surface_set_ready(Resource *
        if (it != __dataMap.end())
        {
                DSWaylandInputPanelSurfaceData *surfaceData = (*it).second;
-               /* TODO: find Window and update base_output resolution */
+               /* TODO: find DSWindow and update base_output resolution */
                show(surfaceData);
        }
 }
@@ -322,7 +500,7 @@ void DSWaylandInputPanelSurfacePrivate::input_panel_surface_set_ready(Resource *
 void DSWaylandInputPanelSurfacePrivate::input_panel_surface_set_floating_panel(Resource *resource, uint32_t state)
 {
        /* TODO:
-        * set Window's vkbd.floating = !!state
+        * set DSWindow's vkbd.floating = !!state
         * if true
         *  policy_conformant_part_del
         * else
@@ -337,6 +515,33 @@ void DSWaylandInputPanelSurfacePrivate::input_panel_surface_set_floating_drag_en
        pub->__inputPanel->setFloatingMovingRequest(!!enabled);
 }
 
+void DSWaylandInputPanelSurfacePrivate::__updateSurfaceVisibility(DSWaylandInputPanelSurfaceData *surfaceData)
+{
+       DS_GET_PUB(DSWaylandInputPanelSurface);
+
+       if (surfaceData->showing) /* TODO: check pixmap is usable too*/
+       {
+               if (pub->__inputPanel->getRerunPanelShow())
+                       pub->__inputPanel->setRerunPanelShow(false);
+               if (pub->isEffectRunning(nullptr)) // FIXME: change this to get window surfaceData->getDSWindow()
+                       surfaceData->needShow = true;
+               else if (surfaceData->resizing)
+                       surfaceData->needShow = true;
+               else
+               {
+                       directShow(surfaceData);
+                       surfaceData->needShow = false;
+               }
+       }
+       else
+       {
+               /* TODO:
+                * change window's property
+                */
+               surfaceData->needShow = false;
+       }
+}
+
 
 DSWaylandInputPanelSurface::DSWaylandInputPanelSurface(DSWaylandCompositor *compositor, DSWaylandInputPanel *inputPanel)
        : DSObject(), _d_ptr(std::make_unique<DSWaylandInputPanelSurfacePrivate>(this, compositor)),
@@ -374,5 +579,36 @@ void DSWaylandInputPanelSurface::flushFrame()
        priv->flushFrame();
 }
 
+void DSWaylandInputPanelSurface::setTransientForSurface(DSWindow *parent)
+{
+       DS_GET_PRIV(DSWaylandInputPanelSurface);
+
+       priv->setTransientForSurface(parent);
+}
+
+void DSWaylandInputPanelSurface::updateSurfaceVisibility(bool visible)
+{
+       DS_GET_PRIV(DSWaylandInputPanelSurface);
+
+       priv->updateSurfaceVisibility(visible);
+}
+
+bool DSWaylandInputPanelSurface::isEffectRunning(DSWindow *window)
+{
+       return __inputPanel->isEffectRunning(window);
+}
+
+void DSWaylandInputPanelSurface::setPosition(DSWindow *window, int width, int height)
+{
+}
+
+void DSWaylandInputPanelSurface::setFloatingPosition(int x, int y)
+{
+       DS_GET_PRIV(DSWaylandInputPanelSurface);
+
+       priv->setFloatingPosition(x, y);
+}
+
+
 }
 

diff --git a/src/DSWaylandServer/DSWaylandInputPanel.h b/src/DSWaylandServer/DSWaylandInputPanel.h
index 33de418..a8d0378 100644 (file)
--- a/src/DSWaylandServer/DSWaylandInputPanel.h
+++ b/src/DSWaylandServer/DSWaylandInputPanel.h
@@ -28,6 +28,8 @@
 #include "DSObject.h"
 #include "DSWaylandCompositor.h"
 #include "DSEventLoop.h"
+#include "DSTextInputPrivate.h"
+#include "DSWindow.h"
 
 namespace display_server
 {
@@ -41,6 +43,7 @@ class DS_DECL_EXPORT DSWaylandInputPanel : public DSObject
 DS_PIMPL_USE_PRIVATE(DSWaylandInputPanel);
 public:
        DSWaylandInputPanel(DSWaylandCompositor *compositor);
+       DSWaylandInputPanel(DSWaylandCompositor *compositor, DSTextInputPrivate *dsTextInputPrivate);
        ~DSWaylandInputPanel() override;
 
        void createSurface(void *client, void *inputPanelResource, unsigned int id, void *surface);
@@ -48,17 +51,24 @@ public:
        bool getWaitUpdate();
        void setWaitUpdate(bool waitUpdate);
        void updateInputPanelState(bool waitUpdate);
+       bool getRerunPanelShow();
+       void setRerunPanelShow(bool needShow);
 
        void setFloatingMovingRequest(bool enabled);
-
-protected:
+       void setTransientFor(DSWindow *parent);
+       void changeVisibility(bool visible);
+       bool isEffectRunning(DSWindow *window);
+       void setFloatingPosition(int x, int y);
+       DSWaylandInputPanelFloating *getFloatingData();
 
 private:
        DSWaylandCompositor *__compositor;
+       DSTextInputPrivate *__dsTextInputPrivate;
        DSEventLoop *__eventLoop;
        DSWaylandInputPanelSurface *__inputPanelSurface;
        DSWaylandInputPanelFloating *__inputPanelFloating;
        bool __waitUpdate;
+       bool __rerunPanelShow;
 
        void __onEventIdleEnterer(void *data);
 };

diff --git a/src/DSWaylandServer/DSWaylandInputPanelSurface.h b/src/DSWaylandServer/DSWaylandInputPanelSurface.h
index 594f3a9..2f036ac 100644 (file)
--- a/src/DSWaylandServer/DSWaylandInputPanelSurface.h
+++ b/src/DSWaylandServer/DSWaylandInputPanelSurface.h
@@ -27,6 +27,7 @@
 #include "DSCore.h"
 #include "DSObject.h"
 #include "DSWaylandInputPanel.h"
+#include "DSWindow.h"
 
 namespace display_server
 {
@@ -43,6 +44,11 @@ public:
        void createGlobal(void *client, void *inputPanelResource, unsigned int id, void *surface);
        void clearGlobals(void *inputPanelResource);
        void flushFrame();
+       void setTransientForSurface(DSWindow *parent);
+       void updateSurfaceVisibility(bool visible);
+       bool isEffectRunning(DSWindow *window);
+       void setPosition(DSWindow *window, int width, int height);
+       void setFloatingPosition(int x, int y);
 
 protected:
 

diff --git a/src/DSWaylandServer/DSWaylandInputPanelSurfacePrivate.h b/src/DSWaylandServer/DSWaylandInputPanelSurfacePrivate.h
index a3cd8c9..5989bed 100644 (file)
--- a/src/DSWaylandServer/DSWaylandInputPanelSurfacePrivate.h
+++ b/src/DSWaylandServer/DSWaylandInputPanelSurfacePrivate.h
@@ -46,7 +46,11 @@ public:
        void clearGlobals(void *inputPanelResource);
 
        void show(DSWaylandInputPanelSurfaceData *surfaceData);
+       void directShow(DSWaylandInputPanelSurfaceData *surfaceData);
        void flushFrame();
+       void setTransientForSurface(DSWindow *parent);
+       void updateSurfaceVisibility(bool visible);
+       void setFloatingPosition(int x, int y);
 
 protected:
        void input_panel_surface_destroy_resource(Resource *resource);
@@ -60,6 +64,8 @@ protected:
 private:
        DSWaylandCompositor *__compositor;
        std::multimap<Resource*, DSWaylandInputPanelSurfaceData *> __dataMap;
+
+       void __updateSurfaceVisibility(DSWaylandInputPanelSurfaceData *surfaceData);
 };
 
 }

diff --git a/src/DSWaylandServer/DSWaylandTextInput.cpp b/src/DSWaylandServer/DSWaylandTextInput.cpp
index 29ea673..5de2744 100644 (file)
--- a/src/DSWaylandServer/DSWaylandTextInput.cpp
+++ b/src/DSWaylandServer/DSWaylandTextInput.cpp
@@ -254,13 +254,13 @@ void DSWaylandTextInputPrivate::showInputPanel(void *resource)
        {
                pub->__dsTextInputPrivate->showInputPanel(pub, id);
                __showClient = privateResource->client();
-               /* TODO: inputpanel wait update set */
+               pub->__dsTextInputPrivate->updateInputPanelState(true);
                if (pub->__dsTextInputPrivate->getInputPanelState() == DSTextInputPrivate::InputPanelStateWillHide)
                {
                        send_private_command(privateResource->handle, 0, "CONFORMANT_RESTORE");
                }
                pub->__dsTextInputPrivate->setInputPanelState(DSTextInputPrivate::InputPanelStateWillShow);
-               /* TODO: inputpanel transient for set */
+               /* TODO: pub->__dsTextInputPrivate->setInputPanelTransientFor(getDSWindow(__activatedResource)); */
        }
 }
 
@@ -315,7 +315,8 @@ void DSWaylandTextInputPrivate::hideInputPanel(Resource *resource, bool forceHid
 
        if (forceHide)
        {
-               /* TODO: Control inputpanel visible status */
+               pub->__dsTextInputPrivate->changeInputPanelVisibility(false);
+        pub->__dsTextInputPrivate->setInputPanelTransientFor(nullptr);
                pub->__dsTextInputPrivate->setInputPanelState(DSTextInputPrivate::InputPanelStateDidHide);
        }
        else
@@ -466,7 +467,8 @@ void DSWaylandTextInputPrivate::text_input_set_input_panel_data(Resource *resour
                /* TODO: will hide timer control */
                if (pub->__dsTextInputPrivate->getInputPanelState() == DSTextInputPrivate::InputPanelStateWillHide)
                {
-                       /* TODO: input panel visibility control */
+                       pub->__dsTextInputPrivate->changeInputPanelVisibility(false);
+                       pub->__dsTextInputPrivate->setInputPanelTransientFor(nullptr);
                        pub->__dsTextInputPrivate->setInputPanelState(DSTextInputPrivate::InputPanelStateDidShow);
                }
        }

diff --git a/tests/DSWaylandInputPanel-test.cpp b/tests/DSWaylandInputPanel-test.cpp
index ead57a2..85f9778 100644 (file)
--- a/tests/DSWaylandInputPanel-test.cpp
+++ b/tests/DSWaylandInputPanel-test.cpp
@@ -102,3 +102,81 @@ TEST_F(DSWaylandInputPanelTest, SetFloatingMovingRequest)
        DSWaylandCompositor::releaseInstance();
 }
 
+TEST_F(DSWaylandInputPanelTest, GetSetRerunPanelShow)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       inputPanel->setRerunPanelShow(true);
+       EXPECT_TRUE(true == inputPanel->getRerunPanelShow());
+
+       inputPanel->setRerunPanelShow(false);
+       EXPECT_TRUE(false == inputPanel->getRerunPanelShow());
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelTest, SetTransientFor)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       inputPanel->setTransientFor(nullptr);
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelTest, ChangeVisibility)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       inputPanel->changeVisibility(true);
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelTest, IsEffectRunning)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       inputPanel->isEffectRunning(nullptr);
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelTest, SetFloatingPosition)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       inputPanel->setFloatingPosition(0, 0);
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelTest, GetFloatingData)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       EXPECT_TRUE(inputPanel != nullptr);
+
+       auto floatingData = inputPanel->getFloatingData();
+
+       EXPECT_TRUE(floatingData != nullptr);
+
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+

diff --git a/tests/DSWaylandInputPanelSurface-test.cpp b/tests/DSWaylandInputPanelSurface-test.cpp
index f3c8e4a..763a8e1 100644 (file)
--- a/tests/DSWaylandInputPanelSurface-test.cpp
+++ b/tests/DSWaylandInputPanelSurface-test.cpp
@@ -81,3 +81,73 @@ TEST_F(DSWaylandInputPanelSurfaceTest, FlushFrame)
        DSWaylandCompositor::releaseInstance();
 }
 
+TEST_F(DSWaylandInputPanelSurfaceTest, SetTransientForSurface)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       DSWaylandInputPanelSurface *inputPanelSurface = new DSWaylandInputPanelSurface(comp, inputPanel);
+       EXPECT_TRUE(inputPanelSurface != nullptr);
+
+       inputPanelSurface->setTransientForSurface(nullptr);
+
+       delete inputPanelSurface;
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelSurfaceTest, UpdateSurfaceVisibility)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       DSWaylandInputPanelSurface *inputPanelSurface = new DSWaylandInputPanelSurface(comp, inputPanel);
+       EXPECT_TRUE(inputPanelSurface != nullptr);
+
+       inputPanelSurface->updateSurfaceVisibility(true);
+
+       delete inputPanelSurface;
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelSurfaceTest, SsEffectRunning)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       DSWaylandInputPanelSurface *inputPanelSurface = new DSWaylandInputPanelSurface(comp, inputPanel);
+       EXPECT_TRUE(inputPanelSurface != nullptr);
+
+       inputPanelSurface->isEffectRunning(nullptr);
+
+       delete inputPanelSurface;
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelSurfaceTest, SetPosition)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       DSWaylandInputPanelSurface *inputPanelSurface = new DSWaylandInputPanelSurface(comp, inputPanel);
+       EXPECT_TRUE(inputPanelSurface != nullptr);
+
+       inputPanelSurface->setPosition(nullptr, 0, 0);
+
+       delete inputPanelSurface;
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+
+TEST_F(DSWaylandInputPanelSurfaceTest, SetFloatingPosition)
+{
+       DSWaylandCompositor *comp = DSWaylandCompositor::getInstance();
+       DSWaylandInputPanel *inputPanel = new DSWaylandInputPanel(comp);
+       DSWaylandInputPanelSurface *inputPanelSurface = new DSWaylandInputPanelSurface(comp, inputPanel);
+       EXPECT_TRUE(inputPanelSurface != nullptr);
+
+       inputPanelSurface->setFloatingPosition(0, 0);
+
+       delete inputPanelSurface;
+       delete inputPanel;
+       DSWaylandCompositor::releaseInstance();
+}
+