public static void SetProgressValue(double progressValue, double progressMax) { if (taskbarSupported && hWnd != IntPtr.Zero) { taskbarInstance.SetProgressValue(hWnd, (ulong)progressValue, (ulong)progressMax); } }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { if (taskbarSupported) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } }
/// <summary>Set progress state.</summary> /// <param name="window">User window handle.</param> /// <param name="state">State of taskbar.</param> /// <param name="maxValue">Maximal progress position.</param> public static void SetState(eStates state, ulong maxValue) { FormInvoke((MethodInvoker) delegate { taskbar.SetProgressState(taskBarForm.Handle, state); taskbar.SetProgressValue(taskBarForm.Handle, 0, maxValue); }); }
public static void SetProgressValue(IntPtr hwnd, ulong current, ulong maximum) { try { if (IsInitialized) { TaskbarList.SetProgressValue(hwnd, current, maximum); } } catch { } }
/// <summary> /// Set value /// </summary> /// <param name="form">Form</param> /// <param name="progressValue">Progress value</param> /// <param name="progressMax">Progress maximal</param> public static void SetValue(Form form, double progressValue, double progressMax) { if (taskbarSupported) { taskbarInstance.SetProgressValue(form.Handle, (ulong)progressValue, (ulong)progressMax); } }
public void SetProgress(TaskbarProgressState state, float progress) { if (!supported) { return; } var winhandle = Process.GetCurrentProcess().MainWindowHandle; var taskstate = 0; switch (state) { case TaskbarProgressState.Indeterminate: taskstate = 0x1; break; case TaskbarProgressState.Progress: taskstate = 0x2; break; case TaskbarProgressState.Error: taskstate = 0x4; break; case TaskbarProgressState.Paused: taskstate = 0x8; break; } instance.SetProgressState(winhandle, taskstate); instance.SetProgressValue(winhandle, (ulong)(progress * 1000), 1000); }
public void SetProgressValue(UInt64 progressValue, UInt64 progressMax) { if (taskbarSupported) { taskbarInstance.SetProgressValue(this.handle_, progressValue, progressMax); } }
public static void SetValue(IntPtr windowHandle, int progressValue, int progressMax) { if (taskbarSupported && !IndicatorStateLocked) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { if (taskbarSupported && !(DetectLinux.WineDetected() || DetectLinux.NativeLinuxDetected())) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } }
public static void SetProgressValue(this Form form, ulong value, ulong max) { if (_Supported) { _Instance.SetProgressValue(form.Handle, value, max); } }
/// <summary> /// Sets the progress value of the specified window's /// taskbar button. /// </summary> /// <param name="hWnd">The window handle.</param> /// <param name="current">The current value.</param> /// <param name="maximum">The maximum value.</param> public static void SetProgressValue(IntPtr hWnd, ulong current, ulong maximum) { if (Windows7OrGreater) { TaskbarList.SetProgressValue(hWnd, current, maximum); } }
private static void SetTaskbarProgressValue(IntPtr hwnd, double value) { if (_taskbarSupported) { _taskbar.SetProgressValue(hwnd, (ulong)(value * 1000), 1000); } }
public static void SetValue(double progressValue, double progressMax) { if (_taskbarSupported) { _taskbarInstance.SetProgressValue(GetConsoleWindow(), (ulong)progressValue, (ulong)progressMax); } }
private static void SetValue(IntPtr handle, ulong value, ulong max) { if (!Supported) { return; } Instance.SetProgressValue(handle, value, max); }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { if (!IsSupported()) { return; } taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); }
internal static void SetValue(IntPtr windowHandle, int progressValue, int progressMax) { if (!_taskbarSupported || windowHandle == IntPtr.Zero) { return; } _instance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); }
private static void SetValueUnsafe(IntPtr handle, ulong value, ulong max) { // ReSharper disable once SuspiciousTypeConversion.Global if (_instance == null) { _instance = new TaskbarInstance() as ITaskbarList3; } _instance?.SetProgressValue(handle, value, max); }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { try { if (taskbarSupported && !DetectLinux.LinuxDetected()) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } } catch { } }
void Show() { _isVisible = true; _taskbarList?.SetProgressState(_handle, ProgressValue.HasValue ? TaskbarStates.Normal : TaskbarStates.Indeterminate); if (ProgressValue.HasValue) { _taskbarList?.SetProgressValue(_handle, (ulong)(ProgressValue.Value * 100), 100); } }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { if (taskbarSupported) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } else { throw new NotSupportedException("TaskBar function is not supported in this OS version"); } }
public static void SetProgressValue(Form fWindow, UInt64 ullCompleted, UInt64 ullTotal) { if (!EnsureInitialized()) { return; } try { m_tbList.SetProgressValue(fWindow.Handle, ullCompleted, ullTotal); } catch (Exception) { Debug.Assert(false); } }
public static void SetState(IntPtr windowHandle, TaskbarStates taskbarState, double progressValue = 0.0, double progressMax = 0.0) { if (taskbarSupported) { taskbarInstance.SetProgressState(windowHandle, taskbarState); if (progressValue > 0 && progressMax > 0) { taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } } }
public static void SetValue(IntPtr windowHandle, double progressValue, double progressMax) { if (taskbarSupported) { if (taskbarInstance == null) { taskbarInstance = (ITaskbarList3) new TaskbarInstance(); } taskbarInstance.SetProgressValue(windowHandle, (ulong)progressValue, (ulong)progressMax); } }
/// <summary> /// catches the StatusUpdate event fired from Form1 and updates the GUI accordingly /// </summary> /// <param name="su"></param> public void UpdateStatus(StatusUpdate su) { try { // possible to abort job abortButton.Enabled = (su.JobStatus == JobStatus.PROCESSING); // Current position positionInClip.Text = (Util.ToString(su.ClipPosition) ?? "---") + " / " + (Util.ToString(su.ClipLength) ?? "---"); // Current frame currentVideoFrame.Text = (Util.ToString(su.NbFramesDone, true) ?? "---") + " / " + (Util.ToString(su.NbFramesTotal, true) ?? "---"); // Data videoData.Text = (su.CurrentFileSize.HasValue ? su.CurrentFileSize.Value.ToString() : "---") + " / " + (su.ProjectedFileSize.HasValue ? su.ProjectedFileSize.Value.ToString() : "---"); // Processing speed fps.Text = su.ProcessingSpeed ?? "---"; // Time elapsed // Now we use TotalHours to avoid 24h+ resets... if (su.TimeElapsed.TotalHours > 24) { timeElapsed.Text = string.Format("{0:00}:{1:00}:{2:00}:{3:00}", (int)su.TimeElapsed.TotalDays, su.TimeElapsed.Hours, su.TimeElapsed.Minutes, su.TimeElapsed.Seconds); } else { timeElapsed.Text = string.Format("{0:00}:{1:00}:{2:00}", (int)su.TimeElapsed.Hours, su.TimeElapsed.Minutes, su.TimeElapsed.Seconds); } // Estimated time // go back to the old function ;-) totalTime.Text = getTimeString(su.TimeElapsed, su.PercentageDoneExact ?? 0M); this.Text = "Status: " + (su.PercentageDoneExact ?? 0M).ToString("0.00") + " %"; statusLabel.Text = su.Status ?? ""; jobNameLabel.Text = "[" + su.JobName + "]"; progress.Value = su.PercentageDone; if ((Environment.OSVersion.Version.Major == 6 && Environment.OSVersion.Version.Minor >= 1) || Environment.OSVersion.Version.Major > 6) { taskbarProgress.SetProgressValue(this.Handle, Convert.ToUInt64(su.PercentageDone), 100); } } catch (Exception) { } }
private HRESULT _UpdateProgressValue(bool attached) { if (!attached || ProgressState == TaskbarItemProgressState.None || ProgressState == TaskbarItemProgressState.Indeterminate) { return(HRESULT.S_OK); } const ulong precisionValue = 1000; Assert.BoundedDoubleInc(0, ProgressValue, 1); var intValue = (ulong)(ProgressValue * precisionValue); return(_taskbarList.SetProgressValue(_hwndSource.Handle, intValue, precisionValue)); }
public static void SetProgress(IntPtr WindowHandle, ulong Completed, ulong Total) { if (Interface != null) { try { Interface.SetProgressValue(WindowHandle, Completed, Total); } catch { } } }
private static void SetValue(IntPtr handle, ulong value, ulong max) { if (!_supported) { return; } try { Instance.SetProgressValue(handle, value, max); } catch (InvalidCastException e) { Logging.Warning(e); _supported = false; } }
public void SetValue(IntPtr windowHandle, ulong progressValue, ulong progressMax) { if (isSupported) { try { instance.SetProgressValue(windowHandle, progressValue, progressMax); } catch (Exception e) { Util.Logging.Log(e); } } }
public override void WriteProgress(long sourceId, ProgressRecord record) { IntPtr hWnd = GetConsoleWindow(); if (record.PercentComplete == 100) { taskBarList.SetProgressState(hWnd, TBPFLAG.TBPF_NOPROGRESS); } else { taskBarList.SetProgressState(hWnd, TBPFLAG.TBPF_NORMAL); } taskBarList.SetProgressValue(hWnd, unchecked ((ulong)record.PercentComplete), unchecked ((ulong)100)); }
private void SetTaskbarProgress(int progress) { if (_isWin7TaskBar) { try { if (progress == 0) { _taskbarList.SetProgressState(_taskbarParent, TBPFLAG.TBPF_NOPROGRESS); } else { _taskbarList.SetProgressState(_taskbarParent, TBPFLAG.TBPF_NORMAL); _taskbarList.SetProgressValue(_taskbarParent, (ulong)progress, 100); } } catch { } } }