src/ElmSharp/ElmSharp/Image.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   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.IO;
  19 using System.Threading;
  20 using System.Threading.Tasks;
  21
  22 namespace ElmSharp
  23 {
  24     /// <summary>
  25     /// The Image is a widget that allows one to load and display an image file on it,
  26     /// be it from a disk file or from a memory region.
  27     /// Inherits Widget
  28     /// </summary>
  29     public class Image : Widget
  30     {
  31         bool _canScaleUp = true;
  32         bool _canScaleDown = true;
  33         SmartEvent _clicked;
  34         Color _color = Color.Default;
  35
  36         EvasImage _imageObject = null;
  37
  38         /// <summary>
  39         /// Creates and initializes a new instance of Image class.
  40         /// </summary>
  41         /// <param name="parent">The parent is a given container which will be attached by Image as a child. It's <see cref="EvasObject"/> type.</param>
  42         public Image(EvasObject parent) : base(parent)
  43         {
  44             _clicked = new SmartEvent(this, "clicked");
  45             _clicked.On += (s, e) => Clicked?.Invoke(this, EventArgs.Empty);
  46         }
  47
  48         /// <summary>
  49         /// Clicked will be triggered when the image is clicked.
  50         /// </summary>
  51         public event EventHandler Clicked;
  52
  53         /// <summary>
  54         /// LoadingCompleted will be triggered when the image is loaded completely.
  55         /// </summary>
  56         public event EventHandler LoadingCompleted;
  57
  58         /// <summary>
  59         /// Clicked will be triggered when the image is fail to load.
  60         /// </summary>
  61         public event EventHandler LoadingFailed;
  62
  63         /// <summary>
  64         /// Gets the file that is used as an image.
  65         /// </summary>
  66         public string File
  67         {
  68             get
  69             {
  70                 return Interop.Elementary.elm_image_file_get(RealHandle);
  71             }
  72         }
  73
  74         /// <summary>
  75         /// Sets or gets the smooth effect for an image.
  76         /// </summary>
  77         public bool IsSmooth
  78         {
  79             get
  80             {
  81                 return Interop.Elementary.elm_image_smooth_get(RealHandle);
  82             }
  83             set
  84             {
  85                 Interop.Elementary.elm_image_smooth_set(RealHandle, value);
  86             }
  87         }
  88
  89         /// <summary>
  90         /// Sets or gets whether scaling is disabled on the object.
  91         /// </summary>
  92         public bool IsScaling
  93         {
  94             get
  95             {
  96                 return !Interop.Elementary.elm_image_no_scale_get(RealHandle);
  97             }
  98             set
  99             {
 100                 Interop.Elementary.elm_image_no_scale_set(RealHandle, !value);
 101             }
 102         }
 103
 104         /// <summary>
 105         /// Sets or gets whether the object is down resizeable.
 106         /// </summary>
 107         public bool CanScaleDown
 108         {
 109             get
 110             {
 111                 return _canScaleDown;
 112             }
 113             set
 114             {
 115                 _canScaleDown = value;
 116                 Interop.Elementary.elm_image_resizable_set(RealHandle, _canScaleUp, _canScaleDown);
 117             }
 118         }
 119
 120         /// <summary>
 121         /// Sets or gets whether the object is up resizeable.
 122         /// </summary>
 123         public bool CanScaleUp
 124         {
 125             get
 126             {
 127                 return _canScaleUp;
 128             }
 129             set
 130             {
 131                 _canScaleUp = value;
 132                 Interop.Elementary.elm_image_resizable_set(RealHandle, _canScaleUp, _canScaleDown);
 133             }
 134         }
 135
 136         /// <summary>
 137         /// Sets or gets whether the image fills the entire object area, when keeping the aspect ratio.
 138         /// </summary>
 139         public bool CanFillOutside
 140         {
 141             get
 142             {
 143                 return Interop.Elementary.elm_image_fill_outside_get(RealHandle);
 144             }
 145             set
 146             {
 147                 Interop.Elementary.elm_image_fill_outside_set(RealHandle, value);
 148             }
 149         }
 150
 151         /// <summary>
 152         /// Sets or gets the prescale size for the image.
 153         /// </summary>
 154         public int PrescaleSize
 155         {
 156             get
 157             {
 158                 return Interop.Elementary.elm_image_prescale_get(RealHandle);
 159             }
 160             set
 161             {
 162                 Interop.Elementary.elm_image_prescale_set(RealHandle, value);
 163             }
 164         }
 165
 166         /// <summary>
 167         /// Sets or gets whether the original aspect ratio of the image should be kept on resize.
 168         /// </summary>
 169         public bool IsFixedAspect
 170         {
 171             get
 172             {
 173                 return Interop.Elementary.elm_image_aspect_fixed_get(RealHandle);
 174             }
 175             set
 176             {
 177                 Interop.Elementary.elm_image_aspect_fixed_set(RealHandle, value);
 178             }
 179         }
 180
 181         /// <summary>
 182         /// Sets or gets whether an image object (which supports animation) is to animate itself.
 183         /// </summary>
 184         public bool IsAnimated
 185         {
 186             get
 187             {
 188                 return Interop.Elementary.elm_image_animated_get(RealHandle);
 189             }
 190             set
 191             {
 192                 Interop.Elementary.elm_image_animated_set(RealHandle, value);
 193             }
 194         }
 195
 196         /// <summary>
 197         /// Gets whether an image object supports animation.
 198         /// </summary>
 199         public bool IsAnimatedAvailable
 200         {
 201             get
 202             {
 203                 return Interop.Elementary.elm_image_animated_available_get(RealHandle);
 204             }
 205         }
 206
 207         /// <summary>
 208         /// Sets or gets whether an image object is under animation.
 209         /// </summary>
 210         /// <remarks>
 211         /// An image object, even if it supports animation, will be displayed by default without animation.
 212         /// To actually start playing any image object's animation, <see cref="IsAnimated"/> should be TRUE before setting this property true.
 213         /// </remarks>
 214         public bool IsAnimationPlaying
 215         {
 216             get
 217             {
 218                 return Interop.Elementary.elm_image_animated_play_get(RealHandle);
 219             }
 220             set
 221             {
 222                 Interop.Elementary.elm_image_animated_play_set(RealHandle, value);
 223             }
 224         }
 225
 226         /// <summary>
 227         /// Sets or gets whether the image is 'editable'.
 228         /// </summary>
 229         public bool IsEditable
 230         {
 231             get
 232             {
 233                 return Interop.Elementary.elm_image_editable_get(RealHandle);
 234             }
 235             set
 236             {
 237                 Interop.Elementary.elm_image_editable_set(RealHandle, value);
 238             }
 239         }
 240
 241         /// <summary>
 242         /// Gets the current size of the image.
 243         /// </summary>
 244         public Size ObjectSize
 245         {
 246             get
 247             {
 248                 Interop.Elementary.elm_image_object_size_get(RealHandle, out int w, out int h);
 249                 return new Size(w, h);
 250             }
 251         }
 252
 253         /// <summary>
 254         /// Sets or gets whether alpha channel data is being used on the given image object.
 255         /// </summary>
 256         public bool IsOpaque
 257         {
 258             get
 259             {
 260                 if (ImageObject != null)
 261                 {
 262                     return ImageObject.IsOpaque;
 263                 }
 264                 return false;
 265             }
 266             set
 267             {
 268                 if (ImageObject != null)
 269                 {
 270                     ImageObject.IsOpaque = value;
 271                 }
 272             }
 273         }
 274
 275         /// <summary>
 276         /// Sets or gets the image orientation.
 277         /// </summary>
 278         public ImageOrientation Orientation
 279         {
 280             get
 281             {
 282                 return (ImageOrientation)Interop.Elementary.elm_image_orient_get(RealHandle);
 283             }
 284             set
 285             {
 286                 Interop.Elementary.elm_image_orient_set(RealHandle, (int)value);
 287             }
 288         }
 289
 290         /// <summary>
 291         /// Sets or gets the image color
 292         /// </summary>
 293         public override Color Color
 294         {
 295             get
 296             {
 297                 return _color;
 298             }
 299             set
 300             {
 301                 if (ImageObject != null)
 302                 {
 303                     if (value.IsDefault)
 304                     {
 305                         ImageObject.Color = Color.FromRgba(255, 255, 255, 255);
 306                     }
 307                     else
 308                     {
 309                         ImageObject.Color = value;
 310                     }
 311                 }
 312                 _color = value;
 313             }
 314         }
 315
 316         /// <summary>
 317         /// Sets the background color
 318         /// </summary>
 319         public override Color BackgroundColor
 320         {
 321             set
 322             {
 323                 if (value.IsDefault)
 324                 {
 325                     SetPartColor("bg", Color.Transparent);
 326                 }
 327                 else
 328                 {
 329                     SetPartColor("bg", value);
 330                 }
 331                 _backgroundColor = value;
 332             }
 333         }
 334
 335         public EvasImage ImageObject
 336         {
 337             get
 338             {
 339                 if (_imageObject == null)
 340                 {
 341                     IntPtr evasObj = Interop.Elementary.elm_image_object_get(RealHandle);
 342                     if (evasObj != IntPtr.Zero)
 343                         _imageObject = new EvasImage(this, evasObj);
 344                 }
 345                 return _imageObject;
 346             }
 347         }
 348
 349         /// <summary>
 350         /// Sets the dimensions for an image object's border, a region which is not scaled together with its center ever.
 351         /// </summary>
 352         /// <param name="left">The border's left width</param>
 353         /// <param name="right">The border's right width</param>
 354         /// <param name="top">The border's top width</param>
 355         /// <param name="bottom">The border's bottom width</param>
 356         public void SetBorder(int left, int right, int top, int bottom)
 357         {
 358             ImageObject?.SetBorder(left, right, top, bottom);
 359         }
 360
 361         /// <summary>
 362         /// Sets or gets if the center part of the given image object (not the border) should be drawn.
 363         /// </summary>
 364         /// <remarks>
 365         /// When rendering, the image may be scaled to fit the size of the image object.
 366         /// This function sets if the center part of the scaled image is to be drawn or left completely blank, or forced to be solid.
 367         /// Very useful for frames and decorations.
 368         /// </remarks>
 369         public ImageBorderFillMode BorderCenterFillMode
 370         {
 371             get
 372             {
 373                 if (ImageObject != null)
 374                 {
 375                     return ImageObject.BorderCenterFillMode;
 376                 }
 377                 else
 378                 {
 379                     return default(ImageBorderFillMode);
 380                 }
 381
 382             }
 383             set
 384             {
 385                 if (ImageObject != null)
 386                 {
 387                     ImageObject.BorderCenterFillMode = value;
 388                 }
 389             }
 390         }
 391
 392         /// <summary>
 393         /// Sets the file that is used as the image's source.
 394         /// </summary>
 395         /// <param name="file">The path to the file that is used as an image source</param>
 396         /// <returns>(true = success, false = error)</returns>
 397         public bool Load(string file)
 398         {
 399             if (file == null)
 400                 throw new ArgumentNullException("file");
 401
 402             Interop.Elementary.elm_image_async_open_set(RealHandle, false);
 403             Interop.Elementary.elm_image_preload_disabled_set(RealHandle, true);
 404             return Interop.Elementary.elm_image_file_set(RealHandle, file, null);
 405         }
 406
 407         /// <summary>
 408         /// Sets the uri that is used as the image's source.
 409         /// </summary>
 410         /// <param name="uri">The uri to the file that is used as an image source</param>
 411         /// <returns>(true = success, false = error)</returns>
 412         public bool Load(Uri uri)
 413         {
 414             if (uri == null)
 415                 throw new ArgumentNullException("uri");
 416
 417             return Load(uri.IsFile ? uri.LocalPath : uri.AbsoluteUri);
 418         }
 419
 420         /// <summary>
 421         /// Sets a location in the memory to be used as an image object's source bitmap.
 422         /// </summary>
 423         /// <remarks>
 424         /// This function is handy when the contents of an image file are mapped into the memory, for example.
 425         /// The format string should be something like "png", "jpg", "tga", "tiff", "bmp" etc, when provided (null, on the contrary).
 426         /// This improves the loader performance as it tries the "correct" loader first, before trying a range of other possible loaders until one succeeds.
 427         /// </remarks>
 428         /// <param name="img">The binary data that is used as an image source</param>
 429         /// <param name="size">The size of the binary data blob img</param>
 430         /// <returns>(true = success, false = error)</returns>
 431         [Obsolete("This method will be removed. Use Load(Stream stream) instead.")]
 432         public unsafe bool Load(byte* img, long size)
 433         {
 434             if (img == null)
 435                 throw new ArgumentNullException("img");
 436
 437             Interop.Elementary.elm_image_async_open_set(RealHandle, false);
 438             Interop.Elementary.elm_image_preload_disabled_set(RealHandle, true);
 439             return Interop.Elementary.elm_image_memfile_set(RealHandle, img, size, IntPtr.Zero, IntPtr.Zero);
 440         }
 441
 442         /// <summary>
 443         /// Sets the stream that is used as the image's source.
 444         /// </summary>
 445         /// <param name="stream">The stream that is used as an image source</param>
 446         /// <returns>(true = success, false = error)</returns>
 447         public bool Load(Stream stream)
 448         {
 449             if (stream == null)
 450                 throw new ArgumentNullException("stream");
 451
 452             Interop.Elementary.elm_image_async_open_set(RealHandle, false);
 453             Interop.Elementary.elm_image_preload_disabled_set(RealHandle, true);
 454             MemoryStream memstream = new MemoryStream();
 455             stream.CopyTo(memstream);
 456             unsafe
 457             {
 458                 byte[] dataArr = memstream.ToArray();
 459                 fixed (byte* data = &dataArr[0])
 460                 {
 461                     return Interop.Elementary.elm_image_memfile_set(RealHandle, data, dataArr.Length, IntPtr.Zero, IntPtr.Zero);
 462                 }
 463             }
 464         }
 465
 466         /// <summary>
 467         /// Sets the file that is used as the image's source with async.
 468         /// </summary>
 469         /// <param name="file">The path to the file that is used as an image source</param>
 470         /// <param name="cancellationToken">cancellation token</param>
 471         /// <returns>(true = success, false = error)</returns>
 472         public Task<bool> LoadAsync(string file, CancellationToken cancellationToken = default(CancellationToken))
 473         {
 474             if (file == null)
 475                 throw new ArgumentNullException("file");
 476
 477             Interop.Elementary.elm_image_async_open_set(RealHandle, true);
 478             Interop.Elementary.elm_image_preload_disabled_set(RealHandle, false);
 479
 480             var tcs = new TaskCompletionSource<bool>();
 481
 482             cancellationToken.Register(() =>
 483             {
 484                 if (tcs != null && !tcs.Task.IsCompleted)
 485                 {
 486                     tcs.SetCanceled();
 487                 }
 488             });
 489
 490             SmartEvent loadReady = new SmartEvent(this, RealHandle, "load,ready");
 491             loadReady.On += (s, e) =>
 492             {
 493                 loadReady.Dispose();
 494                 LoadingCompleted?.Invoke(this, EventArgs.Empty);
 495                 if (tcs != null && !tcs.Task.IsCompleted)
 496                 {
 497                     tcs.SetResult(true);
 498                 }
 499             };
 500
 501             SmartEvent loadError = new SmartEvent(this, RealHandle, "load,error");
 502             loadError.On += (s, e) =>
 503             {
 504                 loadError.Dispose();
 505                 LoadingFailed?.Invoke(this, EventArgs.Empty);
 506                 if (tcs != null && !tcs.Task.IsCompleted)
 507                 {
 508                     tcs.SetResult(false);
 509                 }
 510             };
 511
 512             bool ret = Interop.Elementary.elm_image_file_set(RealHandle, file, null);
 513             if (!ret)
 514             {
 515                 throw new InvalidOperationException("Failed to set file to Image");
 516             }
 517
 518             return tcs.Task;
 519         }
 520
 521         /// <summary>
 522         /// Sets the uri that is used as the image's source with async.
 523         /// </summary>
 524         /// <param name="uri">The uri to the file that is used as an image source</param>
 525         /// <param name="cancellationToken">cancellation token</param>
 526         /// <returns>(true = success, false = error)</returns>
 527         public Task<bool> LoadAsync(Uri uri, CancellationToken cancellationToken = default(CancellationToken))
 528         {
 529             if (uri == null)
 530                 throw new ArgumentNullException("uri");
 531
 532             return LoadAsync(uri.IsFile ? uri.LocalPath : uri.AbsoluteUri, cancellationToken);
 533         }
 534
 535         /// <summary>
 536         /// Sets the stream that is used as the image's source with async.
 537         /// </summary>
 538         /// <param name="stream">The stream that is used as an image source</param>
 539         /// <param name="cancellationToken">cancellation token</param>
 540         /// <returns>(true = success, false = error)</returns>
 541         public async Task<bool> LoadAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken))
 542         {
 543             if (stream == null)
 544                 throw new ArgumentNullException("stream");
 545
 546             Interop.Elementary.elm_image_async_open_set(RealHandle, true);
 547             Interop.Elementary.elm_image_preload_disabled_set(RealHandle, false);
 548
 549             var tcs = new TaskCompletionSource<bool>();
 550
 551             cancellationToken.Register(() =>
 552             {
 553                 if (tcs != null && !tcs.Task.IsCompleted)
 554                 {
 555                     tcs.SetCanceled();
 556                 }
 557             });
 558
 559             SmartEvent loadReady = new SmartEvent(this, RealHandle, "load,ready");
 560             loadReady.On += (s, e) =>
 561             {
 562                 loadReady.Dispose();
 563                 LoadingCompleted?.Invoke(this, EventArgs.Empty);
 564                 if (tcs != null && !tcs.Task.IsCompleted)
 565                 {
 566                     tcs.SetResult(true);
 567                 }
 568             };
 569
 570             SmartEvent loadError = new SmartEvent(this, RealHandle, "load,error");
 571             loadError.On += (s, e) =>
 572             {
 573                 loadError.Dispose();
 574                 LoadingFailed?.Invoke(this, EventArgs.Empty);
 575                 if (tcs != null && !tcs.Task.IsCompleted)
 576                 {
 577                     tcs.SetResult(false);
 578                 }
 579             };
 580
 581             MemoryStream memstream = new MemoryStream();
 582             await stream.CopyToAsync(memstream);
 583
 584             unsafe
 585             {
 586                 byte[] dataArr = memstream.ToArray();
 587                 fixed (byte* data = &dataArr[0])
 588                 {
 589                     bool ret = Interop.Elementary.elm_image_memfile_set(RealHandle, data, dataArr.Length, IntPtr.Zero, IntPtr.Zero);
 590                     if (!ret)
 591                     {
 592                         return false;
 593                     }
 594                 }
 595             }
 596
 597             return await tcs.Task;
 598         }
 599
 600         /// <summary>
 601         /// Sets the color of color class for a given widget.
 602         /// </summary>
 603         /// <param name="part">The name of color class.</param>
 604         /// <param name="color">The struct of color</param>
 605         public override void SetPartColor(string part, Color color)
 606         {
 607             Interop.Elementary.elm_object_color_class_color_set(Handle, part, color.R * color.A / 255,
 608                                                                               color.G * color.A / 255,
 609                                                                               color.B * color.A / 255,
 610                                                                               color.A);
 611         }
 612
 613         /// <summary>
 614         /// Gets the color of color class for a given widget.
 615         /// </summary>
 616         /// <param name="part">The name of color class.</param>
 617         /// <returns>color object</returns>
 618         public override Color GetPartColor(string part)
 619         {
 620             Interop.Elementary.elm_object_color_class_color_get(Handle, part, out int r, out int g, out int b, out int a);
 621             return new Color((int)(r / (a / 255.0)), (int)(g / (a / 255.0)), (int)(b / (a / 255.0)), a);
 622         }
 623
 624         /// <summary>
 625         /// Sets the content at a part of a given container widget.
 626         /// </summary>
 627         /// <param name="parent">The parent is a given container which will be attached by Image as a child. It's <see cref="EvasObject"/> type.</param>
 628         /// <returns>The new object, otherwise null if it cannot be created</returns>
 629         protected override IntPtr CreateHandle(EvasObject parent)
 630         {
 631             IntPtr handle = Interop.Elementary.elm_layout_add(parent);
 632             Interop.Elementary.elm_layout_theme_set(handle, "layout", "background", "default");
 633
 634             RealHandle = Interop.Elementary.elm_image_add(handle);
 635             Interop.Elementary.elm_object_part_content_set(handle, "elm.swallow.content", RealHandle);
 636
 637             return handle;
 638         }
 639     }
 640
 641     /// <summary>
 642     /// Enumeration for the fill mode of image border
 643     /// </summary>
 644     public enum ImageBorderFillMode
 645     {
 646         /// <summary>
 647         /// None mode of image border
 648         /// </summary>
 649         None,
 650
 651         /// <summary>
 652         /// Default mode of image border
 653         /// </summary>
 654         Default,
 655
 656         /// <summary>
 657         /// Solid mode of image border
 658         /// </summary>
 659         Solid,
 660     }
 661
 662     /// <summary>
 663     /// Enumeration for the possible orientation options
 664     /// </summary>
 665     public enum ImageOrientation : int
 666     {
 667         /// <summary>
 668         /// No orientation change
 669         /// </summary>
 670         None = 0,
 671
 672         /// <summary>
 673         /// Rotate 90 degrees clockwise
 674         /// </summary>
 675         Rotate90,
 676
 677         /// <summary>
 678         /// Rotate 180 degrees clockwise
 679         /// </summary>
 680         Rotate180,
 681
 682         /// <summary>
 683         /// Rotate 90 degrees counter-clockwise (i.e. 270 degrees clockwise)
 684         /// </summary>
 685         Rotate270,
 686
 687         /// <summary>
 688         /// Flip image horizontally
 689         /// </summary>
 690         FlipHorizontal,
 691
 692         /// <summary>
 693         /// Flip image vertically
 694         /// </summary>
 695         FlipVertical,
 696
 697         /// <summary>
 698         /// Flip the image along the y = (width - x) line (bottom-left to top-right)
 699         /// </summary>
 700         FlipTranspose,
 701
 702         /// <summary>
 703         /// Flip the image along the y = x line (top-left to bottom-right)
 704         /// </summary>
 705         FlipTransverse
 706     }
 707 }