react-native-external-keyboard 0.8.5 → 0.9.1

package/ios/Services/RNCEKVOrderLinking.mm

@@ -11,8 +11,8 @@
 #import "RNCEKVOrderRelationship.h"
 
 @implementation RNCEKVOrderLinking {
-  NSMutableDictionary *_relationships;
-  NSMapTable *_weakMap;
+  NSMutableDictionary<NSString *, RNCEKVOrderRelationship *> *_relationships;
+  NSMapTable<NSString *, UIView *> *_weakMap;
 }
 
 + (instancetype)sharedInstance {
@@ -24,82 +24,74 @@
   return sharedInstance;
 }
 
-- (RNCEKVOrderRelationship*)getInfo:(NSString*)orderGroup {
-  RNCEKVOrderRelationship* relationship = [_relationships objectForKey: orderGroup];
-  return relationship;
-}
-
 - (id)init {
   if (self = [super init]) {
     _relationships = [NSMutableDictionary dictionary];
     _weakMap = [NSMapTable strongToWeakObjectsMapTable];
   }
-  
   return self;
 }
 
-- (void)add:(NSNumber*)position withOrderKey:(NSString*)orderKey withObject:(NSObject*)obj {
-  RNCEKVOrderRelationship* relationship = [_relationships objectForKey: orderKey];
-  if(relationship == nil) {
+- (RNCEKVOrderRelationship *)getInfo:(NSString *)orderGroup {
+  return _relationships[orderGroup];
+}
+
+- (RNCEKVOrderRelationship *)relationshipForKey:(NSString *)orderKey {
+  RNCEKVOrderRelationship *relationship = _relationships[orderKey];
+  if (relationship == nil) {
     relationship = [[RNCEKVOrderRelationship alloc] init];
-    [_relationships setObject: relationship forKey:orderKey];
+    _relationships[orderKey] = relationship;
   }
-  [relationship add:position withObject:obj];
+  return relationship;
 }
 
--(void)remove:(NSNumber*)position withOrderKey:(NSString*)orderKey {
-  RNCEKVOrderRelationship* relationship = [_relationships objectForKey: orderKey];
-  if(relationship != nil) {
-    [relationship remove:position];
-    if([relationship isEmpty]) {
-      [relationship clear];
-      [_relationships removeObjectForKey: orderKey];
-    }
+- (void)removeRelationshipIfEmpty:(RNCEKVOrderRelationship *)relationship forKey:(NSString *)orderKey {
+  if ([relationship isEmpty]) {
+    [relationship clear];
+    [_relationships removeObjectForKey:orderKey];
   }
 }
 
-- (void)update:(NSNumber*)position lastPosition:(NSNumber*)lastPosition withOrderKey:(NSString*)orderKey withView:(UIView*) view {
-  RNCEKVOrderRelationship* relationship = [_relationships objectForKey: orderKey];
-  if(relationship != nil) {
-    [relationship update:lastPosition withPosition:position withObject:view];
-  }
+- (void)add:(NSNumber *)position withOrderKey:(NSString *)orderKey withObject:(NSObject *)obj {
+  [[self relationshipForKey:orderKey] add:position withObject:obj];
 }
 
-- (void)updateOrderKey:(NSString*)prev next:(NSString*)next position:(NSNumber*)position withView:(UIView*) view {
-  if(prev != nil) {
-    RNCEKVOrderRelationship* relationship = [_relationships objectForKey: prev];
-    if(relationship != nil) {
-      [relationship remove: position];
-    }
-    
-    if([relationship isEmpty]) {
-      [relationship clear];
-      [_relationships removeObjectForKey: prev];
+- (void)remove:(NSNumber *)position withOrderKey:(NSString *)orderKey {
+  RNCEKVOrderRelationship *relationship = _relationships[orderKey];
+  if (relationship == nil) return;
+  [relationship remove:position];
+  [self removeRelationshipIfEmpty:relationship forKey:orderKey];
+}
+
+- (void)update:(NSNumber *)position lastPosition:(NSNumber *)lastPosition withOrderKey:(NSString *)orderKey withView:(UIView *)view {
+  [_relationships[orderKey] update:lastPosition withPosition:position withObject:view];
+}
+
+- (void)updateOrderKey:(NSString *)prev next:(NSString *)next position:(NSNumber *)position withView:(UIView *)view {
+  if (prev != nil) {
+    RNCEKVOrderRelationship *relationship = _relationships[prev];
+    if (relationship != nil) {
+      [relationship remove:position];
+      [self removeRelationshipIfEmpty:relationship forKey:prev];
     }
   }
-  
-  if(next != nil) {
-    RNCEKVOrderRelationship* newRelationship = [_relationships objectForKey: next];
-    if(newRelationship == nil) {
-      newRelationship = [[RNCEKVOrderRelationship alloc] init];
-      [_relationships setObject: newRelationship forKey:next];
-    }
-    [newRelationship add:position withObject:view];
+
+  if (next != nil) {
+    [[self relationshipForKey:next] add:position withObject:view];
   }
 }
 
-- (void)storeOrderId:(NSString*)orderId withView:(UIView*) view {
+- (void)storeOrderId:(NSString *)orderId withView:(UIView *)view {
   [_weakMap setObject:view forKey:orderId];
 }
 
-- (UIView*)getOrderView:(NSString*)orderId {
-  UIView *view = [_weakMap objectForKey:orderId];
-  return view;
-};
+- (UIView *)getOrderView:(NSString *)orderId {
+  return [_weakMap objectForKey:orderId];
+}
 
-- (void)cleanOrderId:(NSString*)orderId {
+- (void)cleanOrderId:(NSString *)orderId {
   [_weakMap removeObjectForKey:orderId];
-};
+}
 
 
 

package/ios/Views/Base/ContextMenu/RNCEKVViewContextMenuBase.h

@@ -0,0 +1,33 @@
+//
+//  RNCEKVViewContextMenuBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewContextMenuBase_h
+#define RNCEKVViewContextMenuBase_h
+
+
+#import "RNCEKVViewFocusChangeBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewContextMenuBase : RNCEKVViewFocusChangeBase<UIContextMenuInteractionDelegate>
+
+@property (nonatomic, assign) BOOL enableContextMenu;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateContextMenuProps:(const RNCEKV::ContextMenuProps &)oldProps
+newProps:(const RNCEKV::ContextMenuProps &)newProps;
+#endif
+
+- (void)onContextMenuPressHandler;
+- (void)onBubbledContextMenuPressHandler;
+
+@end
+
+
+#endif /* RNCEKVViewContextMenuBase_h */

package/ios/Views/Base/ContextMenu/RNCEKVViewContextMenuBase.mm

@@ -0,0 +1,84 @@
+//
+//  RNCEKVViewContextMenuBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+
+
+
+#import "RNCEKVViewContextMenuBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#import "RNCEKVFabricEventHelper.h"
+#endif
+
+@implementation RNCEKVViewContextMenuBase {
+  UIContextMenuInteraction *_contextMenuInteraction;
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  _enableContextMenu = false;
+  [self updateContextMenuRegistration];
+}
+
+- (void)setEnableContextMenu:(BOOL)enableContextMenu {
+  _enableContextMenu = enableContextMenu;
+  [self updateContextMenuRegistration];
+}
+
+- (void)updateContextMenuRegistration {
+  if (@available(iOS 13.0, *)) {
+    BOOL shouldRegister = _enableContextMenu &&
+    self.isKeyboardFocused;
+    
+    if (shouldRegister && _contextMenuInteraction == nil) {
+      _contextMenuInteraction =
+      [[UIContextMenuInteraction alloc] initWithDelegate:self];
+      [self addInteraction:_contextMenuInteraction];
+    }
+    
+    if (!shouldRegister && _contextMenuInteraction != nil) {
+      [self removeInteraction:_contextMenuInteraction];
+      _contextMenuInteraction = nil;
+    }
+  }
+}
+
+- (void)onFocusChangeHandler:(BOOL)isFocused {
+  [super onFocusChangeHandler: isFocused];
+  [self updateContextMenuRegistration];
+}
+
+- (UIContextMenuConfiguration *)contextMenuInteraction:
+(UIContextMenuInteraction *)interaction
+                        configurationForMenuAtLocation:(CGPoint)location
+API_AVAILABLE(ios(13.0)) {
+  if (self.isKeyboardFocused) {
+    [self onContextMenuPressHandler];
+    [self onBubbledContextMenuPressHandler];
+  }
+
+  return nil;
+}
+
+- (void)onContextMenuPressHandler {}
+- (void)onBubbledContextMenuPressHandler {}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateContextMenuProps:(const RNCEKV::ContextMenuProps &)oldProps
+newProps:(const RNCEKV::ContextMenuProps &)newProps {
+  if (oldProps.enableContextMenu != newProps.enableContextMenu) {
+    [self setEnableContextMenu: newProps.enableContextMenu];
+    [self updateContextMenuRegistration];
+  }
+}
+
+#endif
+
+
+@end

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.h

@@ -0,0 +1,37 @@
+//
+//  RNCEKVViewFocusChangeBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#ifndef RNCEKVViewFocusChangeBase_h
+#define RNCEKVViewFocusChangeBase_h
+
+#import "RNCEKVViewGroupIdentifierBase.h"
+#import "RNCEKVFocusDelegate.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewFocusChangeBase : RNCEKVViewGroupIdentifierBase<RNCEKVFocusProtocol>
+
+@property BOOL canBeFocused;
+@property BOOL hasOnFocusChanged;
+@property (nonatomic, assign, readonly) BOOL isKeyboardFocused;
+
+
+@property (nonatomic, strong, readonly) RNCEKVFocusDelegate* focusDelegate;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusProps:(const RNCEKV::FocusProps &)oldProps
+newProps:(const RNCEKV::FocusProps &)newProps;
+#endif
+
+- (void)onFocusChangeHandler:(BOOL)isFocused;
+
+@end
+
+
+#endif /* RNCEKVViewFocusChangeBase_h */

package/ios/Views/Base/FocusChange/RNCEKVViewFocusChangeBase.mm

@@ -0,0 +1,89 @@
+//
+//  RNCEKVViewFocusChangeBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 09/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+
+
+#import "RNCEKVViewFocusChangeBase.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNCEKVNativeProps.h"
+#import "RNCEKVFabricEventHelper.h"
+#endif
+//#import "RNCEKVFocusDelegate.h"
+
+@implementation RNCEKVViewFocusChangeBase {
+  NSNumber* _isFocused;
+}
+
+- (BOOL)isGroup {
+  return false;
+}
+
+- (BOOL)isKeyboardFocused {
+  return [_isFocused isEqual:@YES];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _focusDelegate = [[RNCEKVFocusDelegate alloc] initWithView:self];
+    _isFocused = nil;
+  }
+  
+  return self;
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  _isFocused = nil;
+  _canBeFocused = false;
+  _hasOnFocusChanged = false;
+}
+
+- (UIView *)getFocusTargetView {
+  return [_focusDelegate getFocusingView];
+}
+
+
+- (BOOL)canBecomeFocused {
+  if (!_canBeFocused)
+    NO;
+  return [_focusDelegate canBecomeFocused];
+}
+
+
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator {
+  _isFocused = [_focusDelegate isFocusChanged:context];
+
+  if ([self hasOnFocusChanged]) {
+    if (_isFocused != nil) {
+      [self onFocusChangeHandler:[_isFocused isEqual:@YES]];
+    }
+  }
+
+  [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+}
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusProps:(const RNCEKV::FocusProps &)oldProps
+                          newProps:(const RNCEKV::FocusProps &)newProps {
+  if (_canBeFocused != newProps.canBeFocused) {
+    [self setCanBeFocused:newProps.canBeFocused];
+  }
+  
+  if (_hasOnFocusChanged != newProps.hasOnFocusChanged) {
+    [self setHasOnFocusChanged:newProps.hasOnFocusChanged];
+  }
+}
+
+#endif
+
+- (void)onFocusChangeHandler:(BOOL)isFocused {}
+
+@end

package/ios/Views/Base/FocusOrderGroup/RNCEKVViewOrderGroupBase.h

@@ -0,0 +1,49 @@
+//
+//  RNCEKVViewOrderGroupBase.h
+//  Pods
+//
+//  Created by Artur Kalach on 07/04/2026.
+//
+
+#ifndef RNCEKVViewOrderGroupBase_h
+#define RNCEKVViewOrderGroupBase_h
+
+#import <UIKit/UIKit.h>
+#import "RNCEKVViewGroupBase.h"
+#import "RNCEKVFocusOrderProtocol.h"
+#import "RNCEKVFocusSequenceDelegate.h"
+#import "RNCEKVFocusLinkDelegate.h"
+#import "RNCEKVKeyboardFocusableProtocol.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "RNCEKVNativeProps.h"
+#endif
+
+@interface RNCEKVViewOrderGroupBase : RNCEKVViewGroupBase <RNCEKVFocusOrderProtocol, RNCEKVKeyboardFocusableProtocol>
+
+- (void)cleanReferences;
+
+@property (nonatomic, strong) NSString* orderGroup;
+@property (nonatomic, strong) NSNumber* lockFocus;
+@property (nonatomic, strong) NSNumber* orderPosition;
+@property (nonatomic, strong) NSString* orderLeft;
+@property (nonatomic, strong) NSString* orderRight;
+@property (nonatomic, strong) NSString* orderUp;
+@property (nonatomic, strong) NSString* orderDown;
+@property (nonatomic, strong) NSString* orderForward;
+@property (nonatomic, strong) NSString* orderBackward;
+@property (nonatomic, strong) NSString* orderLast;
+@property (nonatomic, strong) NSString* orderFirst;
+@property (nonatomic, strong) NSString* orderId;
+
+@property (nonatomic, strong, readonly) RNCEKVFocusSequenceDelegate* sequenceDelegate;
+@property (nonatomic, strong, readonly) RNCEKVFocusLinkDelegate* linkDelegate;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusOrderProps:(const RNCEKV::OrderProps &)oldProps
+                     newProps:(const RNCEKV::OrderProps &)newProps;
+#endif
+
+@end
+
+#endif /* RNCEKVViewOrderGroupBase_h */

package/ios/Views/Base/FocusOrderGroup/RNCEKVViewOrderGroupBase.mm

@@ -0,0 +1,245 @@
+//
+//  RNCEKVViewOrderGroupBase.m
+//  react-native-external-keyboard
+//
+//  Created by Artur Kalach on 07/04/2026.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNCEKVViewOrderGroupBase.h"
+#import "RNCEKVOrderLinking.h"
+#import "UIViewController+RNCEKVExternalKeyboard.h"
+#import "UIView+React.h"
+#import "RNCEKVPropHelper.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "RNCEKVNativeProps.h"
+#import "RNCEKVPropHelper.h"
+#endif
+
+@interface RNCEKVViewOrderGroupBase ()
+@property (nonatomic, strong, readwrite) RNCEKVFocusSequenceDelegate* sequenceDelegate;
+@property (nonatomic, strong, readwrite) RNCEKVFocusLinkDelegate* linkDelegate;
+@end
+
+@implementation RNCEKVViewOrderGroupBase
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _sequenceDelegate = [[RNCEKVFocusSequenceDelegate alloc] initWithView:self];
+    _linkDelegate = [[RNCEKVFocusLinkDelegate alloc] initWithView:self];
+  }
+  return self;
+}
+
+- (BOOL)getIsViewFocused:(UIFocusUpdateContext *)context {
+  return context.nextFocusedView == [self getStoredView];
+}
+
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator {
+  [_linkDelegate setIsFocused:[self getIsViewFocused:context]];
+  [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+}
+
+- (void)focus {
+  UIViewController *controller = self.reactViewController;
+  BOOL isAttached = self.superview != nil && controller != nil;
+
+  if (isAttached) {
+    [controller rncekvFocusView:[self getStoredView]];
+  }
+}
+
+- (void)cleanReferences {
+  [super cleanReferences];
+  [_sequenceDelegate unlink];
+  [_linkDelegate unlink];
+
+  _orderGroup = nil;
+  _orderPosition = nil;
+  _orderLeft = nil;
+  _orderRight = nil;
+  _orderUp = nil;
+  _orderDown = nil;
+  _orderForward = nil;
+  _orderBackward = nil;
+  _orderLast = nil;
+  _orderFirst = nil;
+  _orderId = nil;
+  _lockFocus = nil;
+}
+
+- (UIView *)getFocusTargetView {
+  return [self getStoredView];
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  if (self.window) {
+    [_sequenceDelegate link];
+    [_linkDelegate link];
+  } else {
+    [_sequenceDelegate unlink];
+    [_linkDelegate unlink];
+  }
+}
+
+- (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context {
+    BOOL hasLinkConfig = _lockFocus != nil
+    || _orderId != nil
+    || _orderLeft != nil || _orderRight != nil
+    || _orderUp != nil   || _orderDown != nil
+    || _orderForward != nil || _orderBackward != nil
+    || _orderFirst != nil   || _orderLast != nil;
+
+  if (hasLinkConfig) {
+    NSNumber *linkResult = [_linkDelegate shouldUpdateFocusInContext:context];
+    if (linkResult != nil) return linkResult.boolValue;
+  }
+
+  BOOL hasSequenceConfig = _orderGroup != nil && _orderPosition != nil;
+
+  if (hasSequenceConfig) {
+    NSNumber *sequenceResult = [_sequenceDelegate shouldUpdateFocusInContext:context];
+    if (sequenceResult != nil) return sequenceResult.boolValue;
+  }
+
+  return [super shouldUpdateFocusInContext:context];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)updateFocusOrderProps:(const RNCEKV::OrderProps &)oldViewProps
+                     newProps:(const RNCEKV::OrderProps &)newViewProps {
+  NSNumber* lockFocus = [RNCEKVPropHelper unwrapIntValue: newViewProps.lockFocus];
+  if (![_lockFocus isEqual: lockFocus]) {
+    [self setLockFocus: lockFocus];
+  }
+
+  NSNumber* position = [RNCEKVPropHelper unwrapIntValue: newViewProps.orderIndex];
+  if (![_orderPosition isEqual: position]) {
+    [self setOrderPosition: position];
+  }
+
+  NSString* orderGroup = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderGroup];
+  if (![_orderGroup isEqual: orderGroup]) {
+    [self setOrderGroup: orderGroup];
+  }
+
+  NSString* orderId = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderId];
+  if (![_orderId isEqual: orderId]) {
+    [self setOrderId: orderId];
+  }
+
+  NSString* orderLeft = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderLeft];
+  if (![_orderLeft isEqual: orderLeft]) {
+    [self setOrderLeft: orderLeft];
+  }
+
+  NSString* orderRight = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderRight];
+  if (![_orderRight isEqual: orderRight]) {
+    [self setOrderRight: orderRight];
+  }
+
+  NSString* orderUp = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderUp];
+  if (![_orderUp isEqual: orderUp]) {
+    [self setOrderUp: orderUp];
+  }
+
+  NSString* orderDown = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderDown];
+  if (![_orderDown isEqual: orderDown]) {
+    [self setOrderDown: orderDown];
+  }
+
+  NSString* orderForward = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderForward];
+  if (![_orderForward isEqual: orderForward]) {
+    [self setOrderForward: orderForward];
+  }
+
+  NSString* orderBackward = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderBackward];
+  if (![_orderBackward isEqual: orderBackward]) {
+    [self setOrderBackward: orderBackward];
+  }
+
+  NSString* orderLast = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderLast];
+  if (![_orderLast isEqual: orderLast]) {
+    [self setOrderLast: orderLast];
+  }
+
+  NSString* orderFirst = [RNCEKVPropHelper unwrapStringValue: newViewProps.orderFirst];
+  if (![_orderFirst isEqual: orderFirst]) {
+    [self setOrderFirst: orderFirst];
+  }
+}
+#endif
+
+- (void)setLockFocus:(NSNumber *)lockFocus {
+  if ([_lockFocus isEqual:lockFocus]) return;
+  _lockFocus = lockFocus;
+}
+
+- (void)setOrderGroup:(NSString *)orderGroup {
+  if ([_orderGroup isEqual:orderGroup]) return;
+  [_sequenceDelegate updateOrderGroup:orderGroup];
+  _orderGroup = orderGroup;
+}
+
+- (void)setOrderPosition:(NSNumber *)position {
+  NSNumber *newPosition = [position intValue] == -1 ? nil : position;
+  if ([_orderPosition isEqual:newPosition]) return;
+  [_sequenceDelegate updatePosition:newPosition];
+  _orderPosition = newPosition;
+}
+
+- (void)setOrderId:(NSString *)orderId {
+  if ([_orderId isEqual:orderId]) return;
+  [_linkDelegate refreshId:_orderId next:orderId];
+  _orderId = orderId;
+}
+
+- (void)setOrderLeft:(NSString *)orderLeft {
+  if ([_orderLeft isEqual:orderLeft]) return;
+  [_linkDelegate refreshLeft:orderLeft];
+  _orderLeft = orderLeft;
+}
+
+- (void)setOrderRight:(NSString *)orderRight {
+  if ([_orderRight isEqual:orderRight]) return;
+  [_linkDelegate refreshRight:orderRight];
+  _orderRight = orderRight;
+}
+
+- (void)setOrderUp:(NSString *)orderUp {
+  if ([_orderUp isEqual:orderUp]) return;
+  [_linkDelegate refreshUp:orderUp];
+  _orderUp = orderUp;
+}
+
+- (void)setOrderDown:(NSString *)orderDown {
+  if ([_orderDown isEqual:orderDown]) return;
+  [_linkDelegate refreshDown:orderDown];
+  _orderDown = orderDown;
+}
+
+- (void)setOrderForward:(NSString *)orderForward {
+  if ([_orderForward isEqual:orderForward]) return;
+  _orderForward = orderForward;
+}
+
+- (void)setOrderBackward:(NSString *)orderBackward {
+  if ([_orderBackward isEqual:orderBackward]) return;
+  _orderBackward = orderBackward;
+}
+
+- (void)setOrderFirst:(NSString *)orderFirst {
+  if ([_orderFirst isEqual:orderFirst]) return;
+  _orderFirst = orderFirst;
+}
+
+- (void)setOrderLast:(NSString *)orderLast {
+  if ([_orderLast isEqual:orderLast]) return;
+  _orderLast = orderLast;
+}
+
+@end