public override void OnFlowWindowScreenMenuGUI(FD.FlowWindow window, GenericMenu menu)
        {
            if (window.isVisibleState == false)
            {
                return;
            }
            if (window.IsContainer() == true)
            {
                return;
            }
            if (window.IsSmall() == true && window.IsFunction() == true)
            {
                return;
            }
            if (window.IsShowDefault() == true)
            {
                return;
            }

            if (Heatmap.settings == null)
            {
                Heatmap.settings = Heatmap.GetSettingsFile();
            }

            var settings = Heatmap.settings;

            if (settings != null)
            {
                var data = settings.data.Get(window);
                if (data == null)
                {
                    return;
                }

                foreach (var item in settings.items)
                {
                    if (item.show == true && item.enabled == true)
                    {
                        foreach (var serviceBase in this.editor.services)
                        {
                            var service = serviceBase as IAnalyticsService;
                            if (service.GetServiceName() == item.serviceName)
                            {
                                var key      = string.Format("{0}_{1}", item.serviceName, window.id);
                                var windowId = window.id;
                                menu.AddItem(new GUIContent("Open Heatmap..."), false, () => {
                                    //this.fullScreenData = this.heatmapResultsCache[key];
                                    this.fullScreenTexture  = this.heatmapTexturesCache[key];
                                    this.fullScreenWindowId = windowId;
                                    this.fullScreenEditor   = null;

                                    this.openFullScreen = true;
                                    this.flowEditor.SetDisabled();
                                });
                            }
                        }
                    }
                }
            }
        }
        public override void OnFlowSettingsGUI()
        {
            if (Heatmap.settings == null)
            {
                Heatmap.settings = Heatmap.GetSettingsFile();
            }

            if (this.noDataTexture == null)
            {
                this.noDataTexture = UnityEngine.Resources.Load <Texture>("UI.Windows/Heatmap/NoData");
            }

            var settings = Heatmap.settings;

            if (settings == null)
            {
                EditorGUILayout.HelpBox(string.Format(FlowAddon.MODULE_HAS_ERRORS, "Settings file not found (HeatmapSettings)."), MessageType.Error);
            }
            else
            {
                GUILayout.Label(FlowAddon.MODULE_INSTALLED, EditorStyles.centeredGreyMiniLabel);

                if (this.editor == null)
                {
                    this.editor = Editor.CreateEditor(settings) as HeatmapSettingsEditor;
                    this.editor.SetResetCallback(this.ResetCache);
                }

                if (this.editor != null)
                {
                    this.editor.OnInspectorGUI();
                }
            }
        }
        public override void OnFlowWindow(FD.FlowWindow window)
        {
            if (window.isVisibleState == false)
            {
                return;
            }
            if (window.IsContainer() == true)
            {
                return;
            }
            if (window.IsSmall() == true && window.IsFunction() == true)
            {
                return;
            }
            if (window.IsShowDefault() == true)
            {
                return;
            }

            if (Heatmap.settings == null)
            {
                Heatmap.settings = Heatmap.GetSettingsFile();
            }

            var settings = Heatmap.settings;

            if (settings != null)
            {
                var result = new ScreenResult();

                foreach (var item in settings.items)
                {
                    if (item.show == true && item.enabled == true)
                    {
                        foreach (var serviceBase in this.editor.services)
                        {
                            var service = serviceBase as IAnalyticsService;
                            if (service.GetServiceName() == item.serviceName)
                            {
                                var rect = window.rect;
                                this.DrawBubble(new Rect(new Vector2(rect.x + rect.width * 0.5f, rect.y), Vector2.zero), 0, window.id, -1, Vector2.zero, "LabelGreen");

                                int value;
                                var keyTransition = string.Format("{0}_{1}", item.serviceName, window.id);
                                if (this.resultsTransitionCache.TryGetValue(keyTransition, out value) == true)
                                {
                                    result.uniqueCount = value;
                                }

                                if (result.uniqueCount > 0 && result.popup == false)
                                {
                                    // Draw exit bubble
                                    this.DrawBubble(new Vector2(rect.x + rect.width * 0.5f, rect.y + rect.height), result, Vector2.zero, "LabelRed", "{1}");
                                }
                            }
                        }
                    }
                }
            }
        }
        public void DrawBubble(Rect rect, int index, int fromScreenId, int toScreenId, Vector2 offset, string styleName = "LabelYellow", string format = "<b>All:</b> {0}\n<b>Unique:</b> {1}")
        {
            if (Heatmap.settings == null)
            {
                Heatmap.settings = Heatmap.GetSettingsFile();
            }
            if (this.editor == null)
            {
                return;
            }

            var settings = Heatmap.settings;

            foreach (var item in settings.items)
            {
                if (item.show == true && item.enabled == true && item.processing == false)
                {
                    foreach (var serviceBase in this.editor.services)
                    {
                        var service = serviceBase as IAnalyticsService;
                        if (service.GetServiceName() == item.serviceName)
                        {
                            var key           = string.Format("{0}_{1}_{2}_{3}", item.serviceName, index, fromScreenId, toScreenId);
                            var keyTransition = string.Format("{0}_{1}", item.serviceName, fromScreenId);

                            ScreenResult result;
                            if (this.resultsCache.TryGetValue(key, out result) == true)
                            {
                                if (result != null)
                                {
                                    this.DrawBubble(rect.center, result, offset, styleName, format);
                                }
                                else
                                {
                                    // still loading
                                    this.DrawBubble(rect.center, "Loading...", "LabelYellow", Vector2.zero);
                                }
                            }
                            else
                            {
                                this.resultsCache.Add(key, null);
                                if (this.resultsTransitionCache.ContainsKey(keyTransition) == false)
                                {
                                    this.resultsTransitionCache.Add(keyTransition, 0);
                                }

                                var filter = item.userFilter;

                                if (toScreenId == -1)
                                {
/*
 *                                                                      Debug.Log("Screen Request");
 */
                                    service.GetScreen(fromScreenId, filter, (_result) => {
                                        this.resultsCache[key] = _result;
                                        this.resultsTransitionCache[keyTransition] += _result.uniqueCount;
                                    });
                                }
                                else
                                {
/*
 *                                                                      Debug.Log("Screen Transition Request");
 */
                                    service.GetScreenTransition(index, fromScreenId, toScreenId, filter, (_result) => {
                                        this.resultsCache[key] = _result;
                                        this.resultsTransitionCache[keyTransition] -= _result.uniqueCount;
                                    });
                                }
                            }
                        }
                    }
                }
            }
        }
 public override bool InstallationNeeded()
 {
     return(Heatmap.GetSettingsFile() == null);
 }
        public override void OnFlowWindowLayoutGUI(Rect rect, FD.FlowWindow window)
        {
            if (window.isVisibleState == false)
            {
                return;
            }
            if (window.IsContainer() == true)
            {
                return;
            }
            if (window.IsSmall() == true && window.IsFunction() == true)
            {
                return;
            }
            if (window.IsShowDefault() == true)
            {
                return;
            }

            if (Heatmap.settings == null)
            {
                Heatmap.settings = Heatmap.GetSettingsFile();
            }

            var settings = Heatmap.settings;

            if (settings != null)
            {
                var data = settings.data.Get(window);
                if (data == null)
                {
                    return;
                }

                LayoutWindowType screen;
                var layout = HeatmapSystem.GetLayout(window.id, out screen);
                if (layout == null)
                {
                    return;
                }

                var targetScreenSize = new Vector2(layout.root.editorRect.width, layout.root.editorRect.height);

                foreach (var item in settings.items)
                {
                    if (item.show == true && item.enabled == true)
                    {
                        foreach (var serviceBase in this.editor.services)
                        {
                            var service = serviceBase as IAnalyticsService;
                            if (service.GetServiceName() == item.serviceName)
                            {
                                var           key = string.Format("{0}_{1}", item.serviceName, window.id);
                                HeatmapResult result;
                                if (this.heatmapResultsCache.TryGetValue(key, out result) == true)
                                {
                                    if (result != null)
                                    {
                                        var texture = this.heatmapTexturesCache[key];
                                        if (texture != null)
                                        {
                                            var scaleFactor = HeatmapSystem.GetFactor(targetScreenSize, rect.size);
                                            //var scaleFactorCanvas = layout.editorScale > 0f ? 1f / layout.editorScale : 1f;
                                            //scaleFactor *= scaleFactorCanvas;
                                            var r = layout.root.editorRect;
                                            r.x      *= scaleFactor;
                                            r.y      *= scaleFactor;
                                            r.x      += rect.x + rect.width * 0.5f;
                                            r.y      += rect.y + rect.height * 0.5f;
                                            r.width  *= scaleFactor;
                                            r.height *= scaleFactor;

                                            var c = Color.white;
                                            GUI.color = c;
                                            GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, alphaBlend: true);
                                            GUI.color = Color.white;
                                        }
                                        else
                                        {
                                            if (this.noDataTexture != null)
                                            {
                                                GUI.DrawTexture(rect, this.noDataTexture, ScaleMode.ScaleToFit, alphaBlend: true);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        // still loading...
                                    }
                                }
                                else
                                {
                                    if (Event.current.type == EventType.Repaint)
                                    {
                                        var rectSize = targetScreenSize;                                        //rect.size;
                                        var rootRect = layout.root.editorRect;

                                        this.heatmapResultsCache.Add(key, null);
                                        this.heatmapTexturesCache.Add(key, null);
                                        service.GetHeatmapData(window.id, (int)targetScreenSize.x, (int)targetScreenSize.y, item.userFilter, (_result) => {
                                            var heatmapResult = _result as HeatmapResult;

                                            // Convert normalized points to real points
                                            for (int i = 0; i < heatmapResult.points.Length; ++i)
                                            {
                                                var root = layout.GetRootByTag((LayoutTag)heatmapResult.points[i].tag);
                                                if (root != null)
                                                {
                                                    var xn = heatmapResult.points[i].x;
                                                    var yn = heatmapResult.points[i].y;

                                                    var sourceRect     = root.editorRect;
                                                    var radius         = (float)HeatmapVisualizer.GetRadius();
                                                    sourceRect.x      += radius;
                                                    sourceRect.y      += radius;
                                                    sourceRect.width  -= radius * 2f;
                                                    sourceRect.height -= radius * 2f;

                                                    var scaleFactor = HeatmapSystem.GetFactor(targetScreenSize, rectSize);
                                                    var r           = sourceRect;
                                                    r.x            *= scaleFactor;
                                                    r.y            *= scaleFactor;
                                                    r.x            += rootRect.width * 0.5f;
                                                    r.y             = rootRect.height * 0.5f - r.y;
                                                    r.width        *= scaleFactor;
                                                    r.height       *= scaleFactor;

                                                    heatmapResult.points[i].realPoint = new Vector2(r.x + xn * r.width, r.y - yn * r.height);
                                                }
                                            }

                                            this.heatmapResultsCache[key] = heatmapResult;
                                            HeatmapSystem.GenerateTextureFromData((int)targetScreenSize.x, (int)targetScreenSize.y, this.heatmapResultsCache[key], (texture) => { this.heatmapTexturesCache[key] = texture; });
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }