src/Tizen.NUI.XamlBuild/src/public/XamlBuild/CompiledConverters/PositionTypeConverter.cs

   1 /*
   2  * Copyright(c) 2022 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.Collections.Generic;
  18 using System.Globalization;
  19 using System.Linq;
  20
  21 using Mono.Cecil;
  22 using Mono.Cecil.Cil;
  23 using Tizen.NUI.Binding;
  24 using Tizen.NUI.Xaml;
  25 using Tizen.NUI.Xaml.Build.Tasks;
  26
  27 namespace Tizen.NUI.Xaml.Core.XamlC
  28 {
  29     internal class PositionTypeConverter : ICompiledTypeConverter
  30     {
  31         IEnumerable<Instruction> GenerateIL(ModuleDefinition module, params double[] args)
  32         {
  33             foreach (var d in args)
  34                 yield return Instruction.Create(OpCodes.Ldc_R8, d);
  35
  36             yield return Instruction.Create(OpCodes.Newobj, module.ImportCtorReference((XamlTask.nuiAssemblyName, XamlTask.nuiNameSpace, "Position"),
  37                 parameterTypes: args.Select(a => ("mscorlib", "System", "Single")).ToArray()));
  38         }
  39
  40         private IEnumerable<Instruction> ConvertToPoint(string value, ILContext context, BaseNode node)
  41         {
  42             var module = context.Body.Method.Module;
  43
  44             switch (value)
  45             {
  46                 case "Top":
  47                     return GenerateIL(module, 0.0);
  48                 case "Bottom":
  49                     return GenerateIL(module, 1.0);
  50                 case "Left":
  51                     return GenerateIL(module, 0.0);
  52                 case "Right":
  53                     return GenerateIL(module, 1.0);
  54                 case "Middle":
  55                     return GenerateIL(module, 0.5);
  56                 case "TopLeft":
  57                     return GenerateIL(module, 0.0, 0.0, 0.5);
  58                 case "TopCenter":
  59                     return GenerateIL(module, 0.5, 0.0, 0.5);
  60                 case "TopRight":
  61                     return GenerateIL(module, 1.0, 0.0, 0.5);
  62                 case "CenterLeft":
  63                     return GenerateIL(module, 0.0, 0.5, 0.5);
  64                 case "Center":
  65                     return GenerateIL(module, 0.5, 0.5, 0.5);
  66                 case "CenterRight":
  67                     return GenerateIL(module, 1.0, 0.5, 0.5);
  68                 case "BottomLeft":
  69                     return GenerateIL(module, 0.0, 1.0, 0.5);
  70                 case "BottomCenter":
  71                     return GenerateIL(module, 0.5, 1.0, 0.5);
  72                 case "BottomRight":
  73                     return GenerateIL(module, 1.0, 1.0, 0.5);
  74             }
  75
  76             throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
  77         }
  78
  79         public IEnumerable<Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
  80         {
  81             var module = context.Body.Method.Module;
  82
  83             var thickness = value.Split(',');
  84
  85             foreach (var thick in thickness)
  86             {
  87                 if (thick.EndsWith("dp") || thick.EndsWith("px"))
  88                 {
  89                     return null;
  90                 }
  91             }
  92
  93             if (3 == thickness.Length)
  94             {
  95                 double x, y, z;
  96
  97                 if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
  98                             double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y) &&
  99                             double.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out z))
 100                     return GenerateIL(module, x, y, z);
 101             }
 102             else if (2 == thickness.Length)
 103             {
 104                 double x, y;
 105
 106                 if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
 107                             double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
 108                     return GenerateIL(module, x, y, 0);
 109             }
 110             else if (1 == thickness.Length)
 111             {
 112                 if (value.Contains("."))
 113                 {
 114                     string[] parts = value.Split('.');
 115                     if (parts.Length == 2 && (parts[0].Trim() == "ParentOrigin" || parts[0].Trim() == "PivotPoint"))
 116                     {
 117                         string position = parts[parts.Length - 1].Trim();
 118                         return ConvertToPoint(position, context, node);
 119                     }
 120                 }
 121                 else
 122                 {
 123                     return ConvertToPoint(value, context, node);
 124                 }
 125             }
 126
 127             throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
 128         }
 129     }
 130
 131     internal class Position2DTypeConverter : ICompiledTypeConverter
 132     {
 133         IEnumerable<Instruction> GenerateIL(ModuleDefinition module, params int[] args)
 134         {
 135             foreach (var d in args)
 136                 yield return Instruction.Create(OpCodes.Ldc_I4, d);
 137
 138             yield return Instruction.Create(OpCodes.Newobj, module.ImportCtorReference((XamlTask.nuiAssemblyName, XamlTask.nuiNameSpace, "Position2D"),
 139                 parameterTypes: args.Select(a => ("mscorlib", "System", "Int32")).ToArray()));
 140         }
 141
 142         public IEnumerable<Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
 143         {
 144             var module = context.Body.Method.Module;
 145
 146             if (!string.IsNullOrEmpty(value))
 147             {
 148                 int x, y;
 149                 var thickness = value.Split(',');
 150
 151                 foreach (var thick in thickness)
 152                 {
 153                     if (thick.EndsWith("dp") || thick.EndsWith("px"))
 154                     {
 155                         return null;
 156                     }
 157                 }
 158
 159                 if (int.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
 160                     int.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
 161                     return GenerateIL(module, x, y);
 162             }
 163
 164             throw new XamlParseException($"Cannot convert \"{value}\" into Position2D", node);
 165         }
 166     }
 167 }
 168