uisegmentedcontrol类重写，自定义按钮和背景颜色

。h文件

#import <UIKit/UIKit.h>

@interface MCSegmentedControl : UISegmentedControl {

NSMutableArray *_items;

UIFont  *_font;

UIColor *_selectedItemColor;

UIColor *_unselectedItemColor;

UIColor *_selectedItemShadowColor;

UIColor *_unselectedItemShadowColor;

CGFloat _cornerRadius;

NSArray *_unSelectedItemBackgroundGradientColors;

}

/**

 * Font for the segments with title

 * Default is sysyem bold 18points

 */

@property (nonatomic, retain) UIFont  *font;

/**

 * Color of the item in the selected segment

 * Applied to text and images

 */

@property (nonatomic, retain) UIColor *selectedItemColor;

/**

 * Color of the items not in the selected segment

 * Applied to text and images

 */

@property (nonatomic, retain) UIColor *unselectedItemColor;

/**

 * Default is black with .2 alpha

 */

@property (nonatomic, retain) UIColor *selectedItemShadowColor;

/**

 * Default is white

 */

@property (nonatomic, retain) UIColor *unselectedItemShadowColor;

@property (nonatomic, assign) CGFloat cornerRadius;

/**

 * Contains the 2 gradient components for the non-selected items

 * Default is white and gray 200/255.0

 */

@property (nonatomic, retain) NSArray *unSelectedItemBackgroundGradientColors;

@end

。m文件

#import "MCSegmentedControl.h"

#define kDefaultCornerRadius   10.0f

@interface MCSegmentedControl () {

@private

NSArray *_unSelectedItemBackgroundGradientCGColors;

}

@property (nonatomic, retain, readwrite) NSMutableArray *items;

- (BOOL)_mustCustomize;

@end

@implementation MCSegmentedControl

#pragma mark - Object life cycle

- (void)_initialize

{

self.cornerRadius = kDefaultCornerRadius;

self.selectedItemShadowColor = [UIColor colorWithWhite:0.0f alpha:.2f];

self.unselectedItemShadowColor = [UIColor whiteColor];

self.unSelectedItemBackgroundGradientColors = [NSArray arrayWithObjects:

  [UIColor colorWithRed:255/255.0 green:255/255.0 blue:255/255.0 alpha:1.0],

  [UIColor colorWithRed:200/255.0 green:200/255.0 blue:200/255.0 alpha:1.0],

  nil];

}

- (void)awakeFromNib

{

NSMutableArray *ar = [NSMutableArray arrayWithCapacity:self.numberOfSegments];

for (int i = 0; i < self.numberOfSegments; i++) {

NSString *aTitle = [self titleForSegmentAtIndex:i];

if (aTitle) {

[ar addObject:aTitle];

} else {

UIImage *anImage = [self imageForSegmentAtIndex:i];

if (anImage) {

[ar addObject:anImage];

}

}

}

self.items = ar;

[self _initialize];

[self setNeedsDisplay];

}

- (id)initWithItems:(NSArray *)array

{

self = [super initWithItems:array];

if (self) {

if (array) {

NSMutableArray *mutableArray = [array mutableCopy];

self.items = mutableArray;

[mutableArray release];

} else {

self.items = [NSMutableArray array];

}

[self _initialize];

}

return self;

}

- (void)dealloc

{

self.items               = nil;

self.font                = nil;

self.selectedItemColor   = nil;

self.unselectedItemColor = nil;

    [super dealloc];

}

- (BOOL)_mustCustomize

{

return self.segmentedControlStyle == UISegmentedControlStyleBordered

|| self.segmentedControlStyle == UISegmentedControlStylePlain;

}

#pragma mark - Custom accessors

- (UIFont *)font

{

if (_font == nil) {

self.font = [UIFont boldSystemFontOfSize:18.0f];

}

return _font;

}

- (void)setFont:(UIFont *)aFont

{

if (_font != aFont) {

[_font release];

_font = [aFont retain];

[self setNeedsDisplay];

}

}

- (UIColor *)selectedItemColor

{

if (_selectedItemColor == nil) {

self.selectedItemColor = [UIColor whiteColor];

}

return _selectedItemColor;

}

- (void)setSelectedItemColor:(UIColor *)aColor

{

if (aColor != _selectedItemColor) {

[_selectedItemColor release];

_selectedItemColor = [aColor retain];

[self setNeedsDisplay];

}

}

- (UIColor *)unselectedItemColor

