internal void SetActiveDocumentInternal(Document document)
{
// Work around a case where we closed a document but haven't updated
// the active_document_index yet and it points to the closed document
if (HasOpenDocuments && active_document_index != -1 && OpenDocuments.Count > active_document_index)
{
PintaCore.Tools.Commit();
}
int index = OpenDocuments.IndexOf(document);
active_document_index = index;
OnActiveDocumentChanged(EventArgs.Empty);
}
private void OpenAutoSavedDocuments()
{
OpenDocuments.AddRange(LoadAutoSavedDocuments(DocumentRoot.Path));
_dispatcher.InvokeAsync(() =>
{
if (HasNoOpenDocuments)
{
CreateNewDocument();
}
else
{
CurrentOpenDocument = OpenDocuments[0];
}
});
}
public void OpenDocument(DocumentViewModel document)
{
if (document.IsFolder)
{
return;
}
var openDocument = OpenDocuments.FirstOrDefault(x => x.Document == document);
if (openDocument == null)
{
openDocument = GetOpenDocumentViewModel(document);
OpenDocuments.Add(openDocument);
}
CurrentOpenDocument = openDocument;
}
public async Task CloseDocument(OpenDocumentViewModel document)
{
var result = await document.Save(promptSave : true).ConfigureAwait(true);
if (result == SaveResult.Cancel)
{
return;
}
if (document.Document?.IsAutoSave == true)
{
File.Delete(document.Document.Path);
}
RoslynHost.CloseDocument(document.DocumentId);
OpenDocuments.Remove(document);
document.Close();
}
/// <summary>
/// Opens a document in the viewer.
///
/// If the document is already opened it is just activated.
/// </summary>
/// <param name="filePath">Path of the document, which should be opened in the viewer.</param>
/// <param name="searchQuery">Search query for which the match occurrences have been returned.</param>
/// <param name="occurrences">Match occurrences, which should be highlighted in the document viewer.</param>
/// <returns>Opened document view model.</returns>
internal DocumentViewModel OpenDocument(string filePath, string searchQuery, ReadOnlyCollection <IOccurrence> occurrences)
{
int docIndex = 0;
if (Engine.FileStorageProviders.Exists(filePath))
{
try
{
System.Windows.Input.Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait;
foreach (var openDocument in OpenDocuments)
{
if (openDocument.FilePath.Equals(filePath, StringComparison.OrdinalIgnoreCase))
{
break;
}
++docIndex;
}
if (docIndex >= OpenDocuments.Count || OpenDocuments[docIndex].OccurrenceModels != occurrences)
{
var newDocument = new DocumentViewModel(filePath, occurrences, searchQuery, fileActionCloseAllButThis: mCloseAllButThisFileAction, fileActionCloseAll: mCloseAllFilesAction);
newDocument.FileViewerTemplate = mFileViewerTemplate;
if (docIndex < OpenDocuments.Count)
{
OpenDocuments.RemoveAt(docIndex);
}
OpenDocuments.Insert(docIndex, newDocument);
CurrentDocument = newDocument;
}
else
{
CurrentDocument = OpenDocuments[docIndex];
}
return(CurrentDocument);
}
finally
{
System.Windows.Input.Mouse.OverrideCursor = null;
}
}
else
{
System.Windows.MessageBox.Show(string.Format("Cannot open file \"{0}\" because it does not exist!", filePath), "Open file...", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
}
return(null);
}
public Document CreateAndActivateDocument(string filename, Gdk.Size size)
{
Document doc = new Document(size);
if (string.IsNullOrEmpty(filename))
{
doc.Filename = string.Format(Catalog.GetString("Unsaved Image {0}"), new_file_name++);
}
else
{
doc.PathAndFileName = filename;
}
OpenDocuments.Add(doc);
OnDocumentCreated(new DocumentEventArgs(doc));
SetActiveDocument(doc);
return(doc);
}
public async Task CloseDocument(OpenDocumentViewModel document)
{
var result = await document.Save(promptSave : true).ConfigureAwait(true);
if (result == SaveResult.Cancel)
{
return;
}
// ReSharper disable once PossibleNullReferenceException
var autoSavePath = document.Document?.GetAutoSavePath();
if (autoSavePath != null && File.Exists(autoSavePath))
{
File.Delete(autoSavePath);
}
RoslynHost.CloseDocument(document.DocumentId);
OpenDocuments.Remove(document);
document.Close();
}
public async void OpenDocument()
{
try
{
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.ViewMode = PickerViewMode.List;
openPicker.FileTypeFilter.Add(".json");
StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
string token = StorageApplicationPermissions.FutureAccessList.Add(file);
OpenDocuments.Add(await DocumentViewModel.LoadFromFileAsync(this, file, token));
CurrentDocument = OpenDocuments.LastOrDefault();
SaveFileTokensAsync();
}
else
{
}
}
catch { }
}
public async void CloseDocument(BaseDocumentViewModel document)
{
// TODO: Check if not saved
int index = OpenDocuments.IndexOf(document);
if (index != -1)
{
OpenDocuments.RemoveAt(index);
if (index < OpenDocuments.Count)
{
CurrentDocument = OpenDocuments[index];
}
else
{
CurrentDocument = OpenDocuments.LastOrDefault();
}
if (document.Token != null)
{
await SaveFileTokensAsync();
}
}
}
public void OnSelectedSolutionItemChanged()
{
if (!(SelectedSolutionItem?.HasPreview ?? false))
{
return;
}
var alreadyOpenDocument = OpenDocuments.FirstOrDefault(d => d.AssociatedModel == SelectedSolutionItem);
if (alreadyOpenDocument != null)
{
ActiveDocument = alreadyOpenDocument;
return;
}
var currentTemporary = OpenDocuments.FirstOrDefault(d => d.IsTemporary);
var document = OpenDocument(SelectedSolutionItem);
if (currentTemporary == null)
{
currentTemporary = new DocumentViewModel
{
IsTemporary = true
};
OpenDocuments.Add(currentTemporary);
}
currentTemporary.AssociatedModel = document.AssociatedModel;
currentTemporary.Content = document.Content;
currentTemporary.Syntax = document.Syntax;
currentTemporary.Title = $"*{document.Title}";
ActiveDocument = currentTemporary;
}
private async Task LoadFilesAsync()
{
OpenDocuments.Clear();
var tokens = await Settings.GetFileTokensAsync();
var documents = new List <BaseDocumentViewModel>();
foreach (string token in tokens)
{
try
{
StorageFile file;
bool isSaveable = false;
if (token.StartsWith("SampleFile:"))
{
string fileName = token.Substring("SampleFile:".Length);
file = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///{SamplesFolderName}/{fileName}"));
}
else
{
file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync(token);
isSaveable = true;
}
if (file != null)
{
documents.Add(await LoadFromFileAsync(file, token, Properties, isSaveable));
}
}
catch { }
}
try
{
var samplesFolder = await Package.Current.InstalledLocation.GetFolderAsync(SamplesFolderName);
foreach (var file in await samplesFolder.GetFilesAsync())
{
if (file.FileType.ToLower().Equals(".json"))
{
AddDocumentItems.Add(new AddDocumentListItem()
{
DisplayName = file.Name,
File = file
});
}
}
}
catch { }
foreach (var doc in documents)
{
AddDocument(doc);
}
var currDoc = documents.FirstOrDefault(i => i.Token == _currentDocumentToken.Value);
if (currDoc == null)
{
currDoc = documents.FirstOrDefault();
}
CurrentDocument = currDoc;
}
private void AddDocument(BaseDocumentViewModel doc)
{
OpenDocuments.Add(doc);
doc.OnRequestClose += Doc_OnRequestClose;
doc.OnRequestSaveFileTokens += Doc_OnRequestSaveFileTokens;
}
private async void AddAndSelectDocument(BaseDocumentViewModel doc)
{
AddDocument(doc);
CurrentDocument = OpenDocuments.LastOrDefault();
await SaveFileTokensAsync();
}
private void NewDocument()
{
AddDocument(CreateNewDocument());
CurrentDocument = OpenDocuments.Last();
}
/// <summary>
/// Called to update the current status of the command.
/// </summary>
protected override void OnBeforeQueryStatus()
{
Enabled = OpenDocuments.Any();
}
private async Task SaveFileTokensAsync()
{
await Settings.SaveFileTokensAsync(OpenDocuments.Select(i => i.Token));
}
public override System.Threading.Tasks.Task <ParsedDocument> Parse(ParseOptions parseOptions, System.Threading.CancellationToken cancellationToken)
{
Doc.Editor.FileName = parseOptions.FileName;
OpenDocuments.Add(new OpenRazorDocument(Doc.Editor));
return(base.Parse(parseOptions, cancellationToken));
}
public override ParsedDocument Parse(bool storeAst, string fileName, System.IO.TextReader content, Project project = null)
{
Doc.Editor.Document.FileName = fileName;
OpenDocuments.Add(Doc.Editor.Document);
return(base.Parse(storeAst, fileName, content, project));
}
