private void DidDetectHandStateChange(HandState aFromState, HandState aToState, Point aHandLocation)
        {
            HandStateChangeEvent handEvent = null;

            if (aToState == HandState.Open && aFromState != HandState.Open)
            {
                handEvent = new HandStateChangeEvent(HandStateChangeType.CloseToOpen, aHandLocation);
            }
            else if (aToState == HandState.Closed && aFromState != HandState.Closed)
            {
                handEvent = new HandStateChangeEvent(HandStateChangeType.OpenToClose, aHandLocation);
            }

            if (handEvent != null)
            {
                this.NotifyHandStateChangeListenersOfEvent(handEvent);
            }
        }
        private void NotifyHandStateChangeListenersOfEvent(HandStateChangeEvent aEvent)
        {
            //notify the system listener of an interaction
            this._kinectManager.InteractionListener.SystemDidRecieveInteraction();

            lock (_handStateListenerLock)
            {
                foreach (HandStateChangeListener currentListener in this._handStateListeners)
            {
                bool result = currentListener.KinectHandManagerDidDetectHandStateChange(this, aEvent);
                //skip if the event was handled
                if (result)
                {
                    break;
                }
            }
            }

            if (this.Cursor != null)
            {
                KinectCursorView.CursorState state = (aEvent.EventType == HandStateChangeType.OpenToClose ? KinectCursorView.CursorState.ClosedHand : KinectCursorView.CursorState.OpenHand);
                this.Cursor.SetCursorState(state);
            }
        }
        public void KinectManagerDidGetUpdatedBodyData(KinectManager aManager, SmoothedBody<KalmanSmoother>[] aBodies)
        {
            SmoothedBody<KalmanSmoother> tracked = aBodies.Where(b => b.TrackingId == this._kinectManager.CurrentlyTrackingId).FirstOrDefault();

            if (tracked != null && tracked.TrackingId != 0)
            {
                Dictionary<JointType, Point> jointPoints = this._kinectManager.HandManager.ConvertJointsToDepthSpace(tracked);

                //check if we are already tracking a hand
                bool beganTracking = false;
                if (this._lastConfirmedHandState == HandState.NotTracked || !HandIsInCorrectPosition(jointPoints, this.TrackingLeftHand))
                {
                    if (this.ChooseHand(jointPoints))
                    {
                        beganTracking = true;
                        _lastConfirmedHandState = HandState.Open;
                    }
                }

                //Process hand loc
                Point currentHandLoc = ProcessHandLocation(jointPoints);

                //if began tracking, send out event
                if (beganTracking)
                {
                    HandStateChangeEvent beganTrackingEvent = new HandStateChangeEvent(HandStateChangeType.BeganTracking, currentHandLoc);
                    this.NotifyHandStateChangeListenersOfEvent(beganTrackingEvent);
                }

                //Process Hand State
                ProcessHandState(tracked, currentHandLoc);
            }
            else
            {
                _lastConfirmedHandState = HandState.NotTracked;
                _handStateCounter.Reset();
                _scaledHandLocationFilter.Set(new Point(this.HandCoordRangeX / 2, this.HandCoordRangeY / 2));
            }
        }