Fixes #32 - Adds UIManagerModule constants

Some remaining TODOs include integrating the constants from the view managers, and further investigation on how to include other features available in Android.

ReactWindows/ReactNative.Tests/Bridge/JavaScriptModuleRegistryTests.cs

@@ -2,8 +2,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using ReactNative.Bridge;
-using ReactNative.Modules.Core;
 using ReactNative.UIManager;
+using ReactNative.UIManager.Events;
 using System;
 using System.Collections.Generic;
 using System.Threading;

ReactWindows/ReactNative.Tests/UIManager/Events/RCTEventEmitterTests.cs

@@ -1,6 +1,6 @@
 using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
 using Newtonsoft.Json.Linq;
-using ReactNative.Modules.Core;
+using ReactNative.UIManager.Events;
 
 namespace ReactNative.Tests.UIManager.Events
 {

ReactWindows/ReactNative/CoreModulesPackage.cs

@@ -2,6 +2,7 @@
 using ReactNative.Modules.Core;
 using ReactNative.Tracing;
 using ReactNative.UIManager;
+using ReactNative.UIManager.Events;
 using System;
 using System.Collections.Generic;
 using Windows.UI.Xaml;

ReactWindows/ReactNative/ReactNative.csproj

@@ -201,6 +201,9 @@
     <Compile Include="Tracing\TraceDisposable.cs" />
     <Compile Include="Tracing\Tracer.cs" />
     <Compile Include="UIManager\AppRegistry.cs" />
+    <Compile Include="UIManager\Events\TouchEventType.cs" />
+    <Compile Include="UIManager\Events\TouchEventTypeExtensions.cs" />
+    <Compile Include="UIManager\PointerEvents.cs" />
     <Compile Include="UIManager\SizeMonitoringFrameLayout.cs" />
     <Compile Include="UIManager\NativeViewHierarchyManager.cs" />
     <Compile Include="UIManager\ReactProp.cs" />
@@ -211,6 +214,7 @@
     <Compile Include="UIManager\UIImplementation.cs" />
     <Compile Include="UIManager\UIImplementationProvider.cs" />
     <Compile Include="UIManager\UIManagerModule.cs" />
+    <Compile Include="UIManager\UIManagerModule.Constants.cs" />
     <Compile Include="UIManager\UIViewOperationQueue.cs" />
     <Compile Include="UIManager\ViewManager.cs" />
     <Compile Include="UIManager\ViewManagerRegistry.cs" />

ReactWindows/ReactNative/UIManager/Events/RCTEventEmitter.cs

@@ -1,7 +1,7 @@
 using Newtonsoft.Json.Linq;
 using ReactNative.Bridge;
 
-namespace ReactNative.Modules.Core
+namespace ReactNative.UIManager.Events
 {
     /// <summary>
     /// JavaScript event emitter.

ReactWindows/ReactNative/UIManager/Events/TouchEventType.cs

@@ -0,0 +1,29 @@
+namespace ReactNative.UIManager.Events
+{
+    /// <summary>
+    /// Touch event types that the JavaScript module <see cref="RCTEventEmitter"/>
+    /// understands.
+    /// </summary>
+    public enum TouchEventType
+    {
+        /// <summary>
+        /// Touch start event type.
+        /// </summary>
+        Start,
+
+        /// <summary>
+        /// Touch end event type.
+        /// </summary>
+        End,
+
+        /// <summary>
+        /// Touch move event type.
+        /// </summary>
+        Move,
+
+        /// <summary>
+        /// Touch cancel event type.
+        /// </summary>
+        Cancel,
+    }
+}

ReactWindows/ReactNative/UIManager/Events/TouchEventTypeExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace ReactNative.UIManager.Events
+{
+    static class TouchEventTypeExtensions
+    {
+        public static string GetJavaScriptEventName(this TouchEventType eventType)
+        {
+            switch (eventType)
+            {
+                case TouchEventType.Start:
+                    return "topTouchStart";
+                case TouchEventType.End:
+                    return "topTouchEnd";
+                case TouchEventType.Move:
+                    return "topTouchMove";
+                case TouchEventType.Cancel:
+                    return "topTouchCancel";
+                default:
+                    throw new NotSupportedException("Unsupported touch event type.");
+            }
+        }
+    }
+}

ReactWindows/ReactNative/UIManager/PointerEvents.cs

@@ -0,0 +1,30 @@
+namespace ReactNative.UIManager
+{
+    /// <summary>
+    /// Possible values for pointer events that a view and its descendants should
+    /// receive. See https://developer.mozilla.org/en-US/docs/Web/CSS/pointer-events
+    /// for more information.
+    /// </summary>
+    public enum PointerEvents
+    {
+        /// <summary>
+        /// Neither the container nor its children receive events.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Container does not get events but all its children do.
+        /// </summary>
+        BoxNone,
+
+        /// <summary>
+        /// Container gets events but none of its children do.
+        /// </summary>
+        BoxOnly,
+
+        /// <summary>
+        /// Container and all of its children receive touch events.
+        /// </summary>
+        Auto,
+    }
+}

ReactWindows/ReactNative/UIManager/UIManagerModule.Constants.cs

@@ -0,0 +1,260 @@
+using ReactNative.UIManager.Events;
+using System.Collections.Generic;
+
+namespace ReactNative.UIManager
+{
+    using Windows.UI.Xaml;
+    using Map = Dictionary<string, object>;
+
+    public partial class UIManagerModule
+    {
+        private const string CUSTOM_BUBBLING_EVENT_TYPES_KEY = "customBubblingEventTypes";
+        private const string CUSTOM_DIRECT_EVENT_TYPES_KEY = "customDirectEventTypes";
+
+        public const string ACTION_DISMISSED = "dismissed";
+        public const string ACTION_ITEM_SELECTED = "itemSelected";
+
+        public static IDictionary<string, object> CreateConstants(IReadOnlyList<ViewManager<FrameworkElement, ReactShadowNode>> viewManagers)
+        {
+            var constants = GetConstants();
+            var bubblingEventTypesConstants = GetBubblingEventTypeConstants();
+            var directEventTypesConstants = GetDirectEventTypeConstants();
+
+            foreach (var viewManager in viewManagers)
+            {
+                // TODO: add view manager exports
+            }
+
+            constants.Add(CUSTOM_BUBBLING_EVENT_TYPES_KEY, bubblingEventTypesConstants);
+            constants.Add(CUSTOM_DIRECT_EVENT_TYPES_KEY, directEventTypesConstants);
+
+            return constants;
+        }
+
+        public static IDictionary<string, object> GetBubblingEventTypeConstants()
+        {
+            return new Map
+            {
+                {
+                    "topChange",
+                    new Map
+                    {
+                        {
+                            "phasedRegistrationNames",
+                            new Map
+                            {
+                                { "bubbled", "onChange" },
+                                { "captured", "onChangeCapture" },
+                            }
+                        }
+                    }
+                },
+                {
+                    "topSelect",
+                    new Map
+                    {
+                        {
+                            "phasedRegistrationNames",
+                            new Map
+                            {
+                                { "bubbled", "onSelect" },
+                                { "captured", "onSelectCapture" },
+                            }
+                        }
+                    }
+                },
+                {
+                    TouchEventType.Start.GetJavaScriptEventName(),
+                    new Map
+                    {
+                        {
+                            "phasedRegistrationName",
+                            new Map
+                            {
+                                { "bubbled", "onTouchStart" },
+                                { "captured", "onTouchStartCapture" },
+                            }
+                        }
+                    }
+                },
+                                {
+                    TouchEventType.Move.GetJavaScriptEventName(),
+                    new Map
+                    {
+                        {
+                            "phasedRegistrationName",
+                            new Map
+                            {
+                                { "bubbled", "onTouchMove" },
+                                { "captured", "onTouchMoveCapture" },
+                            }
+                        }
+                    }
+                },
+                {
+                    TouchEventType.Start.GetJavaScriptEventName(),
+                    new Map
+                    {
+                        {
+                            "phasedRegistrationName",
+                            new Map
+                            {
+                                { "bubbled", "onTouchEnd" },
+                                { "captured", "onTouchEndCapture" },
+                            }
+                        }
+                    }
+                },
+            };
+        }
+
+        public static IDictionary<string, object> GetDirectEventTypeConstants()
+        {
+            return new Map
+            {
+                {
+                    "topSelectionChange",
+                    new Map
+                    {
+                        { "registrationName", "onSelectionChange" },
+                    }
+                },
+                {
+                    "topLoadingStart",
+                    new Map
+                    {
+                        { "registrationName", "onLoadingStart" },
+                    }
+                },
+                {
+                    "topLoadingFinish",
+                    new Map
+                    {
+                        { "registrationName", "onLoadingFinish" },
+                    }
+                },
+                {
+                    "topLoadingError",
+                    new Map
+                    {
+                        { "registrationName", "onLoadingError" },
+                    }
+                },
+                {
+                    "topLayout",
+                    new Map
+                    {
+                        { "registrationName", "onLayout" },
+                    }
+                },
+            };
+        }
+
+        public static IDictionary<string, object> GetConstants()
+        {
+            return new Map
+            {
+                {
+                    "UIView",
+                    new Map
+                    {
+                        {
+                            "ContentMode",
+                            new Map
+                            {
+                                /* TODO: declare content mode properties */
+                            }
+                        },
+                    }
+                },
+                {
+                    "UIText",
+                    new Map
+                    {
+                        {
+                            "AutocapitalizationType",
+                            new Map
+                            {
+                                /* TODO: declare capitalization types */
+                            }   
+                        },
+                    }
+                },
+                {
+                    "Dimensions",
+                    new Map
+                    {
+                        {
+                            "window",
+                            new Dictionary<string, object>
+                            {
+                                { "width", 100 },
+                                { "height", 100 },
+                                { "scale", 1 },
+                                /* TODO: verify values? */
+                                /* TODO: density and DPI needed? */
+                            }
+                        },
+                    }
+                },
+                {
+                    "StyleConstants",
+                    new Map
+                    {
+                        {
+                            "PointerEventsValues",
+                            new Map
+                            {
+                                { "none", PointerEvents.None.ToString() },
+                                { "boxNone", PointerEvents.BoxNone.ToString() },
+                                { "boxOnly", PointerEvents.BoxOnly.ToString() },
+                                { "unspecified", PointerEvents.Auto.ToString() },
+                            }
+                        },
+                    }
+                },
+                {
+                    "PopupMenu",
+                    new Map
+                    {
+                        { ACTION_DISMISSED, ACTION_DISMISSED },
+                        { ACTION_ITEM_SELECTED, ACTION_ITEM_SELECTED },
+                    }
+                },
+                {
+                    "AccessibilityEventTypes",
+                    new Map
+                    {
+                        /* TODO: declare accessibility event types */
+                    }
+                },
+            };
+        }
+
+        private static void RecursiveMerge(IDictionary<string, object> sink, IDictionary<string, object> source)
+        {
+            foreach (var pair in source)
+            {
+                var existing = default(object);
+                if (sink.TryGetValue(pair.Key, out existing))
+                {
+                    var sourceAsMap = pair.Value as IDictionary<string, object>;
+                    var sinkAsMap = existing as IDictionary<string, object>;
+                    if (sourceAsMap != null && sinkAsMap != null)
+                    {
+                        RecursiveMerge(sinkAsMap, sourceAsMap);
+                    }
+                    else
+                    {
+                        // TODO: replace with exception?
+                        sink.Add(pair.Key, pair.Value);
+                    }
+                }
+                else
+                {
+                    sink.Add(pair.Key, pair.Value);
+                }
+            }
+        }
+    }
+}