public void UpdateSpriteTextSize(int index, int action)
        {
            ScheduleOnce((dt) => {
                if (index != -1 && action != EditTypes.None)
                {
                    var mIconRef = iconList2[index];
                    var mSprite  = mIconRef.Sprite;
                    var mContent = mSprite.GetChildByTag(SpriteTypes.ContentTag) as CCLabel;

                    if (mContent != null)
                    {
                        switch (action)
                        {
                        case EditTypes.UpdateLabelSizeUp:
                            mContent.AddAction(new CCScaleBy(0.2f, 1.1f));
                            break;

                        case EditTypes.UpdateLabelSizeDefault:
                            mContent.AddAction(new CCScaleTo(0.2f, 1f));
                            break;

                        case EditTypes.UpdateLabelSizeDown:
                            mContent.AddAction(new CCScaleBy(0.2f, 0.9f));
                            break;
                        }

                        if (mSprite.Tag == SpriteTypes.FolderTag)
                        {
                            for (var i = storedList.Count - 1; i >= 0; i--)
                            {
                                if (storedList[i].FolderName == mContent.Text)
                                {
                                    var newStoredIconRef = new StoredIconReference(storedList[i].Sprite,
                                                                                   storedList[i].Base64,
                                                                                   storedList[i].FolderName,
                                                                                   storedList[i].Sprite.ScaleX,
                                                                                   mContent.ScaleX,
                                                                                   storedList[i].TextVisible);

                                    storedList.RemoveAt(i);
                                    storedList.Add(newStoredIconRef);
                                }
                            }
                        }
                    }
                }
            }, 0);
        }
        public void LoadSprites(IconStorageObject json)
        {
            iconList2  = new List <IconReference>();
            storedList = new List <StoredIconReference>();

            if (json != null)
            {
                foreach (IconModel icon in json.Icons)
                {
                    if (icon.Tag == SpriteTypes.IconTag)
                    {
                        var newIcon = spriteModelFactory.MakeIconBase64(icon.Base64, icon.Text, icon.X, icon.Y, icon.Scale, icon.TextScale, icon.TextVisible);

                        iconList2.Add(new IconReference(newIcon, icon.Base64, 1f, true));
                        AddEventListener(mListener.Copy(), newIcon);
                    }
                }

                foreach (FolderModel icon in json.Folders)
                {
                    if (icon.Tag == SpriteTypes.FolderTag)
                    {
                        var newIcon = spriteModelFactory.MakeFolder(icon.AssetName, icon.Text, icon.X, icon.Y, icon.Scale);
                        newIcon.Tag = SpriteTypes.FolderTag;
                        iconList2.Add(new IconReference(newIcon, icon.AssetName, icon.TextScale, icon.TextVisible));
                        AddEventListener(mListener.Copy(), newIcon);
                    }
                }

                foreach (StoredIconModel icon in json.StoredIcons)
                {
                    var newIcon       = spriteModelFactory.MakeIconBase64(icon.Base64, icon.Text, icon.X, icon.Y, icon.Scale, icon.TextScale, icon.TextVisible);
                    var storedIconRef = new StoredIconReference(newIcon, icon.Base64, icon.Folder, icon.Scale, icon.TextScale, icon.TextVisible);

                    storedList.Add(storedIconRef);
                }

                SetSingleMode(json.SingleMode);
            }

            var counter = 1;

            foreach (IconReference icon in iconList2)
            {
                AddChild(icon.Sprite, counter, icon.Sprite.Tag);
                counter++;
            }
        }
        public void UpdateSpriteText(int index, string text)
        {
            ScheduleOnce((dt) => {
                if (index != -1 && text != "")
                {
                    var mIconRef = iconList2[index];
                    var mSprite  = mIconRef.Sprite;
                    var mContent = mSprite.GetChildByTag(SpriteTypes.ContentTag) as CCLabel;

                    if (mContent != null)
                    {
                        if (mSprite.Tag == SpriteTypes.FolderTag)
                        {
                            for (var i = storedList.Count - 1; i >= 0; i--)
                            {
                                if (storedList[i].FolderName == mContent.Text)
                                {
                                    var newStoredIconRef = new StoredIconReference(storedList[i].Sprite,
                                                                                   storedList[i].Base64,
                                                                                   text,
                                                                                   storedList[i].Sprite.ScaleX,
                                                                                   storedList[i].TextScale,
                                                                                   storedList[i].TextVisible);

                                    storedList.RemoveAt(i);

                                    storedList.Add(newStoredIconRef);
                                }
                            }
                        }

                        mContent.Text = text;
                    }
                }
            }, 0);
        }
        void OnTouchesEnded(CCTouch touch, CCEvent touchEvent)
        {
            endTime = DateTime.Now;

            var timeDiff = endTime - startTime;

            if (CurrentSpriteTouched != null)
            {
                if (touchType == Tags.Tag.Icon)
                {
                    var    target = (CCSprite)touchEvent.CurrentTarget;
                    CCRect rect   = target.BoundingBoxTransformedToWorld;

                    List <IconReference> mFolders = iconList2.Where(t => t.Sprite.Tag == SpriteTypes.FolderTag).ToList();
                    var mIntersect = mFolders.Where(t => t.Sprite.BoundingBoxTransformedToParent.IntersectsRect(rect)).ToList();

                    if (mIntersect.Count == 1)
                    {
                        string mContentTag = SpriteHasLabel(mIntersect[0].Sprite);

                        if (mContentTag != "")
                        {
                            List <StoredIconReference> mInFolder = storedList.Where(t => t.FolderName == mContentTag).ToList();

                            if (mInFolder.Count < 9)
                            {
                                var mCloneCopy = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();

                                var spriteLabel = mCloneCopy.Sprite.GetChildByTag(SpriteTypes.ContentTag) as CCLabel;

                                if (spriteLabel == null)
                                {
                                    return;
                                }

                                var newItem = new StoredIconReference(mCloneCopy.Sprite, mCloneCopy.Base64, mContentTag, mCloneCopy.Sprite.ScaleX, spriteLabel.ScaleX, spriteLabel.Visible);

                                var savedScale = (float)mCloneCopy.Sprite.ScaleX;

                                CurrentSpriteTouched = null;

                                ScheduleOnce((dt) =>
                                {
                                    var moveAction   = new CCMoveTo(0.2f, mIntersect[0].Sprite.Position);
                                    var scaleAction  = new CCScaleTo(0.2f, 0.1f);
                                    var clearColor   = new CCCallFuncN(node => node.Color = White);
                                    var setInvisible = new CCCallFuncN(node => node.Visible = false);
                                    var scaleAction2 = new CCScaleTo(0.01f, savedScale);
                                    var endAction    = new CCCallFuncN(node => node.RemoveFromParent(true));

                                    target.AddActions(false,
                                                      moveAction,
                                                      scaleAction,
                                                      clearColor,
                                                      setInvisible,
                                                      scaleAction2,
                                                      endAction);
                                }, 0);

                                iconList2.Remove(mCloneCopy);
                                //newItem.Item1.Scale = savedScale;
                                storedList.Add(newItem);
                                //storedList.Add(trueClone);

                                return;
                            }
                        }
                    }

                    if (deleteFrame.BoundingBoxTransformedToParent.IntersectsRect(rect) && inEditMode)
                    {
                        var mSprite = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();

                        ScheduleOnce((dt) => {
                            RemoveChild(target);
                        }, 0);

                        iconList2.Remove(mSprite);
                    }
                    else if (inEditMode && timeDiff.TotalSeconds < 0.25)
                    {
                        var mSprite  = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();
                        var mCounter = iconList2.IndexOf(mSprite);

                        GamePageParent.CallActionSheet(mCounter);
                    }
                }
                else if (touchType == Tags.Tag.FolderIcon && inEditMode && timeDiff.TotalSeconds < 0.25)
                {
                    var target   = (CCSprite)touchEvent.CurrentTarget;
                    var mSprite  = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();
                    var mCounter = iconList2.IndexOf(mSprite);

                    GamePageParent.CallActionSheet(mCounter);
                }
                else if (touchType == Tags.Tag.FolderIcon && !inEditMode)
                {
                    string contentTag = SpriteHasLabel(CurrentSpriteTouched);

                    if (contentTag != "")
                    {
                        ShowWindow(CurrentSpriteTouched, contentTag);
                    }
                }
                else if (touchType == Tags.Tag.Add && inEditMode)
                {
                    GamePageParent.CallImagePicker();
                }
                else if (touchType == Tags.Tag.TakePhoto && inEditMode)
                {
                    GamePageParent.CallImageTaker();
                }
                else if (touchType == Tags.Tag.Folder && inEditMode)
                {
                    var mList = iconList2.Where(t => t.Sprite.Tag == SpriteTypes.FolderTag).ToList();

                    var nameList = new List <string>();

                    mList.ForEach(p =>
                    {
                        var returnedString = SpriteHasLabel(p.Sprite);

                        if (returnedString != "")
                        {
                            nameList.Add(returnedString.ToLower());
                        }
                    });

                    lock (nameList)
                    {
                        GamePageParent.GetFolderSetup(nameList);
                    }
                }
                else if (touchType == Tags.Tag.FolderIcon && inEditMode)
                {
                    var    target = (CCSprite)touchEvent.CurrentTarget;
                    CCRect rect   = target.BoundingBoxTransformedToWorld;

                    if (deleteFrame.BoundingBoxTransformedToParent.IntersectsRect(rect) && inEditMode)
                    {
                        var mSprite = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();

                        ScheduleOnce((dt) => {
                            RemoveChild(target);
                        }, 0);

                        iconList2.Remove(mSprite);
                    }
                    else if (timeDiff.TotalSeconds < 0.25f)
                    {
                        var mSprite  = iconList2.Where(t => t.Sprite.GetHashCode() == target.GetHashCode()).FirstOrDefault();
                        var mCounter = iconList2.IndexOf(mSprite);
                        GamePageParent.CallActionSheet(mCounter);
                    }
                }
                else if (touchType == Tags.Tag.Speak && timeDiff.TotalSeconds < 5.0f)
                {
                    List <IconReference> mList = null;

                    if (!inSingleMode)
                    {
                        mList = iconList2.Where(t => sentenceFrame.BoundingBoxTransformedToParent.IntersectsRect(t.Sprite.BoundingBoxTransformedToParent) == true).ToList();
                    }
                    else
                    {
                        mList = iconList2.Where(t => t.Sprite.Color == Green).ToList();
                    }

                    if (mList.Count > 1)
                    {
                        mList = mList.OrderBy(i => i.Sprite.PositionX).ToList();
                    }

                    List <string> labelList = new List <string>();

                    foreach (IconReference mIcon in mList)
                    {
                        string contentTag = SpriteHasLabel(mIcon.Sprite);

                        if (contentTag != "")
                        {
                            labelList.Add(contentTag);
                        }
                    }

                    var outputString = string.Join(" ", labelList.ToArray());

                    DependencyService.Get <ITextToSpeech>().Speak(outputString);
                }
                else if (touchType == Tags.Tag.Speak && timeDiff.TotalSeconds >= 5.0f)
                {
                    SetEditMode(!inEditMode);
                }
                else if (touchType == Tags.Tag.SingleMode && inEditMode)
                {
                    SetSingleMode(true);
                }
                else if (touchType == Tags.Tag.MultiMode && inEditMode)
                {
                    SetSingleMode(false);
                }

                CurrentSpriteTouched = null;

                CCSprite caller = touchEvent.CurrentTarget as CCSprite;
                caller.Opacity = 255;
            }
        }
        bool OnTouchBegan(CCTouch touch, CCEvent touchEvent)
        {
            CCSprite caller = touchEvent.CurrentTarget as CCSprite;

            if (caller.Tag == SpriteTypes.IconTag)
            {
                ReorderChild(caller, 999);
            }

            CurrentSpriteTouched = null;
            touchType            = Tags.Tag.None;

            startTime = DateTime.Now;

            if (windowFrame != null)
            {
                if (windowFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    if (closeButton.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                    {
                        isModal = false;

                        var scaleAction    = new CCScaleTo(0.2f, 0.05f);
                        var functionAction = new CCCallFunc(ClearWindow);
                        windowFrame.AddActions(false, scaleAction, functionAction);

                        return(true);
                    }

                    var mIcons = windowFrame.Children;

                    foreach (var mIcon in mIcons)
                    {
                        if (mIcon.Tag == SpriteTypes.IconTag && mIcon.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                        {
                            touchType = Tags.Tag.TransitionIcon;

                            var mContent = mIcon.GetChildByTag(SpriteTypes.ContentTag) as CCLabel;

                            if (mContent != null)
                            {
                                StoredIconReference mStoredRef = null;
                                foreach (StoredIconReference storedRef in storedList)
                                {
                                    var mLoopSprite  = storedRef.Sprite;
                                    var mLoopContent = mLoopSprite.GetChildByTag(SpriteTypes.ContentTag) as CCLabel;

                                    if (mLoopContent != null && mLoopContent.Text == mContent.Text)
                                    {
                                        var xMin      = (spriteModelFactory.DynamicHeight * 0.1f) / 2;
                                        var yLocation = mRandom.Next((int)(spriteModelFactory.DynamicHeight * 0.3f), (int)(spriteModelFactory.DynamicHeight - (spriteModelFactory.DynamicHeight * 0.3f)));
                                        var xLocation = mRandom.Next((int)(spriteModelFactory.DynamicWidth * 0.3f), (int)(spriteModelFactory.DynamicWidth - (spriteModelFactory.DynamicWidth * 0.3f)));

                                        var newIcon = spriteModelFactory.MakeIconBase64(storedRef.Base64, mLoopContent.Text,
                                                                                        xLocation, yLocation, storedRef.Scale, storedRef.TextScale, storedRef.TextVisible);

                                        var mIconRef = new IconReference(newIcon, storedRef.Base64, 1f, true);

                                        AddEventListener(mListener.Copy(), mIconRef.Sprite);
                                        iconList2.Add(mIconRef);

                                        AddChild(mIconRef.Sprite);

                                        mStoredRef = storedRef;
                                    }
                                }

                                if (mStoredRef != null)
                                {
                                    storedList.Remove(mStoredRef);
                                }
                            }

                            isModal = false;

                            iconList2.Remove(tempWindow);

                            windowFrame.RemoveChild(closeButton);

                            RemoveChild(windowFrame);

                            windowFrame = closeButton = null;
                            tempWindow  = null;

                            return(true);
                        }
                    }

                    return(false);
                }
            }

            #region ButtonSpecific Listeners

            if (caller.GetHashCode() == speakerFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (speakerFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (speakerFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.Speak;
                    CurrentSpriteTouched = speakerFrame;
                    caller.Opacity       = 155;

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (caller.GetHashCode() == addFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (addFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (addFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.Add;
                    CurrentSpriteTouched = addFrame;
                    caller.Opacity       = 155;
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (caller.GetHashCode() == takePhotoFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (takePhotoFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (takePhotoFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.TakePhoto;
                    CurrentSpriteTouched = takePhotoFrame;
                    caller.Opacity       = 155;
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (caller.GetHashCode() == addFolderFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (addFolderFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (addFolderFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.Folder;
                    CurrentSpriteTouched = addFolderFrame;
                    caller.Opacity       = 155;
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (caller.GetHashCode() == singleFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (singleFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (singleFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.SingleMode;
                    CurrentSpriteTouched = singleFrame;
                    caller.Opacity       = 155;
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (caller.GetHashCode() == multiFrame.GetHashCode())
            {
                foreach (IconReference iconRef in iconList2)
                {
                    var rect = iconRef.Sprite.BoundingBoxTransformedToWorld;

                    if (multiFrame.BoundingBoxTransformedToParent.IntersectsRect(rect))
                    {
                        return(false);
                    }
                }

                if (multiFrame.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                {
                    touchType            = Tags.Tag.MultiMode;
                    CurrentSpriteTouched = multiFrame;
                    caller.Opacity       = 155;
                    return(true);
                }
                else
                {
                    return(false);
                }
            }

            #endregion

            foreach (IconReference iconRef in iconList2)
            {
                if (iconRef.Sprite.Tag == SpriteTypes.IconTag)
                {
                    if (inSingleMode)
                    {
                        if (caller.GetHashCode() == iconRef.Sprite.GetHashCode())
                        {
                            if (iconRef.Sprite.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                            {
                                touchType = Tags.Tag.Icon;

                                CurrentSpriteTouched = iconRef.Sprite;
                                caller.Opacity       = 155;

                                DeSelectIcons();

                                caller.Color = Green;

                                return(true);
                            }
                            else
                            {
                                return(false);
                            }
                        }
                    }
                    else
                    {
                        if (caller.GetHashCode() == iconRef.Sprite.GetHashCode())
                        {
                            if (iconRef.Sprite.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                            {
                                touchType            = Tags.Tag.Icon;
                                CurrentSpriteTouched = iconRef.Sprite;
                                caller.Opacity       = 155;

                                if (!sentenceFrame.Visible)
                                {
                                    caller.Color = Green;
                                }

                                return(true);
                            }
                            else
                            {
                                return(false);
                            }
                        }
                    }
                }
                else if (iconRef.Sprite.Tag == SpriteTypes.FolderTag)
                {
                    if (caller.GetHashCode() == iconRef.Sprite.GetHashCode())
                    {
                        if (iconRef.Sprite.BoundingBoxTransformedToWorld.ContainsPoint(touch.Location))
                        {
                            touchType            = Tags.Tag.FolderIcon;
                            CurrentSpriteTouched = iconRef.Sprite;
                            caller.Opacity       = 155;

                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
            }

            return(false);
        }