コード例 #1
0
ファイル: Layer2d.cs プロジェクト: chkn/cirrus
        // FIXME: Only render dirty rects
        public void Render(BoundingRect rect)
        {
            var ctx = Surface.GetDrawingContext ();
            ApplyTransform (ctx);

            // If we were alredy rendering, stop it
            if (renderFiber != null && renderFiber.Status == FutureStatus.Pending)
                renderFiber.Cancel ();

            renderFiber = Render (rect, ctx);

            // Render children last
            //foreach (var child in Children) {
            //	child.Render (rect.GetIntersection (child.Bounds));
            //}
        }
コード例 #2
0
ファイル: Layer2d.cs プロジェクト: chkn/cirrus
        /// <summary>
        /// Contains the rendering logic for this Layer2d.
        /// </summary>
        /// <remarks>
        /// The rendering logic in a Layer2d can be defined either by setting the <see cref="P:Renderer"/> property,
        ///  or by overriding this method in a subclass.
        /// In either case, the rendering routine may be a fiber that continues rendering, possibly in an infinite loop (i.e for animation),
        ///  or it can be a one-off draw something and return routine. If the first case is desired, it is recommended that
        ///  it be implemented as an asynchronous method that is processed by the postcompiler. At the least, a Future that supports cancellation
        ///  must be returned if the method does not complete synchronously.
        /// For an explanation, take an animation that continues in an indefinite loop, delaying for a certain period between iterations.
        ///  If another layer is placed atop the animation layer, and then moved, exposing a previously unexposed region of the animation layer,
        ///  that region needs to be drawn expeditiously. To accomplish that, the view system will cancel the animation's Future (as returned by
        ///  a previous invocation of this method), and immediately invoke this method again. Thus, any state needed to correctly render the layer
        ///  must not be stored in locals of an asynchronous method.
        /// </remarks>
        /// <param name='rect'>
        /// The BoundingRect into which rendering is required.
        /// </param>
        /// <param name='ctx'>
        /// The ISurface2d into which rendering is required.
        /// </param>
        protected virtual Future Render(BoundingRect rect, IContext2d ctx)
        {
            if (Renderer != null)
                return Renderer (this, rect, ctx);

            return Future.Fulfilled;
        }
コード例 #3
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
        /**
         * Splits the rect argument into the area that overlaps this rect (this is
         * the return value) and an array of areas that do not overlap (this is the
         * remainderRects argument, which must be passed as an empty array).
         * @param rect The rectangle to intersect with this.
         * @param remainderRects An empty array that will be populated with the areas
         * of the rect parameter that do not intersect with this rect.
         * @return The intersection of this rectangle and the rect argument.
         */
        public BoundingRect SplitIntersection(BoundingRect rect, out List<BoundingRect> remainder)
        {
            remainder = new List<BoundingRect> ();
            if (!this.Intersects (rect)) {
                remainder.Add (rect);
                return null;
            }

            // Copy the properties of rect into intersection; we trim this to size later
            var intersection = rect;

            // Check for a non-overlapped rect on the left
            if (intersection.X < this.X) {
                    var left = new BoundingRect {
                        X = intersection.X,
                        Y = intersection.Y,
                        Width = this.X - intersection.X,
                        Height = intersection.Height
                    };

                    // Insert the rect
                    remainder.Add (left);

                    // Adjust the dimensions of the intersection
                    intersection.X = this.X;
                    intersection.Width -= left.Width;
            }

            // Check for a non-overlapped rect on the right
            if (intersection.X + intersection.Width > this.X + this.Width) {
                    var right = new BoundingRect {
                        X = this.X + this.Width,
                        Y = intersection.Y,
                        Width = intersection.Width - (this.X + this.Width - intersection.X),
                        Height = intersection.Height
                    };

                    // Insert the rect
                    remainder.Add (right);

                    // Adjust dimensions of the intersection
                    intersection.Width -= right.Width;
            }

            // Check for a non-overlapped rect above
            if (intersection.Y < this.Y) {
                    var top = new BoundingRect {
                        X = intersection.X,
                        Y = intersection.Y,
                        Width = intersection.Width,
                        Height = this.Y - intersection.Y
                    };

                    // Insert the rect
                    remainder.Add (top);

                    // Adjust the dimensions of the intersection
                    intersection.Y = this.Y;
                    intersection.Height -= top.Height;
            }

            // Check for a non-overlapped rect below
            if (intersection.Y + intersection.Height > this.Y + this.Height) {
                    var bottom = new BoundingRect {
                        X = intersection.X,
                        Y = this.Y + this.Height,
                        Width = intersection.Width,
                        Height = intersection.Height - (this.Y + this.Height - intersection.Y)
                    };

                    // Insert the rect
                    remainder.Add (bottom);

                    // Adjust dimensions of the intersection
                    intersection.Height -= bottom.Height;
            }

            return intersection;
        }
