private void doProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(sender, e);
}
}
private void HandleProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(this, e);
}
}
private void _backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(this, e);
}
}
protected virtual void OnProgressChanged(string message, int progress)
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(this, new ProgressChangedEventArgs(message, progress));
}
}
private void OnProgressEvent(ProgressEventArgs eventArgs)
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(this, eventArgs);
}
}
private void SharedTestTimerOnElapsed(object sender, ElapsedEventArgs e)
{
if (IsTestRunning)
{
if (IsTestCanceled)
{
IsTestRunning = false;
IsTestCanceled = true;
TestComplete.Invoke(TestSysResult.Canceled);
}
else if (e.SignalTime - BeginTime > _testTimeout)
{
// timeout
IsTestRunning = false;
ProgressChanged.Invoke(100, TestSysStepResult.Bad, "МУК не включает Emerson");
TestComplete.Invoke(TestSysResult.Fail);
}
else
{
if (LastReceivedData.Diagnostic3Parsed.MukIsSwitchingEmersionOn)
{
IsTestRunning = false;
LastReceivedData = null;
ProgressChanged.Invoke(100, TestSysStepResult.Good, "Включение Emerson осуществлено");
TestComplete.Invoke(TestSysResult.Success);
}
}
}
}
public ScreenCaptureWorker(IScreenCaptureService screenCaptureService, Size canvasBounds, int captureFps, int idleTimeout) : base(idleTimeout)
{
_screenCaptureService = screenCaptureService;
CaptureInterval = CalculateHaltInterval(captureFps);
CanvasBounds = canvasBounds;
ProgressHandler = new Progress <ScreenCaptureProgressArgs>(progressArgs =>
{
ProgressChanged.Invoke(this, progressArgs);
});
}
public ScreenCaptureWorker(IScreenCaptureService screenCaptureService, int captureInterval)
{
_screenCaptureService = screenCaptureService;
CaptureInterval = captureInterval;
_progressHandler = new Progress <ScreenCaptureProgressArgs>(progressArgs =>
{
ProgressChanged.Invoke(this, progressArgs);
});
}
private void EndGetStreamCallback(IAsyncResult ar)
{
FtpState state = (FtpState)ar.AsyncState;
Stream requestStream = null;
// End the asynchronous call to get the request stream.
try
{
requestStream = state.Request.EndGetRequestStream(ar);
// Copy the file contents to the request stream.
const int bufferLength = 2048;
byte[] buffer = new byte[bufferLength];
int count = 0;
int readBytes = 0;
FileStream stream = File.OpenRead(state.FileName);
do
{
readBytes = stream.Read(buffer, 0, bufferLength);
requestStream.Write(buffer, 0, readBytes);
count += readBytes;
Ctrl.Invoke(new Action(delegate()
{
if (ProgressChanged != null)
{
ProgressChanged.Invoke(this, new ProgressEventArgs(stream.Length, count, readBytes));
}
}));
}while (readBytes != 0);
stream.Close();
Console.WriteLine("Writing {0} bytes to the stream.", count);
// IMPORTANT: Close the request stream before sending the request.
requestStream.Close();
// Asynchronously get the response to the upload request.
state.Request.BeginGetResponse(
new AsyncCallback(EndGetResponseCallback),
state
);
}
// Return exceptions to the main application thread.
catch (Exception e)
{
if (UploadError != null)
{
ThreadExceptionEventArgs arg = new ThreadExceptionEventArgs(e);
UploadError.Invoke(this, arg);
}
}
}
/// <summary>
/// Creates the entire database of songs based on user's music collection
/// </summary>
/// <returns></returns>
public static async Task CheckMusicCollection()
{
if (LoadCollectionCompleted == false)
{
return;
}
LoadCollectionCompleted = false;
IReadOnlyList <StorageFile> musicFiles = await StorageHelper.ScanFolder(KnownFolders.MusicLibrary);
bool result = RefreshDatabase();
StorageFolder coversFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Covers", CreationCollisionOption.OpenIfExists);
Song aux = null;
int totalCount = musicFiles.Count;
double currentValue = 0;
double percentagePerItem = Convert.ToDouble(100) / Convert.ToDouble(totalCount);
List <Song> listOfSongs = new List <Song>();
foreach (StorageFile file in musicFiles)
{
if (Stop)
{
Stop = false;
break;
}
aux = await CreateSongObjectByFile(file, listOfSongs);
if (aux != null)
{
listOfSongs.Add(aux);
}
currentValue = currentValue + percentagePerItem;
ProgressChanged.Invoke(Convert.ToInt16(currentValue), true);
}
ProgressChanged.Invoke(100, false);
ApplicationSettings.IsCollectionLoaded = true;
LoadCollectionCompleted = true;
}
void onTick()
{
if (workPermited)
{
ticksDone++;
ProgressChanged.Invoke();
if (ticksDone >= ticksNeed)
{
ticksDone = 0;
Timer.OneSecond -= onTick;
output.AddOutput();
startTicking();
}
}
}
public IEnumerable <DbAlbum> ReadAlbums()
{
this.StartedReadingAlbums.Invoke();
int counter = 0;
foreach (var album in _deserializedAlbums)
{
counter++;
yield return(album);
ProgressChanged.Invoke(counter, _deserializedAlbums.Count);
}
FinishedReadingAlbums.Invoke();
}
void IYieldFrame.Update(float delta, uint frameCount)
{
_time -= delta;
Value01 = 1f - Mathf.Clamp01(_time / _seconds);
if (ProgressChanged != null)
{
ProgressChanged.Invoke(Value01);
}
if (!keepWaiting)
{
if (Complete != null)
{
Complete.Invoke();
}
}
}
public IEnumerable <DbAlbum> ReadAlbums(SortOrder sortOrder)
{
this.StartedReadingAlbums.Invoke();
uint sortAtom = 0;
switch (sortOrder)
{
case SortOrder.DateAdded:
sortAtom = (uint)SchemaMap.kiIndex_DateAdded;
break;
case SortOrder.Album:
sortAtom = (uint)SchemaMap.kiIndex_Title;
break;
case SortOrder.Artist:
sortAtom = (uint)SchemaMap.kiIndex_DisplayArtist;
break;
default:
throw new ArgumentOutOfRangeException("sortOrder");
}
//querying all albums, creates a property bag inside this method to query the database
ZuneQueryList albums = GetAlbumQueryListSorted(sortAtom);
albums.AddRef();
var uniqueIds = albums.GetUniqueIds();
for (int i = 0; i < uniqueIds.Count; i++)
{
object uniqueId = uniqueIds[i];
yield return(GetAlbumMin((int)uniqueId));
ProgressChanged.Invoke(i, uniqueIds.Count - 1);
}
FinishedReadingAlbums.Invoke();
albums.Release();
albums.Dispose();
}
private void informAboutProgressChange(int depencyIndex, string depencyName, int progress = -1)
{
if (ProgressChanged == null)
{
return;
}
ProgressState ps = new ProgressState()
{
Progress = progress
};
if (progress < 0)
{
ps.AllDepenciesCount = _allDependencies.Count;
ps.CurrentDepencyName = depencyName;
ps.Extracting = false;
ps.FinishedCount = depencyIndex;
}
Task.Run(() => ProgressChanged.Invoke(ps));
}
public void OnProgressChanged(ProgressChangedEventArgs e)
{
ProgressChanged.Invoke(this, e);
}
protected virtual void OnProgressChanged(object sender, ProgressChangedArgs e) => ProgressChanged?.Invoke(sender, e);
private void OnProgressChanged(ProgressData progressData) => ProgressChanged?.Invoke(this, progressData);
public void OnProgressChanged(SeekBar seekBar, int val, bool b)
{
ProgressChanged?.Invoke(seekBar, val, b);
}
public void Report(double progress)
{
ProgressChanged.Invoke(this, new ProgressEventArgs(progress));
}
public void ReportAdd(long value)
{
Progress += value;
ProgressChanged?.Invoke(Progress);
}
public void Import(Project to, Project from, Mode mode = Mode.Group)
{
if (from == null)
{
throw new ArgumentNullException(nameof(from));
}
if (to == null)
{
throw new ArgumentNullException(nameof(to));
}
if (from.Equals(to))
{
throw new FieldAccessException();
}
var count = 0;
int processes;
void notifyProgress()
{
ProgressChanged.Invoke(1F * count / processes);
}
if (mode == Mode.Group)
{
processes = from.Groups.Count;
if (from.Encryted)
{
processes += from.DailyAdmins.Count;
from.DailyAdmins.ForEach((it) =>
{
if (!to.DailyAdmins.Contains(it))
{
to.DailyAdmins.Add(it);
}
count++;
notifyProgress();
});
}
foreach (Group g in from.Groups)
{
Group sameName = to.Groups.Find((it) => it.Name == g.Name);
if (sameName == null)
{
var clone = g.Clone() as Group;
clone.Record.Clear();
to.Groups.Add(clone);
}
else
{
bool cancel = false;
switch (GroupDuplicated.Invoke(sameName, g))
{
case DialogResult.Yes:
foreach (Person p in g.People)
{
Person duplicate = sameName.People.Find((it) => it.Name == p.Name);
if (duplicate == null)
{
sameName.People.Add(p);
}
else
{
switch (MemberDuplicated.Invoke(duplicate, p))
{
case DialogResult.Yes:
sameName.People.Remove(duplicate);
sameName.People.Add(p);
break;
case DialogResult.Cancel:
cancel = true;
break;
default:
break;
}
}
if (cancel)
{
break;
}
}
if (!cancel)
{
sameName.InitalScore = g.InitalScore;
sameName.ChosenColor = System.Drawing.Color.FromArgb(g.ChosenColor.ToArgb());
}
break;
case DialogResult.Cancel:
cancel = true;
break;
default:
break;
}
if (cancel)
{
break;
}
}
count++;
notifyProgress();
}
}
else
{
var people = new List <Person>();
foreach (Group g in from.Groups)
{
g.People.ForEach((person) => people.Add(person));
}
processes = people.Count;
foreach (Person person in people)
{
var find = to.FindPerson(person.ID);
if (find != null)
{
person.Record.ForEach((r) =>
{
if (!find.Group.Record.Exists((it) => it.Time == r.Time))
{
find.Group.Record.Add(new Score(r.Value, r.Reason, find.ID, r.Time, to));
}
});
}
count++;
notifyProgress();
}
}
}
private void OnProgressChanged(int current, int max, object data = null)
{
ProgressChanged?.Invoke(this, new Tuple <int, int, object>(current, max, data));
}
public FFmpegDownloadViewModel(FFmpegSettings FFmpegSettings,
FFmpegDownloadModel DownloadModel,
IFFmpegViewsProvider FFmpegViewsProvider,
IMessageProvider MessageProvider)
{
this.FFmpegSettings = FFmpegSettings;
_downloadModel = DownloadModel;
_messageProvider = MessageProvider;
StartCommand = _downloaderProgress
.Select(M => M.State)
.Select(M => M == FFmpegDownloaderState.Ready)
.ToReactiveCommand()
.WithSubscribe(async() =>
{
var progress = new Progress <FFmpegDownloaderProgress>(M => _downloaderProgress.Value = M);
_downloadTask = DownloadModel.Start(progress);
var result = await _downloadTask;
AfterDownload?.Invoke(result);
});
CanCancel = _downloaderProgress
.Select(M => M.State)
.Select(M => M == FFmpegDownloaderState.Downloading)
.ToReadOnlyReactivePropertySlim();
SelectFolderCommand = _downloaderProgress
.Select(M => M.State)
.Select(M => M == FFmpegDownloaderState.Ready)
.ToReactiveCommand()
.WithSubscribe(FFmpegViewsProvider.PickFolder);
OpenFolderCommand = new ReactiveCommand()
.WithSubscribe(() =>
{
var path = FFmpegSettings.GetFolderPath();
if (Directory.Exists(path))
{
Process.Start(path);
}
});
Status = _downloaderProgress
.Select(M =>
{
switch (M.State)
{
case FFmpegDownloaderState.Error:
return(M.ErrorMessage);
case FFmpegDownloaderState.Downloading:
return($"{FFmpegDownloaderState.Downloading} ({M.DownloadProgress}%)");
default:
return(M.State.ToString());
}
})
.ToReadOnlyReactivePropertySlim();
Progress = _downloaderProgress
.Where(M => M.State == FFmpegDownloaderState.Downloading)
.Select(M => M.DownloadProgress)
.ToReadOnlyReactivePropertySlim();
Progress.Subscribe(M => ProgressChanged?.Invoke(M));
InProgress = _downloaderProgress
.Select(M => M.State)
.Select(M => M == FFmpegDownloaderState.Downloading || M == FFmpegDownloaderState.Extracting)
.ToReadOnlyReactivePropertySlim();
IsDone = _downloaderProgress
.Select(M => M.State)
.Select(M => M == FFmpegDownloaderState.Done || M == FFmpegDownloaderState.Cancelled || M == FFmpegDownloaderState.Error)
.ToReadOnlyReactivePropertySlim();
}
private void Downloader_DownloadProgressChangedEvent(object sender, ProgressChangedEventArgs e)
{
ProgressChanged?.Invoke(this, e);
}
private void progressChanged(DownloadOperation downloadOperation)
{
int progress = (int)(100 * ((double)downloadOperation.Progress.BytesReceived / (double)downloadOperation.Progress.TotalBytesToReceive));
ProgressChanged.Invoke(this, progress);
}
private void Z_ProgressEvent(object sender, int e)
{
ProgressChanged?.Invoke(this, new ProgressChangedEventArgs(e, null));
}
protected void OnLoadProgressChanged(ProgressChangedEventArgs e)
{
ProgressChanged.Invoke(this, e);
}
private void Szip_ProgressChange(object sender, ProgressChangedEventArgs e)
{
ProgressChanged?.Invoke(this, e);
}
protected void ChangeProgress(Progress progress)
{
ProgressChanged?.Invoke(this, new EventArgs <Progress>(progress));
}
