/// <summary> /// MUST be called after de-serializing (i.e. after parameterless ctor was used). /// </summary> /// <param name="owner"></param> internal override void SetOwner(TaskBase owner) { System.Diagnostics.Debug.Assert(_timer == null); base.SetOwner(owner); _timer = new Timer(new TimerCallback(TimerCbk)); if (Enabled) { Start(); // will account for paused as well } }
private void PauseResumeSchedule() { TaskBase task = CurrentTask; if (task == null || !task.Schedule.Enabled) { return; } task.Schedule.Paused = !task.Schedule.Paused; }
private void CheckCurrentTask() { TaskBase task = CurrentTask; if (task != null) { task.Check(true); statusTextTask.Text = task.Message; } }
private void actionToolStripMenuItem_DropDownOpening(object sender, EventArgs e) { TaskBase task = CurrentTask; ActionBase action = CurrentAction; ActionList actions = action == null ? null : action.Task.Actions; actionAddToolStripMenuItem.Enabled = task != null && task.IsReady; actionDeleteToolStripMenuItem.Enabled = actions != null && task.IsReady; actionMoveDownToolStripMenuItem.Enabled = actions != null && task.IsReady && actions.IndexOf(action) < actions.Count - 1; actionMoveUpToolStripMenuItem.Enabled = actions != null && task.IsReady && actions.IndexOf(action) > 0; }
public override void RemoveTask(long taskId) { lock (SyncRoot) { int index; TaskBase task = this.TaskById(taskId, out index); if (task != null) { this.RemoveAt(index); } } }
private void PreviewCurrentTask() { TaskBase task = CurrentTask; if (!CurrentTaskIsReady || !task.Check(false)) { return; } C1.Win.C1Preview.C1PrintPreviewDialog pview = new C1.Win.C1Preview.C1PrintPreviewDialog(); pview.Show(this); pview.Document = task.Document; }
/// <summary> /// MUST be called after de-serializing (i.e. after parameterless ctor was used). /// </summary> /// <param name="owner"></param> internal void SetOwner(TaskBase owner) { System.Diagnostics.Debug.Assert(owner != null && _owner == null); lock (SyncRoot) { _owner = owner; foreach (ActionBase action in this) { action.SetOwner(_owner); } } }
private void taskToolStripMenuItem_DropDownOpening(object sender, EventArgs e) { TaskBase task = CurrentTask; int taskIdx = CurrentTaskIndex; int taskCount = _taskGrid.Rows.Count; taskAddToolStripMenuItem.Enabled = true; taskDeleteToolStripMenuItem.Enabled = task != null && task.IsReady; taskMoveUpToolStripMenuItem.Enabled = taskIdx > 0; taskMoveDownToolStripMenuItem.Enabled = taskIdx >= 0 && taskIdx < taskCount - 1; taskPreviewToolStripMenuItem.Enabled = task != null && task.IsReady && task.ReportKind != ReportKind.Program; taskCheckToolStripMenuItem.Enabled = task != null && task.IsReady; taskCheckAllToolStripMenuItem.Enabled = taskCount > 0; }
private bool UiTaskSelectFileName(TaskBase task) { try { using (OpenFileDialog ofd = new OpenFileDialog()) { ofd.Filter = "Report definition files (*.xml)|*.xml|C1DX documents(*.c1dx)|*.c1dx|C1D documents (*.c1d)|*.c1d|Executable files (*.exe)|*.exe|All files (*.*)|*.*"; if (ofd.ShowDialog() == DialogResult.OK) { task.FileName = ofd.FileName; switch (Path.GetExtension(ofd.FileName).ToLowerInvariant()) { case ".xml": if (task.ReportKind == ReportKind.C1dDocument) { task.ReportKind = ReportKind.XmlReport; } break; case ".c1d": case ".c1dx": if (task.ReportKind != ReportKind.C1dDocument) { task.ReportKind = ReportKind.C1dDocument; } break; case ".exe": if (task.ReportKind != ReportKind.Program) { task.ReportKind = ReportKind.Program; } break; } return(true); } else { return(false); } } } catch (Exception ex) { WinUtil.ShowError(ex.Message); return(false); } }
void _actionGrid_RowsAdded(object sender, DataGridViewRowsAddedEventArgs e) { TaskBase task = CurrentTask; System.Diagnostics.Debug.Assert(task != null); if (task == null) { return; } for (int i = 0; i < e.RowCount; ++i) { ActionBase action = task.Actions[e.RowIndex + i]; UpdateActionGridFormatList(action); UpdateActionGridActionKindList(action); action.PropertyChanged += new PropertyChangedEventHandler(ActionPropertyChanged); } }
protected override void RemoveItem(int index) { lock (SyncRoot) { TaskBase task = this[index]; if (!_movingTask) { task.Schedule.Exit(); } long id = task.Id; base.RemoveItem(index); if (_wcfCallback != null) { _wcfCallback.TaskRemoved(id); } } }
protected override void OnPropertyChanged(string propertyName) { base.OnPropertyChanged(propertyName); TaskBase owner = _owner; if (propertyName != "CheckedStatus" && propertyName != "State") { CheckedStatus = CheckedStatus.Unknown; if (owner != null) { owner.CheckedStatus = CheckedStatus.Unknown; } } if (owner == null) { return; } TaskListServer tasks = owner.Owner as TaskListServer; if (tasks == null) { return; } IC1ReportsSchedulerWcfCallback callback = tasks.WcfCallback; if (callback != null) { try { callback.ActionPropertyChanged(owner.Id, this.Id, ToProxyXml(), propertyName); } catch (Exception ex) { IC1ReportsSchedulerWcf wcfService = tasks.WcfService; if (wcfService != null) { wcfService.Disconnect(ex.Message); } } } }
private void OnCurrentTaskChanged(bool forceUpdate) { TaskBase newCurrentTask = GetCurrentTask(); if (_currentTask == newCurrentTask && !forceUpdate) { return; } if (_currentTask != null) { _currentTask.Schedule.PropertyChanged -= new PropertyChangedEventHandler(_currSchedule_PropertyChanged); } _currentTask = newCurrentTask; if (_currentTask != null) { _currentTask.Schedule.PropertyChanged += new PropertyChangedEventHandler(_currSchedule_PropertyChanged); } this.SuspendLayout(); try { if (_currentTask == null) { _actionGrid.DataSource = null; } else { System.Diagnostics.Debug.Assert(_currentTask.Actions.Invoker == this); _actionGrid.DataSource = _currentTask.Actions; UpdateActionGridDropDowns(); UpdateSchedule(_currentTask); } UpdateCurrentTaskUi(); UpdateCurrentActionUi(); UpdateScheduleUi(); OnTaskStateChanged(_currentTask); } finally { this.ResumeLayout(); } }
void _taskGrid_RowsAdded(object sender, DataGridViewRowsAddedEventArgs e) { try { for (int i = 0; i < e.RowCount; ++i) { TaskBase task = Tasks[e.RowIndex + i]; task.Actions.Invoker = this; UpdateTaskGridReportList(e.RowIndex + i); OnTaskStateChanged(task); task.PropertyChanged += new PropertyChangedEventHandler(TaskPropertyChanged); } } catch (Exception ex) { WinUtil.ShowError(ex.Message); } }
private void UpdateTaskGridReportList(int rowIdx) { if (rowIdx < 0) { return; } // update list of reports: TaskBase task = Tasks[rowIdx]; DataGridViewComboBoxCell cell = (DataGridViewComboBoxCell)_taskGrid[_taskGridInfo.ReportNameColIdx, rowIdx]; if (cell.DataSource != task.ReportNames) { cell.DataSource = task.ReportNames; if (task.ReportNames != null && task.ReportNames.Length > 0 && !task.ReportNames.Contains <string>(task.ReportName)) { task.ReportName = task.ReportNames[0]; } } }
private void scheduleToolStripMenuItem_DropDownOpening(object sender, EventArgs e) { // if service is not running, disable all schedule commands: bool serviceRunning; if (ClientMode) { using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { serviceRunning = sc.Status == ServiceControllerStatus.Running; } catch { serviceRunning = false; } finally { sc.Close(); } } if (!serviceRunning) { btnScheduleStart.Enabled = false; btnSchedulePause.Enabled = false; } } else { serviceRunning = true; } TaskBase task = CurrentTask; bool running = task != null && task.Schedule.Enabled; bool paused = task != null && task.Schedule.Paused; scheduleStartToolStripMenuItem.Enabled = serviceRunning && task != null && !running; scheduleStopToolStripMenuItem.Enabled = serviceRunning && running && !paused; schedulePauseToolStripMenuItem.Enabled = serviceRunning && running && !paused; scheduleResumeToolStripMenuItem.Enabled = serviceRunning && running && paused; }
void _actionGrid_CellClick(object sender, DataGridViewCellEventArgs e) { if (e.RowIndex < 0) { return; // caption was clicked } if (e.ColumnIndex == _actionGridInfo.OutputNameSelectColIdx) { TaskBase task = CurrentTask; if (task != null) { ActionBase action = task.Actions[e.RowIndex]; if (UiActionSelectFileName(action)) { UpdateActionGridFormatList(action); UpdateActionGridActionKindList(action); } } } // ... }
/// <summary> /// Set task grid row's properties according to task state. /// If the passed task is current, also updates actions and schedule panels. /// </summary> /// <param name="task"></param> private void OnTaskStateChanged(TaskBase task) { if (task == null) { return; } try { int taskIdx = Tasks.IndexOf(task); // ignore state change from task if it's not in grid - assume // that it was removed while executing: // System.Diagnostics.Debug.Assert(taskIdx >= 0); if (taskIdx < 0) { return; } bool ro = task.State != TaskState.Ready; _taskGrid.Rows[taskIdx].ReadOnly = ro; if (task == CurrentTask) { _actionGrid.ReadOnly = ro; foreach (ActionBase a in task.Actions) { UpdateActionGridCellsReadonlyState(a); } SetReadOnlyRecursive(grpSchedule.Controls, ro); // for "one time" schedules, repeat freq/unit must be adjusted: numScheduleRepeatFreq.Enabled = chkScheduleRepeat.Checked; cmbScheduleRepeatUnit.Enabled = chkScheduleRepeat.Checked; SetReadOnlyRecursive(flwScheduleFrequency.Controls, ro); dtpScheduleDate.Enabled = !ro; dtpScheduleTime.Enabled = !ro; } } catch (Exception ex) { WinUtil.ShowError(ex.Message); } }
private string GetTaskErrorMessage(TaskBase task) { if (task == null) { return(string.Empty); } else if (!string.IsNullOrEmpty(task.Message)) { return(task.Message); } else { foreach (ActionBase action in task.Actions) { if (!string.IsNullOrEmpty(action.Message)) { return(string.Format("One or more actions have errors: {0}", action.Message)); } } } return(string.Empty); }
private void UpdateCurrentTaskUi() { try { TaskBase task = CurrentTask; int taskIdx = CurrentTaskIndex; int taskCount = _taskGrid.Rows.Count; this.tbtnTaskRemove.Enabled = task != null && task.IsReady; this.tbtnTaskMoveUp.Enabled = taskIdx > 0; this.tbtnTaskMoveDown.Enabled = taskIdx >= 0 && taskIdx < taskCount - 1; this.tbtnTaskPreview.Enabled = task != null && task.IsReady && task.ReportKind != ReportKind.Program; // update status bar: if (task == null) { statusTextTask.Text = string.Empty; statusTextTask.Image = null; } else { statusTextTask.Text = GetTaskErrorMessage(task); if (string.IsNullOrEmpty(statusTextTask.Text)) { statusTextTask.Image = null; } else { statusTextTask.Image = global::C1ReportsScheduler.Properties.Resources.StateError; } } ShowHidePleaseAddTask(); } catch { } }
public ActionClient(TaskBase owner) : base(owner) { }
void _actionGrid_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e) { if (e.RowIndex < 0) { return; } try { TaskBase task = CurrentTask; if (task == null) { return; } bool readOnly = task.State != TaskState.Ready; _actionGrid.ReadOnly = readOnly; e.CellStyle.ForeColor = readOnly ? SystemColors.GrayText : SystemColors.ControlText; if (e.ColumnIndex == _actionGridInfo.CheckedStatusColIdx) { CheckedStatus cs; string message; if (e.RowIndex >= task.Actions.Count) { return; } cs = task.Actions[e.RowIndex].CheckedStatus; message = task.Actions[e.RowIndex].Message; switch (cs) { case CheckedStatus.Unknown: e.Value = global::C1ReportsScheduler.Properties.Resources.GrayBall; _actionGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; case CheckedStatus.Invalid: e.Value = global::C1ReportsScheduler.Properties.Resources.StateError; _actionGrid[e.ColumnIndex, e.RowIndex].ToolTipText = message; break; case CheckedStatus.CheckedOk: e.Value = global::C1ReportsScheduler.Properties.Resources.StateOk; _actionGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; case CheckedStatus.Working: e.Value = global::C1ReportsScheduler.Properties.Resources.Working; _actionGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; default: System.Diagnostics.Debug.Assert(false); break; } } else if (e.ColumnIndex == _actionGridInfo.OutputNameColIdx) { if (readOnly || task.ReportKind == ReportKind.Program) { e.CellStyle.ForeColor = SystemColors.GrayText; } } } catch { } }
private void UpdateSchedule(TaskBase task) { this.dtpScheduleDate.DataBindings.Clear(); this.dtpScheduleDate.DataBindings.Add("Value", task.Schedule, "StartTime"); this.dtpScheduleTime.DataBindings.Clear(); this.dtpScheduleTime.DataBindings.Add("Value", task.Schedule, "StartTime"); this.rbtScheduleOnce.DataBindings.Clear(); this.rbtScheduleOnce.DataBindings.Add("Checked", task.Schedule, "FrequencyOnce"); this.rbtScheduleDaily.DataBindings.Clear(); this.rbtScheduleDaily.DataBindings.Add("Checked", task.Schedule, "FrequencyDaily"); this.rbtScheduleWeekly.DataBindings.Clear(); this.rbtScheduleWeekly.DataBindings.Add("Checked", task.Schedule, "FrequencyWeekly"); this.rbtScheduleMonthly.DataBindings.Clear(); this.rbtScheduleMonthly.DataBindings.Add("Checked", task.Schedule, "FrequencyMonthly"); this.numScheduleDays.DataBindings.Clear(); // NOTE: when Value of a numeric updown is bound, typing a value does not update data: // this.numScheduleDays.DataBindings.Add("Value", task.Schedule, "RecurEveryDays"); this.numScheduleDays.DataBindings.Add("Text", task.Schedule, "RecurEveryDays"); this.numScheduleWeeks.DataBindings.Clear(); // this.numScheduleWeeks.DataBindings.Add("Value", task.Schedule, "RecurEveryWeeks"); this.numScheduleWeeks.DataBindings.Add("Text", task.Schedule, "RecurEveryWeeks"); this.chkScheduleSunday.DataBindings.Clear(); this.chkScheduleSunday.DataBindings.Add("Checked", task.Schedule, "Sunday"); this.chkScheduleMonday.DataBindings.Clear(); this.chkScheduleMonday.DataBindings.Add("Checked", task.Schedule, "Monday"); this.chkScheduleTuesday.DataBindings.Clear(); this.chkScheduleTuesday.DataBindings.Add("Checked", task.Schedule, "Tuesday"); this.chkScheduleWednesday.DataBindings.Clear(); this.chkScheduleWednesday.DataBindings.Add("Checked", task.Schedule, "Wednesday"); this.chkScheduleThursday.DataBindings.Clear(); this.chkScheduleThursday.DataBindings.Add("Checked", task.Schedule, "Thursday"); this.chkScheduleFriday.DataBindings.Clear(); this.chkScheduleFriday.DataBindings.Add("Checked", task.Schedule, "Friday"); this.chkScheduleSaturday.DataBindings.Clear(); this.chkScheduleSaturday.DataBindings.Add("Checked", task.Schedule, "Saturday"); this.chkScheduleJan.DataBindings.Clear(); this.chkScheduleJan.DataBindings.Add("Checked", task.Schedule, "January"); this.chkScheduleFeb.DataBindings.Clear(); this.chkScheduleFeb.DataBindings.Add("Checked", task.Schedule, "February"); this.chkScheduleMar.DataBindings.Clear(); this.chkScheduleMar.DataBindings.Add("Checked", task.Schedule, "March"); this.chkScheduleApr.DataBindings.Clear(); this.chkScheduleApr.DataBindings.Add("Checked", task.Schedule, "April"); this.chkScheduleMay.DataBindings.Clear(); this.chkScheduleMay.DataBindings.Add("Checked", task.Schedule, "May"); this.chkScheduleJun.DataBindings.Clear(); this.chkScheduleJun.DataBindings.Add("Checked", task.Schedule, "June"); this.chkScheduleJul.DataBindings.Clear(); this.chkScheduleJul.DataBindings.Add("Checked", task.Schedule, "July"); this.chkScheduleAug.DataBindings.Clear(); this.chkScheduleAug.DataBindings.Add("Checked", task.Schedule, "August"); this.chkScheduleSep.DataBindings.Clear(); this.chkScheduleSep.DataBindings.Add("Checked", task.Schedule, "September"); this.chkScheduleOct.DataBindings.Clear(); this.chkScheduleOct.DataBindings.Add("Checked", task.Schedule, "October"); this.chkScheduleNov.DataBindings.Clear(); this.chkScheduleNov.DataBindings.Add("Checked", task.Schedule, "November"); this.chkScheduleDec.DataBindings.Clear(); this.chkScheduleDec.DataBindings.Add("Checked", task.Schedule, "December"); this.chkScheduleDay1.DataBindings.Clear(); this.chkScheduleDay1.DataBindings.Add("Checked", task.Schedule, "Day1"); this.chkScheduleDay2.DataBindings.Clear(); this.chkScheduleDay2.DataBindings.Add("Checked", task.Schedule, "Day2"); this.chkScheduleDay3.DataBindings.Clear(); this.chkScheduleDay3.DataBindings.Add("Checked", task.Schedule, "Day3"); this.chkScheduleDay4.DataBindings.Clear(); this.chkScheduleDay4.DataBindings.Add("Checked", task.Schedule, "Day4"); this.chkScheduleDay5.DataBindings.Clear(); this.chkScheduleDay5.DataBindings.Add("Checked", task.Schedule, "Day5"); this.chkScheduleDay6.DataBindings.Clear(); this.chkScheduleDay6.DataBindings.Add("Checked", task.Schedule, "Day6"); this.chkScheduleDay7.DataBindings.Clear(); this.chkScheduleDay7.DataBindings.Add("Checked", task.Schedule, "Day7"); this.chkScheduleDay8.DataBindings.Clear(); this.chkScheduleDay8.DataBindings.Add("Checked", task.Schedule, "Day8"); this.chkScheduleDay9.DataBindings.Clear(); this.chkScheduleDay9.DataBindings.Add("Checked", task.Schedule, "Day9"); this.chkScheduleDay10.DataBindings.Clear(); this.chkScheduleDay10.DataBindings.Add("Checked", task.Schedule, "Day10"); this.chkScheduleDay11.DataBindings.Clear(); this.chkScheduleDay11.DataBindings.Add("Checked", task.Schedule, "Day11"); this.chkScheduleDay12.DataBindings.Clear(); this.chkScheduleDay12.DataBindings.Add("Checked", task.Schedule, "Day12"); this.chkScheduleDay13.DataBindings.Clear(); this.chkScheduleDay13.DataBindings.Add("Checked", task.Schedule, "Day13"); this.chkScheduleDay14.DataBindings.Clear(); this.chkScheduleDay14.DataBindings.Add("Checked", task.Schedule, "Day14"); this.chkScheduleDay15.DataBindings.Clear(); this.chkScheduleDay15.DataBindings.Add("Checked", task.Schedule, "Day15"); this.chkScheduleDay16.DataBindings.Clear(); this.chkScheduleDay16.DataBindings.Add("Checked", task.Schedule, "Day16"); this.chkScheduleDay17.DataBindings.Clear(); this.chkScheduleDay17.DataBindings.Add("Checked", task.Schedule, "Day17"); this.chkScheduleDay18.DataBindings.Clear(); this.chkScheduleDay18.DataBindings.Add("Checked", task.Schedule, "Day18"); this.chkScheduleDay19.DataBindings.Clear(); this.chkScheduleDay19.DataBindings.Add("Checked", task.Schedule, "Day19"); this.chkScheduleDay20.DataBindings.Clear(); this.chkScheduleDay20.DataBindings.Add("Checked", task.Schedule, "Day20"); this.chkScheduleDay21.DataBindings.Clear(); this.chkScheduleDay21.DataBindings.Add("Checked", task.Schedule, "Day21"); this.chkScheduleDay22.DataBindings.Clear(); this.chkScheduleDay22.DataBindings.Add("Checked", task.Schedule, "Day22"); this.chkScheduleDay23.DataBindings.Clear(); this.chkScheduleDay23.DataBindings.Add("Checked", task.Schedule, "Day23"); this.chkScheduleDay24.DataBindings.Clear(); this.chkScheduleDay24.DataBindings.Add("Checked", task.Schedule, "Day24"); this.chkScheduleDay25.DataBindings.Clear(); this.chkScheduleDay25.DataBindings.Add("Checked", task.Schedule, "Day25"); this.chkScheduleDay26.DataBindings.Clear(); this.chkScheduleDay26.DataBindings.Add("Checked", task.Schedule, "Day26"); this.chkScheduleDay27.DataBindings.Clear(); this.chkScheduleDay27.DataBindings.Add("Checked", task.Schedule, "Day27"); this.chkScheduleDay28.DataBindings.Clear(); this.chkScheduleDay28.DataBindings.Add("Checked", task.Schedule, "Day28"); this.chkScheduleDay29.DataBindings.Clear(); this.chkScheduleDay29.DataBindings.Add("Checked", task.Schedule, "Day29"); this.chkScheduleDay30.DataBindings.Clear(); this.chkScheduleDay30.DataBindings.Add("Checked", task.Schedule, "Day30"); this.chkScheduleDay31.DataBindings.Clear(); this.chkScheduleDay31.DataBindings.Add("Checked", task.Schedule, "Day31"); this.chkScheduleDayLast.DataBindings.Clear(); this.chkScheduleDayLast.DataBindings.Add("Checked", task.Schedule, "DayLast"); this.chkScheduleRepeat.DataBindings.Clear(); this.chkScheduleRepeat.DataBindings.Add("Checked", task.Schedule, "Repeat"); this.numScheduleRepeatFreq.DataBindings.Clear(); // this.numScheduleRepeatFreq.DataBindings.Add("Value", task.Schedule, "RepeatFrequency"); this.numScheduleRepeatFreq.DataBindings.Add("Text", task.Schedule, "RepeatFrequency"); this.cmbScheduleRepeatUnit.DataSource = Enum.GetValues(typeof(ScheduleRepeatUnit)); this.cmbScheduleRepeatUnit.DataBindings.Clear(); this.cmbScheduleRepeatUnit.DataBindings.Add("SelectedItem", task.Schedule, "RepeatUnit"); }
private void UpdateScheduleUi() { try { TaskBase task = CurrentTask; if (task == null) { // Note: disabling buttons may result in .net trying to move focus to the task grid, // and if that grid is empty that may cause SetCurrentCellAddressCore exception, // hence this (TFS~~14180): BeginInvoke((Action)(() => UpdateScheduleUiNoTask())); } else { flwScheduleFrequency.Enabled = true; dtpScheduleDate.Enabled = dtpScheduleTime.Enabled = task.State == TaskState.Ready; grpSchedule.Visible = true; flwScheduleOnce.Visible = task.Schedule.FrequencyOnce; flwScheduleDaily.Visible = task.Schedule.FrequencyDaily; pnlScheduleWeek.Visible = task.Schedule.FrequencyWeekly; pnlScheduleMonth.Visible = task.Schedule.FrequencyMonthly; pnlScheduleMonthDays.Visible = task.Schedule.FrequencyMonthly; numScheduleRepeatFreq.Enabled = chkScheduleRepeat.Checked; cmbScheduleRepeatUnit.Enabled = chkScheduleRepeat.Checked; btnScheduleStart.Enabled = true; if (task.Schedule.Enabled) { btnScheduleStart.Text = "Stop"; btnScheduleStart.Image = global::C1ReportsScheduler.Properties.Resources.Stop; btnSchedulePause.Enabled = true; } else { btnScheduleStart.Text = "Start"; btnScheduleStart.Image = global::C1ReportsScheduler.Properties.Resources.Start; btnSchedulePause.Enabled = false; } if (task.Schedule.Paused) { btnSchedulePause.Text = "Resume"; btnSchedulePause.Image = global::C1ReportsScheduler.Properties.Resources.Resume; } else { btnSchedulePause.Text = "Pause"; btnSchedulePause.Image = global::C1ReportsScheduler.Properties.Resources.Pause; } // in client mode, if service is paused, disable both start and stop: if (ClientMode) { bool serviceRunning; using (ServiceController sc = new ServiceController(C1ReportsSchedulerService.Constants.Name)) { try { serviceRunning = sc.Status == ServiceControllerStatus.Running; } catch { serviceRunning = false; } finally { sc.Close(); } } if (!serviceRunning) { btnScheduleStart.Enabled = false; btnSchedulePause.Enabled = false; } } DateTime nextDueTime = task.Schedule.NextDueTime; if (nextDueTime == ScheduleBase.c_DateTimeNever) { lblScheduleNextDueTime.Text = "Never"; } else { lblScheduleNextDueTime.Text = nextDueTime.ToString(); } } } catch { } }
public ScheduleBase(TaskBase owner) { SetOwner(owner); }
/// <summary> /// MUST be called after de-serializing (i.e. after parameterless ctor was used). /// </summary> /// <param name="owner"></param> internal virtual void SetOwner(TaskBase owner) { System.Diagnostics.Debug.Assert(owner != null && _owner == null); _owner = owner; }
protected override void OnListChanged(ListChangedEventArgs e) { base.OnListChanged(e); TaskBase owner = _owner; if (owner == null) { return; } if (e.ListChangedType == ListChangedType.ItemAdded || e.ListChangedType == ListChangedType.ItemDeleted) { owner.CheckedStatus = CheckedStatus.Unknown; } TaskListServer tasks = owner.Owner as TaskListServer; if (tasks == null) { return; } IC1ReportsSchedulerWcfCallback wcfCallback = tasks.WcfCallback; if (wcfCallback == null) { return; } try { switch (e.ListChangedType) { case ListChangedType.ItemAdded: try { ActionServer action = (ActionServer)this[e.NewIndex]; long ownerId; long actionId; string xml; lock (action.SyncRoot) { ownerId = owner.Id; actionId = action.Id; xml = action.ToProxyXml(); } wcfCallback.ActionAdded(ownerId, e.NewIndex, actionId, xml); } catch (Exception ex) { AltUtil.ShowError(ex.Message); } break; case ListChangedType.ItemChanged: try { ActionServer action = (ActionServer)this[e.NewIndex]; long ownerId; long actionId; string xml; lock (action.SyncRoot) { ownerId = owner.Id; actionId = action.Id; xml = action.ToProxyXml(); } wcfCallback.ActionPropertyChanged(ownerId, actionId, xml, e.PropertyDescriptor.Name); } catch (Exception ex) { AltUtil.ShowError(ex.Message); } break; case ListChangedType.ItemDeleted: // we need removed task's id, hence TaskRemoved must be called from RemoveItem override: // wcfCallback.TaskRemoved(TaskId(e.NewIndex)); break; case ListChangedType.ItemMoved: break; case ListChangedType.Reset: break; } } catch (Exception ex) { AltUtil.ShowError(ex.Message); IC1ReportsSchedulerWcf wcfService = tasks.WcfService; if (wcfService != null) { wcfService.Disconnect(ex.Message); } } }
public ScheduleServer(TaskBase owner) : base(owner) { }
private void _taskGrid_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e) { if (e.RowIndex < 0) { return; } bool readOnly = _taskGrid.Rows[e.RowIndex].ReadOnly; e.CellStyle.ForeColor = readOnly ? SystemColors.GrayText : SystemColors.ControlText; if (e.ColumnIndex == _taskGridInfo.ReadyColIdx) { switch (Tasks[e.RowIndex].State) { case TaskState.Ready: e.Value = "Ready"; break; case TaskState.Busy: e.Value = "Busy"; break; case TaskState.Scheduled: e.Value = "Scheduled"; break; case TaskState.Paused: e.Value = "Paused"; break; default: System.Diagnostics.Debug.Assert(false); break; } } else if (e.ColumnIndex == _taskGridInfo.TaskKindColIdx) { TaskBase task = Tasks[e.RowIndex]; e.Value = c_taskKindNames[task.ReportKind].Name; _taskGrid[e.ColumnIndex, e.RowIndex].ToolTipText = c_taskKindNames[task.ReportKind].ToolTip; } else if (e.ColumnIndex == _taskGridInfo.CheckedStatusColIdx) { TaskBase task = Tasks[e.RowIndex]; switch (task.CheckedStatus) { case CheckedStatus.Unknown: e.Value = global::C1ReportsScheduler.Properties.Resources.GrayBall; _taskGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; case CheckedStatus.Invalid: e.Value = global::C1ReportsScheduler.Properties.Resources.StateError; _taskGrid[e.ColumnIndex, e.RowIndex].ToolTipText = GetTaskErrorMessage(task); break; case CheckedStatus.CheckedOk: e.Value = global::C1ReportsScheduler.Properties.Resources.StateOk; _taskGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; case CheckedStatus.Working: e.Value = global::C1ReportsScheduler.Properties.Resources.Working; _taskGrid[e.ColumnIndex, e.RowIndex].ToolTipText = string.Empty; break; default: System.Diagnostics.Debug.Assert(false); break; } } else if (e.ColumnIndex == _taskGridInfo.ReportNameColIdx) { TaskBase task = Tasks[e.RowIndex]; switch (task.ReportKind) { case ReportKind.XmlReport: case ReportKind.ImportedReport: _taskGrid[e.ColumnIndex, e.RowIndex].ReadOnly = false; break; case ReportKind.C1dDocument: case ReportKind.Program: _taskGrid[e.ColumnIndex, e.RowIndex].ReadOnly = true; break; default: System.Diagnostics.Debug.Assert(false); break; } } }