1  // Copyright (c) Microsoft Corporation
  2  // The Microsoft Corporation licenses this file to you under the MIT license.
  3  // See the LICENSE file in the project root for more information.
  4  
  5  using System.Runtime.CompilerServices;
  6  using System.Text.Json;
  7  using System.Text.Json.Serialization;
  8  
  9  using Microsoft.PowerToys.Settings.Telemetry;
 10  using Microsoft.PowerToys.Telemetry;
 11  using Settings.UI.Library.Enumerations;
 12  
 13  namespace Microsoft.PowerToys.Settings.UI.Library
 14  {
 15      public class PowerPreviewProperties
 16      {
 17          public const string DefaultStlThumbnailColor = "#FFC924";
 18          public const int DefaultMonacoMaxFileSize = 50;
 19          public const int DefaultMonacoFontSize = 14;
 20          public const int DefaultSvgBackgroundColorMode = (int)SvgPreviewColorMode.Default;
 21          public const string DefaultSvgBackgroundSolidColor = "#FFFFFF";
 22          public const int DefaultSvgBackgroundCheckeredShade = (int)SvgPreviewCheckeredShade.Light;
 23  
 24          private bool enableSvgPreview = true;
 25  
 26          [JsonPropertyName("svg-previewer-toggle-setting")]
 27          [JsonConverter(typeof(BoolPropertyJsonConverter))]
 28          public bool EnableSvgPreview
 29          {
 30              get => enableSvgPreview;
 31              set
 32              {
 33                  if (value != enableSvgPreview)
 34                  {
 35                      LogTelemetryEvent(value);
 36                      enableSvgPreview = value;
 37                  }
 38              }
 39          }
 40  
 41          [JsonPropertyName("svg-previewer-background-color-mode")]
 42          public IntProperty SvgBackgroundColorMode { get; set; }
 43  
 44          [JsonPropertyName("svg-previewer-background-solid-color")]
 45          public StringProperty SvgBackgroundSolidColor { get; set; }
 46  
 47          [JsonPropertyName("svg-previewer-background-checkered-shade")]
 48          public IntProperty SvgBackgroundCheckeredShade { get; set; }
 49  
 50          private bool enableSvgThumbnail = true;
 51  
 52          [JsonPropertyName("svg-thumbnail-toggle-setting")]
 53          [JsonConverter(typeof(BoolPropertyJsonConverter))]
 54          public bool EnableSvgThumbnail
 55          {
 56              get => enableSvgThumbnail;
 57              set
 58              {
 59                  if (value != enableSvgThumbnail)
 60                  {
 61                      LogTelemetryEvent(value);
 62                      enableSvgThumbnail = value;
 63                  }
 64              }
 65          }
 66  
 67          private bool enableMdPreview = true;
 68  
 69          [JsonPropertyName("md-previewer-toggle-setting")]
 70          [JsonConverter(typeof(BoolPropertyJsonConverter))]
 71          public bool EnableMdPreview
 72          {
 73              get => enableMdPreview;
 74              set
 75              {
 76                  if (value != enableMdPreview)
 77                  {
 78                      LogTelemetryEvent(value);
 79                      enableMdPreview = value;
 80                  }
 81              }
 82          }
 83  
 84          private bool enableMonacoPreview = true;
 85  
 86          [JsonPropertyName("monaco-previewer-toggle-setting")]
 87          [JsonConverter(typeof(BoolPropertyJsonConverter))]
 88          public bool EnableMonacoPreview
 89          {
 90              get => enableMonacoPreview;
 91              set
 92              {
 93                  if (value != enableMonacoPreview)
 94                  {
 95                      LogTelemetryEvent(value);
 96                      enableMonacoPreview = value;
 97                  }
 98              }
 99          }
100  
101          private bool monacoPreviewWordWrap = true;
102  
103          [JsonPropertyName("monaco-previewer-toggle-setting-word-wrap")]
104          [JsonConverter(typeof(BoolPropertyJsonConverter))]
105          public bool EnableMonacoPreviewWordWrap
106          {
107              get => monacoPreviewWordWrap;
108              set
109              {
110                  if (value != monacoPreviewWordWrap)
111                  {
112                      LogTelemetryEvent(value);
113                      monacoPreviewWordWrap = value;
114                  }
115              }
116          }
117  
118          private bool monacoPreviewTryFormat;
119  
120          [JsonPropertyName("monaco-previewer-toggle-try-format")]
121          [JsonConverter(typeof(BoolPropertyJsonConverter))]
122          public bool MonacoPreviewTryFormat
123          {
124              get => monacoPreviewTryFormat;
125              set
126              {
127                  if (value != monacoPreviewTryFormat)
128                  {
129                      LogTelemetryEvent(value);
130                      monacoPreviewTryFormat = value;
131                  }
132              }
133          }
134  
135          [JsonPropertyName("monaco-previewer-max-file-size")]
136          public IntProperty MonacoPreviewMaxFileSize { get; set; }
137  
138          [JsonPropertyName("monaco-previewer-font-size")]
139          public IntProperty MonacoPreviewFontSize { get; set; }
140  
141          private bool monacoPreviewStickyScroll = true;
142  
143          [JsonPropertyName("monaco-previewer-sticky-scroll")]
144          [JsonConverter(typeof(BoolPropertyJsonConverter))]
145          public bool MonacoPreviewStickyScroll
146          {
147              get => monacoPreviewStickyScroll;
148              set
149              {
150                  if (value != monacoPreviewStickyScroll)
151                  {
152                      LogTelemetryEvent(value);
153                      monacoPreviewStickyScroll = value;
154                  }
155              }
156          }
157  
158          private bool monacoPreviewMinimap;
159  
160          [JsonPropertyName("monaco-previewer-minimap")]
161          [JsonConverter(typeof(BoolPropertyJsonConverter))]
162          public bool MonacoPreviewMinimap
163          {
164              get => monacoPreviewMinimap;
165              set
166              {
167                  if (value != monacoPreviewMinimap)
168                  {
169                      LogTelemetryEvent(value);
170                      monacoPreviewMinimap = value;
171                  }
172              }
173          }
174  
175          private bool enablePdfPreview;
176  
177          [JsonPropertyName("pdf-previewer-toggle-setting")]
178          [JsonConverter(typeof(BoolPropertyJsonConverter))]
179          public bool EnablePdfPreview
180          {
181              get => enablePdfPreview;
182              set
183              {
184                  if (value != enablePdfPreview)
185                  {
186                      LogTelemetryEvent(value);
187                      enablePdfPreview = value;
188                  }
189              }
190          }
191  
192          private bool enablePdfThumbnail;
193  
194          [JsonPropertyName("pdf-thumbnail-toggle-setting")]
195          [JsonConverter(typeof(BoolPropertyJsonConverter))]
196          public bool EnablePdfThumbnail
197          {
198              get => enablePdfThumbnail;
199              set
200              {
201                  if (value != enablePdfThumbnail)
202                  {
203                      LogTelemetryEvent(value);
204                      enablePdfThumbnail = value;
205                  }
206              }
207          }
208  
209          private bool enableGcodePreview = true;
210  
211          [JsonPropertyName("gcode-previewer-toggle-setting")]
212          [JsonConverter(typeof(BoolPropertyJsonConverter))]
213          public bool EnableGcodePreview
214          {
215              get => enableGcodePreview;
216              set
217              {
218                  if (value != enableGcodePreview)
219                  {
220                      LogTelemetryEvent(value);
221                      enableGcodePreview = value;
222                  }
223              }
224          }
225  
226          private bool enableBgcodePreview = true;
227  
228          [JsonPropertyName("bgcode-previewer-toggle-setting")]
229          [JsonConverter(typeof(BoolPropertyJsonConverter))]
230          public bool EnableBgcodePreview
231          {
232              get => enableBgcodePreview;
233              set
234              {
235                  if (value != enableBgcodePreview)
236                  {
237                      LogTelemetryEvent(value);
238                      enableBgcodePreview = value;
239                  }
240              }
241          }
242  
243          private bool enableGcodeThumbnail = true;
244  
245          [JsonPropertyName("gcode-thumbnail-toggle-setting")]
246          [JsonConverter(typeof(BoolPropertyJsonConverter))]
247          public bool EnableGcodeThumbnail
248          {
249              get => enableGcodeThumbnail;
250              set
251              {
252                  if (value != enableGcodeThumbnail)
253                  {
254                      LogTelemetryEvent(value);
255                      enableGcodeThumbnail = value;
256                  }
257              }
258          }
259  
260          private bool enableBgcodeThumbnail = true;
261  
262          [JsonPropertyName("bgcode-thumbnail-toggle-setting")]
263          [JsonConverter(typeof(BoolPropertyJsonConverter))]
264          public bool EnableBgcodeThumbnail
265          {
266              get => enableBgcodeThumbnail;
267              set
268              {
269                  if (value != enableBgcodeThumbnail)
270                  {
271                      LogTelemetryEvent(value);
272                      enableBgcodeThumbnail = value;
273                  }
274              }
275          }
276  
277          private bool enableStlThumbnail = true;
278  
279          [JsonPropertyName("stl-thumbnail-toggle-setting")]
280          [JsonConverter(typeof(BoolPropertyJsonConverter))]
281          public bool EnableStlThumbnail
282          {
283              get => enableStlThumbnail;
284              set
285              {
286                  if (value != enableStlThumbnail)
287                  {
288                      LogTelemetryEvent(value);
289                      enableStlThumbnail = value;
290                  }
291              }
292          }
293  
294          [JsonPropertyName("stl-thumbnail-color-setting")]
295          public StringProperty StlThumbnailColor { get; set; }
296  
297          private bool enableQoiPreview = true;
298  
299          [JsonPropertyName("qoi-previewer-toggle-setting")]
300          [JsonConverter(typeof(BoolPropertyJsonConverter))]
301          public bool EnableQoiPreview
302          {
303              get => enableQoiPreview;
304              set
305              {
306                  if (value != enableQoiPreview)
307                  {
308                      LogTelemetryEvent(value);
309                      enableQoiPreview = value;
310                  }
311              }
312          }
313  
314          private bool enableQoiThumbnail = true;
315  
316          [JsonPropertyName("qoi-thumbnail-toggle-setting")]
317          [JsonConverter(typeof(BoolPropertyJsonConverter))]
318          public bool EnableQoiThumbnail
319          {
320              get => enableQoiThumbnail;
321              set
322              {
323                  if (value != enableQoiThumbnail)
324                  {
325                      LogTelemetryEvent(value);
326                      enableQoiThumbnail = value;
327                  }
328              }
329          }
330  
331          public PowerPreviewProperties()
332          {
333              SvgBackgroundColorMode = new IntProperty(DefaultSvgBackgroundColorMode);
334              SvgBackgroundSolidColor = new StringProperty(DefaultSvgBackgroundSolidColor);
335              SvgBackgroundCheckeredShade = new IntProperty(DefaultSvgBackgroundCheckeredShade);
336              StlThumbnailColor = new StringProperty(DefaultStlThumbnailColor);
337              MonacoPreviewMaxFileSize = new IntProperty(DefaultMonacoMaxFileSize);
338              MonacoPreviewFontSize = new IntProperty(DefaultMonacoFontSize);
339          }
340  
341          public override string ToString()
342          {
343              return JsonSerializer.Serialize(this, SettingsSerializationContext.Default.PowerPreviewProperties);
344          }
345  
346          private static void LogTelemetryEvent(bool value, [CallerMemberName] string propertyName = null)
347          {
348              var dataEvent = new SettingsEnabledEvent()
349              {
350                  Value = value,
351                  Name = propertyName,
352              };
353              PowerToysTelemetry.Log.WriteEvent(dataEvent);
354          }
355      }
356  }