plugins/dali-swig/SWIG/events/textfield-event.i

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 %define TEXTFIELD_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
  19 %typemap(csimports) NameSpace::ClassName %{
  20 using System;
  21 using System.Runtime.InteropServices;
  22
  23 %}
  24
  25 %enddef
  26
  27 %define TEXTFIELD_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  28 %typemap(cscode) NameSpace::ClassName %{
  29
  30 public class TextChangedEventArgs : EventArgs
  31 {
  32    private TextField _textField;
  33
  34    public TextField TextField
  35    {
  36       get
  37       {
  38          return _textField;
  39       }
  40       set
  41       {
  42          _textField = value;
  43       }
  44    }
  45 }
  46
  47 public class MaxLengthReachedEventArgs : EventArgs
  48 {
  49    private TextField _textField;
  50
  51    public TextField TextField
  52    {
  53       get
  54       {
  55          return _textField;
  56       }
  57       set
  58       {
  59          _textField = value;
  60       }
  61    }
  62 }
  63
  64
  65   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  66   private delegate void TextChangedCallbackDelegate(IntPtr textField);
  67   private DaliEventHandler<object,TextChangedEventArgs> _textFieldTextChangedEventHandler;
  68   private TextChangedCallbackDelegate _textFieldTextChangedCallbackDelegate;
  69
  70   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  71   private delegate void MaxLengthReachedCallbackDelegate(IntPtr textField);
  72   private DaliEventHandler<object,MaxLengthReachedEventArgs> _textFieldMaxLengthReachedEventHandler;
  73   private MaxLengthReachedCallbackDelegate _textFieldMaxLengthReachedCallbackDelegate;
  74
  75   public event DaliEventHandler<object,TextChangedEventArgs> TextChanged
  76   {
  77      add
  78      {
  79         lock(this)
  80         {
  81            // Restricted to only one listener
  82            if (_textFieldTextChangedEventHandler == null)
  83            {
  84               _textFieldTextChangedEventHandler += value;
  85
  86               _textFieldTextChangedCallbackDelegate = new TextChangedCallbackDelegate(OnTextChanged);
  87               this.TextChangedSignal().Connect(_textFieldTextChangedCallbackDelegate);
  88            }
  89         }
  90      }
  91
  92      remove
  93      {
  94         lock(this)
  95         {
  96            if (_textFieldTextChangedEventHandler != null)
  97            {
  98               this.TextChangedSignal().Disconnect(_textFieldTextChangedCallbackDelegate);
  99            }
 100
 101            _textFieldTextChangedEventHandler -= value;
 102         }
 103      }
 104   }
 105
 106  private void OnTextChanged(IntPtr textField)
 107   {
 108    TextChangedEventArgs e = new TextChangedEventArgs();
 109
 110    // Populate all members of "e" (TextChangedEventArgs) with real data
 111    e.TextField = Dali.TextField.GetTextFieldFromPtr(textField);
 112
 113    if (_textFieldTextChangedEventHandler != null)
 114    {
 115       //here we send all data to user event handlers
 116       _textFieldTextChangedEventHandler(this, e);
 117    }
 118
 119   }
 120
 121   public event DaliEventHandler<object,MaxLengthReachedEventArgs> MaxLengthReached
 122   {
 123      add
 124      {
 125         lock(this)
 126         {
 127            // Restricted to only one listener
 128            if (_textFieldMaxLengthReachedEventHandler == null)
 129            {
 130               _textFieldMaxLengthReachedEventHandler += value;
 131
 132               _textFieldMaxLengthReachedCallbackDelegate = new MaxLengthReachedCallbackDelegate(OnMaxLengthReached);
 133               this.MaxLengthReachedSignal().Connect(_textFieldMaxLengthReachedCallbackDelegate);
 134            }
 135         }
 136      }
 137
 138      remove
 139      {
 140         lock(this)
 141         {
 142            if (_textFieldMaxLengthReachedEventHandler != null)
 143            {
 144               this.MaxLengthReachedSignal().Disconnect(_textFieldMaxLengthReachedCallbackDelegate);
 145            }
 146
 147            _textFieldMaxLengthReachedEventHandler -= value;
 148         }
 149      }
 150   }
 151
 152  private void OnMaxLengthReached(IntPtr textField)
 153   {
 154    MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
 155
 156    // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
 157    e.TextField = Dali.TextField.GetTextFieldFromPtr(textField);
 158
 159    if (_textFieldMaxLengthReachedEventHandler != null)
 160    {
 161       //here we send all data to user event handlers
 162       _textFieldMaxLengthReachedEventHandler(this, e);
 163    }
 164
 165   }
 166
 167  public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
 168    ClassName ret = new ClassName(cPtr, false);
 169    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 170     return ret;
 171   }
 172
 173 %}
 174
 175 %enddef
 176
 177 %define DALI_TEXTFIELD_EVENTHANDLER_PARAM( NameSpace, ClassName)
 178
 179   TEXTFIELD_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 180   TEXTFIELD_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 181
 182 %enddef
 183
 184 namespace Dali
 185 {
 186   DALI_TEXTFIELD_EVENTHANDLER_PARAM( Dali::Toolkit, TextField);
 187 }