mouse cursor handling with glfw3

diff --git a/Crow/src/Enums.cs b/Crow/src/Enums.cs
index 8b90d6ea54da15caacc5f28cdd75468163628b82..9f831ecebb9bbf3f35f52a530764736903c96e58 100644 (file)
--- a/Crow/src/Enums.cs
+++ b/Crow/src/Enums.cs
@@ -62,4 +62,13 @@ namespace Crow
         Bottom,
         Center,
     }
+       public enum MouseCursor
+       {
+               Arrow,
+               IBeam,
+               Crosshair,
+               Hand,
+               HResize,
+               VResize
+       }
 }

diff --git a/Crow/src/GraphicObjects/Label.cs b/Crow/src/GraphicObjects/Label.cs
index 0cd3868856ec96b8e8e951485c14a36d608f52b4..3c9f3f895dba956340869138ca99346370546f88 100644 (file)
--- a/Crow/src/GraphicObjects/Label.cs
+++ b/Crow/src/GraphicObjects/Label.cs
@@ -689,13 +689,13 @@ namespace Crow
                public override void onMouseEnter (object sender, MouseMoveEventArgs e)
                {
                        base.onMouseEnter (sender, e);
-                       //if (Selectable)
-                               //IFace.MouseCursor = MouseCursors.Text;
+                       if (Selectable)
+                               IFace.MouseCursor = MouseCursor.IBeam;
                }
                public override void onMouseLeave (object sender, MouseMoveEventArgs e)
                {
                        base.onMouseLeave (sender, e);
-                       //IFace.MouseCursor = MouseCursors.Default;
+                       IFace.MouseCursor = MouseCursor.Arrow;
                }
                protected override void onFocused (object sender, EventArgs e)
                {

diff --git a/Crow/src/GraphicObjects/Splitter.cs b/Crow/src/GraphicObjects/Splitter.cs
index cc0ba3239860ae793b5a841e765666cda14d8846..58ba94fc055712cd6ed4352d4a7985cf1f886973 100644 (file)
--- a/Crow/src/GraphicObjects/Splitter.cs
+++ b/Crow/src/GraphicObjects/Splitter.cs
@@ -90,14 +90,15 @@ namespace Crow
                public override void onMouseEnter (object sender, MouseMoveEventArgs e)
                {
                        base.onMouseEnter (sender, e);
-                       //if ((Parent as GenericStack).Orientation == Orientation.Horizontal)
-                       //      IFace.MouseCursor = MouseCursors.H;
-                       //else
-                               //IFace.MouseCursor = MouseCursors.V;
+                       if ((Parent as GenericStack).Orientation == Orientation.Horizontal)
+                               IFace.MouseCursor = MouseCursor.HResize;
+                       else
+                               IFace.MouseCursor = MouseCursor.VResize;
                }
                public override void onMouseLeave (object sender, MouseMoveEventArgs e)
                {
                        base.onMouseLeave (sender, e);
+                       IFace.MouseCursor = MouseCursor.Arrow;
                }
                public override void onMouseDown (object sender, MouseButtonEventArgs e)
                {

diff --git a/Crow/src/GraphicObjects/Window.cs b/Crow/src/GraphicObjects/Window.cs
index 8208083693dee5b20372a0e35e04935f7aa75399..9f3785cf85bdfbfde5ada2cfdf943b7f1c4f4cd6 100644 (file)
--- a/Crow/src/GraphicObjects/Window.cs
+++ b/Crow/src/GraphicObjects/Window.cs
@@ -296,7 +296,7 @@ namespace Crow
 
                        if (!hoverBorder) {
                                currentDirection = Direction.None;
-                               //IFace.MouseCursor = MouseCursors.Default;
+                               IFace.MouseCursor = MouseCursor.Arrow;
                                return;
                        }
 
@@ -330,37 +330,37 @@ namespace Crow
                                else
                                        currentDirection = Direction.None;
 
-                               //if (currentDirection != lastDir) {
-                               //      switch (currentDirection) {
-                               //      case Direction.None:
-                               //              otkgw.MouseCursor = MouseCursors.Default;
-                               //              break;
-                               //      case Direction.N:
-                               //              otkgw.MouseCursor = MouseCursors.V;
-                               //              break;
-                               //      case Direction.S:
-                               //              otkgw.MouseCursor = MouseCursors.V;
-                               //              break;
-                               //      case Direction.E:
-                               //              otkgw.MouseCursor = MouseCursors.H;
-                               //              break;
-                               //      case Direction.W:
-                               //              otkgw.MouseCursor = MouseCursors.H;
-                               //              break;
-                               //      case Direction.NW:
-                               //              otkgw.MouseCursor = MouseCursors.NW;
-                               //              break;
-                               //      case Direction.NE:
-                               //              otkgw.MouseCursor = MouseCursors.NE;
-                               //              break;
-                               //      case Direction.SW:
-                               //              otkgw.MouseCursor = MouseCursors.SW;
-                               //              break;
-                               //      case Direction.SE:
-                               //              otkgw.MouseCursor = MouseCursors.SE;
-                               //              break;
-                               //      }
-                               //}                             
+                               if (currentDirection != lastDir) {
+                                       switch (currentDirection) {
+                                       case Direction.None:
+                                               otkgw.MouseCursor = MouseCursor.Arrow;
+                                               break;
+                                       case Direction.N:
+                                               otkgw.MouseCursor = MouseCursor.VResize;
+                                               break;
+                                       case Direction.S:
+                                               otkgw.MouseCursor = MouseCursor.VResize;
+                                               break;
+                                       case Direction.E:
+                                               otkgw.MouseCursor = MouseCursor.HResize;
+                                               break;
+                                       case Direction.W:
+                                               otkgw.MouseCursor = MouseCursor.HResize;
+                                               break;
+                                       /*case Direction.NW:
+                                               otkgw.MouseCursor = MouseCursor.NW;
+                                               break;
+                                       case Direction.NE:
+                                               otkgw.MouseCursor = MouseCursor.NE;
+                                               break;
+                                       case Direction.SW:
+                                               otkgw.MouseCursor = MouseCursor.SW;
+                                               break;
+                                       case Direction.SE:
+                                               otkgw.MouseCursor = MouseCursor.SE;
+                                               break;*/
+                                       }
+                               }                               
                        }                               
                }
                public override void onMouseDown (object sender, MouseButtonEventArgs e)