コード例 #4
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
 void ChangeBounds(BoundingRect old, double unused)
 {
     Change.Fire (new BoundsChange (old, this));
 }
コード例 #5
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
 public bool SamePosition(BoundingRect rect)
 {
     return this.X == rect.X &&
            this.Y == rect.Y;
 }
コード例 #6
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
 public bool SameSize(BoundingRect rect)
 {
     return this.Width == rect.Width &&
            this.Height == rect.Height;
 }
コード例 #7
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
        /**
         * Gets the intersect of this rectangle with the supplied argument.
         * @param rect The rectangle to intersect with this.
         * @return A rectangle that represents the intersection of the two rectangles.
         */
        public BoundingRect GetIntersection(BoundingRect rect)
        {
            return new BoundingRect {
                X = this.X > rect.X ? this.X : rect.X,
                Y = this.Y > rect.Y ? this.Y : rect.Y,

                X2 = this.X2 < rect.X2 ? this.X2 : rect.X2,
                Y2 = this.Y2 < rect.Y2 ? this.Y2 : rect.Y2
            };
        }
コード例 #8
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
 /**
  * Check if this rectangle intersects the argument.
  * @param rect The rect to check for an intersection.
  * @return True if the rects intersect.
  */
 public bool Intersects(BoundingRect rect)
 {
     return ((this.X + this.Width > rect.X) &&
             (this.Y + this.Height > rect.Y) &&
             (this.X < rect.X + rect.Width) &&
             (this.Y < rect.Y + rect.Height));
 }
コード例 #9
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
        /**
         * Gets the smallest rectangle capable of containing this rect and the supplied
         * argument.
         * @param rect The rectangle to add to this.
         * @return The smallest rectangle that can contain this rect and the argument.
         */
        public BoundingRect GetAddition(BoundingRect rect)
        {
            return new BoundingRect {
                X = this.X < rect.X ? this.X : rect.X,
                Y = this.Y < rect.Y ? this.Y : rect.Y,

                X2 = this.X2 > rect.X2 ? this.X2 : rect.X2,
                Y2 = this.Y2 > rect.Y2 ? this.Y2 : rect.Y2
            };
        }
コード例 #10
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
        /**
         * Increases the size of the rect to encompass the supplied argument.
         * @param rect The rect to encompass.
         */
        public void ExpandToInclude(BoundingRect rect)
        {
            var addition = GetAddition (rect);

            this.X = addition.X;
            this.Y = addition.Y;
            this.Width = addition.Width;
            this.Height = addition.Height;
        }
コード例 #11
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
 public bool Equals(BoundingRect rect)
 {
     return this.X == rect.X &&
            this.Y == rect.Y &&
            this.Width == rect.Width &&
            this.Height == rect.Height;
 }
コード例 #12
0
ファイル: BoundingRect.cs プロジェクト: chkn/cirrus
        /**
         * Clips this rectangle to the intersection with the supplied argument.
         * @param rect The rectangle to clip to.
         */
        public void ClipToIntersection(BoundingRect rect)
        {
            var intersect = GetIntersection (rect);

            this.X = intersect.X;
            this.Y = intersect.Y;
            this.Width = intersect.Width;
            this.Height = intersect.Height;
        }
コード例 #13
0
ファイル: VisualEvents.cs プロジェクト: chkn/cirrus
 public BoundsChange(BoundingRect old, BoundingRect current)
 {
     OldBounds = old;
     Bounds = current;
 }