示例#1
0
        partial void OnIsReadonlyChangedPartial(DependencyPropertyChangedEventArgs e)
        {
            if (_textBoxView != null)
            {
                var isReadOnly = IsReadOnly;

                _textBoxView.Focusable            = !isReadOnly;
                _textBoxView.FocusableInTouchMode = !isReadOnly;
                _textBoxView.Clickable            = !isReadOnly;
                _textBoxView.LongClickable        = !isReadOnly;
                _textBoxView.SetCursorVisible(!isReadOnly);

                if (isReadOnly)
                {
                    _listener = _textBoxView.KeyListener;
                    _textBoxView.KeyListener = null;
                }
                else
                {
                    if (_listener != null)
                    {
                        _textBoxView.KeyListener = _listener;
                    }
                }
            }
        }
示例#2
0
        private void UpdateTextBoxViewReadOnly()
        {
            if (_textBoxView == null)
            {
                return;
            }

            // Both IsReadOnly = true and IsTabStop = false make the control
            // not receive any input.
            var isReadOnly = IsReadOnly || !IsTabStop;

            _textBoxView.Focusable            = !isReadOnly;
            _textBoxView.FocusableInTouchMode = !isReadOnly;
            _textBoxView.Clickable            = !isReadOnly;
            _textBoxView.LongClickable        = !isReadOnly;
            _textBoxView.SetCursorVisible(!isReadOnly);

            if (isReadOnly)
            {
                _listener = _textBoxView.KeyListener;
                _textBoxView.KeyListener = null;
            }
            else
            {
                if (_listener != null)
                {
                    _textBoxView.KeyListener = _listener;
                }
            }
        }
示例#3
0
 static public void RemoveListener(IKeyListener aListener)
 {
     if (instance.mListeners.Contains(aListener))
     {
         instance.mListeners.Remove(aListener);
     }
 }
示例#4
0
 static public void AddListener(IKeyListener aListener)
 {
     if (!instance.mListeners.Contains(aListener))
     {
         instance.mListeners.Add(aListener);
     }
 }
示例#5
0
        private void AddKeyListener(IKeyListener iKeyListener)
        {
            if (!mKeyListener.ContainsKey(iKeyListener.Screen))
            {
                mKeyListener[iKeyListener.Screen] = new List <IKeyListener>();
            }

            mKeyListener[iKeyListener.Screen].Add(iKeyListener);
        }
        /// <summary>
        /// Bind the <see cref="IKeyListener{TView}{TView}"/> to the <see cref="KeyGestureListener"/>.
        /// </summary>
        /// <typeparam name="TView">The native view.</typeparam>
        /// <param name="nativeListener">The native listener.</param>
        /// <param name="formsListener">The XF listener.</param>
        /// <param name="sender">The XF view.</param>
        /// <param name="disposable">The disposable used to clean up subscriptions.</param>
        /// <returns>The native key listener.</returns>
        public static IKeyListener <TView> Bind <TView>(
            this IKeyListener <TView> nativeListener,
            KeyGestureListener formsListener,
            View sender,
            CompositeDisposable disposable) where TView : class
        {
            nativeListener.Pressed.Subscribe(keys => formsListener.InvokePressed(sender, keys)).DisposeWith(disposable);
            nativeListener.KeyDown.Subscribe(key => formsListener.InvokeKeyDown(sender, key)).DisposeWith(disposable);
            nativeListener.KeyUp.Subscribe(key => formsListener.InvokeKeyUp(sender, key)).DisposeWith(disposable);

            return(nativeListener);
        }
示例#7
0
        private bool RemoveKeyListener(IKeyListener iKeyListener)
        {
            if (!mKeyListener.ContainsKey(iKeyListener.Screen))
            {
                return(false);
            }

            if (!mKeyListener[iKeyListener.Screen].Contains(iKeyListener))
            {
                return(false);
            }

            mKeyListener[iKeyListener.Screen].Remove(iKeyListener);
            return(true);
        }
示例#8
0
 private void InitKeyboard(FeatureBase _, IKeyListener keylistener)
 {
     foreach (var kls in keylistener.KeyListenSettings)
     {
         foreach (var(key, state) in kls.KeyStates)
         {
             if (_keyliss.TryGetValue(key, out var tarkl) == false)
             {
                 _keyliss[key] = tarkl = new List <IKeyListener>();
             }
             if (tarkl.Contains(keylistener) == false)
             {
                 tarkl.Add(keylistener);
             }
         }
     }
 }
