Monobjc.ApplicationServices.CGRect.CGRectDivide C# (CSharp) Method

CGRectDivide() public static method

Divides a source rectangle into two component rectangles.
Original declaration is : void CGRectDivide ( CGRect rect, CGRect *slice, CGRect *remainder, float amount, CGRectEdge edge );
public static CGRectDivide ( CGRect rect, CGRect &slice, CGRect &remainder, CGFloat amount, CGRectEdge edge ) : void
rect CGRect The source rectangle.
slice CGRect On input, a pointer to an uninitialized rectangle. On return, a rectangle that contains the specified edge and extends the distance beyond it specified by the amount parameter.
remainder CGRect On input, a pointer to an uninitialized rectangle. On return, the rectangle contains the portion of the source rectangle that remains after CGRectEdge produces the 'slice' rectangle.
amount CGFloat A distance from the rectangle's side that is specified in the edge parameter. This distance defines the line, parallel to the specified side, that Quartz uses to divide the source rectangle.
edge CGRectEdge A CGRectEdge value (CGRectMinXEdge, CGRectMinYEdge, CGRectMaxXEdge, or CGRectMaxYEdge) that specifies the side of the rectangle from which the distance passed in the amount parameter is measured. CGRectDivide produces a 'slice' rectangle that contains the specified edge and extends amount distance beyond it.
return void
		public static void CGRectDivide(CGRect rect, ref CGRect slice, ref CGRect remainder, CGFloat amount, CGRectEdge edge)
        {
            if (CGRectIsEmpty(rect) == 1)
            {
                slice = CGRectZero;
                remainder = CGRectZero;
            }

            switch (edge)
            {
                case CGRectEdge.CGRectMinXEdge:
                    {
                        float delta = amount;
                        if (amount > rect.size.width)
                        {
                            delta = rect.size.width;
                        }

                        slice = CGRectMake(rect.origin.x,
                                           rect.origin.y,
                                           delta,
                                           rect.size.height);
                        remainder = CGRectMake(rect.origin.x + delta,
                                               rect.origin.y,
                                               rect.size.width - delta,
                                               rect.size.height);
                    }
                    break;
                case CGRectEdge.CGRectMinYEdge:
                    {
                        float delta = amount;
                        if (amount > rect.size.height)
                        {
                            delta = rect.size.height;
                        }

                        slice = CGRectMake(rect.origin.x,
                                           rect.origin.y,
                                           rect.size.width,
                                           delta);
                        remainder = CGRectMake(rect.origin.x,
                                               rect.origin.y + delta,
                                               rect.size.width,
                                               rect.size.height - delta);
                    }
                    break;
                case CGRectEdge.CGRectMaxXEdge:
                    {
                        float delta = amount;
                        if (amount > rect.size.width)
                        {
                            delta = rect.size.width;
                        }

                        slice = CGRectMake(rect.origin.x + rect.size.width - delta,
                                           rect.origin.y,
                                           delta,
                                           rect.size.height);
                        remainder = CGRectMake(rect.origin.x,
                                               rect.origin.y,
                                               rect.size.width - delta,
                                               rect.size.height);
                    }
                    break;
                case CGRectEdge.CGRectMaxYEdge:
                    {
                        float delta = amount;
                        if (amount > rect.size.height)
                        {
                            delta = rect.size.height;
                        }

                        slice = CGRectMake(rect.origin.x,
                                           rect.origin.y + rect.size.height - delta,
                                           rect.size.width,
                                           delta);
                        remainder = CGRectMake(rect.origin.x,
                                               rect.origin.y,
                                               rect.size.width,
                                               rect.size.height - delta);
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException("edge");
            }
        }