Beispiel #1
0
        public async Task WriteFile()
        {
            await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
            {
                if (string.IsNullOrWhiteSpace(Tab.TabOriginalPathContent))
                {
                    await CreateFile().ContinueWith((e) =>
                    {
                        //await WriteFile();
                    });
                }
                else
                {
                    try
                    {
                        await OneDriveAuthHelper.OneDriveAuthentification();

                        MemoryStream stream = new MemoryStream();
                        StreamWriter writer = new StreamWriter(stream, Encoding.GetEncoding(Tab.TabEncoding));
                        writer.Write(await TabsAccessManager.GetTabContentViaIDAsync(new TabID {
                            ID_Tab = Tab.ID, ID_TabsList = ListTabsID
                        }));
                        writer.Flush();
                        stream.Position = 0;

                        var item = await TabsDataCache.OneDriveClient.Drive.Items[Tab.TabOriginalPathContent].Content.Request().PutAsync <Item>(stream);
                    }
                    catch
                    {
                        await new MessageDialog("Please verify your internet connection or verify if the file still exist in your OneDrive or if you have enough stockage for saving the file.", "OneDrive error").ShowAsync();
                    }
                }
            });
        }
        public async Task WriteFile()
        {
            await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
            {
                try
                {
                    StorageFile file = await StorageFile.GetFileFromPathAsync(Tab.PathContent);

                    if (file != null)
                    {
                        await FileIO.WriteTextAsync(file, string.Empty);
                        using (var rd = new StreamWriter(await file.OpenStreamForWriteAsync(), Encoding.GetEncoding(Tab.TabEncoding)))
                        {
                            rd.Write(await TabsAccessManager.GetTabContentViaIDAsync(new TabID {
                                ID_Tab = Tab.ID, ID_TabsList = ListTabsID
                            }));
                            rd.Flush(); rd.Dispose();
                        }
                    }
                }
                catch
                {
                    await CreateFile().ContinueWith(async(e) =>
                    {
                        await WriteFile();
                    });
                }
            });
        }
