Esempio n. 1
0
        /// <summary>
        /// Загружает документ-раскадровку с рабочего холста программы
        /// </summary>
        /// <param name="storyboardCanvas">Рабочий холст программы, с которой предполагается загрузить документ-раскадровку</param>
        /// <returns></returns>
        public static StoryboardDocument LoadFromCanvas(StoryboardCanvas storyboardCanvas)
        {
            StoryboardDocument newDocument = new StoryboardDocument();

            newDocument.Template = storyboardCanvas.BackgroundManager.CurrentTempalte;

            List <ImageSource> frameBackgrounds = new List <ImageSource>();

            for (int i = 0; i < storyboardCanvas.BackgroundManager.CurrentTempalte.NumFrames; i++)
            {
                frameBackgrounds.Add(storyboardCanvas.BackgroundManager.GetImageOfFrame(i));
            }

            newDocument.FrameBackgrounds = frameBackgrounds;

            List <ItemTuple> storyboardItems = new List <ItemTuple>();

            UIElement[] storyboardCanvasChildren = new UIElement[storyboardCanvas.Children.Count];

            storyboardCanvas.Children.CopyTo(storyboardCanvasChildren, 0);

            foreach (UIElement element in storyboardCanvasChildren.OrderBy(x => Panel.GetZIndex(x)))
            {
                StoryboardItem item = element as StoryboardItem;

                if (item != null)
                {
                    RotateTransform itemTransform = item.RenderTransform as RotateTransform;

                    item.RenderTransform = null;

                    Rect itemRect = new Rect();

                    itemRect.X      = Canvas.GetLeft(item);
                    itemRect.Y      = Canvas.GetTop(item);
                    itemRect.Width  = item.ActualWidth;
                    itemRect.Height = item.ActualHeight;

                    item.RenderTransform = itemTransform;

                    Image itemImageSource = (Image)item.Content;

                    ItemTuple newTuple = new ItemTuple(itemRect, itemTransform, itemImageSource.Source);

                    storyboardItems.Add(newTuple);
                }
            }

            newDocument.StoryboardItems = storyboardItems;

            return(newDocument);
        }
Esempio n. 2
0
        public static void HierarchyFromStream(Stream stream, GameObject root)
        {
            var numSavedChildren = stream.ReadInt();
            var children         = root.GetComponentsInChildren <Transform>();
            var newHierarchy     = numSavedChildren != children.Length;

            var list = new List <ItemTuple <GameObject, int> >(numSavedChildren);

            if (newHierarchy)
            {
                GameObjectFromStream(stream, root);
                list.Add(ItemTuple.Create(root, 0));
                for (int i = 0; i < numSavedChildren - 1; i++)
                {
                    var depth = stream.ReadInt();
                    var go    = new GameObject();
                    GameObjectFromStream(stream, go);
                    list.Add(ItemTuple.Create(go, depth));
                }
            }
            else
            {
                GameObjectFromStream(stream, root);
                list.Add(ItemTuple.Create(root, 0));
                for (int i = 0; i < numSavedChildren - 1; i++)
                {
                    var depth = stream.ReadInt();
                    var go    = children[i + 1].gameObject;
                    GameObjectFromStream(stream, go);
                    list.Add(ItemTuple.Create(go, depth));
                }
            }

            // traverse forward
            for (int i = 0; i < list.Count; i++)
            {
                // foreach item going forward, we traverse backwards
                // to find the first parent item
                var forward = list[i];
                for (int j = i - 1; j >= 0; j--)
                {
                    var backward = list[j];
                    if (forward.Item2 == backward.Item2 + 1)
                    {
                        //Debug.Log("parenting: " + forward.Item1 + " to: " + backward.Item1);
                        forward.Item1.transform.SetParent(backward.Item1.transform, true);
                        break;
                    }
                }
            }
        }
    private static ItemCostTuple getRandomItem()
    {
        ItemTuple     item     = ResourceItems[UnityEngine.Random.Range(0, ResourceItems.Count)];
        ItemCostTuple itemCost = new ItemCostTuple();

        itemCost.item = item;

        float flatPrice = 0;

        foreach (ResourceAmount amount in item.cost)
        {
            flatPrice += CostManager.Instance.getPrice(amount.resourceName) * amount.amount;
        }

        itemCost.priceUpper = Mathf.FloorToInt(flatPrice * (UnityEngine.Random.Range(1f, 1.4f) + (ResourceStorage.Instance.checkResource("Reputation") / 10f)));
        itemCost.priceLower = Mathf.FloorToInt(flatPrice * (UnityEngine.Random.Range(0.8f, 1f) - (ResourceStorage.Instance.checkResource("Reputation") / 20f)));
        return(itemCost);
    }
