/// <summary> /// Creates an instance of a <see cref="Plugin"/> class to be inserted into the database. /// </summary> /// <param name="assembly">The assembly of the plug-in.</param> /// <param name="plugin">The initialized plug-in.</param> /// <param name="fileNameFull">The full file name of the plug-in assembly.</param> /// <returns>A <see cref="Plugin"/> class instance based on the given arguments.</returns> public static Plugin FromPlugin(Assembly assembly, IScriptNotepadPlugin plugin, string fileNameFull) { try { // create a result based on the given parameters.. var result = new Plugin { FileNameFull = fileNameFull, FileName = Path.GetFileName(fileNameFull), FilePath = Path.GetDirectoryName(fileNameFull), PluginName = plugin.PluginName, PluginDescription = plugin.PluginDescription, IsActive = true, PluginInstalled = DateTime.Now, PluginVersion = VersionStringFromAssembly(assembly), }; // set the version for the plug-in.. AssemblyVersion.SetPluginUpdated(result, assembly); // return the result.. return(result); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(null); } }
/// <summary> /// Adds an unique miscellaneous text value to the database. /// </summary> /// <param name="miscText">The misc text.</param> /// <param name="miscellaneousTextType">Type of the miscellaneous text.</param> /// <param name="fileSession">The file session.</param> /// <returns>An instance to a <see cref="MiscellaneousTextEntry"/> if successful, <c>null</c> otherwise.</returns> public static MiscellaneousTextEntry AddUniqueMiscellaneousText(string miscText, MiscellaneousTextType miscellaneousTextType, FileSession fileSession) { try { var context = ScriptNotepadDbContext.DbContext; if (!context.MiscellaneousTextEntries.Any(f => f.TextValue == miscText && f.TextType == miscellaneousTextType && f.Session.SessionName == fileSession.SessionName)) { var result = new MiscellaneousTextEntry { Session = fileSession, TextType = miscellaneousTextType, TextValue = miscText }; result = context.MiscellaneousTextEntries.Add(result).Entity; context.SaveChanges(); return(result); } return(context.MiscellaneousTextEntries.FirstOrDefault(f => f.TextValue == miscText && f.TextType == miscellaneousTextType && f.Session.SessionName == fileSession.SessionName)); // success.. } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(null); // failure.. } }
/// <summary> /// Checks if the access to a given file with given permissions requires elevation. /// </summary> /// <param name="fileName">Name of the file which access permissions to check.</param> /// <param name="fileMode">The mode of how to try to open the file.</param> /// <param name="fileAccess">The file access mode of how to try to open the file.</param> /// <param name="fileShare">The file share mode of how to try to open the file.</param> /// <returns>A named tuple containing a value whether a elevation to access the file is required and a flag indicating whether the file is corrupted (I/O error).</returns> public static (bool ElevationRequied, bool FileCorrupted) FileRequiresElevation(string fileName, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) { try { using (new FileStream(fileName, fileMode, fileAccess, fileShare)) { // nothing to see here.. } return(false, false); } // catch the exception and determine the result based on the type of the exception. catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); if (ex.GetType() == typeof(UnauthorizedAccessException) || ex.GetType() == typeof(SecurityException)) { return(true, false); } else if (ex.GetType() == typeof(IOException)) { return(false, true); } else { return(true, false); } } }
/// <summary> /// Creates a compiled regular expression from a given list of file extensions. /// </summary> /// <param name="extensions">The file extensions to be used with the search.</param> /// <returns>An instance to a <see cref="Regex"/> class.</returns> private static Regex FromExtensions(params string[] extensions) { // remove the useless '*.' and '.' character combinations from the given parameters.. for (int i = 0; i < extensions.Length; i++) { extensions[i] = extensions[i]. Replace("*.", ""). Replace(".", ""); // the '*' character requires special handling; otherwise an exception would occur.. if (extensions[i] == "*") { extensions[i] = "." + extensions[i]; } } // create a compiled regular expression of the given parameters // and return it.. hint: '\.(cs|txt|xml)$' try { return(new Regex(@"\.(" + string.Join("|", extensions) + ")$", RegexOptions.IgnoreCase | RegexOptions.Compiled)); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); // return a regexp matching all file endings.. return(new Regex(@"\\.*", RegexOptions.IgnoreCase | RegexOptions.Compiled)); } }
/// <summary> /// Determines whether the specified file is a .NET Framework assembly. /// </summary> /// <param name="fileName">The name of the file to test for.</param> /// <returns>True if the file is an assembly; otherwise false.</returns> public static bool IsAssembly(string fileName) { try { AssemblyName.GetAssemblyName(fileName); return(true); } catch (FileNotFoundException ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); } catch (BadImageFormatException ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); } catch (FileLoadException ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Cleans up the closed (history) files from a given session with a given maximum amount to keep. /// </summary> /// <param name="keepMaximum">The maximum number of file history to keep per session.</param> /// <param name="session">The session </param> /// <returns><c>true</c> a tuple containing the value whether the clean up was successful and the amount of records deleted.</returns> public static (bool success, int count) CleanUpHistoryFiles(int keepMaximum, FileSession session) { try { var dbContext = ScriptNotepadDbContext.DbContext; var deleteSavesIds = dbContext.FileSaves .Where(f => f.Session.SessionName == session.SessionName && f.IsHistory) .Select(f => new { id = f.Id, modified = f.DatabaseModified }); var deleteAmount = deleteSavesIds.Count() - keepMaximum; if (deleteAmount > 0) { deleteSavesIds = deleteSavesIds.Take(deleteAmount); var deleted = dbContext.FileSaves.Count(f => deleteSavesIds.OrderBy(d => d.modified).Any(h => h.id == f.Id)); dbContext.FileSaves.RemoveRange( dbContext.FileSaves.Where(f => deleteSavesIds.OrderBy(d => d.modified).Any(h => h.id == f.Id))); dbContext.SaveChanges(); return(true, deleted); } return(true, 0); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false, 0); } }
/// <summary> /// Checks if a compiled regular expression from a given list of file extensions is valid. /// </summary> /// <param name="extensions">The file extensions to be used with the check.</param> /// <returns>True if the created regular expression is valid; otherwise false.</returns> public static bool ValidateExtensionRegexp(params string[] extensions) { // remove the useless '*.' and '.' character combinations from the given parameters.. for (int i = 0; i < extensions.Length; i++) { extensions[i] = extensions[i]. Replace("*.", ""). Replace(".", ""); // the '*' character requires special handling; otherwise an exception would occur.. if (extensions[i] == "*") { extensions[i] = "." + extensions[i]; } } // create a compiled regular expression of the given parameters // and return it.. hint: '\.(cs|txt|xml)$' try { // ReSharper disable once ObjectCreationAsStatement new Regex(@"\.(" + string.Join("|", extensions) + ")$", RegexOptions.IgnoreCase | RegexOptions.Compiled); return(true); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Initializes a new instance of the <see cref="AudioVisualizationPlot"/> class. /// </summary> public AudioVisualizationPlot() { InitializeComponent(); tmVisualize.Tick += TmVisualize_Tick; Disposed += AudioVisualizationPlot_Disposed; ShouldResizeChildren += AudioVisualizationBars_ShouldResizeChildren; try { var propertyInfo = typeof(Panel) .GetProperty("DoubleBuffered", BindingFlags.Instance | BindingFlags.NonPublic); if (propertyInfo != null) { propertyInfo.SetValue(pnLeft, true); propertyInfo.SetValue(pnRight, true); propertyInfo.SetValue(pnKHzLabels, true); } } catch (Exception ex) { // report the exception.. ExceptionLogAction?.Invoke(ex); } CalculateHertzLabelHeight(pnKHzLabels.Handle, pnKHzLabels.Font); }
/// <summary> /// Deletes the entire session from the database context. /// </summary> /// <param name="session">The session to delete.</param> /// <returns><c>true</c> if the operation was successful, <c>false</c> otherwise.</returns> public static bool DeleteEntireSession(FileSession session) { try { var context = ScriptNotepadDbContext.DbContext; context.FileSaves.RemoveRange(context.FileSaves.Where(f => f.Session.SessionName == session.SessionName)); context.MiscellaneousTextEntries.RemoveRange(context.MiscellaneousTextEntries.Where(f => f.Session.SessionName == session.SessionName)); context.RecentFiles.RemoveRange(context.RecentFiles.Where(f => f.Session.SessionName == session.SessionName)); session = context.FileSessions.FirstOrDefault(f => f.SessionName == session.SessionName); if (session != null) { context.FileSessions.Remove(session); } context.SaveChanges(); return(true); // success.. } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); // failure.. } }
/// <summary> /// Opens the file with associated program. /// </summary> /// <param name="fileName">The name of the file to open.</param> /// <returns>True if the operation was successful; otherwise false.</returns> public static bool OpenWithAssociatedProgram(string fileName) { try { System.Diagnostics.Process.Start(fileName); return(true); } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Set the Clipboard's contents to a given text. /// </summary> /// <param name="text">The text to set the clipboard's contents to.</param> /// <returns>True if the operation was successful; otherwise false.</returns> public static bool ClipboardSetText(string text) { try { System.Windows.Forms.Clipboard.SetDataObject(text, true, 20, 150); return(true); } catch (Exception ex) { // clipboard operation may fail.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Opens the folder in explorer. /// </summary> /// <param name="folder">The folder to show in the Windows explorer.</param> /// <returns>True if the operation was successful; otherwise false.</returns> public static bool OpenFolderInExplorer(string folder) { try { System.Diagnostics.Process.Start("explorer.exe", folder); return(true); } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Gets an <see cref="Encoding"/> class instance from string describing the encoding. /// </summary> /// <param name="encodingString">The string describing the <see cref="Encoding"/>. I.e: utf-32BE;True;True;True.</param> /// <returns>Returns the <see cref="Encoding"/> created from the given string instance.</returns> public static Encoding EncodingFromString(string encodingString) { try { string[] encodingValues = encodingString.Split(';'); string webName = encodingValues.Length >= 1 ? encodingValues[0] : Encoding.Default.WebName; bool byteOrderMark = encodingValues.Length >= 3 && bool.Parse(encodingValues[2]); bool throwInvalidChars = encodingValues.Length >= 5 && bool.Parse(encodingValues[4]); if (webName == "utf-8") { return(new UTF8Encoding(byteOrderMark, throwInvalidChars)); } if (webName == "utf-16" || webName == "utf-16BE") { return(new UnicodeEncoding(webName == "utf-16BE", byteOrderMark, throwInvalidChars)); } if (webName == "utf-32" || webName == "utf-32BE") { return(new UTF32Encoding(webName == "utf-32BE", byteOrderMark, throwInvalidChars)); } try { return(Encoding.GetEncoding(webName)); } catch (Exception ex) { ExceptionLogAction?.Invoke(ex); try { return(CodePagesEncodingProvider.Instance.GetEncoding(webName)); } catch (Exception exInner) { ExceptionLogAction?.Invoke(exInner); return(Encoding.Default); } } } catch (Exception ex) { ExceptionLogAction?.Invoke(ex); return(Encoding.Default); } }
/// <summary> /// Shows the file or path in Windows explorer. /// </summary> /// <param name="fileOrPath">The file or path to show in the Windows explorer.</param> /// <returns>True if the operation was successful; otherwise false.</returns> public static bool ShowFileOrPathInExplorer(string fileOrPath) { try { // (C): https://social.msdn.microsoft.com/Forums/vstudio/en-US/a6e1458a-20d0-48b4-8e3a-0a00c8618d75/opening-folder-in-explorer-by-c-code?forum=netfxbcl System.Diagnostics.Process.Start("explorer.exe", $"/e,/select,{fileOrPath}"); return(true); } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Gets a version string from a given <see cref="Assembly"/>. /// </summary> /// <param name="assembly">The assembly to set the version from.</param> internal static string VersionStringFromAssembly(Assembly assembly) { try { // return the version from the given assembly.. return(assembly.GetName().Version.ToString()); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); // return a default value.. return("1.0.0.0"); } }
/// <summary> /// Deletes the older <see cref="MiscellaneousTextEntry"/> entries by a given limit to keep. /// </summary> /// <param name="miscellaneousTextType">Type of the miscellaneous text.</param> /// <param name="limit">The limit of how many to entries to keep.</param> /// <param name="fileSession">The file session.</param> /// <returns><c>true</c> if the operation was successful, <c>false</c> otherwise.</returns> public static bool DeleteOlderEntries(MiscellaneousTextType miscellaneousTextType, int limit, FileSession fileSession) { try { ScriptNotepadDbContext.DbContext.MiscellaneousTextEntries.RemoveRange( ScriptNotepadDbContext.DbContext.MiscellaneousTextEntries.Where(f => f.Session.SessionName == fileSession.SessionName) .Except(GetEntriesByLimit(miscellaneousTextType, limit, fileSession))); return(true); // success.. } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); // failure.. } }
/// <summary> /// Cleanups the recent file list by removing older entries from the list by a given number to keep. /// </summary> /// <param name="keepMaximum">The maximum number of recent files to keep per session.</param> /// <param name="session">The session from which to clean the recent file from.</param> /// <returns><c>true</c> a tuple containing the value whether the clean up was successful and the amount of records deleted.</returns> public static (bool success, int count) CleanupHistoryList(int keepMaximum, FileSession session) // one could probably make this a bit more complicated.. { try { var dbContext = ScriptNotepadDbContext.DbContext; session = dbContext.FileSessions.FirstOrDefault(f => f.SessionName == session.SessionName); var closedCount = dbContext.FileSaves.Count(f => f.IsHistory && f.Session.SessionName == session.SessionName); var removeFiles = dbContext.FileSaves .Where(f => !f.IsHistory && f.Session.SessionName == session.SessionName) .Select(f => f.FileNameFull); dbContext.RecentFiles.RemoveRange(dbContext.RecentFiles.Where(f => f.Session.SessionName == session.SessionName && removeFiles.Contains(f.FileNameFull))); var historyRemoveCount = closedCount - keepMaximum; if (historyRemoveCount > 0) { var deleted = dbContext.RecentFiles .OrderByDescending(f => f.ClosedDateTime) .Take(historyRemoveCount).Count(); dbContext.RecentFiles.RemoveRange(dbContext.RecentFiles .OrderByDescending(f => f.ClosedDateTime) .Take(historyRemoveCount)); dbContext.SaveChanges(); return(true, deleted); } return(true, 0); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false, 0); } }
/// <summary> /// Gets the scintilla lines as string list. /// </summary> /// <param name="scintilla">The <see cref="Scintilla"/> class instance to get the lines from.</param> /// <returns>A collection containing the <see cref="Scintilla"/> control's lines.</returns> public static List <string> GetScintillaLinesAsStringList(Scintilla scintilla) { List <string> result = new List <string>(); try { foreach (var line in scintilla.Lines) { result.Add(line.Text); } } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); } return(result); }
/// <summary> /// Loads a custom spell checking assembly if defined in the settings file. /// </summary> public static void Load() { if (FormSettings.Settings.EditorSpellUseCustomDictionary) { try { var data = DictionaryPackage.GetXmlDefinitionDataFromDefinitionFile(FormSettings.Settings .EditorSpellCustomDictionaryDefinitionFile); ExternalSpellChecker.LoadSpellCheck(Path.GetDirectoryName(FormSettings.Settings .EditorSpellCustomDictionaryDefinitionFile), data.lib); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); } } }
/// <summary> /// Adds or updates a <see cref="SearchAndReplaceHistory"/> entity. /// </summary> /// <param name="text">The text used for searching or replacing.</param> /// <param name="searchAndReplaceSearchType">Type of the search and replace search.</param> /// <param name="searchAndReplaceType">Type of the search and replace.</param> /// <param name="caseSensitive">if set to <c>true</c> the search or replace is case sensitive.</param> /// <param name="fileSession">The file session.</param> /// <returns>SearchAndReplaceHistory.</returns> public static SearchAndReplaceHistory AddOrUpdateAndReplaceHistory(string text, SearchAndReplaceSearchType searchAndReplaceSearchType, SearchAndReplaceType searchAndReplaceType, bool caseSensitive, FileSession fileSession) { try { var context = ScriptNotepadDbContext.DbContext; if (!context.SearchAndReplaceHistories.Any(f => f.SearchOrReplaceText == text && f.SearchAndReplaceSearchType.HasFlag(searchAndReplaceSearchType) && f.SearchAndReplaceType == searchAndReplaceType && f.CaseSensitive == caseSensitive && f.Session.SessionName == fileSession.SessionName)) { var result = new SearchAndReplaceHistory { SearchOrReplaceText = text, SearchAndReplaceSearchType = searchAndReplaceSearchType, SearchAndReplaceType = searchAndReplaceType, CaseSensitive = caseSensitive, Session = fileSession, }; result = context.SearchAndReplaceHistories.Add(result).Entity; context.SaveChanges(); return(result); } return(context.SearchAndReplaceHistories.FirstOrDefault(f => f.SearchOrReplaceText == text && f.SearchAndReplaceSearchType.HasFlag(searchAndReplaceSearchType) && f.SearchAndReplaceType == searchAndReplaceType && f.CaseSensitive == caseSensitive && f.Session.SessionName == fileSession.SessionName)); // success.. } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(null); // failure.. } }
/// <summary> /// Loads a spell checker library from a given path with a given file name. /// </summary> /// <param name="path">The path.</param> /// <param name="fileName">Name of the file.</param> public static void LoadSpellCheck(string path, string fileName) { try { fileName = Path.Combine(path, fileName); AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; var assemblyName = Path.Combine(path, fileName); // the location of the assembly must be defined.. Assembly spellCheck = Assembly.LoadFile(assemblyName); SetSpellChecker(spellCheck); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); } }
/// <summary> /// Crawls the directory containing Hunspell dictionary and affix files. /// </summary> /// <param name="path">The path to search the dictionaries from.</param> /// <returns>List<HunspellData>.</returns> public static List <HunspellData> CrawlDirectory(string path) { // create a new instance of the DirectoryCrawler class by user given "arguments".. DirectoryCrawler crawler = new DirectoryCrawler(path, DirectoryCrawler.SearchTypeMatch.Regex, "*.dic", true); // search for the Hunspell dictionary files (*.dic).. var files = crawler.GetCrawlResult(); // initialize a return value.. List <HunspellData> result = new List <HunspellData>(); // loop through the found dictionary files (*.dic).. foreach (var file in files) { try { // create a new HunspellData class instance.. var data = HunspellData.FromDictionaryFile(file); // validate that there is a affix (*.aff) pair for the found dictionary file (*.dic).. if (!File.Exists(data.DictionaryFile) || !File.Exists(data.AffixFile)) { // ..if not, do continue.. continue; } // the validation was successful, so add the data to the result.. result.Add(data); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); } } // return the result.. return(result); }
/// <summary> /// Updates the plug-in entry data. /// </summary> /// <param name="pluginEntry">The plug-in entry <see cref="Plugin"/>.</param> /// <param name="assembly">The assembly of the plug-in.</param> /// <param name="plugin">The initialized plug-in.</param> /// <param name="fileNameFull">The full file name of the plug-in assembly.</param> /// <returns>An updated <see cref="Plugin"/> class instance based on the given arguments.</returns> public static Plugin UpdateFromPlugin(Plugin pluginEntry, Assembly assembly, IScriptNotepadPlugin plugin, string fileNameFull) { try { pluginEntry.FileNameFull = fileNameFull; pluginEntry.FileName = Path.GetFileName(fileNameFull); pluginEntry.FilePath = Path.GetDirectoryName(fileNameFull); pluginEntry.PluginName = plugin.PluginName; pluginEntry.PluginDescription = plugin.PluginDescription; // set the version for the plug-in.. AssemblyVersion.SetPluginUpdated(pluginEntry, assembly); return(pluginEntry); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(pluginEntry); } }
/// <summary> /// Deletes the older entities with a given limit. /// </summary> /// <param name="searchAndReplaceSearchType">Type of the search and replace search.</param> /// <param name="searchAndReplaceType">Type of the search and replace.</param> /// <param name="limit">The limit of how many to entities to keep.</param> /// <param name="fileSession">The file session.</param> /// <returns><c>true</c> if the operation was successful, <c>false</c> otherwise.</returns> public static bool DeleteOlderEntries(SearchAndReplaceSearchType searchAndReplaceSearchType, SearchAndReplaceType searchAndReplaceType, int limit, FileSession fileSession) { try { ScriptNotepadDbContext.DbContext.SearchAndReplaceHistories.RemoveRange( ScriptNotepadDbContext.DbContext.SearchAndReplaceHistories.Where(f => f.Session.SessionName == fileSession.SessionName && f.SearchAndReplaceSearchType.HasFlag(searchAndReplaceSearchType) && f.SearchAndReplaceType == searchAndReplaceType) .Except(GetEntriesByLimit(searchAndReplaceSearchType, searchAndReplaceType, limit, fileSession))); return(true); // success.. } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(false); // failure.. } }
/// <summary> /// Gets a collection the <see cref="Encoding"/> class instances corresponding to the given character set enumeration. /// </summary> /// <param name="characterSets">An enumeration value indicating which character set's encodings to get.</param> /// <returns>A collection of <see cref="Encoding"/> class instances for the given character set enumeration.</returns> public IEnumerable <Encoding> this[CharacterSets characterSets] { get { var result = new List <Encoding>(); int idx = internalList.FindIndex(f => f.Value == characterSets); if (idx != -1) { foreach (int encodingNum in internalList[idx].Key) { try { var encoding = Encoding.GetEncoding(encodingNum); result.Add(encoding); } catch (Exception ex) { ExceptionLogAction?.Invoke(ex); try { var encoding = CodePagesEncodingProvider.Instance.GetEncoding(encodingNum); if (encoding != null) { result.Add(encoding); } } catch (Exception exInner) { ExceptionLogAction?.Invoke(exInner); } } } } return(result); } }
/// <summary> /// Opens the Windows PowerShell (powershell.exe) with a given specific path. /// </summary> /// <param name="path">The path to start the Windows PowerShell with.</param> /// <returns>True if the operation was successful; otherwise false.</returns> public static bool OpenPowerShellWithPath(string path) { try { var processStartInfo = new ProcessStartInfo() { FileName = "powershell.exe", WorkingDirectory = path, UseShellExecute = false, LoadUserProfile = true, }; System.Diagnostics.Process.Start(processStartInfo); return(true); } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); return(false); } }
/// <summary> /// Initializes an external spell checker from a specified <see cref="Assembly"/> /// </summary> /// <param name="assembly">The assembly to load the spell checker from.</param> public static void SetSpellChecker(Assembly assembly) { foreach (Type type in assembly.GetTypes()) { // again keep on trying.. try { // check the validity of the found type.. if (typeof(IExternalDictionarySource).IsAssignableFrom(type)) { ScintillaSpellCheck.ExternalDictionary = (IExternalDictionarySource)Activator.CreateInstance(type); ScintillaSpellCheck.ExternalDictionary.Initialize(); return; } } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); } } }
/// <summary> /// Return data acquired from an assembly in case a plug-in failed to initialize. /// </summary> /// <param name="assembly">The assembly of the plug-in.</param> /// <param name="fileNameFull">The full file name of the plug-in assembly.</param> /// <returns>A <see cref="Plugin"/> class instance based on the given arguments.</returns> public static Plugin InvalidPlugin(Assembly assembly, string fileNameFull) { try { string description = string.Empty; if (assembly != null) { description = assembly.FullName; } // create a result based on the given parameters.. var result = new Plugin { FileNameFull = fileNameFull, FileName = Path.GetFileName(fileNameFull), FilePath = Path.GetDirectoryName(fileNameFull), PluginName = "Unknown", PluginDescription = description, IsActive = false, PluginInstalled = DateTime.Now, LoadFailures = 1, PluginVersion = VersionStringFromAssembly(assembly), }; // set the version for the plug-in.. AssemblyVersion.SetPluginUpdated(result, assembly); // return the result.. return(result); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); return(null); } }
/// <summary> /// Creates a new instance of "this" class from a Notepad++ style definition XML file. /// </summary> /// <param name="fileName">Name of the XML file.</param> /// <returns>MarkColorsHelper.</returns> public static MarkColorsHelper FromFile(string fileName) { try { var markColors = MarkColors.FromFile(fileName); return(new MarkColorsHelper { SmartHighlight = markColors.SmartHighLightingBackground, Mark1Color = markColors.MarkOneBackground, Mark2Color = markColors.MarkTwoBackground, Mark3Color = markColors.MarkThreeBackground, Mark4Color = markColors.MarkFourBackground, Mark5Color = markColors.MarkFiveBackground, CurrentLineBackground = markColors.CurrentLineBackground }); } catch (Exception ex) { // log the exception.. ExceptionLogAction?.Invoke(ex); // ..and return default.. return(default);
/// <summary> /// Executes a new instance of the current application with possible elevated permissions. /// </summary> /// <param name="elevated">If set to true try to run the process as administrator.</param> /// <param name="arguments">The arguments to be passed to the process.</param> /// <returns></returns> public static bool RunApplicationProcess(bool elevated, string arguments) { try { var processStartInfo = new ProcessStartInfo() { FileName = Application.ExecutablePath, LoadUserProfile = true, Verb = elevated ? "runas" : null, // process elevation.. Arguments = arguments }; System.Diagnostics.Process.Start(processStartInfo); return(true); } catch (Exception ex) { // log the exception if the action has a value.. ExceptionLogAction?.Invoke(ex); return(false); } }