Beispiel #3
0
        public async Task WriteFile()
        {
            await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
            {
                try
                {
                    StorageFile file = await StorageFile.GetFileFromPathAsync(Tab.TabOriginalPathContent);

                    if (file != null)
                    {
                        await FileIO.WriteTextAsync(file, string.Empty);

                        Encoding TempEncoding = Encoding.GetEncoding(Tab.TabEncoding);

                        if (TempEncoding == Encoding.UTF8 && !Tab.TabEncodingWithBOM)
                        {
                            TempEncoding = new UTF8Encoding(false);
                        }

                        string Content = await TabsAccessManager.GetTabContentViaIDAsync(new TabID {
                            ID_Tab = Tab.ID, ID_TabsList = ListTabsID
                        });

                        using (var rd = new StreamWriter(await file.OpenStreamForWriteAsync(), TempEncoding))
                        {
                            rd.Write(Content);
                            rd.Flush(); rd.Dispose();
                        }

                        //Update DateModified (updated push with "PushUpdateTabAsync" in StorageRouter.WriteFile())
                        BasicProperties properties = await file.GetBasicPropertiesAsync();
                        Tab.TabDateModified        = properties.DateModified.ToString();

                        if (TempEncoding.CodePage == Encoding.ASCII.CodePage && Tab.TabEncodingReplacingRequest != EncodingReplacingRequest.Never)
                        {
                            var stream = new MemoryStream();
                            var writer = new StreamWriter(stream);
                            writer.Write(Content);
                            writer.Flush();
                            stream.Position = 0;

                            using (MemoryStream str = stream)
                            {
                                var cdet = new Ude.CharsetDetector();
                                cdet.Reset();
                                cdet.Feed(str);
                                cdet.DataEnd();
                                if (cdet.Charset != null)
                                {
                                    if (Encoding.GetEncoding(cdet.Charset).CodePage == Encoding.UTF8.CodePage)
                                    {
                                        await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
                                        {
                                            MessageDialog Dialog = new MessageDialog(new ResourceLoader().GetString("popup-changeencodingcontent"), string.Format(new ResourceLoader().GetString("popup-changeencodingtitle"), TempEncoding.EncodingName, cdet.Charset));
                                            Dialog.Commands.Add(new UICommand {
                                                Label = new ResourceLoader().GetString("popup-changeencodingaccept"), Invoked = async(e) => { Tab.TabEncoding = Encoding.GetEncoding(cdet.Charset).CodePage; Tab.TabEncodingWithBOM = false; Tab.TabEncodingReplacingRequest = EncodingReplacingRequest.NotRequested; await TabsWriteManager.PushUpdateTabAsync(Tab, ListTabsID, false); }
                                            });
                                            Dialog.Commands.Add(new UICommand {
                                                Label = new ResourceLoader().GetString("popup-changeencodinglater"), Invoked = async(e) => { Tab.TabEncodingReplacingRequest = EncodingReplacingRequest.MaybeLater; await TabsWriteManager.PushUpdateTabAsync(Tab, ListTabsID, false); }
                                            });
                                            Dialog.Commands.Add(new UICommand {
                                                Label = new ResourceLoader().GetString("popup-changeencodingno"), Invoked = async(e) => { Tab.TabEncodingReplacingRequest = EncodingReplacingRequest.Never; await TabsWriteManager.PushUpdateTabAsync(Tab, ListTabsID, false); }
                                            });
                                            await Dialog.ShowAsync();
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
                catch
                {
                    await CreateFile().ContinueWith(async(e) =>
                    {
                        if (e.Result)
                        {
                            await WriteFile();
                        }
                    });
                }
            });
        }
        private async void Tabs_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ListView List = sender as ListView;

            if (List.SelectedItem != null)
            {
                if (((TabID)List.SelectedItem).ID_Tab != GlobalVariables.CurrentIDs.ID_Tab)
                {
                    CurrentSelectedIDs = (TabID)List.SelectedItem;
                    var    tab = TabsAccessManager.GetTabViaID(CurrentSelectedIDs);
                    string MonacoID;

                    if (string.IsNullOrEmpty(tab.TabMonacoModelID))
                    {
                        MonacoID = Guid.NewGuid().ToString();
                    }
                    else
                    {
                        MonacoID = tab.TabMonacoModelID;
                    }

                    if (tab.TabContentType == ContentType.File)
                    {
                        int    EncodingType = tab.TabEncoding;
                        string TabType      = "";

                        if (EncodingType == 0)
                        {
                            EncodingType = Encoding.UTF8.CodePage;
                        }

                        if (string.IsNullOrEmpty(tab.TabType))
                        {
                            TabType = "TXT";
                        }
                        else
                        {
                            TabType = tab.TabType.ToUpper();
                        }

                        if (tab != null)
                        {
                            Messenger.Default.Send(new TabSelectedNotification {
                                tabID = CurrentSelectedIDs.ID_Tab, tabsListID = CurrentSelectedIDs.ID_TabsList, code = await TabsAccessManager.GetTabContentViaIDAsync(CurrentSelectedIDs), contactType = ContactTypeSCEE.SetCodeForEditor, typeLanguage = TabType, typeCode = Encoding.GetEncoding(EncodingType).EncodingName, cursorPositionColumn = tab.TabCursorPosition.column, cursorPositionLineNumber = tab.TabCursorPosition.row, tabName = tab.TabName, monacoModelID = MonacoID
                            });
                        }

                        AppSettings.Values["Tabs_tab-selected-index"]  = ((TabID)List.SelectedItem).ID_Tab;
                        AppSettings.Values["Tabs_list-selected-index"] = ((TabID)List.SelectedItem).ID_TabsList;
                    }
                }
            }
        }
Beispiel #5
0
        private async void Tabs_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (Tabs.SelectedItem != null)
            {
                if (((TabID)Tabs.SelectedItem).ID_Tab != GlobalVariables.CurrentIDs.ID_Tab)
                {
                    CurrentSelectedIDs = (TabID)Tabs.SelectedItem;
                    var tab = await TabsAccessManager.GetTabViaIDAsync(CurrentSelectedIDs);

                    int    EncodingType = tab.TabEncoding;
                    string TabType      = "";

                    if (EncodingType == 0)
                    {
                        EncodingType = Encoding.UTF8.CodePage;
                    }

                    if (string.IsNullOrEmpty(tab.TabType))
                    {
                        TabType = "TXT";
                    }
                    else
                    {
                        TabType = tab.TabType.ToUpper();
                    }

                    if (tab != null)
                    {
                        Messenger.Default.Send(new TabSelectedNotification {
                            tabID = CurrentSelectedIDs.ID_Tab, tabsListID = CurrentSelectedIDs.ID_TabsList, code = await TabsAccessManager.GetTabContentViaIDAsync(CurrentSelectedIDs), contactType = ContactTypeSCEE.SetCodeForEditor, typeLanguage = TabType, typeCode = Encoding.GetEncoding(EncodingType).EncodingName
                        });
                    }

                    AppSettings.Values["Tabs_tab-selected-index"]  = ((TabID)Tabs.SelectedItem).ID_Tab;
                    AppSettings.Values["Tabs_list-selected-index"] = ((TabID)Tabs.SelectedItem).ID_TabsList;
                }
            }
        }
Beispiel #6
0
 public IAsyncOperation <string> getContent()
 {
     return(TabsAccessManager.GetTabContentViaIDAsync(new TabID {
         ID_Tab = id.tabID, ID_TabsList = id.listID
     }).AsAsyncOperation());
 }