CGGeometry.h

Go to the documentation of this file.

 
#ifndef __CGGEOMETRY__
#define __CGGEOMETRY__
 
#ifndef __CGBASE__
#include <CGBase.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if PRAGMA_ENUM_ALWAYSINT
#if defined(__fourbyteints__) && !__fourbyteints__
#define __CGGEOMETRY__RESTORE_TWOBYTEINTS
#pragma fourbyteints on
#endif
#pragma enumsalwaysint on
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =int
#elif PRAGMA_ENUM_PACK
#if __option(pack_enums)
#define __CGGEOMETRY__RESTORE_PACKED_ENUMS
#pragma options(!pack_enums)
#endif
#endif
 
  /* Points. */
  struct CGPoint
  {
    float x;
    float y;
  };
  typedef struct CGPoint CGPoint;
  /* Sizes. */
  struct CGSize
  {
    float width;
    float height;
  };
  typedef struct CGSize CGSize;
  /* Rectangles. */
  struct CGRect
  {
    CGPoint origin;
    CGSize size;
  };
  typedef struct CGRect CGRect;
  /* Rectangle edges. */
  enum CGRectEdge
  {
    CGRectMinXEdge = 0,
    CGRectMinYEdge = 1,
    CGRectMaxXEdge = 2,
    CGRectMaxYEdge = 3
  };
  typedef enum CGRectEdge CGRectEdge;
 
  /* The "zero" point -- equivalent to CGPointMake(0, 0). */
  extern const CGPoint CGPointZero;
  /* The "zero" size -- equivalent to CGSizeMake(0, 0). */
  extern const CGSize CGSizeZero;
  /* The "zero" rectangle -- equivalent to CGRectMake(0, 0, 0, 0). */
  extern const CGRect CGRectZero;
  /* The "empty" rect.  This is the rectangle returned when, for example, we
   * intersect two disjoint rectangles.  Note that the null rect is not the
   * same as the zero rect. */
  extern const CGRect CGRectNull;
 
  /* Make a point from `(x, y)'. */
  CGPoint
  CGPointMake(float x, float y);
 
  /* Make a size from `(width, height)'. */
  CGSize
  CGSizeMake(float width, float height);
 
  /* Make a rect from `(x, y; width, height)'. */
  CGRect
  CGRectMake(float x, float y, float width, float height);
 
  /* Return the leftmost x-value of `rect'. */
  float
  CGRectGetMinX(CGRect rect);
 
  /* Return the midpoint x-value of `rect'. */
  float
  CGRectGetMidX(CGRect rect);
 
  /* Return the rightmost x-value of `rect'. */
  float
  CGRectGetMaxX(CGRect rect);
 
  /* Return the bottommost y-value of `rect'. */
  float
  CGRectGetMinY(CGRect rect);
 
  /* Return the midpoint y-value of `rect'. */
  float
  CGRectGetMidY(CGRect rect);
 
  /* Return the topmost y-value of `rect'. */
  float
  CGRectGetMaxY(CGRect rect);
 
  /* Return the width of `rect'. */
  float
  CGRectGetWidth(CGRect rect);
 
  /* Return the height of `rect'. */
  float
  CGRectGetHeight(CGRect rect);
 
  /* Return 1 if `point1' and `point2' are the same, 0 otherwise. */
  int CGPointEqualToPoint(CGPoint point1, CGPoint point2);
 
  /* Return 1 if `size1' and `size2' are the same, 0 otherwise. */
  int CGSizeEqualToSize(CGSize size1, CGSize size2);
 
  /* Return 1 if `rect1' and `rect2' are the same, 0 otherwise. */
  int CGRectEqualToRect(CGRect rect1, CGRect rect2);
 
  /* Standardize `rect' -- i.e., convert it to an equivalent rect which has
   * positive width and height. */
  CGRect
  CGRectStandardize(CGRect rect);
 
  /* Return 1 if `rect' is empty -- i.e., if it has zero width or height.  A
   * null rect is defined to be empty. */
  int CGRectIsEmpty(CGRect rect);
 
  /* Return 1 if `rect' is null -- e.g., the result of intersecting two
   * disjoint rectangles is a null rect. */
  int CGRectIsNull(CGRect rect);
 
  /* Inset `rect' by `(dx, dy)' -- i.e., offset its origin by `(dx, dy)', and
   * decrease its size by `(2*dx, 2*dy)'. */
  CGRect
  CGRectInset(CGRect rect, float dx, float dy);
 
  /* Expand `rect' to the smallest rect containing it with integral origin
   * and size. */
  CGRect
  CGRectIntegral(CGRect rect);
 
  /* Return the union of `r1' and `r2'. */
  CGRect
  CGRectUnion(CGRect r1, CGRect r2);
 
  /* Return the intersection of `r1' and `r2'.  This may return a null
   * rect. */
  CGRect
  CGRectIntersection(CGRect r1, CGRect r2);
 
  /* Offset `rect' by `(dx, dy)'. */
  CGRect
  CGRectOffset(CGRect rect, float dx, float dy);
 
  /* Make two new rectangles, `slice' and `remainder', by dividing `rect'
   * with a line that's parallel to one of its sides, specified by `edge' --
   * either `CGRectMinXEdge', `CGRectMinYEdge', `CGRectMaxXEdge', or
   * `CGRectMaxYEdge'.  The size of `slice' is determined by `amount', which
   * measures the distance from the specified edge. */
  void
  CGRectDivide(CGRect rect, CGRect *slice, CGRect *remainder, float amount,
               CGRectEdge edge);
 
  /* Return 1 if `point' is contained in `rect', 0 otherwise. */
  int CGRectContainsPoint(CGRect rect, CGPoint point);
 
  /* Return 1 if `rect2' is contained in `rect1', 0 otherwise.  `rect2' is
   * contained in `rect1' if the union of `rect1' and `rect2' is equal to
   * `rect1'. */
  int CGRectContainsRect(CGRect rect1, CGRect rect2);
 
  /* Return 1 if `rect1' intersects `rect2', 0 otherwise.  `rect1' intersects
   * `rect2' if the intersection of `rect1' and `rect2' is not the null
   * rect. */
  int CGRectIntersectsRect(CGRect rect1, CGRect rect2);
 
#ifdef __MWERKS__
  CG_INLINE CGPoint __CGPointMake(float x, float y)
  {
    CGPoint p;
    p.x = x;
    p.y = y;
    return p;
  }
#define CGPointMake __CGPointMake
 
  CG_INLINE CGSize __CGSizeMake(float width, float height)
  {
    CGSize size;
    size.width = width;
    size.height = height;
    return size;
  }
#define CGSizeMake __CGSizeMake
 
  CG_INLINE CGRect __CGRectMake(float x, float y, float width, float height)
  {
    CGRect rect;
    rect.origin.x = x;
    rect.origin.y = y;
    rect.size.width = width;
    rect.size.height = height;
    return rect;
  }
#define CGRectMake __CGRectMake
#endif /* __MWERKS__ */
 
#if PRAGMA_ENUM_ALWAYSINT
#pragma enumsalwaysint reset
#ifdef __CGGEOMETRY__RESTORE_TWOBYTEINTS
#pragma fourbyteints off
#endif
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =reset
#elif defined(__CGGEOMETRY__RESTORE_PACKED_ENUMS)
#pragma options(pack_enums)
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CGGEOMETRY__ */