diff --git a/Crow/src/Interface.cs b/Crow/src/Interface.cs
index cd3810b3b5b1c9db7e9bcded32f68f35fec0a9c2..9073b0d572927bf0195fc52d9f51688cfe9af468 100644 (file)
--- a/Crow/src/Interface.cs
+++ b/Crow/src/Interface.cs
@@ -920,17 +920,25 @@ namespace Crow
                }
 
                #region Mouse and Keyboard Handling
-
+               /// <summary>
+               /// Connect to this event to receive mouse cursor change request from crom.
+               /// </summary>
+               public event EventHandler<MouseCursorChangedEventArgs> MouseCursorChanged;
                public MouseState Mouse;
+
                Stopwatch lastMouseDown = new Stopwatch (), mouseRepeatTimer = new Stopwatch ();
                int mouseRepeatCount;
                MouseButtonEventArgs lastMouseDownEvent;
+               MouseCursor cursor = MouseCursor.Arrow;
 
-               //public MouseCursors MouseCursor {
-               //      set {
-               //              //backend.SetCursor (value);
-               //      }
-               //}
+               public MouseCursor MouseCursor {
+                       set {
+                               if (value == cursor)
+                                       return;
+                               cursor = value;
+                               MouseCursorChanged.Raise (this, new MouseCursorChangedEventArgs (cursor));
+                       }
+               }
                /// <summary>Processes mouse move events from the root container, this function
                /// should be called by the host on mouse move event to forward events to crow interfaces</summary>
                /// <returns>true if mouse is in the interface</returns>

