[New Module] Workspaces (#34324)

* spell checker * Adding OOBE Projects page * changed the default hotkey * module interface * rename projects editor * bug report tool * installer * gpo * exit event constant * extend search for projects by search over the containing apps' names * [Projects] fix grammatical issue #43 (1 app - many apps) * [Projects] Editor: Main page: fix layout if there are many apps, launch button not disappearing on the right side * dsc * github * pipeline * guid prefix * [Projects] fixing general settings gpo handling in runner + minor changes * arm build fix * Do not allow saving project if name or applist is empty. Also minor UI changes * version * editor version * spellcheck * editor dll signing * update projects names to filter them out * shortcut saving fix * [Projects] Editor: brining the highlighted app's icon into the foreground. + minor UI fixes * spell checker * spellcheck * [Projects] re-implementing icon size calculation to have similar sized icons for every app. * [projects] Adding info message for cases: there are no projects or no results for the search * [Projects] Adding Edit button to the popup. + minor changes * [Projects] Making popup having rounded corners * changed "no projects" text color and position * remove opening the first proj * fix placing windows of the same app in the project * [Projects] bringing back the breadcrumb on the editor page. Make it clickable. * [Projects] optimizing click handlers * [Projects] Removing not selected apps on save * moved on thread executor to common * moved display utils * added convert rect * unsigned monitor number * set awareness * app placement * [Projects] Re-implementing preview drawing - one common image * [Projects] fix boundary calculation, use DPI aware values * fix launching with command line args * Fix ARM64 CI build * launch packaged apps using names when possible * spell-check * update packaged apps path * projects editor single instance * [Projects] Add Select all checkbox, Delete selected button * Add Checkbox for per monitor selection * modifying highlight in preview * spell checker * logs * exclude help windows https://github.com/JaneaSystems/PowerToys-DevProjects/issues/49 * Add intermediate step to project creation * minor bugfix * mutex fix * modifying highlight for minimized apps * Fixing bug: re-draw the preview on app deletion in the editor * Adding helper class for getting the right bounds for screens * spell checker * spell checker * Minor fixes in the capture dialog * get dpi unaware screen bounds * refactoring: added utils * changed window filter https://github.com/JaneaSystems/PowerToys-DevProjects/issues/2 * clean up * refactoring * projects common lib * localizable default project prefix * launcher resources * clean up * change snapshot project saving https://github.com/JaneaSystems/PowerToys-DevProjects/issues/14 * changed project data https://github.com/JaneaSystems/PowerToys-DevProjects/issues/14 * changed project creation save-cancel handles https://github.com/JaneaSystems/PowerToys-DevProjects/issues/14 * spell-check * Remove checkboxes, delete feature * remove unused from the project * get command line args in the snapshot * minimized settings snap fix * set window property after launching * FZ: ignore projects launched windows * Implementing major new features: remove button, position manipulation, arguments, admin, minimized, maximized * modifying colors * launcher project filters * clean up * Hide Admin checkbox * hide WIP * spell-check * Revert "Hide Admin checkbox" This reverts commit 3036df9d7f. * get app elevated property * Implementing Launch and Edit feature * fixing: update of listed projects on the main page after hitting save in editor * Fix for packaged app's icons * fixing scroll speed issue * change scroll speed to 15 * launch elevated apps * minor fixes * minor fix * enhancing shortcut handling * can-launch-elevated check * projects module interface telemetry * Implementing store of setting "order by". * minor string correction * moved projects data parsing * telemetry * add move apps checkbox * notification about elevated apps * restart unelevated * move existing windows * keep opened windows at the same positions * handle powertoys settings * use common theme * fix corrupted data: project id and monitor id * project launch on "launch and edit" * clean up * show screen numbers instead of monitor names * launcher error messages * fix default shortcut * Adding launch button to projects settings, dashboard and flyout * Adding new app which is launched when launching a project. It shows the status of the launch process * spell checker * Renaming Projects to App Layouts. Replacing only string values, not the variable names * Re-ordering modules after Renaming Projects + spell checker * setting window size according to the screen (making it bigger) * commenting out feature "move apps if exist" * spell checker * Add ProjectsLauncherUI to signing * opening apps in minimized state which are placed on a monitor, which is not found at the moment of launching * consistent file name * removed unused sln * telemetry: create event * WindowPosition comparison * telemetry: edit event * fix muted Launch as admin checkbox * telemetry: delete event * updated Edit telemetry event * added invoke point to launcher args * added utils * parse invoke point * replaced tuple with struct * telemetry: launch event * MonitorRect comparison * resources * rename: folders * remove outdated * rename: window property * rename: files and folders * rename: common data structures * rename: telemetry namespace * rename: workspaces data * rename ProjectsLib -> WorkspacesLib * rename: gpo * rename: settings * rename: launcher UI * rename: other * rename: pt run * rename: fz * rename: module interface * rename: icon * rename: snapshot tool * rename: editor * rename: common files * rename: launcher * rename: editor resources * fix empty file crash * rename: json * rename: module interface * fix custom actions build * added launch editor event constant * xaml formatting * Add missing method defition to interop::Constants idl Remove Any CPU config * more .sln cleanup * [Run][PowerToys] Fix Workspaces utility (#34336) polished workspaces utility * build fix - align CppWinRT version * address PR comment: fix isdigit * indentation * address PR comment: rename function * address PR comment: changed version for workspaces and revision * added supported version definition * addressPR comment: use BringToForeground * address PR comments: updated projects * address PR comment: uncomment gpo in settings * address PR comment: rename oobe view * update OOBE image with current module name * moved AppUtils * launching with AppUserModel.ID * fixed module order in settings * fix xaml formatting * [Workspaces] Close launcher if there are failed launches. Plus adding new spinner gif * fix topmost LauncherUI * clean up * UI closing * BugReportTool - omit cmd arg data * Delete icon on workspace removal * Adding cancellation to launcher UI. * reordered launching * fix terminating UI * Removing old shortcut on workspace renaming * Sentence case labels * get process path without waiting * comment out unused * remove unused argument * logs * New icon * fix launch and edit for the new project * fix launch and edit: save new project * Update exe icons --------- Co-authored-by: donlaci <laszlo@janeasystems.com> Co-authored-by: Jaime Bernardo <jaime@janeasystems.com> Co-authored-by: Stefan Markovic <stefan@janeasystems.com> Co-authored-by: Davide Giacometti <davide.giacometti@outlook.it> Co-authored-by: Niels Laute <niels.laute@live.nl>
2026-04-06 11:16:51 +02:00 · 2024-08-23 09:28:13 +02:00
parent 2a8e211cfd
commit 579619952d
221 changed files with 12805 additions and 12 deletions
--- a/src/modules/Workspaces/WorkspacesEditor/Models/AppListDataTemplateSelector.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/AppListDataTemplateSelector.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace WorkspacesEditor.Models
+{
+    public sealed class AppListDataTemplateSelector : System.Windows.Controls.DataTemplateSelector
+    {
+        public System.Windows.DataTemplate HeaderTemplate { get; set; }
+
+        public System.Windows.DataTemplate AppTemplate { get; set; }
+
+        public AppListDataTemplateSelector()
+        {
+            HeaderTemplate = new System.Windows.DataTemplate();
+            AppTemplate = new System.Windows.DataTemplate();
+        }
+
+        public override System.Windows.DataTemplate SelectTemplate(object item, System.Windows.DependencyObject container)
+        {
+            if (item is MonitorHeaderRow)
+            {
+                return HeaderTemplate;
+            }
+            else
+            {
+                return AppTemplate;
+            }
+        }
+    }
+}
--- a/src/modules/Workspaces/WorkspacesEditor/Models/Application.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/Application.cs
@@ -0,0 +1,474 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
+using System.Windows.Media.Imaging;
+using ManagedCommon;
+using Windows.Management.Deployment;
+
+namespace WorkspacesEditor.Models
+{
+    public class Application : INotifyPropertyChanged, IDisposable
+    {
+        private bool _isInitialized;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public Application()
+        {
+        }
+
+        public Application(Application other)
+        {
+            AppName = other.AppName;
+            AppPath = other.AppPath;
+            AppTitle = other.AppTitle;
+            PackageFullName = other.PackageFullName;
+            AppUserModelId = other.AppUserModelId;
+            CommandLineArguments = other.CommandLineArguments;
+            IsElevated = other.IsElevated;
+            CanLaunchElevated = other.CanLaunchElevated;
+            Minimized = other.Minimized;
+            Maximized = other.Maximized;
+            Position = other.Position;
+            MonitorNumber = other.MonitorNumber;
+
+            Parent = other.Parent;
+            IsNotFound = other.IsNotFound;
+            IsHighlighted = other.IsHighlighted;
+            RepeatIndex = other.RepeatIndex;
+            PackagedId = other.PackagedId;
+            PackagedName = other.PackagedName;
+            PackagedPublisherID = other.PackagedPublisherID;
+            Aumid = other.Aumid;
+            IsExpanded = other.IsExpanded;
+            IsIncluded = other.IsIncluded;
+        }
+
+        public Project Parent { get; set; }
+
+        public struct WindowPosition
+        {
+            public int X { get; set; }
+
+            public int Y { get; set; }
+
+            public int Width { get; set; }
+
+            public int Height { get; set; }
+
+            public static bool operator ==(WindowPosition left, WindowPosition right)
+            {
+                return left.X == right.X && left.Y == right.Y && left.Width == right.Width && left.Height == right.Height;
+            }
+
+            public static bool operator !=(WindowPosition left, WindowPosition right)
+            {
+                return left.X != right.X || left.Y != right.Y || left.Width != right.Width || left.Height != right.Height;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (obj == null || GetType() != obj.GetType())
+                {
+                    return false;
+                }
+
+                WindowPosition pos = (WindowPosition)obj;
+                return X == pos.X && Y == pos.Y && Width == pos.Width && Height == pos.Height;
+            }
+
+            public override int GetHashCode()
+            {
+                return base.GetHashCode();
+            }
+        }
+
+        public string AppName { get; set; }
+
+        public string AppPath { get; set; }
+
+        public string AppTitle { get; set; }
+
+        public string PackageFullName { get; set; }
+
+        public string AppUserModelId { get; set; }
+
+        public string CommandLineArguments { get; set; }
+
+        private bool _isElevated;
+
+        public bool IsElevated
+        {
+            get => _isElevated;
+            set
+            {
+                _isElevated = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(AppMainParams)));
+            }
+        }
+
+        public bool CanLaunchElevated { get; set; }
+
+        internal void SwitchDeletion()
+        {
+            IsIncluded = !IsIncluded;
+            RedrawPreviewImage();
+        }
+
+        private void RedrawPreviewImage()
+        {
+            if (_isInitialized)
+            {
+                Parent.Initialize(App.ThemeManager.GetCurrentTheme());
+            }
+        }
+
+        private bool _minimized;
+
+        public bool Minimized
+        {
+            get => _minimized;
+            set
+            {
+                _minimized = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(Minimized)));
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(EditPositionEnabled)));
+                RedrawPreviewImage();
+            }
+        }
+
+        private bool _maximized;
+
+        public bool Maximized
+        {
+            get => _maximized;
+            set
+            {
+                _maximized = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(Maximized)));
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(EditPositionEnabled)));
+                RedrawPreviewImage();
+            }
+        }
+
+        public bool EditPositionEnabled { get => !Minimized && !Maximized; }
+
+        private string _appMainParams;
+
+        public string AppMainParams
+        {
+            get
+            {
+                _appMainParams = _isElevated ? Properties.Resources.Admin : string.Empty;
+                if (!string.IsNullOrWhiteSpace(CommandLineArguments))
+                {
+                    _appMainParams += (_appMainParams == string.Empty ? string.Empty : " | ") + Properties.Resources.Args + ": " + CommandLineArguments;
+                }
+
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsAppMainParamVisible)));
+                return _appMainParams;
+            }
+        }
+
+        public bool IsAppMainParamVisible { get => !string.IsNullOrWhiteSpace(_appMainParams); }
+
+        private bool _isNotFound;
+
+        [JsonIgnore]
+        public bool IsNotFound
+        {
+            get
+            {
+                return _isNotFound;
+            }
+
+            set
+            {
+                if (_isNotFound != value)
+                {
+                    _isNotFound = value;
+                    OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsNotFound)));
+                }
+            }
+        }
+
+        [JsonIgnore]
+        public bool IsHighlighted { get; set; }
+
+        [JsonIgnore]
+        public int RepeatIndex { get; set; }
+
+        [JsonIgnore]
+        public string RepeatIndexString
+        {
+            get
+            {
+                return RepeatIndex <= 1 ? string.Empty : RepeatIndex.ToString(CultureInfo.InvariantCulture);
+            }
+        }
+
+        [JsonIgnore]
+        private Icon _icon = null;
+
+        [JsonIgnore]
+        public Icon Icon
+        {
+            get
+            {
+                if (_icon == null)
+                {
+                    try
+                    {
+                        if (IsPackagedApp)
+                        {
+                            Uri uri = GetAppLogoByPackageFamilyName();
+                            var bitmap = new Bitmap(uri.LocalPath);
+                            var iconHandle = bitmap.GetHicon();
+                            _icon = Icon.FromHandle(iconHandle);
+                        }
+                        else
+                        {
+                            _icon = Icon.ExtractAssociatedIcon(AppPath);
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        Logger.LogWarning($"Icon not found on app path: {AppPath}. Using default icon");
+                        IsNotFound = true;
+                        _icon = new Icon(@"images\DefaultIcon.ico");
+                    }
+                }
+
+                return _icon;
+            }
+        }
+
+        public Uri GetAppLogoByPackageFamilyName()
+        {
+            var pkgManager = new PackageManager();
+            var pkg = pkgManager.FindPackagesForUser(string.Empty, PackagedId).FirstOrDefault();
+
+            if (pkg == null)
+            {
+                return null;
+            }
+
+            return pkg.Logo;
+        }
+
+        private BitmapImage _iconBitmapImage;
+
+        public BitmapImage IconBitmapImage
+        {
+            get
+            {
+                if (_iconBitmapImage == null)
+                {
+                    try
+                    {
+                        Bitmap previewBitmap = new Bitmap(32, 32);
+                        using (Graphics graphics = Graphics.FromImage(previewBitmap))
+                        {
+                            graphics.SmoothingMode = SmoothingMode.AntiAlias;
+                            graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
+                            graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
+
+                            graphics.DrawIcon(Icon, new Rectangle(0, 0, 32, 32));
+                        }
+
+                        using (var memory = new MemoryStream())
+                        {
+                            previewBitmap.Save(memory, ImageFormat.Png);
+                            memory.Position = 0;
+
+                            var bitmapImage = new BitmapImage();
+                            bitmapImage.BeginInit();
+                            bitmapImage.StreamSource = memory;
+                            bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
+                            bitmapImage.EndInit();
+                            bitmapImage.Freeze();
+
+                            _iconBitmapImage = bitmapImage;
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.LogError($"Exception while drawing icon for app with path: {AppPath}. Exception message: {e.Message}");
+                    }
+                }
+
+                return _iconBitmapImage;
+            }
+        }
+
+        private WindowPosition _position;
+
+        public WindowPosition Position
+        {
+            get => _position;
+            set
+            {
+                _position = value;
+                _scaledPosition = null;
+            }
+        }
+
+        private WindowPosition? _scaledPosition;
+
+        public WindowPosition ScaledPosition
+        {
+            get
+            {
+                if (_scaledPosition == null)
+                {
+                    double scaleFactor = MonitorSetup.Dpi / 96.0;
+                    _scaledPosition = new WindowPosition()
+                    {
+                        X = (int)(scaleFactor * Position.X),
+                        Y = (int)(scaleFactor * Position.Y),
+                        Height = (int)(scaleFactor * Position.Height),
+                        Width = (int)(scaleFactor * Position.Width),
+                    };
+                }
+
+                return _scaledPosition.Value;
+            }
+        }
+
+        public int MonitorNumber { get; set; }
+
+        private MonitorSetup _monitorSetup;
+
+        public MonitorSetup MonitorSetup
+        {
+            get
+            {
+                if (_monitorSetup == null)
+                {
+                    _monitorSetup = Parent.Monitors.Where(x => x.MonitorNumber == MonitorNumber).FirstOrDefault();
+                }
+
+                return _monitorSetup;
+            }
+        }
+
+        public void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            PropertyChanged?.Invoke(this, e);
+        }
+
+        public void InitializationFinished()
+        {
+            _isInitialized = true;
+        }
+
+        private bool? _isPackagedApp;
+
+        public string PackagedId { get; set; }
+
+        public string PackagedName { get; set; }
+
+        public string PackagedPublisherID { get; set; }
+
+        public string Aumid { get; set; }
+
+        public bool IsPackagedApp
+        {
+            get
+            {
+                if (_isPackagedApp == null)
+                {
+                    if (!AppPath.StartsWith("C:\\Program Files\\WindowsApps\\", StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        _isPackagedApp = false;
+                    }
+                    else
+                    {
+                        string appPath = AppPath.Replace("C:\\Program Files\\WindowsApps\\", string.Empty);
+                        Regex packagedAppPathRegex = new Regex(@"(?<APPID>[^_]*)_\d+.\d+.\d+.\d+_x64__(?<PublisherID>[^\\]*)", RegexOptions.ExplicitCapture | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
+                        Match match = packagedAppPathRegex.Match(appPath);
+                        _isPackagedApp = match.Success;
+                        if (match.Success)
+                        {
+                            PackagedName = match.Groups["APPID"].Value;
+                            PackagedPublisherID = match.Groups["PublisherID"].Value;
+                            PackagedId = $"{PackagedName}_{PackagedPublisherID}";
+                            Aumid = $"{PackagedId}!App";
+                        }
+                    }
+                }
+
+                return _isPackagedApp.Value;
+            }
+        }
+
+        private bool _isExpanded;
+
+        public bool IsExpanded
+        {
+            get => _isExpanded;
+            set
+            {
+                if (_isExpanded != value)
+                {
+                    _isExpanded = value;
+                    OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsExpanded)));
+                }
+            }
+        }
+
+        public string DeleteButtonContent { get => _isIncluded ? Properties.Resources.Delete : Properties.Resources.AddBack; }
+
+        private bool _isIncluded = true;
+
+        public bool IsIncluded
+        {
+            get => _isIncluded;
+            set
+            {
+                if (_isIncluded != value)
+                {
+                    _isIncluded = value;
+                    OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsIncluded)));
+                    OnPropertyChanged(new PropertyChangedEventArgs(nameof(DeleteButtonContent)));
+                    if (!_isIncluded)
+                    {
+                        IsExpanded = false;
+                    }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+        }
+
+        internal void CommandLineTextChanged(string newCommandLineValue)
+        {
+            CommandLineArguments = newCommandLineValue;
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(AppMainParams)));
+        }
+
+        internal void MaximizedChecked()
+        {
+            Minimized = false;
+        }
+
+        internal void MinimizedChecked()
+        {
+            Maximized = false;
+        }
+    }
+}
--- a/src/modules/Workspaces/WorkspacesEditor/Models/Monitor.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/Monitor.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Windows;
+
+namespace WorkspacesEditor.Models
+{
+    public class Monitor
+    {
+        public string MonitorName { get; private set; }
+
+        public string MonitorInstanceId { get; private set; }
+
+        public int MonitorNumber { get; private set; }
+
+        public int Dpi { get; private set; }
+
+        public Rect MonitorDpiUnawareBounds { get; private set; }
+
+        public Rect MonitorDpiAwareBounds { get; private set; }
+
+        public Monitor(string monitorName, string monitorInstanceId, int number, int dpi, Rect dpiAwareBounds, Rect dpiUnawareBounds)
+        {
+            MonitorName = monitorName;
+            MonitorInstanceId = monitorInstanceId;
+            MonitorNumber = number;
+            Dpi = dpi;
+            MonitorDpiAwareBounds = dpiAwareBounds;
+            MonitorDpiUnawareBounds = dpiUnawareBounds;
+        }
+    }
+}
--- a/src/modules/Workspaces/WorkspacesEditor/Models/MonitorHeaderRow.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/MonitorHeaderRow.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace WorkspacesEditor.Models
+{
+    internal sealed class MonitorHeaderRow
+    {
+        public string MonitorName { get; set; }
+
+        public string SelectString { get; set; }
+    }
+}
--- a/src/modules/Workspaces/WorkspacesEditor/Models/MonitorSetup.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/MonitorSetup.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using System.Windows;
+
+namespace WorkspacesEditor.Models
+{
+    public class MonitorSetup : Monitor, INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            PropertyChanged?.Invoke(this, e);
+        }
+
+        public string MonitorInfo { get => MonitorName; }
+
+        public string MonitorInfoWithResolution { get => $"{MonitorName}    {MonitorDpiAwareBounds.Width}x{MonitorDpiAwareBounds.Height}"; }
+
+        public MonitorSetup(string monitorName, string monitorInstanceId, int number, int dpi, Rect dpiAwareBounds, Rect dpiUnawareBounds)
+            : base(monitorName, monitorInstanceId, number, dpi, dpiAwareBounds, dpiUnawareBounds)
+        {
+        }
+
+        public MonitorSetup(MonitorSetup other)
+            : base(other.MonitorName, other.MonitorInstanceId, other.MonitorNumber, other.Dpi, other.MonitorDpiAwareBounds, other.MonitorDpiUnawareBounds)
+        {
+        }
+    }
+}
--- a/src/modules/Workspaces/WorkspacesEditor/Models/Project.cs
+++ b/src/modules/Workspaces/WorkspacesEditor/Models/Project.cs
@@ -0,0 +1,376 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using System.Windows.Media.Imaging;
+using ManagedCommon;
+using WorkspacesEditor.Data;
+using WorkspacesEditor.Utils;
+
+namespace WorkspacesEditor.Models
+{
+    public class Project : INotifyPropertyChanged
+    {
+        [JsonIgnore]
+        public string EditorWindowTitle { get; set; }
+
+        public string Id { get; private set; }
+
+        private string _name;
+
+        public string Name
+        {
+            get
+            {
+                return _name;
+            }
+
+            set
+            {
+                _name = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(Name)));
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(CanBeSaved)));
+            }
+        }
+
+        public long CreationTime { get; } // in seconds
+
+        public long LastLaunchedTime { get; } // in seconds
+
+        public bool IsShortcutNeeded { get; set; }
+
+        public bool MoveExistingWindows { get; set; }
+
+        public string LastLaunched
+        {
+            get
+            {
+                string lastLaunched = WorkspacesEditor.Properties.Resources.LastLaunched + ": ";
+                if (LastLaunchedTime == 0)
+                {
+                    return lastLaunched + WorkspacesEditor.Properties.Resources.Never;
+                }
+
+                const int SECOND = 1;
+                const int MINUTE = 60 * SECOND;
+                const int HOUR = 60 * MINUTE;
+                const int DAY = 24 * HOUR;
+                const int MONTH = 30 * DAY;
+
+                DateTime lastLaunchDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(LastLaunchedTime);
+
+                var now = DateTime.UtcNow.Ticks;
+                var ts = DateTime.UtcNow - lastLaunchDateTime;
+                double delta = Math.Abs(ts.TotalSeconds);
+
+                if (delta < 1 * MINUTE)
+                {
+                    return lastLaunched + WorkspacesEditor.Properties.Resources.Recently;
+                }
+
+                if (delta < 2 * MINUTE)
+                {
+                    return lastLaunched + WorkspacesEditor.Properties.Resources.OneMinuteAgo;
+                }
+
+                if (delta < 45 * MINUTE)
+                {
+                    return lastLaunched + ts.Minutes + " " + WorkspacesEditor.Properties.Resources.MinutesAgo;
+                }
+
+                if (delta < 90 * MINUTE)
+                {
+                    return lastLaunched + WorkspacesEditor.Properties.Resources.OneHourAgo;
+                }
+
+                if (delta < 24 * HOUR)
+                {
+                    return lastLaunched + ts.Hours + " " + WorkspacesEditor.Properties.Resources.HoursAgo;
+                }
+
+                if (delta < 48 * HOUR)
+                {
+                    return lastLaunched + WorkspacesEditor.Properties.Resources.Yesterday;
+                }
+
+                if (delta < 30 * DAY)
+                {
+                    return lastLaunched + ts.Days + " " + WorkspacesEditor.Properties.Resources.DaysAgo;
+                }
+
+                if (delta < 12 * MONTH)
+                {
+                    int months = Convert.ToInt32(Math.Floor((double)ts.Days / 30));
+                    return lastLaunched + (months <= 1 ? WorkspacesEditor.Properties.Resources.OneMonthAgo : months + " " + WorkspacesEditor.Properties.Resources.MonthsAgo);
+                }
+                else
+                {
+                    int years = Convert.ToInt32(Math.Floor((double)ts.Days / 365));
+                    return lastLaunched + (years <= 1 ? WorkspacesEditor.Properties.Resources.OneYearAgo : years + " " + WorkspacesEditor.Properties.Resources.YearsAgo);
+                }
+            }
+        }
+
+        public bool CanBeSaved
+        {
+            get => Name.Length > 0 && Applications.Count > 0;
+        }
+
+        private bool _isRevertEnabled;
+
+        public bool IsRevertEnabled
+        {
+            get => _isRevertEnabled;
+            set
+            {
+                if (_isRevertEnabled != value)
+                {
+                    _isRevertEnabled = value;
+                    OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsRevertEnabled)));
+                }
+            }
+        }
+
+        private bool _isPopupVisible;
+
+        [JsonIgnore]
+        public bool IsPopupVisible
+        {
+            get
+            {
+                return _isPopupVisible;
+            }
+
+            set
+            {
+                _isPopupVisible = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(IsPopupVisible)));
+            }
+        }
+
+        public List<Application> Applications { get; set; }
+
+        public List<object> ApplicationsListed
+        {
+            get
+            {
+                List<object> applicationsListed = new List<object>();
+                ILookup<MonitorSetup, Application> apps = Applications.Where(x => !x.Minimized).ToLookup(x => x.MonitorSetup);
+                foreach (var appItem in apps.OrderBy(x => x.Key.MonitorDpiUnawareBounds.Left).ThenBy(x => x.Key.MonitorDpiUnawareBounds.Top))
+                {
+                    MonitorHeaderRow headerRow = new MonitorHeaderRow { MonitorName = "Screen " + appItem.Key.MonitorNumber, SelectString = Properties.Resources.SelectAllAppsOnMonitor + " " + appItem.Key.MonitorInfo };
+                    applicationsListed.Add(headerRow);
+                    foreach (Application app in appItem)
+                    {
+                        applicationsListed.Add(app);
+                    }
+                }
+
+                var minimizedApps = Applications.Where(x => x.Minimized);
+                if (minimizedApps.Any())
+                {
+                    MonitorHeaderRow headerRow = new MonitorHeaderRow { MonitorName = Properties.Resources.Minimized_Apps, SelectString = Properties.Resources.SelectAllMinimizedApps };
+                    applicationsListed.Add(headerRow);
+                    foreach (Application app in minimizedApps)
+                    {
+                        applicationsListed.Add(app);
+                    }
+                }
+
+                return applicationsListed;
+            }
+        }
+
+        [JsonIgnore]
+        public string AppsCountString
+        {
+            get
+            {
+                int count = Applications.Count;
+                return count.ToString(CultureInfo.InvariantCulture) + " " + (count == 1 ? Properties.Resources.App : Properties.Resources.Apps);
+            }
+        }
+
+        public List<MonitorSetup> Monitors { get; }
+
+        public bool IsPositionChangedManually { get; set; } // telemetry
+
+        private BitmapImage _previewIcons;
+        private BitmapImage _previewImage;
+        private double _previewImageWidth;
+
+        public Project(Project selectedProject)
+        {
+            Id = selectedProject.Id;
+            Name = selectedProject.Name;
+            PreviewIcons = selectedProject.PreviewIcons;
+            PreviewImage = selectedProject.PreviewImage;
+            IsShortcutNeeded = selectedProject.IsShortcutNeeded;
+            MoveExistingWindows = selectedProject.MoveExistingWindows;
+
+            int screenIndex = 1;
+
+            Monitors = new List<MonitorSetup>();
+            foreach (var item in selectedProject.Monitors.OrderBy(x => x.MonitorDpiAwareBounds.Left).ThenBy(x => x.MonitorDpiAwareBounds.Top))
+            {
+                Monitors.Add(item);
+                screenIndex++;
+            }
+
+            Applications = new List<Application>();
+            foreach (var item in selectedProject.Applications)
+            {
+                Application newApp = new Application(item);
+                newApp.Parent = this;
+                newApp.InitializationFinished();
+                Applications.Add(newApp);
+            }
+        }
+
+        public Project(ProjectData.ProjectWrapper project)
+        {
+            Id = project.Id;
+            Name = project.Name;
+            CreationTime = project.CreationTime;
+            LastLaunchedTime = project.LastLaunchedTime;
+            IsShortcutNeeded = project.IsShortcutNeeded;
+            MoveExistingWindows = project.MoveExistingWindows;
+            Monitors = new List<MonitorSetup>() { };
+            Applications = new List<Models.Application> { };
+
+            foreach (var app in project.Applications)
+            {
+                Models.Application newApp = new Models.Application()
+                {
+                    AppName = app.Application,
+                    AppPath = app.ApplicationPath,
+                    AppTitle = app.Title,
+                    PackageFullName = app.PackageFullName,
+                    AppUserModelId = app.AppUserModelId,
+                    Parent = this,
+                    CommandLineArguments = app.CommandLineArguments,
+                    IsElevated = app.IsElevated,
+                    CanLaunchElevated = app.CanLaunchElevated,
+                    Maximized = app.Maximized,
+                    Minimized = app.Minimized,
+                    IsNotFound = false,
+                    Position = new Models.Application.WindowPosition()
+                    {
+                        Height = app.Position.Height,
+                        Width = app.Position.Width,
+                        X = app.Position.X,
+                        Y = app.Position.Y,
+                    },
+                    MonitorNumber = app.Monitor,
+                };
+                newApp.InitializationFinished();
+                Applications.Add(newApp);
+            }
+
+            foreach (var monitor in project.MonitorConfiguration)
+            {
+                System.Windows.Rect dpiAware = new System.Windows.Rect(monitor.MonitorRectDpiAware.Left, monitor.MonitorRectDpiAware.Top, monitor.MonitorRectDpiAware.Width, monitor.MonitorRectDpiAware.Height);
+                System.Windows.Rect dpiUnaware = new System.Windows.Rect(monitor.MonitorRectDpiUnaware.Left, monitor.MonitorRectDpiUnaware.Top, monitor.MonitorRectDpiUnaware.Width, monitor.MonitorRectDpiUnaware.Height);
+                Monitors.Add(new MonitorSetup(monitor.Id, monitor.InstanceId, monitor.MonitorNumber, monitor.Dpi, dpiAware, dpiUnaware));
+            }
+        }
+
+        public BitmapImage PreviewIcons
+        {
+            get
+            {
+                return _previewIcons;
+            }
+
+            set
+            {
+                _previewIcons = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(PreviewIcons)));
+            }
+        }
+
+        public BitmapImage PreviewImage
+        {
+            get
+            {
+                return _previewImage;
+            }
+
+            set
+            {
+                _previewImage = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(PreviewImage)));
+            }
+        }
+
+        public double PreviewImageWidth
+        {
+            get
+            {
+                return _previewImageWidth;
+            }
+
+            set
+            {
+                _previewImageWidth = value;
+                OnPropertyChanged(new PropertyChangedEventArgs(nameof(PreviewImageWidth)));
+            }
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            PropertyChanged?.Invoke(this, e);
+        }
+
+        public async void Initialize(Theme currentTheme)
+        {
+            PreviewIcons = await Task.Run(() => DrawHelper.DrawPreviewIcons(this));
+            Rectangle commonBounds = GetCommonBounds();
+            PreviewImage = await Task.Run(() => DrawHelper.DrawPreview(this, commonBounds, currentTheme));
+            PreviewImageWidth = commonBounds.Width / (commonBounds.Height * 1.2 / 200);
+        }
+
+        private Rectangle GetCommonBounds()
+        {
+            double minX = Monitors.First().MonitorDpiAwareBounds.Left;
+            double minY = Monitors.First().MonitorDpiAwareBounds.Top;
+            double maxX = Monitors.First().MonitorDpiAwareBounds.Right;
+            double maxY = Monitors.First().MonitorDpiAwareBounds.Bottom;
+            for (int monitorIndex = 1; monitorIndex < Monitors.Count; monitorIndex++)
+            {
+                Monitor monitor = Monitors[monitorIndex];
+                minX = Math.Min(minX, monitor.MonitorDpiAwareBounds.Left);
+                minY = Math.Min(minY, monitor.MonitorDpiAwareBounds.Top);
+                maxX = Math.Max(maxX, monitor.MonitorDpiAwareBounds.Right);
+                maxY = Math.Max(maxY, monitor.MonitorDpiAwareBounds.Bottom);
+            }
+
+            return new Rectangle((int)minX, (int)minY, (int)(maxX - minX), (int)(maxY - minY));
+        }
+
+        public void UpdateAfterLaunchAndEdit(Project other)
+        {
+            Id = other.Id;
+            Name = other.Name;
+            IsRevertEnabled = true;
+        }
+
+        internal void CloseExpanders()
+        {
+            foreach (Application app in Applications)
+            {
+                app.IsExpanded = false;
+            }
+        }
+    }
+}