CGContextRef context = UIGraphicsGetCurrentContext();

-(id) initWithCoder:(NSCoder*)sourceCoder
{
    if( ( self = [super initWithCoder:sourceCoder]))
    {
        //place any other initialization  here
    }
    return self;
}

// Only override drawRect: if you perform custom drawing.
// An empty implementation adversely affects performance during animation.
- (void)drawRect:(CGRect)rect {
    UIColor* currentColor = [UIColor redColor];
    CGContextRef    context = UIGraphicsGetCurrentContext();
    
    //Set the width of the "pen" that will be used for drawing
    CGContextSetLineWidth(context,4);
    //Set the color of the pen to be used
    CGContextSetStrokeColorWithColor(context, currentColor.CGColor);
    
    //Move the pen to the upper left hand corner
    CGContextMoveToPoint(context, 0, 0);
    //and draw a line to position 100,100 (down and to the right)
    CGContextAddLineToPoint(context, 100, 100);
    //Apply our stroke settings to the line.
    CGContextStrokePath(context);
    
    [currentColor release]; 
}

#import <uikit/uikit.h>

@interface MyDrawingView : UIView {
    CGPoint fromPoint;
    CGPoint toPoint;
    UIColor* currentColor;
}

@property CGPoint fromPoint;
@property CGPoint toPoint;
@property UIColor* currentColor;

@end

#import "MyDrawingView.h"

@implementation MyDrawingView

@synthesize fromPoint;
@synthesize toPoint;
@synthesize currentColor;

- (void) touchesBegan:(NSSet*)touches withEvent:(UIEvent*)event
{
    UITouch* touchPoint = [touches anyObject]; 
    fromPoint = [touchPoint locationInView:self];
    toPoint = [touchPoint locationInView:self];
    
    [self setNeedsDisplay];
}

-(void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch* touch = [touches anyObject];
    toPoint=[touch locationInView:self];
    [self setNeedsDisplay];
}

-(void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch* touch = [touches anyObject];
    toPoint = [touch locationInView:self];
    [self setNeedsDisplay];
}

- (void)drawRect:(CGRect)rect {
    CGContextRef    context = UIGraphicsGetCurrentContext();
    
    CGContextSetLineWidth(context,4);
    CGContextSetStrokeColorWithColor(context, currentColor.CGColor);
    
    
    CGContextMoveToPoint(context,fromPoint.x , fromPoint.y);
    CGContextAddLineToPoint(context, toPoint.x, toPoint.y);
    CGContextStrokePath(context);
}

CGPoint drawingTargetPoint = CGPointMake(0,0);
[backgroundImage drawAtPoint:drawingTargetPoint];

//Gradient related variables
CGGradientRef myGradient;
CGColorSpaceRef myColorSpace;
size_t locationCount = 3;
CGFloat locationList[] = {0.0, 0.5, 1.0};
CGFloat colorList[] = {
    1.0, 0.0, 0.5, 1.0, //red, green, blue, alpha 
    1.0, 0.0, 1.0, 1.0, 
    0.3, 0.5, 1.0, 1.0
};
myColorSpace = CGColorSpaceCreateDeviceRGB();
// CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
myGradient = CGGradientCreateWithColorComponents(myColorSpace, colorList, 
             locationList, locationCount);

//Paint a linear gradient
CGPoint startPoint, endPoint;
startPoint.x = 0;
startPoint.y = 0;
endPoint.x = CGRectGetMaxX(self.bounds)/2;
endPoint.y = CGRectGetMaxY(self.bounds)/2;
    
CGContextDrawLinearGradient(context, myGradient, startPoint, endPoint,0);

//Radia Gradient Rendering
float startRadius = 20;
float endRadius = 210;
CGContextDrawRadialGradient(context, myGradient, startRadius, 
                            startPoint, endRadius, endPoint, 0);

static void myCGFunction ( void * info, const float *in, float * outValue)
{
    int componentCount = (int)info;
    float phaseDelta = 2*3.1415963/(componentCount-1);
    outValue[componentCount-1] = 1;            //Set the alpha value to 1
    for(int n=0;n<componentCount-1;++n)
    {
        outValue[n] = sin(phaseDelta*n+3.0*(*in));
    }
}

static const float inputRange[] = {0,1};
static const float outputRange[] = {0,1,  0,1,  0,1,  0,1  };
static const  CGFunctionCallbacks callback = { 0, &myCGFunction, NULL};

