Esempio n. 1
0
 /// <summary>
 /// Indicates whether a rectangle contains a specified point.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <param name="point">The point to examine.</param>
 /// <returns>Returns 1 if the specified point is located within the specified rectangle; otherwise, 0.</returns>
 /// <remarks>Original declaration is : int CGRectContainsPoint ( CGRect rect, CGPoint point );</remarks>
 public static int CGRectContainsPoint(CGRect rect, CGPoint point)
 {
     return ((point.x >= CGRectGetMinX(rect)) &&
             (point.x < CGRectGetMaxX(rect)) &&
             (point.y >= CGRectGetMinY(rect)) &&
             (point.y < CGRectGetMaxY(rect))) ? 1 : 0;
 }
Esempio n. 2
0
 /// <summary>
 /// Indicates whether the first rectangle contains the second rectangle.
 /// </summary>
 /// <param name="rect1">The rectangle to examine for containment of the rectangle passed in rect2.</param>
 /// <param name="rect2">The rectangle to examine for being contained in the rectangle passed in rect1.</param>
 /// <returns>Returns 1 if the rectangle specified by rect2 is contained in the rectangle passed in rect1; otherwise, 0. The first rectangle contains the second if the union of the two rectangles is equal to the first rectangle.</returns>
 /// <remarks>Original declaration is : int CGRectContainsRect ( CGRect rect1, CGRect rect2 );</remarks>
 public static int CGRectContainsRect(CGRect rect1, CGRect rect2)
 {
     return ((CGRectIsEmpty(rect2) == 0) &&
             (CGRectGetMinX(rect1) <= CGRectGetMinX((rect2))) &&
             (CGRectGetMinY(rect1) <= CGRectGetMinY((rect2))) &&
             (CGRectGetMaxX(rect1) >= CGRectGetMaxX((rect2))) &&
             (CGRectGetMaxY(rect1) >= CGRectGetMaxY((rect2)))) ? 1 : 0;
 }
Esempio n. 3
0
        // Applies the transformations specified in the ImageInfo struct without drawing the actual image
        public static void IIApplyTransformation(ref ImageInfo image, IntPtr context, CGRect bounds)
        {
            if (context != IntPtr.Zero)
            {
                // Whenever you do multiple CTM changes, you have to be very careful with order.
                // Changing the order of your CTM changes changes the outcome of the drawing operation.
                // For example, if you scale a context by 2.0 along the x-axis, and then translate
                // the context by 10.0 along the x-axis, then you will see your drawing will be
                // in a different position than if you had done the operations in the opposite order.

                // Our intent with this operation is that we want to change the location from which we start drawing
                // (translation), then rotate our axies so that our image appears at an angle (rotation), and finally
                // scale our axies so that our image has a different size (scale).
                // Changing the order of operations will markedly change the results.
                IITranslateContext(ref image, context);
                IIRotateContext(ref image, context, bounds);
                IIScaleContext(ref image, context, bounds);
            }
        }