{

if (_unselectedItemColor == nil) {

self.unselectedItemColor = [UIColor grayColor];

}

return _unselectedItemColor;

}

- (void)setUnselectedItemColor:(UIColor *)aColor

{

if (aColor != _unselectedItemColor) {

[_unselectedItemColor release];

_unselectedItemColor = [aColor retain];

[self setNeedsDisplay];

}

}

- (NSMutableArray *)items

{

return _items;

}

- (void)setItems:(NSMutableArray *)array

{

if (_items != array) {

[_items release];

_items = [array retain];

}

}

- (CGFloat)cornerRadius

{

return _cornerRadius;

}

- (void)setCornerRadius:(CGFloat)cornerRadius

{

if (cornerRadius != _cornerRadius) {

_cornerRadius = cornerRadius;

[self setNeedsDisplay];

}

}

- (NSArray *)unSelectedItemBackgroundGradientColors

{

return _unSelectedItemBackgroundGradientCGColors;

}

- (void)setUnSelectedItemBackgroundGradientColors:(NSArray *)array

{

if (array && [array count] != 2) {

NSLog(@"MCSegmentedControl WARNING: unSelectedItemBackgroundGradientColors must contain 2 colors");

} 

else if (array != _unSelectedItemBackgroundGradientColors) {

[_unSelectedItemBackgroundGradientColors release];

_unSelectedItemBackgroundGradientColors = [array retain];

if (_unSelectedItemBackgroundGradientColors) {

[_unSelectedItemBackgroundGradientCGColors release];

_unSelectedItemBackgroundGradientCGColors = [[NSArray alloc] initWithObjects:

(id)((UIColor *)[_unSelectedItemBackgroundGradientColors objectAtIndex:0]).CGColor, 

(id)((UIColor *)[_unSelectedItemBackgroundGradientColors objectAtIndex:1]).CGColor, 

nil];

[self setNeedsDisplay];

}

else {

[_unSelectedItemBackgroundGradientCGColors release], _unSelectedItemBackgroundGradientCGColors = nil;

}

}

}

- (UIColor *)selectedItemShadowColor

{

return _selectedItemShadowColor;

}

- (void)setSelectedItemShadowColor:(UIColor *)selectedItemShadowColor

{

if (selectedItemShadowColor != _selectedItemShadowColor) {

[_selectedItemShadowColor release];

_selectedItemShadowColor = [selectedItemShadowColor retain];

[self setNeedsDisplay];

}

}

- (UIColor *)unselectedItemShadowColor

{

return _unselectedItemShadowColor;

}

- (void)setUnselectedItemShadowColor:(UIColor *)unselectedItemShadowColor

{

if (unselectedItemShadowColor != _unselectedItemShadowColor) {

[_unselectedItemShadowColor release];

_unselectedItemShadowColor = [unselectedItemShadowColor retain];

[self setNeedsDisplay];

}

}

#pragma mark - Overridden UISegmentedControl methods

- (void)layoutSubviews

{

for (UIView *subView in self.subviews) {

[subView removeFromSuperview];

}

}

- (NSUInteger)numberOfSegments

{

if (!self.items || ![self _mustCustomize]) {

return [super numberOfSegments];

} else {

return self.items.count;

}

}

- (void)drawRect:(CGRect)rect

{

// Only the bordered and plain style are customized

if (![self _mustCustomize]) {

[super drawRect:rect];

return;

}

// TODO: support for segment custom width

CGSize itemSize = CGSizeMake(round(rect.size.width / self.numberOfSegments),
rect.size.height);

CGContextRef c = UIGraphicsGetCurrentContext();

CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();

CGContextSaveGState(c);

// Rect with radius, will be used to clip the entire view

CGFloat minx = CGRectGetMinX(rect) + 1, midx = CGRectGetMidX(rect), maxx = CGRectGetMaxX(rect) ;

CGFloat miny = CGRectGetMinY(rect) + 1, midy = CGRectGetMidY(rect) , maxy = CGRectGetMaxY(rect) ;

// Path are drawn starting from the middle of a pixel, in order to avoid an antialiased line

CGContextMoveToPoint(c, minx - .5, midy - .5);

CGContextAddArcToPoint(c, minx - .5, miny - .5, midx - .5, miny - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, miny - .5, maxx - .5, midy - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, maxy - .5, midx - .5, maxy - .5, _cornerRadius);

CGContextAddArcToPoint(c, minx - .5, maxy - .5, minx - .5, midy - .5, _cornerRadius);

CGContextClosePath(c);

CGContextClip(c);

// Background gradient for non selected items

if (_unSelectedItemBackgroundGradientCGColors) {

CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (CFArrayRef)_unSelectedItemBackgroundGradientCGColors, NULL);

CGContextDrawLinearGradient(c, gradient, CGPointZero, CGPointMake(0, rect.size.height),kCGGradientDrawsBeforeStartLocation);

CFRelease(gradient);

}

