src/Tizen.NUI/src/public/BaseComponents/ImageView.cs

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 namespace Tizen.NUI.BaseComponents
  18 {
  19     using System;
  20     using System.Runtime.InteropServices;
  21
  22     /// <summary>
  23     /// ImageView is a class for displaying an image resource.<br>
  24     /// An instance of ImageView can be created using a URL or an Image instance.<br>
  25     /// </summary>
  26     public class ImageView : View
  27     {
  28         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  29
  30         internal ImageView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.ImageView_SWIGUpcast(cPtr), cMemoryOwn)
  31         {
  32             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  33         }
  34
  35         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ImageView obj)
  36         {
  37             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  38         }
  39
  40
  41         /// <summary>
  42         /// Event arguments of resource ready.
  43         /// </summary>
  44         public class ResourceReadyEventArgs : EventArgs
  45         {
  46             private View _view;
  47
  48             /// <summary>
  49             /// The view whose resource is ready.
  50             /// </summary>
  51             public View View
  52             {
  53                 get
  54                 {
  55                     return _view;
  56                 }
  57                 set
  58                 {
  59                     _view = value;
  60                 }
  61             }
  62         }
  63
  64         private EventHandler<ResourceReadyEventArgs> _resourceReadyEventHandler;
  65         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  66         private delegate void ResourceReadyEventCallbackType(IntPtr data);
  67         private ResourceReadyEventCallbackType _resourceReadyEventCallback;
  68
  69         /// <summary>
  70         /// Event for ResourceReady signal which can be used to subscribe/unsubscribe the event handler.<br>
  71         /// This signal is emitted after all resources required by a control are loaded and ready.<br>
  72         /// Most resources are only loaded when the control is placed on stage.<br>
  73         /// </summary>
  74         public event EventHandler<ResourceReadyEventArgs> ResourceReady
  75         {
  76             add
  77             {
  78                 if (_resourceReadyEventHandler == null)
  79                 {
  80                     _resourceReadyEventCallback = OnResourceReady;
  81                     ResourceReadySignal(this).Connect(_resourceReadyEventCallback);
  82                 }
  83
  84                 _resourceReadyEventHandler += value;
  85             }
  86
  87             remove
  88             {
  89                 _resourceReadyEventHandler -= value;
  90
  91                 if (_resourceReadyEventHandler == null && ResourceReadySignal(this).Empty() == false)
  92                 {
  93                     ResourceReadySignal(this).Disconnect(_resourceReadyEventCallback);
  94                 }
  95             }
  96         }
  97
  98         // Callback for View ResourceReady signal
  99         private void OnResourceReady(IntPtr data)
 100         {
 101             ResourceReadyEventArgs e = new ResourceReadyEventArgs();
 102             if(data != null)
 103             {
 104                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
 105             }
 106
 107             if (_resourceReadyEventHandler != null)
 108             {
 109                 _resourceReadyEventHandler(this, e);
 110             }
 111         }
 112
 113         //you can override it to clean-up your own resources.
 114         protected override void Dispose(DisposeTypes type)
 115         {
 116             if (disposed)
 117             {
 118                 return;
 119             }
 120
 121             if(type == DisposeTypes.Explicit)
 122             {
 123                 //Called by User
 124                 //Release your own managed resources here.
 125                 //You should release all of your own disposable objects here.
 126                 _border?.Dispose();
 127                 _border = null;
 128                 _nPatchMap?.Dispose();
 129                 _nPatchMap = null;
 130             }
 131
 132             //Release your own unmanaged resources here.
 133             //You should not access any managed member here except static instance.
 134             //because the execution order of Finalizes is non-deterministic.
 135
 136             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 137             {
 138                 if (swigCMemOwn)
 139                 {
 140                     swigCMemOwn = false;
 141                     NDalicPINVOKE.delete_ImageView(swigCPtr);
 142                 }
 143                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 144             }
 145
 146             base.Dispose(type);
 147         }
 148
 149         internal class Property
 150         {
 151             internal static readonly int RESOURCE_URL = NDalicPINVOKE.ImageView_Property_RESOURCE_URL_get();
 152             internal static readonly int IMAGE = NDalicPINVOKE.ImageView_Property_IMAGE_get();
 153             internal static readonly int PRE_MULTIPLIED_ALPHA = NDalicPINVOKE.ImageView_Property_PRE_MULTIPLIED_ALPHA_get();
 154             internal static readonly int PIXEL_AREA = NDalicPINVOKE.ImageView_Property_PIXEL_AREA_get();
 155         }
 156
 157         /// <summary>
 158         /// Creates an initialized ImageView.
 159         /// </summary>
 160         public ImageView() : this(NDalicPINVOKE.ImageView_New__SWIG_0(), true)
 161         {
 162             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 163
 164         }
 165         /// <summary>
 166         /// Creates an initialized ImageView from an URL to an image resource.<br>
 167         /// If the string is empty, ImageView will not display anything.<br>
 168         /// </summary>
 169         /// <param name="url">The url of the image resource to display</param>
 170         public ImageView(string url) : this(NDalicPINVOKE.ImageView_New__SWIG_2(url), true)
 171         {
 172             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 173
 174         }
 175         internal ImageView(string url, Uint16Pair size) : this(NDalicPINVOKE.ImageView_New__SWIG_3(url, Uint16Pair.getCPtr(size)), true)
 176         {
 177             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 178
 179         }
 180
 181         [Obsolete("Please do not use! this will be deprecated")]
 182         public new static ImageView DownCast(BaseHandle handle)
 183         {
 184             ImageView ret = new ImageView(NDalicPINVOKE.ImageView_DownCast(BaseHandle.getCPtr(handle)), true);
 185             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 186             return ret;
 187         }
 188         /// <summary>
 189         /// Sets this ImageView from the given URL.<br>
 190         /// If the URL is empty, ImageView will not display anything.<br>
 191         /// </summary>
 192         /// <param name="url">The URL to the image resource to display</param>
 193         public void SetImage(string url)
 194         {
 195             NDalicPINVOKE.ImageView_SetImage__SWIG_1(swigCPtr, url);
 196             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 197         }
 198         internal void SetImage(string url, Uint16Pair size)
 199         {
 200             NDalicPINVOKE.ImageView_SetImage__SWIG_2(swigCPtr, url, Uint16Pair.getCPtr(size));
 201             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 202         }
 203
 204         internal ViewResourceReadySignal ResourceReadySignal(View view) {
 205             ViewResourceReadySignal ret = new ViewResourceReadySignal(NDalicPINVOKE.ResourceReadySignal(View.getCPtr(view)), false);
 206             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 207             return ret;
 208         }
 209
 210         /// <summary>
 211         /// Query if all resources required by a control are loaded and ready.<br>
 212         /// Most resources are only loaded when the control is placed on stage.<br>
 213         /// true if the resources are loaded and ready, false otherwise.<br>
 214         /// </summary>
 215         public bool IsResourceReady()
 216         {
 217             bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
 218             if (NDalicPINVOKE.SWIGPendingException.Pending)
 219                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 220             return ret;
 221         }
 222
 223         /// <summary>
 224         /// ImageView ResourceUrl, type string
 225         /// </summary>
 226         public string ResourceUrl
 227         {
 228             get
 229             {
 230                 GetProperty(ImageView.Property.RESOURCE_URL).Get(out _url);
 231                 return _url;
 232             }
 233             set
 234             {
 235                 _url = value;
 236                 UpdateImage();
 237             }
 238         }
 239
 240         /// <summary>
 241         /// ImageView ImageMap, type PropertyMap : string if it is a url, map otherwise
 242         /// </summary>
 243         public PropertyMap ImageMap
 244         {
 245             get
 246             {
 247                 if (_border == null)
 248                 {
 249                     PropertyMap temp = new PropertyMap();
 250                     GetProperty(ImageView.Property.IMAGE).Get(temp);
 251                     return temp;
 252                 }
 253                 else
 254                 {
 255                     return null;
 256                 }
 257             }
 258             set
 259             {
 260                 if (_border == null)
 261                 {
 262                     SetProperty(ImageView.Property.IMAGE, new Tizen.NUI.PropertyValue(value));
 263                 }
 264             }
 265         }
 266
 267         /// <summary>
 268         /// ImageView PreMultipliedAlpha, type Boolean.<br>
 269         /// Image must be initialized.<br>
 270         /// </summary>
 271         public bool PreMultipliedAlpha
 272         {
 273             get
 274             {
 275                 bool temp = false;
 276                 GetProperty(ImageView.Property.PRE_MULTIPLIED_ALPHA).Get(out temp);
 277                 return temp;
 278             }
 279             set
 280             {
 281                 SetProperty(ImageView.Property.PRE_MULTIPLIED_ALPHA, new Tizen.NUI.PropertyValue(value));
 282             }
 283         }
 284
 285         /// <summary>
 286         /// ImageView PixelArea, type Vector4 (Animatable property).<br>
 287         /// Pixel area is a relative value with the whole image area as [0.0, 0.0, 1.0, 1.0].<br>
 288         /// </summary>
 289         public RelativeVector4 PixelArea
 290         {
 291             get
 292             {
 293                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 294                 GetProperty(ImageView.Property.PIXEL_AREA).Get(temp);
 295                 return temp;
 296             }
 297             set
 298             {
 299                 SetProperty(ImageView.Property.PIXEL_AREA, new Tizen.NUI.PropertyValue(value));
 300             }
 301         }
 302
 303         /// <summary>
 304         /// The border of the image in the order: left, right, bottom, top.<br>
 305         /// If set, ImageMap will be ignored.<br>
 306         /// For N-Patch images only.<br>
 307         /// Optional.
 308         /// </summary>
 309         public Rectangle Border
 310         {
 311             get
 312             {
 313                 return _border;
 314             }
 315             set
 316             {
 317                 _border = value;
 318                 UpdateImage();
 319             }
 320         }
 321
 322         /// <summary>
 323         /// Get or set whether to draws the borders only(If true).<br>
 324         /// If not specified, the default is false.<br>
 325         /// For N-Patch images only.<br>
 326         /// Optional.
 327         /// </summary>
 328         public bool BorderOnly
 329         {
 330             get
 331             {
 332                 return _borderOnly ?? false;
 333             }
 334             set
 335             {
 336                 _borderOnly = value;
 337                 UpdateImage();
 338             }
 339         }
 340
 341         public bool SynchronosLoading
 342         {
 343             get
 344             {
 345                 return _synchronousLoading ?? false;
 346             }
 347             set
 348             {
 349                 _synchronousLoading = value;
 350                 UpdateImage();
 351             }
 352         }
 353
 354         private void UpdateImage()
 355         {
 356             if (_url != null)
 357             {
 358                 if (_border != null)
 359                 { // for nine-patch image
 360                     _nPatchMap = new PropertyMap();
 361                     _nPatchMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.NPatch));
 362                     _nPatchMap.Add(NpatchImageVisualProperty.URL, new PropertyValue(_url));
 363                     _nPatchMap.Add(NpatchImageVisualProperty.Border, new PropertyValue(_border));
 364                     if (_borderOnly != null) { _nPatchMap.Add(NpatchImageVisualProperty.BorderOnly, new PropertyValue((bool)_borderOnly)); }
 365                     if (_synchronousLoading != null) _nPatchMap.Add(NpatchImageVisualProperty.SynchronousLoading, new PropertyValue((bool)_synchronousLoading));
 366                     SetProperty(ImageView.Property.IMAGE, new PropertyValue(_nPatchMap));
 367                 }
 368                 else if(_synchronousLoading != null)
 369                 { // for normal image, with synchronous loading property
 370                     PropertyMap imageMap = new PropertyMap();
 371                     imageMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Image));
 372                     imageMap.Add(ImageVisualProperty.URL, new PropertyValue(_url));
 373                     imageMap.Add(ImageVisualProperty.SynchronousLoading, new PropertyValue((bool)_synchronousLoading));
 374                     SetProperty(ImageView.Property.IMAGE, new PropertyValue(imageMap));
 375                 }
 376                 else
 377                 { // just for normal image
 378                     SetProperty(ImageView.Property.RESOURCE_URL, new PropertyValue(_url));
 379                 }
 380             }
 381         }
 382
 383         private Rectangle _border = null;
 384         private PropertyMap _nPatchMap = null;
 385         private bool? _synchronousLoading = null;
 386         private bool? _borderOnly = null;
 387         private string _url = null;
 388
 389     }
 390
 391 }