示例#9
0
        private void UpdateInputScope(InputScope inputScope)
        {
            if (_textBoxView != null)
            {
                var inputType = InputScopeHelper.ConvertInputScope(inputScope ?? InputScope);

                inputType = InputScopeHelper.ConvertToCapitalization(inputType, inputScope ?? InputScope);

                if (!IsSpellCheckEnabled)
                {
                    inputType = InputScopeHelper.ConvertToRemoveSuggestions(inputType, ShouldForceDisableSpellCheck);
                }

                if (AcceptsReturn)
                {
                    inputType |= InputTypes.TextFlagMultiLine;
                }

                if (IsReadOnly)
                {
                    _textBoxView.InputType = InputTypes.Null;

                    // Clear the listener so the inputs have no effect.
                    // Setting the input type to InputTypes.Null is not enough.
                    _listener = _textBoxView.KeyListener;
                    _textBoxView.KeyListener = null;
                }
                else
                {
                    if (_listener != null)
                    {
                        _textBoxView.KeyListener = _listener;
                    }

                    _textBoxView.InputType = inputType;
                }
            }
        }
 public void UnregisterKeyListener(IKeyListener keyListener)
 {
     _keyListeners.Remove(keyListener);
 }
 public void RegisterKeyListerer(IKeyListener keyListener)
 {
     _keyListeners.Add(keyListener);
 }
        protected override void OnElementChanged(ElementChangedEventArgs <Xamarin.Forms.Editor> e)
        {
            bool hasSet = false;


            if (e.OldElement == null && this.Element != null)
            {
                //SetNativeControl(new EditTextCustom(Context));
                //SetNativeControl(new EditTextCustom());
                hasSet = true;
            }

            base.OnElementChanged(e);

            if (!hasSet)
            {
                return;
            }

            if (Control != null)
            {
                DefaultKeyListener = Control.KeyListener;
                // do whatever you want to the textField here!
                Control.SetBackgroundColor(global::Android.Graphics.Color.Transparent);

                if (BaseElement.BackgroundImage != null && BaseElement.BackgroundImage.File != null)
                {
                    var resourceId = UIHelper.GetDrawableResource(BaseElement.BackgroundImage);
                    Control.SetBackgroundResource(resourceId);
                }

                Control.Hint = BaseElement.Placeholder;
                Control.SetHintTextColor(BaseElement.PlaceHolderColor.ToAndroid());

                if (BaseElement.MaxCharacter.HasValue)
                {
                    Control.SetFilters(new IInputFilter[] { new InputFilterLengthFilter(BaseElement.MaxCharacter.Value) });
                }
            }
            var editorControl = (Editor)Element;



            editorControl.PropertyChanged += async(s, ev) =>
            {
                if (Element == null || Control == null)
                {
                    return;
                }

                var element = (Editor)s;

                switch (ev.PropertyName)
                {
                case "BackgroundImage": SetBackground(element); break;

                case "FontFamily": SetTypeface(element); break;

                case "FontSize": SetTextSize(element); break;

                case "TextAlignment": SetTextAlignment(element); break;

                case "SuppressKeyboard": SetShowSoftInputOnFocus(element); break;

                case "Text": HideSoftKeyBoardOnTextChanged(element); break;

                case "IsReadOnly": SetIsReadOnly(element); break;

                case "IsFocused":
                    var x = Control.IsInTouchMode;
                    if (!element.IsFocused)
                    {
                        try
                        {
                            //Control.EditorAction += (object sender, Android.Widget.TextView.EditorActionEventArgs evt) => evt.Handled = true;
                            await Task.Delay(10);

                            //Control.Focusable = false;
                            //Control.Clickable = false;
                            Control.ClearFocus();
                            ////Control.ClearFocus();
                            //await Task.Delay(10);

                            Control.Focusable            = false;
                            Control.FocusableInTouchMode = false;
                            Control.Focusable            = true;
                            Control.FocusableInTouchMode = true;
                        }
                        catch (Exception)
                        {
                        }
                    }
                    break;
                }
            };

            //Control.TextChanged += (s, ev) => Element.Raise("TextChanged", ev);
            //Control.Completed += (s, ev) => Element.Raise("Completed", ev);
            Control.SetPadding(5, 5, 5, 5);
            //Control.Focusable = false;
            //Control.FocusableInTouchMode = true;
            SetBackground(editorControl);
            SetTypeface(editorControl);
            SetTextSize(editorControl);
            SetTextAlignment(editorControl);
            SetShowSoftInputOnFocus(editorControl);
            SetIsReadOnly(editorControl);

            Control.ViewAttachedToWindow += Control_ViewAttachedToWindow;
            //Control.Touch += Control_Touch;
            //Control.FocusChange += Control_FocusChange;
        }
示例#13
0
 public void RegisterListener(IKeyListener keyListener)
 {
     _Listeners.Add(keyListener);
 }
示例#14
0
 public void FlagForAddition(IKeyListener keylistener)
 {
     mKeyListenerToAdd.Add(keylistener);
 }
示例#15
0
 public void FlagForRemoval(IKeyListener keyListener)
 {
     mKeyListenerToRemove.Add(keyListener);
 }
