aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Tango.MachineStudio.Common/StudioViewModel.cs
blob: 9ce79703fb5a2e7e371ad2d6b398d60230f2d2a5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.DI;
using Tango.SharedUI;

namespace Tango.MachineStudio.Common
{
    /// <summary>
    /// Represents a Machine Studio view model
    /// </summary>
    /// <seealso cref="Tango.SharedUI.ViewModel" />
    /// <seealso cref="Tango.MachineStudio.Common.IStudioViewModel" />
    public abstract class StudioViewModel : ViewModel, IStudioViewModel
    {
        private bool _isVisible;
        /// <summary>
        /// Gets or sets a value indicating whether this view model view's is visible.
        /// </summary>
        public bool IsVisible
        {
            get { return _isVisible; }
            set { _isVisible = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="StudioViewModel{Module}"/> class.
        /// </summary>
        public StudioViewModel() : base()
        {

        }

        /// <summary>
        /// Called when the user has navigated out of this view model.
        /// </summary>
        public virtual void OnNavigatedFrom()
        {
            IsVisible = false;
        }

        /// <summary>
        /// Called when the user has navigated in to this view model.
        /// </summary>
        public virtual void OnNavigatedTo()
        {
            IsVisible = true;
        }

        /// <summary>
        /// Called before the application is shutting down.
        /// Return false to cancel the shutdown in case an important process is in progress.
        /// </summary>
        /// <returns></returns>
        public virtual Task<bool> OnShutdownRequest()
        {
            return Task.FromResult(true);
        }

        /// <summary>
        /// Called when application is shutting down.
        /// </summary>
        public virtual void OnShuttingDown()
        {

        }

        /// <summary>
        /// Called when the application has been started
        /// </summary>
        public virtual void OnApplicationStarted()
        {

        }

        /// <summary>
        /// Called when the application is ready and all modules are loaded.
        /// </summary>
        public abstract void OnApplicationReady();
    }

    /// <summary>
    /// Represents a Machine Studio view model with a support for a view contract.
    /// </summary>
    /// <typeparam name="TView"></typeparam>
    /// <seealso cref="Tango.SharedUI.ViewModel" />
    public abstract class StudioViewModel<TView> : StudioViewModel where TView : IView
    {
        /// <summary>
        /// Gets the view model's view.
        /// </summary>
        public TView View { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="StudioViewModel{TView}"/> class.
        /// </summary>
        public StudioViewModel() : base()
        {
            TangoIOC.Default.GetInstanceWhenAvailable<TView>((view) => 
            {
                View = view;
                OnViewAttached(view);
            });
        }

        /// <summary>
        /// Called when the view has been attached
        /// </summary>
        /// <param name="view">The view.</param>
        protected virtual void OnViewAttached(TView view)
        {
            //Do Nothing.
        }
    }
}
an class="n">lazyLoadingFunction; } Exception exception = null; IHighlightingDefinition def = null; try { using (var busyLock = BusyManager.Enter(this)) { if (!busyLock.Success) throw new InvalidOperationException("Tried to create delay-loaded highlighting definition recursively. Make sure the are no cyclic references between the highlighting definitions."); def = func(); } if (def == null) throw new InvalidOperationException("Function for delay-loading highlighting definition returned null"); } catch (Exception ex) { exception = ex; } lock (lockObj) { this.lazyLoadingFunction = null; if (this.definition == null && this.storedException == null) { this.definition = def; this.storedException = exception; } if (this.storedException != null) throw new HighlightingDefinitionInvalidException("Error delay-loading highlighting definition", this.storedException); return this.definition; } } public HighlightingRuleSet MainRuleSet { get { return GetDefinition().MainRuleSet; } } public HighlightingRuleSet GetNamedRuleSet(string name) { return GetDefinition().GetNamedRuleSet(name); } public HighlightingColor GetNamedColor(string name) { return GetDefinition().GetNamedColor(name); } public IEnumerable<HighlightingColor> NamedHighlightingColors { get { return GetDefinition().NamedHighlightingColors; } } public override string ToString() { return this.Name; } public IDictionary<string, string> Properties { get { var def = GetDefinition() as IHighlightingDefinition2; if (def != null) return def.Properties; return null; } } } readonly object lockObj = new object(); Dictionary<string, IHighlightingDefinition> highlightingsByName = new Dictionary<string, IHighlightingDefinition>(); Dictionary<string, IHighlightingDefinition> highlightingsByExtension = new Dictionary<string, IHighlightingDefinition>(StringComparer.OrdinalIgnoreCase); List<IHighlightingDefinition> allHighlightings = new List<IHighlightingDefinition>(); /// <summary> /// Gets a highlighting definition by name. /// Returns null if the definition is not found. /// </summary> public IHighlightingDefinition GetDefinition(string name) { lock (lockObj) { IHighlightingDefinition rh; if (highlightingsByName.TryGetValue(name, out rh)) return rh; else return null; } } /// <summary> /// Gets a copy of all highlightings. /// </summary> public ReadOnlyCollection<IHighlightingDefinition> HighlightingDefinitions { get { lock (lockObj) { return Array.AsReadOnly(allHighlightings.ToArray()); } } } /// <summary> /// Gets the names of the registered highlightings. /// </summary> [ObsoleteAttribute("Use the HighlightingDefinitions property instead.")] public IEnumerable<string> HighlightingNames { get { lock (lockObj) { return new List<string>(highlightingsByName.Keys); } } } /// <summary> /// Gets a highlighting definition by extension. /// Returns null if the definition is not found. /// </summary> public IHighlightingDefinition GetDefinitionByExtension(string extension) { lock (lockObj) { IHighlightingDefinition rh; if (highlightingsByExtension.TryGetValue(extension, out rh)) return rh; else return null; } } /// <summary> /// Registers a highlighting definition. /// </summary> /// <param name="name">The name to register the definition with.</param> /// <param name="extensions">The file extensions to register the definition for.</param> /// <param name="highlighting">The highlighting definition.</param> public void RegisterHighlighting(string name, string[] extensions, IHighlightingDefinition highlighting) { if (highlighting == null) throw new ArgumentNullException("highlighting"); lock (lockObj) { allHighlightings.Add(highlighting); if (name != null) { highlightingsByName[name] = highlighting; } if (extensions != null) { foreach (string ext in extensions) { highlightingsByExtension[ext] = highlighting; } } } } /// <summary> /// Registers a highlighting definition. /// </summary> /// <param name="name">The name to register the definition with.</param> /// <param name="extensions">The file extensions to register the definition for.</param> /// <param name="lazyLoadedHighlighting">A function that loads the highlighting definition.</param> public void RegisterHighlighting(string name, string[] extensions, Func<IHighlightingDefinition> lazyLoadedHighlighting) { if (lazyLoadedHighlighting == null) throw new ArgumentNullException("lazyLoadedHighlighting"); RegisterHighlighting(name, extensions, new DelayLoadedHighlightingDefinition(name, lazyLoadedHighlighting)); } /// <summary> /// Gets the default HighlightingManager instance. /// The default HighlightingManager comes with built-in highlightings. /// </summary> public static HighlightingManager Instance { get { return DefaultHighlightingManager.Instance; } } internal sealed class DefaultHighlightingManager : HighlightingManager { public new static readonly DefaultHighlightingManager Instance = new DefaultHighlightingManager(); public DefaultHighlightingManager() { Resources.RegisterBuiltInHighlightings(this); } // Registering a built-in highlighting internal void RegisterHighlighting(string name, string[] extensions, string resourceName) { try { #if DEBUG // don't use lazy-loading in debug builds, show errors immediately Xshd.XshdSyntaxDefinition xshd; using (Stream s = Resources.OpenStream(resourceName)) { using (XmlTextReader reader = new XmlTextReader(s)) { xshd = Xshd.HighlightingLoader.LoadXshd(reader, false); } } Debug.Assert(name == xshd.Name); if (extensions != null) Debug.Assert(System.Linq.Enumerable.SequenceEqual(extensions, xshd.Extensions)); else Debug.Assert(xshd.Extensions.Count == 0); // round-trip xshd: // string resourceFileName = Path.Combine(Path.GetTempPath(), resourceName); // using (XmlTextWriter writer = new XmlTextWriter(resourceFileName, System.Text.Encoding.UTF8)) { // writer.Formatting = Formatting.Indented; // new Xshd.SaveXshdVisitor(writer).WriteDefinition(xshd); // } // using (FileStream fs = File.Create(resourceFileName + ".bin")) { // new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter().Serialize(fs, xshd); // } // using (FileStream fs = File.Create(resourceFileName + ".compiled")) { // new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter().Serialize(fs, Xshd.HighlightingLoader.Load(xshd, this)); // } RegisterHighlighting(name, extensions, Xshd.HighlightingLoader.Load(xshd, this)); #else RegisterHighlighting(name, extensions, LoadHighlighting(resourceName)); #endif } catch (HighlightingDefinitionInvalidException ex) { throw new InvalidOperationException("The built-in highlighting '" + name + "' is invalid.", ex); } } [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "LoadHighlighting is used only in release builds")] Func<IHighlightingDefinition> LoadHighlighting(string resourceName) { Func<IHighlightingDefinition> func = delegate { Xshd.XshdSyntaxDefinition xshd; using (Stream s = Resources.OpenStream(resourceName)) { using (XmlTextReader reader = new XmlTextReader(s)) { // in release builds, skip validating the built-in highlightings xshd = Xshd.HighlightingLoader.LoadXshd(reader, true); } } return Xshd.HighlightingLoader.Load(xshd, this); }; return func; } } } }