using ExcelDna.Integration;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
namespace TTool.IntelliSense
{
public static class IntelliSenseServer
{
private class RegistrationInfo : IComparable<IntelliSenseServer.RegistrationInfo>
{
public string XllPath;
public Guid ServerId;
public string Version;
public static IntelliSenseServer.RegistrationInfo FromRegistrationString(string registrationString)
{
IntelliSenseServer.RegistrationInfo result;
try
{
string[] array = registrationString.Split(new char[]
{
','
});
result = new IntelliSenseServer.RegistrationInfo
{
XllPath = array[0],
ServerId = Guid.ParseExact(array[1], "N"),
Version = array[2]
};
}
catch (Exception ex)
{
Debug.Print(string.Format("!!! ERROR: Invalid RegistrationString {0}: {1}", registrationString, ex.Message));
result = null;
}
return result;
}
public string ToRegistrationString()
{
return string.Format("{0},{1:N},{2}", this.XllPath, this.ServerId, this.Version);
}
public int CompareTo(IntelliSenseServer.RegistrationInfo other)
{
return IntelliSenseServer.RegistrationInfo.CompareVersions(this.Version, other.Version);
}
public static string GetControlMacroName(Guid serverId)
{
return string.Format("IntelliSenseServerControl_{0:N}", serverId);
}
public string GetControlMacroName()
{
return IntelliSenseServer.RegistrationInfo.GetControlMacroName(this.ServerId);
}
public static int CompareVersions(string versionString1, string versionString2)
{
int[] array = IntelliSenseServer.ParseVersion(versionString1);
int[] array2 = IntelliSenseServer.ParseVersion(versionString2);
int num = Math.Max(array.Length, array2.Length);
int i = 0;
int result;
while (i < num)
{
int num2 = (array.Length - 1 < i) ? 0 : array[i];
int num3 = (array2.Length - 1 < i) ? 0 : array2[i];
bool flag = num2 < num3;
if (flag)
{
result = -1;
}
else
{
bool flag2 = num2 > num3;
if (!flag2)
{
i++;
continue;
}
result = 1;
}
return result;
}
result = 0;
return result;
}
}
[CompilerGenerated]
[Serializable]
private sealed class <>c
{
public static readonly IntelliSenseServer.<>c <>9 = new IntelliSenseServer.<>c();
public static Func<string, IntelliSenseServer.RegistrationInfo> <>9__35_0;
internal IntelliSenseServer.RegistrationInfo <GetHighestPublishedRegistration>b__35_0(string str)
{
return IntelliSenseServer.RegistrationInfo.FromRegistrationString(str);
}
}
private const string ServerVersion = "1.0.1";
private const string DisabledVersionsMachineKeyName = "HKEY_LOCAL_MACHINE\\Software\\ExcelDna\\IntelliSense";
private const string DisabledVersionsUserKeyName = "HKEY_CURRENT_USER\\Software\\ExcelDna\\IntelliSense";
private const string DisabledVersionsValueName = "DisabledVersions";
private const string DisabledVersionsVariable = "EXCELDNA_INTELLISENSE_DISABLEDVERSIONS";
private const string ServersVariable = "EXCELDNA_INTELLISENSE_SERVERS";
private const string ActiveServerVariable = "EXCELDNA_INTELLISENSE_ACTIVE_SERVER";
private const string ControlMessageActivate = "ACTIVATE";
private const string ControlMessageDeactivate = "DEACTIVATE";
private const string ControlMessageRefresh = "REFRESH";
private static string _xllPath = ExcelDnaUtil.get_XllPath();
private static Guid _serverId = Guid.NewGuid();
private static bool _isActive = false;
private static IntelliSenseHelper _helper = null;
private static string RegistrationString
{
get
{
IntelliSenseServer.RegistrationInfo registrationInfo = new IntelliSenseServer.RegistrationInfo
{
XllPath = ExcelDnaUtil.get_XllPath(),
ServerId = IntelliSenseServer._serverId,
Version = "1.0.1"
};
return registrationInfo.ToRegistrationString();
}
}
public static void Register(ref UIMonitor uimonitorget)
{
TraceLogger.Initialize();
Logger.Initialization.Info(string.Format("IntelliSenseServer.Register Begin: Version {0} in {1}", "1.0.1", AppDomain.CurrentDomain.FriendlyName));
bool flag = IntelliSenseServer.IsDisabled();
if (!flag)
{
IntelliSenseServer.RegisterControlMacro();
IntelliSenseServer.PublishRegistration();
bool flag2 = false;
IntelliSenseServer.RegistrationInfo activeRegistrationInfo = IntelliSenseServer.GetActiveRegistrationInfo();
bool flag3 = activeRegistrationInfo == null;
if (flag3)
{
flag2 = true;
}
else
{
bool flag4 = IntelliSenseServer.RegistrationInfo.CompareVersions("1.0.1", activeRegistrationInfo.Version) > 0;
if (flag4)
{
flag2 = true;
}
else
{
Logger.Initialization.Info(string.Format("IntelliSenseServer not being activated now. Active Version: {0}", activeRegistrationInfo.Version));
}
}
bool flag5 = flag2 && (activeRegistrationInfo == null || IntelliSenseServer.DeactivateServer(activeRegistrationInfo));
if (flag5)
{
IntelliSenseServer.Activate();
uimonitorget = IntelliSenseServer._helper._uiMonitor;
}
AppDomain.CurrentDomain.DomainUnload += new EventHandler(IntelliSenseServer.CurrentDomain_DomainUnload);
AppDomain.CurrentDomain.ProcessExit += new EventHandler(IntelliSenseServer.CurrentDomain_ProcessExit);
Logger.Initialization.Info("IntelliSenseServer.Register End");
}
}
public static void Refresh()
{
Logger.Initialization.Info("IntelliSenseServer.Refresh Begin");
bool isActive = IntelliSenseServer._isActive;
if (isActive)
{
IntelliSenseServer.RefreshProviders();
}
else
{
IntelliSenseServer.RegistrationInfo activeRegistrationInfo = IntelliSenseServer.GetActiveRegistrationInfo();
bool flag = activeRegistrationInfo != null;
if (flag)
{
IntelliSenseServer.RefreshServer(activeRegistrationInfo);
}
}
Logger.Initialization.Info("IntelliSenseServer.Refresh End");
}
private static void CurrentDomain_ProcessExit(object sender, EventArgs e)
{
Logger.Initialization.Verbose("IntelliSenseServer ProcessExit Begin");
bool isActive = IntelliSenseServer._isActive;
if (isActive)
{
XlCall.ShutdownStarted();
IntelliSenseServer.Deactivate();
}
Logger.Initialization.Verbose("IntelliSenseServer ProcessExit End");
}
private static void CurrentDomain_DomainUnload(object sender, EventArgs e)
{
Logger.Initialization.Verbose("IntelliSenseServer DomainUnload Begin");
IntelliSenseServer.UnpublishRegistration();
bool isActive = IntelliSenseServer._isActive;
if (isActive)
{
IntelliSenseServer.Deactivate();
IntelliSenseServer.RegistrationInfo highestPublishedRegistration = IntelliSenseServer.GetHighestPublishedRegistration();
bool flag = highestPublishedRegistration != null;
if (flag)
{
IntelliSenseServer.ActivateServer(highestPublishedRegistration);
}
}
Logger.Initialization.Verbose("IntelliSenseServer DomainUnload End");
}
internal static bool Activate()
{
bool result;
try
{
IntelliSenseServer.SetActiveRegistrationInfo();
IntelliSenseServer._isActive = true;
IntelliSenseServer._helper = new IntelliSenseHelper();
result = true;
}
catch (Exception arg)
{
Logger.Initialization.Error(string.Format("IntelliSenseServer.Activate failed: {0}", arg));
result = false;
}
return result;
}
internal static bool Deactivate()
{
bool result;
try
{
bool flag = IntelliSenseServer._helper != null;
if (flag)
{
IntelliSenseServer._helper.Dispose();
}
IntelliSenseServer._isActive = false;
IntelliSenseServer.ClearActiveRegistrationInfo();
result = true;
}
catch (Exception arg)
{
Logger.Initialization.Error(string.Format("IntelliSenseServer.Deactivate error: {0}", arg));
result = false;
}
return result;
}
internal static void RefreshProviders()
{
Logger.Initialization.Info("IntelliSenseServer.RefreshProviders");
try
{
Debug.Assert(IntelliSenseServer._helper != null);
IntelliSenseServer._helper.RefreshProviders();
}
catch (Exception arg)
{
Logger.Initialization.Error(string.Format("IntelliSenseServer.RefreshProviders error: {0}", arg));
}
}
private static bool IsDisabled()
{
string text = Registry.GetValue("HKEY_LOCAL_MACHINE\\Software\\ExcelDna\\IntelliSense", "DisabledVersions", null) as string;
string text2 = Registry.GetValue("HKEY_CURRENT_USER\\Software\\ExcelDna\\IntelliSense", "DisabledVersions", null) as string;
string environmentVariable = Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_DISABLEDVERSIONS");
string text3 = "1.0.1";
bool flag = IntelliSenseServer.IsVersionMatch(text3, text) || IntelliSenseServer.IsVersionMatch(text3, text2) || IntelliSenseServer.IsVersionMatch(text3, environmentVariable);
bool flag2 = flag;
if (flag2)
{
Logger.Initialization.Info(string.Format("IntelliSenseServer version {0} is disabled. MachineDisabled: {1}, UserDisabled: {2}, EnvironmentDisabled: {3}", new object[]
{
text3,
text,
text2,
environmentVariable
}));
}
return flag;
}
private static bool ActivateServer(IntelliSenseServer.RegistrationInfo registrationInfo)
{
bool result;
try
{
object obj = XlCall.Excel(XlCall.xlUDF, new object[]
{
registrationInfo.GetControlMacroName(),
"ACTIVATE"
});
result = (bool)obj;
}
catch (Exception ex)
{
Logger.Initialization.Error(ex, string.Format("IntelliSenseServer {0} could not be activated.", registrationInfo.ToRegistrationString()), new object[0]);
result = false;
}
return result;
}
private static bool DeactivateServer(IntelliSenseServer.RegistrationInfo registrationInfo)
{
bool result;
try
{
object obj = XlCall.Excel(XlCall.xlUDF, new object[]
{
registrationInfo.GetControlMacroName(),
"DEACTIVATE"
});
bool flag = obj is ExcelError;
if (flag)
{
Logger.Initialization.Error(string.Format("IntelliSenseServer {0} could not be deactivated.", registrationInfo.ToRegistrationString()));
result = false;
}
else
{
result = (bool)obj;
}
}
catch (Exception ex)
{
Logger.Initialization.Error(ex, string.Format("IntelliSenseServer Deactivate call for {0} failed.", registrationInfo.ToRegistrationString()), new object[0]);
result = false;
}
return result;
}
private static bool RefreshServer(IntelliSenseServer.RegistrationInfo registrationInfo)
{
bool result;
try
{
object obj = XlCall.Excel(XlCall.xlUDF, new object[]
{
registrationInfo.GetControlMacroName(),
"REFRESH"
});
bool flag = obj is ExcelError;
if (flag)
{
Logger.Initialization.Error(string.Format("IntelliSenseServer {0} could not be deactivated.", registrationInfo.ToRegistrationString()));
result = false;
}
else
{
result = (bool)obj;
}
}
catch (Exception ex)
{
Logger.Initialization.Error(ex, string.Format("IntelliSenseServer Deactivate call for {0} failed.", registrationInfo.ToRegistrationString()), new object[0]);
result = false;
}
return result;
}
private static void PublishRegistration()
{
string environmentVariable = Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_SERVERS");
string value = (environmentVariable == null) ? IntelliSenseServer.RegistrationString : string.Join(";", new string[]
{
environmentVariable,
IntelliSenseServer.RegistrationString
});
Environment.SetEnvironmentVariable("EXCELDNA_INTELLISENSE_SERVERS", value);
}
private static void UnpublishRegistration()
{
List<string> list = new List<string>(Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_SERVERS").Split(new char[]
{
';'
}));
bool condition = list.Remove(IntelliSenseServer.RegistrationString);
Debug.Assert(condition, "IntelliSenseServer.UnpublishRegistration - Registration not found in EXCELDNA_INTELLISENSE_SERVERS");
string value = string.Join(";", list);
Environment.SetEnvironmentVariable("EXCELDNA_INTELLISENSE_SERVERS", value);
}
private static IntelliSenseServer.RegistrationInfo GetActiveRegistrationInfo()
{
string environmentVariable = Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_ACTIVE_SERVER");
bool flag = string.IsNullOrEmpty(environmentVariable);
IntelliSenseServer.RegistrationInfo result;
if (flag)
{
result = null;
}
else
{
result = IntelliSenseServer.RegistrationInfo.FromRegistrationString(environmentVariable);
}
return result;
}
private static void SetActiveRegistrationInfo()
{
string environmentVariable = Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_ACTIVE_SERVER");
Debug.Assert(environmentVariable == null, "ActiveServer already set while activating");
Environment.SetEnvironmentVariable("EXCELDNA_INTELLISENSE_ACTIVE_SERVER", IntelliSenseServer.RegistrationString);
}
private static void ClearActiveRegistrationInfo()
{
Environment.SetEnvironmentVariable("EXCELDNA_INTELLISENSE_ACTIVE_SERVER", null);
}
private static int[] ParseVersion(string versionString)
{
bool flag = string.IsNullOrEmpty(versionString);
int[] result;
if (flag)
{
result = new int[1];
}
else
{
string[] array = versionString.Split(new char[]
{
'.'
});
int[] array2 = new int[array.Length];
for (int i = 0; i < array.Length; i++)
{
int num;
bool flag2 = !int.TryParse(array[i], out num);
if (flag2)
{
result = new int[1];
return result;
}
array2[i] = num;
}
result = array2;
}
return result;
}
private static bool IsVersionMatch(string version, string versionPattern)
{
bool flag = string.IsNullOrEmpty(versionPattern);
bool result;
if (flag)
{
result = false;
}
else
{
bool flag2 = versionPattern == "*";
if (flag2)
{
result = true;
}
else
{
List<string> list = new List<string>();
string[] array = versionPattern.Split(new char[]
{
','
});
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i];
string text2 = text.Trim();
bool flag3 = Regex.IsMatch(text2, "(\\d+\\.)+(\\.\\*)?", RegexOptions.None);
if (flag3)
{
list.Add("^" + text2.Replace(".*", "(\\.\\d+)*") + "$");
}
}
string pattern = string.Join("|", list);
result = Regex.IsMatch(version, pattern);
}
}
return result;
}
private static IntelliSenseServer.RegistrationInfo GetHighestPublishedRegistration()
{
string environmentVariable = Environment.GetEnvironmentVariable("EXCELDNA_INTELLISENSE_SERVERS");
bool flag = environmentVariable == null;
IntelliSenseServer.RegistrationInfo result;
if (flag)
{
Debug.Print("!!! ERROR: ServersVariable not set");
result = null;
}
else
{
IEnumerable<string> arg_54_0 = environmentVariable.Split(new char[]
{
';'
});
Func<string, IntelliSenseServer.RegistrationInfo> arg_54_1;
if ((arg_54_1 = IntelliSenseServer.<>c.<>9__35_0) == null)
{
arg_54_1 = (IntelliSenseServer.<>c.<>9__35_0 = new Func<string, IntelliSenseServer.RegistrationInfo>(IntelliSenseServer.<>c.<>9.<GetHighestPublishedRegistration>b__35_0));
}
result = arg_54_0.Select(arg_54_1).Max<IntelliSenseServer.RegistrationInfo>();
}
return result;
}
private static void RegisterControlMacro()
{
MethodInfo method = typeof(IntelliSenseServer).GetMethod("IntelliSenseServerControl", BindingFlags.Static | BindingFlags.NonPublic);
string controlMacroName = IntelliSenseServer.RegistrationInfo.GetControlMacroName(IntelliSenseServer._serverId);
ExcelIntegration.RegisterMethods(new List<MethodInfo>
{
method
}, new List<object>
{
new ExcelCommandAttribute
{
Name = controlMacroName
}
}, new List<List<object>>
{
new List<object>
{
null
}
});
}
private static object IntelliSenseServerControl(object control)
{
string a = control as string;
bool flag = a == "ACTIVATE";
object result;
if (flag)
{
Debug.Print("IntelliSenseServer.Activate in AppDomain: " + AppDomain.CurrentDomain.FriendlyName);
result = IntelliSenseServer.Activate();
}
else
{
bool flag2 = a == "DEACTIVATE";
if (flag2)
{
Debug.Print("IntelliSenseServer.Deactivate in AppDomain: " + AppDomain.CurrentDomain.FriendlyName);
result = IntelliSenseServer.Deactivate();
}
else
{
bool flag3 = a == "REFRESH";
if (flag3)
{
Debug.Print("IntelliSenseServer.Refresh in AppDomain: " + AppDomain.CurrentDomain.FriendlyName);
bool flag4 = !IntelliSenseServer._isActive;
if (flag4)
{
Logger.Initialization.Error("IntelliSenseServer Refresh call on inactive server.");
result = false;
}
else
{
IntelliSenseServer.RefreshProviders();
result = true;
}
}
else
{
result = false;
}
}
}
return result;
}
}
}
.
.