diff --git a/Crow/src/MouseCursorChangedEventArgs.cs b/Crow/src/MouseCursorChangedEventArgs.cs
index 850ee9c260b9b7d3933d20001efaa921daba1fa6..5e58b861ef96e44d7cccdafedc8b2fc6e2dae08b 100644 (file)
--- a/Crow/src/MouseCursorChangedEventArgs.cs
+++ b/Crow/src/MouseCursorChangedEventArgs.cs
@@ -28,12 +28,12 @@ using System;
 
 namespace Crow
 {
-       //public class MouseCursorChangedEventArgs : EventArgs
-       //{
-       //      public XCursor NewCursor;
-       //      public MouseCursorChangedEventArgs (XCursor newCursor) : base()
-       //      {
-       //              NewCursor = newCursor;
-       //      }
-       //}
+       public class MouseCursorChangedEventArgs : EventArgs
+       {
+               public MouseCursor NewCursor;
+               public MouseCursorChangedEventArgs (MouseCursor newCursor) : base()
+               {
+                       NewCursor = newCursor;
+               }
+       }
 }

diff --git a/Samples/ShowCase/main.cs b/Samples/ShowCase/main.cs
index 9c93758b0b6670b161ae43fdc435590d6182b026..eb9e02602ce1432711c826f89209d74460ca631a 100644 (file)
--- a/Samples/ShowCase/main.cs
+++ b/Samples/ShowCase/main.cs
@@ -1,5 +1,6 @@
 using System.IO;
 using Crow;