Esempio n. 4
0
        public bool Member(MemberInfo member, object rawTarget, UnityObject unityTarget, int id, bool ignoreComposition, out EditorMember wrappedMember)
        {
            if (member.MemberType == MemberTypes.Method)
            {
                var method       = member as MethodInfo;
                var methodKey    = Cache.GetMethodKey(ItemTuple.Create(id, method));
                var methodDrawer = MemberDrawersHandler.GetMethodDrawer(methodKey);
                methodDrawer.Initialize(method, rawTarget, unityTarget, methodKey, this, prefs);
                wrappedMember = null;
                return(methodDrawer.OnGUI());
            }
            else
            {
                var cachedMember = Cache.GetMember(ItemTuple.Create(member, id));
                cachedMember.RawTarget   = rawTarget;
                cachedMember.UnityTarget = unityTarget;
                wrappedMember            = cachedMember;

                return(Member(cachedMember, ignoreComposition));
            }
        }
        private void OnAdd(int startingIndex, ItemType itemType, object group, IList newItems)
        {
            int resolvedLastIndex = _resolvedFirstIndex + _resolvedCount - 1;

            // Perform the Add operation

            ItemTuple[] newData = new ItemTuple[newItems.Count];
            for (int index = 0; index < newItems.Count; ++index)
            {
                newData[index] = new ItemTuple() { ItemType = itemType, Group = group, Item = newItems[index] };
            }

            if (startingIndex <= _resolvedFirstIndex || startingIndex > resolvedLastIndex)
            {
                // If the operation is completely outside the bounds of the resolved items, then it can just happen.
                
                if (startingIndex <= _resolvedFirstIndex)
                {
                    if (_resolvedCount > 0)
                    {
                        _resolvedFirstIndex += newItems.Count;
                    }
                    else
                    {
                        _resolvedFirstIndex = 0;
                    }
                }
            }
            else if (startingIndex < _screenFirstIndex)
            {
                int removeCount = startingIndex - _resolvedFirstIndex + 1;

                while (removeCount-- > 0)
                {
                    RecycleFirst();
                }

                _resolvedFirstIndex += newItems.Count;
            }
            else
            {
                int removeCount = _resolvedCount - startingIndex + _resolvedFirstIndex;

                while (removeCount-- > 0)
                {
                    RecycleLast();
                }
            }

            // Perform the Add operation
            _flattenedItems.InsertRange(startingIndex, newData);
        }
        private ContentPresenter GetAndAddElementFor(ItemTuple tuple)
        {
            ContentPresenter cp = null;
            bool isNew = false;

            switch (tuple.ItemType)
            {
                case ItemType.Item:
                    if (_recycledItems.Count > 0)
                    {
                        cp = _recycledItems.Pop();
                    }
                    else
                    {
                        isNew = true;
                        cp = new ContentPresenter();
                        cp.ContentTemplate = ItemTemplate;

                        GestureService.GetGestureListener(cp).Tap += OnItemTap;
                    }
                    break;
                case ItemType.GroupHeader:
                    if (_recycledGroupHeaders.Count > 0)
                    {
                        cp = _recycledGroupHeaders.Pop();
                    }
                    else
                    {
                        isNew = true;
                        cp = new ContentPresenter();
                        cp.ContentTemplate = GroupHeaderTemplate;

                        GestureService.GetGestureListener(cp).Tap += GroupHeaderTap;
                    }
                    break;
                case ItemType.GroupFooter:
                    if (_recycledGroupFooters.Count > 0)
                    {
                        cp = _recycledGroupFooters.Pop();
                    }
                    else
                    {
                        isNew = true;
                        cp = new ContentPresenter();
                        cp.ContentTemplate = GroupFooterTemplate;
                    }
                    break;
                case ItemType.ListHeader:
                    if (_recycledListHeader != null)
                    {
                        cp = _recycledListHeader;
                        _recycledListHeader = null;
                    }
                    else
                    {
                        isNew = true;
                        cp = new ContentPresenter();
                        cp.ContentTemplate = ListHeaderTemplate;
                    }
                    break;
                case ItemType.ListFooter:
                    if (_recycledListFooter != null)
                    {
                        cp = _recycledListFooter;
                        _recycledListFooter = null;
                    }
                    else
                    {
                        isNew = true;
                        cp = new ContentPresenter();
                        cp.ContentTemplate = ListFooterTemplate;
                    }
                    break;
                default:
                    break;
            }

            if (isNew)
            {
                cp.CacheMode = new BitmapCache();
                _itemsPanel.Children.Add(cp);
                cp.SizeChanged += new SizeChangedEventHandler(OnItemSizeChanged);
            }

            if (cp != null)
            {
                if (cp.Width != _availableSize.Width)
                {
                    cp.Width = _availableSize.Width;
                }
                cp.Content = tuple.Item;
                cp.Visibility = Visibility.Visible;
            }

            EventHandler<LinkUnlinkEventArgs> handler = Link;
            if (handler != null)
            {
                handler(this, new LinkUnlinkEventArgs(cp));
            }
            
            tuple.ContentPresenter = cp;
            cp.Measure(_availableSize);            
            ++_resolvedCount;
            return cp;
        }
        private void RemoveAndAddToRecycleBin(ItemTuple tuple)
        {
            ContentPresenter cp = tuple.ContentPresenter;

            switch (tuple.ItemType)
            {
                case ItemType.Item:
                    _recycledItems.Push(cp);
                    break;
                case ItemType.GroupHeader:
                    _recycledGroupHeaders.Push(cp);
                    break;
                case ItemType.GroupFooter:
                    _recycledGroupFooters.Push(cp);
                    break;
                case ItemType.ListHeader:
                    Debug.Assert(_recycledListHeader == null);
                    _recycledListHeader = cp;
                    break;
                case ItemType.ListFooter:
                    Debug.Assert(_recycledListFooter == null);
                    _recycledListFooter = cp;
                    break;
            }

            EventHandler<LinkUnlinkEventArgs> handler = Unlink;
            if (handler != null)
            {
                handler(this, new LinkUnlinkEventArgs(cp));
            }
            tuple.ContentPresenter = null;
            cp.Content = null;
            cp.SetExtraData(-1, 0);

            --_resolvedCount;
        }
Esempio n. 8
0
 public static MemberInfo CachedGetMember(Type objType, string memberName)
 {
     return(_cachedGetMember(ItemTuple.Create(objType, memberName)));
 }