I’ve written previously on How to Suspend / Ignore Touch Events, which is as simple as:

// Begin ignoring events
[[UIApplicationsharedApplication] beginIgnoringInteractionEvents];
 
// Stop ignoring events
[[UIApplicationsharedApplication] endIgnoringInteractionEvents];

The problem with the above is that depending on when and where you make these calls, you can end up with the lines sprinkled about inside your code, which can make it troublesome to match one call with the other.

For example, if I make a call to begin ignoring events, and then move to a new view in which I then make a request to stop ignoring events, I now have the begin ignorning call in a different class from the end ignorning call. A big deal? Definitely not, however, when you see one call without the other, it can be both hard to know if you have a matching set, not to mention the questions that may arise when you revisit your code a few months down the road.

I get around this by writing a very simple set of methods for stopping and stopping the ignore events process. Here’s how this looks:

Interface Definition for SomeClass

@interface SomeClass : NSObject 
{
  ...
}
 
+ (void)enableEvents;
+ (void)startIgnoringEvents;
+ (void)stopIgnoringEventsAfter:(int)seconds;

Notice that the three methods shown are class methods. The implementation for SomeClass follows:

Implementation for SomeClass

@implementation SomeClass
 
...
 
+ (void)enableEvents
{
  [[UIApplication sharedApplication] endIgnoringInteractionEvents];
}
 
+ (void)startIgnoringEvents
{
  [[UIApplication sharedApplication] beginIgnoringInteractionEvents];
}
 
+ (void)stopIgnoringEventsAfter:(int)seconds
{
  [self performSelector:@selector(enableEvents) withObject:nil afterDelay:seconds];
}
 
@end

How to Start and Stop Ingoring Events

Now that I have these helper methods, I can keep all references to start and stop ignoring of events in one place, here’s how this might look:

// Stop events momentarily...
[SomeClass startIgnoringEvents];    
 
// This is the activity I don't want interrupted
[dropDownViewController showMsg];
 
// Stop ignoring events
[ShoppingListViewController stopIgnoringEventsAfter:2];

Again, these extra steps are not required, however, keeping related code together can be a good thing.

Start by creating a variable of type NSTimeInterval to hold the time the touch event began.

// Define this as an instance variable
NSTimeInterval touchStartTime;
 
-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event;
{
  // When the touch event was detected
  touchStartTime = [event timestamp];
}

Inside the touchesBegan event, with some simple math, one can determine how long from the start event to the end.

-(void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event;
{
  // Calculate how long touch lasted
  NSTimeInterval touchTimeDuration = [event timestamp] - touchStartTime;
 
  NSLog(@"Touch duration: %3.2f seconds", touchTimeDuration);
}

[[UIApplication sharedApplication] beginIgnoringInteractionEvents];

Turning event interaction back on is as follows:

[[UIApplication sharedApplication] endIgnoringInteractionEvents];

The following example shows one approach, the workhorse is CGRectContainsPoint.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/*---------------------------------------------------------------------------
* Touches began
*--------------------------------------------------------------------------*/
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event 
{
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Get the specific point that was touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  // See if the point touched is within these rectangular bounds
  if (CGRectContainsPoint(CGRectMake(5, 5, 40, 130), point))
  {
    do something...
  } 
}

I use CGRectMake to define the bounds of the rectangle and pass in the variable point that was obtained from the touch location.

As with CGRectContainsPoint, CGRectMake is a C function, which is defined as follows:

CGRect CGRectMake(CGFloat x, CGFloat y, CGFloat width, GFloat height);

The C structures you’ll need to put all the pieces together, are shown below:

struct CGRect 
{
   CGPoint origin;
   CGSize size;
};
 
struct CGPoint 
{
   CGFloat x;
   CGFloat y;
};
 
struct CGSize 
{
   CGFloat width;
   CGFloat height;
};

CGFloat is nothing more than a floating point number that is defined as a typedef, based on the system architecture. In other words, it’s just a float.

For more information about CGRect, CGSize and CGPoint, you can read this post.