+using Glfw;
 
 namespace HelloWorld
 {
@@ -8,6 +9,10 @@ namespace HelloWorld
        class Program : CrowVkWin
        {
                static void Main (string[] args) {
+                       //CVKL.Instance.VALIDATION = true;
+                       //CVKL.Instance.DEBUG_UTILS = true;
+                       CVKL.SwapChain.IMAGES_USAGE = VK.VkImageUsageFlags.ColorAttachment | VK.VkImageUsageFlags.TransferDst;
+                       //CVKL.Instance.RENDER_DOC_CAPTURE = true;
                        using (Program vke = new Program ()) {
                                vke.Run ();
                        }
@@ -23,6 +28,11 @@ namespace HelloWorld
                        hideError ();
                }
 
+               protected override void onKeyDown (Glfw.Key key, int scanCode, Modifier modifiers)
+               {
+                       base.onKeyDown (key, scanCode, modifiers);
+               }
+
                void Dv_SelectedItemChanged (object sender, SelectionChangeEventArgs e)
                {
                        FileSystemInfo fi = e.NewValue as FileSystemInfo;
@@ -31,15 +41,6 @@ namespace HelloWorld
                        if (fi is DirectoryInfo)
                                return;
                        hideError ();
-                       lock (crow.UpdateMutex) {
-                               try {
-                                       Widget g = crow.Load (fi.FullName);
-                                       crowContainer.SetChild (g);
-                                       g.DataSource = this;
-                               } catch (Crow.IML.InstantiatorException ex) {
-                                       showError (ex);
-                               }
-                       }
 
                        string source = "";
                        using (Stream s = new FileStream (fi.FullName, FileMode.Open)) {
@@ -48,8 +49,19 @@ namespace HelloWorld
                                }
                        }
                        NotifyValueChanged ("source", source);
+
+                       lock (crow.UpdateMutex) {
+                               try {
+                                       Widget g = crow.CreateInstance (fi.FullName);
+                                       crowContainer.SetChild (g);
+                                       g.DataSource = this;
+                               } catch (Crow.IML.InstantiatorException ex) {
+                                       showError (ex);
+                               }
+                       }
                }
 
+
                void showError (Crow.IML.InstantiatorException ex)
                {
                        NotifyValueChanged ("ErrorMessage", ex.Path + ": " + ex.InnerException.Message);

diff --git a/Samples/common/CrowWin.cs b/Samples/common/CrowWin.cs
index 666267e5c3421edeea5a51d8fbc7143985ac8892..8fe1e025d048f51244d61dcda794afe3b2b6a996 100644 (file)
--- a/Samples/common/CrowWin.cs
+++ b/Samples/common/CrowWin.cs
@@ -23,6 +23,7 @@ namespace Crow
 
         protected CrowVkWin() : base()
         {
+
             Thread crowThread = new Thread(crow_thread_func);
             crowThread.IsBackground = true;
             crowThread.Start();
@@ -60,6 +61,7 @@ namespace Crow
                                vkvg.SampleCount.Sample_8, presentQueue.index);
 
                        crow = new Crow.Interface (vkvgDev, 800, 600);
+                       crow.MouseCursorChanged +=Crow_MouseCursorChanged;; 
 
                        isRunning = true;
                        while (isRunning) {
@@ -72,6 +74,33 @@ namespace Crow
                        crow = null;
                }
 
+               void Crow_MouseCursorChanged (object sender, MouseCursorChangedEventArgs e)
+               {
+                       switch (e.NewCursor) {
+                       case MouseCursor.Arrow:
+                               SetCursor (Glfw.CursorShape.Arrow);
+                               break;
+                       case MouseCursor.IBeam:
+                               SetCursor (Glfw.CursorShape.IBeam);
+                               break;
+                       case MouseCursor.Crosshair:
+                               SetCursor (Glfw.CursorShape.Crosshair);
+                               break;
+                       case MouseCursor.Hand:
+                               SetCursor (Glfw.CursorShape.Hand);
+                               break;
+                       case MouseCursor.HResize:
+                               SetCursor (Glfw.CursorShape.HResize);
+                               break;
+                       case MouseCursor.VResize:
+                               SetCursor (Glfw.CursorShape.VResize);
+                               break;
+                       default:
+                               SetCursor (Glfw.CursorShape.Crosshair);
+                               break;
+                       }
+               }
+
                void initUISurface () {
                        lock (crow.UpdateMutex) {
                                uiImage?.Dispose ();
@@ -99,8 +128,8 @@ namespace Crow
                                        VkImageLayout.Undefined, VkImageLayout.TransferDstOptimal,
                                        VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.Transfer);
                                uiImage.SetLayout (cmd, VkImageAspectFlags.Color,
-                                       VkImageLayout.ColorAttachmentOptimal, VkImageLayout.TransferSrcOptimal,
-                                       VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer);
+                                       VkImageLayout.Undefined, VkImageLayout.TransferSrcOptimal,
+                                       VkPipelineStageFlags.Transfer, VkPipelineStageFlags.Transfer);
                                        
                                VkImageSubresourceLayers imgSubResLayer = new VkImageSubresourceLayers {
                                        aspectMask = VkImageAspectFlags.Color,
@@ -151,13 +180,13 @@ namespace Crow
                }
 
                #region Mouse and keyboard
-               //protected override void onScroll (double xOffset, double yOffset)
-               //{
-               //      if (KeyModifiers.HasFlag (Glfw.Modifier.Shift))
-               //              crow.ProcessMouseWheelChanged ((float)xOffset);
-               //      else
-               //              crow.ProcessMouseWheelChanged ((float)yOffset);
-               //}
+               protected override void onScroll (double xOffset, double yOffset)
+               {
+                       if (KeyModifiers.HasFlag (Glfw.Modifier.Shift))
+                               crow.ProcessMouseWheelChanged ((float)xOffset);
+                       else
+                               crow.ProcessMouseWheelChanged ((float)yOffset);
+               }
                protected override void onMouseMove (double xPos, double yPos)
                {
                        if (crow.ProcessMouseMove ((int)xPos, (int)yPos))
@@ -185,11 +214,11 @@ namespace Crow
                        if (crow.ProcessKeyUp ((Crow.Key)key))
                                return;
                }
-               //protected override void onChar (Glfw.CodePoint cp)
-               //{
-               //      if (crow.ProcessKeyPress (cp.ToChar ()))
-               //              return;
-               //}
+               protected override void onChar (Glfw.CodePoint cp)
+               {
+                       if (crow.ProcessKeyPress (cp.ToChar ()))
+                               return;
+               }
                #endregion
 
                #region dispose