Esempio n. 4
0
        // Draw the image to the given context centered inside the given bounds
        public static void IIDrawImage(ref ImageInfo image, IntPtr context, CGRect bounds)
        {
            CGRect imageRect;

            // Setup the image size so that the image fills it's natural boudaries in the base coordinate system.
            imageRect.size.width = (uint) CGImage.GetWidth(image.fImageRef);
            imageRect.size.height = (uint) CGImage.GetHeight(image.fImageRef);

            // Determine the correct origin of the image such that it is centered in the coordinate system.
            // The exact calculations depends on the image orientation, but the basic idea
            // is that the image is located such that it is positioned so that half the difference
            // between the image's size and the bounds to be drawn is used as it's x/y location.
            if ((image.fProperties == null) || (IIGetImageOrientation(ref image) < 5))
            {
                // For orientations 1-4, the images are unrotated, so the width and height of the base image
                // can be used as the width and height of the coordinate translation calculation.
                imageRect.origin.x = (float) Math.Floor((bounds.size.width - imageRect.size.width)/2.0f);
                imageRect.origin.y = (float) Math.Floor((bounds.size.height - imageRect.size.height)/2.0f);
            }
            else
            {
                // For orientations 5-8, the images are rotated 90 or -90 degrees, so we need to use
                // the image width in place of the height and vice versa.
                imageRect.origin.x = (float) Math.Floor((bounds.size.width - imageRect.size.height)/2.0f);
                imageRect.origin.y = (float) Math.Floor((bounds.size.height - imageRect.size.width)/2.0f);
            }

            // Obtain the orientation matrix for this image
            CGAffineTransform ctm = image.fOrientation;

            // Finally, orient the context so that the image draws naturally.
            CGContext.ConcatCTM(context, ctm);

            // And draw the image.
            CGContext.DrawImage(context, imageRect, image.fImageRef);
        }
Esempio n. 5
0
        /// <summary>
        /// Returns the smallest rectangle that contains two other specified rectangles.
        /// </summary>
        /// <param name="r1">The first source rectangle.</param>
        /// <param name="r2">The second source rectangle.</param>
        /// <returns>The smallest rectangle that completely contains both of the source rectangles.</returns>
        /// <remarks>Original declaration is : CGRect CGRectUnion ( CGRect r1, CGRect r2 );</remarks>
        public static CGRect CGRectUnion(CGRect r1, CGRect r2)
        {
            if ((CGRectIsEmpty(r1) == 1) && (CGRectIsEmpty(r2) == 2))
            {
                return CGRectZero;
            }
            else if (CGRectIsEmpty(r1) == 1)
            {
                return r2;
            }
            else if (CGRectIsEmpty(r2) == 1)
            {
                return r1;
            }

            CGRect result = CGRectMake(Math.Min(CGRectGetMinX(r1), CGRectGetMinX(r2)),
                                       Math.Min(CGRectGetMinY(r1), CGRectGetMinY(r2)),
                                       Math.Max(CGRectGetMaxX(r1), CGRectGetMaxX(r2)),
                                       Math.Max(CGRectGetMaxY(r1), CGRectGetMaxY(r2)));
            return result;
        }
Esempio n. 6
0
        /// <summary>
        /// Returns the intersection of two rectangles.
        /// </summary>
        /// <param name="rect1">The first source rectangle.</param>
        /// <param name="rect2">The second source rectangle.</param>
        /// <returns>A rectangle that is the intersection of the two specified rectangles. If the two rectangles do not intersect, returns the null rectangle. To check for this condition, use CGRectIsNull.</returns>
        /// <remarks>Original declaration is : CGRect CGRectIntersection ( CGRect rect1, CGRect rect2 );</remarks>
        public static CGRect CGRectIntersection(CGRect rect1, CGRect rect2)
        {
            if (((CGRectGetMaxX(rect1) <= CGRectGetMinX(rect2)) || (CGRectGetMaxX(rect2) <= CGRectGetMinX(rect1))) ||
                ((CGRectGetMaxY(rect1) <= CGRectGetMinY(rect2)) || (CGRectGetMaxY(rect2) <= CGRectGetMinY(rect1))))
            {
                return CGRectZero;
            }

            CGRect result = new CGRect();

            result.origin.x = (CGRectGetMinX(rect1) <= CGRectGetMinX(rect2)) ? CGRectGetMinX(rect2) : CGRectGetMinX(rect1);
            result.origin.y = (CGRectGetMinY(rect1) <= CGRectGetMinY(rect2)) ? CGRectGetMinY(rect2) : CGRectGetMinY(rect1);

            result.size.width = (CGRectGetMaxX(rect1) >= CGRectGetMaxX(rect2)) ? (CGRectGetMaxX(rect2) - result.origin.x) : (CGRectGetMaxX(rect1) - result.origin.x);
            result.size.height = (CGRectGetMaxY(rect1) >= CGRectGetMaxY(rect2)) ? (CGRectGetMaxY(rect2) - result.origin.y) : (CGRectGetMaxY(rect1) - result.origin.y);

            return result;
        }