// The total number of components needed is going to be one greater than 
// the number of components in the selected color space.
int colorComponentCount = 1 + CGColorSpaceGetNumberOfComponents(myColorspace);

CGFunctionRef myFunctionRef =
  //I'm passing the number of components as the option value  
  CGFunctionCreate((void*)colorComponentCount,
  1,//The callback function takes one value for its input
  inputRange, //The range of the values for 
  colorComponentCount, 
  outputRange, 
  &callback
);

CGShadingRef myShading = CGShadingCreateAxial(myColorSpace, 
             startPoint, endPoint, myFunctionRef, false, false);
CGContextDrawShading(context, myShading);

typedef void (*CGPatternDrawPatternCallback) (
                void *info, 
                CGContextRef context
            );

void SetPatternColorSpace(CGContextRef context)
{
    CGColorSpaceRef myColorSpace = CGContextSetFillColorSpace(NULL);
    CGContextSetFillColorSpace(context, myColorSpace);
    CGColorSpaceRelease(myColorSpace);
}

CGPatternRef CGPatternCreate (  void *info,
                                CGRect bounds,
                                CGAffineTransform matrix,
                                float xStep,
                                float yStep,
                                CGPatternTiling tiling,
                                int isColored,
                                const CGPatternCallbacks *callbacks );

struct CGPatternCallbacks
{
    unsigned int version;
    CGPatternDrawPatternCallback drawPattern;
    CGPatternReleaseInfoCallback releaseInfo;
};

svoid MyPatternFunction(void* info, CGContextRef context)
{
    CGRect* patternBoundaries = (CGRect*)info;
    float myFillColor[] = {1,0,0,1}; //red;
    
    CGContextSaveGState(context);

    CGContextSetRGBFillColor(context, 0,1,1,1);
    CGContextFillRect(context, *patternBoundaries);
    CGContextSetFillColor(context, myFillColor);
    CGContextFillEllipseInRect(context, *patternBoundaries);

    CGContextFillPath(context);
    CGContextRestoreGState(context);
}

//Forward declaration for top of implementation file. May not be necessary
//depending on where in your file that you past these functions
void MyPatternFunction(void* info, CGContextRef context);
void PaintMyPattern(CGContextRef context, CGRect targetRect);
void SetPatternColorSpace(CGContextRef context);

//The function definitions
void PaintMyPattern(CGContextRef context, CGRect targetRect)
{
    CGPatternCallbacks callbacks = { 0, &MyPatternFunction, NULL };
    CGContextSaveGState(context);
    CGPatternRef myPattern;
    SetPatternColorSpace(context);
    
    CGRect patternRect = CGRectMake(0,0,32,32);
    myPattern = CGPatternCreate((void*)&patternRect,
                                targetRect,
                                CGAffineTransformMake(1, 0, 0, 1, 0, 0),
                                32,
                                32,
                                kCGPatternTilingConstantSpacing,
                                true,
                                &callbacks
                                );
    float alpha = 1;
    CGContextSetFillPattern(context, myPattern, &alpha);
    CGPatternRelease(myPattern);
    CGContextFillRect(context, targetRect);
    
    CGContextRestoreGState(context);
}

void SetPatternColorSpace(CGContextRef context)
{
    CGColorSpaceRef myColorSpace = CGColorSpaceCreatePattern(NULL);
    CGContextSetFillColorSpace(context, myColorSpace);
    CGColorSpaceRelease(myColorSpace);
}

void MyPatternFunction(void* info, CGContextRef context)
{
    CGRect* patternBoundaries = (CGRect*)info;
    float myFillColor[] = {1,0,0,1}; //red;
    
    CGContextSaveGState(context);

    CGContextSetRGBFillColor(context, 0,1,1,1);
    CGContextFillRect(context, *patternBoundaries);
    CGContextSetFillColor(context, myFillColor);
    CGContextFillEllipseInRect(context, *patternBoundaries);

    CGContextFillPath(context);
    CGContextRestoreGState(context);
}

