private static void TaskbarSetProgressState(Form form, TaskbarProgressBarState tbps)
{
if (form != null && WindowHandle != IntPtr.Zero && TaskbarManager.IsPlatformSupported && WindowsTaskbar != null)
{
WindowsTaskbar.SetProgressState(tbps, windowHandle: WindowHandle);
}
}
/// <summary>
/// Public Method to set the Progress of the Taskbar Progressbar.
/// </summary>
/// <param name="Progress">Current Progress</param>
/// <param name="Maximum">Maximum for Progressbar</param>
public static void SetProgressValue(int Progress, int Maximum)
{
TaskbarProgressBarState state = TaskbarProgressBarState.Normal;
TaskbarManager.Instance.SetProgressState(state);
TaskbarManager.Instance.SetProgressValue(Progress, Maximum);
}
public static void TaskbarSetProgressState(Form form, TaskbarProgressBarState tbps)
{
if (form != null && form.ShowInTaskbar && TaskbarManager.IsPlatformSupported && Engine.zWindowsTaskbar != null)
{
Engine.zWindowsTaskbar.SetProgressState(tbps);
}
}
public static void TaskbarSetProgressState(TaskbarProgressBarState tbps)
{
if (TaskbarManager.IsPlatformSupported && Engine.zWindowsTaskbar != null)
{
Engine.zWindowsTaskbar.SetProgressState(tbps);
}
}
public static void SetProgressState(TaskbarProgressBarState state)
{
if (Microsoft.WindowsAPICodePack.Taskbar.TaskbarManager.IsPlatformSupported)
{
Microsoft.WindowsAPICodePack.Taskbar.TaskbarManager.Instance.SetProgressState((Microsoft.WindowsAPICodePack.Taskbar.TaskbarProgressBarState)state);
}
}
private static void TaskbarSetProgressState(Form form, TaskbarProgressBarState tbps)
{
if (form != null && WindowHandle != IntPtr.Zero && TaskbarManager.IsPlatformSupported && WindowsTaskbar != null)
{
WindowsTaskbar.SetProgressState(tbps, windowHandle: WindowHandle);
}
}
public static void SetState(Process process, TaskbarProgressBarState state)
{
if (process != null && !process.HasExited)
{
taskbar.SetProgressState(state, process.MainWindowHandle);
}
}
private ITaskbarItem SetProgressState(TaskbarProgressBarState state)
{
#if !__MonoCS__
_taskbarManager.SetProgressState(state, _windowHandle);
#endif
return(this);
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button of the main application window.
/// </summary>
/// <param name="state">Progress state of the progress button</param>
public static void SetProgressState(TaskbarProgressBarState state)
{
if (IsPlatformSupported && ownerHandle != IntPtr.Zero)
{
TaskbarList.Instance.SetProgressState(ownerHandle, (TaskbarProgressBarStatus)state);
}
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given window handle
/// </summary>
/// <param name="windowHandle">The handle of the window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public static void SetProgressState(TaskbarProgressBarState state, IntPtr windowHandle)
{
if (IsPlatformSupported)
{
TaskbarList.Instance.SetProgressState(windowHandle, (TaskbarProgressBarStatus)state);
}
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given WPF window
/// </summary>
/// <param name="window">The window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state, System.Windows.Window window)
{
CoreHelpers.ThrowIfNotWin7();
TaskbarList.SetProgressState(
(new WindowInteropHelper(window)).Handle,
(TBPFLAG)state);
}
public static void SetProgress(TaskbarProgressBarState state, int progressValue, int maximumValue)
{
Try(taskbar =>
{
taskbar.SetProgressState(TaskbarProgressBarState.Normal);
taskbar.SetProgressValue(progressValue, maximumValue);
});
}
private void EnableServiceStateChangeProgress()
{
if (CoreHelpers.RunningOnWin7)
{
TaskbarProgressBarState state = TaskbarProgressBarState.Indeterminate;
windowsTaskbar.SetProgressState(state);
}
}
private void DisableServiceStateChangeProgress()
{
if (CoreHelpers.RunningOnWin7)
{
TaskbarProgressBarState state = TaskbarProgressBarState.NoProgress;
windowsTaskbar.SetProgressState(state);
}
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button of the main application window.
/// </summary>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state)
{
if (!IsWin7())
{
return;
}
TaskbarList.SetProgressState(OwnerHandle, (TBPFLAG)state);
}
private void comboBoxProgressBarStates_SelectedIndexChanged(object sender, EventArgs e)
{
// Update the status of the taskbar progress bar
TaskbarProgressBarState state = (TaskbarProgressBarState)(Enum.Parse(typeof(TaskbarProgressBarState),
(string)comboBoxProgressBarStates.SelectedItem));
windowsTaskbar.SetProgressState(state, this.Handle);
// Update the application progress bar,
// as well disable the trackbar in some cases
switch (state)
{
case TaskbarProgressBarState.Normal:
if (trackBar1.Value == 0)
{
trackBar1.Value = 20;
progressBar1.Value = trackBar1.Value;
}
progressBar1.Style = ProgressBarStyle.Continuous;
windowsTaskbar.SetProgressValue(trackBar1.Value, 100, this.Handle);
trackBar1.Enabled = true;
break;
case TaskbarProgressBarState.Paused:
if (trackBar1.Value == 0)
{
trackBar1.Value = 20;
progressBar1.Value = trackBar1.Value;
}
progressBar1.Style = ProgressBarStyle.Continuous;
windowsTaskbar.SetProgressValue(trackBar1.Value, 100, this.Handle);
trackBar1.Enabled = true;
break;
case TaskbarProgressBarState.Error:
if (trackBar1.Value == 0)
{
trackBar1.Value = 20;
progressBar1.Value = trackBar1.Value;
}
progressBar1.Style = ProgressBarStyle.Continuous;
windowsTaskbar.SetProgressValue(trackBar1.Value, 100, this.Handle);
trackBar1.Enabled = true;
break;
case TaskbarProgressBarState.Indeterminate:
progressBar1.Style = ProgressBarStyle.Marquee;
progressBar1.MarqueeAnimationSpeed = 30;
trackBar1.Enabled = false;
break;
case TaskbarProgressBarState.NoProgress:
progressBar1.Value = 0;
trackBar1.Value = 0;
progressBar1.Style = ProgressBarStyle.Continuous;
trackBar1.Enabled = false;
break;
}
}
public void SetProgressState(TaskbarProgressBarState state)
{
CoreHelpers.ThrowIfNotWin7();
if (OwnerHandle != IntPtr.Zero)
{
TaskbarList.SetProgressState(OwnerHandle, (TBPFLAG)state);
}
}
private void FlashProgress(TaskbarProgressBarState state)
{
this.Invoke(() =>
{
TaskbarManager.Instance.SetProgressState(state);
TaskbarManager.Instance.SetProgressValue(100, 100);
});
this.InvokeDelay(5000, () => TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.NoProgress));
}
/// <summary>
/// Updates the taskbar progressbar value.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="currentValue">The current value.</param>
/// <param name="maximumValue">The maximum value.</param>
public static void UpdateTaskbarProgressbarValue(TaskbarProgressBarState state, int currentValue, int maximumValue = 100)
{
if (TaskbarManager.IsPlatformSupported)
{
TaskbarManager.Instance.SetProgressState(state);
TaskbarManager.Instance.SetProgressValue(currentValue, maximumValue);
}
}
public static void SetProgressState(TaskbarProgressBarState state)
{
if (!goodOSVersion)
{
return;
}
TaskbarManager.Instance.SetProgressState(state);
InvokeProgressChanged(new EventArgs());
}
public static void SetProgressState(TaskbarProgressBarState state)
{
try
{
TaskbarManager.Instance?.SetProgressState(state);
}
catch
{
// Sometimes windows throws exception internally fetching progressbar and it bubbles out to here (yes, I've seen this)
}
}
public static bool SetProgressState(TaskbarProgressBarState state)
{
var hwnd = mainWindow;
if (hwnd == IntPtr.Zero)
{
return(false);
}
taskbarList.SetProgressState(hwnd, state);
return(true);
}
private void UpdateProgressState(TaskbarProgressBarState progressState)
{
if (this.InvokeRequired)
{
this.Invoke(new UpdateProgressStateHandler(UpdateProgressState), progressState);
}
if (Program.IsWindows7())
{
TaskbarManager.Instance.SetProgressState(progressState);
}
}
public static bool SetProgress(TaskbarProgressBarState state, ulong completed, ulong total)
{
var hwnd = mainWindow;
if (hwnd == IntPtr.Zero)
{
return(false);
}
var tbl = taskbarList;
tbl.SetProgressState(hwnd, state);
tbl.SetProgressValue(hwnd, completed, total);
return(true);
}
private void UpdateProgressBarState(TaskDialogProgressBarState state)
{
SendMessageHelper(TaskDialogMessage.SetProgressBarState, (int)state, 0);
if (!SupportsTaskbarProgress)
{
return;
}
TaskbarProgressBarState taskbarState = TaskbarProgressBarState.Normal;
if (state == TaskDialogProgressBarState.Error)
{
taskbarState = TaskbarProgressBarState.Error;
}
taskbarList.SetProgressState(hWndOwner, taskbarState);
}
void UpdateTaskbarState()
{
if (Config.Instance.TaskbarProgress && TaskbarManager.IsPlatformSupported)
{
TaskbarProgressBarState state = TaskbarProgressBarState.NoProgress;
if (SongPlayer.Instance.State == PlayerState.Playing)
{
state = TaskbarProgressBarState.Normal;
}
else if (SongPlayer.Instance.State == PlayerState.Paused)
{
state = TaskbarProgressBarState.Paused;
}
TaskbarManager.Instance.SetProgressState(state, Handle);
}
}
internal static TaskbarProgressBarState ConvertState(ProgressBarStyle state)
{
TaskbarProgressBarState result = TaskbarProgressBarState.NoProgress;
switch (state)
{
case ProgressBarStyle.Blocks:
case ProgressBarStyle.Continuous:
result = TaskbarProgressBarState.Normal;
break;
case ProgressBarStyle.Marquee:
result = TaskbarProgressBarState.Indeterminate;
break;
}
return(result);
}
void updateProgressBars(TaskbarProgressBarState state, int fileNum, int flashNum, int fileMax, int flashMax)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => { updateProgressBars(state, fileNum, flashNum, fileMax, flashMax); }));
}
else
{
TaskbarManager windowsTaskbar = TaskbarManager.Instance;
// check the values are in an acceptable range
fileMax = Math.Max(fileMax, 1);
fileNum = Math.Min(Math.Max(fileNum, 0), fileMax);
flashMax = Math.Max(flashMax, 1);
flashNum = Math.Min(Math.Max(flashNum, 0), flashMax);
// update text boxes
fileNumLbl.Text = "File " + fileNum + "/" + fileMax;
flashNumLbl.Text = "Flash file " + flashNum + "/" + flashMax;
updateProgressBars(state);
// update values
windowsTaskbar.SetProgressValue(fileNum, fileMax);
flashFileProgressBar.Maximum = flashMax;
flashFileProgressBar.Value = flashNum;
fileProgressBar.Maximum = fileMax;
fileProgressBar.Value = fileNum;
// force repaint
Invalidate();
// respond to events so changes are drawn
//Application.DoEvents();
}
}
void updateProgressBars(TaskbarProgressBarState state, bool updateFormPBars = true)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => { updateProgressBars(state, updateFormPBars); }));
}
else
{
TaskbarManager windowsTaskbar = TaskbarManager.Instance;
windowsTaskbar.SetProgressState(state);
if (updateFormPBars)
{
// update progress bars and task bar states
ProgressBarState pBarState = ProgressBarState.Normal;
if (state == TaskbarProgressBarState.Error)
{
pBarState = ProgressBarState.Error;
}
else if (state == TaskbarProgressBarState.Paused)
{
pBarState = ProgressBarState.Paused;
}
else if (state == TaskbarProgressBarState.NoProgress)
{
flashFileProgressBar.Value = 0;
fileProgressBar.Value = 0;
}
ModifyProgressBarColour.SetState(flashFileProgressBar, pBarState);
ModifyProgressBarColour.SetState(fileProgressBar, pBarState);
}
Invalidate();
}
}
public static void SetTaskbarItemProgress(IntPtr windowPointer, TaskbarProgressBarState progressState, double progressPercentage)
{
if (progressPercentage != 0)
{
int value = (int)(progressPercentage * 1000);
if (value > 1000)
{
value = 1000;
}
else if (value < 0)
{
value = 0;
}
TaskbarManager.Instance.SetProgressValue(value, 1000, windowPointer);
}
else
{
TaskbarManager.Instance.SetProgressValue(0, 0, windowPointer);
}
TaskbarManager.Instance.SetProgressState(progressState, windowPointer);
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given WPF window
/// </summary>
/// <param name="window">The window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state, System.Windows.Window window)
{
CoreHelpers.ThrowIfNotWin7();
TaskbarList.SetProgressState(
(new WindowInteropHelper(window)).Handle,
(TBPFLAG)state);
}
public void SetProgressState(TaskbarProgressBarState state)
{
CoreHelpers.ThrowIfNotWin7();
if (OwnerHandle != IntPtr.Zero)
TaskbarList.SetProgressState(OwnerHandle, (TBPFLAG)state);
}
public void TaskBarProgressState(TaskbarProgressBarState Status)
{
try
{
TaskbarManager.Instance.SetProgressState(Status);
}
catch { }
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given WPF window
/// </summary>
/// <param name="window">The window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state, System.Windows.Window window)
{
TaskbarList.Instance.SetProgressState(
(new WindowInteropHelper(window)).Handle,
(TaskbarProgressBarStatus)state);
}
public void SetTaskbarProgessState(TaskbarProgressBarState State)
{
if (!_taskbarsupport) return;
_taskbar.SetProgressState(State);
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given window handle
/// </summary>
/// <param name="windowHandle">The handle of the window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state, IntPtr windowHandle)
{
CoreHelpers.ThrowIfNotWin7();
TaskbarList.SetProgressState(windowHandle, (TBPFLAG)state);
}
private ITaskbarItem SetProgressState(TaskbarProgressBarState state)
{
#if !__MonoCS__
_taskbarManager.SetProgressState(state, _windowHandle);
#endif
return this;
}
public void SetProgressState(TaskbarProgressBarState state)
{
if (!Taskbar.m_isWin7) return;
this.m_state = state;
this.m_taskbarList.SetProgressState(this.OwnerHandle, (WinAPIs.TBPFLAG)state);
}
public static void TaskbarSetProgressState(TaskbarProgressBarState tbps)
{
TaskbarSetProgressState(Program.MainForm, tbps);
}
/// <summary> /// Sets the type and state of the progress indicator displayed on a taskbar button of the main application window. /// </summary> /// <param name="state">Progress state of the progress button.</param> public abstract void SetProgressState(TaskbarProgressBarState state);
public static void TaskbarSetProgressState(TaskbarProgressBarState tbps)
{
TaskbarSetProgressState(Program.MainForm, tbps);
}
/// <summary>
/// Refreshes the native taskbar with the current progressbar state for the given HWND
/// </summary>
/// <param name="hwnd">Current window handle</param>
/// <param name="state">Current progress bar state</param>
internal void RefreshState(IntPtr hwnd, TaskbarProgressBarState state)
{
TaskbarManager.Instance.TaskbarList.SetProgressState(hwnd, (TBPFLAG)state);
}
public void SetProgressState(TaskbarProgressBarState state, Window window)
{
_manager.SetProgressState(state, window);
}
public void SetProgressState(TaskbarProgressBarState state, Window window)
{
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button of the main application window.
/// </summary>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state)
{
TaskbarList.Instance.SetProgressState(OwnerHandle, (TaskbarProgressBarStatus)state);
}
/// <summary>
/// Sets the type and state of the progress indicator displayed on a taskbar button
/// of the given window handle
/// </summary>
/// <param name="windowHandle">The handle of the window whose associated taskbar button is being used as a progress indicator.
/// This window belong to a calling process associated with the button's application and must be already loaded.</param>
/// <param name="state">Progress state of the progress button</param>
public void SetProgressState(TaskbarProgressBarState state, IntPtr windowHandle)
{
TaskbarList.Instance.SetProgressState(windowHandle, (TaskbarProgressBarStatus)state);
}
private ITaskbarItem SetProgressState(TaskbarProgressBarState state)
{
_taskbarManager.SetProgressState(state, _windowHandle);
return this;
}
private void UpdateProgressState(TaskbarProgressBarState progressState)
{
if (this.InvokeRequired)
{
this.Invoke(new UpdateProgressStateHandler(UpdateProgressState), progressState);
}
if (Program.IsWindows7())
{
TaskbarManager.Instance.SetProgressState(progressState);
}
}
private static void SetTaskBarProgress(TaskbarProgressBarState state)
{
if (!TaskbarManager.IsPlatformSupported || consoleWindowHandle == IntPtr.Zero)
return;
TaskbarManager.Instance.SetProgressState(state, consoleWindowHandle);
}
