Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[TIMOB-26113] iOS: Prioritize ti.ui.defaultunit over other dimensions #10101

Closed
wants to merge 4 commits into from
Closed

[TIMOB-26113] iOS: Prioritize ti.ui.defaultunit over other dimensions #10101

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
255d1c8
Fix ti.ui.defaultunit handling
hansemannn Jun 12, 2018
afdac61
Format code in Layout/
hansemannn Jun 12, 2018
e7b0cf1
Calculate scale automatically
hansemannn Jun 12, 2018
10ade4d
Merge branch 'master' into TIMOB-26113
hansemannn Jun 12, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
250 changes: 119 additions & 131 deletions iphone/Classes/Layout/TiLayoutDimension.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,21 +6,21 @@
*/

#ifdef TI_USE_AUTOLAYOUT
#include <math.h>
#include <Foundation/Foundation.h>
#include <UIKit/UIKit.h>
#include <math.h>

extern NSString* const kTiBehaviorSize;
extern NSString* const kTiBehaviorFill;
extern NSString* const kTiBehaviorAuto;
extern NSString* const kTiUnitPixel;
extern NSString* const kTiUnitCm;
extern NSString* const kTiUnitMm;
extern NSString* const kTiUnitInch;
extern NSString* const kTiUnitDip;
extern NSString* const kTiUnitDipAlternate;
extern NSString* const kTiUnitSystem;
extern NSString* const kTiUnitPercent;
extern NSString *const kTiBehaviorSize;
extern NSString *const kTiBehaviorFill;
extern NSString *const kTiBehaviorAuto;
extern NSString *const kTiUnitPixel;
extern NSString *const kTiUnitCm;
extern NSString *const kTiUnitMm;
extern NSString *const kTiUnitInch;
extern NSString *const kTiUnitDip;
extern NSString *const kTiUnitDipAlternate;
extern NSString *const kTiUnitSystem;
extern NSString *const kTiUnitPercent;

#define INCH_IN_CM 2.54
#define INCH_IN_MM 25.4
Expand All @@ -30,22 +30,22 @@ extern NSString* const kTiUnitPercent;
//Not a class for speed reasons, like LayoutConstraint.

typedef enum {
TiDimensionTypeUndefined,
TiDimensionTypeDip,
TiDimensionTypeAuto,
TiDimensionTypeAutoSize,
TiDimensionTypeAutoFill,
TiDimensionTypePercent,
TiDimensionTypeUndefined,
TiDimensionTypeDip,
TiDimensionTypeAuto,
TiDimensionTypeAutoSize,
TiDimensionTypeAutoFill,
TiDimensionTypePercent,
} TiDimensionType;

/**
The dimension struct.
*/
struct TiDimension {
TiDimensionType type;
CGFloat value;
//If type is TiDimensionTypeDip, value is a Dip constant,
//If type is TiDimensionTypePercent, value ranges from 0 (0%) to 1.0 (100%)
TiDimensionType type;
CGFloat value;
// If type is TiDimensionTypeDip, value is a Dip constant,
// If type is TiDimensionTypePercent, value ranges from 0 (0%) to 1.0 (100%)
};

typedef struct TiDimension TiDimension;
Expand All @@ -66,190 +66,178 @@ CGFloat convertDipToPixels(CGFloat value);

TI_INLINE TiDimension TiDimensionDip(CGFloat value)
{
return TiDimensionMake(TiDimensionTypeDip,value);
return TiDimensionMake(TiDimensionTypeDip, value);
}

TI_INLINE bool TiDimensionIsPercent(TiDimension dimension)
{
return dimension.type == TiDimensionTypePercent;
return dimension.type == TiDimensionTypePercent;
}

TI_INLINE bool TiDimensionIsAuto(TiDimension dimension)
{
return dimension.type == TiDimensionTypeAuto;
return dimension.type == TiDimensionTypeAuto;
}

TI_INLINE bool TiDimensionIsAutoSize(TiDimension dimension)
{
return dimension.type == TiDimensionTypeAutoSize;
return dimension.type == TiDimensionTypeAutoSize;
}