for (int i = 0; i < self.numberOfSegments; i++) {

id item = [self.items objectAtIndex:i];

BOOL isLeftItem  = i == 0;

BOOL isRightItem = i == self.numberOfSegments -1;

BOOL isSegmentEnabled = [self isEnabledForSegmentAtIndex:i];

CGRect itemBgRect = CGRectMake(i * itemSize.width, 

  0.0f,

  itemSize.width,

  rect.size.height);

if (i == self.selectedSegmentIndex) {

// -- Selected item --

// Background gradient is composed of two gradients, one on the top, another rounded on the bottom

CGContextSaveGState(c);

CGContextClipToRect(c, itemBgRect);

float factor  = 1.22f; // multiplier applied to the first color of the gradient to obtain the second

float mfactor = 1.25f; // multiplier applied to the color of the first gradient to obtain the bottom gradient

int red = 55, green = 111, blue = 214; // default blue color

if (self.tintColor != nil) {

const CGFloat *components = CGColorGetComponents(self.tintColor.CGColor);

size_t numberOfComponents = CGColorGetNumberOfComponents(self.tintColor.CGColor);

if (numberOfComponents == 2) {

red = green = blue = components[0] * 255;

} else if (numberOfComponents == 4) {

red   = components[0] * 255;

green = components[1] * 255;

blue  = components[2] * 255;

}

}

// Top gradient

CGFloat top_components[16] = { 

red / 255.0f,         green / 255.0f,         blue/255.0f          , 1.0f,

(red*mfactor)/255.0f, (green*mfactor)/255.0f, (blue*mfactor)/255.0f, 1.0f

};

CGFloat top_locations[2] = {

0.0f, .75f

};

CGGradientRef top_gradient = CGGradientCreateWithColorComponents(colorSpace, top_components, top_locations, 2);

CGContextDrawLinearGradient(c, 

top_gradient, 

itemBgRect.origin, 

CGPointMake(itemBgRect.origin.x, 

itemBgRect.size.height), 

kCGGradientDrawsBeforeStartLocation);

CFRelease(top_gradient);

CGContextRestoreGState(c);

// Bottom gradient

// It's clipped in a rect with the left corners rounded if segment is the first,

// right corners rounded if segment is the last, no rounded corners for the segments inbetween

CGRect bottomGradientRect = CGRectMake(itemBgRect.origin.x, 

  itemBgRect.origin.y + round(itemBgRect.size.height / 2), 

  itemBgRect.size.width, 

  round(itemBgRect.size.height / 2));

CGFloat gradient_minx = CGRectGetMinX(bottomGradientRect) + 1;

CGFloat gradient_midx = CGRectGetMidX(bottomGradientRect);

CGFloat gradient_maxx = CGRectGetMaxX(bottomGradientRect);

CGFloat gradient_miny = CGRectGetMinY(bottomGradientRect) + 1;

CGFloat gradient_midy = CGRectGetMidY(bottomGradientRect);

CGFloat gradient_maxy = CGRectGetMaxY(bottomGradientRect);

CGContextSaveGState(c);

if (isLeftItem) {

CGContextMoveToPoint(c, gradient_minx - .5f, gradient_midy - .5f);

} else {

CGContextMoveToPoint(c, gradient_minx - .5f, gradient_miny - .5f);

}

CGContextAddArcToPoint(c, gradient_minx - .5f, gradient_miny - .5f, gradient_midx - .5f, gradient_miny - .5f,_cornerRadius);

if (isRightItem) {

CGContextAddArcToPoint(c, gradient_maxx - .5f, gradient_miny - .5f, gradient_maxx - .5f, gradient_midy - .5f,_cornerRadius);

CGContextAddArcToPoint(c, gradient_maxx - .5f, gradient_maxy - .5f, gradient_midx - .5f, gradient_maxy - .5f,_cornerRadius);

} else {

CGContextAddLineToPoint(c, gradient_maxx, gradient_miny);

CGContextAddLineToPoint(c, gradient_maxx, gradient_maxy);

}

if (isLeftItem) {

CGContextAddArcToPoint(c, gradient_minx - .5f, gradient_maxy - .5f, gradient_minx - .5f, gradient_midy - .5f,_cornerRadius);

} else {

CGContextAddLineToPoint(c, gradient_minx, gradient_maxy);

}

CGContextClosePath(c);

CGContextClip(c);

CGFloat bottom_components[16] = {

(red*factor)        /255.0f, (green*factor)        /255.0f, (blue*factor)/255.0f,         1.0f,

(red*factor*mfactor)/255.0f, (green*factor*mfactor)/255.0f, (blue*factor*mfactor)/255.0f, 1.0f

};

CGFloat bottom_locations[2] = {

0.0f, 1.0f

};

CGGradientRef bottom_gradient = CGGradientCreateWithColorComponents(colorSpace, bottom_components, bottom_locations, 2);

CGContextDrawLinearGradient(c, 

bottom_gradient, 

bottomGradientRect.origin, 

CGPointMake(bottomGradientRect.origin.x, 

bottomGradientRect.origin.y + bottomGradientRect.size.height), 

kCGGradientDrawsBeforeStartLocation);

CFRelease(bottom_gradient);

CGContextRestoreGState(c);

// Inner shadow

int blendMode = kCGBlendModeDarken;

// Right and left inner shadow 

CGContextSaveGState(c);

CGContextSetBlendMode(c, blendMode);

CGContextClipToRect(c, itemBgRect);

CGFloat inner_shadow_components[16] = {

0.0f, 0.0f, 0.0f, isLeftItem ? 0.0f : .25f,

0.0f, 0.0f, 0.0f, 0.0f,

0.0f, 0.0f, 0.0f, 0.0f,

0.0f, 0.0f, 0.0f, isRightItem ? 0.0f : .25f

};

CGFloat locations[4] = {

0.0f, .05f, .95f, 1.0f

};

CGGradientRef inner_shadow_gradient = CGGradientCreateWithColorComponents(colorSpace, inner_shadow_components, locations, 4);

CGContextDrawLinearGradient(c, 

inner_shadow_gradient, 

itemBgRect.origin, 

CGPointMake(itemBgRect.origin.x + itemBgRect.size.width, 

itemBgRect.origin.y), 

kCGGradientDrawsAfterEndLocation);

CFRelease(inner_shadow_gradient);

CGContextRestoreGState(c);

// Top inner shadow 

CGContextSaveGState(c);

CGContextSetBlendMode(c, blendMode);

CGContextClipToRect(c, itemBgRect);

CGFloat top_inner_shadow_components[8] = { 

0.0f, 0.0f, 0.0f, 0.25f,

0.0f, 0.0f, 0.0f, 0.0f

};

CGFloat top_inner_shadow_locations[2] = {

0.0f, .10f

};

CGGradientRef top_inner_shadow_gradient = CGGradientCreateWithColorComponents(colorSpace, top_inner_shadow_components, top_inner_shadow_locations, 2);

CGContextDrawLinearGradient(c, 

top_inner_shadow_gradient, 

itemBgRect.origin, 

CGPointMake(itemBgRect.origin.x, 

itemBgRect.size.height), 

kCGGradientDrawsAfterEndLocation);

CFRelease(top_inner_shadow_gradient);

CGContextRestoreGState(c);

}

if ([item isKindOfClass:[UIImage class]]) {

CGImageRef imageRef = [(UIImage *)item CGImage];

CGFloat imageScale  = [(UIImage *)item scale];

CGFloat imageWidth  = CGImageGetWidth(imageRef)  / imageScale;

CGFloat imageHeight = CGImageGetHeight(imageRef) / imageScale;

CGRect imageRect = CGRectMake(round(i * itemSize.width + (itemSize.width - imageWidth) / 2), 

  round((itemSize.height - imageHeight) / 2),

  imageWidth,

  imageHeight);

if (i == self.selectedSegmentIndex) {

// 1px shadow

CGContextSaveGState(c);

CGContextTranslateCTM(c, 0, itemBgRect.size.height);  

CGContextScaleCTM(c, 1.0, -1.0);  

CGContextClipToMask(c, CGRectOffset(imageRect, 0, 1), imageRef);

CGContextSetFillColorWithColor(c, self.selectedItemShadowColor.CGColor);

CGContextFillRect(c, CGRectOffset(imageRect, 0, -1));

CGContextRestoreGState(c);

// Image drawn as a mask

CGContextSaveGState(c);

CGContextTranslateCTM(c, 0, rect.size.height);

CGContextScaleCTM(c, 1.0, -1.0);  

CGContextClipToMask(c, imageRect, imageRef);

CGContextSetFillColorWithColor(c, self.selectedItemColor.CGColor);

CGContextFillRect(c, imageRect);

CGContextRestoreGState(c);

} 

else {

if (isSegmentEnabled) {

// 1px shadow

CGContextSaveGState(c);

CGContextTranslateCTM(c, 0, itemBgRect.size.height);  

CGContextScaleCTM(c, 1.0, -1.0);  

CGContextClipToMask(c, CGRectOffset(imageRect, 0, -1), imageRef);

CGContextSetFillColorWithColor(c, self.unselectedItemShadowColor.CGColor);

CGContextFillRect(c, CGRectOffset(imageRect, 0, -1));

CGContextRestoreGState(c);

}

// Image drawn as a mask

CGContextSaveGState(c);

CGContextTranslateCTM(c, 0, itemBgRect.size.height);  

CGContextScaleCTM(c, 1.0, -1.0);  

CGContextClipToMask(c, imageRect, imageRef);

CGContextSetFillColorWithColor(c, [self.unselectedItemColor CGColor]);

CGContextSetAlpha(c, isSegmentEnabled ? 1.0 : 0.5);

CGContextFillRect(c, imageRect);

CGContextRestoreGState(c);

}

}

else if ([item isKindOfClass:[NSString class]]) {

CGContextSaveGState(c);

NSString *string = (NSString *)[_items objectAtIndex:i];

CGSize stringSize = [string sizeWithFont:self.font];

CGRect stringRect = CGRectMake(i * itemSize.width + (itemSize.width - stringSize.width) / 2, 

  (itemSize.height - stringSize.height) / 2,

  stringSize.width,

  stringSize.height);

if (self.selectedSegmentIndex == i) {

[self.selectedItemShadowColor setFill];

[string drawInRect:CGRectOffset(stringRect, 0.0f, -1.0f) withFont:self.font];

[self.selectedItemColor setFill];

[self.selectedItemColor setStroke];

[string drawInRect:stringRect withFont:self.font];

} else {

if (isSegmentEnabled) {

[self.unselectedItemShadowColor setFill];

[string drawInRect:CGRectOffset(stringRect, 0.0f, 1.0f) withFont:self.font];

}

[self.unselectedItemColor setFill];

CGContextSetAlpha(c, isSegmentEnabled ? 1.0 : 0.5);

[string drawInRect:stringRect withFont:self.font];

}

CGContextRestoreGState(c);

}

// Separator

if (i > 0 && i - 1 != self.selectedSegmentIndex &&
i != self.selectedSegmentIndex) {

CGContextSaveGState(c);

CGContextMoveToPoint(c, itemBgRect.origin.x + .5, itemBgRect.origin.y);

CGContextAddLineToPoint(c, itemBgRect.origin.x + .5, itemBgRect.size.height);

CGContextSetLineWidth(c, .5f);

CGContextSetStrokeColorWithColor(c, [UIColor colorWithWhite:120/255.0 alpha:1.0].CGColor);

CGContextStrokePath(c);

CGContextRestoreGState(c);

}

}