Esempio n. 7
0
 /// <summary>
 /// Returns the x-axis coordinate that establishes the right edge of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The x-coordinate of the top-right corner of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetMaxX ( CGRect rect );</remarks>
 public static float CGRectGetMaxX(CGRect rect)
 {
     return rect.origin.x + rect.size.width;
 }
Esempio n. 8
0
 /// <summary>
 /// Returns a rectangle with a positive width and height.
 /// </summary>
 /// <param name="rect">The source rectangle.</param>
 /// <returns>Returns a rectangle, equivalent to the source rectangle, with a positive width and height.</returns>
 /// <remarks>Original declaration is : CGRect CGRectStandardize ( CGRect rect );</remarks>
 public static CGRect CGRectStandardize(CGRect rect)
 {
     bool horiz = (rect.size.width > 0);
     bool vert = (rect.size.height > 0);
     float w = horiz ? rect.size.width : -rect.size.width;
     float h = horiz ? rect.size.height : -rect.size.height;
     float x = horiz ? rect.origin.x : rect.origin.x - w;
     float y = vert ? rect.origin.y : rect.origin.y - h;
     return CGRectMake(x, y, w, h);
 }
Esempio n. 9
0
 /// <summary>
 /// Returns the height of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The height of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetHeight ( CGRect rect );</remarks>
 public static float CGRectGetHeight(CGRect rect)
 {
     return rect.size.height;
 }
Esempio n. 10
0
        /// <summary>
        /// Returns a rectangle with an origin offset from that of the source rectangle.
        /// </summary>
        /// <param name="rect">The source rectangle.</param>
        /// <param name="dx">The value by which to move the x-coordinate of the source rectangle's origin.</param>
        /// <param name="dy">The value by which to move the y-coordinate of the source rectangle's origin.</param>
        /// <returns>A rectangle with the same size as the source, but with its origin offset by dx units along the x-axis and dy units along the y-axis with respect to the source.</returns>
        /// <remarks>Original declaration is : CGRect CGRectOffset ( CGRect rect, float dx, float dy );</remarks>
		public static CGRect CGRectOffset(CGRect rect, CGFloat dx, CGFloat dy)
        {
            return CGRectMake(rect.origin.x + dx,
                              rect.origin.y + dy,
                              rect.size.width,
                              rect.size.height);
        }
Esempio n. 11
0
 /// <summary>
 /// Returns the y-axis coordinate that establishes the top edge of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The y-coordinate of the top-right corner of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetMaxY ( CGRect rect );</remarks>
 public static float CGRectGetMaxY(CGRect rect)
 {
     return rect.origin.y + rect.size.height;
 }
Esempio n. 12
0
        // Scale the context around the center point of the given bounds
        public static void IIScaleContext(ref ImageInfo image, IntPtr context, CGRect bounds)
        {
            // First we translate the context such that the 0,0 location is at the center of the bounds
            CGContext.TranslateCTM(context, bounds.size.width/2.0f, bounds.size.height/2.0f);

            // Next we scale the context to the size that we want
            CGContext.ScaleCTM(context, image.fScaleX, image.fScaleY);

            // Finally we have to restore the center position
            CGContext.TranslateCTM(context, -bounds.size.width/2.0f, -bounds.size.height/2.0f);
        }
Esempio n. 13
0
        /// <summary>
        /// Divides a source rectangle into two component rectangles.
        /// </summary>
        /// <param name="rect">The source rectangle.</param>
        /// <param name="slice">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.</param>
        /// <param name="remainder">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.</param>
        /// <param name="amount">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.</param>
        /// <param name="edge">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.</param>
        /// <returns>Returns 1 if the two specified rectangles have equal size and origin values, or are both null. Otherwise, returns 0.</returns>
        /// <remarks>Original declaration is : void CGRectDivide ( CGRect rect, CGRect *slice, CGRect *remainder, float amount, CGRectEdge edge );</remarks>
		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");
            }
        }