示例#16
0
        protected override void OnElementChanged(ElementChangedEventArgs <Xamarin.Forms.Entry> e)
        {
            bool hasSet = false;

            if (e.OldElement == null && this.Element != null)
            {
                //SetNativeControl(new EditTextCustom(Context));
                //SetNativeControl(new EditTextCustom());
                hasSet = true;
            }

            if (inputMethodManager == null)
            {
                inputMethodManager = base.Context.GetSystemService(Context.InputMethodService) as InputMethodManager;
            }

            base.OnElementChanged(e);

            if (!hasSet)
            {
                return;
            }

            var entryControl = (MvvmAspire.Controls.Entry)Element;


            DefaultKeyListener = Control.KeyListener;

            entryControl.PropertyChanged += (s, ev) =>
            {
                var element = (MvvmAspire.Controls.Entry)s;

                switch (ev.PropertyName)
                {
                case "TextPadding":
                case "ImageLeft":
                case "ImageRight":
                case "ImageTop":
                case "ImageBottom":
                    SetImages(element);
                    break;

                case "ClearFocusTrigger": HideSoftKeyBoardOnTextChanged(element); break;

                case "IsFocused": element.ClearFocus = !element.IsFocused; break;

                case "BackgroundImage": SetBackground(element); break;

                case "FontFamily": SetTypeface(element); break;

                case "FontSize": SetTextSize(element); break;

                case "SuppressKeyboard": SetShowSoftInputOnFocus(element); break;

                case "Text":
                    if (element.ClearFocus)
                    {
                        HideSoftKeyBoardOnTextChanged(element);
                    }
                    break;

                case "ClearFocus":
                    //if (!EntryControl.IsNumeric) break;
                    if (element.ClearFocus)
                    {
                        //inputMethodManager.HideSoftInputFromWindow(base.Control.WindowToken, HideSoftInputFlags.None);
                        //Control.Focusable = false;
                        //Control.ClearFocus();
                        HideSoftKeyBoardOnTextChanged(element);
                    }
                    break;

                case "NextFocus":
                    inputMethodManager.ShowSoftInput(Control, ShowFlags.Implicit);
                    //inputMethodManager.ToggleSoftInput(ShowFlags.Forced, InputMethodManager.ShowImplicit);
                    break;

                case "IsEnabled":
                    if (base.Control == null)
                    {
                        return;
                    }

                    if (!element.IsEnabled)
                    {
                        base.Control.KeyListener = null;
                    }
                    else
                    {
                        base.Control.KeyListener = DefaultKeyListener;
                    }
                    break;

                case "IsReadOnly":
                    SetIsReadOnly(element);
                    break;

                    //case "Padding": SetPadding(element); break;
                }
            };

            //if (EntryControl.IsNumeric)
            //    Control.Touch += Control_Touch;

            SetBackground(entryControl);
            SetImages(entryControl);
            SetTypeface(entryControl);
            SetTextSize(entryControl);
            SetShowSoftInputOnFocus(entryControl);
            SetHintColor(entryControl);
            SetIsReadOnly(entryControl);
            SetTextAlignment();
            //SetPadding(entryControl);
            SetGravity(entryControl);

            if (BaseElement.NextElement != null)
            {
                Control.ImeOptions = ImeAction.Next;
            }
            if (BaseElement.NextElement == null && BaseElement.Command != null)
            {
                Control.ImeOptions = ImeAction.Done;
            }

            if (BaseElement.MaxCharacter.HasValue)
            {
                var filter = new InputFilterLengthFilter(BaseElement.MaxCharacter.Value);
                Control.SetFilters(new IInputFilter[] { filter });
            }

            Control.ViewAttachedToWindow += Control_ViewAttachedToWindow;
            Control.SetPadding(BaseUIHelper.ConvertDPToPixels(BaseElement.Padding.Left),
                               BaseUIHelper.ConvertDPToPixels(BaseElement.Padding.Top),
                               BaseUIHelper.ConvertDPToPixels(BaseElement.Padding.Right),
                               BaseUIHelper.ConvertDPToPixels(BaseElement.Padding.Bottom));

            if (BaseElement.NextElement != null || BaseElement.Command != null)
            {
                Control.SetOnEditorActionListener(this);
            }

            SetTextInputTypes(entryControl);

            if (!entryControl.IsEnabled)
            {
                base.Control.KeyListener = null;
            }

            base.Control.Focusable = !BaseElement.IsReadOnly;

            //Control.Touch += Control_Touch;
            //Control.FocusChange += Control_FocusChange;
            if (BaseElement.IsSingleLine)
            {
                Control.SetMaxLines(1);
                Control.SetSingleLine(true);
                Control.Ellipsize = TextUtils.TruncateAt.End;
            }
            //Control.Gravity = GravityFlags.CenterVertical;
            Control.Background.SetColorFilter(Android.Graphics.Color.Transparent, PorterDuff.Mode.SrcIn);
        }