protected EditorViewModel(IViewModelServiceProvider serviceProvider, MostRecentlyUsedFileCollection mru, string editorName) : base(serviceProvider) { AssetsPlugin.RegisterPlugin(typeof(AssetsEditorPlugin)); serviceProvider.Get <IEditorDialogService>(); ClearMRUCommand = new AnonymousCommand(serviceProvider, () => MRU.Clear()); OpenSettingsWindowCommand = new AnonymousCommand(serviceProvider, OpenSettingsWindow); OpenWebPageCommand = new AnonymousTaskCommand <string>(serviceProvider, OpenWebPage); #if DEBUG DebugCommand = new AnonymousCommand(serviceProvider, DebugFunction); #endif MRU = mru; MRU.MostRecentlyUsedFiles.CollectionChanged += MostRecentlyUsedFiles_CollectionChanged; UpdateRecentFiles(); serviceProvider.Get <IEditorDialogService>().RegisterDefaultTemplateProviders(); EditorName = editorName; if (Instance != null) { throw new InvalidOperationException("The EditorViewModel class can be instanced only once."); } Status = new StatusViewModel(ServiceProvider); Status.PushStatus("Ready"); Instance = this; }
/// <summary> /// Method is called upon application start-up to retrieve session /// relevant information from persistance and restore them (or defaults) /// into their target objects properties. /// </summary> /// <param name="sessionData"></param> /// <param name="window"></param> public void SetSessionData(IProfile sessionData, IViewSize window) { ViewPosSizeModel winModel = null; sessionData.WindowPosSz.TryGetValue(sessionData.MainWindowName, out winModel); window.Height = winModel.Height; window.Width = winModel.Width; window.Left = winModel.X; window.Top = winModel.Y; if (winModel.IsMaximized == true) { window.WindowState = WindowState.Maximized; } else { window.WindowState = WindowState.Normal; } MRU.ReadMruFromSession(sessionData); if (SizeUnitLabel.ScreenPoints >= 6 && SizeUnitLabel.ScreenPoints <= 200) { SizeUnitLabel.ScreenPoints = sessionData.FontSizeScreenPoints; } else { SizeUnitLabel.ScreenPoints = 12; } }
/// <summary> /// Attempts to load the session corresponding to the given path. /// </summary> /// <param name="filePath">The path to a solution or package file.</param> /// <returns><c>True</c> if the session was successfully loaded, <c>False</c> if an error occurred, <c>Null</c> if the operation was cancelled by user.</returns> public async Task <bool?> OpenSession(UFile filePath) { if (Session != null) { throw new InvalidOperationException("A session is already open in this instance."); } if (filePath != null && !File.Exists(filePath)) { MRU.RemoveFile(filePath); await ServiceProvider.Get <IDialogService>().MessageBox(string.Format(Tr._p("Message", @"The file '{0}' does not exist."), filePath), MessageBoxButton.OK, MessageBoxImage.Information); return(false); } var sessionResult = new PackageSessionResult(); var loadedSession = await SessionViewModel.OpenSession(filePath, ServiceProvider, this, sessionResult); // Loading has failed if (loadedSession == null) { // Null means the user has cancelled the loading operation. return(sessionResult.OperationCancelled ? (bool?)null : false); } MRU.AddFile(filePath); Session = loadedSession; InternalSettings.FileDialogLastOpenSessionDirectory.SetValue(new UFile(filePath).GetFullDirectory()); InternalSettings.Save(); return(true); }
/// <summary> /// Method is called upon application exit to store session /// relevant information in persistance and restore on next start-up. /// </summary> /// <param name="sessionData"></param> /// <param name="window"></param> public void GetSessionData(IProfile sessionData, IViewSize window) { // Store session data from actual objects ViewPosSizeModel winModel = null; sessionData.WindowPosSz.TryGetValue(sessionData.MainWindowName, out winModel); winModel.Height = window.Height; winModel.Width = window.Width; winModel.X = window.Left; winModel.Y = window.Top; if (window.WindowState == WindowState.Maximized) { winModel.IsMaximized = true; } else { winModel.IsMaximized = false; } MRU.WriteMruToSession(sessionData); sessionData.FontSizeScreenPoints = SizeUnitLabel.ScreenPoints; }
private void ClearRecentFiles() { //Clear considering old projects that have been deleted or upgraded from older versions var xenkoVersions = RecentFiles?.Select(x => x.Version).ToList(); if (xenkoVersions != null) { foreach (var item in xenkoVersions) { MRU.Clear(item); } } }
public void RemoveRecentFile(UFile filePath) { //Get all versions of showing on recent files var xenkoVersions = RecentFiles?.Select(x => x.Version).Distinct().ToList(); if (xenkoVersions != null) { foreach (var item in xenkoVersions) { MRU.RemoveFile(filePath, item); } } }
public async Task <bool> NewSession(NewSessionParameters newSessionParameters) { if (Session != null) { throw new InvalidOperationException("A session is already open in this instance."); } var newSession = await SessionViewModel.CreateNewSession(this, ServiceProvider, newSessionParameters); if (newSession != null) { Session = newSession; MRU.AddFile(Session.SolutionPath); } return(Session != null); }
public static string[] Load(FrmScripter frmScp, MRU mru, string path) { if (!File.Exists(path)) { UtilSys.MessageBox("File '" + path + "' does not exist."); mru.Remove(path); mru.Save(); return(null); } frmScp.Output("Loading file: " + path); string[] buffer = UtilIO.ReadFile2Array(path); mru.Add(path); mru.Save(); return(buffer); }
public void RemoveRecentFile(UFile filePath) { var packageVersion = PackageSessionHelper.GetPackageVersion(filePath); //Remove considering old projects that have been deleted or upgraded from older versions if (packageVersion == null || string.Compare(packageVersion.ToString(), "3.0", StringComparison.Ordinal) <= 0) { //Get all versions of showing on recent files var xenkoVersions = RecentFiles?.Select(x => x.Version).ToList(); if (xenkoVersions != null) { foreach (var item in xenkoVersions) { MRU.RemoveFile(filePath, item); } } } else { MRU.RemoveFile(filePath, packageVersion.ToString()); } }
private void DragDrop(object sender, DragEventArgs e) { if (e.Data.GetDataPresent(DataFormats.FileDrop, true)) { string[] droppedFilePaths = e.Data.GetData(DataFormats.FileDrop, true) as string[]; foreach (var file in droppedFilePaths) { var mru = new MRU(file); if (mru.IsValid) { try { VM.ClearAll(); this.Title = mru.Name; ShowJSON(File.ReadAllText(mru.Address)); VM.AddMRUToUserSettings(mru); } catch (Exception ex) { VM.Error = ex.Demystify().ToString(); } } else { VM.Error = $"File {file} is not a valid JSON file"; } break; // Only one file for now. } } }
static void Main() { // Instantiate a log that maintains a running record of the recognised voice commands. This log // will be displayed within a ListBox in the main form, frmGAVPI. We specify a callback method so // that we may inform an already open frmGAVPI to update the ListBox with the log content. try { Log = new Logging <string>(GAVPI.OnLogMessage); } catch (Exception) { throw; } Settings = new Settings(); Profile = new Profile(null); vi = new InputEngine(); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // // To ensure that only a single instance of the application can be executed at a time, we'll use // Mutex ownership to determine if we're already running. I used http://www.guidgenerator.com/ // to create a Globally Unique ID (GUID) as the name of a Mutex, which the application will attempt // to secure before running proper. If the Mutex can't be secured it means our application is // already running. // Mutex LockApplicationInstance; bool OnlyApplicationInstance = false; // // We'll do something useful if the application is already running by sending it a message asking // it to show itself. This may be achieved through the native Win32 API PostMessage (an asynchronous // call). But regardless of whether another instance of the application is running or now, we should // request a message that is unique to our application. // if ((WM_OPEN_EXISTING_INSTANCE = Win32_APIs.RegisterWindowMessage("WM_OPEN_EXISTING_INSTANCE")) == 0) { throw new Win32Exception(); } // Now we can check to see if our application already running... if (((LockApplicationInstance = new Mutex(true, APPLICATION_ID, out OnlyApplicationInstance)) != null) && !OnlyApplicationInstance) { // // It is already running. Now assuming the user wants to do something productive, let's bring the // existing instance to the front. PostMessage is non-blocking native Win32 call, so will return // immediately, whose intent is picked up in the frmGAVPI.WndProc() method of the existing instance. // Win32_APIs.PostMessage((IntPtr)Win32_APIs.HWND_BROADCAST, WM_OPEN_EXISTING_INSTANCE, IntPtr.Zero, IntPtr.Zero); // We can happily quit now. return; } // if() // // A system tray icon and associated menu offers an alternative UI, providing the key functionality // of the application in a convenient menu. // // So, let's set the Tray Icon's tooltip name, use an instance of the application's icon (from the // project's resources, and provide a handler for when a user double-clicks the system tray icon. sysTrayIcon = new NotifyIcon(); sysTrayIcon.Icon = Properties.Resources.gavpi; sysTrayIcon.Visible = true; sysTrayIcon.DoubleClick += new System.EventHandler(OnDoubleClickIcon); sysTrayIcon.Text = APPLICATION_TITLE; // Our system tray icon's context menu consists of items that may be enabled or disabled depending // on the available workflow. By default, however, their initial states should be as declared. sysTrayMenu = new ContextMenu(); // Our MRU menu. We'll add it to the top of the system tray icon's context menu. ProfileMRU = new MRU("Recent", OnMRUListItem); sysTrayMenu.MenuItems.Add(ProfileMRU.GetMenu()); sysTrayMenu.MenuItems.Add("Open Profile", LoadProfile); sysTrayMenu.MenuItems.Add("Modify", OpenProfileEditor).Enabled = false; sysTrayMenu.MenuItems.Add("-"); sysTrayMenu.MenuItems.Add("Show Log", OpenMainWindow); sysTrayMenu.MenuItems.Add("-"); sysTrayMenu.MenuItems.Add("Listen", StartListening).Enabled = false; sysTrayMenu.MenuItems.Add("Stop", StopListening).Enabled = false; sysTrayMenu.MenuItems.Add("-"); sysTrayMenu.MenuItems.Add("Settings", OpenSettings); sysTrayMenu.MenuItems.Add("-"); sysTrayMenu.MenuItems.Add("Exit", Exit); // And now we can attach the menu to the system tray icon. sysTrayIcon.ContextMenu = sysTrayMenu; // Now let's load the MRU items before running the application propper. ProfileMRU.Deserialize(); // Let's commence monitoring process startup and automatically open Profiles if any have been // associated with an executable and the option to do so has been set. if (Properties.Settings.Default.EnableAutoOpenProfile) { EnableAutoOpenProfile(null, null); } // And display the main window upon start if specified in the configuration. if (Properties.Settings.Default.ShowGAVPI) { OpenMainWindow(null, null); } Application.Run(); // We don't want the garbage collector to think our Mutex is up for grabs before we close the program, // so let's protect it. GC.KeepAlive(LockApplicationInstance); LockApplicationInstance.ReleaseMutex(); } // static void Main()
/// <summary> /// Store settings in the settings model space. /// This method should be called before destroying a page for good. /// </summary> /// <param name="settings"></param> void ISaveSettings.SavePageSettings(Settings.Interfaces.ISettingsManager settings) { // Store the current list of MRU model items in the settings manager space settings.SessionData.ResetMRUModel(MRU.GetModelList()); }
/// <summary> /// Given a MRU, convert it to a meeting. /// </summary> /// <param name="mru">The MRU.</param> /// <returns></returns> private IMeetingRef ConvertToIMeeting(MRU mru) { var ag = AgendaInfo.FromShortString(mru.IDRef); return(new IndicoMeetingRef(ag)); }
private void UpdateMru(MRU mru) { mnuFileRecent.DropDownItems.Clear(); List<ToolStripMenuItem> items = new List<ToolStripMenuItem>(); if (mru.Count == 0) { items.Add(mnuFileRecentNone); } else { int n = 0; foreach (string file in mru) { n++; string name = ShortPath(file, 60, 75); if (n < 10) { name = String.Format("&{0} {1}", n, name); } else if (n == 10) { name = String.Format("1&0 {1}", n, name); } ToolStripMenuItem item = new ToolStripMenuItem(name) { Tag = file }; item.Click += new EventHandler(MRU_Click); items.Add(item); } } mnuFileRecent.DropDownItems.AddRange(items.ToArray()); }
static void Main(string[] args) { LeArquivo(); CriaProcessos(); //MostraProcessos(); var fifo = new FIFO(); var mru = new MRU(); var nuf = new NUF(); var optimum = new OPTIMUM(); int[] trocas = new int[3]; int min; int melhor; StringBuilder algoritmos = new StringBuilder(); foreach (var processo in processos) { trocas[0] = fifo.Run(processo); processo.Molduras.Clear(); trocas[1] = mru.Run(processo); processo.Molduras.Clear(); trocas[2] = nuf.Run(processo); processo.Molduras.Clear(); melhor = optimum.Run(processo); processo.Molduras.Clear(); min = trocas.Min(); for (int i = 0; i < trocas.Length; i++) { if (trocas[i] == min) { if (i == 0) { algoritmos.Append("FIFO "); } else if (i == 1) { algoritmos.Append("MRU "); } else { algoritmos.Append("NUF"); } } } // Console.WriteLine($"FIFO: {trocas[0]} | MRU: {trocas[1]} | NUF: {trocas[2]} | Ótimo: {melhor} | Melhor(es): {algoritmos}"); // Console.WriteLine($"{trocas[0]}|{trocas[1]}|{trocas[2]}|{melhor}|{algoritmos}"); // correção para a saída ficar a igual a proposta sem alterar o resto // 5 caracteres do 'FIFO ' que é o maior if (algoritmos.Length > 5) { algoritmos.Clear(); algoritmos.Append("empate"); } Console.WriteLine($"{trocas[0]}|{trocas[1]}|{trocas[2]}|{melhor}|{algoritmos}"); algoritmos.Clear(); } }