Esempio n. 14
0
		public static NSRect NSRectFromCGRect(CGRect cgrect)
		{
			return NSMakeRect(cgrect.origin.x, cgrect.origin.y, cgrect.size.width, cgrect.size.height);
		}
Esempio n. 15
0
 /// <summary>
 /// Returns a rectangle with integer values for its origin and size.
 /// </summary>
 /// <param name="rect">The source rectangle.</param>
 /// <returns>The rectangle with smallest integer values for its origin and size that contains the source rectangle. That is, given a rectangle with fractional origin or size values, CGRectIntegral rounds the rectangle's origin downward and its size upward to the nearest whole integers, such that the result contains the original rectangle.</returns>
 /// <remarks>Original declaration is : CGRect CGRectIntegral ( CGRect rect );</remarks>
 public static CGRect CGRectIntegral(CGRect rect)
 {
     CGRect result = new CGRect();
     result.origin.x = (float)Math.Floor(rect.origin.x);
     result.origin.y = (float)Math.Floor(rect.origin.y);
     result.size.width = (float)Math.Ceiling(rect.origin.x + rect.size.width) - result.origin.x;
     result.size.height = (float)Math.Ceiling(rect.origin.y + rect.size.height) - result.origin.y;
     return result;
 }
Esempio n. 16
0
 /// <summary>
 /// Returns the width of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The width of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetWidth ( CGRect rect );</remarks>
 public static float CGRectGetWidth(CGRect rect)
 {
     return rect.size.width;
 }
Esempio n. 17
0
 /// <summary>
 /// Returns the y-axis coordinate that establishes the bottom edge of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The y-coordinate of the bottom-left corner of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetMinY ( CGRect rect );</remarks>
 public static float CGRectGetMinY(CGRect rect)
 {
     return rect.origin.y;
 }
Esempio n. 18
0
 /// <summary>
 /// Returns the y-axis coordinate that establishes the center of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The y-coordinate of the center of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetMidY ( CGRect rect );</remarks>
 public static float CGRectGetMidY(CGRect rect)
 {
     return rect.origin.y + (rect.size.height/2.0f);
 }
Esempio n. 19
0
 /// <summary>
 /// Returns the x-axis coordinate that establishes the center of a rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>The x-coordinate of the center of the specified rectangle.</returns>
 /// <remarks>Original declaration is : float CGRectGetMidX ( CGRect rect );</remarks>
 public static float CGRectGetMidX(CGRect rect)
 {
     return rect.origin.x + (rect.size.width/2.0f);
 }
		/// <summary>
		/// <para>Applies an affine transform to a rectangle.</para>
		/// <para>Original signature is : CGRect CGRectApplyAffineTransform ( CGRect rect, CGAffineTransform t );</para>
		/// <para>Available in Mac OS X v10.4 and later.</para>
		/// </summary>
		/// <param name="rect">The rectangle whose corner points you want to transform.</param>
		/// <param name="t">The affine transform to apply to the rect parameter.</param>
		/// <returns>The transformed rectangle.</returns>
		public static CGRect CGRectApplyAffineTransform (CGRect rect, CGAffineTransform t)
		{
			// TODO : To implement
			throw new NotImplementedException ();
		}
