| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #import "WXRichText.h" |
| #import "WXSDKManager.h" |
| #import "WXSDKEngine.h" |
| #import "WXConvert.h" |
| #import "WXSDKInstance.h" |
| #import "WXComponent+Layout.h" |
| #import "WXNavigationProtocol.h" |
| #import "WXImgLoaderProtocol.h" |
| #import "WXComponentManager.h" |
| #import "WXLog.h" |
| #import "WXDarkThemeProtocol.h" |
| #include <pthread/pthread.h> |
| |
| @interface WXRichNode : NSObject |
| |
| @property (nonatomic, strong) NSString *type; |
| @property (nonatomic, strong) NSString *ref; |
| @property (nonatomic, strong) NSString *text; |
| @property (nonatomic, strong) UIColor *color; |
| @property (nonatomic, strong) UIColor *darkThemeColor; |
| @property (nonatomic, strong) UIColor *backgroundColor; |
| @property (nonatomic, strong) UIColor *darkThemeBackgroundColor; |
| @property (nonatomic, strong) NSString *fontFamily; |
| @property (nonatomic, assign) CGFloat fontSize; |
| @property (nonatomic, assign) CGFloat fontWeight; |
| @property (nonatomic, assign) WXTextStyle fontStyle; |
| @property (nonatomic, assign) WXTextDecoration textDecoration; |
| @property (nonatomic, strong) NSString *pseudoRef; |
| @property (nonatomic, assign) CGFloat width; |
| @property (nonatomic, assign) CGFloat height; |
| @property (nonatomic, strong) NSURL *href; |
| @property (nonatomic, strong) NSURL *src; |
| @property (nonatomic, assign) NSRange range; |
| @property (nonatomic, strong) NSMutableArray *childNodes; |
| |
| @end |
| |
| @implementation WXRichNode |
| - (instancetype)init |
| { |
| if (self = [super init]) { |
| _childNodes = [[NSMutableArray alloc] init]; |
| } |
| return self; |
| } |
| |
| @end |
| |
| @interface WXRichTextView : UITextView |
| |
| @end |
| |
| @implementation WXRichTextView |
| |
| - (instancetype)initWithFrame:(CGRect)frame |
| { |
| if ((self = [super initWithFrame:frame])) { |
| self.isAccessibilityElement = YES; |
| self.accessibilityTraits |= UIAccessibilityTraitStaticText; |
| self.opaque = NO; |
| self.editable = NO; |
| self.selectable = YES; |
| self.contentMode = UIViewContentModeRedraw; |
| self.textContainerInset = UIEdgeInsetsZero; |
| self.textContainer.lineFragmentPadding = 0.0f; |
| self.textContainer.lineBreakMode = NSLineBreakByClipping; |
| } |
| return self; |
| } |
| |
| @end |
| |
| #define WX_STYLE_FILL_RICHTEXT(key, type)\ |
| do {\ |
| id value = styles[@#key]; \ |
| if (value) { \ |
| node.key = [WXConvert type:value];\ |
| } else if (!([@#key isEqualToString:@"backgroundColor"] || \ |
| [@#key isEqualToString:@"darkThemeBackgroundColor"] || \ |
| [@#key isEqualToString:@"textDecoration"]) && superNode.key ) { \ |
| node.key = superNode.key; \ |
| } \ |
| } while(0); |
| |
| #define WX_STYLE_FILL_RICHTEXT_PIXEL(key)\ |
| do {\ |
| id value = styles[@#key];\ |
| if (value) {\ |
| node.key = [WXConvert WXPixelType:value scaleFactor:self.weexInstance.pixelScaleFactor];\ |
| } else if (superNode.key ) { \ |
| node.key = superNode.key; \ |
| } \ |
| } while(0); |
| |
| |
| @implementation WXRichText |
| { |
| WXRichTextView *textView; |
| NSMutableArray *_richNodes; |
| NSMutableDictionary *_nodeRanges; |
| NSMutableDictionary *_styles; |
| NSMutableDictionary *_attributes; |
| NSTextAlignment _textAlign; |
| UIColor *_backgroundColor; |
| pthread_mutex_t _attributedStringMutex; |
| pthread_mutexattr_t _propertMutexAttr; |
| CGFloat _lineHeight; |
| } |
| |
| - (void)dealloc |
| { |
| pthread_mutex_destroy(&_attributedStringMutex); |
| pthread_mutexattr_destroy(&_propertMutexAttr); |
| } |
| |
| - (WXRichTextView *)textView |
| { |
| if (!textView) { |
| textView = [[WXRichTextView alloc]init]; |
| textView.delegate = self; |
| textView.scrollEnabled = NO; |
| } |
| return textView; |
| } |
| |
| - (instancetype)initWithRef:(NSString *)ref |
| type:(NSString *)type |
| styles:(NSDictionary *)styles |
| attributes:(NSDictionary *)attributes |
| events:(NSArray *)events |
| weexInstance:(WXSDKInstance *)weexInstance |
| { |
| self = [super initWithRef:ref type:type styles:styles attributes:attributes events:events weexInstance:weexInstance]; |
| if (self) { |
| _richNodes = [NSMutableArray new]; |
| _nodeRanges = [NSMutableDictionary new]; |
| _styles = [NSMutableDictionary dictionaryWithDictionary:styles]; |
| _attributes = [NSMutableDictionary dictionaryWithDictionary:attributes]; |
| _textAlign = styles[@"textAlign"] ? [WXConvert NSTextAlignment:styles[@"textAlign"]] : NSTextAlignmentLeft; |
| _lineHeight = styles[@"lineHeight"] ? [WXConvert CGFloat:styles[@"lineHeight"]] / 2: 0; |
| pthread_mutexattr_init(&(_propertMutexAttr)); |
| pthread_mutexattr_settype(&(_propertMutexAttr), PTHREAD_MUTEX_RECURSIVE); |
| pthread_mutex_init(&(_attributedStringMutex), &(_propertMutexAttr)); |
| } |
| return self; |
| } |
| |
| - (void)fillAttributes:(NSDictionary *)attributes |
| { |
| id value = attributes[@"value"]; |
| if (!value) { |
| return; |
| } |
| if ([value isKindOfClass:[NSString class]]) { |
| value = [WXUtility objectFromJSON:value]; |
| } |
| if ([value isKindOfClass: [NSArray class]]) { |
| [_richNodes removeAllObjects]; |
| |
| WXRichNode *rootNode = [[WXRichNode alloc]init]; |
| [_richNodes addObject:rootNode]; |
| |
| rootNode.type = @"root"; |
| if (_styles) { |
| [self fillCSSStyles:_styles toNode:rootNode superNode:nil]; |
| } |
| |
| for (NSDictionary *dict in value) { |
| [self recursivelyAddChildNode:dict toSuperNode:rootNode]; |
| } |
| |
| _backgroundColor = rootNode.backgroundColor?:[UIColor whiteColor]; |
| } |
| } |
| |
| - (void)fillCSSStyles:(NSDictionary *)styles toNode:(WXRichNode *)node superNode:(WXRichNode *)superNode |
| { |
| WX_STYLE_FILL_RICHTEXT(color, UIColor) |
| WX_STYLE_FILL_RICHTEXT(darkThemeColor, UIColor) |
| WX_STYLE_FILL_RICHTEXT(backgroundColor, UIColor) |
| WX_STYLE_FILL_RICHTEXT(darkThemeBackgroundColor, UIColor) |
| WX_STYLE_FILL_RICHTEXT(fontFamily, NSString) |
| WX_STYLE_FILL_RICHTEXT_PIXEL(fontSize) |
| WX_STYLE_FILL_RICHTEXT(fontWeight, WXTextWeight) |
| WX_STYLE_FILL_RICHTEXT(fontStyle, WXTextStyle) |
| WX_STYLE_FILL_RICHTEXT(textDecoration, WXTextDecoration) |
| WX_STYLE_FILL_RICHTEXT_PIXEL(width) |
| WX_STYLE_FILL_RICHTEXT_PIXEL(height) |
| } |
| |
| - (void)fillAttributes:(NSDictionary *)attributes toNode:(WXRichNode *)node superNode:(WXRichNode *)superNode |
| { |
| if (attributes[@"pseudoRef"]) { |
| node.pseudoRef = attributes[@"pseudoRef"]; |
| node.href = [NSURL URLWithString:@"click://"]; |
| } |
| |
| if (attributes[@"href"]) { |
| node.href = [NSURL URLWithString:attributes[@"href"]]; |
| } |
| else if (superNode.href) { |
| node.href = superNode.href; |
| if (!(node.pseudoRef.length) && superNode.pseudoRef.length) { |
| node.pseudoRef = superNode.pseudoRef; |
| } |
| } |
| |
| if (attributes[@"src"]) { |
| node.src = [NSURL URLWithString:attributes[@"src"]]; |
| } |
| |
| if (attributes[@"value"] ) { |
| id value = attributes[@"value"]; |
| if ([value isKindOfClass:[NSString class]]) { |
| node.text = (NSString *)value; |
| } |
| } |
| } |
| |
| - (void)recursivelyAddChildNode:(NSDictionary *)nodeValue toSuperNode:(WXRichNode *)superNode |
| { |
| if (![nodeValue isKindOfClass:[NSDictionary class]]) { |
| WXLogError(@"Invalid rich text structure."); |
| return; |
| } |
| |
| if (![nodeValue[@"type"] isKindOfClass:[NSString class]]) { |
| WXLogError(@"Invalid rich text structure."); |
| return; |
| } |
| |
| WXRichNode *node = [[WXRichNode alloc]init]; |
| [_richNodes addObject:node]; |
| |
| node.type = nodeValue[@"type"]; |
| |
| [self fillCSSStyles:nodeValue[@"style"] toNode:node superNode:superNode]; |
| |
| if (nodeValue[@"attr"]) { |
| [self fillAttributes:nodeValue[@"attr"] toNode:node superNode:superNode]; |
| } |
| |
| if (nodeValue[@"children"]) { |
| id value = nodeValue[@"children"]; |
| if ([value isKindOfClass:[NSArray class]]) { |
| NSArray *children = (NSArray *)value; |
| for(NSDictionary *childValue in children){ |
| [self recursivelyAddChildNode:childValue toSuperNode:node]; |
| } |
| } |
| } |
| } |
| |
| - (WXRichNode*)findRichNode:(NSString*)ref { |
| NSMutableArray *array = [NSMutableArray arrayWithArray:_richNodes]; |
| for (WXRichNode* node in array) { |
| if ([node.ref isEqualToString:ref]) { |
| return node; |
| } |
| } |
| return nil; |
| } |
| |
| - (NSInteger)indexOfRichNode:(WXRichNode*)node { |
| NSInteger index = -1; |
| NSMutableArray *array = [NSMutableArray arrayWithArray:_richNodes]; |
| for (WXRichNode* item in array) { |
| if ([item.ref isEqualToString:node.ref]) { |
| return index+1; |
| } |
| index++; |
| } |
| return index; |
| } |
| |
| - (void)removeChildNode:(NSString*)ref superNodeRef:(NSString *)superNodeRef { |
| WXRichNode* node = [self findRichNode:ref]; |
| WXRichNode* superNode = [self findRichNode:@"_root"]; |
| if (superNodeRef.length > 0) { |
| superNode = [self findRichNode:superNodeRef]; |
| } |
| if (superNode) { |
| [superNode.childNodes removeObject:node]; |
| } |
| [_richNodes removeObject:node]; |
| [self setNeedsLayout]; |
| [self innerLayout]; |
| } |
| |
| - (void)addChildNode:(NSString *)type ref:(NSString*)ref styles:(NSDictionary*)styles attributes:(NSDictionary*)attributes toSuperNodeRef:(NSString *)superNodeRef { |
| if ([_richNodes count] == 0) { |
| WXRichNode *rootNode = [[WXRichNode alloc]init]; |
| [_richNodes addObject:rootNode]; |
| rootNode.type = @"root"; |
| rootNode.ref = @"_root"; |
| if (_styles) { |
| [self fillCSSStyles:_styles toNode:rootNode superNode:nil]; |
| } |
| _backgroundColor = rootNode.backgroundColor?:[UIColor whiteColor]; |
| } |
| |
| WXRichNode* superNode = [self findRichNode:@"_root"]; |
| if (superNodeRef.length > 0) { |
| superNode = [self findRichNode:superNodeRef]; |
| } |
| |
| WXRichNode *node = [[WXRichNode alloc]init]; |
| node.ref = ref; |
| NSInteger index = [self indexOfRichNode:superNode]; |
| if (index < 0) { |
| return; |
| } |
| if (index == 0) { |
| [_richNodes addObject:node]; |
| } else { |
| [_richNodes insertObject:node atIndex:(index + superNode.childNodes.count + 1)]; |
| } |
| [superNode.childNodes addObject:node]; |
| node.type = type; |
| |
| [self fillCSSStyles:styles toNode:node superNode:superNode]; |
| [self fillAttributes:attributes toNode:node superNode:superNode]; |
| [self setNeedsLayout]; |
| [self innerLayout]; |
| } |
| |
| #pragma mark - Subclass |
| |
| - (UIView *)loadView |
| { |
| return [self textView]; |
| } |
| |
| - (void)viewDidUnload |
| { |
| textView = nil; |
| } |
| |
| - (void)viewDidLoad |
| { |
| [self innerLayout]; |
| } |
| |
| - (void)layoutDidFinish |
| { |
| [self innerLayout]; |
| } |
| |
| - (void)innerLayout |
| { |
| __weak typeof(self) wself = self; |
| WXPerformBlockOnComponentThread(^{ |
| __strong typeof(wself) sself = wself; |
| if (sself) { |
| if (sself.flexCssNode == nullptr) { |
| return; |
| } |
| UIEdgeInsets padding = { |
| WXFloorPixelValue(sself.flexCssNode->getPaddingTop()+sself.flexCssNode->getBorderWidthTop()), |
| WXFloorPixelValue(sself.flexCssNode->getPaddingLeft()+sself.flexCssNode->getBorderWidthLeft()), |
| WXFloorPixelValue(sself.flexCssNode->getPaddingBottom()+sself.flexCssNode->getBorderWidthBottom()), |
| WXFloorPixelValue(sself.flexCssNode->getPaddingRight()+sself.flexCssNode->getBorderWidthRight()) |
| }; |
| |
| NSMutableAttributedString* attrString = [sself buildAttributeString]; |
| WXPerformBlockOnMainThread(^{ |
| WXRichTextView* view = [sself textView]; |
| view.attributedText = attrString; |
| view.textContainerInset = padding; |
| view.backgroundColor = [UIColor clearColor]; |
| }); |
| } |
| }); |
| } |
| |
| - (CGSize (^)(CGSize))measureBlock |
| { |
| __weak typeof(self) weakSelf = self; |
| |
| return ^CGSize (CGSize constrainedSize) { |
| |
| NSMutableAttributedString *attributedString = [weakSelf buildAttributeString]; |
| |
| CGFloat width = constrainedSize.width; |
| if (isnan(width)) { |
| width = CGFLOAT_MAX; |
| } |
| |
| CGRect rect = [attributedString boundingRectWithSize:CGSizeMake(width, CGFLOAT_MAX) options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading context:nil]; |
| CGSize computedSize = rect.size; |
| if(weakSelf.flexCssNode != nullptr){ |
| if (!isnan(weakSelf.flexCssNode->getMinWidth())) { |
| computedSize.width = MAX(computedSize.width, weakSelf.flexCssNode->getMinWidth()); |
| } |
| if (!isnan(weakSelf.flexCssNode->getMaxWidth())) { |
| computedSize.width = MIN(computedSize.width, weakSelf.flexCssNode->getMaxWidth()); |
| } |
| if (!isnan(weakSelf.flexCssNode->getMinHeight())) { |
| computedSize.width = MAX(computedSize.height, weakSelf.flexCssNode->getMinHeight()); |
| } |
| if (!isnan(weakSelf.flexCssNode->getMaxHeight())) { |
| computedSize.width = MIN(computedSize.height, weakSelf.flexCssNode->getMaxHeight()); |
| } |
| } |
| return (CGSize) { |
| WXCeilPixelValue(computedSize.width), |
| WXCeilPixelValue(computedSize.height) |
| }; |
| }; |
| } |
| |
| - (void)themeDidChange:(NSString*)theme |
| { |
| [super themeDidChange:theme]; |
| if ([self isViewLoaded]) { |
| // Force inner layout |
| [self innerLayout]; |
| } |
| } |
| |
| #pragma mark Text Building |
| |
| - (NSMutableAttributedString *)buildAttributeString |
| { |
| pthread_mutex_lock(&(_attributedStringMutex)); |
| [self fillAttributes:_attributes]; |
| NSMutableArray *array = [NSMutableArray arrayWithArray:_richNodes]; |
| pthread_mutex_unlock(&(_attributedStringMutex)); |
| |
| NSMutableDictionary *nodeRange = [NSMutableDictionary dictionary]; |
| NSMutableAttributedString *attrStr = [[NSMutableAttributedString alloc] init]; |
| NSUInteger location; |
| |
| BOOL invert = self.invertForDarkTheme; |
| |
| // Invert default background color. |
| UIColor* defaultTextColor = [UIColor blackColor]; |
| UIColor* defaultBackgroundColor = _backgroundColor; |
| if (invert && [self.weexInstance isDarkTheme]) { |
| defaultTextColor = [[WXSDKInstance darkThemeColorHandler] getInvertedColorFor:[UIColor blackColor] ofScene:[self colorSceneType] withDefault:[UIColor blackColor]]; |
| defaultBackgroundColor = [[WXSDKInstance darkThemeColorHandler] getInvertedColorFor:_backgroundColor ofScene:[self colorSceneType] withDefault:_backgroundColor]; |
| } |
| |
| __weak typeof(self) weakSelf = self; |
| for (WXRichNode *node in array) { |
| location = attrStr.length; |
| |
| if ([node.type isEqualToString:@"span"]) { |
| if (node.text && [node.text length] > 0) { |
| NSString *text = node.text; |
| [attrStr.mutableString appendString:text]; |
| |
| NSRange range = NSMakeRange(location, text.length); |
| UIColor* textColor = [self.weexInstance chooseColor:node.color darkThemeColor:node.darkThemeColor invert:invert scene:[self colorSceneType]]; |
| UIColor* bgColor = [self.weexInstance chooseColor:node.backgroundColor darkThemeColor:node.darkThemeBackgroundColor invert:invert scene:[self colorSceneType]]; |
| [attrStr addAttribute:NSForegroundColorAttributeName value:textColor ?: defaultTextColor range:range]; |
| [attrStr addAttribute:NSBackgroundColorAttributeName value:bgColor ?: defaultBackgroundColor range:range]; |
| |
| UIFont *font = [WXUtility fontWithSize:node.fontSize textWeight:node.fontWeight textStyle:WXTextStyleNormal fontFamily:node.fontFamily scaleFactor:self.weexInstance.pixelScaleFactor]; |
| if (font) { |
| [attrStr addAttribute:NSFontAttributeName value:font range:range]; |
| } |
| if (node.fontStyle == WXTextStyleItalic) { |
| [attrStr addAttribute:NSObliquenessAttributeName value:@0.3 range:range]; |
| } |
| else |
| { |
| [attrStr addAttribute:NSObliquenessAttributeName value:@0 range:range]; |
| } |
| [attrStr addAttribute:NSUnderlineStyleAttributeName value:[NSNumber numberWithInteger:WXTextDecorationNone] range:range]; |
| [attrStr addAttribute:NSStrikethroughStyleAttributeName value:[NSNumber numberWithInteger:WXTextDecorationNone] range:range]; |
| |
| if (node.textDecoration == WXTextDecorationUnderline) { |
| [attrStr addAttribute:NSUnderlineStyleAttributeName value:[NSNumber numberWithInteger:WXTextDecorationUnderline] range:range]; |
| } |
| else if (node.textDecoration == WXTextDecorationLineThrough) { |
| [attrStr addAttribute:NSStrikethroughStyleAttributeName value:[NSNumber numberWithInteger:WXTextDecorationLineThrough] range:range]; |
| } |
| |
| if (node.href) { |
| [attrStr addAttribute:NSLinkAttributeName value:node.href range:range]; |
| } |
| else { |
| [attrStr removeAttribute:NSLinkAttributeName range:range]; |
| } |
| |
| NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init]; |
| paragraphStyle.alignment = _textAlign; |
| if(_lineHeight != 0 ) |
| { |
| paragraphStyle.minimumLineHeight = _lineHeight; |
| paragraphStyle.maximumLineHeight = _lineHeight; |
| [attrStr addAttribute:NSBaselineOffsetAttributeName value:@((_lineHeight - font.lineHeight)/2) range:range]; |
| } |
| [attrStr addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:range]; |
| |
| [nodeRange setObject:node forKey:NSStringFromRange(range)]; |
| } |
| } |
| else if ([node.type isEqualToString:@"image"]) { |
| NSTextAttachment *imgAttachment = [[NSTextAttachment alloc]init]; |
| imgAttachment.bounds = CGRectMake(0, 0, node.width, node.height); |
| |
| NSAttributedString *attachAttriStr = [NSAttributedString attributedStringWithAttachment:imgAttachment]; |
| [attrStr appendAttributedString:attachAttriStr]; |
| |
| NSRange range = NSMakeRange(location, attachAttriStr.length); |
| [attrStr addAttribute:NSFontAttributeName value: [UIFont systemFontOfSize:node.height] range:range]; |
| |
| if (node.href) { |
| [attrStr addAttribute:NSLinkAttributeName value:node.href range:range]; |
| } |
| else { |
| [attrStr removeAttribute:NSLinkAttributeName range:range]; |
| } |
| |
| [nodeRange setObject:node forKey:NSStringFromRange(range)]; |
| |
| if (node.src) { |
| [[self imageLoader] downloadImageWithURL:node.src.absoluteString imageFrame:imgAttachment.bounds userInfo:nil completed:^(UIImage *image, NSError *error, BOOL finished) { |
| dispatch_async(dispatch_get_main_queue(), ^{ |
| imgAttachment.image = image; |
| [[weakSelf textView].layoutManager invalidateDisplayForCharacterRange:range]; |
| }); |
| }]; |
| } |
| } |
| } |
| |
| pthread_mutex_lock(&(_attributedStringMutex)); |
| [_nodeRanges removeAllObjects]; |
| _nodeRanges = [NSMutableDictionary dictionaryWithDictionary:nodeRange]; |
| pthread_mutex_unlock(&(_attributedStringMutex)); |
| |
| return attrStr; |
| } |
| |
| - (void)updateStyles:(NSDictionary *)styles { |
| |
| if (styles[@"textAlign"]) { |
| _textAlign = [WXConvert NSTextAlignment:styles[@"textAlign"]]; |
| } |
| if (styles[@"lineHeight"]) { |
| _lineHeight = [WXConvert CGFloat:styles[@"lineHeight"]] / 2; |
| } |
| |
| WXPerformBlockOnComponentThread(^{ |
| [_styles addEntriesFromDictionary:styles]; |
| [self syncTextStorageForView]; |
| }); |
| } |
| |
| - (void)updateChildNodeStyles:(NSDictionary *)styles ref:(NSString*)ref parentRef:(NSString*)parentRef { |
| WXPerformBlockOnComponentThread(^{ |
| WXRichNode* node = [self findRichNode:ref]; |
| if (node) { |
| WXRichNode* superNode = [self findRichNode:@"_root"]; |
| if (parentRef.length > 0) { |
| superNode = [self findRichNode:parentRef]; |
| } |
| if (superNode) { |
| [self fillCSSStyles:styles toNode:node superNode:superNode]; |
| [self syncTextStorageForView]; |
| } |
| } |
| }); |
| } |
| |
| - (void)updateAttributes:(NSDictionary *)attributes { |
| WXPerformBlockOnComponentThread(^{ |
| _attributes = [NSMutableDictionary dictionaryWithDictionary:attributes]; |
| [self syncTextStorageForView]; |
| }); |
| } |
| |
| - (void)updateChildNodeAttributes:(NSDictionary *)attributes ref:(NSString*)ref parentRef:(NSString*)parentRef { |
| WXPerformBlockOnComponentThread(^{ |
| WXRichNode* node = [self findRichNode:ref]; |
| if (node) { |
| WXRichNode* superNode = [self findRichNode:@"_root"]; |
| if (parentRef.length > 0) { |
| superNode = [self findRichNode:parentRef]; |
| } |
| if (superNode) { |
| [self fillAttributes:attributes toNode:node superNode:superNode]; |
| [self syncTextStorageForView]; |
| } |
| } |
| }); |
| } |
| |
| - (void)syncTextStorageForView { |
| pthread_mutex_lock(&(_attributedStringMutex)); |
| [self fillAttributes:_attributes]; |
| pthread_mutex_unlock(&(_attributedStringMutex)); |
| |
| if (_styles[@"height"]) { |
| [self innerLayout]; |
| } |
| else { |
| [self setNeedsLayout]; |
| } |
| } |
| |
| #pragma mark - UITextView Delegate |
| |
| - (BOOL)textView:(UITextView *)textView shouldInteractWithTextAttachment:(NSTextAttachment *)textAttachment inRange:(NSRange)characterRange { |
| return NO; |
| } |
| |
| - (BOOL)textView:(UITextView *)textView shouldInteractWithURL:(NSURL *)URL inRange:(NSRange)characterRange { |
| if (!URL) { |
| return NO; |
| } |
| |
| NSString *rangeStr = NSStringFromRange(characterRange); |
| WXRichNode *node = [_nodeRanges objectForKey:rangeStr]; |
| |
| if (![[node.href absoluteString] isEqualToString:@"click://"]) { |
| id<WXNavigationProtocol> navigationHandler = [self navigationHandler]; |
| if ([navigationHandler respondsToSelector:@selector(pushViewControllerWithParam: |
| completion: |
| withContainer:)]) { |
| [navigationHandler pushViewControllerWithParam:@{@"url":URL.absoluteString} completion:^(NSString *code, NSDictionary *responseData) { |
| } withContainer:self.weexInstance.viewController]; |
| } else { |
| WXLogError(@"Event handler of class %@ does not respond to pushViewControllerWithParam", NSStringFromClass([navigationHandler class])); |
| } |
| } |
| else if (node.pseudoRef) { |
| NSMutableDictionary *params = [NSMutableDictionary new]; |
| [params setObject:node.pseudoRef forKey:@"pseudoRef"]; |
| [[WXSDKManager bridgeMgr] fireEvent:self.weexInstance.instanceId ref:self.ref type:@"itemclick" params:params domChanges:nil]; |
| } |
| |
| return NO; |
| } |
| |
| # pragma mark - imageLoader |
| |
| - (id<WXImgLoaderProtocol>)imageLoader { |
| static id<WXImgLoaderProtocol> imageLoader; |
| static dispatch_once_t onceToken; |
| dispatch_once(&onceToken, ^{ |
| imageLoader = [WXSDKEngine handlerForProtocol:@protocol(WXImgLoaderProtocol)]; |
| }); |
| return imageLoader; |
| } |
| |
| - (id<WXNavigationProtocol>)navigationHandler { |
| static id<WXNavigationProtocol> navigationHandler; |
| static dispatch_once_t onceToken; |
| dispatch_once(&onceToken, ^{ |
| navigationHandler = [WXSDKEngine handlerForProtocol:@protocol(WXNavigationProtocol)]; |
| }); |
| return navigationHandler; |
| } |
| |
| @end |
