public void Process(WatchedEvent @event)
{
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("Watcher fired on path: {0} state: {1} type {2}", @event.Path, @event.State, @event.Type);
}
try
{
writeLock.Lock();
}
catch (Exception e)
{
LOG.WarnFormat("Failed to acquire lock: {0} {1}", e, e.StackTrace);
}
}
/// <summary>
/// Retrieve a list of all formats currently in the IDataObject
/// </summary>
/// <returns>List<string> with the current formats</returns>
public static List <string> GetFormats(IDataObject dataObj)
{
string[] formats = null;
if (dataObj != null)
{
formats = dataObj.GetFormats();
}
if (formats != null)
{
LOG.DebugFormat("Got clipboard formats: {0}", String.Join(",", formats));
return(new List <string>(formats));
}
return(new List <string>());
}
/// <summary>
/// Add a new path to the paths that will be scanned for language files!
/// </summary>
/// <param name="path"></param>
/// <returns>true if the path exists and is added</returns>
public static bool AddLanguageFilePath(string path)
{
if (!languagePaths.Contains(path))
{
LOG.DebugFormat("New language path {0}", path);
if (AddPath(path))
{
ScanFiles();
Reload();
}
else
{
return(false);
}
}
return(true);
}
public void PrintRemoteTree()
{
LOG.Debug("Listing remote tree...");
try
{
Tree <RemoteFileInfo> .PrintTree(m_remoteTree, 0);
}
catch (Exception e)
{
LOG.ErrorFormat("Error: {0}", e);
}
int numberOfFiles = Tree <RemoteFileInfo> .GetNumberOfChildren(m_remoteTree, 0);
LOG.DebugFormat("Refreshed {0} remote files", numberOfFiles);
}
public void PrintIgnoreTree()
{
LOG.Debug("Listing ignored files...");
try
{
Tree <RemoteFileInfo> .PrintTree(m_ignoreTree, 0);
}
catch (Exception e)
{
LOG.ErrorFormat("Error: {0}", e);
}
int numberOfFiles = Tree <RemoteFileInfo> .GetNumberOfChildren(m_ignoreTree, 0);
LOG.DebugFormat("Loaded {0} ignored files", numberOfFiles);
}
/// <summary>
/// Internal method to add a path to the paths that will be scanned for language files!
/// </summary>
/// <param name="path"></param>
/// <returns>true if the path exists and is added</returns>
private static bool AddPath(string path)
{
if (!languagePaths.Contains(path))
{
if (Directory.Exists(path))
{
LOG.DebugFormat("Adding language path {0}", path);
languagePaths.Add(path);
return(true);
}
else
{
LOG.InfoFormat("Not adding non existing language path {0}", path);
}
}
return(false);
}
public virtual void AddField(Field field)
{
if (fieldsByType != null && fieldsByType.ContainsKey(field.FieldType))
{
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("A field with of type '{0}' already exists in this {1}, will overwrite.", field.FieldType, GetType());
}
}
fields.Add(field);
fieldsByType[field.FieldType] = field;
field.PropertyChanged += delegate { if (fieldChanged != null)
{
fieldChanged(this, new FieldChangedEventArgs(field));
}
};
}
private void GetFiles(string _remotePath, string _localPath, bool _remove = false, TransferOptions _transformOptions = null)
{
LOG.DebugFormat("Getting files from {0} >> {1}", _remotePath, _localPath);
try
{
// Download files and throw on any error
m_session.GetFiles(_remotePath, _localPath, _remove, _transformOptions).Check();
}
finally
{
// Terminate line after the last file (if any)
if (m_lastFileName != null)
{
LOG.Info("\nGetFiles done!");
}
}
}
/// <summary>
/// Make sure the content is also transformed.
/// </summary>
/// <param name="matrix"></param>
public override void Transform(Matrix matrix)
{
int rotateAngle = CalculateAngle(matrix);
// we currently assume only one transformation has been made.
if (rotateAngle != 0)
{
LOG.DebugFormat("Rotating element with {0} degrees.", rotateAngle);
DisposeShadow();
using (var tmpMatrix = new Matrix())
{
using (Image tmpImage = image)
{
image = ImageHelper.ApplyEffect(image, new RotateEffect(rotateAngle), tmpMatrix);
}
}
}
base.Transform(matrix);
}
/// <summary>
/// Returns the "com" type of the wrapperproxy, making it possible to perform reflection on it.
/// </summary>
/// <param name="wrapperProxy">wrapperProxy to get the type from</param>
/// <returns>Type</returns>
public static Type GetUnderlyingTypeForWrapper(object wrapperProxy)
{
Type returnType = null;
COMWrapper wrapper = RemotingServices.GetRealProxy(wrapperProxy) as COMWrapper;
if (wrapper != null)
{
IDispatch dispatch = wrapper._COMObject as IDispatch;
if (dispatch != null)
{
int result = dispatch.GetTypeInfo(0, 0, out returnType);
if (result != 0)
{
LOG.DebugFormat("GetTypeInfo : 0x{0} ({1})", result.ToString("X"), result);
}
}
}
return(returnType);
}
private void TabbedAnythingForm_FormClosing(object sender, FormClosingEventArgs e)
{
LOG.DebugFormat("FormClosing - Reason: {0}", e.CloseReason);
if (e.CloseReason == CloseReason.UserClosing)
{
if (!this.ConfirmClose())
{
LOG.Debug("FormClosing - Cancelled on confirm close");
e.Cancel = true;
return;
}
}
ProcessTabs.TabRemoved -= ProcessTabs_TabRemoved;
ProcessTabs.TabClosed -= ProcessTabs_TabClosed;
RemoveAllProcesses();
SaveWindowState();
}
/// <summary>
/// Get LastModified for a URI
/// </summary>
/// <param name="uri">Uri</param>
/// <returns>DateTime</returns>
public static DateTime GetLastModified(Uri uri)
{
try
{
HttpWebRequest webRequest = CreateWebRequest(uri);
webRequest.Method = HTTPMethod.HEAD.ToString();
using (HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse())
{
LOG.DebugFormat("RSS feed was updated at {0}", webResponse.LastModified);
return(webResponse.LastModified);
}
}
catch (Exception wE)
{
LOG.WarnFormat("Problem requesting HTTP - HEAD on uri {0}", uri);
LOG.Warn(wE.Message);
// Pretend it is old
return(DateTime.MinValue);
}
}
/// <summary>
/// Get an Image from the IDataObject, don't check for FileDrop
/// </summary>
/// <param name="dataObject"></param>
/// <returns>Image or null</returns>
private static Image GetImage(IDataObject dataObject)
{
Image returnImage = null;
if (dataObject != null)
{
IList <string> formats = GetFormats(dataObject);
string[] retrieveFormats;
// Found a weird bug, where PNG's from Outlook 2010 are clipped
// So I build some special logik to get the best format:
if (formats != null && formats.Contains(FORMAT_PNG_OFFICEART) && formats.Contains(DataFormats.Dib))
{
// Outlook ??
LOG.Info("Most likely the current clipboard contents come from Outlook, as this has a problem with PNG and others we place the DIB format to the front...");
retrieveFormats = new string[] { DataFormats.Dib, FORMAT_BITMAP, FORMAT_FILECONTENTS, FORMAT_PNG_OFFICEART, FORMAT_PNG, FORMAT_JFIF_OFFICEART, FORMAT_JPG, FORMAT_JFIF, DataFormats.Tiff, FORMAT_GIF };
}
else
{
retrieveFormats = new string[] { FORMAT_PNG_OFFICEART, FORMAT_PNG, FORMAT_17, FORMAT_JFIF_OFFICEART, FORMAT_JPG, FORMAT_JFIF, DataFormats.Tiff, DataFormats.Dib, FORMAT_BITMAP, FORMAT_FILECONTENTS, FORMAT_GIF };
}
foreach (string currentFormat in retrieveFormats)
{
if (formats.Contains(currentFormat))
{
LOG.InfoFormat("Found {0}, trying to retrieve.", currentFormat);
returnImage = GetImageForFormat(currentFormat, dataObject);
}
else
{
LOG.DebugFormat("Couldn't find format {0}.", currentFormat);
}
if (returnImage != null)
{
ImageHelper.Orientate(returnImage);
return(returnImage);
}
}
}
return(null);
}
public void UpdateRemoteFileList()
{
Stopwatch.Restart();
m_remoteTree.Data = new RemoteFileInfo();
m_remoteTree.Data.Name = RemoteRoot;
Update(RemoteRoot, m_remoteTree);
if (PrintTrees)
{
PrintRemoteChildren();
}
else
{
int numberOfFiles = Tree <RemoteFileInfo> .GetNumberOfChildren(m_remoteTree, 0);
numberOfFiles = (numberOfFiles == 1) ? 0 : numberOfFiles;
LOG.DebugFormat("Refreshed {0} remote files in [{1}ms]", numberOfFiles, Stopwatch.ElapsedMilliseconds);
}
}
public void PrintIgnoreChildren()
{
LOG.Debug("Listing ignore files...");
try
{
if (m_ignoreTree.Children.Count > 0)
{
Tree <RemoteFileInfo> .PrintTreeChildren(m_ignoreTree, RemoteRoot);
}
}
catch (Exception e)
{
LOG.ErrorFormat("Error: {0}", e);
}
int numberOfFiles = Tree <RemoteFileInfo> .GetNumberOfChildren(m_ignoreTree, 0);
numberOfFiles = (numberOfFiles == 1) ? 0 : numberOfFiles;
LOG.DebugFormat("Loaded {0} ignore files", numberOfFiles);
}
public void PrintRemoteChildren()
{
LOG.Debug("Listing remote files...");
try
{
if (m_remoteTree.Children.Count > 0)
{
Tree <RemoteFileInfo> .PrintTreeChildren(m_remoteTree, "");
}
}
catch (Exception e)
{
LOG.ErrorFormat("Error: {0}", e);
}
int numberOfFiles = Tree <RemoteFileInfo> .GetNumberOfChildren(m_remoteTree, 0);
numberOfFiles = (numberOfFiles == 1) ? 0 : numberOfFiles;
LOG.DebugFormat("Refreshed {0} remote files", numberOfFiles);
}
public SafeCurrentInputDesktopHandle() : base(true)
{
IntPtr hDesktop = User32.OpenInputDesktop(0, true, DesktopAccessRight.GENERIC_ALL);
if (hDesktop != IntPtr.Zero)
{
SetHandle(hDesktop);
if (User32.SetThreadDesktop(hDesktop))
{
LOG.DebugFormat("Switched to desktop {0}", hDesktop);
}
else
{
LOG.WarnFormat("Couldn't switch to desktop {0}", hDesktop);
LOG.Error(User32.CreateWin32Exception("SetThreadDesktop"));
}
}
else
{
LOG.Warn("Couldn't get current desktop.");
LOG.Error(User32.CreateWin32Exception("OpenInputDesktop"));
}
}
/// <summary>
/// Release the COM reference
/// </summary>
/// <param name="disposing">
/// <see langword="true"/> if this was called from the
/// <see cref="IDisposable"/> interface.
/// </param>
private void Dispose(bool disposing)
{
if (null != _COMObject)
{
LOG.DebugFormat("Disposing {0}", _InterceptType.ToString());
if (Marshal.IsComObject(_COMObject))
{
try
{
while (Marshal.ReleaseComObject(_COMObject) > 0)
{
;
}
}
catch (Exception ex)
{
LOG.WarnFormat("Problem releasing {0}", _COMType);
LOG.Warn("Error: ", ex);
}
}
_COMObject = null;
}
}
private void ProcessTabs_TabAdded(object sender, TabAddedEventArgs e)
{
LOG.DebugFormat("TabAdded - Tab: {0}", e.Tab);
RegisterExistingTab(e.Tab);
}
/// <summary>
/// This method will set the ini value to the supplied value or use the default if non supplied
/// </summary>
/// <param name="propertyValue"></param>
public void UseValueOrDefault(string propertyValue)
{
Type valueType = ValueType;
string propertyName = attributes.Name;
string defaultValue = attributes.DefaultValue;
bool defaultUsed = false;
object defaultValueFromConfig = containingIniSection.GetDefault(propertyName);
if (string.IsNullOrEmpty(propertyValue))
{
if (defaultValue != null && defaultValue.Trim().Length != 0)
{
propertyValue = defaultValue;
defaultUsed = true;
}
else if (defaultValueFromConfig != null)
{
LOG.DebugFormat("Default for Property {0} implemented!", propertyName);
}
else
{
if (attributes.ExcludeIfNull)
{
Value = null;
return;
}
LOG.DebugFormat("Property {0} has no value or default value!", propertyName);
}
}
// Now set the value
if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Dictionary <,>))
{
// Logic for Dictionary<,>
Type type1 = valueType.GetGenericArguments()[0];
Type type2 = valueType.GetGenericArguments()[1];
//LOG.Info(String.Format("Found Dictionary<{0},{1}>", type1.Name, type2.Name));
object dictionary = Activator.CreateInstance(valueType);
MethodInfo addMethodInfo = valueType.GetMethod("Add");
bool addedElements = false;
Dictionary <string, string> properties = IniConfig.PropertiesForSection(containingIniSection);
foreach (string key in properties.Keys)
{
if (key != null && key.StartsWith(propertyName + "."))
{
// What "key" do we need to store it under?
string subPropertyName = key.Substring(propertyName.Length + 1);
string stringValue = properties[key];
object newValue1 = null;
object newValue2 = null;
try
{
newValue1 = ConvertStringToValueType(type1, subPropertyName, attributes.Separator);
}
catch (Exception ex)
{
LOG.Warn(ex);
//LOG.Error("Problem converting " + subPropertyName + " to type " + type1.FullName, e);
}
try
{
newValue2 = ConvertStringToValueType(type2, stringValue, attributes.Separator);
}
catch (Exception ex)
{
LOG.Warn(ex);
//LOG.Error("Problem converting " + stringValue + " to type " + type2.FullName, e);
}
addMethodInfo.Invoke(dictionary, new[] { newValue1, newValue2 });
addedElements = true;
}
}
// No need to return something that isn't filled!
if (addedElements)
{
Value = dictionary;
return;
}
else if (defaultValueFromConfig != null)
{
Value = defaultValueFromConfig;
return;
}
}
else if (!string.IsNullOrEmpty(propertyValue))
{
if (valueType.IsGenericType && valueType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
// We are dealing with a generic type that is nullable
valueType = Nullable.GetUnderlyingType(valueType);
}
object newValue = null;
try
{
newValue = ConvertStringToValueType(valueType, propertyValue, attributes.Separator);
}
catch (Exception ex1)
{
newValue = null;
if (!defaultUsed)
{
try
{
LOG.WarnFormat("Problem '{0}' while converting {1} to type {2} trying fallback...", ex1.Message, propertyValue, valueType.FullName);
newValue = ConvertStringToValueType(valueType, defaultValue, attributes.Separator);
ContainingIniSection.IsDirty = true;
LOG.InfoFormat("Used default value {0} for property {1}", defaultValue, propertyName);
}
catch (Exception ex2)
{
LOG.Warn("Problem converting fallback value " + defaultValue + " to type " + valueType.FullName, ex2);
}
}
else
{
LOG.Warn("Problem converting " + propertyValue + " to type " + valueType.FullName, ex1);
}
}
Value = newValue;
return;
}
// If nothing is set, we can use the default value from the config (if we habe one)
if (defaultValueFromConfig != null)
{
Value = defaultValueFromConfig;
return;
}
if (ValueType != typeof(string))
{
try
{
Value = Activator.CreateInstance(ValueType);
}
catch (Exception)
{
LOG.WarnFormat("Couldn't create instance of {0} for {1}, using default value.", ValueType.FullName, attributes.Name);
Value = default(ValueType);
}
}
else
{
Value = default(ValueType);
}
}
public void Process(WatchedEvent @event)
{
LOG.DebugFormat("Watcher fired on path: {0} state: {1} type {2}", @event.Path, @event.State, @event.Type);
reset.Set();
}
/// <summary>
/// Saves image to stream with specified quality
/// To prevent problems with GDI version of before Windows 7:
/// the stream is checked if it's seekable and if needed a MemoryStream as "cache" is used.
/// </summary>
/// <param name="imageToSave">image to save</param>
/// <param name="surface">surface for the elements, needed if the greenshot format is used</param>
/// <param name="stream">Stream to save to</param>
/// <param name="outputSettings">SurfaceOutputSettings</param>
public static void SaveToStream(Image imageToSave, ISurface surface, Stream stream, SurfaceOutputSettings outputSettings)
{
ImageFormat imageFormat = null;
bool useMemoryStream = false;
MemoryStream memoryStream = null;
if (outputSettings.Format == OutputFormat.greenshot && surface == null)
{
throw new ArgumentException("Surface needs to be se when using OutputFormat.Greenshot");
}
try
{
switch (outputSettings.Format)
{
case OutputFormat.bmp:
imageFormat = ImageFormat.Bmp;
break;
case OutputFormat.gif:
imageFormat = ImageFormat.Gif;
break;
case OutputFormat.jpg:
imageFormat = ImageFormat.Jpeg;
break;
case OutputFormat.tiff:
imageFormat = ImageFormat.Tiff;
break;
case OutputFormat.greenshot:
case OutputFormat.png:
default:
// Problem with non-seekable streams most likely doesn't happen with Windows 7 (OS Version 6.1 and later)
// http://stackoverflow.com/questions/8349260/generic-gdi-error-on-one-machine-but-not-the-other
if (!stream.CanSeek)
{
int majorVersion = Environment.OSVersion.Version.Major;
int minorVersion = Environment.OSVersion.Version.Minor;
if (majorVersion < 6 || (majorVersion == 6 && minorVersion == 0))
{
useMemoryStream = true;
LOG.Warn("Using memorystream prevent an issue with saving to a non seekable stream.");
}
}
imageFormat = ImageFormat.Png;
break;
}
LOG.DebugFormat("Saving image to stream with Format {0} and PixelFormat {1}", imageFormat, imageToSave.PixelFormat);
// Check if we want to use a memory stream, to prevent a issue which happens with Windows before "7".
// The save is made to the targetStream, this is directed to either the MemoryStream or the original
Stream targetStream = stream;
if (useMemoryStream)
{
memoryStream = new MemoryStream();
targetStream = memoryStream;
}
if (imageFormat == ImageFormat.Jpeg)
{
bool foundEncoder = false;
foreach (ImageCodecInfo imageCodec in ImageCodecInfo.GetImageEncoders())
{
if (imageCodec.FormatID == imageFormat.Guid)
{
EncoderParameters parameters = new EncoderParameters(1);
parameters.Param[0] = new EncoderParameter(Encoder.Quality, outputSettings.JPGQuality);
// Removing transparency if it's not supported in the output
if (Image.IsAlphaPixelFormat(imageToSave.PixelFormat))
{
Image nonAlphaImage = ImageHelper.Clone(imageToSave, PixelFormat.Format24bppRgb);
AddTag(nonAlphaImage);
nonAlphaImage.Save(targetStream, imageCodec, parameters);
nonAlphaImage.Dispose();
nonAlphaImage = null;
}
else
{
AddTag(imageToSave);
imageToSave.Save(targetStream, imageCodec, parameters);
}
foundEncoder = true;
break;
}
}
if (!foundEncoder)
{
throw new ApplicationException("No JPG encoder found, this should not happen.");
}
}
else
{
// Removing transparency if it's not supported in the output
if (imageFormat != ImageFormat.Png && Image.IsAlphaPixelFormat(imageToSave.PixelFormat))
{
Image nonAlphaImage = ImageHelper.Clone(imageToSave, PixelFormat.Format24bppRgb);
AddTag(nonAlphaImage);
nonAlphaImage.Save(targetStream, imageFormat);
nonAlphaImage.Dispose();
nonAlphaImage = null;
}
else
{
AddTag(imageToSave);
imageToSave.Save(targetStream, imageFormat);
}
}
// If we used a memory stream, we need to stream the memory stream to the original stream.
if (useMemoryStream)
{
memoryStream.WriteTo(stream);
}
// Output the surface elements, size and marker to the stream
if (outputSettings.Format == OutputFormat.greenshot)
{
using (MemoryStream tmpStream = new MemoryStream())
{
long bytesWritten = surface.SaveElementsToStream(tmpStream);
using (BinaryWriter writer = new BinaryWriter(tmpStream))
{
writer.Write(bytesWritten);
Version v = Assembly.GetExecutingAssembly().GetName().Version;
byte[] marker = Encoding.ASCII.GetBytes(String.Format("Greenshot{0:00}.{1:00}", v.Major, v.Minor));
writer.Write(marker);
tmpStream.WriteTo(stream);
}
}
}
}
finally
{
if (memoryStream != null)
{
memoryStream.Dispose();
}
}
}
public void TakeLeadership()
{
Leader = b;
LOG.DebugFormat("Leader: {0:x}", b);
}
/// <summary>
/// Gets a COM object and returns the transparent proxy which intercepts all calls to the object
/// </summary>
/// <param name="type">Interface which defines the method and properties to intercept</param>
/// <returns>Transparent proxy to the real proxy for the object</returns>
/// <remarks>The <paramref name="type"/> must be an interface decorated with the <see cref="ComProgIdAttribute"/>attribute.</remarks>
public static T GetInstance <T>()
{
Type type = typeof(T);
if (null == type)
{
throw new ArgumentNullException("type");
}
if (!type.IsInterface)
{
throw new ArgumentException("The specified type must be an interface.", "type");
}
ComProgIdAttribute progIDAttribute = ComProgIdAttribute.GetAttribute(type);
if (null == progIDAttribute || null == progIDAttribute.Value || 0 == progIDAttribute.Value.Length)
{
throw new ArgumentException("The specified type must define a ComProgId attribute.", "type");
}
string progId = progIDAttribute.Value;
object comObject = null;
// Convert from clsid to Prog ID, if needed
if (progId.StartsWith("clsid:"))
{
Guid guid = new Guid(progId.Substring(6));
int result = ProgIDFromCLSID(ref guid, out progId);
if (result != 0)
{
// Restore progId, as it's overwritten
progId = progIDAttribute.Value;
try
{
GetActiveObject(ref guid, IntPtr.Zero, out comObject);
}
catch (Exception)
{
LOG.WarnFormat("Error {0} getting instance for class id {1}", result, progIDAttribute.Value);
}
if (comObject == null)
{
LOG.WarnFormat("Error {0} getting progId {1}", result, progIDAttribute.Value);
}
}
else
{
LOG.InfoFormat("Mapped {0} to progId {1}", progIDAttribute.Value, progId);
}
}
if (comObject == null)
{
try
{
comObject = Marshal.GetActiveObject(progId);
}
catch (COMException comE)
{
if (comE.ErrorCode == MK_E_UNAVAILABLE)
{
LOG.DebugFormat("No current instance of {0} object available.", progId);
}
else if (comE.ErrorCode == CO_E_CLASSSTRING)
{
LOG.WarnFormat("Unknown progId {0}", progId);
}
else
{
LOG.Warn("Error getting active object for " + progIDAttribute.Value, comE);
}
}
catch (Exception e)
{
LOG.Warn("Error getting active object for " + progIDAttribute.Value, e);
}
}
if (comObject != null)
{
if (comObject is IDispatch)
{
COMWrapper wrapper = new COMWrapper(comObject, type, progIDAttribute.Value);
return((T)wrapper.GetTransparentProxy());
}
else
{
return((T)comObject);
}
}
return(default(T));
}
public void AddAllRemoteFilesToIgnoreList()
{
LOG.DebugFormat("Adding all remote files from {0} to ignore list", RemoteRoot);
m_ignoreTree = Tree <RemoteFileInfo> .Clone(m_remoteTree);
}
/// <summary>
/// Called if the cancel button is clicked, will use Thread.Abort()
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CancelButtonClick(object sender, EventArgs e)
{
LOG.DebugFormat("Cancel clicked on {0}", title);
cancelButton.Enabled = false;
waitFor.Abort();
}
public bool RunForLeader()
{
long sessionId = Zookeeper.SessionId;
string prefix = "election-" + sessionId + "-";
var names = Zookeeper.GetChildren(path, false);
// See whether we have already run for election in this process
foreach (string name in names)
{
if (name.StartsWith(prefix))
{
id = name;
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("Found id created last time: {0}", id);
}
}
}
if (id == null)
{
id = Zookeeper.Create(path.Combine(prefix), data, Acl, CreateMode.EphemeralSequential);
if (LOG.IsDebugEnabled)
{
LOG.DebugFormat("Created id: {0}", id);
}
}
idName = new ZNodeName(id);
names = Zookeeper.GetChildren(path, false);
var sortedNames = new SortedSet <ZNodeName>();
foreach (var name in names)
{
sortedNames.Add(new ZNodeName(name));
}
var priors = sortedNames.HeadSet(idName);
if (priors.Count == 0)
{
throw new InvalidOperationException("Count of priors is 0, but should at least include this node.");
}
if (priors.Count == 1)
{
IsOwner = true;
watcher.TakeLeadership();
return(true);
}
// only watch the node directly before us
ZNodeName penultimate = null, last = null;
foreach (var name in sortedNames)
{
penultimate = last;
last = name;
}
if (penultimate == null)
{
throw new InvalidOperationException("Penultimate value in priors is null, but count shoudl have been at least 2.");
}
var penultimatePath = path.Combine(penultimate.Name);
if (Zookeeper.Exists(penultimatePath, new LeaderWatcher(Zookeeper, this, penultimatePath, watcher, path, id)) == null)
{
IsOwner = true;
watcher.TakeLeadership();
return(true);
}
return(false);
}
/// <summary>
/// Intercept method calls
/// </summary>
/// <param name="myMessage">
/// Contains information about the method being called
/// </param>
/// <returns>
/// A <see cref="ReturnMessage"/>.
/// </returns>
public override IMessage Invoke(IMessage myMessage)
{
IMethodCallMessage callMessage = myMessage as IMethodCallMessage;
if (null == callMessage)
{
LOG.DebugFormat("Message type not implemented: {0}", myMessage.GetType().ToString());
return(null);
}
MethodInfo method = callMessage.MethodBase as MethodInfo;
if (null == method)
{
LOG.DebugFormat("Unrecognized Invoke call: {0}", callMessage.MethodBase.ToString());
return(null);
}
object returnValue = null;
object[] outArgs = null;
int outArgsCount = 0;
string methodName = method.Name;
Type returnType = method.ReturnType;
BindingFlags flags = BindingFlags.InvokeMethod;
int argCount = callMessage.ArgCount;
object invokeObject;
Type invokeType;
Type byValType;
object[] args;
object arg;
COMWrapper[] originalArgs;
COMWrapper wrapper;
ParameterModifier[] argModifiers = null;
ParameterInfo[] parameters = null;
ParameterInfo parameter;
if ("Dispose" == methodName && 0 == argCount && typeof(void) == returnType)
{
Dispose();
}
else if ("ToString" == methodName && 0 == argCount && typeof(string) == returnType)
{
returnValue = ToString();
}
else if ("GetType" == methodName && 0 == argCount && typeof(Type) == returnType)
{
returnValue = _InterceptType;
}
else if ("GetHashCode" == methodName && 0 == argCount && typeof(int) == returnType)
{
returnValue = GetHashCode();
}
else if ("Equals" == methodName && 1 == argCount && typeof(bool) == returnType)
{
returnValue = Equals(callMessage.Args[0]);
}
else if (1 == argCount && typeof(void) == returnType && (methodName.StartsWith("add_") || methodName.StartsWith("remove_")))
{
bool removeHandler = methodName.StartsWith("remove_");
methodName = methodName.Substring(removeHandler ? 7 : 4);
Delegate handler = callMessage.InArgs[0] as Delegate;
if (null == handler)
{
return(new ReturnMessage(new ArgumentNullException("handler"), callMessage));
}
}
else
{
invokeObject = _COMObject;
invokeType = _COMType;
if (methodName.StartsWith("get_"))
{
// Property Get
methodName = methodName.Substring(4);
flags = BindingFlags.GetProperty;
args = callMessage.InArgs;
}
else if (methodName.StartsWith("set_"))
{
// Property Set
methodName = methodName.Substring(4);
flags = BindingFlags.SetProperty;
args = callMessage.InArgs;
}
else
{
args = callMessage.Args;
if (null != args && 0 != args.Length)
{
// Modifiers for ref / out parameters
argModifiers = new ParameterModifier[1];
argModifiers[0] = new ParameterModifier(args.Length);
parameters = method.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
parameter = parameters[i];
if (parameter.IsOut || parameter.ParameterType.IsByRef)
{
argModifiers[0][i] = true;
outArgsCount++;
}
}
if (0 == outArgsCount)
{
argModifiers = null;
}
}
}
// Un-wrap wrapped COM objects before passing to the method
if (null == args || 0 == args.Length)
{
originalArgs = null;
}
else
{
originalArgs = new COMWrapper[args.Length];
for (int i = 0; i < args.Length; i++)
{
if (null != args[i] && RemotingServices.IsTransparentProxy(args[i]))
{
wrapper = RemotingServices.GetRealProxy(args[i]) as COMWrapper;
if (null != wrapper)
{
originalArgs[i] = wrapper;
args[i] = wrapper._COMObject;
}
}
else if (0 != outArgsCount && argModifiers[0][i])
{
byValType = GetByValType(parameters[i].ParameterType);
if (byValType.IsInterface)
{
// If we're passing a COM object by reference, and
// the parameter is null, we need to pass a
// DispatchWrapper to avoid a type mismatch exception.
if (null == args[i])
{
args[i] = new DispatchWrapper(null);
}
}
else if (typeof(Decimal) == byValType)
{
// If we're passing a decimal value by reference,
// we need to pass a CurrencyWrapper to avoid a
// type mismatch exception.
// http://support.microsoft.com/?kbid=837378
args[i] = new CurrencyWrapper(args[i]);
}
}
}
}
do
{
try
{
returnValue = invokeType.InvokeMember(methodName, flags, null, invokeObject, args, argModifiers, null, null);
break;
}
catch (Exception ex)
{
// Test for rejected
COMException comEx = ex as COMException;
if (comEx == null)
{
comEx = ex.InnerException as COMException;
}
if (comEx != null && (comEx.ErrorCode == RPC_E_CALL_REJECTED || comEx.ErrorCode == RPC_E_FAIL))
{
string destinationName = _TargetName;
// Try to find a "catchy" name for the rejecting application
if (destinationName != null && destinationName.Contains("."))
{
destinationName = destinationName.Substring(0, destinationName.IndexOf("."));
}
if (destinationName == null)
{
destinationName = _InterceptType.FullName;
}
DialogResult result = MessageBox.Show(Language.GetFormattedString("com_rejected", destinationName), Language.GetString("com_rejected_title"), MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
if (result == DialogResult.OK)
{
continue;
}
}
// Not rejected OR pressed cancel
return(new ReturnMessage(ex, callMessage));
}
} while (true);
// Handle enum and interface return types
if (null != returnValue)
{
if (returnType.IsInterface)
{
// Wrap the returned value in an intercepting COM wrapper
if (Marshal.IsComObject(returnValue))
{
returnValue = Wrap(returnValue, returnType, _TargetName);
}
}
else if (returnType.IsEnum)
{
// Convert to proper Enum type
returnValue = Enum.Parse(returnType, returnValue.ToString());
}
}
// Handle out args
if (0 != outArgsCount)
{
outArgs = new object[args.Length];
for (int i = 0; i < parameters.Length; i++)
{
if (!argModifiers[0][i])
{
continue;
}
arg = args[i];
if (null == arg)
{
continue;
}
parameter = parameters[i];
wrapper = null;
byValType = GetByValType(parameter.ParameterType);
if (typeof(Decimal) == byValType)
{
if (arg is CurrencyWrapper)
{
arg = ((CurrencyWrapper)arg).WrappedObject;
}
}
else if (byValType.IsEnum)
{
arg = Enum.Parse(byValType, arg.ToString());
}
else if (byValType.IsInterface)
{
if (Marshal.IsComObject(arg))
{
wrapper = originalArgs[i];
if (null != wrapper && wrapper._COMObject != arg)
{
wrapper.Dispose();
wrapper = null;
}
if (null == wrapper)
{
wrapper = new COMWrapper(arg, byValType, _TargetName);
}
arg = wrapper.GetTransparentProxy();
}
}
outArgs[i] = arg;
}
}
}
return(new ReturnMessage(returnValue, outArgs, outArgsCount, callMessage.LogicalCallContext, callMessage));
}
/// <summary>
/// Get an Image from the IDataObject, don't check for FileDrop
/// </summary>
/// <param name="dataObject"></param>
/// <returns>Image or null</returns>
private static Image GetImage(IDataObject dataObject)
{
Image returnImage = null;
if (dataObject != null)
{
IList <string> formats = GetFormats(dataObject);
string[] retrieveFormats;
// Found a weird bug, where PNG's from Outlook 2010 are clipped
// So I build some special logik to get the best format:
if (formats != null && formats.Contains(FORMAT_PNG_OFFICEART) && formats.Contains(DataFormats.Dib))
{
// Outlook ??
LOG.Info("Most likely the current clipboard contents come from Outlook, as this has a problem with PNG and others we place the DIB format to the front...");
retrieveFormats = new string[] { DataFormats.Dib, FORMAT_BITMAP_PLACEHOLDER, FORMAT_FILECONTENTS, FORMAT_PNG_OFFICEART, FORMAT_PNG, FORMAT_JFIF_OFFICEART, FORMAT_JPG, FORMAT_JFIF, DataFormats.Tiff, FORMAT_GIF };
}
else
{
retrieveFormats = new string[] { FORMAT_PNG_OFFICEART, FORMAT_PNG, FORMAT_JFIF_OFFICEART, FORMAT_JPG, FORMAT_JFIF, DataFormats.Tiff, DataFormats.Dib, FORMAT_BITMAP_PLACEHOLDER, FORMAT_FILECONTENTS, FORMAT_GIF };
}
foreach (string currentFormat in retrieveFormats)
{
if (FORMAT_BITMAP_PLACEHOLDER.Equals(currentFormat))
{
LOG.Info("Using default .NET Clipboard.GetImage()");
try
{
returnImage = Clipboard.GetImage();
if (returnImage != null)
{
return(returnImage);
}
else
{
LOG.Info("Clipboard.GetImage() didn't return an image.");
}
}
catch (Exception ex)
{
LOG.Error("Problem retrieving Image via Clipboard.GetImage(): ", ex);
}
}
else if (formats.Contains(currentFormat))
{
LOG.InfoFormat("Found {0}, trying to retrieve.", currentFormat);
if (currentFormat == DataFormats.Dib)
{
returnImage = GetDIBImage(dataObject);
}
else
{
returnImage = GetImageFormat(currentFormat, dataObject);
}
if (returnImage != null)
{
return(returnImage);
}
}
else
{
LOG.DebugFormat("Couldn't find format {0}.", currentFormat);
}
}
}
return(null);
}
/// <summary>
/// A simple create instance, doesn't create a wrapper!!
/// </summary>
/// <returns>T</returns>
public static T CreateInstance <T>()
{
Type type = typeof(T);
if (null == type)
{
throw new ArgumentNullException("type");
}
if (!type.IsInterface)
{
throw new ArgumentException("The specified type must be an interface.", "type");
}
ComProgIdAttribute progIDAttribute = ComProgIdAttribute.GetAttribute(type);
if (null == progIDAttribute || null == progIDAttribute.Value || 0 == progIDAttribute.Value.Length)
{
throw new ArgumentException("The specified type must define a ComProgId attribute.", "type");
}
string progId = progIDAttribute.Value;
Type comType = null;
if (progId.StartsWith("clsid:"))
{
Guid guid = new Guid(progId.Substring(6));
try
{
comType = Type.GetTypeFromCLSID(guid);
}
catch (Exception ex)
{
LOG.WarnFormat("Error {1} type for {0}", progId, ex.Message);
}
}
else
{
try
{
comType = Type.GetTypeFromProgID(progId, true);
}
catch (Exception ex)
{
LOG.WarnFormat("Error {1} type for {0}", progId, ex.Message);
}
}
object comObject = null;
if (comType != null)
{
try
{
comObject = Activator.CreateInstance(comType);
if (comObject != null)
{
LOG.DebugFormat("Created new instance of {0} object.", progId);
}
}
catch (Exception e)
{
LOG.WarnFormat("Error {1} creating object for {0}", progId, e.Message);
}
}
if (comObject != null)
{
return((T)comObject);
}
return(default(T));
}
