/// <summary>
/// This method handles the OnComponentChanged event to display a notification.
/// </summary>
/// <param name="sender"></param>
/// <param name="ce"></param>
private void OnComponentChanged(object sender, ComponentChangedEventArgs ce)
{
if (ce.Component != null && ((IComponent)ce.Component).Site != null && ce.Member != null)
{
if ("LanguageKey".Equals(ce.Member.Name))
{
Control control = ce.Component as Control;
if (control != null)
{
LOG.InfoFormat("Changing LanguageKey for {0} to {1}", control.Name, ce.NewValue);
ApplyLanguage(control, (string)ce.NewValue);
}
else
{
ToolStripItem item = ce.Component as ToolStripItem;
if (item != null)
{
LOG.InfoFormat("Changing LanguageKey for {0} to {1}", item.Name, ce.NewValue);
ApplyLanguage(item, (string)ce.NewValue);
}
else
{
LOG.InfoFormat("Not possible to changing LanguageKey for {0} to {1}", ce.Component.GetType(), ce.NewValue);
}
}
}
}
}
/// <summary>
/// Load the resources from the language file
/// </summary>
/// <param name="languageFile">File to load from</param>
private static void LoadResources(LanguageFile languageFile)
{
LOG.InfoFormat("Loading language file {0}", languageFile.Filepath);
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(languageFile.Filepath);
XmlNodeList resourceNodes = xmlDocument.GetElementsByTagName("resource");
foreach (XmlNode resourceNode in resourceNodes)
{
string key = resourceNode.Attributes["name"].Value;
if (!string.IsNullOrEmpty(languageFile.Prefix))
{
key = languageFile.Prefix + "." + key;
}
string text = resourceNode.InnerText;
if (!string.IsNullOrEmpty(text))
{
text = text.Trim();
}
if (!resources.ContainsKey(key))
{
resources.Add(key, text);
}
else
{
resources[key] = text;
}
}
}
catch (Exception e)
{
LOG.Error("Could not load language file " + languageFile.Filepath, e);
}
}
/// <summary>
/// Try to find the best match for the supplied IETF
/// </summary>
/// <param name="inputIETF"></param>
/// <returns>IETF</returns>
private static string FindBestIETFMatch(string inputIETF)
{
string returnIETF = inputIETF;
if (string.IsNullOrEmpty(returnIETF))
{
returnIETF = DEFAULT_LANGUAGE;
}
returnIETF = ReformatIETF(returnIETF);
if (!languageFiles.ContainsKey(returnIETF))
{
LOG.WarnFormat("Unknown language {0}, trying best match!", returnIETF);
if (returnIETF.Length == 5)
{
returnIETF = returnIETF.Substring(0, 2);
}
foreach (string availableIETF in languageFiles.Keys)
{
if (availableIETF.StartsWith(returnIETF))
{
LOG.InfoFormat("Found language {0}, best match for {1}!", availableIETF, returnIETF);
returnIETF = availableIETF;
break;
}
}
}
return(returnIETF);
}
/// <summary>
/// Helper method to try to get an image in the specified format from the dataObject
/// </summary>
/// <param name="format">string with the format</param>
/// <param name="dataObject">IDataObject</param>
/// <returns>Image or null</returns>
private static Image GetImageFormat(string format, IDataObject dataObject)
{
MemoryStream imageStream = GetFromDataObject(dataObject, format) as MemoryStream;
if (isValidStream(imageStream))
{
try
{
using (FileStream fs = new FileStream(@"C:\Localdata\test.png", FileMode.OpenOrCreate))
{
imageStream.WriteTo(fs);
}
imageStream.Seek(0, SeekOrigin.Begin);
using (Image tmpImage = Image.FromStream(imageStream, true, true))
{
if (tmpImage != null)
{
LOG.InfoFormat("Got image with clipboard format {0} from the clipboard.", format);
return(ImageHelper.Clone(tmpImage));
}
}
}
catch (Exception streamImageEx)
{
LOG.Error(string.Format("Problem retrieving {0} from clipboard.", format), streamImageEx);
}
}
return(null);
}
private void SessionFileTransferProgress(object sender, FileTransferProgressEventArgs e)
{
// Print transfer progress
LOG.InfoFormat("\r{0} ({1:P0} CPS = {2})", e.FileName, e.FileProgress, e.CPS);
// Remember a name of the last file reported
m_lastFileName = e.FileName;
}
/// <summary>
///
/// </summary>
/// <param name="webRequest"></param>
/// <returns></returns>
public static string GetResponseAsString(HttpWebRequest webRequest, bool alsoReturnContentOnError)
{
string responseData = null;
HttpWebResponse response = null;
bool isHttpError = false;
try
{
response = (HttpWebResponse)webRequest.GetResponse();
LOG.InfoFormat("Response status: {0}", response.StatusCode);
isHttpError = (int)response.StatusCode >= 300;
if (isHttpError)
{
LOG.ErrorFormat("HTTP error {0}", response.StatusCode);
}
DebugHeaders(response);
responseData = GetResponseAsString(response);
if (isHttpError)
{
LOG.ErrorFormat("HTTP response {0}", responseData);
}
}
catch (WebException e)
{
response = (HttpWebResponse)e.Response;
HttpStatusCode statusCode = HttpStatusCode.Unused;
if (response != null)
{
statusCode = response.StatusCode;
LOG.ErrorFormat("HTTP error {0}", statusCode);
string errorContent = GetResponseAsString(response);
if (alsoReturnContentOnError)
{
return(errorContent);
}
LOG.ErrorFormat("Content: {0}", errorContent);
}
LOG.Error("WebException: ", e);
if (statusCode == HttpStatusCode.Unauthorized)
{
throw new UnauthorizedAccessException(e.Message);
}
throw;
}
finally
{
if (response != null)
{
if (isHttpError)
{
LOG.ErrorFormat("HTTP error {0} with content: {1}", response.StatusCode, responseData);
}
response.Close();
}
}
return(responseData);
}
/// <summary>
/// Load a Greenshot surface
/// </summary>
/// <param name="fullPath"></param>
/// <returns></returns>
public static ISurface LoadGreenshotSurface(string fullPath, ISurface returnSurface)
{
if (string.IsNullOrEmpty(fullPath))
{
return(null);
}
Image fileImage = null;
LOG.InfoFormat("Loading image from file {0}", fullPath);
// Fixed lock problem Bug #3431881
using (Stream surfaceFileStream = File.OpenRead(fullPath))
{
// And fixed problem that the bitmap stream is disposed... by Cloning the image
// This also ensures the bitmap is correctly created
// We create a copy of the bitmap, so everything else can be disposed
surfaceFileStream.Position = 0;
using (Image tmpImage = Image.FromStream(surfaceFileStream, true, true))
{
LOG.DebugFormat("Loaded {0} with Size {1}x{2} and PixelFormat {3}", fullPath, tmpImage.Width, tmpImage.Height, tmpImage.PixelFormat);
fileImage = ImageHelper.Clone(tmpImage);
}
// Start at -14 read "GreenshotXX.YY" (XX=Major, YY=Minor)
const int markerSize = 14;
surfaceFileStream.Seek(-markerSize, SeekOrigin.End);
string greenshotMarker;
using (StreamReader streamReader = new StreamReader(surfaceFileStream))
{
greenshotMarker = streamReader.ReadToEnd();
if (greenshotMarker == null || !greenshotMarker.StartsWith("Greenshot"))
{
throw new ArgumentException(string.Format("{0} is not a Greenshot file!", fullPath));
}
LOG.InfoFormat("Greenshot file format: {0}", greenshotMarker);
const int filesizeLocation = 8 + markerSize;
surfaceFileStream.Seek(-filesizeLocation, SeekOrigin.End);
long bytesWritten = 0;
using (BinaryReader reader = new BinaryReader(surfaceFileStream))
{
bytesWritten = reader.ReadInt64();
surfaceFileStream.Seek(-(bytesWritten + filesizeLocation), SeekOrigin.End);
returnSurface.LoadElementsFromStream(surfaceFileStream);
}
}
}
if (fileImage != null)
{
returnSurface.Image = fileImage;
LOG.InfoFormat("Information about file {0}: {1}x{2}-{3} Resolution {4}x{5}", fullPath, fileImage.Width, fileImage.Height, fileImage.PixelFormat, fileImage.HorizontalResolution, fileImage.VerticalResolution);
}
return(returnSurface);
}
/// <summary>
/// Default init
/// </summary>
public static void Init(string configFolder)
{
AssemblyProductAttribute[] assemblyProductAttributes = Assembly.GetEntryAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false) as AssemblyProductAttribute[];
if (assemblyProductAttributes.Length > 0)
{
string productName = assemblyProductAttributes[0].Product;
LOG.InfoFormat("Using ProductName {0}", productName);
Init(productName, "GreenshotImageEditor", configFolder);
}
else
{
throw new InvalidOperationException("Assembly ProductName not set.");
}
}
public override void OnInit()
{
CSVOrders csvOrders = CSVOrders.getInstance();
fixedDollarRiskProfile = new FixedDollarRiskProfile(this, 150, 10);
foreach (var csvOrder in csvOrders)
{
LOG.InfoFormat("{0} on:{1} at:{2} stop:{3} tp1:{4} tp2:{5}",
csvOrder.TradeOperation.ToString(),
csvOrder.Pair,
csvOrder.Entry,
csvOrder.Stop,
csvOrder.TakeProfit1,
csvOrder.TakeProfit2
);
bool tradeExists = false;
for (int i = 0; i < this.OrdersTotal(); i++)
{
if (OrderSelect(i, (int)SELECTION_TYPE.SELECT_BY_POS, (int)SELECTION_POOL.MODE_TRADES) && OrderMagicNumber() == magicnumber && csvOrder.Pair == OrderSymbol())
{
if ((OrderType() == (int)TRADE_OPERATION.OP_SELL || OrderType() == (int)TRADE_OPERATION.OP_SELLLIMIT) &&
csvOrder.TradeOperation == TRADE_OPERATION.OP_SELLLIMIT)
{
tradeExists = true;
break;
}
if ((OrderType() == (int)TRADE_OPERATION.OP_BUY || OrderType() == (int)TRADE_OPERATION.OP_BUYLIMIT) &&
csvOrder.TradeOperation == TRADE_OPERATION.OP_BUYLIMIT)
{
tradeExists = true;
break;
}
}
}
if (!tradeExists)
{
// Place the trade
LOG.InfoFormat("Placing trade on {0}", csvOrder.Pair);
executeTrade(csvOrder, true);
executeTrade(csvOrder, false);
}
}
}
/// <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);
}
/// <summary>
/// Read the ini file into the Dictionary
/// </summary>
/// <param name="iniLocation">Path & Filename of ini file</param>
private static Dictionary <string, Dictionary <string, string> > Read(string iniLocation)
{
if (!File.Exists(iniLocation))
{
LOG.Info("Can't find file: " + iniLocation);
return(null);
}
LOG.InfoFormat("Loading ini-file: {0}", iniLocation);
//LOG.Info("Reading ini-properties from file: " + iniLocation);
Dictionary <string, Dictionary <string, string> > newSections = IniReader.read(iniLocation, Encoding.UTF8);
// Merge the newly loaded properties to the already available
foreach (string section in newSections.Keys)
{
Dictionary <string, string> newProperties = newSections[section];
if (!sections.ContainsKey(section))
{
// This section is not yet loaded, simply add the complete section
sections.Add(section, newProperties);
}
else
{
// Overwrite or add every property from the newly loaded section to the available one
Dictionary <string, string> currentProperties = sections[section];
foreach (string propertyName in newProperties.Keys)
{
string propertyValue = newProperties[propertyName];
if (currentProperties.ContainsKey(propertyName))
{
// Override current value as we are loading in a certain order which insures the default, current and fixed
currentProperties[propertyName] = propertyValue;
}
else
{
// Add "new" value
currentProperties.Add(propertyName, propertyValue);
}
}
}
}
return(newSections);
}
/// <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);
}
/// <summary>
/// Dump the Type-Information for the Type to the log, this uses reflection
/// </summary>
/// <param name="type">Type to inspect</param>
public static void DumpTypeInfo(Type type)
{
LOG.InfoFormat("Type information for Type with name: {0}", type.Name);
try
{
foreach (MemberInfo memberInfo in type.GetMembers())
{
LOG.InfoFormat("Member: {0};", memberInfo.ToString());
}
}
catch (Exception memberException)
{
LOG.Error(memberException);
}
try
{
foreach (PropertyInfo propertyInfo in type.GetProperties())
{
LOG.InfoFormat("Property: {0};", propertyInfo.ToString());
}
}
catch (Exception propertyException)
{
LOG.Error(propertyException);
}
try
{
foreach (FieldInfo fieldInfo in type.GetFields())
{
LOG.InfoFormat("Field: {0};", fieldInfo.ToString());
}
}
catch (Exception fieldException)
{
LOG.Error(fieldException);
}
LOG.InfoFormat("Type information end.");
}
/// <summary>
/// Get all images (multiple if filenames are available) from the dataObject
/// Returned images must be disposed by the calling code!
/// </summary>
/// <param name="dataObject"></param>
/// <returns>IEnumerable<Image></returns>
public static IEnumerable <Image> GetImages(IDataObject dataObject)
{
// Get single image, this takes the "best" match
Image singleImage = GetImage(dataObject);
if (singleImage != null)
{
LOG.InfoFormat("Got image from clipboard with size {0} and format {1}", singleImage.Size, singleImage.PixelFormat);
yield return(singleImage);
}
else
{
// check if files are supplied
List <string> imageFiles = GetImageFilenames(dataObject);
if (imageFiles != null)
{
foreach (string imageFile in imageFiles)
{
Image returnImage = null;
try
{
returnImage = ImageHelper.LoadImage(imageFile);
}
catch (Exception streamImageEx)
{
LOG.Error("Problem retrieving Image from clipboard.", streamImageEx);
}
if (returnImage != null)
{
LOG.InfoFormat("Got image from clipboard with size {0} and format {1}", returnImage.Size, returnImage.PixelFormat);
yield return(returnImage);
}
}
}
}
}
/// <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));
}
/// <summary>
/// the DIB readed should solve the issue reported here: https://sourceforge.net/projects/greenshot/forums/forum/676083/topic/6354353/index/page/1
/// </summary>
/// <returns>Image</returns>
private static Image GetDIBImage(IDataObject dataObejct)
{
try
{
// If the EnableSpecialDIBClipboardReader flag in the config is set, use the code from:
// http://www.thomaslevesque.com/2009/02/05/wpf-paste-an-image-from-the-clipboard/
// to read the DeviceIndependentBitmap from the clipboard, this might fix bug 3576125
if (config.EnableSpecialDIBClipboardReader)
{
MemoryStream dibStream = GetFromDataObject(dataObejct, DataFormats.Dib) as MemoryStream;
if (isValidStream(dibStream))
{
LOG.Info("Found valid DIB stream, trying to process it.");
byte[] dibBuffer = new byte[dibStream.Length];
dibStream.Read(dibBuffer, 0, dibBuffer.Length);
BitmapInfoHeader infoHeader = BinaryStructHelper.FromByteArray <BitmapInfoHeader>(dibBuffer);
// Only use this code, when the biCommpression != 0 (BI_RGB)
if (infoHeader.biCompression != 0)
{
LOG.InfoFormat("Using special DIB format reader for biCompression {0}", infoHeader.biCompression);
int fileHeaderSize = Marshal.SizeOf(typeof(BitmapFileHeader));
uint infoHeaderSize = infoHeader.biSize;
int fileSize = (int)(fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage);
BitmapFileHeader fileHeader = new BitmapFileHeader();
fileHeader.bfType = BitmapFileHeader.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = (int)(fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4);
byte[] fileHeaderBytes = BinaryStructHelper.ToByteArray <BitmapFileHeader>(fileHeader);
using (MemoryStream bitmapStream = new MemoryStream())
{
bitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
bitmapStream.Write(dibBuffer, 0, dibBuffer.Length);
bitmapStream.Seek(0, SeekOrigin.Begin);
using (Image tmpImage = Image.FromStream(bitmapStream))
{
if (tmpImage != null)
{
return(ImageHelper.Clone(tmpImage));
}
}
}
}
else
{
LOG.InfoFormat("Skipping special DIB format reader for biCompression {0}", infoHeader.biCompression);
}
}
}
else
{
LOG.Info("Skipping special DIB format reader as it's disabled in the configuration.");
}
}
catch (Exception dibEx)
{
LOG.Error("Problem retrieving DIB from clipboard.", dibEx);
}
return(null);
}
/// <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>
/// Helper method to try to get an image in the specified format from the dataObject
/// the DIB readed should solve the issue reported here: https://sourceforge.net/projects/greenshot/forums/forum/676083/topic/6354353/index/page/1
/// It also supports Format17/DibV5, by using the following information: http://stackoverflow.com/a/14335591
/// </summary>
/// <param name="format">string with the format</param>
/// <param name="dataObject">IDataObject</param>
/// <returns>Image or null</returns>
private static Image GetImageForFormat(string format, IDataObject dataObject)
{
object clipboardObject = GetFromDataObject(dataObject, format);
MemoryStream imageStream = clipboardObject as MemoryStream;
if (!isValidStream(imageStream))
{
// TODO: add "HTML Format" support here...
return(clipboardObject as Image);
}
else
{
if (config.EnableSpecialDIBClipboardReader)
{
if (format == FORMAT_17 || format == DataFormats.Dib)
{
LOG.Info("Found DIB stream, trying to process it.");
try
{
byte[] dibBuffer = new byte[imageStream.Length];
imageStream.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader = BinaryStructHelper.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
if (!infoHeader.IsDibV5)
{
LOG.InfoFormat("Using special DIB <v5 format reader with biCompression {0}", infoHeader.biCompression);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
uint infoHeaderSize = infoHeader.biSize;
int fileSize = (int)(fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage);
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = (int)(fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4);
byte[] fileHeaderBytes = BinaryStructHelper.ToByteArray <BITMAPFILEHEADER>(fileHeader);
using (MemoryStream bitmapStream = new MemoryStream())
{
bitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
bitmapStream.Write(dibBuffer, 0, dibBuffer.Length);
bitmapStream.Seek(0, SeekOrigin.Begin);
using (Image tmpImage = Image.FromStream(bitmapStream))
{
if (tmpImage != null)
{
return(ImageHelper.Clone(tmpImage));
}
}
}
}
else
{
LOG.Info("Using special DIBV5 / Format17 format reader");
// CF_DIBV5
IntPtr gcHandle = IntPtr.Zero;
try
{
GCHandle handle = GCHandle.Alloc(dibBuffer, GCHandleType.Pinned);
gcHandle = GCHandle.ToIntPtr(handle);
return(new Bitmap(infoHeader.biWidth, infoHeader.biHeight, -(int)(infoHeader.biSizeImage / infoHeader.biHeight),
infoHeader.biBitCount == 32 ? PixelFormat.Format32bppArgb : PixelFormat.Format24bppRgb,
new IntPtr(handle.AddrOfPinnedObject().ToInt32() + infoHeader.OffsetToPixels + (infoHeader.biHeight - 1) * (int)(infoHeader.biSizeImage / infoHeader.biHeight))));
}
catch (Exception ex)
{
LOG.Error("Problem retrieving Format17 from clipboard.", ex);
}
finally
{
if (gcHandle == IntPtr.Zero)
{
GCHandle.FromIntPtr(gcHandle).Free();
}
}
}
}
catch (Exception dibEx)
{
LOG.Error("Problem retrieving DIB from clipboard.", dibEx);
}
}
}
else
{
LOG.Info("Skipping special DIB format reader as it's disabled in the configuration.");
}
try
{
imageStream.Seek(0, SeekOrigin.Begin);
using (Image tmpImage = Image.FromStream(imageStream, true, true))
{
if (tmpImage != null)
{
LOG.InfoFormat("Got image with clipboard format {0} from the clipboard.", format);
return(ImageHelper.Clone(tmpImage));
}
}
}
catch (Exception streamImageEx)
{
LOG.Error(string.Format("Problem retrieving {0} from clipboard.", format), streamImageEx);
}
}
return(null);
}
/// <summary>
/// Scan the files in all directories
/// </summary>
private static void ScanFiles()
{
languageFiles.Clear();
helpFiles.Clear();
foreach (string languagePath in languagePaths)
{
if (!Directory.Exists(languagePath))
{
LOG.InfoFormat("Skipping non existing language path {0}", languagePath);
continue;
}
LOG.InfoFormat("Searching language directory '{0}' for language files with pattern '{1}'", languagePath, LANGUAGE_FILENAME_PATTERN);
try
{
foreach (string languageFilepath in Directory.GetFiles(languagePath, LANGUAGE_FILENAME_PATTERN, SearchOption.AllDirectories))
{
//LOG.DebugFormat("Found language file: {0}", languageFilepath);
LanguageFile languageFile = LoadFileInfo(languageFilepath);
if (languageFile == null)
{
continue;
}
if (string.IsNullOrEmpty(languageFile.Ietf))
{
LOG.WarnFormat("Fixing missing ietf in language-file {0}", languageFilepath);
string languageFilename = Path.GetFileName(languageFilepath);
if (IETF_REGEXP.IsMatch(languageFilename))
{
string replacementIETF = IETF_REGEXP.Replace(languageFilename, "$1");
languageFile.Ietf = ReformatIETF(replacementIETF);
LOG.InfoFormat("Fixed IETF to {0}", languageFile.Ietf);
}
else
{
LOG.ErrorFormat("Missing ietf , no recover possible... skipping language-file {0}!", languageFilepath);
continue;
}
}
// Check if we can display the file
if (!string.IsNullOrEmpty(languageFile.LanguageGroup) && unsupportedLanguageGroups.Contains(languageFile.LanguageGroup))
{
LOG.InfoFormat("Skipping unsuported (not able to display) language {0} from file {1}", languageFile.Description, languageFilepath);
continue;
}
// build prefix, based on the filename, but only if it's not set in the file itself.
if (string.IsNullOrEmpty(languageFile.Prefix))
{
string languageFilename = Path.GetFileNameWithoutExtension(languageFilepath);
if (PREFIX_REGEXP.IsMatch(languageFilename))
{
languageFile.Prefix = PREFIX_REGEXP.Replace(languageFilename, "$1");
if (!string.IsNullOrEmpty(languageFile.Prefix))
{
languageFile.Prefix = languageFile.Prefix.Replace("plugin", "").ToLower();
}
}
}
List <LanguageFile> currentFiles = null;
if (languageFiles.ContainsKey(languageFile.Ietf))
{
currentFiles = languageFiles[languageFile.Ietf];
bool needToAdd = true;
List <LanguageFile> deleteList = new List <LanguageFile>();
foreach (LanguageFile compareWithLangfile in currentFiles)
{
if ((languageFile.Prefix == null && compareWithLangfile.Prefix == null) || (languageFile.Prefix != null && languageFile.Prefix.Equals(compareWithLangfile.Prefix)))
{
if (compareWithLangfile.Version > languageFile.Version)
{
LOG.WarnFormat("Skipping {0}:{1}:{2} as {3}:{4}:{5} is newer", languageFile.Filepath, languageFile.Prefix, languageFile.Version, compareWithLangfile.Filepath, compareWithLangfile.Prefix, compareWithLangfile.Version);
needToAdd = false;
break;
}
else
{
LOG.WarnFormat("Found {0}:{1}:{2} and deleting {3}:{4}:{5}", languageFile.Filepath, languageFile.Prefix, languageFile.Version, compareWithLangfile.Filepath, compareWithLangfile.Prefix, compareWithLangfile.Version);
deleteList.Add(compareWithLangfile);
}
}
}
if (needToAdd)
{
foreach (LanguageFile deleteFile in deleteList)
{
currentFiles.Remove(deleteFile);
}
LOG.InfoFormat("Added language {0} from: {1}", languageFile.Description, languageFile.Filepath);
currentFiles.Add(languageFile);
}
}
else
{
currentFiles = new List <LanguageFile>();
currentFiles.Add(languageFile);
languageFiles.Add(languageFile.Ietf, currentFiles);
LOG.InfoFormat("Added language {0} from: {1}", languageFile.Description, languageFile.Filepath);
}
}
}
catch (DirectoryNotFoundException)
{
LOG.InfoFormat("Non existing language directory: {0}", languagePath);
}
catch (Exception e)
{
LOG.Error("Error trying for read directory " + languagePath, e);
}
// Now find the help files
LOG.InfoFormat("Searching language directory '{0}' for help files with pattern '{1}'", languagePath, HELP_FILENAME_PATTERN);
try
{
foreach (string helpFilepath in Directory.GetFiles(languagePath, HELP_FILENAME_PATTERN, SearchOption.AllDirectories))
{
LOG.DebugFormat("Found help file: {0}", helpFilepath);
string helpFilename = Path.GetFileName(helpFilepath);
string ietf = ReformatIETF(helpFilename.Replace(".html", "").Replace("help-", ""));
if (!helpFiles.ContainsKey(ietf))
{
helpFiles.Add(ietf, helpFilepath);
}
else
{
LOG.WarnFormat("skipping help file {0}, already a file with the same IETF {1} found!", helpFilepath, ietf);
}
}
}
catch (DirectoryNotFoundException)
{
LOG.InfoFormat("Non existing language directory: {0}", languagePath);
}
catch (Exception e)
{
LOG.Error("Error trying for read directory " + languagePath, e);
}
}
}
/// <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);
}
}
/// <summary>
/// Create an image from a surface with the settings from the output settings applied
/// </summary>
/// <param name="surface"></param>
/// <param name="outputSettings"></param>
/// <param name="imageToSave"></param>
/// <returns>true if the image must be disposed</returns>
public static bool CreateImageFromSurface(ISurface surface, SurfaceOutputSettings outputSettings, out Image imageToSave)
{
bool disposeImage = false;
ImageFormat imageFormat = null;
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:
imageFormat = ImageFormat.Png;
break;
}
if (outputSettings.Format == OutputFormat.greenshot || outputSettings.SaveBackgroundOnly)
{
// We save the image of the surface, this should not be disposed
imageToSave = surface.Image;
}
else
{
// We create the export image of the surface to save
imageToSave = surface.GetImageForExport();
disposeImage = true;
}
// The following block of modifications should be skipped when saving the greenshot format, no effects or otherwise!
if (outputSettings.Format != OutputFormat.greenshot)
{
Image tmpImage;
if (outputSettings.Effects != null && outputSettings.Effects.Count > 0)
{
// apply effects, if there are any
Point ignoreOffset;
tmpImage = ImageHelper.ApplyEffects((Bitmap)imageToSave, outputSettings.Effects, out ignoreOffset);
if (tmpImage != null)
{
if (disposeImage)
{
imageToSave.Dispose();
}
imageToSave = tmpImage;
disposeImage = true;
}
}
// check for color reduction, forced or automatically, only when the DisableReduceColors is false
if (!outputSettings.DisableReduceColors && (conf.OutputFileAutoReduceColors || outputSettings.ReduceColors))
{
bool isAlpha = Image.IsAlphaPixelFormat(imageToSave.PixelFormat);
if (outputSettings.ReduceColors || (!isAlpha && conf.OutputFileAutoReduceColors))
{
using (WuQuantizer quantizer = new WuQuantizer((Bitmap)imageToSave))
{
int colorCount = quantizer.GetColorCount();
LOG.InfoFormat("Image with format {0} has {1} colors", imageToSave.PixelFormat, colorCount);
if (outputSettings.ReduceColors || colorCount < 256)
{
try
{
LOG.Info("Reducing colors on bitmap to 256.");
tmpImage = quantizer.GetQuantizedImage(256);
if (disposeImage)
{
imageToSave.Dispose();
}
imageToSave = tmpImage;
// Make sure the "new" image is disposed
disposeImage = true;
}
catch (Exception e)
{
LOG.Warn("Error occurred while Quantizing the image, ignoring and using original. Error: ", e);
}
}
}
}
else if (isAlpha && !outputSettings.ReduceColors)
{
LOG.Info("Skipping 'optional' color reduction as the image has alpha");
}
}
}
return(disposeImage);
}