You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1495 lines
53 KiB
1495 lines
53 KiB
//
|
|
// MBProgressHUD.m
|
|
// Version 1.1.0
|
|
// Created by Matej Bukovinski on 2.4.09.
|
|
//
|
|
|
|
#import "MBProgressHUD.h"
|
|
#import <tgmath.h>
|
|
|
|
|
|
#ifndef kCFCoreFoundationVersionNumber_iOS_7_0
|
|
#define kCFCoreFoundationVersionNumber_iOS_7_0 847.20
|
|
#endif
|
|
|
|
#ifndef kCFCoreFoundationVersionNumber_iOS_8_0
|
|
#define kCFCoreFoundationVersionNumber_iOS_8_0 1129.15
|
|
#endif
|
|
|
|
#define MBMainThreadAssert() NSAssert([NSThread isMainThread], @"MBProgressHUD needs to be accessed on the main thread.");
|
|
|
|
CGFloat const MBProgressMaxOffset = 1000000.f;
|
|
|
|
static const CGFloat MBDefaultPadding = 4.f;
|
|
static const CGFloat MBDefaultLabelFontSize = 16.f;
|
|
static const CGFloat MBDefaultDetailsLabelFontSize = 12.f;
|
|
|
|
|
|
@interface MBProgressHUD () {
|
|
// Deprecated
|
|
UIColor *_activityIndicatorColor;
|
|
CGFloat _opacity;
|
|
}
|
|
|
|
@property (nonatomic, assign) BOOL useAnimation;
|
|
@property (nonatomic, assign, getter=hasFinished) BOOL finished;
|
|
@property (nonatomic, strong) UIView *indicator;
|
|
@property (nonatomic, strong) NSDate *showStarted;
|
|
@property (nonatomic, strong) NSArray *paddingConstraints;
|
|
@property (nonatomic, strong) NSArray *bezelConstraints;
|
|
@property (nonatomic, strong) UIView *topSpacer;
|
|
@property (nonatomic, strong) UIView *bottomSpacer;
|
|
@property (nonatomic, weak) NSTimer *graceTimer;
|
|
@property (nonatomic, weak) NSTimer *minShowTimer;
|
|
@property (nonatomic, weak) NSTimer *hideDelayTimer;
|
|
@property (nonatomic, weak) CADisplayLink *progressObjectDisplayLink;
|
|
|
|
// Deprecated
|
|
@property (assign) BOOL taskInProgress;
|
|
|
|
@end
|
|
|
|
|
|
@interface MBProgressHUDRoundedButton : UIButton
|
|
@end
|
|
|
|
|
|
@implementation MBProgressHUD
|
|
|
|
#pragma mark - Class methods
|
|
|
|
+ (instancetype)showHUDAddedTo:(UIView *)view animated:(BOOL)animated {
|
|
MBProgressHUD *hud = [[self alloc] initWithView:view];
|
|
hud.removeFromSuperViewOnHide = YES;
|
|
[view addSubview:hud];
|
|
[hud showAnimated:animated];
|
|
return hud;
|
|
}
|
|
|
|
+ (BOOL)hideHUDForView:(UIView *)view animated:(BOOL)animated {
|
|
MBProgressHUD *hud = [self HUDForView:view];
|
|
if (hud != nil) {
|
|
hud.removeFromSuperViewOnHide = YES;
|
|
[hud hideAnimated:animated];
|
|
return YES;
|
|
}
|
|
return NO;
|
|
}
|
|
|
|
+ (MBProgressHUD *)HUDForView:(UIView *)view {
|
|
NSEnumerator *subviewsEnum = [view.subviews reverseObjectEnumerator];
|
|
for (UIView *subview in subviewsEnum) {
|
|
if ([subview isKindOfClass:self]) {
|
|
MBProgressHUD *hud = (MBProgressHUD *)subview;
|
|
if (hud.hasFinished == NO) {
|
|
return hud;
|
|
}
|
|
}
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (void)commonInit {
|
|
// Set default values for properties
|
|
_animationType = MBProgressHUDAnimationFade;
|
|
_mode = MBProgressHUDModeIndeterminate;
|
|
_margin = 20.0f;
|
|
_opacity = 1.f;
|
|
_defaultMotionEffectsEnabled = YES;
|
|
|
|
// Default color, depending on the current iOS version
|
|
BOOL isLegacy = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;
|
|
_contentColor = isLegacy ? [UIColor whiteColor] : [UIColor colorWithWhite:0.f alpha:0.7f];
|
|
// Transparent background
|
|
self.opaque = NO;
|
|
self.backgroundColor = [UIColor clearColor];
|
|
// Make it invisible for now
|
|
self.alpha = 0.0f;
|
|
self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
|
|
self.layer.allowsGroupOpacity = NO;
|
|
|
|
[self setupViews];
|
|
[self updateIndicators];
|
|
[self registerForNotifications];
|
|
}
|
|
|
|
- (instancetype)initWithFrame:(CGRect)frame {
|
|
if ((self = [super initWithFrame:frame])) {
|
|
[self commonInit];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (instancetype)initWithCoder:(NSCoder *)aDecoder {
|
|
if ((self = [super initWithCoder:aDecoder])) {
|
|
[self commonInit];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (id)initWithView:(UIView *)view {
|
|
NSAssert(view, @"View must not be nil.");
|
|
return [self initWithFrame:view.bounds];
|
|
}
|
|
|
|
- (void)dealloc {
|
|
[self unregisterFromNotifications];
|
|
}
|
|
|
|
#pragma mark - Show & hide
|
|
|
|
- (void)showAnimated:(BOOL)animated {
|
|
MBMainThreadAssert();
|
|
[self.minShowTimer invalidate];
|
|
self.useAnimation = animated;
|
|
self.finished = NO;
|
|
// If the grace time is set, postpone the HUD display
|
|
if (self.graceTime > 0.0) {
|
|
NSTimer *timer = [NSTimer timerWithTimeInterval:self.graceTime target:self selector:@selector(handleGraceTimer:) userInfo:nil repeats:NO];
|
|
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
|
|
self.graceTimer = timer;
|
|
}
|
|
// ... otherwise show the HUD immediately
|
|
else {
|
|
[self showUsingAnimation:self.useAnimation];
|
|
}
|
|
}
|
|
|
|
- (void)hideAnimated:(BOOL)animated {
|
|
MBMainThreadAssert();
|
|
[self.graceTimer invalidate];
|
|
self.useAnimation = animated;
|
|
self.finished = YES;
|
|
// If the minShow time is set, calculate how long the HUD was shown,
|
|
// and postpone the hiding operation if necessary
|
|
if (self.minShowTime > 0.0 && self.showStarted) {
|
|
NSTimeInterval interv = [[NSDate date] timeIntervalSinceDate:self.showStarted];
|
|
if (interv < self.minShowTime) {
|
|
NSTimer *timer = [NSTimer timerWithTimeInterval:(self.minShowTime - interv) target:self selector:@selector(handleMinShowTimer:) userInfo:nil repeats:NO];
|
|
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
|
|
self.minShowTimer = timer;
|
|
return;
|
|
}
|
|
}
|
|
// ... otherwise hide the HUD immediately
|
|
[self hideUsingAnimation:self.useAnimation];
|
|
}
|
|
|
|
- (void)hideAnimated:(BOOL)animated afterDelay:(NSTimeInterval)delay {
|
|
// Cancel any scheduled hideDelayed: calls
|
|
[self.hideDelayTimer invalidate];
|
|
|
|
NSTimer *timer = [NSTimer timerWithTimeInterval:delay target:self selector:@selector(handleHideTimer:) userInfo:@(animated) repeats:NO];
|
|
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
|
|
self.hideDelayTimer = timer;
|
|
}
|
|
|
|
#pragma mark - Timer callbacks
|
|
|
|
- (void)handleGraceTimer:(NSTimer *)theTimer {
|
|
// Show the HUD only if the task is still running
|
|
if (!self.hasFinished) {
|
|
[self showUsingAnimation:self.useAnimation];
|
|
}
|
|
}
|
|
|
|
- (void)handleMinShowTimer:(NSTimer *)theTimer {
|
|
[self hideUsingAnimation:self.useAnimation];
|
|
}
|
|
|
|
- (void)handleHideTimer:(NSTimer *)timer {
|
|
[self hideAnimated:[timer.userInfo boolValue]];
|
|
}
|
|
|
|
#pragma mark - View Hierrarchy
|
|
|
|
- (void)didMoveToSuperview {
|
|
[self updateForCurrentOrientationAnimated:NO];
|
|
}
|
|
|
|
#pragma mark - Internal show & hide operations
|
|
|
|
- (void)showUsingAnimation:(BOOL)animated {
|
|
// Cancel any previous animations
|
|
[self.bezelView.layer removeAllAnimations];
|
|
[self.backgroundView.layer removeAllAnimations];
|
|
|
|
// Cancel any scheduled hideDelayed: calls
|
|
[self.hideDelayTimer invalidate];
|
|
|
|
self.showStarted = [NSDate date];
|
|
self.alpha = 1.f;
|
|
|
|
// Needed in case we hide and re-show with the same NSProgress object attached.
|
|
[self setNSProgressDisplayLinkEnabled:YES];
|
|
|
|
if (animated) {
|
|
[self animateIn:YES withType:self.animationType completion:NULL];
|
|
} else {
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
self.bezelView.alpha = self.opacity;
|
|
#pragma clang diagnostic pop
|
|
self.backgroundView.alpha = 1.f;
|
|
}
|
|
}
|
|
|
|
- (void)hideUsingAnimation:(BOOL)animated {
|
|
if (animated && self.showStarted) {
|
|
self.showStarted = nil;
|
|
[self animateIn:NO withType:self.animationType completion:^(BOOL finished) {
|
|
[self done];
|
|
}];
|
|
} else {
|
|
self.showStarted = nil;
|
|
self.bezelView.alpha = 0.f;
|
|
self.backgroundView.alpha = 1.f;
|
|
[self done];
|
|
}
|
|
}
|
|
|
|
- (void)animateIn:(BOOL)animatingIn withType:(MBProgressHUDAnimation)type completion:(void(^)(BOOL finished))completion {
|
|
// Automatically determine the correct zoom animation type
|
|
if (type == MBProgressHUDAnimationZoom) {
|
|
type = animatingIn ? MBProgressHUDAnimationZoomIn : MBProgressHUDAnimationZoomOut;
|
|
}
|
|
|
|
CGAffineTransform small = CGAffineTransformMakeScale(0.5f, 0.5f);
|
|
CGAffineTransform large = CGAffineTransformMakeScale(1.5f, 1.5f);
|
|
|
|
// Set starting state
|
|
UIView *bezelView = self.bezelView;
|
|
if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomIn) {
|
|
bezelView.transform = small;
|
|
} else if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomOut) {
|
|
bezelView.transform = large;
|
|
}
|
|
|
|
// Perform animations
|
|
dispatch_block_t animations = ^{
|
|
if (animatingIn) {
|
|
bezelView.transform = CGAffineTransformIdentity;
|
|
} else if (!animatingIn && type == MBProgressHUDAnimationZoomIn) {
|
|
bezelView.transform = large;
|
|
} else if (!animatingIn && type == MBProgressHUDAnimationZoomOut) {
|
|
bezelView.transform = small;
|
|
}
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
bezelView.alpha = animatingIn ? self.opacity : 0.f;
|
|
#pragma clang diagnostic pop
|
|
self.backgroundView.alpha = animatingIn ? 1.f : 0.f;
|
|
};
|
|
|
|
// Spring animations are nicer, but only available on iOS 7+
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_7_0) {
|
|
[UIView animateWithDuration:0.3 delay:0. usingSpringWithDamping:1.f initialSpringVelocity:0.f options:UIViewAnimationOptionBeginFromCurrentState animations:animations completion:completion];
|
|
return;
|
|
}
|
|
#endif
|
|
[UIView animateWithDuration:0.3 delay:0. options:UIViewAnimationOptionBeginFromCurrentState animations:animations completion:completion];
|
|
}
|
|
|
|
- (void)done {
|
|
// Cancel any scheduled hideDelayed: calls
|
|
[self.hideDelayTimer invalidate];
|
|
[self setNSProgressDisplayLinkEnabled:NO];
|
|
|
|
if (self.hasFinished) {
|
|
self.alpha = 0.0f;
|
|
if (self.removeFromSuperViewOnHide) {
|
|
[self removeFromSuperview];
|
|
}
|
|
}
|
|
MBProgressHUDCompletionBlock completionBlock = self.completionBlock;
|
|
if (completionBlock) {
|
|
completionBlock();
|
|
}
|
|
id<MBProgressHUDDelegate> delegate = self.delegate;
|
|
if ([delegate respondsToSelector:@selector(hudWasHidden:)]) {
|
|
[delegate performSelector:@selector(hudWasHidden:) withObject:self];
|
|
}
|
|
}
|
|
|
|
#pragma mark - UI
|
|
|
|
- (void)setupViews {
|
|
UIColor *defaultColor = self.contentColor;
|
|
|
|
MBBackgroundView *backgroundView = [[MBBackgroundView alloc] initWithFrame:self.bounds];
|
|
backgroundView.style = MBProgressHUDBackgroundStyleSolidColor;
|
|
backgroundView.backgroundColor = [UIColor clearColor];
|
|
backgroundView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
|
|
backgroundView.alpha = 0.f;
|
|
[self addSubview:backgroundView];
|
|
_backgroundView = backgroundView;
|
|
|
|
MBBackgroundView *bezelView = [MBBackgroundView new];
|
|
bezelView.translatesAutoresizingMaskIntoConstraints = NO;
|
|
bezelView.layer.cornerRadius = 5.f;
|
|
bezelView.alpha = 0.f;
|
|
[self addSubview:bezelView];
|
|
_bezelView = bezelView;
|
|
[self updateBezelMotionEffects];
|
|
|
|
UILabel *label = [UILabel new];
|
|
label.adjustsFontSizeToFitWidth = NO;
|
|
label.textAlignment = NSTextAlignmentCenter;
|
|
label.textColor = defaultColor;
|
|
label.font = [UIFont boldSystemFontOfSize:MBDefaultLabelFontSize];
|
|
label.opaque = NO;
|
|
label.backgroundColor = [UIColor clearColor];
|
|
_label = label;
|
|
|
|
UILabel *detailsLabel = [UILabel new];
|
|
detailsLabel.adjustsFontSizeToFitWidth = NO;
|
|
detailsLabel.textAlignment = NSTextAlignmentCenter;
|
|
detailsLabel.textColor = defaultColor;
|
|
detailsLabel.numberOfLines = 0;
|
|
detailsLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];
|
|
detailsLabel.opaque = NO;
|
|
detailsLabel.backgroundColor = [UIColor clearColor];
|
|
_detailsLabel = detailsLabel;
|
|
|
|
UIButton *button = [MBProgressHUDRoundedButton buttonWithType:UIButtonTypeCustom];
|
|
button.titleLabel.textAlignment = NSTextAlignmentCenter;
|
|
button.titleLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];
|
|
[button setTitleColor:defaultColor forState:UIControlStateNormal];
|
|
_button = button;
|
|
|
|
for (UIView *view in @[label, detailsLabel, button]) {
|
|
view.translatesAutoresizingMaskIntoConstraints = NO;
|
|
[view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];
|
|
[view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];
|
|
[bezelView addSubview:view];
|
|
}
|
|
|
|
UIView *topSpacer = [UIView new];
|
|
topSpacer.translatesAutoresizingMaskIntoConstraints = NO;
|
|
topSpacer.hidden = YES;
|
|
[bezelView addSubview:topSpacer];
|
|
_topSpacer = topSpacer;
|
|
|
|
UIView *bottomSpacer = [UIView new];
|
|
bottomSpacer.translatesAutoresizingMaskIntoConstraints = NO;
|
|
bottomSpacer.hidden = YES;
|
|
[bezelView addSubview:bottomSpacer];
|
|
_bottomSpacer = bottomSpacer;
|
|
}
|
|
|
|
- (void)updateIndicators {
|
|
UIView *indicator = self.indicator;
|
|
BOOL isActivityIndicator = [indicator isKindOfClass:[UIActivityIndicatorView class]];
|
|
BOOL isRoundIndicator = [indicator isKindOfClass:[MBRoundProgressView class]];
|
|
|
|
MBProgressHUDMode mode = self.mode;
|
|
if (mode == MBProgressHUDModeIndeterminate) {
|
|
if (!isActivityIndicator) {
|
|
// Update to indeterminate indicator
|
|
[indicator removeFromSuperview];
|
|
indicator = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
|
|
[(UIActivityIndicatorView *)indicator startAnimating];
|
|
[self.bezelView addSubview:indicator];
|
|
}
|
|
}
|
|
else if (mode == MBProgressHUDModeDeterminateHorizontalBar) {
|
|
// Update to bar determinate indicator
|
|
[indicator removeFromSuperview];
|
|
indicator = [[MBBarProgressView alloc] init];
|
|
[self.bezelView addSubview:indicator];
|
|
}
|
|
else if (mode == MBProgressHUDModeDeterminate || mode == MBProgressHUDModeAnnularDeterminate) {
|
|
if (!isRoundIndicator) {
|
|
// Update to determinante indicator
|
|
[indicator removeFromSuperview];
|
|
indicator = [[MBRoundProgressView alloc] init];
|
|
[self.bezelView addSubview:indicator];
|
|
}
|
|
if (mode == MBProgressHUDModeAnnularDeterminate) {
|
|
[(MBRoundProgressView *)indicator setAnnular:YES];
|
|
}
|
|
}
|
|
else if (mode == MBProgressHUDModeCustomView && self.customView != indicator) {
|
|
// Update custom view indicator
|
|
[indicator removeFromSuperview];
|
|
indicator = self.customView;
|
|
[self.bezelView addSubview:indicator];
|
|
}
|
|
else if (mode == MBProgressHUDModeText) {
|
|
[indicator removeFromSuperview];
|
|
indicator = nil;
|
|
}
|
|
indicator.translatesAutoresizingMaskIntoConstraints = NO;
|
|
self.indicator = indicator;
|
|
|
|
if ([indicator respondsToSelector:@selector(setProgress:)]) {
|
|
[(id)indicator setValue:@(self.progress) forKey:@"progress"];
|
|
}
|
|
|
|
[indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];
|
|
[indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];
|
|
|
|
[self updateViewsForColor:self.contentColor];
|
|
[self setNeedsUpdateConstraints];
|
|
}
|
|
|
|
- (void)updateViewsForColor:(UIColor *)color {
|
|
if (!color) return;
|
|
|
|
self.label.textColor = color;
|
|
self.detailsLabel.textColor = color;
|
|
[self.button setTitleColor:color forState:UIControlStateNormal];
|
|
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
if (self.activityIndicatorColor) {
|
|
color = self.activityIndicatorColor;
|
|
}
|
|
#pragma clang diagnostic pop
|
|
|
|
// UIAppearance settings are prioritized. If they are preset the set color is ignored.
|
|
|
|
UIView *indicator = self.indicator;
|
|
if ([indicator isKindOfClass:[UIActivityIndicatorView class]]) {
|
|
UIActivityIndicatorView *appearance = nil;
|
|
#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
|
|
appearance = [UIActivityIndicatorView appearanceWhenContainedIn:[MBProgressHUD class], nil];
|
|
#else
|
|
// For iOS 9+
|
|
appearance = [UIActivityIndicatorView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
|
|
#endif
|
|
|
|
if (appearance.color == nil) {
|
|
((UIActivityIndicatorView *)indicator).color = color;
|
|
}
|
|
} else if ([indicator isKindOfClass:[MBRoundProgressView class]]) {
|
|
MBRoundProgressView *appearance = nil;
|
|
#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
|
|
appearance = [MBRoundProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];
|
|
#else
|
|
appearance = [MBRoundProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
|
|
#endif
|
|
if (appearance.progressTintColor == nil) {
|
|
((MBRoundProgressView *)indicator).progressTintColor = color;
|
|
}
|
|
if (appearance.backgroundTintColor == nil) {
|
|
((MBRoundProgressView *)indicator).backgroundTintColor = [color colorWithAlphaComponent:0.1];
|
|
}
|
|
} else if ([indicator isKindOfClass:[MBBarProgressView class]]) {
|
|
MBBarProgressView *appearance = nil;
|
|
#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
|
|
appearance = [MBBarProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];
|
|
#else
|
|
appearance = [MBBarProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
|
|
#endif
|
|
if (appearance.progressColor == nil) {
|
|
((MBBarProgressView *)indicator).progressColor = color;
|
|
}
|
|
if (appearance.lineColor == nil) {
|
|
((MBBarProgressView *)indicator).lineColor = color;
|
|
}
|
|
} else {
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV
|
|
if ([indicator respondsToSelector:@selector(setTintColor:)]) {
|
|
[indicator setTintColor:color];
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
- (void)updateBezelMotionEffects {
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV
|
|
MBBackgroundView *bezelView = self.bezelView;
|
|
if (![bezelView respondsToSelector:@selector(addMotionEffect:)]) return;
|
|
|
|
if (self.defaultMotionEffectsEnabled) {
|
|
CGFloat effectOffset = 10.f;
|
|
UIInterpolatingMotionEffect *effectX = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.x" type:UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis];
|
|
effectX.maximumRelativeValue = @(effectOffset);
|
|
effectX.minimumRelativeValue = @(-effectOffset);
|
|
|
|
UIInterpolatingMotionEffect *effectY = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.y" type:UIInterpolatingMotionEffectTypeTiltAlongVerticalAxis];
|
|
effectY.maximumRelativeValue = @(effectOffset);
|
|
effectY.minimumRelativeValue = @(-effectOffset);
|
|
|
|
UIMotionEffectGroup *group = [[UIMotionEffectGroup alloc] init];
|
|
group.motionEffects = @[effectX, effectY];
|
|
|
|
[bezelView addMotionEffect:group];
|
|
} else {
|
|
NSArray *effects = [bezelView motionEffects];
|
|
for (UIMotionEffect *effect in effects) {
|
|
[bezelView removeMotionEffect:effect];
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#pragma mark - Layout
|
|
|
|
- (void)updateConstraints {
|
|
UIView *bezel = self.bezelView;
|
|
UIView *topSpacer = self.topSpacer;
|
|
UIView *bottomSpacer = self.bottomSpacer;
|
|
CGFloat margin = self.margin;
|
|
NSMutableArray *bezelConstraints = [NSMutableArray array];
|
|
NSDictionary *metrics = @{@"margin": @(margin)};
|
|
|
|
NSMutableArray *subviews = [NSMutableArray arrayWithObjects:self.topSpacer, self.label, self.detailsLabel, self.button, self.bottomSpacer, nil];
|
|
if (self.indicator) [subviews insertObject:self.indicator atIndex:1];
|
|
|
|
// Remove existing constraints
|
|
[self removeConstraints:self.constraints];
|
|
[topSpacer removeConstraints:topSpacer.constraints];
|
|
[bottomSpacer removeConstraints:bottomSpacer.constraints];
|
|
if (self.bezelConstraints) {
|
|
[bezel removeConstraints:self.bezelConstraints];
|
|
self.bezelConstraints = nil;
|
|
}
|
|
|
|
// Center bezel in container (self), applying the offset if set
|
|
CGPoint offset = self.offset;
|
|
NSMutableArray *centeringConstraints = [NSMutableArray array];
|
|
[centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterX multiplier:1.f constant:offset.x]];
|
|
[centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterY relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterY multiplier:1.f constant:offset.y]];
|
|
[self applyPriority:998.f toConstraints:centeringConstraints];
|
|
[self addConstraints:centeringConstraints];
|
|
|
|
// Ensure minimum side margin is kept
|
|
NSMutableArray *sideConstraints = [NSMutableArray array];
|
|
[sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];
|
|
[sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];
|
|
[self applyPriority:999.f toConstraints:sideConstraints];
|
|
[self addConstraints:sideConstraints];
|
|
|
|
// Minimum bezel size, if set
|
|
CGSize minimumSize = self.minSize;
|
|
if (!CGSizeEqualToSize(minimumSize, CGSizeZero)) {
|
|
NSMutableArray *minSizeConstraints = [NSMutableArray array];
|
|
[minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeWidth relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.width]];
|
|
[minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.height]];
|
|
[self applyPriority:997.f toConstraints:minSizeConstraints];
|
|
[bezelConstraints addObjectsFromArray:minSizeConstraints];
|
|
}
|
|
|
|
// Square aspect ratio, if set
|
|
if (self.square) {
|
|
NSLayoutConstraint *square = [NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeWidth multiplier:1.f constant:0];
|
|
square.priority = 997.f;
|
|
[bezelConstraints addObject:square];
|
|
}
|
|
|
|
// Top and bottom spacing
|
|
[topSpacer addConstraint:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];
|
|
[bottomSpacer addConstraint:[NSLayoutConstraint constraintWithItem:bottomSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];
|
|
// Top and bottom spaces should be equal
|
|
[bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bottomSpacer attribute:NSLayoutAttributeHeight multiplier:1.f constant:0.f]];
|
|
|
|
// Layout subviews in bezel
|
|
NSMutableArray *paddingConstraints = [NSMutableArray new];
|
|
[subviews enumerateObjectsUsingBlock:^(UIView *view, NSUInteger idx, BOOL *stop) {
|
|
// Center in bezel
|
|
[bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeCenterX multiplier:1.f constant:0.f]];
|
|
// Ensure the minimum edge margin is kept
|
|
[bezelConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[view]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(view)]];
|
|
// Element spacing
|
|
if (idx == 0) {
|
|
// First, ensure spacing to bezel edge
|
|
[bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeTop multiplier:1.f constant:0.f]];
|
|
} else if (idx == subviews.count - 1) {
|
|
// Last, ensure spacing to bezel edge
|
|
[bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeBottom relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f]];
|
|
}
|
|
if (idx > 0) {
|
|
// Has previous
|
|
NSLayoutConstraint *padding = [NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:subviews[idx - 1] attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f];
|
|
[bezelConstraints addObject:padding];
|
|
[paddingConstraints addObject:padding];
|
|
}
|
|
}];
|
|
|
|
[bezel addConstraints:bezelConstraints];
|
|
self.bezelConstraints = bezelConstraints;
|
|
|
|
self.paddingConstraints = [paddingConstraints copy];
|
|
[self updatePaddingConstraints];
|
|
|
|
[super updateConstraints];
|
|
}
|
|
|
|
- (void)layoutSubviews {
|
|
// There is no need to update constraints if they are going to
|
|
// be recreated in [super layoutSubviews] due to needsUpdateConstraints being set.
|
|
// This also avoids an issue on iOS 8, where updatePaddingConstraints
|
|
// would trigger a zombie object access.
|
|
if (!self.needsUpdateConstraints) {
|
|
[self updatePaddingConstraints];
|
|
}
|
|
[super layoutSubviews];
|
|
}
|
|
|
|
- (void)updatePaddingConstraints {
|
|
// Set padding dynamically, depending on whether the view is visible or not
|
|
__block BOOL hasVisibleAncestors = NO;
|
|
[self.paddingConstraints enumerateObjectsUsingBlock:^(NSLayoutConstraint *padding, NSUInteger idx, BOOL *stop) {
|
|
UIView *firstView = (UIView *)padding.firstItem;
|
|
UIView *secondView = (UIView *)padding.secondItem;
|
|
BOOL firstVisible = !firstView.hidden && !CGSizeEqualToSize(firstView.intrinsicContentSize, CGSizeZero);
|
|
BOOL secondVisible = !secondView.hidden && !CGSizeEqualToSize(secondView.intrinsicContentSize, CGSizeZero);
|
|
// Set if both views are visible or if there's a visible view on top that doesn't have padding
|
|
// added relative to the current view yet
|
|
padding.constant = (firstVisible && (secondVisible || hasVisibleAncestors)) ? MBDefaultPadding : 0.f;
|
|
hasVisibleAncestors |= secondVisible;
|
|
}];
|
|
}
|
|
|
|
- (void)applyPriority:(UILayoutPriority)priority toConstraints:(NSArray *)constraints {
|
|
for (NSLayoutConstraint *constraint in constraints) {
|
|
constraint.priority = priority;
|
|
}
|
|
}
|
|
|
|
#pragma mark - Properties
|
|
|
|
- (void)setMode:(MBProgressHUDMode)mode {
|
|
if (mode != _mode) {
|
|
_mode = mode;
|
|
[self updateIndicators];
|
|
}
|
|
}
|
|
|
|
- (void)setCustomView:(UIView *)customView {
|
|
if (customView != _customView) {
|
|
_customView = customView;
|
|
if (self.mode == MBProgressHUDModeCustomView) {
|
|
[self updateIndicators];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)setOffset:(CGPoint)offset {
|
|
if (!CGPointEqualToPoint(offset, _offset)) {
|
|
_offset = offset;
|
|
[self setNeedsUpdateConstraints];
|
|
}
|
|
}
|
|
|
|
- (void)setMargin:(CGFloat)margin {
|
|
if (margin != _margin) {
|
|
_margin = margin;
|
|
[self setNeedsUpdateConstraints];
|
|
}
|
|
}
|
|
|
|
- (void)setMinSize:(CGSize)minSize {
|
|
if (!CGSizeEqualToSize(minSize, _minSize)) {
|
|
_minSize = minSize;
|
|
[self setNeedsUpdateConstraints];
|
|
}
|
|
}
|
|
|
|
- (void)setSquare:(BOOL)square {
|
|
if (square != _square) {
|
|
_square = square;
|
|
[self setNeedsUpdateConstraints];
|
|
}
|
|
}
|
|
|
|
- (void)setProgressObjectDisplayLink:(CADisplayLink *)progressObjectDisplayLink {
|
|
if (progressObjectDisplayLink != _progressObjectDisplayLink) {
|
|
[_progressObjectDisplayLink invalidate];
|
|
|
|
_progressObjectDisplayLink = progressObjectDisplayLink;
|
|
|
|
[_progressObjectDisplayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
|
|
}
|
|
}
|
|
|
|
- (void)setProgressObject:(NSProgress *)progressObject {
|
|
if (progressObject != _progressObject) {
|
|
_progressObject = progressObject;
|
|
[self setNSProgressDisplayLinkEnabled:YES];
|
|
}
|
|
}
|
|
|
|
- (void)setProgress:(float)progress {
|
|
if (progress != _progress) {
|
|
_progress = progress;
|
|
UIView *indicator = self.indicator;
|
|
if ([indicator respondsToSelector:@selector(setProgress:)]) {
|
|
[(id)indicator setValue:@(self.progress) forKey:@"progress"];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)setContentColor:(UIColor *)contentColor {
|
|
if (contentColor != _contentColor && ![contentColor isEqual:_contentColor]) {
|
|
_contentColor = contentColor;
|
|
[self updateViewsForColor:contentColor];
|
|
}
|
|
}
|
|
|
|
- (void)setDefaultMotionEffectsEnabled:(BOOL)defaultMotionEffectsEnabled {
|
|
if (defaultMotionEffectsEnabled != _defaultMotionEffectsEnabled) {
|
|
_defaultMotionEffectsEnabled = defaultMotionEffectsEnabled;
|
|
[self updateBezelMotionEffects];
|
|
}
|
|
}
|
|
|
|
#pragma mark - NSProgress
|
|
|
|
- (void)setNSProgressDisplayLinkEnabled:(BOOL)enabled {
|
|
// We're using CADisplayLink, because NSProgress can change very quickly and observing it may starve the main thread,
|
|
// so we're refreshing the progress only every frame draw
|
|
if (enabled && self.progressObject) {
|
|
// Only create if not already active.
|
|
if (!self.progressObjectDisplayLink) {
|
|
self.progressObjectDisplayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateProgressFromProgressObject)];
|
|
}
|
|
} else {
|
|
self.progressObjectDisplayLink = nil;
|
|
}
|
|
}
|
|
|
|
- (void)updateProgressFromProgressObject {
|
|
self.progress = self.progressObject.fractionCompleted;
|
|
}
|
|
|
|
#pragma mark - Notifications
|
|
|
|
- (void)registerForNotifications {
|
|
#if !TARGET_OS_TV
|
|
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
|
|
|
|
[nc addObserver:self selector:@selector(statusBarOrientationDidChange:)
|
|
name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];
|
|
#endif
|
|
}
|
|
|
|
- (void)unregisterFromNotifications {
|
|
#if !TARGET_OS_TV
|
|
NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
|
|
[nc removeObserver:self name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];
|
|
#endif
|
|
}
|
|
|
|
#if !TARGET_OS_TV
|
|
- (void)statusBarOrientationDidChange:(NSNotification *)notification {
|
|
UIView *superview = self.superview;
|
|
if (!superview) {
|
|
return;
|
|
} else {
|
|
[self updateForCurrentOrientationAnimated:YES];
|
|
}
|
|
}
|
|
#endif
|
|
|
|
- (void)updateForCurrentOrientationAnimated:(BOOL)animated {
|
|
// Stay in sync with the superview in any case
|
|
if (self.superview) {
|
|
self.frame = self.superview.bounds;
|
|
}
|
|
|
|
// Not needed on iOS 8+, compile out when the deployment target allows,
|
|
// to avoid sharedApplication problems on extension targets
|
|
#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
|
|
// Only needed pre iOS 8 when added to a window
|
|
BOOL iOS8OrLater = kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0;
|
|
if (iOS8OrLater || ![self.superview isKindOfClass:[UIWindow class]]) return;
|
|
|
|
// Make extension friendly. Will not get called on extensions (iOS 8+) due to the above check.
|
|
// This just ensures we don't get a warning about extension-unsafe API.
|
|
Class UIApplicationClass = NSClassFromString(@"UIApplication");
|
|
if (!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) return;
|
|
|
|
UIApplication *application = [UIApplication performSelector:@selector(sharedApplication)];
|
|
UIInterfaceOrientation orientation = application.statusBarOrientation;
|
|
CGFloat radians = 0;
|
|
|
|
if (UIInterfaceOrientationIsLandscape(orientation)) {
|
|
radians = orientation == UIInterfaceOrientationLandscapeLeft ? -(CGFloat)M_PI_2 : (CGFloat)M_PI_2;
|
|
// Window coordinates differ!
|
|
self.bounds = CGRectMake(0, 0, self.bounds.size.height, self.bounds.size.width);
|
|
} else {
|
|
radians = orientation == UIInterfaceOrientationPortraitUpsideDown ? (CGFloat)M_PI : 0.f;
|
|
}
|
|
|
|
if (animated) {
|
|
[UIView animateWithDuration:0.3 animations:^{
|
|
self.transform = CGAffineTransformMakeRotation(radians);
|
|
}];
|
|
} else {
|
|
self.transform = CGAffineTransformMakeRotation(radians);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@implementation MBRoundProgressView
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (id)init {
|
|
return [self initWithFrame:CGRectMake(0.f, 0.f, 37.f, 37.f)];
|
|
}
|
|
|
|
- (id)initWithFrame:(CGRect)frame {
|
|
self = [super initWithFrame:frame];
|
|
if (self) {
|
|
self.backgroundColor = [UIColor clearColor];
|
|
self.opaque = NO;
|
|
_progress = 0.f;
|
|
_annular = NO;
|
|
_progressTintColor = [[UIColor alloc] initWithWhite:1.f alpha:1.f];
|
|
_backgroundTintColor = [[UIColor alloc] initWithWhite:1.f alpha:.1f];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
#pragma mark - Layout
|
|
|
|
- (CGSize)intrinsicContentSize {
|
|
return CGSizeMake(37.f, 37.f);
|
|
}
|
|
|
|
#pragma mark - Properties
|
|
|
|
- (void)setProgress:(float)progress {
|
|
if (progress != _progress) {
|
|
_progress = progress;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
- (void)setProgressTintColor:(UIColor *)progressTintColor {
|
|
NSAssert(progressTintColor, @"The color should not be nil.");
|
|
if (progressTintColor != _progressTintColor && ![progressTintColor isEqual:_progressTintColor]) {
|
|
_progressTintColor = progressTintColor;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
- (void)setBackgroundTintColor:(UIColor *)backgroundTintColor {
|
|
NSAssert(backgroundTintColor, @"The color should not be nil.");
|
|
if (backgroundTintColor != _backgroundTintColor && ![backgroundTintColor isEqual:_backgroundTintColor]) {
|
|
_backgroundTintColor = backgroundTintColor;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Drawing
|
|
|
|
- (void)drawRect:(CGRect)rect {
|
|
CGContextRef context = UIGraphicsGetCurrentContext();
|
|
BOOL isPreiOS7 = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;
|
|
|
|
if (_annular) {
|
|
// Draw background
|
|
CGFloat lineWidth = isPreiOS7 ? 5.f : 2.f;
|
|
UIBezierPath *processBackgroundPath = [UIBezierPath bezierPath];
|
|
processBackgroundPath.lineWidth = lineWidth;
|
|
processBackgroundPath.lineCapStyle = kCGLineCapButt;
|
|
CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
|
|
CGFloat radius = (self.bounds.size.width - lineWidth)/2;
|
|
CGFloat startAngle = - ((float)M_PI / 2); // 90 degrees
|
|
CGFloat endAngle = (2 * (float)M_PI) + startAngle;
|
|
[processBackgroundPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
|
|
[_backgroundTintColor set];
|
|
[processBackgroundPath stroke];
|
|
// Draw progress
|
|
UIBezierPath *processPath = [UIBezierPath bezierPath];
|
|
processPath.lineCapStyle = isPreiOS7 ? kCGLineCapRound : kCGLineCapSquare;
|
|
processPath.lineWidth = lineWidth;
|
|
endAngle = (self.progress * 2 * (float)M_PI) + startAngle;
|
|
[processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
|
|
[_progressTintColor set];
|
|
[processPath stroke];
|
|
} else {
|
|
// Draw background
|
|
CGFloat lineWidth = 2.f;
|
|
CGRect allRect = self.bounds;
|
|
CGRect circleRect = CGRectInset(allRect, lineWidth/2.f, lineWidth/2.f);
|
|
CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
|
|
[_progressTintColor setStroke];
|
|
[_backgroundTintColor setFill];
|
|
CGContextSetLineWidth(context, lineWidth);
|
|
if (isPreiOS7) {
|
|
CGContextFillEllipseInRect(context, circleRect);
|
|
}
|
|
CGContextStrokeEllipseInRect(context, circleRect);
|
|
// 90 degrees
|
|
CGFloat startAngle = - ((float)M_PI / 2.f);
|
|
// Draw progress
|
|
if (isPreiOS7) {
|
|
CGFloat radius = (CGRectGetWidth(self.bounds) / 2.f) - lineWidth;
|
|
CGFloat endAngle = (self.progress * 2.f * (float)M_PI) + startAngle;
|
|
[_progressTintColor setFill];
|
|
CGContextMoveToPoint(context, center.x, center.y);
|
|
CGContextAddArc(context, center.x, center.y, radius, startAngle, endAngle, 0);
|
|
CGContextClosePath(context);
|
|
CGContextFillPath(context);
|
|
} else {
|
|
UIBezierPath *processPath = [UIBezierPath bezierPath];
|
|
processPath.lineCapStyle = kCGLineCapButt;
|
|
processPath.lineWidth = lineWidth * 2.f;
|
|
CGFloat radius = (CGRectGetWidth(self.bounds) / 2.f) - (processPath.lineWidth / 2.f);
|
|
CGFloat endAngle = (self.progress * 2.f * (float)M_PI) + startAngle;
|
|
[processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
|
|
// Ensure that we don't get color overlapping when _progressTintColor alpha < 1.f.
|
|
CGContextSetBlendMode(context, kCGBlendModeCopy);
|
|
[_progressTintColor set];
|
|
[processPath stroke];
|
|
}
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@implementation MBBarProgressView
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (id)init {
|
|
return [self initWithFrame:CGRectMake(.0f, .0f, 120.0f, 20.0f)];
|
|
}
|
|
|
|
- (id)initWithFrame:(CGRect)frame {
|
|
self = [super initWithFrame:frame];
|
|
if (self) {
|
|
_progress = 0.f;
|
|
_lineColor = [UIColor whiteColor];
|
|
_progressColor = [UIColor whiteColor];
|
|
_progressRemainingColor = [UIColor clearColor];
|
|
self.backgroundColor = [UIColor clearColor];
|
|
self.opaque = NO;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
#pragma mark - Layout
|
|
|
|
- (CGSize)intrinsicContentSize {
|
|
BOOL isPreiOS7 = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;
|
|
return CGSizeMake(120.f, isPreiOS7 ? 20.f : 10.f);
|
|
}
|
|
|
|
#pragma mark - Properties
|
|
|
|
- (void)setProgress:(float)progress {
|
|
if (progress != _progress) {
|
|
_progress = progress;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
- (void)setProgressColor:(UIColor *)progressColor {
|
|
NSAssert(progressColor, @"The color should not be nil.");
|
|
if (progressColor != _progressColor && ![progressColor isEqual:_progressColor]) {
|
|
_progressColor = progressColor;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
- (void)setProgressRemainingColor:(UIColor *)progressRemainingColor {
|
|
NSAssert(progressRemainingColor, @"The color should not be nil.");
|
|
if (progressRemainingColor != _progressRemainingColor && ![progressRemainingColor isEqual:_progressRemainingColor]) {
|
|
_progressRemainingColor = progressRemainingColor;
|
|
[self setNeedsDisplay];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Drawing
|
|
|
|
- (void)drawRect:(CGRect)rect {
|
|
CGContextRef context = UIGraphicsGetCurrentContext();
|
|
|
|
CGContextSetLineWidth(context, 2);
|
|
CGContextSetStrokeColorWithColor(context,[_lineColor CGColor]);
|
|
CGContextSetFillColorWithColor(context, [_progressRemainingColor CGColor]);
|
|
|
|
// Draw background and Border
|
|
CGFloat radius = (rect.size.height / 2) - 2;
|
|
CGContextMoveToPoint(context, 2, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 2, 2, radius + 2, 2, radius);
|
|
CGContextAddArcToPoint(context, rect.size.width - 2, 2, rect.size.width - 2, rect.size.height / 2, radius);
|
|
CGContextAddArcToPoint(context, rect.size.width - 2, rect.size.height - 2, rect.size.width - radius - 2, rect.size.height - 2, radius);
|
|
CGContextAddArcToPoint(context, 2, rect.size.height - 2, 2, rect.size.height/2, radius);
|
|
CGContextDrawPath(context, kCGPathFillStroke);
|
|
|
|
CGContextSetFillColorWithColor(context, [_progressColor CGColor]);
|
|
radius = radius - 2;
|
|
CGFloat amount = self.progress * rect.size.width;
|
|
|
|
// Progress in the middle area
|
|
if (amount >= radius + 4 && amount <= (rect.size.width - radius - 4)) {
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
|
|
CGContextAddLineToPoint(context, amount, 4);
|
|
CGContextAddLineToPoint(context, amount, radius + 4);
|
|
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
|
|
CGContextAddLineToPoint(context, amount, rect.size.height - 4);
|
|
CGContextAddLineToPoint(context, amount, radius + 4);
|
|
|
|
CGContextFillPath(context);
|
|
}
|
|
|
|
// Progress in the right arc
|
|
else if (amount > radius + 4) {
|
|
CGFloat x = amount - (rect.size.width - radius - 4);
|
|
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
|
|
CGContextAddLineToPoint(context, rect.size.width - radius - 4, 4);
|
|
CGFloat angle = -acos(x/radius);
|
|
if (isnan(angle)) angle = 0;
|
|
CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, M_PI, angle, 0);
|
|
CGContextAddLineToPoint(context, amount, rect.size.height/2);
|
|
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
|
|
CGContextAddLineToPoint(context, rect.size.width - radius - 4, rect.size.height - 4);
|
|
angle = acos(x/radius);
|
|
if (isnan(angle)) angle = 0;
|
|
CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, -M_PI, angle, 1);
|
|
CGContextAddLineToPoint(context, amount, rect.size.height/2);
|
|
|
|
CGContextFillPath(context);
|
|
}
|
|
|
|
// Progress is in the left arc
|
|
else if (amount < radius + 4 && amount > 0) {
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
|
|
CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);
|
|
|
|
CGContextMoveToPoint(context, 4, rect.size.height/2);
|
|
CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
|
|
CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);
|
|
|
|
CGContextFillPath(context);
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@interface MBBackgroundView ()
|
|
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
@property UIVisualEffectView *effectView;
|
|
#endif
|
|
#if !TARGET_OS_TV
|
|
@property UIToolbar *toolbar;
|
|
#endif
|
|
|
|
@end
|
|
|
|
|
|
@implementation MBBackgroundView
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (instancetype)initWithFrame:(CGRect)frame {
|
|
if ((self = [super initWithFrame:frame])) {
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_7_0) {
|
|
_style = MBProgressHUDBackgroundStyleBlur;
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
_blurEffectStyle = UIBlurEffectStyleLight;
|
|
#endif
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {
|
|
_color = [UIColor colorWithWhite:0.8f alpha:0.6f];
|
|
} else {
|
|
_color = [UIColor colorWithWhite:0.95f alpha:0.6f];
|
|
}
|
|
} else {
|
|
_style = MBProgressHUDBackgroundStyleSolidColor;
|
|
_color = [[UIColor blackColor] colorWithAlphaComponent:0.8];
|
|
}
|
|
|
|
self.clipsToBounds = YES;
|
|
|
|
[self updateForBackgroundStyle];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
#pragma mark - Layout
|
|
|
|
- (CGSize)intrinsicContentSize {
|
|
// Smallest size possible. Content pushes against this.
|
|
return CGSizeZero;
|
|
}
|
|
|
|
#pragma mark - Appearance
|
|
|
|
- (void)setStyle:(MBProgressHUDBackgroundStyle)style {
|
|
if (style == MBProgressHUDBackgroundStyleBlur && kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0) {
|
|
style = MBProgressHUDBackgroundStyleSolidColor;
|
|
}
|
|
if (_style != style) {
|
|
_style = style;
|
|
[self updateForBackgroundStyle];
|
|
}
|
|
}
|
|
|
|
- (void)setColor:(UIColor *)color {
|
|
NSAssert(color, @"The color should not be nil.");
|
|
if (color != _color && ![color isEqual:_color]) {
|
|
_color = color;
|
|
[self updateViewsForColor:color];
|
|
}
|
|
}
|
|
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
|
|
- (void)setBlurEffectStyle:(UIBlurEffectStyle)blurEffectStyle {
|
|
if (_blurEffectStyle == blurEffectStyle) {
|
|
return;
|
|
}
|
|
|
|
_blurEffectStyle = blurEffectStyle;
|
|
|
|
[self updateForBackgroundStyle];
|
|
}
|
|
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark - Views
|
|
|
|
- (void)updateForBackgroundStyle {
|
|
MBProgressHUDBackgroundStyle style = self.style;
|
|
if (style == MBProgressHUDBackgroundStyleBlur) {
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {
|
|
UIBlurEffect *effect = [UIBlurEffect effectWithStyle:self.blurEffectStyle];
|
|
UIVisualEffectView *effectView = [[UIVisualEffectView alloc] initWithEffect:effect];
|
|
[self addSubview:effectView];
|
|
effectView.frame = self.bounds;
|
|
effectView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
|
|
self.backgroundColor = self.color;
|
|
self.layer.allowsGroupOpacity = NO;
|
|
self.effectView = effectView;
|
|
} else {
|
|
#endif
|
|
#if !TARGET_OS_TV
|
|
UIToolbar *toolbar = [[UIToolbar alloc] initWithFrame:CGRectInset(self.bounds, -100.f, -100.f)];
|
|
toolbar.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
|
|
toolbar.barTintColor = self.color;
|
|
toolbar.translucent = YES;
|
|
[self addSubview:toolbar];
|
|
self.toolbar = toolbar;
|
|
#endif
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
}
|
|
#endif
|
|
} else {
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {
|
|
[self.effectView removeFromSuperview];
|
|
self.effectView = nil;
|
|
} else {
|
|
#endif
|
|
#if !TARGET_OS_TV
|
|
[self.toolbar removeFromSuperview];
|
|
self.toolbar = nil;
|
|
#endif
|
|
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV
|
|
}
|
|
#endif
|
|
self.backgroundColor = self.color;
|
|
}
|
|
}
|
|
|
|
- (void)updateViewsForColor:(UIColor *)color {
|
|
if (self.style == MBProgressHUDBackgroundStyleBlur) {
|
|
if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {
|
|
self.backgroundColor = self.color;
|
|
} else {
|
|
#if !TARGET_OS_TV
|
|
self.toolbar.barTintColor = color;
|
|
#endif
|
|
}
|
|
} else {
|
|
self.backgroundColor = self.color;
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@implementation MBProgressHUD (Deprecated)
|
|
|
|
#pragma mark - Class
|
|
|
|
+ (NSUInteger)hideAllHUDsForView:(UIView *)view animated:(BOOL)animated {
|
|
NSArray *huds = [MBProgressHUD allHUDsForView:view];
|
|
for (MBProgressHUD *hud in huds) {
|
|
hud.removeFromSuperViewOnHide = YES;
|
|
[hud hideAnimated:animated];
|
|
}
|
|
return [huds count];
|
|
}
|
|
|
|
+ (NSArray *)allHUDsForView:(UIView *)view {
|
|
NSMutableArray *huds = [NSMutableArray array];
|
|
NSArray *subviews = view.subviews;
|
|
for (UIView *aView in subviews) {
|
|
if ([aView isKindOfClass:self]) {
|
|
[huds addObject:aView];
|
|
}
|
|
}
|
|
return [NSArray arrayWithArray:huds];
|
|
}
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (id)initWithWindow:(UIWindow *)window {
|
|
return [self initWithView:window];
|
|
}
|
|
|
|
#pragma mark - Show & hide
|
|
|
|
- (void)show:(BOOL)animated {
|
|
[self showAnimated:animated];
|
|
}
|
|
|
|
- (void)hide:(BOOL)animated {
|
|
[self hideAnimated:animated];
|
|
}
|
|
|
|
- (void)hide:(BOOL)animated afterDelay:(NSTimeInterval)delay {
|
|
[self hideAnimated:animated afterDelay:delay];
|
|
}
|
|
|
|
#pragma mark - Threading
|
|
|
|
- (void)showWhileExecuting:(SEL)method onTarget:(id)target withObject:(id)object animated:(BOOL)animated {
|
|
[self showAnimated:animated whileExecutingBlock:^{
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
|
|
// Start executing the requested task
|
|
[target performSelector:method withObject:object];
|
|
#pragma clang diagnostic pop
|
|
}];
|
|
}
|
|
|
|
- (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block {
|
|
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
|
|
[self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:NULL];
|
|
}
|
|
|
|
- (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block completionBlock:(void (^)(void))completion {
|
|
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
|
|
[self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:completion];
|
|
}
|
|
|
|
- (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block onQueue:(dispatch_queue_t)queue {
|
|
[self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:NULL];
|
|
}
|
|
|
|
- (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block onQueue:(dispatch_queue_t)queue completionBlock:(nullable MBProgressHUDCompletionBlock)completion {
|
|
self.taskInProgress = YES;
|
|
self.completionBlock = completion;
|
|
dispatch_async(queue, ^(void) {
|
|
block();
|
|
dispatch_async(dispatch_get_main_queue(), ^(void) {
|
|
[self cleanUp];
|
|
});
|
|
});
|
|
[self showAnimated:animated];
|
|
}
|
|
|
|
- (void)cleanUp {
|
|
self.taskInProgress = NO;
|
|
[self hideAnimated:self.useAnimation];
|
|
}
|
|
|
|
#pragma mark - Labels
|
|
|
|
- (NSString *)labelText {
|
|
return self.label.text;
|
|
}
|
|
|
|
- (void)setLabelText:(NSString *)labelText {
|
|
MBMainThreadAssert();
|
|
self.label.text = labelText;
|
|
}
|
|
|
|
- (UIFont *)labelFont {
|
|
return self.label.font;
|
|
}
|
|
|
|
- (void)setLabelFont:(UIFont *)labelFont {
|
|
MBMainThreadAssert();
|
|
self.label.font = labelFont;
|
|
}
|
|
|
|
- (UIColor *)labelColor {
|
|
return self.label.textColor;
|
|
}
|
|
|
|
- (void)setLabelColor:(UIColor *)labelColor {
|
|
MBMainThreadAssert();
|
|
self.label.textColor = labelColor;
|
|
}
|
|
|
|
- (NSString *)detailsLabelText {
|
|
return self.detailsLabel.text;
|
|
}
|
|
|
|
- (void)setDetailsLabelText:(NSString *)detailsLabelText {
|
|
MBMainThreadAssert();
|
|
self.detailsLabel.text = detailsLabelText;
|
|
}
|
|
|
|
- (UIFont *)detailsLabelFont {
|
|
return self.detailsLabel.font;
|
|
}
|
|
|
|
- (void)setDetailsLabelFont:(UIFont *)detailsLabelFont {
|
|
MBMainThreadAssert();
|
|
self.detailsLabel.font = detailsLabelFont;
|
|
}
|
|
|
|
- (UIColor *)detailsLabelColor {
|
|
return self.detailsLabel.textColor;
|
|
}
|
|
|
|
- (void)setDetailsLabelColor:(UIColor *)detailsLabelColor {
|
|
MBMainThreadAssert();
|
|
self.detailsLabel.textColor = detailsLabelColor;
|
|
}
|
|
|
|
- (CGFloat)opacity {
|
|
return _opacity;
|
|
}
|
|
|
|
- (void)setOpacity:(CGFloat)opacity {
|
|
MBMainThreadAssert();
|
|
_opacity = opacity;
|
|
}
|
|
|
|
- (UIColor *)color {
|
|
return self.bezelView.color;
|
|
}
|
|
|
|
- (void)setColor:(UIColor *)color {
|
|
MBMainThreadAssert();
|
|
self.bezelView.color = color;
|
|
}
|
|
|
|
- (CGFloat)yOffset {
|
|
return self.offset.y;
|
|
}
|
|
|
|
- (void)setYOffset:(CGFloat)yOffset {
|
|
MBMainThreadAssert();
|
|
self.offset = CGPointMake(self.offset.x, yOffset);
|
|
}
|
|
|
|
- (CGFloat)xOffset {
|
|
return self.offset.x;
|
|
}
|
|
|
|
- (void)setXOffset:(CGFloat)xOffset {
|
|
MBMainThreadAssert();
|
|
self.offset = CGPointMake(xOffset, self.offset.y);
|
|
}
|
|
|
|
- (CGFloat)cornerRadius {
|
|
return self.bezelView.layer.cornerRadius;
|
|
}
|
|
|
|
- (void)setCornerRadius:(CGFloat)cornerRadius {
|
|
MBMainThreadAssert();
|
|
self.bezelView.layer.cornerRadius = cornerRadius;
|
|
}
|
|
|
|
- (BOOL)dimBackground {
|
|
MBBackgroundView *backgroundView = self.backgroundView;
|
|
UIColor *dimmedColor = [UIColor colorWithWhite:0.f alpha:.2f];
|
|
return backgroundView.style == MBProgressHUDBackgroundStyleSolidColor && [backgroundView.color isEqual:dimmedColor];
|
|
}
|
|
|
|
- (void)setDimBackground:(BOOL)dimBackground {
|
|
MBMainThreadAssert();
|
|
self.backgroundView.style = MBProgressHUDBackgroundStyleSolidColor;
|
|
self.backgroundView.color = dimBackground ? [UIColor colorWithWhite:0.f alpha:.2f] : [UIColor clearColor];
|
|
}
|
|
|
|
- (CGSize)size {
|
|
return self.bezelView.frame.size;
|
|
}
|
|
|
|
- (UIColor *)activityIndicatorColor {
|
|
return _activityIndicatorColor;
|
|
}
|
|
|
|
- (void)setActivityIndicatorColor:(UIColor *)activityIndicatorColor {
|
|
if (activityIndicatorColor != _activityIndicatorColor) {
|
|
_activityIndicatorColor = activityIndicatorColor;
|
|
UIActivityIndicatorView *indicator = (UIActivityIndicatorView *)self.indicator;
|
|
if ([indicator isKindOfClass:[UIActivityIndicatorView class]]) {
|
|
[indicator setColor:activityIndicatorColor];
|
|
}
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
@implementation MBProgressHUDRoundedButton
|
|
|
|
#pragma mark - Lifecycle
|
|
|
|
- (instancetype)initWithFrame:(CGRect)frame {
|
|
self = [super initWithFrame:frame];
|
|
if (self) {
|
|
CALayer *layer = self.layer;
|
|
layer.borderWidth = 1.f;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
#pragma mark - Layout
|
|
|
|
- (void)layoutSubviews {
|
|
[super layoutSubviews];
|
|
// Fully rounded corners
|
|
CGFloat height = CGRectGetHeight(self.bounds);
|
|
self.layer.cornerRadius = ceil(height / 2.f);
|
|
}
|
|
|
|
- (CGSize)intrinsicContentSize {
|
|
// Only show if we have associated control events
|
|
if (self.allControlEvents == 0) return CGSizeZero;
|
|
CGSize size = [super intrinsicContentSize];
|
|
// Add some side padding
|
|
size.width += 20.f;
|
|
return size;
|
|
}
|
|
|
|
#pragma mark - Color
|
|
|
|
- (void)setTitleColor:(UIColor *)color forState:(UIControlState)state {
|
|
[super setTitleColor:color forState:state];
|
|
// Update related colors
|
|
[self setHighlighted:self.highlighted];
|
|
self.layer.borderColor = color.CGColor;
|
|
}
|
|
|
|
- (void)setHighlighted:(BOOL)highlighted {
|
|
[super setHighlighted:highlighted];
|
|
UIColor *baseColor = [self titleColorForState:UIControlStateSelected];
|
|
self.backgroundColor = highlighted ? [baseColor colorWithAlphaComponent:0.1f] : [UIColor clearColor];
|
|
}
|
|
|
|
@end
|