CGContextRestoreGState(c);

if (self.segmentedControlStyle ==  UISegmentedControlStyleBordered) {

CGContextMoveToPoint(c, minx - .5, midy - .5);

CGContextAddArcToPoint(c, minx - .5, miny - .5, midx - .5, miny - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, miny - .5, maxx - .5, midy - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, maxy - .5, midx - .5, maxy - .5, _cornerRadius);

CGContextAddArcToPoint(c, minx - .5, maxy - .5, minx - .5, midy - .5, _cornerRadius);

CGContextClosePath(c);

CGContextSetStrokeColorWithColor(c,[UIColor blackColor].CGColor);

CGContextSetLineWidth(c, 1.0f);

CGContextStrokePath(c);

} else {

CGContextSaveGState(c);

CGRect bottomHalfRect = CGRectMake(0, 

  rect.size.height - _cornerRadius + 7,

  rect.size.width,

  _cornerRadius);

CGContextClearRect(c, CGRectMake(0, 

rect.size.height - 1,

rect.size.width,

1));

CGContextClipToRect(c, bottomHalfRect);

CGContextMoveToPoint(c, minx + .5, midy - .5);

CGContextAddArcToPoint(c, minx + .5, miny - .5, midx - .5, miny - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, miny - .5, maxx - .5, midy - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, maxy - .5, midx - .5, maxy - .5, _cornerRadius);

CGContextAddArcToPoint(c, minx + .5, maxy - .5, minx - .5, midy - .5, _cornerRadius);

CGContextClosePath(c);

CGContextSetBlendMode(c, kCGBlendModeLighten);

CGContextSetStrokeColorWithColor(c,[UIColor colorWithWhite:255/255.0 alpha:1.0].CGColor);

CGContextSetLineWidth(c, .5f);

CGContextStrokePath(c);

CGContextRestoreGState(c);

midy--, maxy--;

CGContextMoveToPoint(c, minx - .5, midy - .5);

CGContextAddArcToPoint(c, minx - .5, miny - .5, midx - .5, miny - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, miny - .5, maxx - .5, midy - .5, _cornerRadius);

CGContextAddArcToPoint(c, maxx - .5, maxy - .5, midx - .5, maxy - .5, _cornerRadius);

CGContextAddArcToPoint(c, minx - .5, maxy - .5, minx - .5, midy - .5, _cornerRadius);

CGContextClosePath(c);

CGContextSetBlendMode(c, kCGBlendModeMultiply);

CGContextSetStrokeColorWithColor(c,[UIColor colorWithWhite:30/255.0 alpha:.9].CGColor);

CGContextSetLineWidth(c, .5f);

CGContextStrokePath(c);

}

