public async void ManageQueueTabs()
{
while (!CanManageQueue)
{
await Task.Delay(20);
}
if (CanManageQueue)
{
CanManageQueue = false;
try
{
if (GlobalVariables.CurrentIDs.ID_Tab != 0)
{
//Code content
string content = await ContentViewer.GetCode();
SerrisModulesServer.Manager.AsyncHelpers.RunSync(() => TabsWriteManager.PushTabContentViaIDAsync(GlobalVariables.CurrentIDs, content, false));
//Cursor position
PositionSCEE CursorPosition = await ContentViewer.GetCursorPosition();
InfosTab Tab = TabsAccessManager.GetTabViaID(GlobalVariables.CurrentIDs);
Tab.TabCursorPosition = new CursorPosition {
column = CursorPosition.column, row = CursorPosition.row
};
await TabsWriteManager.PushUpdateTabAsync(Tab, GlobalVariables.CurrentIDs.ID_TabsList, false);
}
}
catch { }
foreach (CoreApplicationView view in CoreApplication.Views)
{
if (Dispatcher != view.Dispatcher)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.TabUpdated, ID = GlobalVariables.CurrentIDs
});
});
}
}
GlobalVariables.CurrentIDs = new TabID {
ID_Tab = Queue_Tabs[0].tabID, ID_TabsList = Queue_Tabs[0].tabsListID
};
ContentViewer.MonacoModelID = Queue_Tabs[0].monacoModelID;
ContentViewer.CursorPositionColumn = Queue_Tabs[0].cursorPositionColumn;
ContentViewer.CursorPositionRow = Queue_Tabs[0].cursorPositionLineNumber;
ContentViewer.CodeLanguage = Queue_Tabs[0].typeLanguage;
ContentViewer.Code = Queue_Tabs[0].code;
ChangePushed = false;
Queue_Tabs.RemoveAt(0);
CanManageQueue = true;
}
}
private async void Current_Suspending(object sender, Windows.ApplicationModel.SuspendingEventArgs e)
{
var deferral = e.SuspendingOperation.GetDeferral();
try
{
if (GlobalVariables.CurrentIDs.ID_Tab != 0)
{
//Code content
string content = await ContentViewer.GetCode();
await TabsWriteManager.PushTabContentViaIDAsync(GlobalVariables.CurrentIDs, content, false);
//Cursor position
PositionSCEE CursorPosition = await ContentViewer.GetCursorPosition();
InfosTab Tab = TabsAccessManager.GetTabViaID(GlobalVariables.CurrentIDs);
Tab.TabCursorPosition = new CursorPosition {
column = CursorPosition.column, row = CursorPosition.row
};
await TabsWriteManager.PushUpdateTabAsync(Tab, GlobalVariables.CurrentIDs.ID_TabsList, false);
deferral.Complete();
}
else
{
deferral.Complete();
}
}
catch
{
deferral.Complete();
}
}
private async void UpdateTabInformations()
{
//Set temp tab + tabs list ID
try
{
current_tab = await TabsAccessManager.GetTabViaIDAsync(new TabID { ID_Tab = current_tab.ID, ID_TabsList = current_list });
foreach (CoreApplicationView view in CoreApplication.Views)
{
if (current_tab.TabName.Length >= 4)
{
Extension_tab.Text = current_tab.TabName.Substring(0, 4);
}
else
{
Extension_tab.Text = current_tab.TabType.ToUpper();
}
name_tab.Text = current_tab.TabName;
if (!string.IsNullOrEmpty(current_tab.PathContent))
{
path_tab.Text = current_tab.PathContent;
encoding_file.Text = Encoding.GetEncoding(current_tab.TabEncoding).EncodingName;
More_Tab.Visibility = Visibility.Visible;
}
else
{
More_Tab.Visibility = Visibility.Collapsed;
}
}
}
catch { }
}
public static void CreateNewTabInFolder(int IDList, TabID FolderIDs, string FileName, Encoding encoding, StorageListTypes type, string content)
{
var newtab = new InfosTab
{
TabName = FileName,
TabStorageMode = type,
TabEncoding = encoding.CodePage,
TabContentType = ContentType.File,
CanBeDeleted = true,
CanBeModified = true,
TabType = LanguagesHelper.GetLanguageType(FileName),
TabInvisibleByDefault = true
};
Task.Run(() =>
{
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(newtab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await TabsWriteManager.PushTabContentViaIDAsync(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}, content, false)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
InfosTab Folder = TabsAccessManager.GetTabViaID(FolderIDs);
Folder.FolderContent.Add(id_tab);
Task.Run(async() => { await TabsWriteManager.PushUpdateTabAsync(Folder, FolderIDs.ID_TabsList, false); });
}
});
}
/// <summary>
/// Delete a tab who was selected by his ID and tabs list ID
/// </summary>
/// <param name="ids">ID of the tab and tabs list where is the tab</param>
/// <returns></returns>
public static async Task <bool> DeleteTabAsync(TabID ids)
{
TabsDataCache.LoadTabsData();
try
{
TabsList list_tabs = TabsDataCache.TabsListDeserialized.First(m => m.ID == ids.ID_TabsList);
InfosTab tab = list_tabs.tabs.First(m => m.ID == ids.ID_Tab);
list_tabs.tabs.Remove(tab);
StorageFile delete_file = await TabsDataCache.TabsListFolder.CreateFileAsync(ids.ID_TabsList + "_" + ids.ID_Tab + ".json", CreationCollisionOption.ReplaceExisting); await delete_file.DeleteAsync();
TabsDataCache.WriteTabsListContentFile();
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.TabDeleted, ID = new TabID {
ID_Tab = ids.ID_Tab, ID_TabsList = ids.ID_TabsList
}
});
});
}
return(true);
}
catch
{
return(false);
}
}
public static int CreateNewTabReturn(int IDList, string FileName, Encoding encoding, bool encodingbom, StorageListTypes type, string content)
{
var newtab = new InfosTab
{
TabName = FileName,
TabStorageMode = type,
TabEncoding = encoding.CodePage,
TabEncodingWithBOM = encodingbom,
TabEncodingReplacingRequest = EncodingReplacingRequest.NotRequested,
TabContentType = ContentType.File,
CanBeDeleted = true,
CanBeModified = true,
TabType = LanguagesHelper.GetLanguageType(FileName),
TabInvisibleByDefault = false
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(newtab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await TabsWriteManager.PushTabContentViaIDAsync(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}, content, false)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
return(id_tab);
}
else
{
return(0);
}
}
/// <summary>
/// Delete a tab who was selected by his ID and tabs list ID
/// </summary>
/// <param name="ids">ID of the tab and tabs list where is the tab</param>
/// <returns></returns>
public static async Task <bool> DeleteTabAsync(TabID ids)
{
using (var reader = new StreamReader(await file.OpenStreamForReadAsync()))
using (JsonReader JsonReader = new JsonTextReader(reader))
{
try
{
List <TabsList> list = new JsonSerializer().Deserialize <List <TabsList> >(JsonReader);
TabsList list_tabs = list.First(m => m.ID == ids.ID_TabsList);
InfosTab tab = list_tabs.tabs.First(m => m.ID == ids.ID_Tab);
list_tabs.tabs.Remove(tab);
StorageFile delete_file = await folder_tabs.CreateFileAsync(ids.ID_TabsList + "_" + ids.ID_Tab + ".json", CreationCollisionOption.ReplaceExisting); await delete_file.DeleteAsync();
await FileIO.WriteTextAsync(file, JsonConvert.SerializeObject(list, Formatting.Indented));
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.TabDeleted, ID = new TabID {
ID_Tab = ids.ID_Tab, ID_TabsList = ids.ID_TabsList
}
});
});
}
return(true);
}
catch
{
return(false);
}
}
}
private void Tab_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
{
if (DataContext != null)
{
TabID ids = (TabID)DataContext;
if (current_tab == null)
{
current_tab = new InfosTab();
}
current_tab.ID = ids.ID_Tab; current_list = ids.ID_TabsList;
UpdateTabInformations();
}
}
/// <summary>
/// Create a tab in a tabs list who was selected by his ID
/// </summary>
/// <param name="tab">Tab you want to create</param>
/// <param name="id_list">ID of the tabs list</param>
/// <returns>ID of the new tab</returns>
public static async Task <int> CreateTabAsync(InfosTab tab, int id_list, bool SendNotification)
{
using (var reader = new StreamReader(await file.OpenStreamForReadAsync()))
using (JsonReader JsonReader = new JsonTextReader(reader))
{
try
{
tab.ID = new Random().Next(999999);
List <TabsList> list = new JsonSerializer().Deserialize <List <TabsList> >(JsonReader);
TabsList list_tabs = list.First(m => m.ID == id_list);
if (list_tabs.tabs == null)
{
list_tabs.tabs = new List <InfosTab>();
}
list_tabs.tabs.Add(tab);
StorageFile data_tab = await folder_tabs.CreateFileAsync(id_list + "_" + tab.ID + ".json", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(data_tab, JsonConvert.SerializeObject(new ContentTab {
ID = tab.ID, Content = ""
}, Formatting.Indented));
await FileIO.WriteTextAsync(file, JsonConvert.SerializeObject(list, Formatting.Indented));
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (SendNotification)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = tab.ID, ID_TabsList = id_list
}
});
}
});
}
return(tab.ID);
}
catch
{
return(0);
}
}
}
/// <summary>
/// Update tab informations (please use PushTabContentViaIDAsync() for set tab content)
/// </summary>
/// <param name="tab">Tab infos you want to update</param>
/// <param name="id_list">ID of the tabs list where is the tab</param>
/// <returns></returns>
public static async Task <bool> PushUpdateTabAsync(InfosTab tab, int id_list, bool UpdateMonacoID)
{
TabsDataCache.LoadTabsData();
try
{
TabsList list_tabs = TabsDataCache.TabsListDeserialized.First(m => m.ID == id_list);
InfosTab _tab = list_tabs.tabs.First(m => m.ID == tab.ID);
int index_list = TabsDataCache.TabsListDeserialized.IndexOf(list_tabs), index_tab = list_tabs.tabs.IndexOf(_tab);
if (UpdateMonacoID)
{
tab.TabMonacoModelID = Guid.NewGuid().ToString();
}
TabsDataCache.TabsListDeserialized[index_list].tabs[index_tab] = tab;
StorageFile data_tab = await TabsDataCache.TabsListFolder.CreateFileAsync(id_list + "_" + tab.ID + ".json", CreationCollisionOption.OpenIfExists);
if (tab.TabContentTemporary != null)
{
await FileIO.WriteTextAsync(data_tab, JsonConvert.SerializeObject(new ContentTab {
ID = tab.ID, Content = tab.TabContentTemporary
}, Formatting.Indented));
}
TabsDataCache.WriteTabsListContentFile();
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.TabUpdated, ID = new TabID {
ID_Tab = tab.ID, ID_TabsList = id_list
}
});
});
}
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Create a tab in a tabs list who was selected by his ID
/// </summary>
/// <param name="tab">Tab you want to create</param>
/// <param name="id_list">ID of the tabs list</param>
/// <returns>ID of the new tab</returns>
public static async Task <int> CreateTabAsync(InfosTab tab, int id_list, bool SendNotification)
{
TabsDataCache.LoadTabsData();
try
{
tab.ID = new Random().Next(999999);
tab.TabMonacoModelID = Guid.NewGuid().ToString();
TabsList list_tabs = TabsDataCache.TabsListDeserialized.First(m => m.ID == id_list);
if (list_tabs.tabs == null)
{
list_tabs.tabs = new List <InfosTab>();
}
list_tabs.tabs.Add(tab);
StorageFile data_tab = await TabsDataCache.TabsListFolder.CreateFileAsync(id_list + "_" + tab.ID + ".json", CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(data_tab, JsonConvert.SerializeObject(new ContentTab {
ID = tab.ID, Content = ""
}, Formatting.Indented));
TabsDataCache.WriteTabsListContentFile();
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (SendNotification)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = tab.ID, ID_TabsList = id_list
}
});
}
});
}
return(tab.ID);
}
catch
{
return(0);
}
}
public static async Task <int> CreateNewTab(int IDList, string FileName, Encoding encoding, StorageListTypes type, string content)
{
string extension = "";
foreach (string type_file in FileTypes.List_Type_extensions)
{
if (FileName.Contains(type_file))
{
extension = FileTypes.GetExtensionType(Path.GetExtension(FileName));
break;
}
else
{
continue;
}
}
var newtab = new InfosTab
{
TabName = FileName,
TabStorageMode = type,
TabEncoding = encoding.CodePage,
TabContentType = ContentType.File,
CanBeDeleted = true,
CanBeModified = true,
TabType = extension,
TabInvisibleByDefault = false
};
int id_tab = await TabsWriteManager.CreateTabAsync(newtab, IDList, false);
if (await TabsWriteManager.PushTabContentViaIDAsync(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}, content, false))
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
return(id_tab);
}
else
{
return(0);
}
}
public static void UpdateTab(ref InfosTab tab, int id_list)
{
using (var reader = new StreamReader(file.OpenStreamForReadAsync().Result))
{
try
{
int id = tab.ID;
JObject tabs = JObject.Parse(reader.ReadToEnd()).Values <JObject>().Where(m => m["ID"].Value <int>() == id_list).FirstOrDefault(),
tab_search = tabs.Values <JObject>().Where(m => m["ID"].Value <int>() == id).FirstOrDefault();
if (tab != null)
{
tab = tab_search.Value <InfosTab>();
}
}
catch { }
}
}
/// <summary>
/// Update tab informations (please use PushTabContentViaIDAsync() for set tab content)
/// </summary>
/// <param name="tab">Tab infos you want to update</param>
/// <param name="id_list">ID of the tabs list where is the tab</param>
/// <returns></returns>
public static async Task <bool> PushUpdateTabAsync(InfosTab tab, int id_list)
{
using (var reader = new StreamReader(await file.OpenStreamForReadAsync()))
using (JsonReader JsonReader = new JsonTextReader(reader))
{
try
{
List <TabsList> list = new JsonSerializer().Deserialize <List <TabsList> >(JsonReader);
TabsList list_tabs = list.First(m => m.ID == id_list);
InfosTab _tab = list_tabs.tabs.First(m => m.ID == tab.ID);
int index_list = list.IndexOf(list_tabs), index_tab = list_tabs.tabs.IndexOf(_tab);
list[index_list].tabs[index_tab] = tab;
StorageFile data_tab = await folder_tabs.CreateFileAsync(id_list + "_" + tab.ID + ".json", CreationCollisionOption.OpenIfExists);
if (tab.TabContentTemporary != null)
{
await FileIO.WriteTextAsync(data_tab, JsonConvert.SerializeObject(new ContentTab {
ID = tab.ID, Content = tab.TabContentTemporary
}, Formatting.Indented));
}
await FileIO.WriteTextAsync(file, JsonConvert.SerializeObject(list, Formatting.Indented));
foreach (CoreApplicationView view in CoreApplication.Views)
{
await view.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.TabUpdated, ID = new TabID {
ID_Tab = tab.ID, ID_TabsList = id_list
}
});
});
}
return(true);
}
catch
{
return(false);
}
}
}
public static async Task <List <int> > OpenFilesAndCreateNewTabsFiles(int IDList, StorageListTypes type)
{
var list_ids = new List <int>();
var opener = new FileOpenPicker();
opener.ViewMode = PickerViewMode.Thumbnail;
opener.SuggestedStartLocation = PickerLocationId.ComputerFolder;
opener.FileTypeFilter.Add("*");
IReadOnlyList <StorageFile> files = await opener.PickMultipleFilesAsync();
foreach (StorageFile file in files)
{
await Task.Run(() =>
{
if (file != null)
{
StorageApplicationPermissions.FutureAccessList.Add(file);
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = type, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, PathContent = file.Path, TabInvisibleByDefault = false, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(tab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
}
list_ids.Add(id_tab);
}
});
}
return(list_ids);
}
public static void UpdateTabRef(ref InfosTab tab, int id_list)
{
TabsDataCache.LoadTabsData();
using (var reader = new StreamReader(Task.Run(async() => { return(await TabsDataCache.TabsListFile.OpenStreamForReadAsync()); }).Result))
{
try
{
int id = tab.ID;
JObject tabs = JObject.Parse(reader.ReadToEnd()).Values <JObject>().Where(m => m["ID"].Value <int>() == id_list).FirstOrDefault(),
tab_search = tabs.Values <JObject>().Where(m => m["ID"].Value <int>() == id).FirstOrDefault();
if (tab != null)
{
tab = tab_search.Value <InfosTab>();
}
}
catch { }
}
}
private async void CheckIfTabHaveNewOutsideUpdate(InfosTab tab)
{
try
{
if (!string.IsNullOrEmpty(tab.TabOriginalPathContent) && tab.TabStorageMode == StorageListTypes.LocalStorage && !string.IsNullOrEmpty(tab.TabDateModified) && tab.TabOutsideContentUpdatedRequestTemp == OutsideContentUpdatedRequest.NotRequested)
{
StorageFile file = await StorageFile.GetFileFromPathAsync(tab.TabOriginalPathContent);
BasicProperties properties = await file.GetBasicPropertiesAsync();
DateTimeOffset LastUpdate = DateTimeOffset.Parse(tab.TabDateModified);
if (properties.DateModified.Second != LastUpdate.Second || properties.DateModified.Hour != LastUpdate.Hour || properties.DateModified.Minute != LastUpdate.Minute)
{
await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
{
MessageDialog Dialog = new MessageDialog(string.Format(GlobalVariables.GlobalizationRessources.GetString("popup-updatedfilecontent"), properties.DateModified.ToString("G"), LastUpdate.ToString("G")), string.Format(GlobalVariables.GlobalizationRessources.GetString("popup-updatedfiletitle"), tab.TabName));
Dialog.Commands.Add(new UICommand
{
Label = GlobalVariables.GlobalizationRessources.GetString("popup-updatedfileaccept"),
Invoked = async(e) =>
{
if (tab.ID == GlobalVariables.CurrentIDs.ID_Tab)
{
tab.TabOutsideContentUpdatedRequestTemp = OutsideContentUpdatedRequest.NotRequested;
tab.TabDateModified = properties.DateModified.ToString();
string FileContent = await new StorageRouter(tab, GlobalVariables.CurrentIDs.ID_TabsList).ReadFileAndGetContent();
new SCEELibs.Editor.EditorEngine().injectJS($"editor.setValue('{EditorEngine.javaScriptEncode(FileContent)}', -1)");
//Update DateModified & TabOutsideContentUpdatedRequestTemp (updated push with "PushUpdateTabAsync" in Tab.SetMessenger() => TypeUpdateTab.TabNewModifications)
}
}
});
Dialog.Commands.Add(new UICommand {
Label = GlobalVariables.GlobalizationRessources.GetString("popup-updatedfilerefuse"), Invoked = async(e) => { tab.TabOutsideContentUpdatedRequestTemp = OutsideContentUpdatedRequest.Requested; await TabsWriteManager.PushUpdateTabAsync(tab, GlobalVariables.CurrentIDs.ID_TabsList, false); }
});
await Dialog.ShowAsync();
});
}
}
}
catch { }
}
private void Tab_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
{
if (DataContext != null)
{
TabID ids = (TabID)DataContext;
if (current_tab == null)
{
current_tab = new InfosTab();
}
if (AppSettings.Values.ContainsKey("ui_leftpanelength"))
{
GridInfoLeft.Width = (int)AppSettings.Values["ui_leftpanelength"];
StackInfos.Margin = new Thickness((int)AppSettings.Values["ui_leftpanelength"], 0, 0, 0);
}
current_tab.ID = ids.ID_Tab; current_list = ids.ID_TabsList;
UpdateTabInformations();
}
}
private async void Accept_Click(object sender, RoutedEventArgs e)
{
OneDriveLoadStart();
InfosTab RequestedTab = TabsAccessManager.GetTabViaID(TabIDRequest);
switch (CurrentExplorerMode)
{
case OnedriveExplorerMode.CreateFile:
MemoryStream stream = new MemoryStream();
var file = await TabsDataCache.OneDriveClient.Drive.Items[CurrentTab.TabOriginalPathContent].ItemWithPath(RequestedTab.TabName).Content.Request().PutAsync <Item>(stream);
RequestedTab.TabOriginalPathContent = file.Id;
RequestedTab.TabDateModified = file.LastModifiedDateTime.ToString();
await TabsWriteManager.PushUpdateTabAsync(RequestedTab, TabIDRequest.ID_TabsList, false);
break;
case OnedriveExplorerMode.SelectFile:
var tab = new InfosTab {
TabName = CurrentTab.TabName, TabStorageMode = Storage.StorageListTypes.OneDrive, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = CurrentTab.TabOriginalPathContent, TabInvisibleByDefault = false, TabType = LanguagesHelper.GetLanguageType(CurrentTab.TabName)
};
int id_tab = await TabsWriteManager.CreateTabAsync(tab, TabIDRequest.ID_TabsList, false);
if (await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = TabIDRequest.ID_TabsList
}), TabIDRequest.ID_TabsList).ReadFile(true))
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = TabIDRequest.ID_TabsList
}
});
}
break;
}
OnedriveLoadFinished();
try { Window.Current.Close(); } catch { }
}
private async static Task <int> OpenSubFolder(StorageFolder Folder, int IDList, StorageListTypes type)
{
return(await Task.Run(async() =>
{
var FolderItemIDs = new List <int>();
foreach (IStorageItem Item in await Folder.GetItemsAsync())
{
StorageApplicationPermissions.FutureAccessList.Add(Item);
if (Item.IsOfType(StorageItemTypes.File))
{
StorageFile file = (StorageFile)Item;
if (file.ContentType.Contains("text") || LanguagesHelper.IsFileLanguageIsCompatible(file.Name))
{
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = type, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = file.Path, TabInvisibleByDefault = true, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = await TabsWriteManager.CreateTabAsync(tab, IDList, false);
await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true);
FolderItemIDs.Add(id_tab);
}
}
else
{
FolderItemIDs.Add(await OpenSubFolder((StorageFolder)Item, IDList, type));
}
}
return await TabsWriteManager.CreateTabAsync(new InfosTab {
TabName = Folder.Name, TabOriginalPathContent = Folder.Path, TabContentType = ContentType.Folder, FolderContent = FolderItemIDs, FolderOpened = false, TabInvisibleByDefault = true
}, IDList, false);
}));
}
private async void tabs_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
OnedriveExplorerItem Tab = (sender as ListView).SelectedItem as OnedriveExplorerItem;
if (Tabs.SelectedIndex != -1)
{
Tabs.SelectedIndex = -1;
switch (Tab.Tab.TabContentType)
{
case ContentType.Folder:
Tabs.Items.Clear(); od_foldername.Text = Tab.Tab.TabName; OneDriveNavigationHistory.Add(new Tuple <string, string>(Tab.Tab.TabName, Tab.Tab.TabOriginalPathContent));
OneDriveLoadStart();
foreach (var item in await OneDriveNavigate(Tab.Tab.TabOriginalPathContent))
{
Tabs.Items.Add(item);
}
OnedriveLoadFinished();
if (CurrentExplorerMode == OnedriveExplorerMode.CreateFile)
{
CurrentTab = Tab.Tab;
folder_name.Text = $"Create the new file in {Tab.Tab.TabName} ?";
accept.IsEnabled = true;
}
break;
case ContentType.File:
if (CurrentExplorerMode == OnedriveExplorerMode.SelectFile)
{
CurrentTab = Tab.Tab;
folder_name.Text = $"Open the file {Tab.Tab.TabName} ?";
accept.IsEnabled = true;
}
break;
}
}
}
public LocalStorage(InfosTab tab, int _ListTabsID) : base(tab, _ListTabsID)
{
Tab = tab; ListTabsID = _ListTabsID;
}
private async void UpdateTabInformations()
{
//Set temp tab + tabs list ID
try
{
current_tab = TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = current_tab.ID, ID_TabsList = current_list
});
name_tab.Text = current_tab.TabName;
switch (current_tab.TabContentType)
{
case ContentType.File:
int ModuleIDIcon = LanguagesHelper.GetModuleIDOfLangageType(current_tab.TabType);
TabIcon.Source = await ModulesAccessManager.GetModuleIconViaIDAsync(ModuleIDIcon, ModulesAccessManager.GetModuleViaID(ModuleIDIcon).ModuleSystem);
if (!string.IsNullOrEmpty(current_tab.PathContent))
{
path_tab.Text = current_tab.PathContent;
encoding_file.Text = Encoding.GetEncoding(current_tab.TabEncoding).EncodingName;
More_Tab.Visibility = Visibility.Visible;
}
else
{
More_Tab.Visibility = Visibility.Collapsed;
}
TabsListGrid.Visibility = Visibility.Collapsed;
TabIcon.Visibility = Visibility.Visible;
FolderIcon.Visibility = Visibility.Collapsed;
StackInfos.Visibility = Visibility.Visible;
break;
case ContentType.Folder:
More_Tab.Visibility = Visibility.Visible;
TabsListGrid.Visibility = Visibility.Visible;
StackInfos.Visibility = Visibility.Collapsed;
TabIcon.Visibility = Visibility.Collapsed;
FolderIcon.Visibility = Visibility.Visible;
if (TempTabID != current_tab.ID && TabsList.ListID != current_list)
{
ShowInfos.Begin();
TabsList.ListTabs.Items.Clear();
TempTabID = current_tab.ID;
TabsList.ListID = current_list;
foreach (int ID in current_tab.FolderContent)
{
try
{
if (TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = ID, ID_TabsList = current_list
}) != null)
{
TabsList.ListTabs.Items.Add(new TabID {
ID_Tab = ID, ID_TabsList = current_list
});
if ((int)AppSettings.Values["Tabs_tab-selected-index"] == ID && (int)AppSettings.Values["Tabs_list-selected-index"] == current_list)
{
TabsList.ListTabs.SelectedIndex = TabsList.ListTabs.Items.Count - 1;
}
}
}
catch { }
}
}
break;
}
}
catch { }
}
public StorageRouter(InfosTab _tab, int id_list)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
tab = _tab; IdList = id_list;
}
public static async Task <List <int> > OpenFilesAlreadyOpenedAndCreateNewTabsFiles(int IDList, IReadOnlyList <IStorageItem> files)
{
var list_ids = new List <int>();
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.RefreshCurrentList, ID = new TabID {
ID_TabsList = IDList
}
});
foreach (StorageFile file in files)
{
await Task.Run(() =>
{
bool FileAlreadyAvailable = false; int IDSelectedFile = 0;
if (file != null)
{
foreach (InfosTab Tab in TabsAccessManager.GetTabsListViaID(IDList).tabs)
{
if (Tab.TabOriginalPathContent == file.Path)
{
IDSelectedFile = Tab.ID;
FileAlreadyAvailable = true;
break;
}
}
if (!FileAlreadyAvailable)
{
StorageApplicationPermissions.FutureAccessList.Add(file);
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = StorageListTypes.LocalStorage, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = file.Path, TabInvisibleByDefault = false, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(tab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
}
list_ids.Add(id_tab);
}
else
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.SelectTab, ID = new TabID {
ID_Tab = IDSelectedFile, ID_TabsList = IDList
}
});
}
}
});
}
return(list_ids);
}
public static async Task <List <int> > OpenFilesAndCreateNewTabsFiles(int IDList, StorageListTypes type)
{
var list_ids = new List <int>();
switch (type)
{
case StorageListTypes.LocalStorage:
var opener = new FileOpenPicker();
opener.ViewMode = PickerViewMode.Thumbnail;
opener.SuggestedStartLocation = PickerLocationId.ComputerFolder;
opener.FileTypeFilter.Add("*");
IReadOnlyList <StorageFile> files = await opener.PickMultipleFilesAsync();
foreach (StorageFile file in files)
{
await Task.Run(() =>
{
if (file != null)
{
StorageApplicationPermissions.FutureAccessList.Add(file);
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = type, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = file.Path, TabInvisibleByDefault = false, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(tab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
}
list_ids.Add(id_tab);
}
});
}
break;
case StorageListTypes.OneDrive:
var currentAV = ApplicationView.GetForCurrentView(); var newAV = CoreApplication.CreateNewView();
await newAV.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async() =>
{
var newWindow = Window.Current;
var newAppView = ApplicationView.GetForCurrentView();
newAppView.Title = "OneDrive explorer";
var frame = new Frame();
frame.Navigate(typeof(OnedriveExplorer), new Tuple <OnedriveExplorerMode, TabID>(OnedriveExplorerMode.SelectFile, new TabID {
ID_TabsList = IDList
}));
newWindow.Content = frame;
newWindow.Activate();
await ApplicationViewSwitcher.TryShowAsStandaloneAsync(
newAppView.Id,
ViewSizePreference.UseHalf,
currentAV.Id,
ViewSizePreference.UseHalf);
});
break;
}
return(list_ids);
}
public static async Task <List <int> > OpenFolder(int IDList, StorageListTypes type)
{
var list_ids = new List <int>();
var opener = new FolderPicker();
opener.ViewMode = PickerViewMode.Thumbnail;
opener.SuggestedStartLocation = PickerLocationId.ComputerFolder;
opener.FileTypeFilter.Add("*");
var Folder = await opener.PickSingleFolderAsync();
if (Folder != null)
{
StorageApplicationPermissions.FutureAccessList.Add(Folder);
foreach (IStorageItem Item in await Folder.GetItemsAsync())
{
await Task.Run(async() =>
{
if (Item.IsOfType(StorageItemTypes.File))
{
StorageFile file = (StorageFile)Item;
if (file != null)
{
StorageApplicationPermissions.FutureAccessList.Add(file);
if (file.ContentType.Contains("text") || LanguagesHelper.IsFileLanguageIsCompatible(file.Name))
{
var tab = new InfosTab {
TabName = file.Name, TabStorageMode = type, TabContentType = ContentType.File, CanBeDeleted = true, CanBeModified = true, TabOriginalPathContent = file.Path, TabInvisibleByDefault = true, TabType = LanguagesHelper.GetLanguageType(file.Name)
};
int id_tab = Task.Run(async() => { return(await TabsWriteManager.CreateTabAsync(tab, IDList, false)); }).Result;
if (Task.Run(async() => { return(await new StorageRouter(TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}), IDList).ReadFile(true)); }).Result)
{
Messenger.Default.Send(new STSNotification {
Type = TypeUpdateTab.NewTab, ID = new TabID {
ID_Tab = id_tab, ID_TabsList = IDList
}
});
}
list_ids.Add(id_tab);
}
}
}
else
{
StorageFolder FolderItem = (StorageFolder)Item;
list_ids.Add(await OpenSubFolder(FolderItem, IDList, type));
}
});
}
await TabsWriteManager.CreateTabAsync(new InfosTab { TabName = Folder.Name, TabOriginalPathContent = Folder.Path, TabContentType = ContentType.Folder, FolderContent = list_ids, FolderOpened = true }, IDList, true);
}
return(list_ids);
}
public OneDrive(InfosTab tab, int _ListTabsID) : base(tab, _ListTabsID)
{
Tab = tab; ListTabsID = _ListTabsID;
}
private async void UpdateTabInformations()
{
//Set temp tab + tabs list ID
try
{
current_tab = TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = current_tab.ID, ID_TabsList = current_list
});
name_tab.Text = current_tab.TabName;
//Tooltip name
ToolTip ButtonTooltip = new ToolTip();
ButtonTooltip.Content = current_tab.TabName;
ToolTipService.SetToolTip(IconAndTabNameGrid, ButtonTooltip);
switch (current_tab.TabContentType)
{
case ContentType.File:
string ModuleIDIcon = LanguagesHelper.GetModuleIDOfLangageType(current_tab.TabType);
TabIcon.Source = await ModulesAccessManager.GetModuleIconViaIDAsync(ModuleIDIcon, ModulesAccessManager.GetModuleViaID(ModuleIDIcon).ModuleSystem);
if (!string.IsNullOrEmpty(current_tab.TabOriginalPathContent))
{
switch (current_tab.TabStorageMode)
{
case StorageListTypes.LocalStorage:
path_tab.Text = current_tab.TabOriginalPathContent;
break;
case StorageListTypes.OneDrive:
path_tab.Text = "OneDrive file";
break;
}
Size_Stackpanel.Visibility = Visibility.Visible;
Modified_Stackpanel.Visibility = Visibility.Visible;
Created_Stackpanel.Visibility = Visibility.Visible;
Rename_Tab.IsEnabled = false;
}
else
{
Size_Stackpanel.Visibility = Visibility.Collapsed;
Modified_Stackpanel.Visibility = Visibility.Collapsed;
Created_Stackpanel.Visibility = Visibility.Collapsed;
Rename_Tab.IsEnabled = true;
}
Notification.ShowBadge = current_tab.TabNewModifications;
TabsListGrid.Visibility = Visibility.Collapsed;
TabIcon.Visibility = Visibility.Visible;
FolderIcon.Visibility = Visibility.Collapsed;
StackInfos.Visibility = Visibility.Visible;
MaxHeightAnimShow.Value = 200;
MaxHeightAnimRemove.Value = 200;
break;
case ContentType.Folder:
Notification.ShowBadge = false;
Rename_Tab.IsEnabled = false;
More_Tab.Visibility = Visibility.Visible;
TabsListGrid.Visibility = Visibility.Visible;
StackInfos.Visibility = Visibility.Collapsed;
TabIcon.Visibility = Visibility.Collapsed;
FolderIcon.Visibility = Visibility.Visible;
if (TempTabID != current_tab.ID && TabsList.ListID != current_list)
{
if (current_tab.FolderOpened)
{
ShowInfos.Begin(); infos_opened = true;
}
else
{
infos_opened = false;
}
TabsList.ListTabs.Items.Clear();
TempTabID = current_tab.ID;
TabsList.ListID = current_list;
foreach (int ID in current_tab.FolderContent)
{
try
{
if (TabsAccessManager.GetTabViaID(new TabID {
ID_Tab = ID, ID_TabsList = current_list
}) != null)
{
TabsList.ListTabs.Items.Add(new TabID {
ID_Tab = ID, ID_TabsList = current_list
});
if ((int)AppSettings.Values["Tabs_tab-selected-index"] == ID && (int)AppSettings.Values["Tabs_list-selected-index"] == current_list)
{
TabsList.ListTabs.SelectedIndex = TabsList.ListTabs.Items.Count - 1;
}
}
}
catch { }
}
}
MaxHeightAnimShow.Value = 1500;
MaxHeightAnimRemove.Value = 1500;
break;
}
}
catch { }
}
public StorageType(InfosTab tab, int _ListTabsID)
{
}
