Add Input Device for mouse

	- modify ps2 mouse point, ABS to REL
	- modify typo
	- add input.mouse parameter

Change-Id: I15d01cc6e49dc0a9b36e80a090da70ed80824b1f
Signed-off-by: hyunjin816.lee <hyunjin816.lee@samsung.com>

diff --git a/tizen/src/emul_state.h b/tizen/src/emul_state.h
index 80be40c5e8906fcfb1dbe4c0bddea6b218562c1b..ba7dd7279519dd4bf1557abb1471b456e6c0a1d5 100644 (file)
--- a/tizen/src/emul_state.h
+++ b/tizen/src/emul_state.h
@@ -52,6 +52,7 @@ enum {
     MOUSE_DRAG = 3,
     MOUSE_WHEELUP = 4,
     MOUSE_WHEELDOWN = 5,
+    MOUSE_MOVE = 6,
 };
 
 /* keep it consistent with emulator-skin definition */

diff --git a/tizen/src/emulator.c b/tizen/src/emulator.c
index 1cbc611ab38ef9590049dbd553e4a402273b4910..6c1849a041faba396b792ddab7921602d7931b5f 100644 (file)
--- a/tizen/src/emulator.c
+++ b/tizen/src/emulator.c
@@ -270,6 +270,8 @@ static void extract_qemu_info(int qemu_argc, char **qemu_argv)
             set_emul_input_touch_enable(true);
         }
     }
+    if (is_emul_input_touch_enable() != true)
+        set_emul_input_mouse_enable(true);
 }
 
 static void extract_skin_info(int skin_argc, char **skin_argv)

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSdlSkin.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSdlSkin.java
index b1e59a6d02ecf62a26ad863f1c42d5162bb428af..3cc30e3d245b81e29e43a3cb5673bc6c7092a725 100644 (file)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSdlSkin.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSdlSkin.java
@@ -34,6 +34,7 @@ import java.util.logging.Logger;
 
 import org.eclipse.swt.SWT;
 import org.tizen.emulator.skin.config.EmulatorConfig;
+import org.tizen.emulator.skin.config.EmulatorConfig.ArgsConstants;
 import org.tizen.emulator.skin.exception.ScreenShotException;
 import org.tizen.emulator.skin.image.ImageRegistry.IconName;
 import org.tizen.emulator.skin.info.SkinInformation;