CFRelease(colorSpace);

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

if (![self _mustCustomize]) {

[super touchesBegan:touches withEvent:event];

} else {

CGPoint point = [[touches anyObject] locationInView:self];

int itemIndex = floor(self.numberOfSegments * point.x / self.bounds.size.width);

if ([self isEnabledForSegmentAtIndex:itemIndex]) {

self.selectedSegmentIndex = itemIndex;

[self setNeedsDisplay];

}

}

}

- (void)setSelectedSegmentIndex:(NSInteger)selectedSegmentIndex

{

if (selectedSegmentIndex == self.selectedSegmentIndex) return;

[super setSelectedSegmentIndex:selectedSegmentIndex];

#ifdef __IPHONE_5_0

if ([self respondsToSelector:@selector(apportionsSegmentWidthsByContent)]

&& [self _mustCustomize]) 

{

[self sendActionsForControlEvents:UIControlEventValueChanged];

}

#endif

}

- (void)setSegmentedControlStyle:(UISegmentedControlStyle)aStyle

{

[super setSegmentedControlStyle:aStyle];

if ([self _mustCustomize]) {

[self setNeedsDisplay];

}

}

- (void)setTitle:(NSString *)title forSegmentAtIndex:(NSUInteger)segment

{

if (![self _mustCustomize]) {

[super setTitle:title forSegmentAtIndex:segment];

} else {

[self.items replaceObjectAtIndex:segment withObject:title];

[self setNeedsDisplay];

}

}