TI_INLINE bool TiDimensionIsAutoFill(TiDimension dimension)
{
return dimension.type == TiDimensionTypeAutoFill;
return dimension.type == TiDimensionTypeAutoFill;
}

TI_INLINE bool TiDimensionIsDip(TiDimension dimension)
{
return dimension.type == TiDimensionTypeDip;
return dimension.type == TiDimensionTypeDip;
}

TI_INLINE bool TiDimensionIsUndefined(TiDimension dimension)
{
return dimension.type == TiDimensionTypeUndefined;
return dimension.type == TiDimensionTypeUndefined;
}

TI_INLINE bool TiDimensionEqual(TiDimension dimension1, TiDimension dimension2)
{
if (dimension1.type != dimension2.type)
{
return false;
}
if (TiDimensionIsDip(dimension1) || TiDimensionIsPercent(dimension1)) {
return dimension1.value == dimension2.value;
}
return true;
if (dimension1.type != dimension2.type) {
return false;
}
if (TiDimensionIsDip(dimension1) || TiDimensionIsPercent(dimension1)) {
return dimension1.value == dimension2.value;
}
return true;
}


TI_INLINE BOOL TiDimensionDidCalculateValue(TiDimension dimension,CGFloat boundingValue,CGFloat * result)
TI_INLINE BOOL TiDimensionDidCalculateValue(TiDimension dimension, CGFloat boundingValue, CGFloat *result)
{
switch (dimension.type)
{
case TiDimensionTypeDip:
*result = dimension.value;
return YES;
case TiDimensionTypePercent:
*result = roundf(dimension.value * boundingValue);
return YES;
default: {
break;
}
}
return NO;
switch (dimension.type) {
case TiDimensionTypeDip:
*result = dimension.value;
return YES;
case TiDimensionTypePercent:
*result = roundf(dimension.value * boundingValue);
return YES;
default: {
break;
}
}
return NO;
}

TI_INLINE CGFloat TiDimensionCalculateValue(TiDimension dimension,CGFloat boundingValue)
TI_INLINE CGFloat TiDimensionCalculateValue(TiDimension dimension, CGFloat boundingValue)
{
CGFloat result;
if(TiDimensionDidCalculateValue(dimension,boundingValue,&result))
{
return result;
}
return 0.0;
CGFloat result;
if (TiDimensionDidCalculateValue(dimension, boundingValue, &result)) {
return result;
}
return 0.0;
}

TI_INLINE CGFloat TiDimensionCalculateRatio(TiDimension dimension,CGFloat boundingValue)
TI_INLINE CGFloat TiDimensionCalculateRatio(TiDimension dimension, CGFloat boundingValue)
{
switch (dimension.type)
{
case TiDimensionTypePercent:
return dimension.value;
case TiDimensionTypeDip:
return dimension.value / boundingValue;
default: {
break;
}
}
return 0.0;
switch (dimension.type) {
case TiDimensionTypePercent:
return dimension.value;
case TiDimensionTypeDip:
return dimension.value / boundingValue;
default: {
break;
}
}
return 0.0;
}

TI_INLINE CGFloat TiDimensionCalculateMargins(TiDimension dimension1, TiDimension dimension2, CGFloat boundingValue)
{
return boundingValue - (TiDimensionCalculateValue(dimension1, boundingValue) + TiDimensionCalculateValue(dimension2, boundingValue));
return boundingValue - (TiDimensionCalculateValue(dimension1, boundingValue) + TiDimensionCalculateValue(dimension2, boundingValue));
}

