protected override void SetupView()
{
_background.Texture = (Texture)GD.Load($"{_resourcesPath}background.png");
_background.Position = new Vector2(300, 30);
_leftButtonTexture = (Texture)GD.Load($"{_resourcesPath}sun.png");
_rightButtonTexture = (Texture)GD.Load($"{_resourcesPath}moon.png");
_progressBarStates = new ProgressBarState[]
{
new ProgressBarState {
Id = 0, Texture = (Texture)GD.Load($"{_resourcesPath}daytime_1.png")
},
new ProgressBarState {
Id = 1, Texture = (Texture)GD.Load($"{_resourcesPath}daytime_2.png")
},
new ProgressBarState {
Id = 2, Texture = (Texture)GD.Load($"{_resourcesPath}daytime_3.png")
},
};
_windowWrapper.RectPosition = new Vector2(70, 5);
var leftButton = _progressBarSideScrollControl.GetNode <TextureButton>("LeftButton");
var rightButton = _progressBarSideScrollControl.GetNode <TextureButton>("RightButton");
leftButton.RectPosition = new Vector2(-55, -18);
rightButton.RectPosition = new Vector2(420, -18);
}
public static void SetState(this ProgressBar self, ProgressBarState state)
{
SendMessage(self.Handle,
0x400 + 16, //WM_USER + PBM_SETSTATE
(uint)state,
0);
}
public void SetBusy(ProgressBarState state = ProgressBarState.Normal, string title = null, string message = null,
int percent = -1)
{
if (title == null)
{
title = GlobalHelper.Get("key_3");
}
if (message == null)
{
message = GlobalHelper.Get("LongTask");
}
BusyIndicator.IsBusy = state != ProgressBarState.NoProgress;
BusyIndicator.DisplayAfter = TimeSpan.FromSeconds(1);
BusyIndicator.BusyContent = message;
if (state == ProgressBarState.Normal)
{
windowsTaskbar.SetProgressValue(percent, 100, this);
ProgressBar.Value = percent;
}
else
{
ProgressBar.IsIndeterminate = state == ProgressBarState.Indeterminate;
windowsTaskbar.SetProgressState((TaskbarProgressBarState)(state), this);
}
}
/// <summary>
/// Sets the state of the progress bar.
/// </summary>
/// <param name="state">The state to set the progress bar.</param>
/// <exception cref="ArgumentOutOfRangeException"><c>state</c> is out of range.</exception>
public void SetProgressBarState(ProgressBarState state)
{
switch (state)
{
case ProgressBarState.Normal:
progressBar.ForeColor = SystemColors.Highlight;
progressBar.MarqueeAnimationSpeed = ProgressBarSpeed;
break;
case ProgressBarState.Pause:
progressBar.ForeColor = SystemColors.Highlight;
progressBar.MarqueeAnimationSpeed = int.MaxValue;
break;
case ProgressBarState.Error:
// This is actually unsupported as the ProgressBar ignores ForeColor
// and PBM_SETSTATE is not supported in XP
progressBar.ForeColor = Color.Red;
progressBar.MarqueeAnimationSpeed = int.MaxValue;
break;
default:
throw new ArgumentOutOfRangeException("state");
}
ProgressBarState = state;
}
protected virtual void OnProgressBarStateChanged(ProgressBarState e)
{
EventHandler handler = ProgressBarStateChanged;
if (handler != null)
{
handler(this, e);
}
}
public static void SetStatus(Form f, ProgressBarState state)
{
IntPtr i = GetTaskBarForm(f);
if (i != IntPtr.Zero)
{
SetStatusHwnd(i, state);
}
}
public void SetProgressBarCountDown(float time, ProgressBarCallback callback)
{
progressBar.gameObject.SetActive(true);
progressBarState = ProgressBarState.SlidingDown;
progressBarTotal = time;
progressBarTimeout = time;
OnProgressComplete = callback;
}
private void SetState(ProgressBarState targetState)
{
if (!IsHandleCreated)
{
return;
}
Methods.SendMessage(Handle, (uint)WindowMessage.PBM_SETSTATE,
(int)targetState.ToNative(), 0);
}
private void progressBarFileState(ProgressBarState prbState)
{
if (this.progressFile.InvokeRequired)
{
this.progressFile.Invoke(new MethodInvoker(delegate { this.progressFile.State = prbState; }));
}
else
{
this.progressFile.State = prbState;
}
}
/// <summary>
/// Sets the state of the progress bar.
/// </summary>
/// <param name="newState">The state to set the progress bar.</param>
/// <returns>If the function succeeds the return value is true.</returns>
public bool SetProgressBarState(ProgressBarState newState)
{
// TDM_SET_PROGRESS_BAR_STATE = WM_USER+104, // wParam = new progress state
return(UnsafeNativeMethods.SendMessage(
this.handle,
(uint)UnsafeNativeMethods.TASKDIALOG_MESSAGES.TDM_SET_PROGRESS_BAR_STATE,
(IntPtr)newState,
IntPtr.Zero) != IntPtr.Zero);
// Future: get more detailed error from and throw.
}
/// <summary>
/// Resets the Task Dialog to the state when first constructed, all properties set to their default value.
/// </summary>
private void Reset( )
{
TaskConfig = new TaskDialogConfig();
Width = 460;
IsExpanded = TaskConfig.Flags.ExpandedByDefault;
FocusControl = null;
StartTime = DateTime.Now;
ProgressBarSpeed = int.MaxValue;
ProgressBarState = ProgressBarState.Normal;
_verificationChecked = TaskConfig.Flags.VerificationFlagChecked;
}
/// <summary>
/// Updates the UI. Not thread-safe.
/// </summary>
private void doUpdateUI(string strStatus, string strDetail, ProgressBarStyle pbarStyle,
ProgressBarState pbarState, int pbarValue1000, string strButtonText, bool btnEnabled, bool linkVisible)
{
lblStatus.Text = strStatus;
lblDetail.Text = strDetail;
pbar.Style = pbarStyle;
pbar.Value = pbarValue1000;
SendMessage(pbar.Handle, 1040, (IntPtr)pbarState, IntPtr.Zero);
btnClose.Text = strButtonText;
btnClose.Enabled = btnEnabled;
llZydeoSite.Visible = linkVisible;
}
public static void SetProgressState(IntPtr handle, ProgressBarState state)
{
if (!WindowsUtils.IsWindows7)
{
return;
}
try
{
lock (_taskbarList)
_taskbarList.SetProgressState(handle, state);
}
catch
{}
}
/// <summary>
/// Converts a <see cref="ProgressBarState"/> value into a native
/// Win32 value, represented by <see cref="Native.ProgressBarState"/>.
/// </summary>
public static Native.ProgressBarState ToNative(ProgressBarState state)
{
switch (state)
{
default:
case ProgressBarState.Normal:
return(Native.ProgressBarState.Normal);
case ProgressBarState.Error:
return(Native.ProgressBarState.Error);
case ProgressBarState.Paused:
return(Native.ProgressBarState.Paused);
}
}
public static ProgressBar SetState(this ProgressBar b, ProgressBarState state)
{
if (b == null)
{
return(b);
}
if (b.Style == ProgressBarStyle.Marquee)
{
b.Style = ProgressBarStyle.Blocks;
}
User32.SendMessage(b.Handle, 1040, (IntPtr)(state + 1), IntPtr.Zero);
return(b);
}
/// <summary>
/// Sets the progress bar's state.
/// </summary>
/// <param name="progressBar">The progress bar to set the state of.</param>
/// <param name="state">The desired state.</param>
/// <returns>The result of the native SendMessage call.</returns>
public static int SetStateNative(this ProgressBar progressBar, ProgressBarState state)
{
if (progressBar.IsHandleCreated == false)
{
return(-1);
}
if (state == ProgressBarState.Unknown ||
Enum.IsDefined(typeof(ProgressBarState), state) == false)
{
throw new ArgumentException($"{nameof(state)} must be a known {nameof(ProgressBarState)} value.", nameof(state));
}
UIntPtr wParam = new((uint)state);
return(Native.User32.SendMessage(progressBar.Handle, PBM.SETSTATE, wParam, IntPtr.Zero));
}
private TaskbarItemProgressState GetTaskbarState(ProgressBarState state)
{
switch (state)
{
case ProgressBarState.None: return(TaskbarItemProgressState.None);
case ProgressBarState.Indeterminate: return(TaskbarItemProgressState.Indeterminate);
case ProgressBarState.Normal: return(TaskbarItemProgressState.Normal);
case ProgressBarState.Error: return(TaskbarItemProgressState.Error);
case ProgressBarState.Paused: return(TaskbarItemProgressState.Paused);
default:
throw new ArgumentOutOfRangeException(nameof(state), state, null);
}
}
private ReturnTypes T(ProgressBarState comResult)
{
switch (comResult)
{
case ProgressBarState.OK:
return(ReturnTypes.rtOK);
case ProgressBarState.UNITIALIZED:
return(ReturnTypes.rtErrorInitializeFirst);
case ProgressBarState.WAIT_MORE:
return(ReturnTypes.rtWaitMore);
default:
log.Error("Unknown ProgressBarState " + comResult);
return(ReturnTypes.rtErrorUnknown);
}
}
public static void SetProgressState(IntPtr handle, ProgressBarState state)
{
if (_taskbarList == null)
{
return;
}
try
{
lock (_taskbarList)
_taskbarList.SetProgressState(handle, state);
}
#region Error handling
catch (Exception ex)
{
Log.Warn(ex);
}
#endregion
}
private void SetGlobalProgressState(ProgressBarState state)
{
switch (state)
{
case ProgressBarState.Normal:
mTaskbarManager?.SetProgressState(TaskbarProgressBarState.Normal);
break;
case ProgressBarState.Error:
mTaskbarManager?.SetProgressState(TaskbarProgressBarState.Error);
break;
case ProgressBarState.Warning:
mTaskbarManager?.SetProgressState(TaskbarProgressBarState.Paused);
break;
default:
throw new ArgumentOutOfRangeException(nameof(state), state, null);
}
}
/// <inheritdoc />
public void SetState(ProgressBarState state)
{
var window = Application.Current?.MainWindow;
if (window == null)
{
return;
}
if (window.TaskbarItemInfo == null)
{
window.TaskbarItemInfo = new TaskbarItemInfo();
}
var taskbarState = GetTaskbarState(state);
if (window.TaskbarItemInfo.ProgressState != taskbarState)
{
window.TaskbarItemInfo.ProgressState = taskbarState;
}
}
public static void SetStatusHwnd(IntPtr hwnd, ProgressBarState state)
{
if (Windows7OrGreater)
{
// set the progress bar state (Normal, Error, Paused)
Windows7Taskbar.SendMessage(hwnd, 0x410, (int)state, 0);
ThumbnailProgressState thmState;
if (state == ProgressBarState.Error)
{
thmState = ThumbnailProgressState.Error;
}
else if (state == ProgressBarState.Pause)
{
thmState = ThumbnailProgressState.Paused;
}
else
{
thmState = ThumbnailProgressState.NoProgress;
}
Windows7Taskbar.SetProgressState(hwnd, thmState);
}
}
protected override void SetupView()
{
_background.Texture = (Texture)GD.Load($"{_resourcesPath}volume_background.png");
_background.Position = new Vector2(273, 86);
_leftButtonTexture = (Texture)GD.Load($"{_resourcesPath}min_volume.png");
_rightButtonTexture = (Texture)GD.Load($"{_resourcesPath}max_volume.png");
_progressBarStates = new ProgressBarState[]
{
new ProgressBarState {
Id = 0, Texture = (Texture)GD.Load($"{_resourcesPath}volume_1.png")
},
new ProgressBarState {
Id = 1, Texture = (Texture)GD.Load($"{_resourcesPath}volume_2.png")
},
new ProgressBarState {
Id = 2, Texture = (Texture)GD.Load($"{_resourcesPath}volume_3.png")
},
};
var font = (DynamicFont)GD.Load($"{_resourcesPath}montserrat_light.tres");
font.Size = 24;
_title.AddFontOverride("font", font);
_title.Text = "Zvuk";
_windowWrapper.Set("custom_constants/separation", 65);
_windowWrapper.RectPosition = new Vector2(15, 5);
_marginContainer.Set("custom_constants/margin_left", 55);
var leftButton = _progressBarSideScrollControl.GetNode <TextureButton>("LeftButton");
var rightButton = _progressBarSideScrollControl.GetNode <TextureButton>("RightButton");
leftButton.RectPosition = new Vector2(-35, -7);
rightButton.RectPosition = new Vector2(400, -15);
}
public static void SetBusy(ProgressBarState state, string title = null, string message = null, int percent = 0)
{
if (title == null)
{
title = GlobalHelper.Get("key_3");
}
if (message == null)
{
message = GlobalHelper.Get("LongTask");
}
if (Application.Current == null)
{
return;
}
ControlExtended.UIInvoke(() =>
{
var item = Application.Current.MainWindow as IDockableManager;
if (item == null)
{
return;
}
UIInvoke(() => item.SetBusy(state, title, message, percent));
});
}
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 applyUpdateInterfaceInteractionEventArgs(ProgressBarState prgState) {
progressBarState = prgState;
}
public void SetProgressBarState(ProgressBarState state) =>
SendTaskDialogMessage(TaskDialogMessages.SetProgressBarState, (int)state, IntPtr.Zero);
public bool SetProgressBarState(ProgressBarState newState)
{
return UnsafeNativeMethods.SendMessage(
this.handle,
(uint)UnsafeNativeMethods.TASKDIALOG_MESSAGES.TDM_SET_PROGRESS_BAR_STATE,
(IntPtr)newState,
IntPtr.Zero) != IntPtr.Zero;
}
/// <summary>
/// Sets the ProgressBarState of a given ProgressBar.
/// </summary>
/// <param name="pBar">The progress bar control whose state is being set.</param>
/// <param name="state">The new state of the progress bar.</param>
public static void SetState(this ProgressBar pBar, ProgressBarState state)
{
SendMessage(new HandleRef(pBar, pBar.Handle), PBM_SETSTATE, (IntPtr)state, IntPtr.Zero);
}
public static void SetState(this ProgressBar bar, ProgressBarState state)
{
SendMessage(bar.Handle, PBM_SETSTATE, (IntPtr)state, IntPtr.Zero);
}
public void SetProgressBarState(ProgressBarState state)
{
ProgressBar.IsIndeterminate = state == ProgressBarState.Running;
}
public static ComponentBuilder <TConfig, ProgressBar> SetState <TConfig>(this ComponentBuilder <TConfig, ProgressBar> builder, ProgressBarState state)
where TConfig : BootstrapConfig
{
builder.Component.ToggleCss(state);
return(builder);
}
public static void SetState(this ProgressBar bar, ProgressBarState state)
{
SendMessage(bar.Handle, WindowMessage.PBM_SETSTATE, (IntPtr)state, IntPtr.Zero);
}
public static void SetProgressState(IntPtr handle, ProgressBarState state)
{
if (!WindowsUtils.IsWindows7) return;
try
{
lock (_taskbarList)
_taskbarList.SetProgressState(handle, state);
}
catch
{}
}
public static void SetState(ProgressBar self, ProgressBarState state)
{
NativeMethods.SendMessage(self.Handle, NativeMethods.PBM_SETSTATE, (IntPtr)state, IntPtr.Zero);
}
public static void SetState(ProgressBar self, ProgressBarState state)
{
NativeMethods.SendMessage(self.Handle, NativeMethods.PBM_SETSTATE, (IntPtr)state, IntPtr.Zero);
}
/// <summary>
/// Updates the UI. Not thread-safe.
/// </summary>
private void doUpdateUI(string strStatus, string strDetail, ProgressBarStyle pbarStyle,
ProgressBarState pbarState, int pbarValue1000, string strButtonText, bool btnEnabled, bool linkVisible)
{
lblStatus.Text = strStatus;
lblDetail.Text = strDetail;
pbar.Style = pbarStyle;
pbar.Value = pbarValue1000;
SendMessage(pbar.Handle, 1040, (IntPtr)pbarState, IntPtr.Zero);
btnClose.Text = strButtonText;
btnClose.Enabled = btnEnabled;
llZydeoSite.Visible = linkVisible;
}
/// <summary>
/// Sets the state of the progress bar.
/// </summary>
/// <param name="newState">The state to set the progress bar.</param>
/// <returns>If the function succeeds the return value is true.</returns>
public bool SetProgressBarState(ProgressBarState newState)
{
// TDM_SET_PROGRESS_BAR_STATE = WM_USER+104, // wParam = new progress state
return UnsafeNativeMethods.SendMessage(
this.handle,
(uint)UnsafeNativeMethods.TASKDIALOG_MESSAGES.TDM_SET_PROGRESS_BAR_STATE,
(IntPtr)newState,
IntPtr.Zero) != IntPtr.Zero;
// Future: get more detailed error from and throw.
}
public static void SetState(this ProgressBar progressBar, ProgressBarState state)
{
Native.SendMessage(progressBar.Handle, PBM_SETSTATE, new IntPtr((int)state), IntPtr.Zero);
}
public static void SetProgressState(IntPtr handle, ProgressBarState state)
{
if (_taskbarList == null) return;
try
{
lock (_taskbarList)
_taskbarList.SetProgressState(handle, state);
}
#region Error handling
catch (Exception ex)
{
Log.Warn(ex);
}
#endregion
}
private void progressBarFileState(ProgressBarState prbState)
{
if (this.progressFile.InvokeRequired)
{
this.progressFile.Invoke(new MethodInvoker(delegate { this.progressFile.State = prbState; }));
}
else
{
this.progressFile.State = prbState;
}
}
