LearnWithTouch/App/LearnWithTouch_ios/Classes/UI/Keyboard.mm

862 lines
27 KiB
Plaintext
Raw Permalink Normal View History

2019-07-01 14:33:21 +02:00
#include "Keyboard.h"
#include "DisplayManager.h"
#include "UnityAppController.h"
#include "UnityForwardDecls.h"
#include <string>
#ifndef FILTER_EMOJIS_IOS_KEYBOARD
#define FILTER_EMOJIS_IOS_KEYBOARD 0
#endif
static KeyboardDelegate* _keyboard = nil;
static bool _shouldHideInput = false;
static bool _shouldHideInputChanged = false;
static const unsigned kToolBarHeight = 40;
static const unsigned kSystemButtonsSpace = 2 * 60 + 3 * 18; // empirical value, there is no way to know the exact widths of the system bar buttons
@implementation KeyboardDelegate
{
// UI handling
// in case of single line we use UITextField inside UIToolbar
// in case of multi-line input we use UITextView with UIToolbar as accessory view
// toolbar buttons are kept around to prevent releasing them
// tvOS does not support multiline input thus only UITextField option is implemented
#if PLATFORM_IOS
UITextView* textView;
UIToolbar* viewToolbar;
NSArray* viewToolbarItems;
NSLayoutConstraint* widthConstraint;
#endif
UITextField* textField;
// keep toolbar items for both single- and multi- line edit in NSArray to make sure they are kept around
#if PLATFORM_IOS
UIToolbar* fieldToolbar;
NSArray* fieldToolbarItems;
#endif
// inputView is view used for actual input (it will be responder): UITextField [single-line] or UITextView [multi-line]
// editView is the "root" view for keyboard: UIToolbar [single-line] or UITextView [multi-line]
UIView* inputView;
UIView* editView;
KeyboardShowParam cachedKeyboardParam;
CGRect _area;
NSString* initialText;
UIKeyboardType keyboardType;
BOOL _multiline;
BOOL _inputHidden;
BOOL _active;
KeyboardStatus _status;
int _characterLimit;
// not pretty but seems like easiest way to keep "we are rotating" status
BOOL _rotating;
}
@synthesize area;
@synthesize active = _active;
@synthesize status = _status;
@synthesize text;
@synthesize selection;
- (BOOL)textFieldShouldReturn:(UITextField*)textFieldObj
{
[self textInputDone: nil];
return YES;
}
- (void)textInputDone:(id)sender
{
if (_status == Visible)
_status = Done;
[self hide];
}
- (void)textInputCancel:(id)sender
{
_status = Canceled;
[self hide];
}
- (void)textInputLostFocus
{
if (_status == Visible)
_status = LostFocus;
[self hide];
}
- (BOOL)textViewShouldBeginEditing:(UITextView*)view
{
#if !PLATFORM_TVOS
view.inputAccessoryView = viewToolbar;
#endif
return YES;
}
#if PLATFORM_IOS
- (void)keyboardWillShow:(NSNotification *)notification
{
if (notification.userInfo == nil || inputView == nil)
return;
CGRect srcRect = [[notification.userInfo objectForKey: UIKeyboardFrameEndUserInfoKey] CGRectValue];
CGRect rect = [UnityGetGLView() convertRect: srcRect fromView: nil];
rect.origin.y = [UnityGetGLView() frame].size.height - rect.size.height; // iPhone X sometimes reports wrong y value for keyboard
[self positionInput: rect x: rect.origin.x y: rect.origin.y];
}
- (void)keyboardDidShow:(NSNotification*)notification
{
_active = YES;
}
- (void)keyboardWillHide:(NSNotification*)notification
{
[self systemHideKeyboard];
}
- (void)keyboardDidChangeFrame:(NSNotification*)notification
{
_active = true;
CGRect srcRect = [[notification.userInfo objectForKey: UIKeyboardFrameEndUserInfoKey] CGRectValue];
CGRect rect = [UnityGetGLView() convertRect: srcRect fromView: nil];
if (rect.origin.y >= [UnityGetGLView() bounds].size.height)
[self systemHideKeyboard];
else
{
rect.origin.y = [UnityGetGLView() frame].size.height - rect.size.height; // iPhone X sometimes reports wrong y value for keyboard
[self positionInput: rect x: rect.origin.x y: rect.origin.y];
}
}
#endif
+ (void)Initialize
{
NSAssert(_keyboard == nil, @"[KeyboardDelegate Initialize] called after creating keyboard");
if (!_keyboard)
_keyboard = [[KeyboardDelegate alloc] init];
}
+ (KeyboardDelegate*)Instance
{
if (!_keyboard)
_keyboard = [[KeyboardDelegate alloc] init];
return _keyboard;
}
#if PLATFORM_IOS
struct CreateToolbarResult
{
UIToolbar* toolbar;
NSArray* items;
};
- (CreateToolbarResult)createToolbarWithView:(UIView*)view
{
UIToolbar* toolbar = [[UIToolbar alloc] initWithFrame: CGRectMake(0, 840, 320, kToolBarHeight)];
UnitySetViewTouchProcessing(toolbar, touchesIgnored);
toolbar.hidden = NO;
UIBarButtonItem* inputItem = view ? [[UIBarButtonItem alloc] initWithCustomView: view] : nil;
UIBarButtonItem* doneItem = [[UIBarButtonItem alloc] initWithBarButtonSystemItem: UIBarButtonSystemItemDone target: self action: @selector(textInputDone:)];
UIBarButtonItem* cancelItem = [[UIBarButtonItem alloc] initWithBarButtonSystemItem: UIBarButtonSystemItemCancel target: self action: @selector(textInputCancel:)];
NSArray* items = view ? @[inputItem, doneItem, cancelItem] : @[doneItem, cancelItem];
toolbar.items = items;
inputItem = nil;
doneItem = nil;
cancelItem = nil;
CreateToolbarResult ret = {toolbar, items};
return ret;
}
#endif
- (id)init
{
NSAssert(_keyboard == nil, @"You can have only one instance of KeyboardDelegate");
self = [super init];
if (self)
{
#if PLATFORM_IOS
textView = [[UITextView alloc] initWithFrame: CGRectMake(0, 840, 480, 30)];
textView.delegate = self;
textView.font = [UIFont systemFontOfSize: 18.0];
textView.hidden = YES;
#endif
textField = [[UITextField alloc] initWithFrame: CGRectMake(0, 0, 120, 30)];
textField.delegate = self;
textField.borderStyle = UITextBorderStyleRoundedRect;
textField.font = [UIFont systemFontOfSize: 20.0];
textField.clearButtonMode = UITextFieldViewModeWhileEditing;
#if PLATFORM_IOS
widthConstraint = [NSLayoutConstraint constraintWithItem: textField attribute: NSLayoutAttributeWidth relatedBy: NSLayoutRelationEqual toItem: nil attribute: NSLayoutAttributeNotAnAttribute multiplier: 1.0 constant: textField.frame.size.width];
[textField addConstraint: widthConstraint];
#endif
#define CREATE_TOOLBAR(t, i, v) \
do { \
CreateToolbarResult res = [self createToolbarWithView:v]; \
t = res.toolbar; \
i = res.items; \
} while(0)
#if PLATFORM_IOS
CREATE_TOOLBAR(viewToolbar, viewToolbarItems, nil);
CREATE_TOOLBAR(fieldToolbar, fieldToolbarItems, textField);
#endif
#undef CREATE_TOOLBAR
#if PLATFORM_IOS
[[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardWillShow:) name: UIKeyboardWillShowNotification object: nil];
[[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardDidShow:) name: UIKeyboardDidShowNotification object: nil];
[[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardWillHide:) name: UIKeyboardWillHideNotification object: nil];
[[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardDidChangeFrame:) name: UIKeyboardDidChangeFrameNotification object: nil];
#endif
[[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(textInputDone:) name: UITextFieldTextDidEndEditingNotification object: nil];
}
return self;
}
- (void)setTextInputTraits:(id<UITextInputTraits>)traits
withParam:(KeyboardShowParam)param
withCap:(UITextAutocapitalizationType)capitalization
{
traits.keyboardType = param.keyboardType;
traits.autocorrectionType = param.autocorrectionType;
traits.secureTextEntry = param.secure;
traits.keyboardAppearance = param.appearance;
traits.autocapitalizationType = capitalization;
}
- (void)setKeyboardParams:(KeyboardShowParam)param
{
if (!editView.hidden)
{
[NSObject cancelPreviousPerformRequestsWithTarget: self];
if (cachedKeyboardParam.multiline != param.multiline ||
cachedKeyboardParam.secure != param.secure ||
cachedKeyboardParam.keyboardType != param.keyboardType ||
cachedKeyboardParam.autocorrectionType != param.autocorrectionType ||
cachedKeyboardParam.appearance != param.appearance)
{
[self hideUIDelayed];
}
}
cachedKeyboardParam = param;
if (_active)
[self hide];
initialText = param.text ? [[NSString alloc] initWithUTF8String: param.text] : @"";
_characterLimit = param.characterLimit;
UITextAutocapitalizationType capitalization = UITextAutocapitalizationTypeSentences;
if (param.keyboardType == UIKeyboardTypeURL || param.keyboardType == UIKeyboardTypeEmailAddress || param.keyboardType == UIKeyboardTypeWebSearch)
capitalization = UITextAutocapitalizationTypeNone;
#if PLATFORM_IOS
_multiline = param.multiline;
if (_multiline)
{
textView.text = initialText;
[self setTextInputTraits: textView withParam: param withCap: capitalization];
UITextPosition* end = [textView endOfDocument];
UITextRange* endTextRange = [textView textRangeFromPosition: end toPosition: end];
[textView setSelectedTextRange: endTextRange];
}
else
{
textField.text = initialText;
[self setTextInputTraits: textField withParam: param withCap: capitalization];
textField.placeholder = [NSString stringWithUTF8String: param.placeholder];
UITextPosition* end = [textField endOfDocument];
UITextRange* endTextRange = [textField textRangeFromPosition: end toPosition: end];
[textField setSelectedTextRange: endTextRange];
}
inputView = _multiline ? textView : textField;
editView = _multiline ? textView : fieldToolbar;
#else // PLATFORM_TVOS
textField.text = initialText;
[self setTextInputTraits: textField withParam: param withCap: capitalization];
textField.placeholder = [NSString stringWithUTF8String: param.placeholder];
inputView = textField;
editView = textField;
UITextPosition* end = [textField endOfDocument];
UITextRange* endTextRange = [textField textRangeFromPosition: end toPosition: end];
[textField setSelectedTextRange: endTextRange];
#endif
[self shouldHideInput: _shouldHideInput];
_status = Visible;
_active = YES;
}
// we need to show/hide keyboard to react to orientation too, so extract we extract UI fiddling
- (void)showUI
{
// if we unhide everything now the input will be shown smaller then needed quickly (and resized later)
// so unhide only when keyboard is actually shown (we will update it when reacting to ios notifications)
[NSObject cancelPreviousPerformRequestsWithTarget: self];
if (!inputView.isFirstResponder)
{
editView.hidden = YES;
[UnityGetGLView() addSubview: editView];
[inputView becomeFirstResponder];
}
}
- (void)hideUI
{
[NSObject cancelPreviousPerformRequestsWithTarget: self];
[self performSelector: @selector(hideUIDelayed) withObject: nil afterDelay: 0.05]; // to avoid unnecessary hiding
}
- (void)hideUIDelayed
{
[inputView resignFirstResponder];
[editView removeFromSuperview];
editView.hidden = YES;
}
- (void)systemHideKeyboard
{
// when we are rotating os will bombard us with keyboardWillHide: and keyboardDidChangeFrame:
// ignore all of them (we do it here only to simplify code: we call systemHideKeyboard only from these notification handlers)
if (_rotating)
return;
_active = editView.isFirstResponder;
editView.hidden = YES;
_area = CGRectMake(0, 0, 0, 0);
}
- (void)show
{
[self showUI];
}
- (void)hide
{
[self hideUI];
}
- (void)updateInputHidden
{
if (_shouldHideInputChanged)
{
[self shouldHideInput: _shouldHideInput];
_shouldHideInputChanged = false;
}
textField.returnKeyType = _inputHidden ? UIReturnKeyDone : UIReturnKeyDefault;
editView.hidden = _inputHidden ? YES : NO;
inputView.hidden = _inputHidden ? YES : NO;
}
#if PLATFORM_IOS
- (void)positionInput:(CGRect)kbRect x:(float)x y:(float)y
{
float safeAreaInsetLeft = 0;
float safeAreaInsetRight = 0;
#if UNITY_HAS_IOSSDK_11_0
if (@available(iOS 11.0, *))
{
safeAreaInsetLeft = [UnityGetGLView() safeAreaInsets].left;
safeAreaInsetRight = [UnityGetGLView() safeAreaInsets].right;
}
#endif
if (_multiline)
{
// use smaller area for iphones and bigger one for ipads
int height = UnityDeviceDPI() > 300 ? 75 : 100;
editView.frame = CGRectMake(safeAreaInsetLeft, y - height, kbRect.size.width - safeAreaInsetLeft - safeAreaInsetRight, height);
}
else
{
editView.frame = CGRectMake(0, y - kToolBarHeight, kbRect.size.width, kToolBarHeight);
// old constraint must be removed, changing value while constraint is active causes conflict when changing inputView.frame
[inputView removeConstraint: widthConstraint];
inputView.frame = CGRectMake(inputView.frame.origin.x,
inputView.frame.origin.y,
kbRect.size.width - safeAreaInsetLeft - safeAreaInsetRight - kSystemButtonsSpace,
inputView.frame.size.height);
// required to avoid auto-resizing on iOS 11 in case if input text is too long
widthConstraint.constant = inputView.frame.size.width;
[inputView addConstraint: widthConstraint];
}
_area = CGRectMake(x, y, kbRect.size.width, kbRect.size.height);
[self updateInputHidden];
}
#endif
- (CGRect)queryArea
{
return editView.hidden ? _area : CGRectUnion(_area, editView.frame);
}
- (NSRange)querySelection
{
UIView<UITextInput>* textInput;
#if PLATFORM_TVOS
textInput = textField;
#else
textInput = _multiline ? textView : textField;
#endif
UITextPosition* beginning = textInput.beginningOfDocument;
UITextRange* selectedRange = textInput.selectedTextRange;
UITextPosition* selectionStart = selectedRange.start;
UITextPosition* selectionEnd = selectedRange.end;
const NSInteger location = [textInput offsetFromPosition: beginning toPosition: selectionStart];
const NSInteger length = [textInput offsetFromPosition: selectionStart toPosition: selectionEnd];
return NSMakeRange(location, length);
}
- (void)assignSelection:(NSRange)range
{
UIView<UITextInput>* textInput;
#if PLATFORM_TVOS
textInput = textField;
#else
textInput = _multiline ? textView : textField;
#endif
UITextPosition* begin = [textInput beginningOfDocument];
UITextPosition* caret = [textInput positionFromPosition: begin offset: range.location];
UITextPosition* select = [textInput positionFromPosition: caret offset: range.length];
UITextRange* textRange = [textInput textRangeFromPosition: caret toPosition: select];
[textInput setSelectedTextRange: textRange];
}
+ (void)StartReorientation
{
if (_keyboard && _keyboard.active)
_keyboard->_rotating = YES;
}
+ (void)FinishReorientation
{
if (_keyboard)
_keyboard->_rotating = NO;
}
- (NSString*)getText
{
if (_status == Canceled)
return initialText;
else
{
#if PLATFORM_TVOS
return [textField text];
#else
return _multiline ? [textView text] : [textField text];
#endif
}
}
- (void)setText:(NSString*)newText
{
#if PLATFORM_IOS
if (_multiline)
textView.text = newText;
else
textField.text = newText;
#else
textField.text = newText;
#endif
}
- (void)shouldHideInput:(BOOL)hide
{
if (hide)
{
switch (keyboardType)
{
case UIKeyboardTypeDefault: hide = YES; break;
case UIKeyboardTypeASCIICapable: hide = YES; break;
case UIKeyboardTypeNumbersAndPunctuation: hide = YES; break;
case UIKeyboardTypeURL: hide = YES; break;
case UIKeyboardTypeNumberPad: hide = NO; break;
case UIKeyboardTypePhonePad: hide = NO; break;
case UIKeyboardTypeNamePhonePad: hide = NO; break;
case UIKeyboardTypeEmailAddress: hide = YES; break;
case UIKeyboardTypeTwitter: hide = YES; break;
case UIKeyboardTypeWebSearch: hide = YES; break;
default: hide = NO; break;
}
}
_inputHidden = hide;
}
#if FILTER_EMOJIS_IOS_KEYBOARD
static bool StringContainsEmoji(NSString *string);
- (BOOL)textField:(UITextField*)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString*)string_
{
if (range.length + range.location > textField.text.length)
return NO;
return [self currentText: textField.text shouldChangeInRange: range replacementText: string_] && !StringContainsEmoji(string_);
}
- (BOOL)textView:(UITextView*)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString*)text_
{
if (range.length + range.location > textView.text.length)
return NO;
return [self currentText: textView.text shouldChangeInRange: range replacementText: text_] && !StringContainsEmoji(text_);
}
#else
- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString*)string_
{
if (range.length + range.location > textField.text.length)
return NO;
return [self currentText: textField.text shouldChangeInRange: range replacementText: string_];
}
- (BOOL)textView:(UITextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString*)text_
{
if (range.length + range.location > textView.text.length)
return NO;
return [self currentText: textView.text shouldChangeInRange: range replacementText: text_];
}
#endif // FILTER_EMOJIS_IOS_KEYBOARD
- (BOOL)currentText:(NSString*)currentText shouldChangeInRange:(NSRange)range replacementText:(NSString*)text_
{
NSUInteger newLength = currentText.length + (text_.length - range.length);
if (newLength > _characterLimit && _characterLimit != 0 && newLength >= currentText.length)
{
NSString* newReplacementText = @"";
if ((currentText.length - range.length) < _characterLimit)
newReplacementText = [text_ substringWithRange: NSMakeRange(0, _characterLimit - (currentText.length - range.length))];
NSString* newText = [currentText stringByReplacingCharactersInRange: range withString: newReplacementText];
#if PLATFORM_IOS
if (_multiline)
[textView setText: newText];
else
[textField setText: newText];
#else
[textField setText: newText];
#endif
return NO;
}
else
{
return YES;
}
}
@end
//==============================================================================
//
// Unity Interface:
extern "C" void UnityKeyboard_Create(unsigned keyboardType, int autocorrection, int multiline, int secure, int alert, const char* text, const char* placeholder, int characterLimit)
{
#if PLATFORM_TVOS
// Not supported. The API for showing keyboard for editing multi-line text
// is not available on tvOS
multiline = false;
#endif
static const UIKeyboardType keyboardTypes[] =
{
UIKeyboardTypeDefault,
UIKeyboardTypeASCIICapable,
UIKeyboardTypeNumbersAndPunctuation,
UIKeyboardTypeURL,
UIKeyboardTypeNumberPad,
UIKeyboardTypePhonePad,
UIKeyboardTypeNamePhonePad,
UIKeyboardTypeEmailAddress,
UIKeyboardTypeDefault, // Default is used in case Wii U specific NintendoNetworkAccount type is selected (indexed at 8 in UnityEngine.TouchScreenKeyboardType)
UIKeyboardTypeTwitter,
UIKeyboardTypeWebSearch
};
static const UITextAutocorrectionType autocorrectionTypes[] =
{
UITextAutocorrectionTypeNo,
UITextAutocorrectionTypeDefault,
};
static const UIKeyboardAppearance keyboardAppearances[] =
{
UIKeyboardAppearanceDefault,
UIKeyboardAppearanceAlert,
};
KeyboardShowParam param =
{
text, placeholder,
keyboardTypes[keyboardType],
autocorrectionTypes[autocorrection],
keyboardAppearances[alert],
(BOOL)multiline, (BOOL)secure,
characterLimit
};
[[KeyboardDelegate Instance] setKeyboardParams: param];
}
extern "C" void UnityKeyboard_Show()
{
// do not send hide if didnt create keyboard
// TODO: probably assert?
if (!_keyboard)
return;
[[KeyboardDelegate Instance] show];
}
extern "C" void UnityKeyboard_Hide()
{
// do not send hide if didnt create keyboard
// TODO: probably assert?
if (!_keyboard)
return;
[[KeyboardDelegate Instance] textInputLostFocus];
}
extern "C" void UnityKeyboard_SetText(const char* text)
{
[KeyboardDelegate Instance].text = [NSString stringWithUTF8String: text];
}
extern "C" NSString* UnityKeyboard_GetText()
{
return [KeyboardDelegate Instance].text;
}
extern "C" int UnityKeyboard_IsActive()
{
return (_keyboard && _keyboard.active) ? 1 : 0;
}
extern "C" int UnityKeyboard_Status()
{
return _keyboard ? _keyboard.status : Canceled;
}
extern "C" void UnityKeyboard_SetInputHidden(int hidden)
{
_shouldHideInput = hidden;
_shouldHideInputChanged = true;
// update hidden status only if keyboard is on screen to avoid showing input view out of nowhere
if (_keyboard && _keyboard.active)
[_keyboard updateInputHidden];
}
extern "C" int UnityKeyboard_IsInputHidden()
{
return _shouldHideInput ? 1 : 0;
}
extern "C" void UnityKeyboard_GetRect(float* x, float* y, float* w, float* h)
{
CGRect area = _keyboard ? _keyboard.area : CGRectMake(0, 0, 0, 0);
// convert to unity coord system
float multX = (float)GetMainDisplaySurface()->targetW / UnityGetGLView().bounds.size.width;
float multY = (float)GetMainDisplaySurface()->targetH / UnityGetGLView().bounds.size.height;
*x = 0;
*y = area.origin.y * multY;
*w = area.size.width * multX;
*h = area.size.height * multY;
}
extern "C" void UnityKeyboard_SetCharacterLimit(unsigned characterLimit)
{
[KeyboardDelegate Instance].characterLimit = characterLimit;
}
extern "C" int UnityKeyboard_CanGetSelection()
{
return (_keyboard) ? 1 : 0;
}
extern "C" void UnityKeyboard_GetSelection(int* location, int* length)
{
if (_keyboard)
{
NSRange selection = _keyboard.selection;
*location = (int)selection.location;
*length = (int)selection.length;
}
else
{
*location = 0;
*length = 0;
}
}
extern "C" int UnityKeyboard_CanSetSelection()
{
return (_keyboard) ? 1 : 0;
}
extern "C" void UnityKeyboard_SetSelection(int location, int length)
{
if (_keyboard)
{
NSRange range = NSMakeRange(location, length);
_keyboard.selection = range;
}
}
//==============================================================================
//
// Emoji Filtering: unicode magic
#if FILTER_EMOJIS_IOS_KEYBOARD
static bool StringContainsEmoji(NSString *string)
{
__block BOOL returnValue = NO;
[string enumerateSubstringsInRange: NSMakeRange(0, string.length)
options: NSStringEnumerationByComposedCharacterSequences
usingBlock:^(NSString* substring, NSRange substringRange, NSRange enclosingRange, BOOL* stop)
{
const unichar hs = [substring characterAtIndex: 0];
const unichar ls = substring.length > 1 ? [substring characterAtIndex: 1] : 0;
#define IS_IN(val, min, max) (((val) >= (min)) && ((val) <= (max)))
if (IS_IN(hs, 0xD800, 0xDBFF))
{
if (substring.length > 1)
{
const int uc = ((hs - 0xD800) * 0x400) + (ls - 0xDC00) + 0x10000;
// Musical: [U+1D000, U+1D24F]
// Enclosed Alphanumeric Supplement: [U+1F100, U+1F1FF]
// Enclosed Ideographic Supplement: [U+1F200, U+1F2FF]
// Miscellaneous Symbols and Pictographs: [U+1F300, U+1F5FF]
// Supplemental Symbols and Pictographs: [U+1F900, U+1F9FF]
// Emoticons: [U+1F600, U+1F64F]
// Transport and Map Symbols: [U+1F680, U+1F6FF]
if (IS_IN(uc, 0x1D000, 0x1F9FF))
returnValue = YES;
}
}
else if (substring.length > 1 && ls == 0x20E3)
{
// emojis for numbers: number + modifier ls = U+20E3
returnValue = YES;
}
else
{
if ( // Latin-1 Supplement
hs == 0x00A9 || hs == 0x00AE
// General Punctuation
|| hs == 0x203C || hs == 0x2049
// Letterlike Symbols
|| hs == 0x2122 || hs == 0x2139
// Arrows
|| IS_IN(hs, 0x2194, 0x2199) || IS_IN(hs, 0x21A9, 0x21AA)
// Miscellaneous Technical
|| IS_IN(hs, 0x231A, 0x231B) || IS_IN(hs, 0x23E9, 0x23F3) || IS_IN(hs, 0x23F8, 0x23FA) || hs == 0x2328 || hs == 0x23CF
// Geometric Shapes
|| IS_IN(hs, 0x25AA, 0x25AB) || IS_IN(hs, 0x25FB, 0x25FE) || hs == 0x25B6 || hs == 0x25C0
// Miscellaneous Symbols
|| IS_IN(hs, 0x2600, 0x2604) || IS_IN(hs, 0x2614, 0x2615) || IS_IN(hs, 0x2622, 0x2623) || IS_IN(hs, 0x262E, 0x262F)
|| IS_IN(hs, 0x2638, 0x263A) || IS_IN(hs, 0x2648, 0x2653) || IS_IN(hs, 0x2665, 0x2666) || IS_IN(hs, 0x2692, 0x2694)
|| IS_IN(hs, 0x2696, 0x2697) || IS_IN(hs, 0x269B, 0x269C) || IS_IN(hs, 0x26A0, 0x26A1) || IS_IN(hs, 0x26AA, 0x26AB)
|| IS_IN(hs, 0x26B0, 0x26B1) || IS_IN(hs, 0x26BD, 0x26BE) || IS_IN(hs, 0x26C4, 0x26C5) || IS_IN(hs, 0x26CE, 0x26CF)
|| IS_IN(hs, 0x26D3, 0x26D4) || IS_IN(hs, 0x26D3, 0x26D4) || IS_IN(hs, 0x26E9, 0x26EA) || IS_IN(hs, 0x26F0, 0x26F5)
|| IS_IN(hs, 0x26F7, 0x26FA)
|| hs == 0x260E || hs == 0x2611 || hs == 0x2618 || hs == 0x261D || hs == 0x2620 || hs == 0x2626 || hs == 0x262A
|| hs == 0x2660 || hs == 0x2663 || hs == 0x2668 || hs == 0x267B || hs == 0x267F || hs == 0x2699 || hs == 0x26C8
|| hs == 0x26D1 || hs == 0x26FD
// Dingbats
|| IS_IN(hs, 0x2708, 0x270D) || IS_IN(hs, 0x2733, 0x2734) || IS_IN(hs, 0x2753, 0x2755)
|| IS_IN(hs, 0x2763, 0x2764) || IS_IN(hs, 0x2795, 0x2797)
|| hs == 0x2702 || hs == 0x2705 || hs == 0x270F || hs == 0x2712 || hs == 0x2714 || hs == 0x2716 || hs == 0x271D
|| hs == 0x2721 || hs == 0x2728 || hs == 0x2744 || hs == 0x2747 || hs == 0x274C || hs == 0x274E || hs == 0x2757
|| hs == 0x27A1 || hs == 0x27B0 || hs == 0x27BF
// CJK Symbols and Punctuation
|| hs == 0x3030 || hs == 0x303D
// Enclosed CJK Letters and Months
|| hs == 0x3297 || hs == 0x3299
// Supplemental Arrows-B
|| IS_IN(hs, 0x2934, 0x2935)
// Miscellaneous Symbols and Arrows
|| IS_IN(hs, 0x2B05, 0x2B07) || IS_IN(hs, 0x2B1B, 0x2B1C) || hs == 0x2B50 || hs == 0x2B55
)
{
returnValue = YES;
}
}
#undef IS_IN
}];
return returnValue;
}
#endif // FILTER_EMOJIS_IOS_KEYBOARD