@@ -121,13 +122,15 @@ public class EmulatorSdlSkin extends EmulatorSkin {
        @Override
        public void displayOn() {
                logger.info("display on");
-               /* do nothing */
+               if (super.config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true)
+                       super.isDisplayOn = true;
        }
 
        @Override
        public void displayOff() {
                logger.info("display off");
-               /* do nothing */
+               if (super.config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true)
+                       super.isDisplayOn = false;
        }
 
        @Override

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorShmSkin.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorShmSkin.java
index ec62597ea034975eca9c537fec75f85ea632a165..fb77287210ca74f68d02c658ec9fcccd7e1ea390 100644 (file)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorShmSkin.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorShmSkin.java
@@ -393,6 +393,8 @@ public class EmulatorShmSkin extends EmulatorSkin {
        @Override
        public void displayOn() {
                logger.info("display on");
+               if (super.config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true)
+                       super.isDisplayOn = true;
 
 //             if (pollThread.isAlive()) {
 //                     pollThread.setWaitIntervalTime(30);
@@ -406,6 +408,8 @@ public class EmulatorShmSkin extends EmulatorSkin {
        @Override
        public void displayOff() {
                logger.info("display off");
+               if (super.config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true)
+                       super.isDisplayOn = false;
 
 //             if (pollThread.isAlive()) {
 //                     pollThread.setWaitIntervalTime(0);

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
index b965f066c8c2776338c62fd2512fc4b8b5dac4c6..e0cf32df270c760a72dba5a796422a4fa1bc95e3 100755 (executable)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/EmulatorSkin.java
@@ -184,6 +184,9 @@ public class EmulatorSkin {
        private ShellListener shellListener;
        private MenuDetectListener shellMenuDetectListener;
 
+       protected boolean isDisplayOn;
+       private int prev_x;
+       private int prev_y;
        private MouseMoveListener canvasMouseMoveListener;
        private MouseListener canvasMouseListener;
        private MouseWheelListener canvasMouseWheelListener;
@@ -286,6 +289,13 @@ public class EmulatorSkin {
 
                lcdCanvas = skinComposer.compose(displayCanvasStyle);
 
+               if (config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true) {
+                       prev_x = lcdCanvas.getSize().x / 2;
+                       prev_y = lcdCanvas.getSize().y / 2;
+                       logger.info("prev_x : " + prev_x + " prev_y : " + prev_y);
+                       isDisplayOn = false;
+               }
+
                /* load a hover color */
                currentState.setHoverColor(loadHoverColor());
 
@@ -617,7 +627,7 @@ public class EmulatorSkin {
                }
        }
 
-       private MouseMoveListener makeDisplayTouchMoveLitener() {
+       private MouseMoveListener makeDisplayTouchMoveListener() {
                MouseMoveListener listener = new MouseMoveListener() {
                        @Override
                        public void mouseMove(MouseEvent e) {
@@ -653,45 +663,79 @@ public class EmulatorSkin {
                return listener;
        }
 
-       private MouseMoveListener makeDisplayMouseMoveLitener() {
+       private void getRelativePoint(MouseEvent e) {
+               int diff_x = e.x - prev_x;
+               int diff_y = e.y - prev_y;
+               int final_x = e.x;
+               int final_y = e.y;
+               Point canvasSize = lcdCanvas.getSize();
+
+               /* caculate maximum relative point */
+               if (final_x >= canvasSize.x) {
+                       e.x = canvasSize.x - prev_x - 1;
+                       prev_x = canvasSize.x - 1;
+               } else if (final_x <= 0) {
+                       e.x = -prev_x;
+                       prev_x = 0;
+               } else {
+                       prev_x = e.x;
+                       e.x = diff_x;
+               }
+
+               if (final_y >= canvasSize.y) {
+                       e.y = canvasSize.y - prev_y - 1;
+                       prev_y = canvasSize.y - 1;
+               } else if (final_y <= 0) {
+                       e.y = -prev_y;
+                       prev_y = 0;
+               } else {
+                       prev_y = e.y;
+                       e.y = diff_y;
+               }
+       }
+
+       private MouseMoveListener makeDisplayMouseMoveListener() {
                MouseMoveListener listener = new MouseMoveListener() {
                        @Override
                        public void mouseMove(MouseEvent e) {
-                               logger.info("mouse move : " + e);
-                               int eventType = MouseEventType.MOVE.value();
+                               if (isDisplayOn) {
+                                       int eventType = MouseEventType.MOVE.value();
 
-                               if (true == isDisplayDragging) {
-                                       Point canvasSize = lcdCanvas.getSize();
-                                       eventType = MouseEventType.DRAG.value();
-                                       if (e.x < 0) {
-                                               e.x = 0;
-                                               eventType = MouseEventType.RELEASE.value();
-                                               isDisplayDragging = false;
-                                       } else if (e.x >= canvasSize.x) {
-                                               e.x = canvasSize.x - 1;
-                                               eventType = MouseEventType.RELEASE.value();
-                                               isDisplayDragging = false;
-                                       }
+                                       if (true == isDisplayDragging) {
+                                               Point canvasSize = lcdCanvas.getSize();
+                                               eventType = MouseEventType.DRAG.value();
+                                               if (e.x < 0) {
+                                                       e.x = 0;
+                                                       eventType = MouseEventType.RELEASE.value();
+                                                       isDisplayDragging = false;
+                                               } else if (e.x >= canvasSize.x) {
+                                                       e.x = canvasSize.x - 1;
+                                                       eventType = MouseEventType.RELEASE.value();
+                                                       isDisplayDragging = false;
+                                               }
 
-                                       if (e.y < 0) {
-                                               e.y = 0;
-                                               eventType = MouseEventType.RELEASE.value();
-                                               isDisplayDragging = false;
-                                       } else if (e.y >= canvasSize.y) {
-                                               e.y = canvasSize.y - 1;
-                                               eventType = MouseEventType.RELEASE.value();
-                                               isDisplayDragging = false;
+                                               if (e.y < 0) {
+                                                       e.y = 0;
+                                                       eventType = MouseEventType.RELEASE.value();
+                                                       isDisplayDragging = false;
+                                               } else if (e.y >= canvasSize.y) {
+                                                       e.y = canvasSize.y - 1;
+                                                       eventType = MouseEventType.RELEASE.value();
+                                                       isDisplayDragging = false;
+                                               }
                                        }
-                               }
+                                       getRelativePoint(e);
 
-                               mouseMoveDelivery(e, eventType);
+                                       if (e.x != 0 || e.y != 0)
+                                               mouseMoveDelivery(e, eventType);
+                               }
                        }
                };
 
                return listener;
        }
 
-       private MouseListener makeDisplayTouchClickLitener() {
+       private MouseListener makeDisplayTouchClickListener() {
                MouseListener listener = new MouseListener() {
                        @Override
                        public void mouseUp(MouseEvent e) {
@@ -731,29 +775,35 @@ public class EmulatorSkin {
                return listener;
        }
 
-       private MouseListener makeDisplayMouseClickLitener() {
+       private MouseListener makeDisplayMouseClickListener() {
                MouseListener listener = new MouseListener() {
                        @Override
                        public void mouseUp(MouseEvent e) {
-                               logger.info("mouse up : " + e);
-                               if (1 == e.button) { /* left button */
-                                       if (true == isDisplayDragging) {
-                                               isDisplayDragging = false;
+                               if (isDisplayOn) {
+                                       logger.info("mouse up : " + e);
+                                       if (1 == e.button) { /* left button */
+                                               if (true == isDisplayDragging) {
+                                                       isDisplayDragging = false;
+                                               }
+                                               getRelativePoint(e);
+                                               mouseUpDelivery(e);
+                                       } else if (2 == e.button) { /* wheel button */
+                                               logger.info("wheelUp in display");
                                        }
-                                       mouseUpDelivery(e);
-                               } else if (2 == e.button) { /* wheel button */
-                                       logger.info("wheelUp in display");
                                }
                        }
 
                        @Override
                        public void mouseDown(MouseEvent e) {
-                               logger.info("mouse down : " + e);
-                               if (1 == e.button) { /* left button */
-                                       if (false == isDisplayDragging) {
-                                               isDisplayDragging = true;
+                               if (isDisplayOn) {
+                                       logger.info("mouse down : " + e);
+                                       if (1 == e.button) { /* left button */
+                                               if (false == isDisplayDragging) {
+                                                       isDisplayDragging = true;
+                                               }
+                                               getRelativePoint(e);
+                                               mouseDownDelivery(e);
                                        }
-                                       mouseDownDelivery(e);
                                }
                        }
 
@@ -767,10 +817,13 @@ public class EmulatorSkin {
                return listener;
        }
 
-       private MouseWheelListener makeDisplayMouseWheelLitener() {
+       private MouseWheelListener makeDisplayMouseWheelListener() {
                MouseWheelListener listener = new MouseWheelListener() {
                        @Override
                        public void mouseScrolled(MouseEvent e) {
+                               if (config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true)
+                                       getRelativePoint(e);
+
                                int[] geometry = SkinUtil.convertMouseGeometry(e.x, e.y,
                                                currentState.getCurrentResolutionWidth(),
                                                currentState.getCurrentResolutionHeight(),
@@ -839,20 +892,20 @@ public class EmulatorSkin {
 
                /* mouse event */
                if (config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true) {
-                       canvasMouseMoveListener = makeDisplayMouseMoveLitener();
+                       canvasMouseMoveListener = makeDisplayMouseMoveListener();
                } else {
-                       canvasMouseMoveListener = makeDisplayTouchMoveLitener();
+                       canvasMouseMoveListener = makeDisplayTouchMoveListener();
                }
                lcdCanvas.addMouseMoveListener(canvasMouseMoveListener);
 
                if (config.getArgBoolean(ArgsConstants.INPUT_MOUSE, false) == true) {
-                       canvasMouseListener = makeDisplayMouseClickLitener();
+                       canvasMouseListener = makeDisplayMouseClickListener();
                } else {
-                       canvasMouseListener = makeDisplayTouchClickLitener();
+                       canvasMouseListener = makeDisplayTouchClickListener();
                }
                lcdCanvas.addMouseListener(canvasMouseListener);
 
-               canvasMouseWheelListener = makeDisplayMouseWheelLitener();
+               canvasMouseWheelListener = makeDisplayMouseWheelListener();
                lcdCanvas.addMouseWheelListener(canvasMouseWheelListener);
 
                /* keyboard event */

diff --git a/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/ICommunicator.java b/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/ICommunicator.java
index adc8775eb31b1cc32728b14c5d43dc6e7556375e..61cc8c4171a2632daeefb947b0a81f141c48246e 100644 (file)
--- a/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/ICommunicator.java
+++ b/tizen/src/skin/client/src/org/tizen/emulator/skin/comm/ICommunicator.java
@@ -97,8 +97,7 @@ public interface ICommunicator extends Runnable {
                DRAG( (short)3 ),
                WHEELUP( (short)4 ),
                WHEELDOWN( (short)5 ),
-               MOVE( (short)6 ),
-               DOUBLECLICK( (short)7 );
+               MOVE( (short)6 );
 
                private short value;
                MouseEventType( short value ) {

diff --git a/tizen/src/skin/maruskin_client.c b/tizen/src/skin/maruskin_client.c
index 6807641db703b130d036d4602193e4b09cbc32f7..db85ef2c701dbb4329d9b29e2268da0ff6a425b2 100644 (file)
--- a/tizen/src/skin/maruskin_client.c
+++ b/tizen/src/skin/maruskin_client.c
@@ -120,18 +120,11 @@ static void *run_skin_client(void *arg)
 #endif
 
     /* input */
-    char buf_input_mouse[8] = { 0, };
-    if (is_emul_input_mouse_enable() == true) {
-        strcpy(buf_input_mouse, OPT_BOOLEAN_TRUE);
-    } else {
-        strcpy(buf_input_mouse, OPT_BOOLEAN_FALSE);
-    }
-    char buf_input_touch[8] = { 0, };
-    if (is_emul_input_touch_enable() == true) {
-        strcpy(buf_input_touch, OPT_BOOLEAN_TRUE);
-    } else {
-        strcpy(buf_input_touch, OPT_BOOLEAN_FALSE);
-    }
+    char buf_input[12] = { 0, };
+    if (is_emul_input_mouse_enable() == true)
+        strcpy(buf_input, OPT_INPUT_MOUSE);
+    else
+        strcpy(buf_input, OPT_INPUT_TOUCH);
 
 #ifdef CONFIG_WIN32
     /* find java path in 64bit windows */
@@ -186,8 +179,8 @@ static void *run_skin_client(void *arg)
             strlen(buf_vm_base_port) + SPACE_LEN +
         strlen(OPT_DISPLAY_SHM) + EQUAL_LEN +
             strlen(buf_display_shm) + SPACE_LEN +
-        strlen(OPT_INPUT_TOUCH) + EQUAL_LEN +
-            strlen(buf_input_touch) + SPACE_LEN +
+        strlen(buf_input) + EQUAL_LEN +
+            strlen(OPT_BOOLEAN_TRUE) + SPACE_LEN +
         strlen(OPT_MAX_TOUCHPOINT) + EQUAL_LEN +
             len_maxtouchpoint + SPACE_LEN + 1 +
         strlen(argv);
@@ -221,7 +214,7 @@ static void *run_skin_client(void *arg)
         OPT_VM_PATH, vm_path,
         OPT_VM_BASE_PORT, vm_base_port,
         OPT_DISPLAY_SHM, buf_display_shm,
-        OPT_INPUT_TOUCH, buf_input_touch,
+        buf_input, OPT_BOOLEAN_TRUE,
         OPT_MAX_TOUCHPOINT, maxtouchpoint,
         argv);
 

diff --git a/tizen/src/skin/maruskin_operation.c b/tizen/src/skin/maruskin_operation.c
index d0b9102e0207ebf91b7781e6fecb75bf5c1fcde1..cf0ad5fa98929b275496a9402fe1baaa747411f7 100644 (file)
--- a/tizen/src/skin/maruskin_operation.c
+++ b/tizen/src/skin/maruskin_operation.c
@@ -141,15 +141,28 @@ void do_mouse_event(int button_type, int event_type,
             break;
         case MOUSE_WHEELUP:
         case MOUSE_WHEELDOWN:
-            x -= guest_x;
-            y -= guest_y;
-            guest_x += x;
-            guest_y += y;
+            if (is_emul_input_touch_enable() == true) {
+                x -= guest_x;
+                y -= guest_y;
+                guest_x += x;
+                guest_y += y;
+            } else {
+                guest_x = x;
+                guest_y = y;
+            }
 
             kbd_mouse_event(x, y, -z, event_type);
             TRACE("mouse_event event_type:%d, origin:(%d, %d), x:%d, y:%d, z:%d\n\n",
             event_type, origin_x, origin_y, x, y, z);
             break;
+        case MOUSE_MOVE:
+            guest_x = x;
+            guest_y = y;
+
+            kbd_mouse_event(x, y, z, event_type);
+            TRACE("mouse_event event_type:%d, origin:(%d, %d), x:%d, y:%d, z:%d\n\n",
+            event_type, origin_x, origin_y, x, y, z);
+            break;
         default:
             ERR("undefined mouse event type passed:%d\n", event_type);
             break;