-(void)updateElementPositioning
{
    float barWidth;
    float circleWidth;
    CGRect viewRect = self.bounds;
    
    barWidth = MIN(viewRect.size.width, viewRect.size.height)/4;
    circleWidth = barWidth*3;
    
    
    verticalLevelPosition.size.width=barWidth;
    verticalLevelPosition.size.height=viewRect.size.height-barWidth;
    verticalLevelPosition.origin.y=barWidth;
    verticalLevelPosition.origin.x=0;
    
    
    horizontalLevelPosition.size.height=barWidth;
    horizontalLevelPosition.size.width = viewRect.size.width;
    horizontalLevelPosition.origin.x=0;
    horizontalLevelPosition.origin.y=0;
    
    circularLevelPosition.size.width = 
    circularLevelPosition.size.height = circleWidth;
    
    circularLevelPosition.origin.x = 
        verticalLevelPosition.size.width+verticalLevelPosition.origin.x+
        ((viewRect.size.width - verticalLevelPosition.size.width-circleWidth)/2);
    circularLevelPosition.origin.y = 
        horizontalLevelPosition.size.height+horizontalLevelPosition.origin.y+
        ((viewRect.size.height-horizontalLevelPosition.size.height-circleWidth)/2);
}

-(void)drawRect:(CGRect)rect
{
    float verticalRectColor[] = {1,0,0,1};
    float horizontalRectColor[] = {0,1,0,1};
    float circularRectColor[] = {0,0,1,1};
    
    
    CGContextRef context = UIGraphicsGetCurrentContext();
    
    CGContextSetFillColor(context,verticalRectColor );
    CGContextFillRect(context, verticalLevelPosition);
    CGContextSetFillColor(context, horizontalRectColor);
    CGContextFillRect(context, horizontalLevelPosition);
    CGContextSetFillColor(context, circularRectColor);
    CGContextFillRect(context, circularLevelPosition);
}

-(void) drawCircularLevel:(CGContextRef)context :(CGRect)rect :(float) circleMargin
{
    CGRect    outerCircle;
    CGRect middleCircle;
    CGRect    innerCircle;

    
    float innerCircleColor[] = {1,0,0,0.7};
    float middleCircleColor[] = {0, 1, 0, 0.7};
    float outerCircleColor[] = {0, 0, 1, 0.7};
    
    
    const float middleCircleFactor = 0.95;
    const float innerCircleFactor = 0.90;
    
    //calculate the rectangle binding the outer circle.
    outerCircle = rect;
    outerCircle.origin.x+=(outerCircle.size.width*circleMargin)/2;
    outerCircle.origin.y+=(outerCircle.size.height*circleMargin)/2;
    outerCircle.size.width*=(1-circleMargin);
    outerCircle.size.height*=(1-circleMargin);
    
    //calculate the rectangle binding the midle circle
    middleCircle = outerCircle;
    middleCircle.origin.x+=(outerCircle.size.width*(1-middleCircleFactor)/2);
    middleCircle.origin.y+=(outerCircle.size.height*(1-middleCircleFactor)/2);
    middleCircle.size.width=outerCircle.size.width*middleCircleFactor;
    middleCircle.size.height=outerCircle.size.height*middleCircleFactor;
    
    innerCircle = outerCircle;
    innerCircle.origin.x+=(innerCircle.size.width*(1-innerCircleFactor)/2);
    innerCircle.origin.y+=(innerCircle.size.height*(1-innerCircleFactor)/2);
    innerCircle.size.width*=innerCircleFactor;
    innerCircle.size.height*=innerCircleFactor;
    
    CGContextSetFillColor(context, outerCircleColor);
    CGContextFillEllipseInRect(context, outerCircle);
    
    CGContextSetFillColor(context, middleCircleColor);
    CGContextFillEllipseInRect(context, middleCircle);
    
    CGContextSetFillColor(context, innerCircleColor);
    CGContextFillEllipseInRect(context, innerCircle);
}

CGContextSaveGState(context);
CGContextBeginPath(context);
CGContextAddRect(context, targetRect);
CGContextClip(context);

CGContextSetFillColor(context, levelBackgroundColor);
CGContextFillRect(context, targetRect);
CGContextSetFillColor(context, levelReflectionColor);
CGContextFillRect(context, reflectionRect);

CGContextDrawRadialGradient(context, shadingGradient, 
         gradientCenter1, 0, gradientCenter1, shadingRadius, 0);
CGContextDrawRadialGradient(context, shadingGradient, 
         gradientCenter2, 0, gradientCenter2, shadingRadius, 0);

-(void)accelerometer:(UIAccelerometer *)accelerometer 
             didAccelerate:(UIAcceleration *)acceleration
{
    tiltDirection = atan2(acceleration.y, acceleration.x);
    tiltMagnitude = MIN(1, sqrt( acceleration.x*acceleration.x+
                                 acceleration.y*acceleration.y));
    levelPosition.y = sin(tiltDirection)*tiltMagnitude;
    levelPosition.x = -cos(tiltDirection)*tiltMagnitude;
    [self setNeedsDisplay];
}