460 lines
17 KiB
C#
460 lines
17 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using Foo.Platform;
|
|
using System.Diagnostics;
|
|
|
|
namespace Foo.Settings
|
|
{
|
|
[Guid("6FBB970D-0825-471e-9839-448FB2B6A842")]
|
|
[InterfaceType(ComInterfaceType.InterfaceIsDual)]
|
|
[ComVisible(true)]
|
|
public interface IOoganizerSettings
|
|
{
|
|
// reading in configuration data
|
|
configuration ReadConfigXMLFile();
|
|
|
|
// write custom configuration data to default location
|
|
void WriteConfigXMLFileDefaultLoc(configuration config);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializable Xml Object used to store all Configuration data - place any new class objects in here
|
|
/// </summary>
|
|
[Guid("EA2D77C2-AA17-4142-8FA7-7D6FA35316F4")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
[XmlRoot("configuration", Namespace = "http://www.ooganizer.com", IsNullable = false)]
|
|
public class configuration
|
|
{
|
|
// Member Tags <>
|
|
public ButtonHookSettings ButtonHook = null;
|
|
|
|
/// <summary>
|
|
/// configuration - Constructor
|
|
/// </summary>
|
|
public configuration()
|
|
{
|
|
ButtonHook = new ButtonHookSettings();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializable Xml Object used to store ButtonHookSettings
|
|
/// </summary>
|
|
[Guid("2C055265-715A-4d10-B744-ADCE796BED1C")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
[XmlRoot("ButtonHookSettings", Namespace = "http://www.ooganizer.com", IsNullable = false)]
|
|
public class ButtonHookSettings
|
|
{
|
|
// Member Tags <>
|
|
public AllowedProcessNamesW AllowedProcessNames = null;
|
|
public AllowedWindowTitlesW AllowedWindowTitles = null;
|
|
public AllowedWindowClassesW AllowedWindowClasses = null;
|
|
public LoggingSettings LogSettings = null;
|
|
|
|
/// <summary>
|
|
/// AllowedProcessNames - (Wrapper) around ArrayList to work with COM and XML
|
|
/// </summary>
|
|
[Guid("06403D5A-E309-42d3-B639-1F9DB99880A4")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
public class AllowedProcessNamesW
|
|
{
|
|
private ArrayList m_ArrayList;
|
|
public AllowedProcessNamesW()
|
|
{
|
|
m_ArrayList = new ArrayList();
|
|
}
|
|
|
|
[XmlElement("ProcessName")]
|
|
public ProcessName[] ProcessNames
|
|
{
|
|
get
|
|
{
|
|
ProcessName[] processNames = new ProcessName[m_ArrayList.Count];
|
|
m_ArrayList.CopyTo(processNames);
|
|
return processNames;
|
|
}
|
|
set
|
|
{
|
|
if (value == null) return;
|
|
ProcessName[] processNames = (ProcessName[])value;
|
|
m_ArrayList.Clear();
|
|
foreach (ProcessName processName in processNames)
|
|
m_ArrayList.Add(processName);
|
|
}
|
|
}
|
|
|
|
public int AddProcessName(ProcessName processName)
|
|
{
|
|
return m_ArrayList.Add(processName);
|
|
}
|
|
}
|
|
|
|
[Guid("EC4E542F-2877-4bb4-8FEF-30F1A1C1B53B")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
public class ProcessName
|
|
{
|
|
public ProcessName()
|
|
{
|
|
this.CustomBHTop = 0;
|
|
this.CustomBHRight = 0;
|
|
}
|
|
|
|
public ProcessName(string ProcessExe, string Resolver, string ResolverPrms, string Launcher, string Closer, string ShowHider, string Versions, int CustomBHTop, int CustomBHRight)
|
|
{
|
|
this._ProcessExe = ProcessExe;
|
|
this.Resolver = Resolver;
|
|
this.ResolverPrms = ResolverPrms;
|
|
this.Launcher = Launcher;
|
|
this.Closer = Closer;
|
|
this.ShowHider = ShowHider;
|
|
this.Versions = Versions;
|
|
this.CustomBHTop = CustomBHTop;
|
|
this.CustomBHRight = CustomBHRight;
|
|
}
|
|
|
|
private string _ProcessExe;
|
|
[XmlText]
|
|
public string ProcessExe
|
|
{
|
|
get
|
|
{
|
|
if (!String.IsNullOrEmpty(_ProcessExe))
|
|
return _ProcessExe.ToUpper();
|
|
else
|
|
return String.Empty;
|
|
}
|
|
set
|
|
{
|
|
_ProcessExe = value;
|
|
}
|
|
}
|
|
|
|
[XmlAttribute("Resolver")]
|
|
public string Resolver;
|
|
|
|
[XmlAttribute("ResolverPrms")]
|
|
public string ResolverPrms;
|
|
|
|
[XmlAttribute("Launcher")]
|
|
public string Launcher;
|
|
|
|
[XmlAttribute("Closer")]
|
|
public string Closer;
|
|
|
|
[XmlAttribute("ShowHider")]
|
|
public string ShowHider;
|
|
|
|
[XmlAttribute("Versions")]
|
|
public string Versions;
|
|
|
|
[XmlAttribute("CustomBHTop")]
|
|
public int CustomBHTop;
|
|
|
|
[XmlAttribute("CustomBHRight")]
|
|
public int CustomBHRight;
|
|
}
|
|
|
|
/// <summary>
|
|
/// AllowedWindowTitles - (Wrapper) around ArrayList to work with COM and XML
|
|
/// </summary>
|
|
[Guid("5B9CC560-9E53-4ae2-8701-E60F99A9A80D")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
public class AllowedWindowTitlesW
|
|
{
|
|
private ArrayList m_ArrayList;
|
|
public AllowedWindowTitlesW()
|
|
{
|
|
m_ArrayList = new ArrayList();
|
|
m_ArrayList.Add("");
|
|
}
|
|
[XmlElement("WindowTitle")]
|
|
public string[] WindowTitle
|
|
{
|
|
get
|
|
{
|
|
string[] windowTitles = new string[m_ArrayList.Count];
|
|
m_ArrayList.CopyTo(windowTitles);
|
|
return windowTitles;
|
|
}
|
|
set
|
|
{
|
|
if (value == null) return;
|
|
string[] windowTitles = (string[])value;
|
|
m_ArrayList.Clear();
|
|
foreach (string windowTitle in windowTitles)
|
|
m_ArrayList.Add(windowTitle);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// AllowedWindowClasses - (Wrapper) around ArrayList to work with COM and XML
|
|
/// </summary>
|
|
[Guid("FE3ECBC4-9082-43b5-8274-7DC3A4FB4855")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
public class AllowedWindowClassesW
|
|
{
|
|
private ArrayList m_ArrayList;
|
|
public AllowedWindowClassesW()
|
|
{
|
|
m_ArrayList = new ArrayList();
|
|
m_ArrayList.Add("");
|
|
}
|
|
|
|
[XmlElement("WindowClass")]
|
|
public string[] WindowClass
|
|
{
|
|
get
|
|
{
|
|
string[] windowClasses = new string[m_ArrayList.Count];
|
|
m_ArrayList.CopyTo(windowClasses);
|
|
return windowClasses;
|
|
}
|
|
set
|
|
{
|
|
if (value == null) return;
|
|
string[] windowClasses = (string[])value;
|
|
m_ArrayList.Clear();
|
|
foreach (string windowClass in windowClasses)
|
|
m_ArrayList.Add(windowClass);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// LoggingSettings = Set Log Settings (Location & Detail) for ButtonHook
|
|
/// </summary>
|
|
[Guid("A5A6EBA5-DC51-4bba-B7DC-0202153F57DF")]
|
|
[ClassInterface(ClassInterfaceType.AutoDual)]
|
|
[ComVisible(true)]
|
|
public class LoggingSettings
|
|
{
|
|
public uint LoggingDetail;
|
|
|
|
private string _LogPath;
|
|
public string LogPath
|
|
{
|
|
get
|
|
{
|
|
if (!String.IsNullOrEmpty(_LogPath))
|
|
return Platform.Env.GetLogDirectory();
|
|
else
|
|
return _LogPath;
|
|
}
|
|
set
|
|
{
|
|
try
|
|
{
|
|
if (Directory.Exists(value))
|
|
_LogPath = value;
|
|
}
|
|
catch(Exception){}
|
|
}
|
|
}
|
|
|
|
public LoggingSettings()
|
|
{
|
|
_LogPath = String.Empty;
|
|
LoggingDetail = (int)_LoggingDetail.LOGGING_NONE;
|
|
}
|
|
|
|
// same enum Definition in ButtonHook
|
|
public enum _LoggingDetail { LOGGING_NONE = 0, LOGGING_LOW = 1, LOGGING_MEDIUM = 2, LOGGING_HIGH = 3};
|
|
}
|
|
|
|
/// <summary>
|
|
/// ButtonHookSettings - Constructor
|
|
/// </summary>
|
|
public ButtonHookSettings()
|
|
{
|
|
AllowedProcessNames = new AllowedProcessNamesW();
|
|
AllowedWindowTitles = new AllowedWindowTitlesW();
|
|
AllowedWindowClasses = new AllowedWindowClassesW();
|
|
LogSettings = new LoggingSettings();
|
|
}
|
|
}
|
|
|
|
[Guid("80adff74-7124-42e6-ac2c-e19f51a47432")]
|
|
[ClassInterface(ClassInterfaceType.None)]
|
|
[ProgId("Ooganizer.SettingsAcc")]
|
|
[ComVisible(true)]
|
|
public class OoganizerSettingsAcc : IOoganizerSettings
|
|
{
|
|
private XmlSerializer m_ConfigSerializer = null;
|
|
public const string DEFAULT_CONFIG_XML_FILE_NAME = "AppConfig.xml";
|
|
private string m_AssemblyLocation = "";// location of running assembly
|
|
private configuration m_Configuration; // holds the latest configuration read in or written out,
|
|
// for easy access to the configuration
|
|
|
|
/// <summary>
|
|
/// Construcs the SettingsAccessor Object, Responsible for
|
|
/// interfacing with the App.Config file
|
|
/// </summary>
|
|
public OoganizerSettingsAcc()
|
|
{
|
|
m_ConfigSerializer = new XmlSerializer(typeof(configuration));
|
|
|
|
if (m_ConfigSerializer == null)
|
|
throw new OutOfMemoryException();
|
|
|
|
// The location of this assembly is in the Platform Directory
|
|
m_AssemblyLocation = Platform.InstallationSpec.InstallPath;
|
|
}
|
|
|
|
#region IOoganizerSettings
|
|
|
|
/// <summary>
|
|
/// Reads in the Config File from the Resource.
|
|
/// </summary>
|
|
/// <returns>the configuration object</returns>
|
|
public configuration ReadConfigXMLFile()
|
|
{
|
|
string strFileNameWithPath = m_AssemblyLocation + '\\' + DEFAULT_CONFIG_XML_FILE_NAME;
|
|
|
|
// If a physical xml file exists in the current directory (allow it to overwrite our settings)
|
|
if (File.Exists(strFileNameWithPath + '\\' + DEFAULT_CONFIG_XML_FILE_NAME))
|
|
{
|
|
return ReadConfigXMLFile(strFileNameWithPath, false);
|
|
}
|
|
else
|
|
{
|
|
// Else force reading of the Resource
|
|
return ReadConfigXMLFile(strFileNameWithPath, true);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the specified configruation to the default location and configuration file
|
|
/// </summary>
|
|
/// <param name="config">configuration object to write out</param>
|
|
public void WriteConfigXMLFileDefaultLoc(configuration config)
|
|
{
|
|
string strFileNameWithPath = m_AssemblyLocation + '\\' + DEFAULT_CONFIG_XML_FILE_NAME;
|
|
WriteConfigXMLFile(strFileNameWithPath, config);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region XML Writer Functions - useful for * Development and Debugging *
|
|
|
|
/// <summary>
|
|
/// Writes the specified configuration to the specified configuration file
|
|
/// </summary>
|
|
/// <param name="strFileNameWithPath">absolute path to file</param>
|
|
/// <param name="config">configuration object to write out</param>
|
|
public void WriteConfigXMLFile(string strFileNameWithPath, configuration config)
|
|
{
|
|
try
|
|
{
|
|
if (!Directory.Exists(Path.GetDirectoryName(strFileNameWithPath)))
|
|
{
|
|
Log.Error(string.Format("{0}() - Directory for {1} does not exist", MethodBase.GetCurrentMethod().Name, strFileNameWithPath));
|
|
return;
|
|
}
|
|
|
|
TextWriter writer = new StreamWriter(strFileNameWithPath);
|
|
m_ConfigSerializer.Serialize(writer, config);
|
|
m_Configuration = config;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(string.Format("{0}() - error thrown", MethodBase.GetCurrentMethod().Name), e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this to write a blank xml config file that you can then use
|
|
/// to store your configuration
|
|
/// </summary>
|
|
/// <param name="strFileNameWithPath">absolute path to file</param>
|
|
public void WriteBlankConfigXMLFile(string strFileNameWithPath)
|
|
{
|
|
try
|
|
{
|
|
if (!Directory.Exists(Path.GetDirectoryName(strFileNameWithPath)))
|
|
{
|
|
Log.Error(string.Format("{0}() - Directory for {1} does not exist", MethodBase.GetCurrentMethod().Name, strFileNameWithPath));
|
|
return;
|
|
}
|
|
|
|
TextWriter writer = new StreamWriter(strFileNameWithPath);
|
|
configuration settings = new configuration();
|
|
m_ConfigSerializer.Serialize(writer, settings);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(string.Format("{0}() - error thrown", MethodBase.GetCurrentMethod().Name), e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Main ReadConfig Function - Does most of the work
|
|
|
|
/// <summary>
|
|
/// Reads in the config file from the passed in location or from the Resource
|
|
/// </summary>
|
|
/// <param name="strFileNameWithPath">absolute path to file (not used when bReadFromResource is true)</param>
|
|
/// <param name="bReadFromResource">true to read Resource XML, false to read from passed in strFileNameWithPath</param>
|
|
/// <returns></returns>
|
|
private configuration ReadConfigXMLFile(string strFileNameWithPath, bool bReadFromResource)
|
|
{
|
|
const string SETTING_XML_RESOURCE_NAME = "Foo.Platform.AppConfig.xml";
|
|
try
|
|
{
|
|
|
|
if (bReadFromResource)
|
|
{
|
|
Assembly assembly = Assembly.GetExecutingAssembly();
|
|
|
|
// * Debugging Only * Make sure resource Name exists
|
|
#if DEBUG
|
|
string[] resourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
|
|
bool bFound = false;
|
|
foreach (string resourceName in resourceNames)
|
|
{
|
|
if (resourceName == SETTING_XML_RESOURCE_NAME)
|
|
bFound = true;
|
|
}
|
|
Debug.Assert(bFound);
|
|
#endif
|
|
|
|
TextReader reader = new StreamReader(assembly.GetManifestResourceStream(SETTING_XML_RESOURCE_NAME));
|
|
m_Configuration = (configuration)m_ConfigSerializer.Deserialize(reader);
|
|
return m_Configuration;
|
|
}
|
|
else
|
|
{
|
|
TextReader reader = new StreamReader(strFileNameWithPath);
|
|
m_Configuration = (configuration)m_ConfigSerializer.Deserialize(reader);
|
|
return m_Configuration;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(string.Format("{0}() - error thrown", MethodBase.GetCurrentMethod().Name), e);
|
|
throw (new Exception(e.Message));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
// Declare the Log4net Variable
|
|
private static log4net.ILog Log = Logger.GetLog4NetInterface(MethodBase.GetCurrentMethod().DeclaringType);
|
|
}
|
|
}
|