Gh0stByte
/
Bkstg-Plus
peilaus alkaen https://github.com/Gh0stByte/Bkstg-Plus
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Julkaisut 3 Wiki Activity
Save your Bkstg media (Reddit TweakBounty)
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.
8 Commitit
1 Haara
Puu: 3415c0f6f7
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '3415c0f6f7'
${ noResults }
Bkstg-Plus/MBProgressHUD.m

1485 lines
53KB
Raaka Blame Historia 

  1. //

  2. // MBProgressHUD.m

  3. // Version 1.0.0

  4. // Created by Matej Bukovinski on 2.4.09.

  5. //

  6. 

  7. #import "MBProgressHUD.h"

  8. #import <tgmath.h>

  9. 

  10. 

  11. #ifndef kCFCoreFoundationVersionNumber_iOS_7_0

  12.     #define kCFCoreFoundationVersionNumber_iOS_7_0 847.20

  13. #endif

  14. 

  15. #ifndef kCFCoreFoundationVersionNumber_iOS_8_0

  16.     #define kCFCoreFoundationVersionNumber_iOS_8_0 1129.15

  17. #endif

  18. 

  19. #define MBMainThreadAssert() NSAssert([NSThread isMainThread], @"MBProgressHUD needs to be accessed on the main thread.");

  20. 

  21. CGFloat const MBProgressMaxOffset = 1000000.f;

  22. 

  23. static const CGFloat MBDefaultPadding = 4.f;

  24. static const CGFloat MBDefaultLabelFontSize = 16.f;

  25. static const CGFloat MBDefaultDetailsLabelFontSize = 12.f;

  26. 

  27. 

  28. @interface MBProgressHUD () {

  29.     // Deprecated

  30.     UIColor *_activityIndicatorColor;

  31.     CGFloat _opacity;

  32. }

  33. 

  34. @property (nonatomic, assign) BOOL useAnimation;

  35. @property (nonatomic, assign, getter=hasFinished) BOOL finished;

  36. @property (nonatomic, strong) UIView *indicator;

  37. @property (nonatomic, strong) NSDate *showStarted;

  38. @property (nonatomic, strong) NSArray *paddingConstraints;

  39. @property (nonatomic, strong) NSArray *bezelConstraints;

  40. @property (nonatomic, strong) UIView *topSpacer;

  41. @property (nonatomic, strong) UIView *bottomSpacer;

  42. @property (nonatomic, weak) NSTimer *graceTimer;

  43. @property (nonatomic, weak) NSTimer *minShowTimer;

  44. @property (nonatomic, weak) NSTimer *hideDelayTimer;

  45. @property (nonatomic, weak) CADisplayLink *progressObjectDisplayLink;

  46. 

  47. // Deprecated

  48. @property (assign) BOOL taskInProgress;

  49. 

  50. @end

  51. 

  52. 

  53. @interface MBProgressHUDRoundedButton : UIButton

  54. @end

  55. 

  56. 

  57. @implementation MBProgressHUD

  58. 

  59. #pragma mark - Class methods

  60. 

  61. + (instancetype)showHUDAddedTo:(UIView *)view animated:(BOOL)animated {

  62.     MBProgressHUD *hud = [[self alloc] initWithView:view];

  63.     hud.removeFromSuperViewOnHide = YES;

  64.     [view addSubview:hud];

  65.     [hud showAnimated:animated];

  66.     return hud;

  67. }

  68. 

  69. + (BOOL)hideHUDForView:(UIView *)view animated:(BOOL)animated {

  70.     MBProgressHUD *hud = [self HUDForView:view];

  71.     if (hud != nil) {

  72.         hud.removeFromSuperViewOnHide = YES;

  73.         [hud hideAnimated:animated];

  74.         return YES;

  75.     }

  76.     return NO;

  77. }

  78. 

  79. + (MBProgressHUD *)HUDForView:(UIView *)view {

  80.     NSEnumerator *subviewsEnum = [view.subviews reverseObjectEnumerator];

  81.     for (UIView *subview in subviewsEnum) {

  82.         if ([subview isKindOfClass:self]) {

  83.             return (MBProgressHUD *)subview;

  84.         }

  85.     }

  86.     return nil;

  87. }

  88. 

  89. #pragma mark - Lifecycle

  90. 

  91. - (void)commonInit {

  92.     // Set default values for properties

  93.     _animationType = MBProgressHUDAnimationFade;

  94.     _mode = MBProgressHUDModeIndeterminate;

  95.     _margin = 20.0f;

  96.     _opacity = 1.f;

  97.     _defaultMotionEffectsEnabled = YES;

  98. 

  99.     // Default color, depending on the current iOS version

  100.     BOOL isLegacy = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;

  101.     _contentColor = isLegacy ? [UIColor whiteColor] : [UIColor colorWithWhite:0.f alpha:0.7f];

  102.     // Transparent background

  103.     self.opaque = NO;

  104.     self.backgroundColor = [UIColor clearColor];

  105.     // Make it invisible for now

  106.     self.alpha = 0.0f;

  107.     self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;

  108.     self.layer.allowsGroupOpacity = NO;

  109. 

  110.     [self setupViews];

  111.     [self updateIndicators];

  112.     [self registerForNotifications];

  113. }

  114. 

  115. - (instancetype)initWithFrame:(CGRect)frame {

  116.     if ((self = [super initWithFrame:frame])) {

  117.         [self commonInit];

  118.     }

  119.     return self;

  120. }

  121. 

  122. - (instancetype)initWithCoder:(NSCoder *)aDecoder {

  123.     if ((self = [super initWithCoder:aDecoder])) {

  124.         [self commonInit];

  125.     }

  126.     return self;

  127. }

  128. 

  129. - (id)initWithView:(UIView *)view {

  130.     NSAssert(view, @"View must not be nil.");

  131.     return [self initWithFrame:view.bounds];

  132. }

  133. 

  134. - (void)dealloc {

  135.     [self unregisterFromNotifications];

  136. }

  137. 

  138. #pragma mark - Show & hide

  139. 

  140. - (void)showAnimated:(BOOL)animated {

  141.     MBMainThreadAssert();

  142.     [self.minShowTimer invalidate];

  143.     self.useAnimation = animated;

  144.     self.finished = NO;

  145.     // If the grace time is set, postpone the HUD display

  146.     if (self.graceTime > 0.0) {

  147.         NSTimer *timer = [NSTimer timerWithTimeInterval:self.graceTime target:self selector:@selector(handleGraceTimer:) userInfo:nil repeats:NO];

  148.         [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

  149.         self.graceTimer = timer;

  150.     } 

  151.     // ... otherwise show the HUD immediately

  152.     else {

  153.         [self showUsingAnimation:self.useAnimation];

  154.     }

  155. }

  156. 

  157. - (void)hideAnimated:(BOOL)animated {

  158.     MBMainThreadAssert();

  159.     [self.graceTimer invalidate];

  160.     self.useAnimation = animated;

  161.     self.finished = YES;

  162.     // If the minShow time is set, calculate how long the HUD was shown,

  163.     // and postpone the hiding operation if necessary

  164.     if (self.minShowTime > 0.0 && self.showStarted) {

  165.         NSTimeInterval interv = [[NSDate date] timeIntervalSinceDate:self.showStarted];

  166.         if (interv < self.minShowTime) {

  167.             NSTimer *timer = [NSTimer timerWithTimeInterval:(self.minShowTime - interv) target:self selector:@selector(handleMinShowTimer:) userInfo:nil repeats:NO];

  168.             [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

  169.             self.minShowTimer = timer;

  170.             return;

  171.         } 

  172.     }

  173.     // ... otherwise hide the HUD immediately

  174.     [self hideUsingAnimation:self.useAnimation];

  175. }

  176. 

  177. - (void)hideAnimated:(BOOL)animated afterDelay:(NSTimeInterval)delay {

  178.     NSTimer *timer = [NSTimer timerWithTimeInterval:delay target:self selector:@selector(handleHideTimer:) userInfo:@(animated) repeats:NO];

  179.     [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

  180.     self.hideDelayTimer = timer;

  181. }

  182. 

  183. #pragma mark - Timer callbacks

  184. 

  185. - (void)handleGraceTimer:(NSTimer *)theTimer {

  186.     // Show the HUD only if the task is still running

  187.     if (!self.hasFinished) {

  188.         [self showUsingAnimation:self.useAnimation];

  189.     }

  190. }

  191. 

  192. - (void)handleMinShowTimer:(NSTimer *)theTimer {

  193.     [self hideUsingAnimation:self.useAnimation];

  194. }

  195. 

  196. - (void)handleHideTimer:(NSTimer *)timer {

  197.     [self hideAnimated:[timer.userInfo boolValue]];

  198. }

  199. 

  200. #pragma mark - View Hierrarchy

  201. 

  202. - (void)didMoveToSuperview {

  203.     [self updateForCurrentOrientationAnimated:NO];

  204. }

  205. 

  206. #pragma mark - Internal show & hide operations

  207. 

  208. - (void)showUsingAnimation:(BOOL)animated {

  209.     // Cancel any previous animations

  210.     [self.bezelView.layer removeAllAnimations];

  211.     [self.backgroundView.layer removeAllAnimations];

  212. 

  213.     // Cancel any scheduled hideDelayed: calls

  214.     [self.hideDelayTimer invalidate];

  215. 

  216.     self.showStarted = [NSDate date];

  217.     self.alpha = 1.f;

  218. 

  219.     // Needed in case we hide and re-show with the same NSProgress object attached.

  220.     [self setNSProgressDisplayLinkEnabled:YES];

  221. 

  222.     if (animated) {

  223.         [self animateIn:YES withType:self.animationType completion:NULL];

  224.     } else {

  225. #pragma clang diagnostic push

  226. #pragma clang diagnostic ignored "-Wdeprecated-declarations"

  227.         self.bezelView.alpha = self.opacity;

  228. #pragma clang diagnostic pop

  229.         self.backgroundView.alpha = 1.f;

  230.     }

  231. }

  232. 

  233. - (void)hideUsingAnimation:(BOOL)animated {

  234.     if (animated && self.showStarted) {

  235.         self.showStarted = nil;

  236.         [self animateIn:NO withType:self.animationType completion:^(BOOL finished) {

  237.             [self done];

  238.         }];

  239.     } else {

  240.         self.showStarted = nil;

  241.         self.bezelView.alpha = 0.f;

  242.         self.backgroundView.alpha = 1.f;

  243.         [self done];

  244.     }

  245. }

  246. 

  247. - (void)animateIn:(BOOL)animatingIn withType:(MBProgressHUDAnimation)type completion:(void(^)(BOOL finished))completion {

  248.     // Automatically determine the correct zoom animation type

  249.     if (type == MBProgressHUDAnimationZoom) {

  250.         type = animatingIn ? MBProgressHUDAnimationZoomIn : MBProgressHUDAnimationZoomOut;

  251.     }

  252. 

  253.     CGAffineTransform small = CGAffineTransformMakeScale(0.5f, 0.5f);

  254.     CGAffineTransform large = CGAffineTransformMakeScale(1.5f, 1.5f);

  255. 

  256.     // Set starting state

  257.     UIView *bezelView = self.bezelView;

  258.     if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomIn) {

  259.         bezelView.transform = small;

  260.     } else if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomOut) {

  261.         bezelView.transform = large;

  262.     }

  263. 

  264.     // Perform animations

  265.     dispatch_block_t animations = ^{

  266.         if (animatingIn) {

  267.             bezelView.transform = CGAffineTransformIdentity;

  268.         } else if (!animatingIn && type == MBProgressHUDAnimationZoomIn) {

  269.             bezelView.transform = large;

  270.         } else if (!animatingIn && type == MBProgressHUDAnimationZoomOut) {

  271.             bezelView.transform = small;

  272.         }

  273. #pragma clang diagnostic push

  274. #pragma clang diagnostic ignored "-Wdeprecated-declarations"

  275.         bezelView.alpha = animatingIn ? self.opacity : 0.f;

  276. #pragma clang diagnostic pop

  277.         self.backgroundView.alpha = animatingIn ? 1.f : 0.f;

  278.     };

  279. 

  280.     // Spring animations are nicer, but only available on iOS 7+

  281. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV

  282.     if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_7_0) {

  283.         [UIView animateWithDuration:0.3 delay:0. usingSpringWithDamping:1.f initialSpringVelocity:0.f options:UIViewAnimationOptionBeginFromCurrentState animations:animations completion:completion];

  284.         return;

  285.     }

  286. #endif

  287.     [UIView animateWithDuration:0.3 delay:0. options:UIViewAnimationOptionBeginFromCurrentState animations:animations completion:completion];

  288. }

  289. 

  290. - (void)done {

  291.     // Cancel any scheduled hideDelayed: calls

  292.     [self.hideDelayTimer invalidate];

  293.     [self setNSProgressDisplayLinkEnabled:NO];

  294. 

  295.     if (self.hasFinished) {

  296.         self.alpha = 0.0f;

  297.         if (self.removeFromSuperViewOnHide) {

  298.             [self removeFromSuperview];

  299.         }

  300.     }

  301.     MBProgressHUDCompletionBlock completionBlock = self.completionBlock;

  302.     if (completionBlock) {

  303.         completionBlock();

  304.     }

  305.     id<MBProgressHUDDelegate> delegate = self.delegate;

  306.     if ([delegate respondsToSelector:@selector(hudWasHidden:)]) {

  307.         [delegate performSelector:@selector(hudWasHidden:) withObject:self];

  308.     }

  309. }

  310. 

  311. #pragma mark - UI

  312. 

  313. - (void)setupViews {

  314.     UIColor *defaultColor = self.contentColor;

  315. 

  316.     MBBackgroundView *backgroundView = [[MBBackgroundView alloc] initWithFrame:self.bounds];

  317.     backgroundView.style = MBProgressHUDBackgroundStyleSolidColor;

  318.     backgroundView.backgroundColor = [UIColor clearColor];

  319.     backgroundView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;

  320.     backgroundView.alpha = 0.f;

  321.     [self addSubview:backgroundView];

  322.     _backgroundView = backgroundView;

  323. 

  324.     MBBackgroundView *bezelView = [MBBackgroundView new];

  325.     bezelView.translatesAutoresizingMaskIntoConstraints = NO;

  326.     bezelView.layer.cornerRadius = 5.f;

  327.     bezelView.alpha = 0.f;

  328.     [self addSubview:bezelView];

  329.     _bezelView = bezelView;

  330.     [self updateBezelMotionEffects];

  331. 

  332.     UILabel *label = [UILabel new];

  333.     label.adjustsFontSizeToFitWidth = NO;

  334.     label.textAlignment = NSTextAlignmentCenter;

  335.     label.textColor = defaultColor;

  336.     label.font = [UIFont boldSystemFontOfSize:MBDefaultLabelFontSize];

  337.     label.opaque = NO;

  338.     label.backgroundColor = [UIColor clearColor];

  339.     _label = label;

  340. 

  341.     UILabel *detailsLabel = [UILabel new];

  342.     detailsLabel.adjustsFontSizeToFitWidth = NO;

  343.     detailsLabel.textAlignment = NSTextAlignmentCenter;

  344.     detailsLabel.textColor = defaultColor;

  345.     detailsLabel.numberOfLines = 0;

  346.     detailsLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];

  347.     detailsLabel.opaque = NO;

  348.     detailsLabel.backgroundColor = [UIColor clearColor];

  349.     _detailsLabel = detailsLabel;

  350. 

  351.     UIButton *button = [MBProgressHUDRoundedButton buttonWithType:UIButtonTypeCustom];

  352.     button.titleLabel.textAlignment = NSTextAlignmentCenter;

  353.     button.titleLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];

  354.     [button setTitleColor:defaultColor forState:UIControlStateNormal];

  355.     _button = button;

  356. 

  357.     for (UIView *view in @[label, detailsLabel, button]) {

  358.         view.translatesAutoresizingMaskIntoConstraints = NO;

  359.         [view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];

  360.         [view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];

  361.         [bezelView addSubview:view];

  362.     }

  363. 

  364.     UIView *topSpacer = [UIView new];

  365.     topSpacer.translatesAutoresizingMaskIntoConstraints = NO;

  366.     topSpacer.hidden = YES;

  367.     [bezelView addSubview:topSpacer];

  368.     _topSpacer = topSpacer;

  369. 

  370.     UIView *bottomSpacer = [UIView new];

  371.     bottomSpacer.translatesAutoresizingMaskIntoConstraints = NO;

  372.     bottomSpacer.hidden = YES;

  373.     [bezelView addSubview:bottomSpacer];

  374.     _bottomSpacer = bottomSpacer;

  375. }

  376. 

  377. - (void)updateIndicators {

  378.     UIView *indicator = self.indicator;

  379.     BOOL isActivityIndicator = [indicator isKindOfClass:[UIActivityIndicatorView class]];

  380.     BOOL isRoundIndicator = [indicator isKindOfClass:[MBRoundProgressView class]];

  381. 

  382.     MBProgressHUDMode mode = self.mode;

  383.     if (mode == MBProgressHUDModeIndeterminate) {

  384.         if (!isActivityIndicator) {

  385.             // Update to indeterminate indicator

  386.             [indicator removeFromSuperview];

  387.             indicator = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];

  388.             [(UIActivityIndicatorView *)indicator startAnimating];

  389.             [self.bezelView addSubview:indicator];

  390.         }

  391.     }

  392.     else if (mode == MBProgressHUDModeDeterminateHorizontalBar) {

  393.         // Update to bar determinate indicator

  394.         [indicator removeFromSuperview];

  395.         indicator = [[MBBarProgressView alloc] init];

  396.         [self.bezelView addSubview:indicator];

  397.     }

  398.     else if (mode == MBProgressHUDModeDeterminate || mode == MBProgressHUDModeAnnularDeterminate) {

  399.         if (!isRoundIndicator) {

  400.             // Update to determinante indicator

  401.             [indicator removeFromSuperview];

  402.             indicator = [[MBRoundProgressView alloc] init];

  403.             [self.bezelView addSubview:indicator];

  404.         }

  405.         if (mode == MBProgressHUDModeAnnularDeterminate) {

  406.             [(MBRoundProgressView *)indicator setAnnular:YES];

  407.         }

  408.     } 

  409.     else if (mode == MBProgressHUDModeCustomView && self.customView != indicator) {

  410.         // Update custom view indicator

  411.         [indicator removeFromSuperview];

  412.         indicator = self.customView;

  413.         [self.bezelView addSubview:indicator];

  414.     }

  415.     else if (mode == MBProgressHUDModeText) {

  416.         [indicator removeFromSuperview];

  417.         indicator = nil;

  418.     }

  419.     indicator.translatesAutoresizingMaskIntoConstraints = NO;

  420.     self.indicator = indicator;

  421. 

  422.     if ([indicator respondsToSelector:@selector(setProgress:)]) {

  423.         [(id)indicator setValue:@(self.progress) forKey:@"progress"];

  424.     }

  425. 

  426.     [indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];

  427.     [indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];

  428. 

  429.     [self updateViewsForColor:self.contentColor];

  430.     [self setNeedsUpdateConstraints];

  431. }

  432. 

  433. - (void)updateViewsForColor:(UIColor *)color {

  434.     if (!color) return;

  435. 

  436.     self.label.textColor = color;

  437.     self.detailsLabel.textColor = color;

  438.     [self.button setTitleColor:color forState:UIControlStateNormal];

  439. 

  440. #pragma clang diagnostic push

  441. #pragma clang diagnostic ignored "-Wdeprecated-declarations"

  442.     if (self.activityIndicatorColor) {

  443.         color = self.activityIndicatorColor;

  444.     }

  445. #pragma clang diagnostic pop

  446. 

  447.     // UIAppearance settings are prioritized. If they are preset the set color is ignored.

  448. 

  449.     UIView *indicator = self.indicator;

  450.     if ([indicator isKindOfClass:[UIActivityIndicatorView class]]) {

  451.         UIActivityIndicatorView *appearance = nil;

  452. #if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000

  453.         appearance = [UIActivityIndicatorView appearanceWhenContainedIn:[MBProgressHUD class], nil];

  454. #else

  455.         // For iOS 9+

  456.         appearance = [UIActivityIndicatorView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];

  457. #endif

  458.         

  459.         if (appearance.color == nil) {

  460.             ((UIActivityIndicatorView *)indicator).color = color;

  461.         }

  462.     } else if ([indicator isKindOfClass:[MBRoundProgressView class]]) {

  463.         MBRoundProgressView *appearance = nil;

  464. #if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000

  465.         appearance = [MBRoundProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];

  466. #else

  467.         appearance = [MBRoundProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];

  468. #endif

  469.         if (appearance.progressTintColor == nil) {

  470.             ((MBRoundProgressView *)indicator).progressTintColor = color;

  471.         }

  472.         if (appearance.backgroundTintColor == nil) {

  473.             ((MBRoundProgressView *)indicator).backgroundTintColor = [color colorWithAlphaComponent:0.1];

  474.         }

  475.     } else if ([indicator isKindOfClass:[MBBarProgressView class]]) {

  476.         MBBarProgressView *appearance = nil;

  477. #if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000

  478.         appearance = [MBBarProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];

  479. #else

  480.         appearance = [MBBarProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];

  481. #endif

  482.         if (appearance.progressColor == nil) {

  483.             ((MBBarProgressView *)indicator).progressColor = color;

  484.         }

  485.         if (appearance.lineColor == nil) {

  486.             ((MBBarProgressView *)indicator).lineColor = color;

  487.         }

  488.     } else {

  489. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV

  490.         if ([indicator respondsToSelector:@selector(setTintColor:)]) {

  491.             [indicator setTintColor:color];

  492.         }

  493. #endif

  494.     }

  495. }

  496. 

  497. - (void)updateBezelMotionEffects {

  498. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 70000 || TARGET_OS_TV

  499.     MBBackgroundView *bezelView = self.bezelView;

  500.     if (![bezelView respondsToSelector:@selector(addMotionEffect:)]) return;

  501. 

  502.     if (self.defaultMotionEffectsEnabled) {

  503.         CGFloat effectOffset = 10.f;

  504.         UIInterpolatingMotionEffect *effectX = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.x" type:UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis];

  505.         effectX.maximumRelativeValue = @(effectOffset);

  506.         effectX.minimumRelativeValue = @(-effectOffset);

  507. 

  508.         UIInterpolatingMotionEffect *effectY = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.y" type:UIInterpolatingMotionEffectTypeTiltAlongVerticalAxis];

  509.         effectY.maximumRelativeValue = @(effectOffset);

  510.         effectY.minimumRelativeValue = @(-effectOffset);

  511. 

  512.         UIMotionEffectGroup *group = [[UIMotionEffectGroup alloc] init];

  513.         group.motionEffects = @[effectX, effectY];

  514. 

  515.         [bezelView addMotionEffect:group];

  516.     } else {

  517.         NSArray *effects = [bezelView motionEffects];

  518.         for (UIMotionEffect *effect in effects) {

  519.             [bezelView removeMotionEffect:effect];

  520.         }

  521.     }

  522. #endif

  523. }

  524. 

  525. #pragma mark - Layout

  526. 

  527. - (void)updateConstraints {

  528.     UIView *bezel = self.bezelView;

  529.     UIView *topSpacer = self.topSpacer;

  530.     UIView *bottomSpacer = self.bottomSpacer;

  531.     CGFloat margin = self.margin;

  532.     NSMutableArray *bezelConstraints = [NSMutableArray array];

  533.     NSDictionary *metrics = @{@"margin": @(margin)};

  534. 

  535.     NSMutableArray *subviews = [NSMutableArray arrayWithObjects:self.topSpacer, self.label, self.detailsLabel, self.button, self.bottomSpacer, nil];

  536.     if (self.indicator) [subviews insertObject:self.indicator atIndex:1];

  537. 

  538.     // Remove existing constraints

  539.     [self removeConstraints:self.constraints];

  540.     [topSpacer removeConstraints:topSpacer.constraints];

  541.     [bottomSpacer removeConstraints:bottomSpacer.constraints];

  542.     if (self.bezelConstraints) {

  543.         [bezel removeConstraints:self.bezelConstraints];

  544.         self.bezelConstraints = nil;

  545.     }

  546. 

  547.     // Center bezel in container (self), applying the offset if set

  548.     CGPoint offset = self.offset;

  549.     NSMutableArray *centeringConstraints = [NSMutableArray array];

  550.     [centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterX multiplier:1.f constant:offset.x]];

  551.     [centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterY relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterY multiplier:1.f constant:offset.y]];

  552.     [self applyPriority:998.f toConstraints:centeringConstraints];

  553.     [self addConstraints:centeringConstraints];

  554. 

  555.     // Ensure minimum side margin is kept

  556.     NSMutableArray *sideConstraints = [NSMutableArray array];

  557.     [sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];

  558.     [sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];

  559.     [self applyPriority:999.f toConstraints:sideConstraints];

  560.     [self addConstraints:sideConstraints];

  561. 

  562.     // Minimum bezel size, if set

  563.     CGSize minimumSize = self.minSize;

  564.     if (!CGSizeEqualToSize(minimumSize, CGSizeZero)) {

  565.         NSMutableArray *minSizeConstraints = [NSMutableArray array];

  566.         [minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeWidth relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.width]];

  567.         [minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.height]];

  568.         [self applyPriority:997.f toConstraints:minSizeConstraints];

  569.         [bezelConstraints addObjectsFromArray:minSizeConstraints];

  570.     }

  571. 

  572.     // Square aspect ratio, if set

  573.     if (self.square) {

  574.         NSLayoutConstraint *square = [NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeWidth multiplier:1.f constant:0];

  575.         square.priority = 997.f;

  576.         [bezelConstraints addObject:square];

  577.     }

  578. 

  579.     // Top and bottom spacing

  580.     [topSpacer addConstraint:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];

  581.     [bottomSpacer addConstraint:[NSLayoutConstraint constraintWithItem:bottomSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];

  582.     // Top and bottom spaces should be equal

  583.     [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bottomSpacer attribute:NSLayoutAttributeHeight multiplier:1.f constant:0.f]];

  584. 

  585.     // Layout subviews in bezel

  586.     NSMutableArray *paddingConstraints = [NSMutableArray new];

  587.     [subviews enumerateObjectsUsingBlock:^(UIView *view, NSUInteger idx, BOOL *stop) {

  588.         // Center in bezel

  589.         [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeCenterX multiplier:1.f constant:0.f]];

  590.         // Ensure the minimum edge margin is kept

  591.         [bezelConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[view]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(view)]];

  592.         // Element spacing

  593.         if (idx == 0) {

  594.             // First, ensure spacing to bezel edge

  595.             [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeTop multiplier:1.f constant:0.f]];

  596.         } else if (idx == subviews.count - 1) {

  597.             // Last, ensure spacing to bezel edge

  598.             [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeBottom relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f]];

  599.         }

  600.         if (idx > 0) {

  601.             // Has previous

  602.             NSLayoutConstraint *padding = [NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:subviews[idx - 1] attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f];

  603.             [bezelConstraints addObject:padding];

  604.             [paddingConstraints addObject:padding];

  605.         }

  606.     }];

  607. 

  608.     [bezel addConstraints:bezelConstraints];

  609.     self.bezelConstraints = bezelConstraints;

  610.     

  611.     self.paddingConstraints = [paddingConstraints copy];

  612.     [self updatePaddingConstraints];

  613.     

  614.     [super updateConstraints];

  615. }

  616. 

  617. - (void)layoutSubviews {

  618.     // There is no need to update constraints if they are going to

  619.     // be recreated in [super layoutSubviews] due to needsUpdateConstraints being set.

  620.     // This also avoids an issue on iOS 8, where updatePaddingConstraints

  621.     // would trigger a zombie object access.

  622.     if (!self.needsUpdateConstraints) {

  623.         [self updatePaddingConstraints];

  624.     }

  625.     [super layoutSubviews];

  626. }

  627. 

  628. - (void)updatePaddingConstraints {

  629.     // Set padding dynamically, depending on whether the view is visible or not

  630.     __block BOOL hasVisibleAncestors = NO;

  631.     [self.paddingConstraints enumerateObjectsUsingBlock:^(NSLayoutConstraint *padding, NSUInteger idx, BOOL *stop) {

  632.         UIView *firstView = (UIView *)padding.firstItem;

  633.         UIView *secondView = (UIView *)padding.secondItem;

  634.         BOOL firstVisible = !firstView.hidden && !CGSizeEqualToSize(firstView.intrinsicContentSize, CGSizeZero);

  635.         BOOL secondVisible = !secondView.hidden && !CGSizeEqualToSize(secondView.intrinsicContentSize, CGSizeZero);

  636.         // Set if both views are visible or if there's a visible view on top that doesn't have padding

  637.         // added relative to the current view yet

  638.         padding.constant = (firstVisible && (secondVisible || hasVisibleAncestors)) ? MBDefaultPadding : 0.f;

  639.         hasVisibleAncestors |= secondVisible;

  640.     }];

  641. }

  642. 

  643. - (void)applyPriority:(UILayoutPriority)priority toConstraints:(NSArray *)constraints {

  644.     for (NSLayoutConstraint *constraint in constraints) {

  645.         constraint.priority = priority;

  646.     }

  647. }

  648. 

  649. #pragma mark - Properties

  650. 

  651. - (void)setMode:(MBProgressHUDMode)mode {

  652.     if (mode != _mode) {

  653.         _mode = mode;

  654.         [self updateIndicators];

  655.     }

  656. }

  657. 

  658. - (void)setCustomView:(UIView *)customView {

  659.     if (customView != _customView) {

  660.         _customView = customView;

  661.         if (self.mode == MBProgressHUDModeCustomView) {

  662.             [self updateIndicators];

  663.         }

  664.     }

  665. }

  666. 

  667. - (void)setOffset:(CGPoint)offset {

  668.     if (!CGPointEqualToPoint(offset, _offset)) {

  669.         _offset = offset;

  670.         [self setNeedsUpdateConstraints];

  671.     }

  672. }

  673. 

  674. - (void)setMargin:(CGFloat)margin {

  675.     if (margin != _margin) {

  676.         _margin = margin;

  677.         [self setNeedsUpdateConstraints];

  678.     }

  679. }

  680. 

  681. - (void)setMinSize:(CGSize)minSize {

  682.     if (!CGSizeEqualToSize(minSize, _minSize)) {

  683.         _minSize = minSize;

  684.         [self setNeedsUpdateConstraints];

  685.     }

  686. }

  687. 

  688. - (void)setSquare:(BOOL)square {

  689.     if (square != _square) {

  690.         _square = square;

  691.         [self setNeedsUpdateConstraints];

  692.     }

  693. }

  694. 

  695. - (void)setProgressObjectDisplayLink:(CADisplayLink *)progressObjectDisplayLink {

  696.     if (progressObjectDisplayLink != _progressObjectDisplayLink) {

  697.         [_progressObjectDisplayLink invalidate];

  698.         

  699.         _progressObjectDisplayLink = progressObjectDisplayLink;

  700.         

  701.         [_progressObjectDisplayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];

  702.     }

  703. }

  704. 

  705. - (void)setProgressObject:(NSProgress *)progressObject {

  706.     if (progressObject != _progressObject) {

  707.         _progressObject = progressObject;

  708.         [self setNSProgressDisplayLinkEnabled:YES];

  709.     }

  710. }

  711. 

  712. - (void)setProgress:(float)progress {

  713.     if (progress != _progress) {

  714.         _progress = progress;

  715.         UIView *indicator = self.indicator;

  716.         if ([indicator respondsToSelector:@selector(setProgress:)]) {

  717.             [(id)indicator setValue:@(self.progress) forKey:@"progress"];

  718.         }

  719.     }

  720. }

  721. 

  722. - (void)setContentColor:(UIColor *)contentColor {

  723.     if (contentColor != _contentColor && ![contentColor isEqual:_contentColor]) {

  724.         _contentColor = contentColor;

  725.         [self updateViewsForColor:contentColor];

  726.     }

  727. }

  728. 

  729. - (void)setDefaultMotionEffectsEnabled:(BOOL)defaultMotionEffectsEnabled {

  730.     if (defaultMotionEffectsEnabled != _defaultMotionEffectsEnabled) {

  731.         _defaultMotionEffectsEnabled = defaultMotionEffectsEnabled;

  732.         [self updateBezelMotionEffects];

  733.     }

  734. }

  735. 

  736. #pragma mark - NSProgress

  737. 

  738. - (void)setNSProgressDisplayLinkEnabled:(BOOL)enabled {

  739.     // We're using CADisplayLink, because NSProgress can change very quickly and observing it may starve the main thread,

  740.     // so we're refreshing the progress only every frame draw

  741.     if (enabled && self.progressObject) {

  742.         // Only create if not already active.

  743.         if (!self.progressObjectDisplayLink) {

  744.             self.progressObjectDisplayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateProgressFromProgressObject)];

  745.         }

  746.     } else {

  747.         self.progressObjectDisplayLink = nil;

  748.     }

  749. }

  750. 

  751. - (void)updateProgressFromProgressObject {

  752.     self.progress = self.progressObject.fractionCompleted;

  753. }

  754. 

  755. #pragma mark - Notifications

  756. 

  757. - (void)registerForNotifications {

  758. #if !TARGET_OS_TV

  759.     NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

  760. 

  761.     [nc addObserver:self selector:@selector(statusBarOrientationDidChange:)

  762.                name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];

  763. #endif

  764. }

  765. 

  766. - (void)unregisterFromNotifications {

  767. #if !TARGET_OS_TV

  768.     NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

  769.     [nc removeObserver:self name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];

  770. #endif

  771. }

  772. 

  773. #if !TARGET_OS_TV

  774. - (void)statusBarOrientationDidChange:(NSNotification *)notification {

  775.     UIView *superview = self.superview;

  776.     if (!superview) {

  777.         return;

  778.     } else {

  779.         [self updateForCurrentOrientationAnimated:YES];

  780.     }

  781. }

  782. #endif

  783. 

  784. - (void)updateForCurrentOrientationAnimated:(BOOL)animated {

  785.     // Stay in sync with the superview in any case

  786.     if (self.superview) {

  787.         self.bounds = self.superview.bounds;

  788.     }

  789. 

  790.     // Not needed on iOS 8+, compile out when the deployment target allows,

  791.     // to avoid sharedApplication problems on extension targets

  792. #if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000

  793.     // Only needed pre iOS 8 when added to a window

  794.     BOOL iOS8OrLater = kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0;

  795.     if (iOS8OrLater || ![self.superview isKindOfClass:[UIWindow class]]) return;

  796. 

  797.     // Make extension friendly. Will not get called on extensions (iOS 8+) due to the above check.

  798.     // This just ensures we don't get a warning about extension-unsafe API.

  799.     Class UIApplicationClass = NSClassFromString(@"UIApplication");

  800.     if (!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) return;

  801. 

  802.     UIApplication *application = [UIApplication performSelector:@selector(sharedApplication)];

  803.     UIInterfaceOrientation orientation = application.statusBarOrientation;

  804.     CGFloat radians = 0;

  805.     

  806.     if (UIInterfaceOrientationIsLandscape(orientation)) {

  807.         radians = orientation == UIInterfaceOrientationLandscapeLeft ? -(CGFloat)M_PI_2 : (CGFloat)M_PI_2;

  808.         // Window coordinates differ!

  809.         self.bounds = CGRectMake(0, 0, self.bounds.size.height, self.bounds.size.width);

  810.     } else {

  811.         radians = orientation == UIInterfaceOrientationPortraitUpsideDown ? (CGFloat)M_PI : 0.f;

  812.     }

  813. 

  814.     if (animated) {

  815.         [UIView animateWithDuration:0.3 animations:^{

  816.             self.transform = CGAffineTransformMakeRotation(radians);

  817.         }];

  818.     } else {

  819.         self.transform = CGAffineTransformMakeRotation(radians);

  820.     }

  821. #endif

  822. }

  823. 

  824. @end

  825. 

  826. 

  827. @implementation MBRoundProgressView

  828. 

  829. #pragma mark - Lifecycle

  830. 

  831. - (id)init {

  832.     return [self initWithFrame:CGRectMake(0.f, 0.f, 37.f, 37.f)];

  833. }

  834. 

  835. - (id)initWithFrame:(CGRect)frame {

  836.     self = [super initWithFrame:frame];

  837.     if (self) {

  838.         self.backgroundColor = [UIColor clearColor];

  839.         self.opaque = NO;

  840.         _progress = 0.f;

  841.         _annular = NO;

  842.         _progressTintColor = [[UIColor alloc] initWithWhite:1.f alpha:1.f];

  843.         _backgroundTintColor = [[UIColor alloc] initWithWhite:1.f alpha:.1f];

  844.     }

  845.     return self;

  846. }

  847. 

  848. #pragma mark - Layout

  849. 

  850. - (CGSize)intrinsicContentSize {

  851.     return CGSizeMake(37.f, 37.f);

  852. }

  853. 

  854. #pragma mark - Properties

  855. 

  856. - (void)setProgress:(float)progress {

  857.     if (progress != _progress) {

  858.         _progress = progress;

  859.         [self setNeedsDisplay];

  860.     }

  861. }

  862. 

  863. - (void)setProgressTintColor:(UIColor *)progressTintColor {

  864.     NSAssert(progressTintColor, @"The color should not be nil.");

  865.     if (progressTintColor != _progressTintColor && ![progressTintColor isEqual:_progressTintColor]) {

  866.         _progressTintColor = progressTintColor;

  867.         [self setNeedsDisplay];

  868.     }

  869. }

  870. 

  871. - (void)setBackgroundTintColor:(UIColor *)backgroundTintColor {

  872.     NSAssert(backgroundTintColor, @"The color should not be nil.");

  873.     if (backgroundTintColor != _backgroundTintColor && ![backgroundTintColor isEqual:_backgroundTintColor]) {

  874.         _backgroundTintColor = backgroundTintColor;

  875.         [self setNeedsDisplay];

  876.     }

  877. }

  878. 

  879. #pragma mark - Drawing

  880. 

  881. - (void)drawRect:(CGRect)rect {

  882.     CGContextRef context = UIGraphicsGetCurrentContext();

  883.     BOOL isPreiOS7 = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;

  884. 

  885.     if (_annular) {

  886.         // Draw background

  887.         CGFloat lineWidth = isPreiOS7 ? 5.f : 2.f;

  888.         UIBezierPath *processBackgroundPath = [UIBezierPath bezierPath];

  889.         processBackgroundPath.lineWidth = lineWidth;

  890.         processBackgroundPath.lineCapStyle = kCGLineCapButt;

  891.         CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));

  892.         CGFloat radius = (self.bounds.size.width - lineWidth)/2;

  893.         CGFloat startAngle = - ((float)M_PI / 2); // 90 degrees

  894.         CGFloat endAngle = (2 * (float)M_PI) + startAngle;

  895.         [processBackgroundPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];

  896.         [_backgroundTintColor set];

  897.         [processBackgroundPath stroke];

  898.         // Draw progress

  899.         UIBezierPath *processPath = [UIBezierPath bezierPath];

  900.         processPath.lineCapStyle = isPreiOS7 ? kCGLineCapRound : kCGLineCapSquare;

  901.         processPath.lineWidth = lineWidth;

  902.         endAngle = (self.progress * 2 * (float)M_PI) + startAngle;

  903.         [processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];

  904.         [_progressTintColor set];

  905.         [processPath stroke];

  906.     } else {

  907.         // Draw background

  908.         CGFloat lineWidth = 2.f;

  909.         CGRect allRect = self.bounds;

  910.         CGRect circleRect = CGRectInset(allRect, lineWidth/2.f, lineWidth/2.f);

  911.         CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));

  912.         [_progressTintColor setStroke];

  913.         [_backgroundTintColor setFill];

  914.         CGContextSetLineWidth(context, lineWidth);

  915.         if (isPreiOS7) {

  916.             CGContextFillEllipseInRect(context, circleRect);

  917.         }

  918.         CGContextStrokeEllipseInRect(context, circleRect);

  919.         // 90 degrees

  920.         CGFloat startAngle = - ((float)M_PI / 2.f);

  921.         // Draw progress

  922.         if (isPreiOS7) {

  923.             CGFloat radius = (CGRectGetWidth(self.bounds) / 2.f) - lineWidth;

  924.             CGFloat endAngle = (self.progress * 2.f * (float)M_PI) + startAngle;

  925.             [_progressTintColor setFill];

  926.             CGContextMoveToPoint(context, center.x, center.y);

  927.             CGContextAddArc(context, center.x, center.y, radius, startAngle, endAngle, 0);

  928.             CGContextClosePath(context);

  929.             CGContextFillPath(context);

  930.         } else {

  931.             UIBezierPath *processPath = [UIBezierPath bezierPath];

  932.             processPath.lineCapStyle = kCGLineCapButt;

  933.             processPath.lineWidth = lineWidth * 2.f;

  934.             CGFloat radius = (CGRectGetWidth(self.bounds) / 2.f) - (processPath.lineWidth / 2.f);

  935.             CGFloat endAngle = (self.progress * 2.f * (float)M_PI) + startAngle;

  936.             [processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];

  937.             // Ensure that we don't get color overlaping when _progressTintColor alpha < 1.f.

  938.             CGContextSetBlendMode(context, kCGBlendModeCopy);

  939.             [_progressTintColor set];

  940.             [processPath stroke];

  941.         }

  942.     }

  943. }

  944. 

  945. @end

  946. 

  947. 

  948. @implementation MBBarProgressView

  949. 

  950. #pragma mark - Lifecycle

  951. 

  952. - (id)init {

  953.     return [self initWithFrame:CGRectMake(.0f, .0f, 120.0f, 20.0f)];

  954. }

  955. 

  956. - (id)initWithFrame:(CGRect)frame {

  957.     self = [super initWithFrame:frame];

  958.     if (self) {

  959.         _progress = 0.f;

  960.         _lineColor = [UIColor whiteColor];

  961.         _progressColor = [UIColor whiteColor];

  962.         _progressRemainingColor = [UIColor clearColor];

  963.         self.backgroundColor = [UIColor clearColor];

  964.         self.opaque = NO;

  965.     }

  966.     return self;

  967. }

  968. 

  969. #pragma mark - Layout

  970. 

  971. - (CGSize)intrinsicContentSize {

  972.     BOOL isPreiOS7 = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0;

  973.     return CGSizeMake(120.f, isPreiOS7 ? 20.f : 10.f);

  974. }

  975. 

  976. #pragma mark - Properties

  977. 

  978. - (void)setProgress:(float)progress {

  979.     if (progress != _progress) {

  980.         _progress = progress;

  981.         [self setNeedsDisplay];

  982.     }

  983. }

  984. 

  985. - (void)setProgressColor:(UIColor *)progressColor {

  986.     NSAssert(progressColor, @"The color should not be nil.");

  987.     if (progressColor != _progressColor && ![progressColor isEqual:_progressColor]) {

  988.         _progressColor = progressColor;

  989.         [self setNeedsDisplay];

  990.     }

  991. }

  992. 

  993. - (void)setProgressRemainingColor:(UIColor *)progressRemainingColor {

  994.     NSAssert(progressRemainingColor, @"The color should not be nil.");

  995.     if (progressRemainingColor != _progressRemainingColor && ![progressRemainingColor isEqual:_progressRemainingColor]) {

  996.         _progressRemainingColor = progressRemainingColor;

  997.         [self setNeedsDisplay];

  998.     }

  999. }

  1000. 

  1001. #pragma mark - Drawing

  1002. 

  1003. - (void)drawRect:(CGRect)rect {

  1004.     CGContextRef context = UIGraphicsGetCurrentContext();

  1005.     

  1006.     CGContextSetLineWidth(context, 2);

  1007.     CGContextSetStrokeColorWithColor(context,[_lineColor CGColor]);

  1008.     CGContextSetFillColorWithColor(context, [_progressRemainingColor CGColor]);

  1009.     

  1010.     // Draw background

  1011.     CGFloat radius = (rect.size.height / 2) - 2;

  1012.     CGContextMoveToPoint(context, 2, rect.size.height/2);

  1013.     CGContextAddArcToPoint(context, 2, 2, radius + 2, 2, radius);

  1014.     CGContextAddLineToPoint(context, rect.size.width - radius - 2, 2);

  1015.     CGContextAddArcToPoint(context, rect.size.width - 2, 2, rect.size.width - 2, rect.size.height / 2, radius);

  1016.     CGContextAddArcToPoint(context, rect.size.width - 2, rect.size.height - 2, rect.size.width - radius - 2, rect.size.height - 2, radius);

  1017.     CGContextAddLineToPoint(context, radius + 2, rect.size.height - 2);

  1018.     CGContextAddArcToPoint(context, 2, rect.size.height - 2, 2, rect.size.height/2, radius);

  1019.     CGContextFillPath(context);

  1020.     

  1021.     // Draw border

  1022.     CGContextMoveToPoint(context, 2, rect.size.height/2);

  1023.     CGContextAddArcToPoint(context, 2, 2, radius + 2, 2, radius);

  1024.     CGContextAddLineToPoint(context, rect.size.width - radius - 2, 2);

  1025.     CGContextAddArcToPoint(context, rect.size.width - 2, 2, rect.size.width - 2, rect.size.height / 2, radius);

  1026.     CGContextAddArcToPoint(context, rect.size.width - 2, rect.size.height - 2, rect.size.width - radius - 2, rect.size.height - 2, radius);

  1027.     CGContextAddLineToPoint(context, radius + 2, rect.size.height - 2);

  1028.     CGContextAddArcToPoint(context, 2, rect.size.height - 2, 2, rect.size.height/2, radius);

  1029.     CGContextStrokePath(context);

  1030.     

  1031.     CGContextSetFillColorWithColor(context, [_progressColor CGColor]);

  1032.     radius = radius - 2;

  1033.     CGFloat amount = self.progress * rect.size.width;

  1034.     

  1035.     // Progress in the middle area

  1036.     if (amount >= radius + 4 && amount <= (rect.size.width - radius - 4)) {

  1037.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1038.         CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);

  1039.         CGContextAddLineToPoint(context, amount, 4);

  1040.         CGContextAddLineToPoint(context, amount, radius + 4);

  1041.         

  1042.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1043.         CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);

  1044.         CGContextAddLineToPoint(context, amount, rect.size.height - 4);

  1045.         CGContextAddLineToPoint(context, amount, radius + 4);

  1046.         

  1047.         CGContextFillPath(context);

  1048.     }

  1049.     

  1050.     // Progress in the right arc

  1051.     else if (amount > radius + 4) {

  1052.         CGFloat x = amount - (rect.size.width - radius - 4);

  1053. 

  1054.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1055.         CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);

  1056.         CGContextAddLineToPoint(context, rect.size.width - radius - 4, 4);

  1057.         CGFloat angle = -acos(x/radius);

  1058.         if (isnan(angle)) angle = 0;

  1059.         CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, M_PI, angle, 0);

  1060.         CGContextAddLineToPoint(context, amount, rect.size.height/2);

  1061. 

  1062.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1063.         CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);

  1064.         CGContextAddLineToPoint(context, rect.size.width - radius - 4, rect.size.height - 4);

  1065.         angle = acos(x/radius);

  1066.         if (isnan(angle)) angle = 0;

  1067.         CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, -M_PI, angle, 1);

  1068.         CGContextAddLineToPoint(context, amount, rect.size.height/2);

  1069.         

  1070.         CGContextFillPath(context);

  1071.     }

  1072.     

  1073.     // Progress is in the left arc

  1074.     else if (amount < radius + 4 && amount > 0) {

  1075.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1076.         CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);

  1077.         CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);

  1078. 

  1079.         CGContextMoveToPoint(context, 4, rect.size.height/2);

  1080.         CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);

  1081.         CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);

  1082.         

  1083.         CGContextFillPath(context);

  1084.     }

  1085. }

  1086. 

  1087. @end

  1088. 

  1089. 

  1090. @interface MBBackgroundView ()

  1091. 

  1092. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV

  1093. @property UIVisualEffectView *effectView;

  1094. #endif

  1095. #if !TARGET_OS_TV

  1096. @property UIToolbar *toolbar;

  1097. #endif

  1098. 

  1099. @end

  1100. 

  1101. 

  1102. @implementation MBBackgroundView

  1103. 

  1104. #pragma mark - Lifecycle

  1105. 

  1106. - (instancetype)initWithFrame:(CGRect)frame {

  1107.     if ((self = [super initWithFrame:frame])) {

  1108.         if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_7_0) {

  1109.             _style = MBProgressHUDBackgroundStyleBlur;

  1110.             if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {

  1111.                 _color = [UIColor colorWithWhite:0.8f alpha:0.6f];

  1112.             } else {

  1113.                 _color = [UIColor colorWithWhite:0.95f alpha:0.6f];

  1114.             }

  1115.         } else {

  1116.             _style = MBProgressHUDBackgroundStyleSolidColor;

  1117.             _color = [[UIColor blackColor] colorWithAlphaComponent:0.8];

  1118.         }

  1119. 

  1120.         self.clipsToBounds = YES;

  1121. 

  1122.         [self updateForBackgroundStyle];

  1123.     }

  1124.     return self;

  1125. }

  1126. 

  1127. #pragma mark - Layout

  1128. 

  1129. - (CGSize)intrinsicContentSize {

  1130.     // Smallest size possible. Content pushes against this.

  1131.     return CGSizeZero;

  1132. }

  1133. 

  1134. #pragma mark - Appearance

  1135. 

  1136. - (void)setStyle:(MBProgressHUDBackgroundStyle)style {

  1137.     if (style == MBProgressHUDBackgroundStyleBlur && kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_7_0) {

  1138.         style = MBProgressHUDBackgroundStyleSolidColor;

  1139.     }

  1140.     if (_style != style) {

  1141.         _style = style;

  1142.         [self updateForBackgroundStyle];

  1143.     }

  1144. }

  1145. 

  1146. - (void)setColor:(UIColor *)color {

  1147.     NSAssert(color, @"The color should not be nil.");

  1148.     if (color != _color && ![color isEqual:_color]) {

  1149.         _color = color;

  1150.         [self updateViewsForColor:color];

  1151.     }

  1152. }

  1153. 

  1154. ///////////////////////////////////////////////////////////////////////////////////////////

  1155. #pragma mark - Views

  1156. 

  1157. - (void)updateForBackgroundStyle {

  1158.     MBProgressHUDBackgroundStyle style = self.style;

  1159.     if (style == MBProgressHUDBackgroundStyleBlur) {

  1160. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV

  1161.         if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {

  1162.             UIBlurEffect *effect = [UIBlurEffect effectWithStyle:UIBlurEffectStyleLight];

  1163.             UIVisualEffectView *effectView = [[UIVisualEffectView alloc] initWithEffect:effect];

  1164.             [self addSubview:effectView];

  1165.             effectView.frame = self.bounds;

  1166.             effectView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;

  1167.             self.backgroundColor = self.color;

  1168.             self.layer.allowsGroupOpacity = NO;

  1169.             self.effectView = effectView;

  1170.         } else {

  1171. #endif

  1172. #if !TARGET_OS_TV

  1173.             UIToolbar *toolbar = [[UIToolbar alloc] initWithFrame:CGRectInset(self.bounds, -100.f, -100.f)];

  1174.             toolbar.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;

  1175.             toolbar.barTintColor = self.color;

  1176.             toolbar.translucent = YES;

  1177.             [self addSubview:toolbar];

  1178.             self.toolbar = toolbar;

  1179. #endif

  1180. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV

  1181.         }

  1182. #endif

  1183.     } else {

  1184. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV

  1185.         if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {

  1186.             [self.effectView removeFromSuperview];

  1187.             self.effectView = nil;

  1188.         } else {

  1189. #endif

  1190. #if !TARGET_OS_TV

  1191.             [self.toolbar removeFromSuperview];

  1192.             self.toolbar = nil;

  1193. #endif

  1194. #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000 || TARGET_OS_TV

  1195.         }

  1196. #endif

  1197.         self.backgroundColor = self.color;

  1198.     }

  1199. }

  1200. 

  1201. - (void)updateViewsForColor:(UIColor *)color {

  1202.     if (self.style == MBProgressHUDBackgroundStyleBlur) {

  1203.         if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0) {

  1204.             self.backgroundColor = self.color;

  1205.         } else {

  1206. #if !TARGET_OS_TV

  1207.             self.toolbar.barTintColor = color;

  1208. #endif

  1209.         }

  1210.     } else {

  1211.         self.backgroundColor = self.color;

  1212.     }

  1213. }

  1214. 

  1215. @end

  1216. 

  1217. 

  1218. @implementation MBProgressHUD (Deprecated)

  1219. 

  1220. #pragma mark - Class

  1221. 

  1222. + (NSUInteger)hideAllHUDsForView:(UIView *)view animated:(BOOL)animated {

  1223.     NSArray *huds = [MBProgressHUD allHUDsForView:view];

  1224.     for (MBProgressHUD *hud in huds) {

  1225.         hud.removeFromSuperViewOnHide = YES;

  1226.         [hud hideAnimated:animated];

  1227.     }

  1228.     return [huds count];

  1229. }

  1230. 

  1231. + (NSArray *)allHUDsForView:(UIView *)view {

  1232.     NSMutableArray *huds = [NSMutableArray array];

  1233.     NSArray *subviews = view.subviews;

  1234.     for (UIView *aView in subviews) {

  1235.         if ([aView isKindOfClass:self]) {

  1236.             [huds addObject:aView];

  1237.         }

  1238.     }

  1239.     return [NSArray arrayWithArray:huds];

  1240. }

  1241. 

  1242. #pragma mark - Lifecycle

  1243. 

  1244. - (id)initWithWindow:(UIWindow *)window {

  1245.     return [self initWithView:window];

  1246. }

  1247. 

  1248. #pragma mark - Show & hide

  1249. 

  1250. - (void)show:(BOOL)animated {

  1251.     [self showAnimated:animated];

  1252. }

  1253. 

  1254. - (void)hide:(BOOL)animated {

  1255.     [self hideAnimated:animated];

  1256. }

  1257. 

  1258. - (void)hide:(BOOL)animated afterDelay:(NSTimeInterval)delay {

  1259.     [self hideAnimated:animated afterDelay:delay];

  1260. }

  1261. 

  1262. #pragma mark - Threading

  1263. 

  1264. - (void)showWhileExecuting:(SEL)method onTarget:(id)target withObject:(id)object animated:(BOOL)animated {

  1265.     [self showAnimated:animated whileExecutingBlock:^{

  1266. #pragma clang diagnostic push

  1267. #pragma clang diagnostic ignored "-Warc-performSelector-leaks"

  1268.         // Start executing the requested task

  1269.         [target performSelector:method withObject:object];

  1270. #pragma clang diagnostic pop

  1271.     }];

  1272. }

  1273. 

  1274. - (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block {

  1275.     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  1276.     [self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:NULL];

  1277. }

  1278. 

  1279. - (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block completionBlock:(void (^)())completion {

  1280.     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  1281.     [self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:completion];

  1282. }

  1283. 

  1284. - (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block onQueue:(dispatch_queue_t)queue {

  1285.     [self showAnimated:animated whileExecutingBlock:block onQueue:queue completionBlock:NULL];

  1286. }

  1287. 

  1288. - (void)showAnimated:(BOOL)animated whileExecutingBlock:(dispatch_block_t)block onQueue:(dispatch_queue_t)queue completionBlock:(nullable MBProgressHUDCompletionBlock)completion {

  1289.     self.taskInProgress = YES;

  1290.     self.completionBlock = completion;

  1291.     dispatch_async(queue, ^(void) {

  1292.         block();

  1293.         dispatch_async(dispatch_get_main_queue(), ^(void) {

  1294.             [self cleanUp];

  1295.         });

  1296.     });

  1297.     [self showAnimated:animated];

  1298. }

  1299. 

  1300. - (void)cleanUp {

  1301.     self.taskInProgress = NO;

  1302.     [self hideAnimated:self.useAnimation];

  1303. }

  1304. 

  1305. #pragma mark - Labels

  1306. 

  1307. - (NSString *)labelText {

  1308.     return self.label.text;

  1309. }

  1310. 

  1311. - (void)setLabelText:(NSString *)labelText {

  1312.     MBMainThreadAssert();

  1313.     self.label.text = labelText;

  1314. }

  1315. 

  1316. - (UIFont *)labelFont {

  1317.     return self.label.font;

  1318. }

  1319. 

  1320. - (void)setLabelFont:(UIFont *)labelFont {

  1321.     MBMainThreadAssert();

  1322.     self.label.font = labelFont;

  1323. }

  1324. 

  1325. - (UIColor *)labelColor {

  1326.     return self.label.textColor;

  1327. }

  1328. 

  1329. - (void)setLabelColor:(UIColor *)labelColor {

  1330.     MBMainThreadAssert();

  1331.     self.label.textColor = labelColor;

  1332. }

  1333. 

  1334. - (NSString *)detailsLabelText {

  1335.     return self.detailsLabel.text;

  1336. }

  1337. 

  1338. - (void)setDetailsLabelText:(NSString *)detailsLabelText {

  1339.     MBMainThreadAssert();

  1340.     self.detailsLabel.text = detailsLabelText;

  1341. }

  1342. 

  1343. - (UIFont *)detailsLabelFont {

  1344.     return self.detailsLabel.font;

  1345. }

  1346. 

  1347. - (void)setDetailsLabelFont:(UIFont *)detailsLabelFont {

  1348.     MBMainThreadAssert();

  1349.     self.detailsLabel.font = detailsLabelFont;

  1350. }

  1351. 

  1352. - (UIColor *)detailsLabelColor {

  1353.     return self.detailsLabel.textColor;

  1354. }

  1355. 

  1356. - (void)setDetailsLabelColor:(UIColor *)detailsLabelColor {

  1357.     MBMainThreadAssert();

  1358.     self.detailsLabel.textColor = detailsLabelColor;

  1359. }

  1360. 

  1361. - (CGFloat)opacity {

  1362.     return _opacity;

  1363. }

  1364. 

  1365. - (void)setOpacity:(CGFloat)opacity {

  1366.     MBMainThreadAssert();

  1367.     _opacity = opacity;

  1368. }

  1369. 

  1370. - (UIColor *)color {

  1371.     return self.bezelView.color;

  1372. }

  1373. 

  1374. - (void)setColor:(UIColor *)color {

  1375.     MBMainThreadAssert();

  1376.     self.bezelView.color = color;

  1377. }

  1378. 

  1379. - (CGFloat)yOffset {

  1380.     return self.offset.y;

  1381. }

  1382. 

  1383. - (void)setYOffset:(CGFloat)yOffset {

  1384.     MBMainThreadAssert();

  1385.     self.offset = CGPointMake(self.offset.x, yOffset);

  1386. }

  1387. 

  1388. - (CGFloat)xOffset {

  1389.     return self.offset.x;

  1390. }

  1391. 

  1392. - (void)setXOffset:(CGFloat)xOffset {

  1393.     MBMainThreadAssert();

  1394.     self.offset = CGPointMake(xOffset, self.offset.y);

  1395. }

  1396. 

  1397. - (CGFloat)cornerRadius {

  1398.     return self.bezelView.layer.cornerRadius;

  1399. }

  1400. 

  1401. - (void)setCornerRadius:(CGFloat)cornerRadius {

  1402.     MBMainThreadAssert();

  1403.     self.bezelView.layer.cornerRadius = cornerRadius;

  1404. }

  1405. 

  1406. - (BOOL)dimBackground {

  1407.     MBBackgroundView *backgroundView = self.backgroundView;

  1408.     UIColor *dimmedColor =  [UIColor colorWithWhite:0.f alpha:.2f];

  1409.     return backgroundView.style == MBProgressHUDBackgroundStyleSolidColor && [backgroundView.color isEqual:dimmedColor];

  1410. }

  1411. 

  1412. - (void)setDimBackground:(BOOL)dimBackground {

  1413.     MBMainThreadAssert();

  1414.     self.backgroundView.style = MBProgressHUDBackgroundStyleSolidColor;

  1415.     self.backgroundView.color = dimBackground ? [UIColor colorWithWhite:0.f alpha:.2f] : [UIColor clearColor];

  1416. }

  1417. 

  1418. - (CGSize)size {

  1419.     return self.bezelView.frame.size;

  1420. }

  1421. 

  1422. - (UIColor *)activityIndicatorColor {

  1423.     return _activityIndicatorColor;

  1424. }

  1425. 

  1426. - (void)setActivityIndicatorColor:(UIColor *)activityIndicatorColor {

  1427.     if (activityIndicatorColor != _activityIndicatorColor) {

  1428.         _activityIndicatorColor = activityIndicatorColor;

  1429.         UIActivityIndicatorView *indicator = (UIActivityIndicatorView *)self.indicator;

  1430.         if ([indicator isKindOfClass:[UIActivityIndicatorView class]]) {

  1431.             [indicator setColor:activityIndicatorColor];

  1432.         }

  1433.     }

  1434. }

  1435. 

  1436. @end

  1437. 

  1438. @implementation MBProgressHUDRoundedButton

  1439. 

  1440. #pragma mark - Lifecycle

  1441. 

  1442. - (instancetype)initWithFrame:(CGRect)frame {

  1443.     self = [super initWithFrame:frame];

  1444.     if (self) {

  1445.         CALayer *layer = self.layer;

  1446.         layer.borderWidth = 1.f;

  1447.     }

  1448.     return self;

  1449. }

  1450. 

  1451. #pragma mark - Layout

  1452. 

  1453. - (void)layoutSubviews {

  1454.     [super layoutSubviews];

  1455.     // Fully rounded corners

  1456.     CGFloat height = CGRectGetHeight(self.bounds);

  1457.     self.layer.cornerRadius = ceil(height / 2.f);

  1458. }

  1459. 

  1460. - (CGSize)intrinsicContentSize {

  1461.     // Only show if we have associated control events

  1462.     if (self.allControlEvents == 0) return CGSizeZero;

  1463.     CGSize size = [super intrinsicContentSize];

  1464.     // Add some side padding

  1465.     size.width += 20.f;

  1466.     return size;

  1467. }

  1468. 

  1469. #pragma mark - Color

  1470. 

  1471. - (void)setTitleColor:(UIColor *)color forState:(UIControlState)state {

  1472.     [super setTitleColor:color forState:state];

  1473.     // Update related colors

  1474.     [self setHighlighted:self.highlighted];

  1475.     self.layer.borderColor = color.CGColor;

  1476. }

  1477. 

  1478. - (void)setHighlighted:(BOOL)highlighted {

  1479.     [super setHighlighted:highlighted];

  1480.     UIColor *baseColor = [self titleColorForState:UIControlStateSelected];

  1481.     self.backgroundColor = highlighted ? [baseColor colorWithAlphaComponent:0.1f] : [UIColor clearColor];

  1482. }

  1483. 

  1484. @end