private void BuildEncodingIndicatorFlyout()
{
if (StatusBar == null) return;
if (EncodingSelectionFlyout.Items?.Count > 0)
{
return;
}
var reopenWithEncoding = new MenuFlyoutSubItem()
{
Text = _resourceLoader.GetString("TextEditor_EncodingIndicator_FlyoutItem_ReopenWithEncoding"),
FlowDirection = FlowDirection.RightToLeft,
Name = "ReopenWithEncoding"
};
var saveWithEncoding = new MenuFlyoutSubItem()
{
Text = _resourceLoader.GetString("TextEditor_EncodingIndicator_FlyoutItem_SaveWithEncoding"),
FlowDirection = FlowDirection.RightToLeft,
Name = "SaveWithEncoding"
};
// Add auto guess Encoding option in ReopenWithEncoding menu
reopenWithEncoding.Items?.Add(CreateAutoGuessEncodingItem());
reopenWithEncoding.Items?.Add(new MenuFlyoutSeparator());
// Add suggested ANSI encodings
var appAndSystemANSIEncodings = new HashSet<Encoding>();
if (EncodingUtility.TryGetSystemDefaultANSIEncoding(out var systemDefaultANSIEncoding))
{
appAndSystemANSIEncodings.Add(systemDefaultANSIEncoding);
}
if (EncodingUtility.TryGetCurrentCultureANSIEncoding(out var currentCultureANSIEncoding))
{
appAndSystemANSIEncodings.Add(currentCultureANSIEncoding);
}
if (appAndSystemANSIEncodings.Count > 0)
{
foreach (var encoding in appAndSystemANSIEncodings)
{
AddEncodingItem(encoding, reopenWithEncoding, saveWithEncoding);
}
reopenWithEncoding.Items?.Add(new MenuFlyoutSeparator());
saveWithEncoding.Items?.Add(new MenuFlyoutSeparator());
}
// Add Unicode encodings
var unicodeEncodings = new List<Encoding>
{
new UTF8Encoding(false), // "UTF-8"
new UTF8Encoding(true), // "UTF-8-BOM"
new UnicodeEncoding(false, true), // "UTF-16 LE BOM"
new UnicodeEncoding(true, true), // "UTF-16 BE BOM"
};
foreach (var encoding in unicodeEncodings)
{
AddEncodingItem(encoding, reopenWithEncoding, saveWithEncoding);
}
// Add legacy ANSI encodings
var ANSIEncodings = EncodingUtility.GetAllSupportedANSIEncodings();
if (ANSIEncodings.Length > 0)
{
reopenWithEncoding.Items?.Add(new MenuFlyoutSeparator());
saveWithEncoding.Items?.Add(new MenuFlyoutSeparator());
var reopenWithEncodingOthers = new MenuFlyoutSubItem()
{
Text = _resourceLoader.GetString("TextEditor_EncodingIndicator_FlyoutItem_MoreEncodings"),
FlowDirection = FlowDirection.RightToLeft,
};
var saveWithEncodingOthers = new MenuFlyoutSubItem()
{
Text = _resourceLoader.GetString("TextEditor_EncodingIndicator_FlyoutItem_MoreEncodings"),
FlowDirection = FlowDirection.RightToLeft,
};
foreach (var encoding in ANSIEncodings)
{
AddEncodingItem(encoding, reopenWithEncodingOthers, saveWithEncodingOthers);
}
reopenWithEncoding.Items?.Add(reopenWithEncodingOthers);
saveWithEncoding.Items?.Add(saveWithEncodingOthers);
}
EncodingSelectionFlyout.Items?.Add(reopenWithEncoding);
EncodingSelectionFlyout.Items?.Add(saveWithEncoding);
}
private async Task <ITextEditor> RecoverTextEditorAsync(TextEditorSessionDataV1 editorSessionData)
{
StorageFile editingFile = null;
if (editorSessionData.EditingFileFutureAccessToken != null)
{
editingFile = await FileSystemUtility.GetFileFromFutureAccessList(editorSessionData.EditingFileFutureAccessToken);
}
string lastSavedFile = editorSessionData.LastSavedBackupFilePath;
string pendingFile = editorSessionData.PendingBackupFilePath;
ITextEditor textEditor;
if (editingFile == null && lastSavedFile == null && pendingFile == null)
{
textEditor = null;
}
else if (editingFile != null && lastSavedFile == null && pendingFile == null) // File without pending changes
{
textEditor = await _notepadsCore.CreateTextEditor(editorSessionData.Id, editingFile, ignoreFileSizeLimit : true);
textEditor.ResetEditorState(editorSessionData.StateMetaData);
}
else // File with pending changes
{
string lastSavedText = string.Empty;
string pendingText = null;
if (lastSavedFile != null)
{
TextFile lastSavedTextFile = await FileSystemUtility.ReadFile(lastSavedFile, ignoreFileSizeLimit : true,
EncodingUtility.GetEncodingByName(editorSessionData.StateMetaData.LastSavedEncoding));
lastSavedText = lastSavedTextFile.Content;
}
var textFile = new TextFile(lastSavedText,
EncodingUtility.GetEncodingByName(editorSessionData.StateMetaData.LastSavedEncoding),
LineEndingUtility.GetLineEndingByName(editorSessionData.StateMetaData.LastSavedLineEnding),
editorSessionData.StateMetaData.DateModifiedFileTime);
textEditor = _notepadsCore.CreateTextEditor(
editorSessionData.Id,
textFile,
editingFile,
editorSessionData.StateMetaData.IsModified);
if (pendingFile != null)
{
TextFile pendingTextFile = await FileSystemUtility.ReadFile(pendingFile,
ignoreFileSizeLimit : true,
EncodingUtility.GetEncodingByName(editorSessionData.StateMetaData.LastSavedEncoding));
pendingText = pendingTextFile.Content;
}
textEditor.ResetEditorState(editorSessionData.StateMetaData, pendingText);
}
return(textEditor);
}
private void UpdateEncodingIndicator(Encoding encoding)
{
if (StatusBar == null) return;
EncodingIndicator.Text = EncodingUtility.GetEncodingName(encoding);
}
private async Task ActivateAsync(IActivatedEventArgs e)
{
bool rootFrameCreated = false;
if (!(Window.Current.Content is Frame rootFrame))
{
rootFrame = CreateRootFrame(e);
Window.Current.Content = rootFrame;
rootFrameCreated = true;
ThemeSettingsService.Initialize();
AppSettingsService.Initialize();
}
var appLaunchSettings = new Dictionary <string, string>()
{
{ "OSArchitecture", SystemInformation.OperatingSystemArchitecture.ToString() },
{ "OSVersion", $"{SystemInformation.OperatingSystemVersion.Major}.{SystemInformation.OperatingSystemVersion.Minor}.{SystemInformation.OperatingSystemVersion.Build}" },
{ "UseWindowsTheme", ThemeSettingsService.UseWindowsTheme.ToString() },
{ "ThemeMode", ThemeSettingsService.ThemeMode.ToString() },
{ "UseWindowsAccentColor", ThemeSettingsService.UseWindowsAccentColor.ToString() },
{ "AppBackgroundTintOpacity", $"{(int) (ThemeSettingsService.AppBackgroundPanelTintOpacity * 10.0) * 10}" },
{ "ShowStatusBar", AppSettingsService.ShowStatusBar.ToString() },
{ "IsSessionSnapshotEnabled", AppSettingsService.IsSessionSnapshotEnabled.ToString() },
{ "IsShadowWindow", (!IsPrimaryInstance && !IsGameBarWidget).ToString() },
{ "IsGameBarWidget", IsGameBarWidget.ToString() },
{ "AlwaysOpenNewWindow", AppSettingsService.AlwaysOpenNewWindow.ToString() },
{ "IsHighlightMisspelledWordsEnabled", AppSettingsService.IsHighlightMisspelledWordsEnabled.ToString() },
{ "IsSmartCopyEnabled", AppSettingsService.IsSmartCopyEnabled.ToString() }
};
LoggingService.LogInfo($"[{nameof(App)}] Launch settings: \n{string.Join("\n", appLaunchSettings.Select(x => x.Key + "=" + x.Value).ToArray())}.");
Analytics.TrackEvent("AppLaunch_Settings", appLaunchSettings);
var appLaunchEditorSettings = new Dictionary <string, string>()
{
{ "EditorDefaultLineEnding", AppSettingsService.EditorDefaultLineEnding.ToString() },
{ "EditorDefaultEncoding", EncodingUtility.GetEncodingName(AppSettingsService.EditorDefaultEncoding) },
{ "EditorDefaultTabIndents", AppSettingsService.EditorDefaultTabIndents.ToString() },
{ "EditorDefaultDecoding", AppSettingsService.EditorDefaultDecoding == null ? "Auto" : EncodingUtility.GetEncodingName(AppSettingsService.EditorDefaultDecoding) },
{ "EditorFontFamily", AppSettingsService.EditorFontFamily },
{ "EditorFontSize", AppSettingsService.EditorFontSize.ToString() },
{ "EditorFontStyle", AppSettingsService.EditorFontStyle.ToString() },
{ "EditorFontWeight", AppSettingsService.EditorFontWeight.Weight.ToString() },
{ "EditorDefaultSearchEngine", AppSettingsService.EditorDefaultSearchEngine.ToString() },
{ "DisplayLineHighlighter", AppSettingsService.EditorDisplayLineHighlighter.ToString() },
{ "DisplayLineNumbers", AppSettingsService.EditorDisplayLineNumbers.ToString() },
};
LoggingService.LogInfo($"[{nameof(App)}] Editor settings: \n{string.Join("\n", appLaunchEditorSettings.Select(x => x.Key + "=" + x.Value).ToArray())}.");
Analytics.TrackEvent("AppLaunch_Editor_Settings", appLaunchEditorSettings);
try
{
await ActivationService.ActivateAsync(rootFrame, e);
}
catch (Exception ex)
{
var diagnosticInfo = new Dictionary <string, string>()
{
{ "Message", ex?.Message },
{ "Exception", ex?.ToString() },
};
Analytics.TrackEvent("AppFailedToActivate", diagnosticInfo);
Crashes.TrackError(ex, diagnosticInfo);
throw;
}
if (rootFrameCreated)
{
ExtendViewIntoTitleBar();
Window.Current.Activate();
}
}
private async void Sets_Drop(object sender, DragEventArgs args)
{
if (!(sender is SetsView))
{
return;
}
var sets = sender as SetsView;
// Handle non Notepads drop event
if (string.IsNullOrEmpty(args.DataView?.Properties?.ApplicationName) ||
!string.Equals(args.DataView?.Properties?.ApplicationName, App.ApplicationName))
{
if (args.DataView == null || !args.DataView.Contains(StandardDataFormats.StorageItems))
{
return;
}
var fileDropDeferral = args.GetDeferral();
var storageItems = await args.DataView.GetStorageItemsAsync();
StorageItemsDropped?.Invoke(this, storageItems);
fileDropDeferral.Complete();
return;
}
var deferral = args.GetDeferral();
try
{
args.DataView.Properties.TryGetValue(NotepadsTextEditorMetaData, out object dataObj);
if (!(dataObj is string data))
{
throw new Exception("Failed to drop editor set: NotepadsTextEditorMetaData is invalid (Not String).");
}
TextEditorStateMetaData metaData = JsonConvert.DeserializeObject <TextEditorStateMetaData>(data);
if (args.DataView.Properties.TryGetValue(NotepadsTextEditorEditingFilePath,
out object editingFilePathObj) && editingFilePathObj is string editingFilePath)
{
var editor = GetTextEditor(editingFilePath);
if (editor != null)
{
SwitchTo(editor);
NotificationCenter.Instance.PostNotification(_resourceLoader.GetString("TextEditor_NotificationMsg_FileAlreadyOpened"), 2500);
throw new Exception("Failed to drop editor set: File already opened.");
}
}
StorageFile editingFile = null;
if (metaData.HasEditingFile && args.DataView.Contains(StandardDataFormats.StorageItems))
{
var storageItems = await args.DataView.GetStorageItemsAsync();
if (storageItems.Count == 1 && storageItems[0] is StorageFile file)
{
editingFile = file;
}
else
{
throw new Exception("Failed to read storage file from dropped set: Expecting only one storage file.");
}
}
string lastSavedText = null;
string pendingText = null;
if (args.DataView.Properties.TryGetValue(NotepadsTextEditorLastSavedContent, out object lastSavedContentObj) &&
lastSavedContentObj is string lastSavedContent)
{
lastSavedText = lastSavedContent;
}
else
{
throw new Exception($"Failed to get last saved content from DataView: NotepadsTextEditorLastSavedContent property Is null");
}
if (args.DataView.Properties.TryGetValue(NotepadsTextEditorPendingContent, out object pendingContentObj) &&
pendingContentObj is string pendingContent)
{
pendingText = pendingContent;
}
ApplicationSettingsStore.Write(SetDragAndDropActionStatus, "Handled");
var index = -1;
// Determine which items in the list our pointer is in between.
for (int i = 0; i < sets.Items?.Count; i++)
{
var item = sets.ContainerFromIndex(i) as SetsViewItem;
if (args.GetPosition(item).X - item?.ActualWidth < 0)
{
index = i;
break;
}
}
var atIndex = index == -1 ? sets.Items.Count : index;
var textFile = new TextFile(lastSavedText,
EncodingUtility.GetEncodingByName(metaData.LastSavedEncoding),
LineEndingUtility.GetLineEndingByName(metaData.LastSavedLineEnding),
metaData.DateModifiedFileTime);
var newEditor = CreateTextEditor(Guid.NewGuid(), textFile, editingFile, metaData.FileNamePlaceholder, metaData.IsModified);
OpenTextEditor(newEditor, atIndex);
newEditor.ResetEditorState(metaData, pendingText);
if (metaData.IsContentPreviewPanelOpened)
{
newEditor.ShowHideContentPreview();
}
if (metaData.IsInDiffPreviewMode)
{
newEditor.OpenSideBySideDiffViewer();
}
deferral.Complete();
Analytics.TrackEvent("OnSetDropped");
}
catch (Exception ex)
{
LoggingService.LogException(ex);
deferral.Complete();
}
}
public override void WriteJson(JsonWriter writer, Encoding value, JsonSerializer serializer)
{
writer.WriteValue(EncodingUtility.GetEncodingName(value));
}
private async System.Threading.Tasks.Task ActivateAsync(IActivatedEventArgs e)
{
if (!(Window.Current.Content is Frame rootFrame))
{
rootFrame = CreateRootFrame(e);
Window.Current.Content = rootFrame;
}
ThemeSettingsService.Initialize();
EditorSettingsService.Initialize();
var appLaunchSettings = new Dictionary <string, string>()
{
{
"OSArchitecture", SystemInformation.OperatingSystemArchitecture.ToString()
},
{
"UseWindowsTheme", ThemeSettingsService.UseWindowsTheme.ToString()
},
{
"ThemeMode", ThemeSettingsService.ThemeMode.ToString()
},
{
"UseWindowsAccentColor", ThemeSettingsService.UseWindowsAccentColor.ToString()
},
{
"AppBackgroundTintOpacity", $"{(int) (ThemeSettingsService.AppBackgroundPanelTintOpacity * 100.0)}"
},
{
"ShowStatusBar", EditorSettingsService.ShowStatusBar.ToString()
},
{
"EditorDefaultLineEnding", EditorSettingsService.EditorDefaultLineEnding.ToString()
},
{
"EditorDefaultEncoding", EncodingUtility.GetEncodingName(EditorSettingsService.EditorDefaultEncoding)
},
{
"EditorDefaultTabIndents", EditorSettingsService.EditorDefaultTabIndents.ToString()
},
{
"EditorDefaultDecoding", EncodingUtility.GetEncodingName(EditorSettingsService.EditorDefaultDecoding)
},
{
"EditorFontFamily", EditorSettingsService.EditorFontFamily
},
{
"EditorFontSize", EditorSettingsService.EditorFontSize.ToString()
},
{
"IsSessionSnapshotEnabled", EditorSettingsService.IsSessionSnapshotEnabled.ToString()
},
{
"IsShadowWindow", (!IsFirstInstance).ToString()
},
{
"AlwaysOpenNewWindow", EditorSettingsService.AlwaysOpenNewWindow.ToString()
},
{
"IsHighlightMisspelledWordsEnabled", EditorSettingsService.IsHighlightMisspelledWordsEnabled.ToString()
},
{
"IsLineHighlighterEnabled", EditorSettingsService.IsLineHighlighterEnabled.ToString()
},
{
"EditorDefaultSearchEngine", EditorSettingsService.EditorDefaultSearchEngine.ToString()
}
};
LoggingService.LogInfo($"AppLaunchSettings: {string.Join(";", appLaunchSettings.Select(x => x.Key + "=" + x.Value).ToArray())}");
Analytics.TrackEvent("AppLaunch_Settings", appLaunchSettings);
try
{
await ActivationService.ActivateAsync(rootFrame, e);
}
catch (Exception ex)
{
throw new Exception("AppFailedToActivate", ex);
}
Window.Current.Activate();
ExtendAcrylicIntoTitleBar();
}
public OAuthUrlProvider Callback(string callback)
{
_parameterMap.Set("oauth_callback", EncodingUtility.UrlEncode(callback));
return(this);
}
public override Encoding ReadJson(JsonReader reader, Type objectType, Encoding existingValue, bool hasExistingValue, JsonSerializer serializer)
{
return(EncodingUtility.GetEncodingByName((string)reader.Value, fallbackEncoding: new UTF8Encoding(false)));
}
/// <summary>
/// 采用MD5计算二进制序列的Hash结果，并转换成Base64格式的字符串返回
/// </summary>
/// <param name="inputs"></param>
/// <returns></returns>
public static string ComputeHashStringByMD5(string fileName)
{
return(EncodingUtility.ToBase64FromBytes(ComputeHashByMD5(fileName)));
}
/// <summary>
/// 采用MD5计算二进制序列的Hash结果，并转换成Base64格式的字符串返回
/// </summary>
/// <param name="inputs"></param>
/// <returns></returns>
public static string ComputeHashStringByMD5(byte[] inputs)
{
return(EncodingUtility.ToBase64FromBytes(EncryptUtility.ComputeHashByMD5(inputs)));
}
/// <summary>
/// 把字符串加密（可以进行解密），并且把加密结果转换为base64编码.
/// </summary>
/// <param name="rawString">需要加密的数据</param>
/// <param name="passwordString">用来加密的密钥</param>
/// <returns></returns>
public static string EncryptByTriple(string rawString, string passwordString)
{
byte[] passwordBytes = EncodingUtility.ToBytesFromUnicode(passwordString);
byte[] passwordMd5Bytes = ComputeHashByMD5(passwordBytes);
return(EncryptByTriple(rawString, DefaultEncoding, passwordMd5Bytes, passwordMd5Bytes));
}
protected override IDataLoader OnBuild(IApplication arguments)
{
Encoding encoding = EncodingUtility.GetEncoding(m_encoding);
return(new DataLoaderFileText(encoding));
}
public static void TextWithEncoding_Initialize(TestContext context)
{
EncodingUtility.RegisterRequiredProviders();
}
/// <summary>
/// Gets the response content as a byte array.
/// </summary>
/// <param name="response"></param>
/// <param name="buffer"></param>
/// <param name="encoding"></param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"><paramref name="buffer"/> is null.</exception>
/// <exception cref="System.NotSupportedException">Not supported character set.</exception>
public static string GetResponseString(this HttpWebResponse response, Encoding encoding, byte[] buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (encoding == null)
{
encoding = HttpHelper.GetTextEncoding(response);
}
byte[] data = GetResponseContent(response, buffer);
if (encoding == null)
{
if ((encoding = EncodingUtility.DetectUnicodeEncoding(data)) == null)
{
string content = DefaultContentEncoding.GetString(data);
Match match = g_charsetRegex.Match(content);
if (match != null && match.Success)
{
switch (match.Groups[1].Value.ToLower())
{
case "utf8":
case "utf-8":
encoding = Encoding.UTF8;
break;
case "utf16":
case "utf-16":
encoding = Encoding.Unicode;
break;
case "utf32":
case "utf-32":
encoding = Encoding.UTF32;
break;
default:
try {
encoding = Encoding.GetEncoding(match.Groups[1].Value);
} catch (ArgumentException) {
}
break;
}
}
if (encoding == null)
{
foreach (string item in content.Between("<meta ", ">", StringComparison.OrdinalIgnoreCase).Select((item) => item.ToLower()))
{
if (item.Contains("utf8") || item.Contains("utf-8"))
{
encoding = Encoding.UTF8;
}
else if (item.Contains("utf16") || item.Contains("utf-16"))
{
encoding = Encoding.Unicode;
}
else if (item.Contains("utf32") || item.Contains("utf-32"))
{
encoding = Encoding.UTF32;
}
else if (item.Contains("gb2312"))
{
encoding = Encoding.GetEncoding("gb2312");
}
else if (item.Contains("gbk"))
{
encoding = Encoding.GetEncoding("gbk");
}
if (encoding != null)
{
break;
}
}
}
/*
* if can not determine the encoding type, we use default encoding.
*/
if (encoding == null || DefaultContentEncoding.Equals(encoding))
{
return(content);
}
}
}
return(encoding.GetString(data));
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
// Figure out what resource the request is intending to access to see if the
// user has already authenticated to with it
EndUserAuthorizationRequest pendingRequest = _authorizationServer.ReadAuthorizationRequest();
if (pendingRequest == null)
{
throw new HttpException(Convert.ToInt32(HttpStatusCode.BadRequest), "Missing authorization request.");
}
try
{
_targetResource = _resourceRepository.FindWithSupportedScopes(pendingRequest.Scope);
// Above will return null if no resource supports all of the requested scopes
if (_targetResource == null)
{
throw new HttpException(Convert.ToInt32(HttpStatusCode.BadRequest), "Bad authorization request.");
}
}
catch (Exception)
{
throw new HttpException(Convert.ToInt32(HttpStatusCode.BadRequest), "Bad authorization request.");
}
// User is considered authorized if in possession of token that originated from the resource's login page,
// Name of token is determined by the resource configuration
string tokenName = _targetResource.AuthenticationTokenName;
string encryptedToken = httpContext.Request[tokenName]; //could be in cookie if previously logged in, or querystring if just logged in
if (string.IsNullOrWhiteSpace(encryptedToken))
{
// No token, so unauthorized
return(false);
}
// Validate this thing came from us via shared secret with the resource's login page
// The implementation here ideally could be generalized a bit better or standardized
string encryptionKey = _targetResource.AuthenticationKey;
string decryptedToken = EncodingUtility.Decode(encryptedToken, encryptionKey);
string[] tokenContentParts = decryptedToken.Split(';');
string name = tokenContentParts[0];
DateTime loginDate = DateTime.Parse(tokenContentParts[1]);
bool storeCookie = bool.Parse(tokenContentParts[2]);
if ((DateTime.Now.Subtract(loginDate) > TimeSpan.FromDays(7)))
{
// Expired, remove cookie if present and flag user as unauthorized
httpContext.Response.Cookies.Remove(tokenName);
return(false);
}
// Things look good.
// Set principal for the authorization server
IIdentity identity = new GenericIdentity(name);
httpContext.User = new GenericPrincipal(identity, null);
// If desired, persist cookie so user doesn't have to authenticate with the resource over and over
var cookie = new HttpCookie(tokenName, encryptedToken);
if (storeCookie)
{
cookie.Expires = DateTime.Now.AddDays(7); // could parameterize lifetime
}
httpContext.Response.AppendCookie(cookie);
return(true);
}
