src/ElmSharp/ElmSharp/EvasImage.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.Collections.Generic;
  19 using System.ComponentModel;
  20 using System.IO;
  21 using System.Text;
  22
  23 namespace ElmSharp
  24 {
  25     /// <summary>
  26     /// This group provides functions for image objects.
  27     /// </summary>
  28     /// <since_tizen> preview </since_tizen>
  29     public class EvasImage : EvasObject
  30     {
  31         EvasObject _source = null;
  32         IntPtr _handle = IntPtr.Zero;
  33
  34         /// <summary>
  35         /// Creates and initializes a new instance of EvasImage class.
  36         /// </summary>
  37         /// <param name="parent">The parent is a given container which will be attached by EvasImage as a child. It's <see cref="EvasObject"/> type.</param>
  38         /// <since_tizen> preview </since_tizen>
  39         public EvasImage(EvasObject parent) : base(parent)
  40         {
  41         }
  42
  43         internal EvasImage(EvasObject parent, IntPtr handle) : base()
  44         {
  45             _handle = handle;
  46             Realize(parent);
  47         }
  48
  49         /// <summary>
  50         /// Sets or gets the source file from where an image object must fetch the real image data
  51         /// </summary>
  52         /// <since_tizen> preview </since_tizen>
  53         public string File
  54         {
  55             get
  56             {
  57                 string file, key;
  58                 Interop.Evas.evas_object_image_file_get(RealHandle, out file, out key);
  59                 return file;
  60             }
  61             set
  62             {
  63                 Interop.Evas.evas_object_image_file_set(RealHandle, value, null);
  64             }
  65         }
  66
  67         /// <summary>
  68         /// Sets or gets the source object to be visible.
  69         /// </summary>
  70         /// <since_tizen> preview </since_tizen>
  71         public bool IsSourceVisible
  72         {
  73             get
  74             {
  75                 return Interop.Evas.evas_object_image_source_visible_get(RealHandle);
  76             }
  77             set
  78             {
  79                 Interop.Evas.evas_object_image_source_visible_set(RealHandle, value);
  80             }
  81         }
  82
  83         /// <summary>
  84         /// Sets or gets whether an object is clipped by source object's clipper.
  85         /// </summary>
  86         /// <since_tizen> preview </since_tizen>
  87         public bool IsSourceClipped
  88         {
  89             get
  90             {
  91                 return Interop.Evas.evas_object_image_source_clip_get(RealHandle);
  92             }
  93             set
  94             {
  95                 Interop.Evas.evas_object_image_source_clip_set(RealHandle, value);
  96             }
  97         }
  98
  99         /// <summary>
 100         /// Sets or gets if the center part of the given image object (not the border) should be drawn.
 101         /// </summary>
 102         /// <remarks>
 103         /// When rendering, the image may be scaled to fit the size of the image object.
 104         /// This function sets if the center part of the scaled image is to be drawn or left completely blank, or forced to be solid.
 105         /// Very useful for frames and decorations.
 106         /// </remarks>
 107         /// <since_tizen> preview </since_tizen>
 108         public ImageBorderFillMode BorderCenterFillMode
 109         {
 110             get
 111             {
 112                 return (ImageBorderFillMode)Interop.Evas.evas_object_image_border_center_fill_get(RealHandle);
 113             }
 114             set
 115             {
 116                 Interop.Evas.evas_object_image_border_center_fill_set(RealHandle, (int)value);
 117             }
 118         }
 119
 120         /// <summary>
 121         /// Sets or gets whether the image object's fill property should track the object's size.
 122         /// </summary>
 123         /// <since_tizen> preview </since_tizen>
 124         public bool IsFilled
 125         {
 126             get
 127             {
 128                 return Interop.Evas.evas_object_image_filled_get(RealHandle);
 129             }
 130             set
 131             {
 132                 Interop.Evas.evas_object_image_filled_set(RealHandle, value);
 133             }
 134         }
 135
 136         /// <summary>
 137         /// Sets or gets the scaling factor (multiplier) for the borders of an image object.
 138         /// </summary>
 139         /// <since_tizen> preview </since_tizen>
 140         public double BorderScale
 141         {
 142             get
 143             {
 144                 return Interop.Evas.evas_object_image_border_scale_get(RealHandle);
 145             }
 146             set
 147             {
 148                 Interop.Evas.evas_object_image_border_scale_set(RealHandle, value);
 149             }
 150         }
 151
 152         /// <summary>
 153         /// Sets or gets the size of the given image object.
 154         /// </summary>
 155         /// <since_tizen> preview </since_tizen>
 156         public Size Size
 157         {
 158             get
 159             {
 160                 int w, h;
 161                 Interop.Evas.evas_object_image_size_get(RealHandle, out w, out h);
 162                 return new Size(w, h);
 163             }
 164             set
 165             {
 166                 Interop.Evas.evas_object_image_size_set(RealHandle, value.Width, value.Height);
 167             }
 168         }
 169
 170         /// <summary>
 171         /// Gets the row stride of the given image object.
 172         /// </summary>
 173         /// <since_tizen> preview </since_tizen>
 174         public int Stride
 175         {
 176             get
 177             {
 178                 return Interop.Evas.evas_object_image_stride_get(RealHandle);
 179             }
 180         }
 181
 182         /// <summary>
 183         /// Sets or gets whether alpha channel data is being used on the given image object.
 184         /// </summary>
 185         /// <since_tizen> preview </since_tizen>
 186         public bool IsOpaque
 187         {
 188             get
 189             {
 190                 return !Interop.Evas.evas_object_image_alpha_get(RealHandle);
 191             }
 192             set
 193             {
 194                 Interop.Evas.evas_object_image_alpha_set(RealHandle, !value);
 195             }
 196         }
 197
 198         /// <summary>
 199         /// Sets or gets whether to use high-quality image scaling algorithm on the given image object.
 200         /// </summary>
 201         /// <since_tizen> preview </since_tizen>
 202         public bool IsSmoothScaled
 203         {
 204             get
 205             {
 206                 return Interop.Evas.evas_object_image_smooth_scale_get(RealHandle);
 207             }
 208             set
 209             {
 210                 Interop.Evas.evas_object_image_smooth_scale_set(RealHandle, value);
 211             }
 212         }
 213
 214         /// <summary>
 215         /// Sets how to fill an image object's drawing rectangle given the (real) image bound to it.
 216         /// </summary>
 217         /// <param name="geometry"></param>
 218         /// <since_tizen> preview </since_tizen>
 219         public void SetFill(Rect geometry)
 220         {
 221             Interop.Evas.evas_object_image_fill_set(RealHandle, geometry.X, geometry.Y, geometry.Width, geometry.Height);
 222         }
 223
 224         /// <summary>
 225         /// Sets the source file from where an image object must fetch the real image data (it may be an Eet file, besides pure image ones).
 226         /// </summary>
 227         /// <param name="file">The image file path</param>
 228         /// <param name="key">The image key in file (if its an Eet one), otherwise set null</param>
 229         /// <since_tizen> preview </since_tizen>
 230         public void SetFile(string file, string key)
 231         {
 232             Interop.Evas.evas_object_image_file_set(RealHandle, file, key);
 233         }
 234
 235         /// <summary>
 236         /// Sets the data for an image from memory to be loaded.
 237         /// </summary>
 238         /// <param name="stream">memory stream</param>
 239         /// <since_tizen> preview </since_tizen>
 240         public void SetStream(Stream stream)
 241         {
 242             if (stream == null)
 243                 throw new ArgumentNullException("stream");
 244
 245             MemoryStream memstream = new MemoryStream();
 246             stream.CopyTo(memstream);
 247             unsafe
 248             {
 249                 byte[] dataArr = memstream.ToArray();
 250                 fixed (byte* data = &dataArr[0])
 251                 {
 252                     Interop.Evas.evas_object_image_memfile_set(RealHandle, data, dataArr.Length, IntPtr.Zero, IntPtr.Zero);
 253                 }
 254             }
 255             memstream.Dispose();
 256         }
 257
 258         /// <summary>
 259         /// Sets the source object on an image object to used as a proxy.
 260         /// </summary>
 261         /// <param name="source">The proxy (image) object</param>
 262         /// <returns>true if the source object is set successfully, ortherwise false on error</returns>
 263         /// <since_tizen> preview </since_tizen>
 264         public bool SetSource(EvasObject source)
 265         {
 266             bool result = false;
 267             _source = source;
 268             result = Interop.Evas.evas_object_image_source_set(RealHandle, IntPtr.Zero);
 269             if (source != null)
 270                 result = result && Interop.Evas.evas_object_image_source_set(RealHandle, source.Handle);
 271             return result;
 272         }
 273
 274         /// <summary>
 275         /// Set the native surface of a given image of the canvas
 276         /// </summary>
 277         /// <param name="surface">The surface.</param>
 278         /// <since_tizen> preview </since_tizen>
 279         [EditorBrowsable(EditorBrowsableState.Never)]
 280         public void SetNativeSurface(IntPtr surface)
 281         {
 282             Interop.Evas.evas_object_image_native_surface_set(RealHandle, surface);
 283         }
 284
 285         /// <summary>
 286         /// Sets the dimensions for an image object's border, a region which is not scaled together with its center ever.
 287         /// </summary>
 288         /// <param name="left">The border's left width</param>
 289         /// <param name="right">The border's right width</param>
 290         /// <param name="top">The border's top width</param>
 291         /// <param name="bottom">The border's bottom width</param>
 292         /// <since_tizen> preview </since_tizen>
 293         public void SetBorder(int left, int right, int top, int bottom)
 294         {
 295             Interop.Evas.evas_object_image_border_set(RealHandle, left, right, top, bottom);
 296         }
 297
 298         /// <summary>
 299         /// Sets the content at a part of a given container widget.
 300         /// </summary>
 301         /// <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>
 302         /// <returns>The new object, otherwise null if it cannot be created</returns>
 303         /// <since_tizen> preview </since_tizen>
 304         protected override IntPtr CreateHandle(EvasObject parent)
 305         {
 306             return _handle != IntPtr.Zero ? _handle : Interop.Evas.evas_object_image_add(Interop.Evas.evas_object_evas_get(parent.Handle));
 307         }
 308     }
 309 }