public DAL(IsolatedStorageOfflineContext context
, String appName
, String language
, String userName
, String userPassword
, String configName
, String configVersion
, IDictionary<string, string> deviceInfo
, ProgressDelegate p
, Func<Uri, CacheControllerBehavior, AsyncWorkerManager, CacheRequestHandler> chacheRequestFactory)
{
this.appName = appName;
this.language = language;
this.configName = configName;
this.configVersion = configVersion;
this.onProgress = p;
this.context = context;
this.context.LoadCompleted += context_LoadCompleted;
this.context.CacheController.SetCacheRequestFactory(chacheRequestFactory);
this.context.CacheController.RefreshCompleted += CacheController_RefreshCompleted;
this.context.CacheController.ControllerBehavior.Credentials = new System.Net.NetworkCredential(userName, userPassword);
this.context.CacheController.ControllerBehavior.ConfigName = this.configName;
this.context.CacheController.ControllerBehavior.ConfigVersion = this.configVersion;
this.context.CacheController.ControllerBehavior.CoreVersion = CoreInformation.CoreVersion;
this.context.CacheController.ControllerBehavior.ReadProgressCallback = ReadProgressCallback;
this.context.CacheController.ControllerBehavior.DeviceInfo = deviceInfo;
//this.context.CacheController.ControllerBehavior.AddScopeParameters("Outlet","{A507956F-D135-4E8A-BD7F-14B54AC1E95C}");
}
public static RSSFile Download(string url, ProgressDelegate listener, ICancellable cancelObject)
{
try
{
Logger.Log("Downloading RSS file from {0}", url);
var request = HttpWebRequest.Create(url);
request.Timeout = 15000;
using (var response = request.GetResponse())
{
using (var stream = new ProgressStream(response.GetResponseStream(), response.ContentLength, listener, cancelObject))
{
try
{
return(new RSSFile(stream));
}
finally
{
stream.Close();
}
}
}
}
catch (Exception e)
{
Logger.Log("Caught exception: {0}", e.ToString());
return(null);
}
}
/// <summary>
/// Build tile system and apply stripping rules.
/// </summary>
/// <param name="system">Tile system.</param>
/// <param name="progressHandler">Progress handler delegate.</param>
/// <returns>Tile system builder that was used to build tile system.</returns>
private static TileSystemBuilder BuildTileSystemHelper(TileSystem system, ProgressDelegate progressHandler = null)
{
var builder = new TileSystemBuilder(progressHandler);
BuildTileSystemHelper(builder, system);
return(builder);
}
ProgressDelegate getAndRemoveCallbackFromRegister(HttpRequestMessage request)
{
ProgressDelegate emptyDelegate = delegate { };
lock (registeredProgressCallbacks) {
if (!registeredProgressCallbacks.ContainsKey(request))
{
return(emptyDelegate);
}
var weakRef = registeredProgressCallbacks[request];
if (weakRef == null)
{
return(emptyDelegate);
}
var callback = weakRef.Target as ProgressDelegate;
if (callback == null)
{
return(emptyDelegate);
}
registeredProgressCallbacks.Remove(request);
return(callback);
}
}
private void init(ProgressStream stream)
{
stream.ReadCallback = readBytes;
Progress = delegate
{
};
}
/// <summary>
/// This will simulate the mod installation and decide installation choices and files final paths.
/// </summary>
/// <param name="modArchiveFileList">The list of files inside the mod archive.</param>
/// <param name="stopPatterns">patterns matching files or directories that should be at the top of the directory structure.</param>
/// <param name="pluginPath">skip as the first path component in installer destinations</param>
/// <param name="destinationPath">The file install destination folder.</param>
/// <param name="progressDelegate">A delegate to provide progress feedback.</param>
/// <param name="coreDelegate">A delegate for all the interactions with the js core.</param>
public abstract Task <Dictionary <string, object> > Install(List <string> modArchiveFileList,
List <string> stopPatterns,
string pluginPath,
string destinationPath,
dynamic preset,
ProgressDelegate progressDelegate,
CoreDelegates coreDelegate);
private void Initialize(DirectoryInfo directory, uint level, ProgressDelegate Progress)
{
FileSystemInfo[] children = directory.GetFileSystemInfos();
if (children != null)
{
Progress?.Invoke(this, new ProgressEventArgs(0, children.Length));
int childNumberLength = children.Length.ToString().Length;
for (int i = 0; i < children.Length; i++)
{
IsoFolderElement child;
string childNumber = string.Format("{0:D" + childNumberLength.ToString() + "}", i);
if (children[i].GetType() == typeof(DirectoryInfo))
{
child = new IsoDirectory(this, (DirectoryInfo)children[i], level + 1, childNumber);
}
else
{
child = new IsoFile((FileInfo)children[i], childNumber);
}
Children.Add(child);
Progress?.Invoke(this, new ProgressEventArgs(i));
}
}
Children.Sort();
CalculateSize();
}
/**
* 上传文件
*/
protected string uploadFiles(Object upauth, ArrayList filelist, ProgressDelegate progress = null)
{
string upresults = "[";
Dictionary <Object, Object> dt = (Dictionary <Object, Object>)upauth;
object nsp_host, nsp_tstr, secret, nsp_tapp;
if (dt.TryGetValue((object)"nsp_host", out nsp_host) == false ||
dt.TryGetValue((object)"nsp_tstr", out nsp_tstr) == false ||
dt.TryGetValue((object)"secret", out secret) == false ||
dt.TryGetValue((object)"nsp_tapp", out nsp_tapp) == false)
{
throw new Exception("上传鉴权出错");
}
foreach (Object filename in filelist)
{
string uploadresult = null;
string mksinglefile = null;
try
{
uploadresult = uploadFile(nsp_tapp.ToString(), secret.ToString(), nsp_host.ToString(), nsp_tstr.ToString(), filename.ToString(), progress);
mksinglefile = mkfilestr(uploadresult);
}
catch (Exception err) {
NSPLog.log(LogMsgType.NSP_LOG_ERR, err.Message);
throw err;
}
upresults += mksinglefile + ",";
}
upresults = upresults.Substring(0, upresults.Length - 1) + "]";
return(upresults);
}
public static void UpdateProgresssBar(double progress, ProgressDelegate progressDelegate)
{
if (progressDelegate != null)
{
progressDelegate.Invoke(progress);
}
}
public virtual async Task <IRestApiResult <TResult> > PostAsync <TContent, TResult>(
Priority priority,
string path,
TContent content = default(TContent),
ProgressDelegate progressDelegate = null,
IList <KeyValuePair <string, string> > headers = null,
IHttpContentResolver httpContentResolver = null,
IHttpResponseResolver httpResponseResolver = null,
CancellationToken cancellationToken = default(CancellationToken))
{
var httpContent = ResolveHttpContent(content);
var stream = await httpContent.ReadAsStreamAsync();
var progressContent = new ProgressStreamContent(httpContent.Headers, stream, cancellationToken)
{
Progress = progressDelegate
};
var httpRequestMessage = new HttpRequestMessage(new HttpMethod("POST"), path)
{
Content = progressContent
};
return(await SendAsync <TResult>(priority, httpRequestMessage, headers, httpResponseResolver, cancellationToken));
}
public DAL(IsolatedStorageOfflineContext context
, String appName
, String language
, String userName
, String userPassword
, String configName
, String configVersion
, IDictionary <string, string> deviceInfo
, ProgressDelegate p
, Func <Uri, CacheControllerBehavior, AsyncWorkerManager, CacheRequestHandler> chacheRequestFactory)
{
this.appName = appName;
this.language = language;
this.configName = configName;
this.configVersion = configVersion;
this.onProgress = p;
this.context = context;
this.context.LoadCompleted += context_LoadCompleted;
this.context.CacheController.SetCacheRequestFactory(chacheRequestFactory);
this.context.CacheController.RefreshCompleted += CacheController_RefreshCompleted;
this.context.CacheController.ControllerBehavior.Credentials = new System.Net.NetworkCredential(userName, userPassword);
this.context.CacheController.ControllerBehavior.ConfigName = this.configName;
this.context.CacheController.ControllerBehavior.ConfigVersion = this.configVersion;
this.context.CacheController.ControllerBehavior.CoreVersion = CoreInformation.CoreVersion;
this.context.CacheController.ControllerBehavior.ReadProgressCallback = ReadProgressCallback;
this.context.CacheController.ControllerBehavior.DeviceInfo = deviceInfo;
//this.context.CacheController.ControllerBehavior.AddScopeParameters("Outlet","{A507956F-D135-4E8A-BD7F-14B54AC1E95C}");
}
/// <summary>
/// For ROOT Only !!
/// </summary>
public IsoDirectory(TreeNode directory, UInt32 level, string childNumber, ProgressDelegate Progress)
: base(directory, true, childNumber)
{
Parent = this;
Initialize(directory, level, Progress);
}
private void Initialize(DirectoryInfo directory, UInt32 level, ProgressDelegate Progress)
{
Level = level;
FileSystemInfo[] children = directory.GetFileSystemInfos();
if (children != null)
{
Progress?.Invoke(this, new ProgressEventArgs(0, children.Length));
int childNumberLength = children.Length.ToString().Length;
for (int i = 0; i < children.Length; i++)
{
string childNumber = String.Format("{0:D" + childNumberLength.ToString() + "}", i);
Children.Add(children[i] is DirectoryInfo ? (IsoFolderElement)
new IsoDirectory(this, (DirectoryInfo)children[i], level + 1, childNumber) :
new IsoFile((FileInfo)children[i], childNumber));
Progress?.Invoke(this, new ProgressEventArgs(i));
}
}
Children.Sort();
CalculateSize();
}
public static void UpdateProgresssBar(double progress, ProgressDelegate progressDelegate)
{
if (progressDelegate != null)
{
progressDelegate.Invoke(progress);
}
}
public async Task <Dictionary <string, object> > ApplyPatch(JObject data,
ProgressDelegate progress,
CoreDelegates core)
{
Dictionary <string, object> res = await IsPatchApplicable(data, core);
if (res ["Result"].ToString() == "False")
{
return(res);
}
res = await ReflectionPatch.Instance.ApplyPatch(data, progress, core);
if (res ["Result"].ToString() == "False")
{
return(res);
}
if (await core.context.IsDeploymentRequired())
{
res = await DeployFiles(core);
if (res ["Result"].ToString() == "False")
{
return(res);
}
}
return(await Injector.Instance.ApplyPatch(data, progress, core));
}
public static void CompressDirectory(string _inputDirectory, string _zippedFileName, ProgressDelegate _progress)
{
DirectoryInfo _inputDirectoryInfo = new DirectoryInfo(_inputDirectory);
Uri _inputDirectoryURI = new Uri(_inputDirectory.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar);
using (FileStream _zippedFileStream = new FileStream(_zippedFileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
using (GZipStream _zipStream = new GZipStream(_zippedFileStream, CompressionMode.Compress))
{
// Iterate through each file to get relative path to the file and compress that file
foreach (FileInfo _file in _inputDirectoryInfo.GetFiles("*.*", SearchOption.AllDirectories))
{
string _curFilePath = _file.FullName;
if (Path.GetExtension(_curFilePath) == ".meta")
continue;
string _curFileRelativePath = _inputDirectoryURI.MakeRelativePath(_curFilePath);
if (_progress != null)
_progress("[Zip] Compressing file: " + _curFileRelativePath);
CompressFile(_inputDirectory, _curFileRelativePath, _zipStream);
}
}
}
}
/// <summary>
/// Выполняет операцию в фоновом потоке, не блокируя UI элементы формы. Может быть вызван сколько угодно раз подряд
/// </summary>
/// <param name="args">Начальные аргументы для потока</param>
/// <param name="action">Метод, выполняемый в фоновом потоке</param>
/// <param name="progress">Метод, выполняемый в фоновом потоке, позволяющий откликаться в основной поток</param>
/// <param name="completed">Метод, выполняемый после окончания фонового потока</param>
/// <param name="cancellationToken">Токен для воркеров с возможностью остановки</param>
public static void RunAsync(object args, DoWorkDelegate action, ProgressDelegate progress, CompletedDelegate completed, CancellationTokenSource cancellationToken = null)
{
Worker w = new Worker(args, action, completed, progress, progress != null, cancellationToken);
w.Complited += new EventHandler(w_Complited);
Count++;
}
/// <summary>
/// This will assign all files to the proper destination.
/// </summary>
/// <param name="fileList">The list of files inside the mod archive.</param>
/// <param name="stopPatterns">patterns matching files or directories that should be at the top of the directory structure.</param>
/// <param name="progressDelegate">A delegate to provide progress feedback.</param>
/// <param name="coreDelegate">A delegate for all the interactions with the js core.</param>
protected async Task <List <Instruction> > BasicModInstall(List <string> fileList,
List <string> stopPatterns,
ProgressDelegate progressDelegate,
CoreDelegates coreDelegate)
{
List <Instruction> FilesToInstall = new List <Instruction>();
string prefix = ArchiveStructure.FindPathPrefix(fileList, stopPatterns);
await Task.Run(() =>
{
foreach (string ArchiveFile in fileList)
{
if (ArchiveFile.EndsWith("" + Path.DirectorySeparatorChar))
{
// don't include directories, only files
continue;
}
string destination;
if (ArchiveFile.StartsWith(prefix))
{
destination = ArchiveFile.Substring(prefix.Length);
}
else
{
destination = ArchiveFile;
}
FilesToInstall.Add(Instruction.CreateCopy(ArchiveFile, destination));
// Progress should increase.
}
});
return(FilesToInstall);
}
// For ROOT !!
public IsoDirectory(DirectoryInfo directory, uint level, string childNumber, ProgressDelegate Progress)
: base(directory, true, childNumber)
{
Parent = this;
Initialize(directory, level, Progress);
}
public static RSSFile Download(string url, ProgressDelegate listener, ICancellable cancelObject)
{
try
{
var request = HttpWebRequest.Create(url);
request.Timeout = 15000;
using (var response = request.GetResponse())
{
using (var stream = new ProgressStream(response.GetResponseStream(), response.ContentLength, listener, cancelObject))
{
try
{
return(new RSSFile(stream));
}
finally
{
stream.Close();
}
}
}
}
catch (IOException)
{
return(null);
}
catch (WebException)
{
return(null);
}
}
public static async Task <TResult> PostAsync <TContent, TResult>(this WebApiClient webApiClient,
Priority priority, string path, TContent content = default(TContent),
ProgressDelegate progressDelegate = null, IHttpContentResolver contentResolver = null)
{
var httpClient = webApiClient.GetWebApiClient(priority);
webApiClient.SetHttpRequestHeaders(httpClient);
var httpContent = webApiClient.ResolveHttpContent(content);
var stream = await httpContent.ReadAsStreamAsync();
var progressContent = new ProgressStreamContent(httpContent.Headers, stream, CancellationToken.None);
progressContent.Progress = progressDelegate;
var response = await httpClient
.PostAsync(path, progressContent)
.ConfigureAwait(false);
if (!await response.EnsureSuccessStatusCodeAsync())
{
return(default(TResult));
}
return(await webApiClient.HttpResponseResolver.ResolveHttpResponseAsync <TResult>(response));
}
/// <summary>
/// Perfroms a two dimensional isotropic wavelet transformation for an array. The result is copied back to the declared array.
/// </summary>
/// <exception cref="ArgumentException"></exception>
virtual public void BacktransformIsotropic2D(float[,] src, ProgressDelegate progressDelegate = null)
{
lock (threadSync) {
checkArrayArgument(src, "src");
//Calculate the integral digits of log to the base two of the maximum of "width" and "height"
//The resulting number of "width | height" cannot have a greater log to the base 2 (integral digits)
//than the greater of both values.
int log2 = 1;
int test = 1;
while (test < (width | height))
{
test <<= 1;
log2++;
}
float[,] tmp = getTempArray();
int i = 1;
initProgress(progressDelegate);
while ((i <= log2) && (!updateProgress(0)))
{
//Shift always rounds down (towards negative infinity)
//However, for odd lengths we have one more low-pass value than
//high-pass values. By shifting the negative value and negating the result
//we get the desired result.
int w = -(-width >> (log2 - i));
int h = -(-height >> (log2 - i));
if ((w >= minSize) && (h >= minSize))
{
InvTransformCols(src, tmp, w, h);
InvTransformRows(tmp, src, w, h);
}
i++;
}
}
}
/// <summary>
/// Updates the progress value of the current task by the declared increment and
/// calls a callback to notify the caller about the progress and give
/// the possiblily to abort the current task.
/// </summary>
/// <param name="progressDelegate">a delegate to notify the caller about the progress and to give
/// the possiblity to abort the current task. Can be set to null if notification is not required</param>
/// <param name="maxValue">The maximal progress value (to calculate progress percentage). Can be set to 0 if used with TransformIsotropic2D() or BacktransformIsotropic2D() </param>
private void initProgress(ProgressDelegate progressDelegate, long maxValue = 0)
{
if (progressDelegate != null)
{
this.progressSync = new object();
}
else
{
this.progressSync = null;
}
int w = width, h = height;
this.progressMax = maxValue;
//Calculate the exact maximal value for the progress value if not declared (used by TransformIsotropic2D() and BacktransformIsotropic2D())
if (this.progressMax == 0)
{
while ((w >= minSize) && (h >= minSize))
{
this.progressMax += 2 * w * h;
w = -(-w >> 1);
h = -(-h >> 1);
}
}
this.progressDelegate = progressDelegate;
this.progressValue = 0;
this.progressAbort = false;
}
public void Write( BinaryWriter writer, ProgressDelegate Progress ) {
if ( m_extent > 0 && m_size > 0 ) {
FileStream source = new FileStream( m_fullPath, FileMode.Open, FileAccess.Read );
BinaryReader reader = new BinaryReader( source );
// The write buffer is 1MB long. I haven't given too much study into this particular field, so
// feel free to change according two whatever writing speed is optimal.
int bucket = (int)IsoAlgorithm.SectorSize*512; // 1 MB
byte[] buffer = new byte[bucket];
while ( true ) {
int bytesRead = reader.Read( buffer, 0, bucket );
if ( bytesRead == 0 ) {
break;
}
if ( bytesRead == bucket ) {
writer.Write( buffer );
} else {
writer.Write( buffer, 0, bytesRead );
if ( bytesRead%IsoAlgorithm.SectorSize != 0 ) {
writer.Write( new byte[IsoAlgorithm.SectorSize-( bytesRead%IsoAlgorithm.SectorSize )] );
}
break;
}
Progress( this, new ProgressEventArgs( (int)( writer.BaseStream.Length/IsoAlgorithm.SectorSize ) ) );
}
reader.Close();
source.Close();
}
}
public ConcurrentBag <List <Candle> > GetHistoryFromFile(ProgressDelegate progress, int period, DateTime fromDate, DateTime toDate)
{
IHistory h;
int num;
Dictionary <string, string> source = ZerodhaOperations.LoadInstruments();
ConcurrentBag <List <Candle> > resultCollection = new ConcurrentBag <List <Candle> >();
int num2 = period;
if (num2 > 10)
{
if (num2 == 15)
{
h = new TradeHistory15();
goto TR_0000;
}
else if (num2 == 30)
{
h = new TradeHistory30();
goto TR_0000;
}
else if (num2 == 60)
{
h = new TradeHistory60();
goto TR_0000;
}
}
else if (num2 == 5)
{
h = new TradeHistory5();
goto TR_0000;
}
else if (num2 == 10)
{
h = new TradeHistory10();
goto TR_0000;
}
else if (num2 == 100)
{
h = new TradeHistoryDaily();
goto TR_0000;
}
{
h = new TradeHistoryDaily();
}
TR_0000:
num = Environment.ProcessorCount;
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = num;
Parallel.ForEach <KeyValuePair <string, string> >(source, parallelOptions, delegate(KeyValuePair <string, string> i)
{
resultCollection.Add(h.GetHistoryFromFile(h.folderName, i.Value, fromDate.AddDays(-30), toDate));
if (progress != null)
{
progress($"Loading Data ... {i.Value}");
}
});
return(resultCollection);
}
public MainForm()
{
InitializeComponent();
FormClosing += OnFormClosing;
ProgressCallback = progressCallback;
UpdateNodeCallback = updateNodeCallback;
}
public SplashForm()
{
InitializeComponent();
update_version_function = this.UpdateVersionInternal;
update_information_function = this.UpdateInformationInternal;
update_progress_function = this.UpdateProgressInternal;
}
public void SlowMethod(ProgressDelegate progressDelegate)
{
for (int i = 0; i < 10; i++)
{
Thread.Sleep(500);
progressDelegate();
}
}
public SplashScreen()
{
InitializeComponent();
this.StartPosition = FormStartPosition.CenterScreen;
this.progressBar1.Maximum = 100;
del = this.UpdateProgressInternal;
this.label4.Text = ProductVersion;
}
public static bool DecompressFile(string sDir, GZipStream zipStream, ProgressDelegate progress)
{
//Decompress file name
byte[] bytes = new byte[sizeof(int)];
int Readed = zipStream.Read(bytes, 0, sizeof(int));
if (Readed < sizeof(int))
{
return(false);
}
int iNameLen = BitConverter.ToInt32(bytes, 0);
bytes = new byte[sizeof(char)];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < iNameLen; i++)
{
zipStream.Read(bytes, 0, sizeof(char));
char c = BitConverter.ToChar(bytes, 0);
sb.Append(c);
}
string sFileName = sb.ToString();
if (progress != null)
{
progress(sFileName);
}
//Decompress file content
bytes = new byte[sizeof(int)];
zipStream.Read(bytes, 0, sizeof(int));
int iFileLen = BitConverter.ToInt32(bytes, 0);
bytes = new byte[iFileLen];
zipStream.Read(bytes, 0, bytes.Length);
string sFilePath = Path.Combine(sDir, sFileName);
string sFinalDir = Path.GetDirectoryName(sFilePath);
if (!Directory.Exists(sFinalDir))
{
Directory.CreateDirectory(sFinalDir);
}
TryAgain:
try
{
using (FileStream outFile = new FileStream(sFilePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
outFile.Write(bytes, 0, iFileLen);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
goto TryAgain;
}
return(true);
}
public Form1()
{
rand = new Random();
cookieContainer = new CookieContainer();
progressDelegate = new ProgressDelegate(updateProgress);
listViewDelegate = new ListViewDelegate(updateListView);
statusDelegate = new StatusDelegate(updateStatus);
InitializeComponent();
}
public DataImportWizardP2(string file)
{
_excelFile = file;
_dbManager = DBAccessManager.GetInstance();
InitializeComponent();
_dlgLbl = new DataDelegate(Update);
_dlgPrg = new ProgressDelegate(UpdateProgress);
new Thread(() => LoadData()).Start();
}
public void TestProgress()
{
ProgressDelegate p = null;
p += WriteProgressToConsole;
p += WriteProgressToFile;
ProgressEmulator(p);
}
public void RegisterForProgress(HttpRequestMessage request, ProgressDelegate callback)
{
if (callback == null && registeredProgressCallbacks.ContainsKey(request)) {
registeredProgressCallbacks.Remove(request);
return;
}
registeredProgressCallbacks[request] = new WeakReference(callback);
}
public static void UnPackFolder(string inpath, string outpath, ProgressDelegate progress)
{
UPKFolder.UnPackFolder(new FileChangeInfo
{
inpath = inpath,
outpath = outpath,
progressDelegate = progress
});
}
public static void Compress(string inpath, string outpath, ProgressDelegate progress)
{
Compress(new FileChangeInfo
{
inpath = inpath,
outpath = outpath,
progressDelegate = progress
});
}
public void RegisterForProgress(HttpRequestMessage request, ProgressDelegate callback)
{
if (callback == null && registeredProgressCallbacks.ContainsKey(request)) {
registeredProgressCallbacks.Remove(request);
return;
}
registeredProgressCallbacks[request] = callback;
}
public static void DeCompress(string inpath, string outpath, ProgressDelegate progress)
{
FileChangeInfo info = new FileChangeInfo();
info.inpath = inpath;
info.outpath = outpath;
info.progressDelegate = progress;
DeCompress(info);
}
public static void DecompressToDirectory(string sCompressedFile, string sDir, ProgressDelegate progress)
{
using (FileStream inFile = new FileStream(sCompressedFile, FileMode.Open, FileAccess.Read, FileShare.None))
using (GZipStream zipStream = new GZipStream(inFile, CompressionMode.Decompress, true))
while (DecompressFile(sDir, zipStream, progress))
{
;
}
}
/// <summary>
/// Adds the specified integers while reporting progress.
/// </summary>
/// <returns>The result of adding a and b.</returns>
/// <param name="a">The integer a.</param>
/// <param name="b">The integer b.</param>
/// <param name="progress">The progress callback.</param>
public static int AddWithProgress(int a, int b, ProgressDelegate progress)
{
progress(0.25f, "25%");
Thread.Sleep(1000);
progress(0.5f, "50%");
Thread.Sleep(1000);
progress(0.75f, "75%");
Thread.Sleep(1000);
return a + b;
}
public void PlaceTrees(ProgressDelegate progressDelegate)
{
if (!Validate())
return;
instances = new ArrayList();
TreesPosition = new List<TreePosition>();
//get alpha map width and height of terrain
int alphamapWidth = terrainData.alphamapWidth;
int alphamapHeight = terrainData.alphamapHeight;
//get splat map of terrain
splatmap = terrainData.GetAlphamaps(0,0,alphamapWidth,alphamapHeight);
//dimension of splatmaps
int xDim = splatmap.GetUpperBound(0);
int yDim = splatmap.GetUpperBound(1);
//how big is one unit in real world
xUnit = (float)terrainData.size.x / (float)(xDim + 1);
yUnit = (float)terrainData.size.z / (float)(yDim + 1);
float percentPosition = 0.1f;
progressDelegate("Placing trees", "Determining basic position", percentPosition);
float calculation = 0.4f / xDim;
for(int x = 0; x <= xDim; x ++)
{
for(int y = 0; y <= yDim; y ++)
{
foreach(TreeTextureSettings treeTexture in TreeTextures)
{
//this texture is not used for planting trees
if (treeTexture.IsUsed == false)
continue;
float alphaMap = splatmap[x,y,treeTexture.Index];
//this texture is not where we are currently in
if (alphaMap < treeTexture.AlphamapValue)
continue;
//check distance from the nearest tree
if (IsTreePositionClose(x, y, treeTexture.TreeDistance, treeTexture.Index))
continue;
TreePosition position = new TreePosition();
position.PosX = x;
position.PosY = y;
position.TreeIndex = treeTexture.DetermineTreePrototype;
position.TextureIndex = treeTexture.Index;
TreesPosition.Add(position);
}
}
percentPosition += calculation;
progressDelegate("Placing trees", "Determining basic position", percentPosition);
}
Place(progressDelegate);
}
public DownloadState Download(string url, Control ctrl, ProgressDelegate pd)
{
RequestState myRequestState = new RequestState();
try
{
// Create a HttpWebrequest object to the desired URL.
HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url);
// Create an instance of the RequestState and assign the previous myHttpWebRequest
// object to its request field.
myRequestState.downloadManager = this;
myRequestState.request = myHttpWebRequest;
myRequestState.ctrl = ctrl;
myRequestState.progFormCB = new ProgressFormDelegate(Progress);
myRequestState.progCB = new ProgressDelegate( pd );
// Start the asynchronous request.
IAsyncResult result = (IAsyncResult)myHttpWebRequest.BeginGetResponse(new AsyncCallback(RespCallback), myRequestState);
// this line implements the timeout, if there is a timeout, the callback fires and the request becomes aborted
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), myHttpWebRequest, DefaultTimeout, true);
// Release the HttpWebResponse resource.
//myRequestState.response.Close();
lock (activeDownloads)
{
activeDownloads.Add(myRequestState);
}
return (DownloadState)myRequestState;
}
catch (WebException e)
{
myRequestState.error = e;
myRequestState.progFormCB(myRequestState.progCB, myRequestState);
/*
Console.WriteLine("\nMain Exception raised!");
Console.WriteLine("\nMessage:{0}", e.Message);
Console.WriteLine("\nStatus:{0}", e.Status);
Console.WriteLine("Press any key to continue..........");
*/
}
catch (Exception e)
{
Console.WriteLine("\nMain Exception raised!");
Console.WriteLine("Source :{0} ", e.Source);
Console.WriteLine("Message :{0} ", e.Message);
Console.WriteLine("Press any key to continue..........");
//Console.Read();
}
return null;
}
public ProgressStream( Stream innerStream, long lengthHint, ProgressDelegate listener, ICancellable cancelObject )
{
m_innerStream = innerStream;
m_listener = listener;
m_cancelObject = cancelObject;
m_length = lengthHint;
m_position = 0;
m_lastProgress = -1;
EmitProgress();
}
public static void DecompressToDirectory(string _compressedFilePath, string _targetFolder, ProgressDelegate _progress = null)
{
string _curZippedFileName = Path.GetFileNameWithoutExtension(_compressedFilePath);
string _decompressToDirectory = Path.Combine(_targetFolder, _curZippedFileName);
using (FileStream _compressedFileStream = new FileStream(_compressedFilePath, FileMode.Open, FileAccess.Read, FileShare.None))
{
using (GZipStream _zipStream = new GZipStream(_compressedFileStream, CompressionMode.Decompress, true))
{
while (DecompressFile(_decompressToDirectory, _zipStream, _progress));
}
}
}
public SplashScreen()
{
InitializeComponent();
//Application.EnableVisualStyles();
this.textBox1.Text = "";
this.textBox2.Text = "";
this.textBox3.Text = "";
this.textBox4.Text = "";
//this.textBox5.Text = "";
//this.progressBar1.Maximum = 100;
deleg = this.UpdateProgressInternal;
// this.Opacity = 0.70D;
}
static void CompressDirectory(string sInDir, string sOutFile, ProgressDelegate progress)
{
string[] sFiles = Directory.GetFiles(sInDir, "*.*", SearchOption.AllDirectories);
int iDirLen = sInDir[sInDir.Length - 1] == Path.DirectorySeparatorChar ? sInDir.Length : sInDir.Length + 1;
using (FileStream outFile = new FileStream(sOutFile, FileMode.Create, FileAccess.Write, FileShare.None))
using (GZipStream str = new GZipStream(outFile, CompressionMode.Compress))
foreach (string sFilePath in sFiles)
{
string sRelativePath = sFilePath.Substring(iDirLen);
if (progress != null)
progress(sRelativePath);
CompressFile(sInDir, sRelativePath, str);
}
}
/// <summary>
/// writes messages about calculation status and progress
/// </summary>
/// <param name="KeyOfSender"></param>
/// <param name="Percent"></param>
/// <param name="Message"></param>
public void Progress(string KeyOfSender, int Percent, string StatusMsg)
{
if (this.InvokeRequired == false)
{
string msg = StatusMsg;
int perc = Percent;
this.Text = msg + perc.ToString() + " % done!";
calcProgressBar.Value = perc;
}
else
{
ProgressDelegate progDeleg = new ProgressDelegate(Progress);
this.BeginInvoke(progDeleg, new object[] { KeyOfSender, Percent, StatusMsg });
}
}
private void btnStart_Click(object sender, EventArgs e)
{
// Reset all progress trackers to 0
Reset();
ProgressDelegate progressDelegate = null;
if (rdoSpinBox.Checked)
progressDelegate = new ProgressDelegate(IncrementSpinBox);
else if (rdoProgressBar.Checked)
progressDelegate = new ProgressDelegate(IncrementProgressBar);
else
progressDelegate = new ProgressDelegate(IncrementTrackBar);
// Run the simulation!
SlowMethod(progressDelegate);
}
public void delegateTest(){
ProgressDelegate progress;
Console.WriteLine("Enter 2 numbers separated with a comma:");
string input = Console.ReadLine();
int commaPos = input.IndexOf(',');
double param1 = Convert.ToDouble(input.Substring(0,commaPos));
double param2 = Convert.ToDouble(input.Substring(commaPos+1,input.Length - commaPos-1));
Console.Write("Enter M to multiply or D to divide:");
input = Console.ReadLine();
if( input == "M"){
progress = new ProgressDelegate(Multiply);
}else{
progress = new ProgressDelegate(Divide);
}
Console.WriteLine("Result: {0}",progress(param1,param2));
Console.ReadKey();
}
public List< Tuple< File, File > > Compare( ExtensionFilesGroup _other, ProgressDelegate _progress ) {
int maxFilesCount = Math.Max( m_files.Count, _other.m_files.Count );
// First, compare file sizes
Dictionary< long, Tuple< List< File >, List< File > > > size2Files = new Dictionary< long, Tuple< List< File >, List< File > > >( maxFilesCount );
foreach ( File file in m_files ) {
if ( !size2Files.ContainsKey( file.m_size ) )
size2Files.Add( file.m_size, new Tuple< List< File >, List< File > >( new List< File >(), new List< File >() ) );
size2Files[file.m_size].Item1.Add( file );
}
foreach ( File file in _other.m_files ) {
if ( !size2Files.ContainsKey( file.m_size ) )
size2Files.Add( file.m_size, new Tuple< List< File >, List< File > >( new List< File >(), new List< File >() ) );
size2Files[file.m_size].Item2.Add( file );
}
// Compare among files of the same size
List< Tuple< File, File > > result = new List< Tuple< File, File > >( maxFilesCount );
int sameSizeFilesProgressCount = Math.Max( 1, size2Files.Values.Count / 100 );
int sameSizeFilesIndex = 0;
foreach ( Tuple< List< File >, List< File > > sameSizeFiles in size2Files.Values ) {
if ( (++sameSizeFilesIndex % sameSizeFilesProgressCount) == 0 ) {
// Notify of progress
_progress( (float) sameSizeFilesIndex / size2Files.Values.Count, result.Count );
}
for ( int fileIndex0=0; fileIndex0 < sameSizeFiles.Item1.Count; fileIndex0++ ) {
File file0 = sameSizeFiles.Item1[fileIndex0];
for ( int fileIndex1=0; fileIndex1 < sameSizeFiles.Item2.Count; fileIndex1++ ) {
File file1 = sameSizeFiles.Item2[fileIndex1];
if ( file0.m_fullName == file1.m_fullName )
continue; // Ignore same files...
if ( file0.CompareBinary( file1 ) ) {
result.Add( new Tuple<File,File>( file0, file1 ) ); // Same!
}
}
}
}
return result;
}
public static bool DecompressFile(string sDir, GZipStream zipStream, ProgressDelegate progress)
{
//Decompress file name
byte[] bytes = new byte[sizeof(int)];
int Readed = zipStream.Read(bytes, 0, sizeof(int));
if (Readed < sizeof(int))
return false;
int iNameLen = BitConverter.ToInt32(bytes, 0);
bytes = new byte[sizeof(char)];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < iNameLen; i++)
{
zipStream.Read(bytes, 0, sizeof(char));
char c = BitConverter.ToChar(bytes, 0);
sb.Append(c);
}
string sFileName = sb.ToString();
if (progress != null)
progress(sFileName);
//Decompress file content
bytes = new byte[sizeof(int)];
zipStream.Read(bytes, 0, sizeof(int));
int iFileLen = BitConverter.ToInt32(bytes, 0);
bytes = new byte[iFileLen];
zipStream.Read(bytes, 0, bytes.Length);
string sFilePath = Path.Combine(sDir, sFileName);
string sFinalDir = Path.GetDirectoryName(sFilePath);
if (!Directory.Exists(sFinalDir))
Directory.CreateDirectory(sFinalDir);
using (FileStream outFile = new FileStream(sFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
outFile.Write(bytes, 0, iFileLen);
return true;
}
public static bool InstallGame( string gameTitle, string gameVersion, ProgressDelegate listener, ICancellable cancelObject )
{
var downloadPath = GetDownloadPath( gameTitle, gameVersion );
var installPath = GetInstallPath( gameTitle, gameVersion );
if( File.Exists( downloadPath ) )
{
try
{
using( var zipFile = new ZipFile( downloadPath ) )
{
// Delete old install
if( Directory.Exists( installPath ) )
{
Directory.Delete( installPath, true );
}
Directory.CreateDirectory( installPath );
// Extract new install
int totalFiles = zipFile.Entries.Count;
int filesInstalled = 0;
int lastProgress = 0;
listener.Invoke( 0 );
foreach( var entry in zipFile.Entries )
{
// Extract the file
var entryInstallPath = Path.Combine( installPath, entry.FileName );
if( entry.IsDirectory )
{
Directory.CreateDirectory( entryInstallPath );
}
else
{
Directory.CreateDirectory( Path.GetDirectoryName( entryInstallPath ) );
using( var file = File.OpenWrite( entryInstallPath ) )
{
try
{
using( var reader = new ProgressStream( entry.OpenReader(), -1, delegate {
// TODO: Emit progress during installation of large individual files?
}, cancelObject ) )
{
try
{
reader.CopyTo( file );
if( Program.Platform == Platform.Linux ||
Program.Platform == Platform.OSX )
{
Mono.Unix.Native.Syscall.chmod(
entryInstallPath,
Mono.Unix.Native.FilePermissions.ACCESSPERMS
);
}
}
finally
{
reader.Close();
}
}
}
finally
{
file.Close();
}
}
}
// Check for cancellation
if( cancelObject.Cancelled )
{
throw new IOCancelledException();
}
// Notify the progress listener
filesInstalled++;
int progress = (filesInstalled * 100) / totalFiles;
if( progress != lastProgress )
{
listener.Invoke( progress );
lastProgress = progress;
}
}
}
return true;
}
catch( IOException )
{
if( Directory.Exists( installPath ) )
{
Directory.Delete( installPath, true );
}
return false;
}
catch( ZipException )
{
if( Directory.Exists( installPath ) )
{
Directory.Delete( installPath, true );
}
return false;
}
}
return false;
}
private static string BuildHTMLPage(
IServiceProvider provider,
IList<IMsg> msgs,
ProgressDelegate pd,
bool processSmiles,
Encoding encoding)
{
var formatter = new TextFormatter();
var sb = new StringBuilder();
var forum = new Forum(provider);
forum.LoadData(msgs[0].ForumID);
sb.AppendFormat(
@"<tr><td class='s' colspan='2' align='center'>{0} <font size='1'>[{1}]</font></td></tr>",
forum.Description, forum.Name);
string messageFormat;
using (var rd = new StreamReader(Assembly.GetExecutingAssembly().GetRequiredResourceStream(_messageFormatResource)))
messageFormat = rd.ReadToEnd();
var i = 0;
foreach (var msg in msgs)
{
var formattedRating = msg.GetFormattedRating();
sb.AppendFormat(
messageFormat,
msg.ID,
msg.Subject,
msg.ParentID,
SR.Forum.ExportMessages.Export2ParentLink,
msg.UserNick,
FormatUserClass((UserClass)msg.UserClass, true),
msg.Date,
string.IsNullOrEmpty(formattedRating)
? string.Empty
: SR.TGColumnRate + " " + formattedRating,
formatter.Format(msg.Body, processSmiles));
i++;
pd(i, msgs.Count);
}
string exportPageFormat;
using (var rd = new StreamReader(Assembly.GetExecutingAssembly().GetRequiredResourceStream(_exportPageResource)))
exportPageFormat = rd.ReadToEnd();
string exportForumStyle;
using (var rd = new StreamReader(Assembly.GetExecutingAssembly().GetRequiredResourceStream(_exportForumResource)))
exportForumStyle = rd.ReadToEnd();
return
string.Format(
exportPageFormat,
forum.Description + " [" + forum.Name + "]",
encoding.HeaderName,
exportForumStyle,
sb);
}
private static void Export2Mht(
IServiceProvider provider,
IList<IMsg> msgs,
Stream fs,
ProgressDelegate pd)
{
var encoding = Encoding.UTF8;
using (var sw = new StreamWriter(fs, Encoding.Default))
{
sw.Write(
_mhtHeader,
DateTime.Now.ToString("ddd, d MMM yyyy h:m:s zz00", CultureInfo.InvariantCulture),
encoding.HeaderName);
sw.Flush();
var htmlText = BuildHTMLPage(provider, msgs, pd, true, Encoding.UTF8);
var page = encoding.GetBytes(htmlText);
fs.Write(page, 0, page.Length);
var usedSmileFiles =
msgs
.SelectMany(msg => TextFormatter.GetSmileFiles(msg.Body))
.Distinct();
const string prefix = @"ForumImages\";
foreach (var smileName in usedSmileFiles)
{
var smileImage =
provider
.GetRequiredService<IStyleImageManager>()
.GetImage(prefix + smileName, StyleImageType.ConstSize);
var ifi = ImageFormatInfo.FromImageFormat(smileImage.RawFormat);
sw.Write(_mhtContentImageHeader, ifi.MimeType, smileName, ifi.Extension);
using (var ms = new MemoryStream())
{
smileImage.Save(ms, smileImage.RawFormat);
sw.Write(Convert.ToBase64String(ms.ToArray(), Base64FormattingOptions.InsertLineBreaks));
}
}
sw.Write(_mhtFooter);
}
}
private static void Export2HTML(IServiceProvider provider, IList<IMsg> msgs, Stream fs, ProgressDelegate pd)
{
using (var sw = new StreamWriter(fs, Encoding.Default))
sw.Write(BuildHTMLPage(provider, msgs, pd, false, Encoding.UTF8));
}
private static void Export2Text(ICollection<IMsg> msgs, Stream fs, ProgressDelegate pd)
{
var sb = new StringBuilder();
var maxCharacters = Config.Instance.ForumExportConfig.CharsPerLine;
var i = 0;
foreach (var msg in msgs)
{
sb.Append(BuildTxtString("_", ' ', ' ', maxCharacters));
sb.Append(BuildTxtString(SR.TGColumnDate
+ ": " + msg.Date, '|', '|', maxCharacters));
sb.Append(BuildTxtString(SR.TGColumnAuthor
+ ": " + msg.UserNick + " " + FormatUserClass((UserClass)msg.UserClass, false), '|', '|',
maxCharacters));
sb.Append(BuildTxtString(SR.TGColumnSubject
+ ": " + msg.Subject, '|', '|', maxCharacters));
if (msg.GetFormattedRating().Length > 0)
sb.Append(BuildTxtString(SR.TGColumnRate
+ ": " + msg.GetFormattedRating(), '|', '|', maxCharacters));
sb.Append(BuildTxtString("~", '|', '|', maxCharacters));
sb.Append(
BuildTxtString(
(Config.Instance.ForumExportConfig.ExportRemoveTags ? RemoveTags(msg.Body) : msg.Body), '|',
'|', maxCharacters));
sb.Append(BuildTxtString("_", '|', '|', maxCharacters));
sb.Append(BuildTxtString(" ", ' ', ' ', maxCharacters));
i++;
pd(i, msgs.Count);
}
var encoding = Encoding.Default;
switch (Config.Instance.ForumExportConfig.ExportPlainTextEncoding)
{
case ExportPlainTextEncoding.Default:
encoding = Encoding.Default;
break;
case ExportPlainTextEncoding.DOSCP866:
encoding = Encoding.GetEncoding(866);
break;
case ExportPlainTextEncoding.Unicode:
encoding = Encoding.Unicode;
break;
case ExportPlainTextEncoding.UTF8:
encoding = Encoding.UTF8;
break;
case ExportPlainTextEncoding.WinCP1251:
encoding = Encoding.GetEncoding(1251);
break;
}
using (var sw = new StreamWriter(fs, encoding))
{
sw.Write(sb);
sw.Flush();
}
}
public static bool ExtractEmbeddedGame( ProgressDelegate listener, ICancellable cancelObject )
{
string gameTitle, gameVersion, gameURL, username, password;
if( GetEmbeddedGameInfo( out gameTitle, out gameVersion, out gameURL, out username, out password ) && gameVersion != null )
{
var downloadPath = GetDownloadPath( gameTitle, gameVersion );
try
{
var assembly = Assembly.GetExecutingAssembly();
var stream = assembly.GetManifestResourceStream( "EmbeddedGame." + Program.Platform + ".zip" );
if( stream == null )
{
stream = assembly.GetManifestResourceStream( "EmbeddedGame.zip" );
}
if( stream != null )
{
using( stream )
{
try
{
using( var progressStream = new ProgressStream( stream, -1, listener, cancelObject ) )
{
// Delete old download
if( File.Exists( downloadPath ) )
{
File.Delete( downloadPath );
}
// Create new download
try
{
Directory.CreateDirectory( Path.GetDirectoryName( downloadPath ) );
using( var output = File.OpenWrite( downloadPath ) )
{
try
{
progressStream.CopyTo( output );
}
finally
{
output.Close();
}
}
}
finally
{
progressStream.Close();
}
}
}
finally
{
stream.Close();
}
}
return true;
}
return false;
}
catch( IOException )
{
if( File.Exists( downloadPath ) )
{
File.Delete( downloadPath );
}
return false;
}
}
return false;
}
public void Progress(double pctComplete)
{
if (this.InvokeRequired)
{
ProgressDelegate del = new ProgressDelegate(Progress);
this.Invoke(del, new object[] { pctComplete });
}
else
{
progressbar.Value = (int)pctComplete;
}
}
public void RegisterForProgress(HttpRequestMessage request, ProgressDelegate callback)
{
throw new Exception(wrongVersion);
}
public static bool DownloadGame( string gameTitle, string gameVersion, string url, string username, string password, ProgressDelegate listener, ICancellable cancelObject, out bool o_authFailure, out string o_customMessage )
{
if( url == null )
{
o_authFailure = false;
o_customMessage = null;
return false;
}
var downloadPath = GetDownloadPath( gameTitle, gameVersion );
try
{
var request = HttpWebRequest.Create( url );
request.Timeout = 15000;
if( username != null && password != null )
{
request.Credentials = new NetworkCredential( username, password );
}
using( var response = request.GetResponse() )
{
// Read the message
o_customMessage = response.Headers.Get( "X-IndieLauncher-Message" );
// Read the content
using( var stream = new ProgressStream( response.GetResponseStream(), response.ContentLength, listener, cancelObject ) )
{
try
{
// Delete old download
if( File.Exists( downloadPath ) )
{
File.Delete( downloadPath );
}
// Create new download
Directory.CreateDirectory( Path.GetDirectoryName( downloadPath ) );
using( var output = File.OpenWrite( downloadPath ) )
{
try
{
stream.CopyTo( output );
}
finally
{
output.Close();
}
}
}
finally
{
stream.Close();
}
}
}
o_authFailure = false;
return true;
}
catch( IOException )
{
if( File.Exists( downloadPath ) )
{
File.Delete( downloadPath );
}
o_customMessage = null;
o_authFailure = false;
return false;
}
catch( WebException e )
{
if( File.Exists( downloadPath ) )
{
File.Delete( downloadPath );
}
if( e.Response != null )
{
o_customMessage = e.Response.Headers.Get( "X-IndieLauncher-Message" );
if( ((HttpWebResponse)e.Response).StatusCode == HttpStatusCode.Unauthorized )
{
o_authFailure = true;
}
else
{
o_authFailure = false;
}
}
else
{
o_customMessage = null;
o_authFailure = false;
}
return false;
}
}