//TODO: Do these ALL have to be TI_INLINE?
TI_INLINE CGRect TiDimensionLayerContentCenter(TiDimension top, TiDimension left, TiDimension bottom, TiDimension right, CGSize imageSize)
{
CGRect result;
result.origin.y = TiDimensionCalculateRatio(top,imageSize.height);
result.size.height = 1.0 - TiDimensionCalculateRatio(bottom,imageSize.height) - result.origin.y;
result.origin.x = TiDimensionCalculateRatio(left,imageSize.width);
result.size.width = 1.0 - TiDimensionCalculateRatio(right,imageSize.width) - result.origin.x;
CGRect result;
result.origin.y = TiDimensionCalculateRatio(top, imageSize.height);
result.size.height = 1.0 - TiDimensionCalculateRatio(bottom, imageSize.height) - result.origin.y;
result.origin.x = TiDimensionCalculateRatio(left, imageSize.width);
result.size.width = 1.0 - TiDimensionCalculateRatio(right, imageSize.width) - result.origin.x;

return result;
return result;
}



typedef enum {
TiLayoutRuleAbsolute,
TiLayoutRuleVertical,
TiLayoutRuleHorizontal,
TiLayoutRuleAbsolute,
TiLayoutRuleVertical,
TiLayoutRuleHorizontal,
} TiLayoutRule;

struct TiLayoutConstraint {

BOOL centerX_isSet;
BOOL left_isSet;
BOOL right_isSet;
BOOL width_isSet;

BOOL centerY_isSet;
BOOL top_isSet;
BOOL bottom_isSet;
BOOL height_isSet;

TiDimension centerX;
TiDimension left;
TiDimension right;
TiDimension width;

TiDimension centerY;
TiDimension top;
TiDimension bottom;
TiDimension height;

TiLayoutRule layoutStyle;
struct {
unsigned int horizontalWrap:1;
} layoutFlags;

CGFloat minimumHeight;
CGFloat minimumWidth;


BOOL centerX_isSet;
BOOL left_isSet;
BOOL right_isSet;
BOOL width_isSet;

BOOL centerY_isSet;
BOOL top_isSet;
BOOL bottom_isSet;
BOOL height_isSet;

TiDimension centerX;
TiDimension left;
TiDimension right;
TiDimension width;

TiDimension centerY;
TiDimension top;
TiDimension bottom;
TiDimension height;

TiLayoutRule layoutStyle;
struct {
unsigned int horizontalWrap : 1;
} layoutFlags;

CGFloat minimumHeight;
CGFloat minimumWidth;
};

typedef struct TiLayoutConstraint TiLayoutConstraint;


TI_INLINE CGFloat TiFixedValueRuleFromObject(id value)
{
if([value respondsToSelector:@selector(floatValue)]) {
return [value floatValue];
}
return 0;
if ([value respondsToSelector:@selector(floatValue)]) {
return [value floatValue];
}
return 0;
}

TI_INLINE TiLayoutRule TiLayoutRuleFromObject(id object)
{
if ([object isKindOfClass:[NSString class]])
{
if ([object caseInsensitiveCompare:@"vertical"]==NSOrderedSame)
{
return TiLayoutRuleVertical;
}
if ([object caseInsensitiveCompare:@"horizontal"]==NSOrderedSame)
{
return TiLayoutRuleHorizontal;
}
if ([object isKindOfClass:[NSString class]]) {
if ([object caseInsensitiveCompare:@"vertical"] == NSOrderedSame) {
return TiLayoutRuleVertical;
}
if ([object caseInsensitiveCompare:@"horizontal"] == NSOrderedSame) {
return TiLayoutRuleHorizontal;
}
return TiLayoutRuleAbsolute;
}
return TiLayoutRuleAbsolute;
}

TI_INLINE BOOL TiLayoutRuleIsAbsolute(TiLayoutRule rule)
{
return rule==TiLayoutRuleAbsolute;
return rule == TiLayoutRuleAbsolute;
}

TI_INLINE BOOL TiLayoutRuleIsVertical(TiLayoutRule rule)
{
return rule==TiLayoutRuleVertical;
return rule == TiLayoutRuleVertical;
}

TI_INLINE BOOL TiLayoutRuleIsHorizontal(TiLayoutRule rule)
{
return rule==TiLayoutRuleHorizontal;
return rule == TiLayoutRuleHorizontal;
}
#endif
Loading