- (void)setImage:(UIImage *)image forSegmentAtIndex:(NSUInteger)segment

{

if (![self _mustCustomize]) {

[super setImage:image forSegmentAtIndex:segment];

} else {

[self.items replaceObjectAtIndex:segment withObject:image];

[self setNeedsDisplay];

}

}

- (void)insertSegmentWithTitle:(NSString *)title atIndex:(NSUInteger)segment animated:(BOOL)animated

{

if (![self _mustCustomize]) {

[super insertSegmentWithTitle:title atIndex:segment animated:animated];

} else {

if (segment >= self.numberOfSegments && segment != 0) return;

[super insertSegmentWithTitle:title atIndex:segment animated:animated];

[self.items insertObject:title atIndex:segment];

[self setNeedsDisplay];

}

}

- (void)insertSegmentWithImage:(UIImage *)image atIndex:(NSUInteger)segment animated:(BOOL)animated

{

if (![self _mustCustomize]) {

[super insertSegmentWithImage:image atIndex:segment animated:animated];

} else {

if (segment >= self.numberOfSegments) return;

[super insertSegmentWithImage:image atIndex:segment animated:animated];

[self.items insertObject:image atIndex:segment];

[self setNeedsDisplay];

}

}

- (void)removeSegmentAtIndex:(NSUInteger)segment animated:(BOOL)animated

{

if (![self _mustCustomize]) {

[super removeSegmentAtIndex:segment animated:animated];

} else {

if (segment >= self.numberOfSegments) return;

[self.items removeObjectAtIndex:segment];

[self setNeedsDisplay];

}

}

@end