Esempio n. 21
0
 /// <summary>
 /// Indicates whether two rectangles intersect.
 /// </summary>
 /// <param name="rect1">The first rectangle to examine.</param>
 /// <param name="rect2">The second rectangle to examine.</param>
 /// <returns>Returns 1 if the two specified rectangles intersect; otherwise, 0. The first rectangle intersects the second if the intersection of the rectangles is not equal to the null rectangle.</returns>
 /// <remarks>Original declaration is : int CGRectIntersectsRect ( CGRect rect1, CGRect rect2 );</remarks>
 public static int CGRectIntersectsRect(CGRect rect1, CGRect rect2)
 {
     return (((CGRectGetMaxX(rect1) <= CGRectGetMinX(rect2)) || (CGRectGetMaxX(rect2) <= CGRectGetMinX(rect1))) ||
             ((CGRectGetMaxY(rect1) <= CGRectGetMinY(rect2)) || (CGRectGetMaxY(rect2) <= CGRectGetMinY(rect1))))
                ? 0
                : 1;
 }
Esempio n. 22
0
        // Draw the image to the given context centered inside the given bounds with
        // the transformation info. The CTM of the context is unchanged after this call
        public static void IIDrawImageTransformed(ref ImageInfo image, IntPtr context, CGRect bounds)
        {
            // We save the current graphics state so as to not disrupt it for the caller.
            CGContext.SaveGState(context);

            // Apply the transformation
            IIApplyTransformation(ref image, context, bounds);

            // Draw the image centered in the context
            IIDrawImage(ref image, context, bounds);

            // Restore our original graphics state.
            CGContext.RestoreGState(context);
        }
Esempio n. 23
0
 /// <summary>
 /// Indicates whether a rectangle has zero width or height or is a null rectangle.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>Returns 1 if the specified rectangle is empty; otherwise, 0.</returns>
 /// <remarks>Original declaration is : int CGRectIsEmpty ( CGRect rect );</remarks>
 public static int CGRectIsEmpty(CGRect rect)
 {
     return ((rect.size.width > 0) && (rect.size.height > 0)) ? 0 : 1;
 }
Esempio n. 24
0
        // Rotates the context around the center point of the given bounds
        public static void IIRotateContext(ref ImageInfo image, IntPtr context, CGRect bounds)
        {
            // First we translate the context such that the 0,0 location is at the center of the bounds
            CGContext.TranslateCTM(context, bounds.size.width/2.0f, bounds.size.height/2.0f);

            // Then we rotate the context, converting our angle from degrees to radians
            CGContext.RotateCTM(context, image.fRotation*M_PI/180.0f);

            // Finally we have to restore the center position
            CGContext.TranslateCTM(context, -bounds.size.width/2.0f, -bounds.size.height/2.0f);
        }
Esempio n. 25
0
 /// <summary>
 /// Checks whether a rectangle is infinite.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>Returns true if the specified rectangle is infinite, false otherwise.</returns>
 /// <remarks>Original declaration is : bool CGRectIsInfinite ( CGRect rect );</remarks>
 public static bool CGRectIsInfinite(CGRect rect)
 {
     return false;
 }
Esempio n. 26
0
 /// <summary>
 /// Indicates whether a rectangle is invalid.
 /// </summary>
 /// <param name="rect">The rectangle to examine.</param>
 /// <returns>Returns 1 if the specified rectangle is null; otherwise, 0.</returns>
 /// <remarks>Original declaration is : int CGRectIsNull ( CGRect rect );</remarks>
 public static int CGRectIsNull(CGRect rect)
 {
     return 0;
 }
Esempio n. 27
0
 /// <summary>
 /// Indicates whether two rectangles are equal in size and position.
 /// </summary>
 /// <param name="rect1">The first rectangle to examine.</param>
 /// <param name="rect2">The second rectangle to examine.</param>
 /// <returns>Returns 1 if the two specified rectangles have equal size and origin values, or are both null. Otherwise, returns 0.</returns>
 /// <remarks>Original declaration is : int CGRectEqualToRect ( CGRect rect1, CGRect rect2 );</remarks>
 public static int CGRectEqualToRect(CGRect rect1, CGRect rect2)
 {
     return Equals(rect1, rect2) ? 1 : 0;
 }