public BatchConvertXlsToAccess(ConvertMode mode)
{
InitializeComponent();
checkBox1.Checked += new RoutedEventHandler(checkBox1_Checked);
CurConvertMode = mode;
InitSelf();
}
/// <summary>
/// 将整型变量转化为布尔变量(True或False).
/// 规则：如果整型数值大于0,返回True,否则返回False.
/// </summary>
/// <param name="intParam">The int param.</param>
/// <param name="mode">严格模式：只能转换0或1；宽松模式：大于0,返回True,否则返回False.</param>
/// <returns></returns>
public static bool IntToBoolean(int intParam, ConvertMode mode)
{
switch (mode)
{
case ConvertMode.Strict:
{
switch (intParam)
{
case 0:
return(false);
case 1:
return(true);
}
throw new ArgumentOutOfRangeException(string.Format(ArgumentValidationString.ValueMustIs0or1, "intParam"));
}
case ConvertMode.Relaxed:
return(IntToBoolean(intParam));
default:
Debug.Fail(mode.ToString());
return(false);
}
}
public ToolConverterForm()
{
InitializeComponent();
_mode = ConvertMode.HexToAscii;
gbInput.Text = _hexIn;
gbOutput.Text = _textOut;
}
protected virtual void OnRadiobuttonSendActivated(object sender, System.EventArgs e)
{
if (radiobuttonText.Active)
{
NowSendMode = ConvertMode.Text;
}
else if (radiobuttonHex.Active)
{
NowSendMode = ConvertMode.Hex;
}
else if (radiobuttonDec.Active)
{
NowSendMode = ConvertMode.Dec;
}
if (NowSendMode != SendMode)
{
string strSend = textviewSend.Buffer.Text;
byte[] sendByte;
switch (SendMode)
{
case ConvertMode.Text:
sendByte = new byte[StringConverts.StringToBytes(strSend).Length];
sendByte = StringConverts.StringToBytes(strSend);
break;
case ConvertMode.Hex:
sendByte = new byte[StringConverts.HexStringToBytes(strSend).Length];
sendByte = StringConverts.HexStringToBytes(strSend);
break;
case ConvertMode.Dec:
sendByte = new byte[StringConverts.DecStringToBytes(strSend).Length];
sendByte = StringConverts.DecStringToBytes(strSend);
break;
default:
sendByte = new byte[StringConverts.StringToBytes(strSend).Length];
sendByte = StringConverts.StringToBytes(strSend);
break;
}
switch (NowSendMode)
{
case ConvertMode.Text:
strSend = StringConverts.BytesToString(sendByte);
break;
case ConvertMode.Hex:
strSend = StringConverts.BytesToHexString(sendByte);
break;
case ConvertMode.Dec:
strSend = StringConverts.BytesToDecString(sendByte);
break;
}
textviewSend.Buffer.Text = strSend;
SendMode = NowSendMode;
}
}
public static async Task <byte[]> ConvertDocument(byte[] documentData, ConvertMode type)
{
var tempFile = GetTempFile("docx");
File.WriteAllBytes(tempFile, documentData);
var result = await ConvertDocument(tempFile, type);
DeleteTempFiles(tempFile);
return(result);
}
public static string ConvertProperty(string inputPath, string outputPath, ConvertMode mode)
{
string extraArg = mode != ConvertMode.Unknown ? (mode == ConvertMode.Import ? "--i" : "--e") : "";
Run(convertProperty, "\"" + inputPath + "\" \"" + outputPath + "\" " + extraArg);
if (File.Exists(outputPath))
{
return(outputPath);
}
return(null);
}
void checkBox1_Checked(object sender, RoutedEventArgs e)
{
if ((bool)checkBox1.IsChecked)
{
CurConvertMode = ConvertMode.Folder;
}
else
{
CurConvertMode = ConvertMode.SingleFile;
}
InitSelf();
}
private void btnSwap_Click(object sender, EventArgs e)
{
if (_mode == ConvertMode.AsciiToHex)
{
_mode = ConvertMode.HexToAscii;
gbInput.Text = _hexIn;
gbOutput.Text = _textOut;
}
else
{
_mode = ConvertMode.AsciiToHex;
gbInput.Text = _textIn;
gbOutput.Text = _hexOut;
}
}
public BuilderOptions(
string name,
string outputPath,
string preFix = "",
string suffix = "",
ConvertMode mode = ConvertMode.None,
BuilderType type = BuilderType.Builder
)
{
Name = name;
OutPutPath = outputPath;
Prefix = preFix;
Suffix = suffix;
Mode = mode;
Type = type;
}
private void rbtn_CheckedChanged(object sender, EventArgs e)
{
switch ((sender as RadioButton).Name)
{
case "rbtnByte":
Mode = ConvertMode.Byte;
break;
case "rbtnInt16":
Mode = ConvertMode.Int16;
break;
case "rbtnInt32":
Mode = ConvertMode.Int32;
break;
case "rbtnInt64":
Mode = ConvertMode.Int64;
break;
case "rbtnString":
Mode = ConvertMode.String;
break;
default:
break;
}
if (LastSender != null)
{
switch (LastSender.Name)
{
case "rtbxHex":
rtbxHex_KeyUp(LastSender, null);
break;
case "rtbxPlain":
rtbxPlain_KeyUp(LastSender, null);
break;
default:
break;
}
}
}
/// <summary>
/// 将char转化为布尔变量(True或False).
/// </summary>
/// <param name="charParam">char值</param>
/// <param name="mode">选择是否严格转换模式，当宽松模式下，非0或1的char都将返回false</param>
/// <returns>如果char是0,返回False；如果char是1,返回True</returns>
public static bool CharToBoolean(char charParam, ConvertMode mode)
{
switch (charParam)
{
case '1':
return(true);
case '0':
return(false);
default:
if (mode == ConvertMode.Relaxed)
{
return(false);
}
throw new ArgumentException(charParam + " , 参数应严格是1或0.");
}
}
private async Task <byte[]> ConvertWithSelectedMode(ConvertMode convertMode, byte[] loadImageByteArr)
{
ManagedClass mc = new ManagedClass();
if (convertMode == ConvertMode.Normally)
{
ToMainColors(loadImageByteArr);
}
if (convertMode == ConvertMode.Asynchronously)
{
await ToMainColorsAsync(loadImageByteArr);
}
if (convertMode == ConvertMode.UsingCpp)
{
mc.ToMainColorsCPP(loadImageByteArr);
}
return(loadImageByteArr);
}
void ConvertImages(ConvertMode convertMode, ThresholdImageType type, string SavePath)
{
for (int imagePosition = 0; imagePosition < fileName.Length; imagePosition++)
{
ThreadHelperClass.SetImage(this, imgPreviewImage, this.image[imagePosition].Bitmap);
ThreadHelperClass.SetText(this, lblPreviewImagePosition, "Image " + (imagePosition + 1) + " of " + this.image.Length);
Mat image = new Mat(this.image[imagePosition].Rows, this.image[imagePosition].Cols, DepthType.Cv8U, 1);
CvInvoke.CvtColor(this.image[imagePosition], image, ColorConversion.Bgr2Gray);
Mat resultImage = new Mat(image.Rows, image.Cols, Emgu.CV.CvEnum.DepthType.Cv8U, 1);
if (convertMode == ConvertMode.Automatic)
{
if (type == ThresholdImageType.Normal)
{
CvInvoke.AdaptiveThreshold(image, resultImage, 255, Emgu.CV.CvEnum.AdaptiveThresholdType.GaussianC, Emgu.CV.CvEnum.ThresholdType.Binary, 75, 25);
}
else
{
CvInvoke.AdaptiveThreshold(image, resultImage, 255, Emgu.CV.CvEnum.AdaptiveThresholdType.GaussianC, Emgu.CV.CvEnum.ThresholdType.BinaryInv, 75, 25);
}
}
else
{
if (type == ThresholdImageType.Normal)
{
resultImage = new Image <Bgra, byte>(ImageProcessor.ImageProcessor.RecolorMonochrome(image.Bitmap, threshold)).Mat;
}
else
{
resultImage = new Image <Bgra, byte>(ImageProcessor.ImageProcessor.RecolorMonochromeInverted(image.Bitmap, threshold)).Mat;
}
}
ThreadHelperClass.SetImage(this, imgResultImage, resultImage.Bitmap);
resultImage.Bitmap.Save(SavePath + "\\" + Path.GetFileName(fileName[imagePosition]));
image.Dispose();
resultImage.Dispose();
}
}
public DelimiterConverter(IDictionary <String, String> paramters)
{
if (paramters == null)
{
return;
}
if (!paramters.Value(DELIMITER, out _delimiter))
{
_delimiter = "_";
}
if (!paramters.Value(CONVERT_MODE, out _convertMode))
{
_convertMode = ConvertMode.None;
}
if (!paramters.Value(PREFIX, out _prefix))
{
_prefix = string.Empty;
}
}
public async Task <byte[]> Convert(Stream file, ConvertMode type)
{
byte[] result = null;
await Task.Run(() =>
{
try
{
var ms = new MemoryStream();
var doc = new Document(file);
var fileFormat = FileFormat.Auto;
switch (type)
{
case ConvertMode.Xml:
fileFormat = FileFormat.Xml;
break;
case ConvertMode.Html:
fileFormat = FileFormat.Html;
break;
case ConvertMode.Pdf:
fileFormat = FileFormat.PDF;
break;
case ConvertMode.Xps:
fileFormat = FileFormat.XPS;
break;
}
doc.SaveToStream(ms, fileFormat);
result = ms.GetBuffer();
}
finally
{
}
});
return(result);
}
public void Initialize(IDictionary<string, object> paramters)
{
if (paramters != null)
{
if (!paramters.Value(DELIMITER, out _delimiter))
{
_delimiter = "_";
}
if (!paramters.Value(CONVERT_MODE, out _convertMode))
{
_convertMode = ConvertMode.None;
}
if (!paramters.Value(PREFIX, out _prefix))
{
_prefix = string.Empty;
}
}
Initialized = true;
}
//здесь реализована логика алгоритма
//Сжатие:
//первая строка в нужном формате опорная, относительно нее все считается и она просто переписывается как есть
//затем берется две соседних строки, если текущая строка больше или равна предыдущей, берется разность дат и времени работы
//и записывается в новую строку, если же нет, то текущая строка считается опорной,
//строки которые не подходят под формат лога, просто переписываются как есть
//Разжатие:
//В целом аналогично сжатию, но в обратную сторону, из двух строк одна уже была переведена в исходное состояние или она опорная
//к ней прибавляется разница дат и времени работы записанная в следующей строке
public static void Convert(Stream source, Stream target, ConvertMode mode)
{
Log previous = null;
var isFirstLine = true;
foreach (var line in Splitter.ReadLines(source))
{
if (isFirstLine)
{
if (Log.TryParse(line, out var current))
{
Connector.Write(target, current.ToBytes());
previous = current;
isFirstLine = false;
}
else
{
Connector.Write(target, line);
}
}
else
{
if (mode == ConvertMode.Convert)
{
Convert(line);
}
else
{
Deconvert(line);
}
}
}
Connector.Write(target, new byte[0]);
void Convert(byte[] line)
{
if (Log.TryParse(line, out var current))
{
if ((current.DateTime >= previous.DateTime) && (current.RunTime >= previous.RunTime))
{
var currentCompressed = new CompressedLog((current.DateTime - previous.DateTime).TotalMilliseconds,
(current.RunTime - previous.RunTime),
current.Message);
Connector.Write(target, currentCompressed.ToBytes());
}
else
{
Connector.Write(target, current.ToBytes());
}
previous = current;
}
else
{
Connector.Write(target, line);
}
}
void Deconvert(byte[] line)
{
if (CompressedLog.TryParse(line, out var currentCompressed))
{
var currentUncompressed = new Log(previous.DateTime.AddMilliseconds(currentCompressed.DeltaDateTime),
previous.RunTime + currentCompressed.DeltaRunTime,
currentCompressed.Message);
Connector.Write(target, currentUncompressed.ToBytes());
previous = currentUncompressed;
}
else
{
if (Log.TryParse(line, out var current))
{
previous = current;
}
Connector.Write(target, line);
}
}
}
private void processScrollEvent(ConvertMode convertMode, Boolean isSend)
{
// String textviewString = null;
Gtk.ScrolledWindow scrolledWindow = null;
Gtk.TextView textView = null;
ScrolledTextViewMover mover = null;
// int offset = 0;
if (isSend)
{
switch (convertMode)
{
case ConvertMode.Text:
scrolledWindow = GtkScrolledWindowTextS;
textView = textviewTextS;
mover = moverTextS;
break;
case ConvertMode.Hex:
scrolledWindow = GtkScrolledWindowHexS;
textView = textviewHexS;
mover = moverHexS;
break;
case ConvertMode.Dec:
scrolledWindow = GtkScrolledWindowDecS;
textView = textviewDecS;
mover = moverDecS;
break;
}
}
else
{
switch (convertMode)
{
case ConvertMode.Text:
scrolledWindow = GtkScrolledWindowText;
textView = textviewText;
// offset = textviewTextOffset;
// textviewString = textviewTextString;
mover = moverText;
break;
case ConvertMode.Hex:
scrolledWindow = GtkScrolledWindowHex;
textView = textviewHex;
// offset = textviewHexOffset;
// textviewString = textviewHexString;
mover = moverHex;
break;
case ConvertMode.Dec:
scrolledWindow = GtkScrolledWindowDec;
textView = textviewDec;
// offset = textviewDecOffset;
// textviewString = textviewDecString;
mover = moverDec;
break;
}
}
double vadjustmentLower = scrolledWindow.Vadjustment.Lower;
double vadjustmentUpper = scrolledWindow.Vadjustment.Upper;
double vadjustmentValue = scrolledWindow.Vadjustment.Value;
double vadjustmentPageSize = scrolledWindow.Vadjustment.PageSize;
double vadjustmentPosition = (vadjustmentValue - vadjustmentLower) / (vadjustmentUpper - vadjustmentPageSize - vadjustmentLower);
//Console.WriteLine ("VADJ:" + vadjustmentPosition);
// if (textviewString.Length < 3 * textViewDataBytesMaxCount) {
// int forwardBytes = textviewString.Length - offset;
// if (forwardBytes > 0) {
// TextIter iter = textView.Buffer.EndIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offset, forwardBytes));
// offset += forwardBytes;
// // if (textviewText.Buffer.CharCount > 2 * textViewDataBytesMaxCount) {
// // TextIter iterStart = textviewText.Buffer.StartIter;
// // TextIter iterEnd = textviewText.Buffer.StartIter;
// // if (iterEnd.ForwardChars (textviewText.Buffer.CharCount - textViewDataBytesMaxCount)) {
// // textviewText.Buffer.Delete (ref iterStart, ref iterEnd);
// // textviewTextOffset += textviewText.Buffer.CharCount - textViewDataBytesMaxCount;
// // }
// // }
// }
//
// } else {
// if (vadjustmentPosition > 0.9) {
// Console.WriteLine ("Count:" + textView.Buffer.CharCount.ToString ());
// int forwardBytes = textviewString.Length - offset;
// if (forwardBytes > textViewDataBytesMaxCount) {
// forwardBytes = textViewDataBytesMaxCount;
// }
// if (forwardBytes > 0) {
// TextIter iter = textView.Buffer.EndIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offset, forwardBytes));
// offset += forwardBytes;
// int deleteBytes = textView.Buffer.CharCount - 3 * textViewDataBytesMaxCount;
//
// if (deleteBytes > 0) {
// Console.WriteLine ("Delete:" + deleteBytes.ToString ());
// TextIter iterStart = textView.Buffer.StartIter;
// TextIter iterEnd = textView.Buffer.StartIter;
// if (iterEnd.ForwardChars (deleteBytes)) {
// textView.Buffer.Delete (ref iterStart, ref iterEnd);
// }
// }
// }
// }
// if (vadjustmentPosition < 0.1) {
// Console.WriteLine ("Delete:" + textView.Buffer.CharCount.ToString ());
// if (offset >= textViewDataBytesMaxCount * 3) {
// int offsetEnd = offset - textViewDataBytesMaxCount * 3;
// int offsetStart = offsetEnd - textViewDataBytesMaxCount;
// if (offsetStart < 0) {
// offsetStart = 0;
// }
// int backwardBytes = offsetEnd - offsetStart;
// if (backwardBytes > 0) {
// TextIter iter = textView.Buffer.StartIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offsetStart, backwardBytes));
// offset -= backwardBytes;
// }
// }
// }
// }
// if (isSend) {
// switch (convertMode) {
// case ConvertMode.Text:
// break;
// case ConvertMode.Hex:
// break;
// case ConvertMode.Dec:
// break;
// }
// } else {
// switch (convertMode) {
// case ConvertMode.Text:
// break;
// case ConvertMode.Hex:
// //textviewHexOffset = offset;
// break;
// case ConvertMode.Dec:
// //textviewDecOffset = offset;
// break;
// }
// }
bool isAutoScroll = false;
if (isSend)
{
isAutoScroll = checkbuttonAutoScrollSend.Active;
}
else
{
isAutoScroll = checkbuttonAutoScrollReceive.Active;
}
if (isAutoScroll)
{
if (scrolledWindow.VScrollbar.Visible == false || vadjustmentPosition > 0.98)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 10;
mover.MoveDown();
TextIter iter = textView.Buffer.EndIter;
textView.Buffer.CreateMark("EndMark", iter, false);
textView.ScrollToMark(textView.Buffer.CreateMark("EndMark", iter, false), 0, false, 0, 0);
textView.Buffer.DeleteMark("EndMark");
}
}
else
if (vadjustmentPosition < 0.02)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 10;
mover.MoveUp();
TextIter iter = textView.Buffer.StartIter;
textView.Buffer.CreateMark("StartMark", iter, false);
textView.ScrollToMark(textView.Buffer.CreateMark("StartMark", iter, false), 0, false, 0, 0);
textView.Buffer.DeleteMark("StartMark");
}
}
else
if (vadjustmentPosition > 0.7)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 100;
mover.MoveDown();
TextIter iter = textView.Buffer.EndIter;
}
}
else
if (vadjustmentPosition < 0.3)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 100;
mover.MoveUp();
TextIter iter = textView.Buffer.StartIter;
}
}
else
if (vadjustmentPosition > 0.55)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 300;
mover.MoveDown();
TextIter iter = textView.Buffer.EndIter;
}
}
else
if (vadjustmentPosition < 0.45)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 300;
mover.MoveUp();
TextIter iter = textView.Buffer.StartIter;
}
}
}
else
{
if (vadjustmentPosition > 0.9)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 100;
mover.MoveDown();
}
}
else
if (vadjustmentPosition < 0.1)
{
if (mover != null)
{
mover.StepSize = mover.WindowSize / 100;
mover.MoveUp();
}
}
}
}
public async Task <WriteableBitmap> CreateNewConvertedImage(BitmapImage loadImage, ConvertMode convertMode)
{
int height = loadImage.PixelHeight;
int width = loadImage.PixelWidth;
int nStride = loadImage.PixelWidth * 4;
byte[] loadImageByteArr;
WriteableBitmap writeImg;
Int32Rect rect;
var dpix = loadImage.DpiX;
var dpiy = loadImage.DpiY;
loadImageByteArr = ConvertImageToByteArray(loadImage);
loadImageByteArr = await ConvertWithSelectedMode(convertMode, loadImageByteArr);
writeImg = CreateNewEmptyImage(width, height, out rect, dpix, dpiy);
writeImg.WritePixels(rect, loadImageByteArr, nStride, 0);
return(writeImg);
}
private void processScrollEvent(ConvertMode convertMode, Boolean isSend)
{
// String textviewString = null;
Gtk.ScrolledWindow scrolledWindow = null;
Gtk.TextView textView = null;
ScrolledTextViewMover mover = null;
// int offset = 0;
if (isSend) {
switch (convertMode) {
case ConvertMode.Text:
scrolledWindow = GtkScrolledWindowTextS;
textView = textviewTextS;
mover = moverTextS;
break;
case ConvertMode.Hex:
scrolledWindow = GtkScrolledWindowHexS;
textView = textviewHexS;
mover = moverHexS;
break;
case ConvertMode.Dec:
scrolledWindow = GtkScrolledWindowDecS;
textView = textviewDecS;
mover = moverDecS;
break;
}
} else {
switch (convertMode) {
case ConvertMode.Text:
scrolledWindow = GtkScrolledWindowText;
textView = textviewText;
// offset = textviewTextOffset;
// textviewString = textviewTextString;
mover = moverText;
break;
case ConvertMode.Hex:
scrolledWindow = GtkScrolledWindowHex;
textView = textviewHex;
// offset = textviewHexOffset;
// textviewString = textviewHexString;
mover = moverHex;
break;
case ConvertMode.Dec:
scrolledWindow = GtkScrolledWindowDec;
textView = textviewDec;
// offset = textviewDecOffset;
// textviewString = textviewDecString;
mover = moverDec;
break;
}
}
double vadjustmentLower = scrolledWindow.Vadjustment.Lower;
double vadjustmentUpper = scrolledWindow.Vadjustment.Upper;
double vadjustmentValue = scrolledWindow.Vadjustment.Value;
double vadjustmentPageSize = scrolledWindow.Vadjustment.PageSize;
double vadjustmentPosition = (vadjustmentValue - vadjustmentLower) / (vadjustmentUpper - vadjustmentPageSize - vadjustmentLower);
//Console.WriteLine ("VADJ:" + vadjustmentPosition);
// if (textviewString.Length < 3 * textViewDataBytesMaxCount) {
// int forwardBytes = textviewString.Length - offset;
// if (forwardBytes > 0) {
// TextIter iter = textView.Buffer.EndIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offset, forwardBytes));
// offset += forwardBytes;
// // if (textviewText.Buffer.CharCount > 2 * textViewDataBytesMaxCount) {
// // TextIter iterStart = textviewText.Buffer.StartIter;
// // TextIter iterEnd = textviewText.Buffer.StartIter;
// // if (iterEnd.ForwardChars (textviewText.Buffer.CharCount - textViewDataBytesMaxCount)) {
// // textviewText.Buffer.Delete (ref iterStart, ref iterEnd);
// // textviewTextOffset += textviewText.Buffer.CharCount - textViewDataBytesMaxCount;
// // }
// // }
// }
//
// } else {
// if (vadjustmentPosition > 0.9) {
// Console.WriteLine ("Count:" + textView.Buffer.CharCount.ToString ());
// int forwardBytes = textviewString.Length - offset;
// if (forwardBytes > textViewDataBytesMaxCount) {
// forwardBytes = textViewDataBytesMaxCount;
// }
// if (forwardBytes > 0) {
// TextIter iter = textView.Buffer.EndIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offset, forwardBytes));
// offset += forwardBytes;
// int deleteBytes = textView.Buffer.CharCount - 3 * textViewDataBytesMaxCount;
//
// if (deleteBytes > 0) {
// Console.WriteLine ("Delete:" + deleteBytes.ToString ());
// TextIter iterStart = textView.Buffer.StartIter;
// TextIter iterEnd = textView.Buffer.StartIter;
// if (iterEnd.ForwardChars (deleteBytes)) {
// textView.Buffer.Delete (ref iterStart, ref iterEnd);
// }
// }
// }
// }
// if (vadjustmentPosition < 0.1) {
// Console.WriteLine ("Delete:" + textView.Buffer.CharCount.ToString ());
// if (offset >= textViewDataBytesMaxCount * 3) {
// int offsetEnd = offset - textViewDataBytesMaxCount * 3;
// int offsetStart = offsetEnd - textViewDataBytesMaxCount;
// if (offsetStart < 0) {
// offsetStart = 0;
// }
// int backwardBytes = offsetEnd - offsetStart;
// if (backwardBytes > 0) {
// TextIter iter = textView.Buffer.StartIter;
// textView.Buffer.Insert (ref iter, textviewString.Substring (offsetStart, backwardBytes));
// offset -= backwardBytes;
// }
// }
// }
// }
// if (isSend) {
// switch (convertMode) {
// case ConvertMode.Text:
// break;
// case ConvertMode.Hex:
// break;
// case ConvertMode.Dec:
// break;
// }
// } else {
// switch (convertMode) {
// case ConvertMode.Text:
// break;
// case ConvertMode.Hex:
// //textviewHexOffset = offset;
// break;
// case ConvertMode.Dec:
// //textviewDecOffset = offset;
// break;
// }
// }
bool isAutoScroll = false;
if (isSend) {
isAutoScroll = checkbuttonAutoScrollSend.Active;
} else {
isAutoScroll = checkbuttonAutoScrollReceive.Active;
}
if (isAutoScroll) {
if (scrolledWindow.VScrollbar.Visible == false || vadjustmentPosition > 0.98) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 10;
mover.MoveDown ();
TextIter iter = textView.Buffer.EndIter;
textView.Buffer.CreateMark ("EndMark", iter, false);
textView.ScrollToMark (textView.Buffer.CreateMark ("EndMark", iter, false), 0, false, 0, 0);
textView.Buffer.DeleteMark ("EndMark");
}
} else
if (vadjustmentPosition < 0.02) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 10;
mover.MoveUp ();
TextIter iter = textView.Buffer.StartIter;
textView.Buffer.CreateMark ("StartMark", iter, false);
textView.ScrollToMark (textView.Buffer.CreateMark ("StartMark", iter, false), 0, false, 0, 0);
textView.Buffer.DeleteMark ("StartMark");
}
} else
if (vadjustmentPosition > 0.7) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 100;
mover.MoveDown ();
TextIter iter = textView.Buffer.EndIter;
}
} else
if (vadjustmentPosition < 0.3) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 100;
mover.MoveUp ();
TextIter iter = textView.Buffer.StartIter;
}
} else
if (vadjustmentPosition > 0.55) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 300;
mover.MoveDown ();
TextIter iter = textView.Buffer.EndIter;
}
} else
if (vadjustmentPosition < 0.45) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 300;
mover.MoveUp ();
TextIter iter = textView.Buffer.StartIter;
}
}
} else {
if (vadjustmentPosition > 0.9) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 100;
mover.MoveDown ();
}
} else
if (vadjustmentPosition < 0.1) {
if (mover != null) {
mover.StepSize = mover.WindowSize / 100;
mover.MoveUp ();
}
}
}
}
private static string GetTempFile(ConvertMode type)
{
string extension = type.ToString().ToLower();
return(GetTempFile(extension));
}
public static async Task <byte[]> ConvertDocument(string filePath, ConvertMode type)
{
byte[] result = null;
object utf = MsoEncoding.msoEncodingUTF8;
object m = System.Reflection.Missing.Value;
object path = filePath;
object falseValue = false;
object trueValue = true;
var app = new Application();
object tempFilePath = null;
object saveChanges = WdSaveOptions.wdDoNotSaveChanges;
Document doc = null;
try
{
app.Visible = false;
app.ScreenUpdating = false;
doc = app.Documents.Open(ref path, ref falseValue, ref falseValue, ref m, ref m, ref m, ref m, ref m, ref m, ref m, ref utf);
doc.WebOptions.Encoding = MsoEncoding.msoEncodingUTF8;
tempFilePath = GetTempFile(type);
object fileType = null;
switch (type)
{
case ConvertMode.Xml:
fileType = WdSaveFormat.wdFormatXMLDocument;
break;
case ConvertMode.Html:
fileType = WdSaveFormat.wdFormatFilteredHTML;
break;
case ConvertMode.Pdf:
fileType = WdSaveFormat.wdFormatPDF;
break;
case ConvertMode.Xps:
fileType = WdSaveFormat.wdFormatXPS;
break;
}
doc.SaveAs(ref tempFilePath, ref fileType, ref m, ref m, ref m, ref m, ref m, ref m, ref m, ref m, ref m, ref utf);
doc.Close(ref saveChanges);
doc = null;
if (type == ConvertMode.Html)
{
result = Encoding.UTF8.GetBytes(EmbeddingHtmlImages(tempFilePath.ToString()));
}
else
{
result = File.ReadAllBytes(tempFilePath.ToString());
}
}
finally
{
if (doc != null)
{
doc.Close(ref saveChanges);
doc = null;
}
if (app != null)
{
app.Quit(ref saveChanges);
app = null;
}
DeleteTempFiles(tempFilePath.ToString());
}
await TaskRuner.Delay(0);
return(result);
}
public ToStringConverter(ConvertMode convertMode)
{
this.ConvertMode = convertMode;
}
public DDIStrongTypeConverter(Type targetType, ConvertMode convertMode)
{
this.targetType = targetType;
this.convertMode = convertMode;
}
public DefaultWordsConvert(ConvertMode mode)
{
Mode = mode;
}
private static void Convert(
ConvertMode mode,
IntPtr hwnd,
int xSource,
int ySource,
out int xTarget,
out int yTarget)
{
if (hwnd == UIObject.Root.NativeWindowHandle)
{
xTarget = xSource;
yTarget = ySource;
}
else
{
POINT lpPoint = new POINT(xSource, ySource);
RECT lpRect = new RECT();
if (!GetClientRect(hwnd, out lpRect))
{
throw new ExternalException("GetClientRect failed.", Marshal.GetHRForLastWin32Error());
}
if (MapWindowPoints(hwnd, IntPtr.Zero, ref lpRect, 2) == 0)
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 0)
{
throw new ExternalException("MapWindowPoints failed.", lastWin32Error);
}
}
RECT extendedFrameBoundsRect = new RECT();
int dwmRectangle = GetDwmRectangle(hwnd, ref extendedFrameBoundsRect);
switch (dwmRectangle)
{
case -2147024890:
case 0:
POINT point = new POINT();
point.X = lpRect.Left - extendedFrameBoundsRect.Left;
point.Y = lpRect.Top - extendedFrameBoundsRect.Top;
switch (mode)
{
case ConvertMode.ClientToScreen:
if (!ClientToScreen(hwnd, ref lpPoint))
{
throw new ExternalException("ClientToScreen failed.", Marshal.GetHRForLastWin32Error());
}
lpPoint.X -= point.X;
lpPoint.Y -= point.Y;
break;
case ConvertMode.ScreenToClient:
if (!ScreenToClient(hwnd, ref lpPoint))
{
throw new ExternalException("ScreenToClient failed.", Marshal.GetHRForLastWin32Error());
}
lpPoint.X += point.X;
lpPoint.Y += point.Y;
break;
}
xTarget = lpPoint.X;
yTarget = lpPoint.Y;
break;
default:
throw new ExternalException("DwmGetWindowAttribute failed.", dwmRectangle);
}
}
}
public async Task <byte[]> Convert(string filePath, ConvertMode type)
{
var fs = File.OpenRead(filePath);
return(await Convert(fs, type));
}
public CConverter(ConvertMode mode)
{
Mode = mode;
}
