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

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