/// <summary> /// A function that can be used as CopyProgressRoutine delegate and is passed into the win32 method /// </summary> /// <param name="TotalFileSize"></param> /// <param name="TotalBytesTransferred"></param> /// <param name="StreamSize"></param> /// <param name="StreamBytesTransferred"></param> /// <param name="notUsed"></param> /// <param name="CallbackReason"></param> /// <param name="sourceFileHandle"></param> /// <param name="destinationFileHandle"></param> /// <param name="notUsed2"></param> /// <returns></returns> private CopyProgressResult CopyProgressFunc( long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint notUsed, CopyProgressCallbackReason CallbackReason, IntPtr sourceFileHandle, IntPtr destinationFileHandle, IntPtr notUsed2 ) { var streamSize = StreamSize; var streamBytesTrans = StreamBytesTransferred; _totalFileSize = TotalFileSize; var progressResult = CopyProgressResult.PROGRESS_CONTINUE; if (CallbackReason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { var fileMoveEventArgs = new FileMoveProgressArgs(TotalFileSize, TotalBytesTransferred); ProgressCallback(fileMoveEventArgs); if (fileMoveEventArgs.Cancelled) { progressResult = CopyProgressResult.PROGRESS_CANCEL; } } return(progressResult); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { switch (reason) { case CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED: m_dtElapsedTime = DateTime.Now - m_dtStartTime; EventCopyHandler(this, new CopyEventArgs(((double)transferred / total) * 100, (transferred / 1024) / m_dtElapsedTime.TotalSeconds)); return m_bCancel ? CopyProgressResult.PROGRESS_CANCEL : CopyProgressResult.PROGRESS_CONTINUE; default: return CopyProgressResult.PROGRESS_CONTINUE; } }
public CopyProgressResult CopyProgressRoutine( long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { return(progressUpdate(State, TotalFileSize, TotalBytesTransferred)); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (_nMilisecondPeriodToDelay < DateTime.Now.Subtract(_dtLastDelay).TotalMilliseconds) { _dtLastDelay = DateTime.Now; nIndex++; System.Threading.Thread.Sleep(_nDelay); } //_nChunkIndx++; //if (_nChunkIndx % _nChanksPeriodToDelay == 0) // System.Threading.Thread.Sleep(_nDelay); return CopyProgressResult.PROGRESS_CONTINUE; }
private CopyProgressResult CancelableCopyProgressRoutine( long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { return(cancel ? CopyProgressResult.PROGRESS_CANCEL : CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { OnProgressChanged(transferred, total); } if (transferred >= total) { OnCompleted(); } return(CopyProgressResult.PROGRESS_CONTINUE); }
int copyProgress(long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, int streamNumber, CopyProgressCallbackReason callbackReason, IntPtr sourceFile, IntPtr destinationFile, IntPtr data) { int fileProgress = (int)((100 * totalBytesTransferred) / totalFileSize); GCHandle h = GCHandle.FromIntPtr(data); CancellableOperationProgressBase progress = (CancellableOperationProgressBase)h.Target; if (fileProgress != progress.ItemProgress) { progress.ItemProgress = fileProgress; } CopyFileCallbackAction action = progress.CancellationToken.IsCancellationRequested ? CopyFileCallbackAction.CANCEL : CopyFileCallbackAction.CONTINUE; return((int)action); }
private CopyProgressResult CopyProgressRoutineImpl( long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { var current = totalBytesTransferred - _transferred; if (current > 1000000) { _progress?.Invoke(current, totalBytesTransferred); _transferred = totalBytesTransferred; } return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { CopyProgressResult result = CopyProgressResult.PROGRESS_CONTINUE; if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { result = OnProgressChanged((transferred / (double)total) * 100.0); } if (transferred >= total) { OnCompleted(); } if (result == CopyProgressResult.PROGRESS_CANCEL) { IsCancelled = 1; } return(result); }
private CopyProgressResult CopyProgressRoutineInternal(long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (FileCopyProgress != null) { FileCopyProgress(new FileCopyProgressEventArgs { TransferredBytes = TotalBytesTransferred, TotalBytes = TotalFileSize, SourceFile = sourceFile, DestinationFile = destinationFile, ProgressPercentage = (int)((double)TotalBytesTransferred / TotalFileSize * 100) }); } if (TotalFileSize == TotalBytesTransferred) { if (FileCopyCompleted != null) { FileCopyCompleted(new FileCopyCompletedEventArgs { CopiedFiles = copiedFiles, TotalFiles = totalFiles, SourceFile = sourceFile, DestinationFile = destinationFile }); } } if (cancelCopyOperation) { CopyCancelled(); return(CopyProgressResult.PROGRESS_CANCEL); } else { return(CopyProgressResult.PROGRESS_CONTINUE); } }
private CopyProgressResult CopyProgressHandler( long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, uint streamNumber, CopyProgressCallbackReason callbackReason, IntPtr sourceFileHandle, IntPtr destinationFileHandle, IntPtr dataPtr) { if (callbackReason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { bool cancel; OnProgressChanged((double)totalBytesTransferred / totalFileSize * 100, out cancel); if (cancel) { return(CopyProgressResult.PROGRESS_CANCEL); } } return(CopyProgressResult.PROGRESS_CONTINUE); }
/// <summary> /// Delegate which will be called by Win32 API for progress change /// </summary> /// <param name="total">the total size</param> /// <param name="transferred">the transferrred size</param> /// <param name="streamSize">size of the stream</param> /// <param name="streamByteTrans"></param> /// <param name="dwStreamNumber">stream number</param> /// <param name="reason">reason for callback</param> /// <param name="hSourceFile">the source file handle</param> /// <param name="hDestinationFile">the destination file handle</param> /// <param name="lpData">data passed by users</param> /// <returns>indicating whether to continue or do somthing else.</returns> private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //when a chunk is finished call the progress changed. if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { OnProgressChanged((transferred / (double)total) * 100.0); } //transfer completed if (transferred >= total) { if (CloseHandle(hDestinationFile)) { OnCompleted(CopyCompletedType.Succeeded, null); } else { OnCompleted(CopyCompletedType.Exception, new System.IO.IOException("Unable to close the file handle")); } } return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //Debug.WriteLine("Total: " + total); Total = total; //Debug.WriteLine("Transferred: " + transferred); Transferred = transferred; return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { while (!_bCancelCopying && (_bPause || _bPauseFile)) { System.Threading.Thread.Sleep(300); } if (_bCancelCopying) { return(CopyProgressResult.PROGRESS_CANCEL); } _nTotalSize = total; if (transferred >= total) //transfer completed { //if file is read only, remove read-only attribute(case to handle CD drive import) //FileAttributes attr = File.GetAttributes(destinationFilePath); //if ((attr & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) //{ // attr = attr & ~FileAttributes.ReadOnly; // File.SetAttributes(destinationFilePath, attr); //} _nProgressPercent = 100F; bCompleted = true; if (null != _OnProgressChanged) { _OnProgressChanged(_nProgressPercent); } } else { if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { //_nChunkIndx++; //if (_nChunkIndx % _nChunksPeriod == 0) // можно раз во сколько-то чанков что-то делать // {} if (transferred > _nBytesNextPoint) // а лучше раз во сколько-то байт { _nBytesNextPoint += _nBytesPeriod; _nProgressPercent = (float)((transferred / (double)total) * 100.0); if (null != _OnProgressChanged) { _OnProgressChanged(_nProgressPercent); } } if (_nMilisecondPeriodToDelay > 0 && _dtNextDelay < DateTime.Now) // а можно раз во сколько-то миллисекунд что-то делать { _nDelayTotal += _nDelay; System.Threading.Thread.Sleep(_nDelay); _dtNextDelay = DateTime.Now.AddMilliseconds(_nMilisecondPeriodToDelay); } } } return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { // Mikant int currentProgress = (int)((transferred / (float)total) * 100); if (this.InvokeRequired) { this.Invoke(UpdateUI, currentProgress); } else { UpdateUI(currentProgress); } // !Mikant return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { // notify client SendProgressChangedMessage(currentSource, currentDestination, total, transferred); return CopyProgressResult.PROGRESS_CONTINUE; }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { double percentage = transferred * 100.0 / total; OnProgressChanged(percentage); return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) OnProgressChanged((transferred / (double)total) * 100.0); if (transferred >= total) OnCompleted(); return CopyProgressResult.PROGRESS_CONTINUE; }
private CopyProgressResult CopyProgressHandler(Int64 total, Int64 transferred, Int64 streamSize, Int64 StreamByteTrans, UInt32 dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //Check to see if there is a dialog window to use if (digWindow != null) { //Are we going to send the update on the correct thread? if (digWindow.SynchronizationObject != null && digWindow.SynchronizationObject.InvokeRequired) { digWindow.SynchronizationObject.Invoke(new CopyProgressRoutine(CopyProgressHandler), new Object[] { total, transferred, streamSize, StreamByteTrans, dwStreamNumber, reason, hSourceFile, hDestinationFile, lpData }); } else { digWindow.update(totalFiles, totalFilesCopied, total, transferred, currentFilename); } } return CopyProgressResult.PROGRESS_CONTINUE; }
/// <summary> /// Delegate which will be called by Win32 API for progress change /// </summary> /// <param name="total">the total size</param> /// <param name="transferred">the transferrred size</param> /// <param name="streamSize">size of the stream</param> /// <param name="streamByteTrans"></param> /// <param name="dwStreamNumber">stream number</param> /// <param name="reason">reason for callback</param> /// <param name="hSourceFile">the source file handle</param> /// <param name="hDestinationFile">the destination file handle</param> /// <param name="lpData">data passed by users</param> /// <returns>indicating whether to continue or do somthing else.</returns> private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //when a chunk is finished call the progress changed. if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { OnProgressChanged((transferred / (double)total) * 100.0); } //transfer completed if (transferred >= total) { if (CloseHandle(hDestinationFile)) { OnCompleted(CopyCompletedType.Succeeded, null); } else { OnCompleted(CopyCompletedType.Exception, new System.IO.IOException("Unable to close the file handle")); } } return CopyProgressResult.PROGRESS_CONTINUE; }
private CopyProgressResult CopyProgressHandler(Int64 total, Int64 transferred, Int64 streamSize, Int64 StreamByteTrans, UInt32 dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //Check to see if there is a dialog window to use if (_digWindow != null) { //Are we going to send the update on the correct thread? if (_digWindow.SynchronizationObject != null && _digWindow.SynchronizationObject.InvokeRequired) { _digWindow.SynchronizationObject.Invoke(new CopyProgressRoutine(CopyProgressHandler), new Object[] { total, transferred, streamSize, StreamByteTrans, dwStreamNumber, reason, hSourceFile, hDestinationFile, lpData }); } else { _digWindow.Update(_totalFiles, _totalFilesCopied, total, transferred, _currentFilename); } } return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { return CopyProgressResult.PROGRESS_CONTINUE; }
/// <summary> /// CopyProgressRoutineHandler gives the progress of the file currently being copied /// </summary> /// <param name="TotalFileSize">Total size of the file in bytes</param> /// <param name="TotalBytesTransferred">The size in bytes that has been copied</param> /// <param name="StreamSize">Total Size in bytes of the current stream that is being copied</param> /// <param name="StreamBytesTransferred">The size in bytes that has been copied</param> /// <param name="dwStreamNumber"></param> /// <param name="dwCallbackReason"></param> /// <param name="hSourceFile">Pointer to the Source File</param> /// <param name="hDestinationFile">Pointer to the Destination File</param> /// <param name="lpData"></param> /// <returns>Returns the progress status of the file being copied</returns> private CopyProgressResult CopyProgressRoutineHandler(Int64 TotalFileSize, Int64 TotalBytesTransferred, Int64 StreamSize, Int64 StreamBytesTransferred, UInt32 StreamNumber, CopyProgressCallbackReason CallbackReason, IntPtr SourceFile, IntPtr DestinationFile, IntPtr Data) { resetEvent.WaitOne(); switch (CallbackReason) { case CopyProgressCallbackReason.CallbackChunkedFinished: this.copiedSize += TotalBytesTransferred - previousCopiedSize; RaiseFileCopyProgressEvent(this.CurrentFile, TotalBytesTransferred, TotalFileSize); this.RaiseCopyProgressEvent(); previousCopiedSize = TotalBytesTransferred; break; case CopyProgressCallbackReason.CallbackStreamSwitch: break; default: break; } return((skip) ? CopyProgressResult.ProgressCancel : CopyProgressResult.ProgressContinue); }
private CopyProgressResult CopyProgressHandler( long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, uint streamNumber, CopyProgressCallbackReason callbackReason, IntPtr sourceFileHandle, IntPtr destinationFileHandle, IntPtr dataPtr) { if (callbackReason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED) { bool cancel; OnProgressChanged((double)totalBytesTransferred / totalFileSize * 100, out cancel); if (cancel) { return CopyProgressResult.PROGRESS_CANCEL; } } return CopyProgressResult.PROGRESS_CONTINUE; }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { long percent = (transferred * 100) / total; updateProgress(percent); Application.DoEvents(); if (cancelouCopia) { return(CopyProgressResult.PROGRESS_CANCEL); } else { return(CopyProgressResult.PROGRESS_CONTINUE); } }
/// <summary> /// Default handler for <see cref="XCopy" />. /// </summary> /// <param name="total"></param> /// <param name="transferred"></param> /// <param name="streamSize"></param> /// <param name="StreamByteTrans"></param> /// <param name="dwStreamNumber"></param> /// <param name="reason"></param> /// <param name="hSourceFile"></param> /// <param name="hDestinationFile"></param> /// <param name="lpData"></param> /// <returns></returns> public static CopyProgressResult CopyProgressHandler(Int64 total, Int64 transferred, Int64 streamSize, Int64 StreamByteTrans, DWORD dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) => CopyProgressResult.PROGRESS_CONTINUE;
private static CopyProgressResult EmptyCopyProgressHandler( long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { //calculate progress int iProgress; iProgress = (int)(((float)transferred / (float)total) * 100); Progress(this, new ProgressEventArgs(iProgress)); return(CopyProgressResult.PROGRESS_CONTINUE); }
int copyProgress(long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, int streamNumber, CopyProgressCallbackReason callbackReason, IntPtr sourceFile, IntPtr destinationFile, IntPtr data) { int fileProgress = (int)((100 * totalBytesTransferred) / totalFileSize); GCHandle h = GCHandle.FromIntPtr(data); CancellableOperationProgressBase progress = (CancellableOperationProgressBase)h.Target; if (fileProgress != progress.ItemProgress) { progress.ItemProgress = fileProgress; } CopyFileCallbackAction action = progress.CancellationToken.IsCancellationRequested ? CopyFileCallbackAction.CANCEL : CopyFileCallbackAction.CONTINUE; return ((int)action); }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (_pbCancel == 0) { float progress = 100 * transferred / total; _Copy_Progress(progress); _trasferedSize(transferred); return(CopyProgressResult.PROGRESS_CONTINUE); } else { return(CopyProgressResult.PROGRESS_CANCEL); } }
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { OnPropertyChanged(transferred, _fileName); return(CopyProgressResult.PROGRESS_CONTINUE); }
private CopyProgressResult CopyProgress(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData) { if (this.progress(total, transferred)) { return(CopyProgressResult.PROGRESS_CONTINUE); } else { return(CopyProgressResult.PROGRESS_CANCEL); } }