source: trunk/eraser/Eraser/TaskPropertiesForm.cs @ 2312

Revision 2312, 15.5 KB checked in by lowjoel, 2 years ago (diff)

Be explicit about the behaviour of the schedule check boxes. Since we handle the checking ourselves, we need to be careful of when the boxes are triggered and reset the states properly. Fixes the bug described in http://bbs.heidi.ie/viewtopic.php?p=24697#p24697

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008-2010 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By:
6 *
7 * This file is part of Eraser.
8 *
9 * Eraser is free software: you can redistribute it and/or modify it under the
10 * terms of the GNU General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option) any later
12 * version.
13 *
14 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
15 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
16 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17 *
18 * A copy of the GNU General Public License can be found at
19 * <http://www.gnu.org/licenses/>.
20 */
21
22using System;
23using System.Collections.Generic;
24using System.ComponentModel;
25using System.Data;
26using System.Drawing;
27using System.Text;
28using System.Windows.Forms;
29
30using System.Globalization;
31using Eraser.Manager;
32using Eraser.Util;
33
34namespace Eraser
35{
36    public partial class TaskPropertiesForm : Form
37    {
38        public TaskPropertiesForm()
39        {
40            InitializeComponent();
41            Theming.ApplyTheme(this);
42            scheduleTime.CustomFormat = DateTimeFormatInfo.CurrentInfo.ShortTimePattern;
43
44            //Set a default task type
45            typeManual.Checked = true;
46            scheduleDaily.Checked = true;
47            //panelresize(schedulePanel);
48            this.AutoScaleMode = AutoScaleMode.None;
49        }
50
51        /// <summary>
52        /// Sets or retrieves the task object to be edited or being edited.
53        /// </summary>
54        public Task Task
55        {
56            get { UpdateTaskFromUI(); return task; }
57            set { task = value; UpdateUIFromTask(); }
58        }
59
60        /// <summary>
61        /// Updates the local task object from the UI elements.
62        /// </summary>
63        private void UpdateTaskFromUI()
64        {
65            //Set the name of the task
66            task.Name = name.Text;
67
68            //And the schedule, if selected.
69            if (typeManual.Checked)
70            {
71                task.Schedule = Schedule.RunManually;
72            }
73            else if (typeImmediate.Checked)
74            {
75                task.Schedule = Schedule.RunNow;
76            }
77            else if (typeRestart.Checked)
78            {
79                task.Schedule = Schedule.RunOnRestart;
80            }
81            else if (typeRecurring.Checked)
82            {
83                RecurringSchedule schedule = new RecurringSchedule();
84                schedule.ExecutionTime = new DateTime(1, 1, 1, scheduleTime.Value.Hour,
85                    scheduleTime.Value.Minute, scheduleTime.Value.Second);
86
87                if (scheduleDaily.Checked)
88                {
89                    if (scheduleDailyByDay.Checked)
90                    {
91                        schedule.ScheduleType = RecurringScheduleUnit.Daily;
92                        schedule.Frequency = (int)scheduleDailyByDayFreq.Value;
93                    }
94                    else
95                    {
96                        schedule.ScheduleType = RecurringScheduleUnit.Weekdays;
97                    }
98                }
99                else if (scheduleWeekly.Checked)
100                {
101                    schedule.ScheduleType = RecurringScheduleUnit.Weekly;
102                    schedule.Frequency = (int)scheduleWeeklyFreq.Value;
103                    DaysOfWeek weeklySchedule = 0;
104                    if (scheduleWeeklyMonday.Checked)
105                        weeklySchedule |= DaysOfWeek.Monday;
106                    if (scheduleWeeklyTuesday.Checked)
107                        weeklySchedule |= DaysOfWeek.Tuesday;
108                    if (scheduleWeeklyWednesday.Checked)
109                        weeklySchedule |= DaysOfWeek.Wednesday;
110                    if (scheduleWeeklyThursday.Checked)
111                        weeklySchedule |= DaysOfWeek.Thursday;
112                    if (scheduleWeeklyFriday.Checked)
113                        weeklySchedule |= DaysOfWeek.Friday;
114                    if (scheduleWeeklySaturday.Checked)
115                        weeklySchedule |= DaysOfWeek.Saturday;
116                    if (scheduleWeeklySunday.Checked)
117                        weeklySchedule |= DaysOfWeek.Sunday;
118                    schedule.WeeklySchedule = weeklySchedule;
119                }
120                else if (scheduleMonthly.Checked)
121                {
122                    schedule.ScheduleType = RecurringScheduleUnit.Monthly;
123                    schedule.Frequency = (int)scheduleMonthlyFreq.Value;
124                    schedule.MonthlySchedule = (int)scheduleMonthlyDayNumber.Value;
125                }
126                else
127                    throw new ArgumentException("No such scheduling method.");
128
129                task.Schedule = schedule;
130            }
131        }
132
133        /// <summary>
134        /// Updates the UI elements to reflect the data in the Task object.
135        /// </summary>
136        private void UpdateUIFromTask()
137        {
138            //Set the name of the task
139            name.Text = task.Name;
140
141            //The data
142            foreach (ErasureTarget target in task.Targets)
143            {
144                ListViewItem item;
145                if (System.IO.File.Exists(target.UIText))
146                {
147                    item = data.Items.Add(System.IO.Path.GetFileName(target.UIText));
148                    item.ToolTipText = target.UIText;
149                }
150                else if (System.IO.Directory.Exists(target.UIText))
151                {
152                    item = data.Items.Add(System.IO.Path.GetDirectoryName(target.UIText));
153                    item.ToolTipText = target.UIText;
154                }
155                else
156                {
157                    item = data.Items.Add(target.UIText);
158                }
159               
160                item.SubItems.Add(target.Method == ErasureMethodRegistrar.Default ?
161                    S._("(default)") : target.Method.Name);
162                item.Tag = target;
163            }
164
165            //And the schedule, if selected.
166            if (task.Schedule == Schedule.RunManually)
167            {
168                typeManual.Checked = true;
169            }
170            else if (task.Schedule == Schedule.RunNow)
171            {
172                typeImmediate.Checked = true;
173            }
174            else if (task.Schedule == Schedule.RunOnRestart)
175            {
176                typeRestart.Checked = true;
177            }
178            else
179            {
180                typeRecurring.Checked = true;
181                RecurringSchedule schedule = (RecurringSchedule)task.Schedule;
182                scheduleTime.Value = scheduleTime.MinDate.Add(schedule.ExecutionTime.TimeOfDay);
183
184                switch (schedule.ScheduleType)
185                {
186                    case RecurringScheduleUnit.Daily:
187                        scheduleDaily.Checked = true;
188                        scheduleDailyByDay.Checked = true;
189                        scheduleDailyByDayFreq.Value = schedule.Frequency;
190                        break;
191                    case RecurringScheduleUnit.Weekdays:
192                        scheduleDaily.Checked = true;
193                        scheduleDailyByWeekday.Checked = true;
194                        break;
195                    case RecurringScheduleUnit.Weekly:
196                        scheduleWeeklyFreq.Value = schedule.Frequency;
197                        scheduleWeekly.Checked = true;
198                        scheduleWeeklyMonday.Checked =
199                            (schedule.WeeklySchedule & DaysOfWeek.Monday) != 0;
200                        scheduleWeeklyTuesday.Checked =
201                            (schedule.WeeklySchedule & DaysOfWeek.Tuesday) != 0;
202                        scheduleWeeklyWednesday.Checked =
203                            (schedule.WeeklySchedule & DaysOfWeek.Wednesday) != 0;
204                        scheduleWeeklyThursday.Checked =
205                            (schedule.WeeklySchedule & DaysOfWeek.Thursday) != 0;
206                        scheduleWeeklyFriday.Checked =
207                            (schedule.WeeklySchedule & DaysOfWeek.Friday) != 0;
208                        scheduleWeeklySaturday.Checked =
209                            (schedule.WeeklySchedule & DaysOfWeek.Saturday) != 0;
210                        scheduleWeeklySunday.Checked =
211                            (schedule.WeeklySchedule & DaysOfWeek.Sunday) != 0;
212                        break;
213                    case RecurringScheduleUnit.Monthly:
214                        scheduleMonthly.Checked = true;
215                        scheduleMonthlyFreq.Value = schedule.Frequency;
216                        scheduleMonthlyDayNumber.Value = schedule.MonthlySchedule;
217                        break;
218                    default:
219                        throw new ArgumentException("Unknown schedule type.");
220                }
221            }
222        }
223
224        /// <summary>
225        /// Triggered when the user clicks on the Add Data button.
226        /// </summary>
227        /// <param name="sender">The button.</param>
228        /// <param name="e">Event argument.</param>
229        private void dataAdd_Click(object sender, EventArgs e)
230        {
231            using (TaskDataSelectionForm form = new TaskDataSelectionForm())
232            {
233                if (form.ShowDialog() == DialogResult.OK)
234                {
235                    ErasureTarget target = form.Target;
236                    ListViewItem item = data.Items.Add(target.UIText);
237                    item.SubItems.Add(target.Method == ErasureMethodRegistrar.Default ?
238                        S._("(default)") : target.Method.Name);
239                    item.Tag = target;
240
241                    task.Targets.Add(target);
242                    errorProvider.Clear();
243                }
244            }
245        }
246
247        /// <summary>
248        /// Generated when the user double-clicks an item in the list-view.
249        /// </summary>
250        /// <param name="sender">The list-view which generated this event.</param>
251        /// <param name="e">Event argument.</param>
252        private void data_ItemActivate(object sender, EventArgs e)
253        {
254            using (TaskDataSelectionForm form = new TaskDataSelectionForm())
255            {
256                ListViewItem item = data.SelectedItems[0];
257                form.Target = task.Targets[item.Index];
258
259                if (form.ShowDialog() == DialogResult.OK)
260                {
261                    ErasureTarget target = form.Target;
262                    task.Targets.RemoveAt(item.Index);
263                    task.Targets.Insert(item.Index, target);
264
265                    item.Tag = target;
266                    item.Text = target.UIText;
267                    item.SubItems[1].Text = target.Method == ErasureMethodRegistrar.Default ?
268                        S._("(default)") : target.Method.Name;
269                }
270            }
271        }
272
273        private void data_DragEnter(object sender, DragEventArgs e)
274        {
275            //Get the list of files.
276            bool recycleBin = false;
277            List<string> paths = new List<string>(TaskDragDropHelper.GetFiles(e, out recycleBin));
278
279            for (int i = 0; i < paths.Count; ++i)
280            {
281                //Just use the file name/directory name.
282                paths[i] = System.IO.Path.GetFileName(paths[i]);
283            }
284
285            //Add the recycle bin if it was dropped.
286            if (recycleBin)
287                paths.Add(S._("Recycle Bin"));
288
289            string description = null;
290            if (paths.Count == 0)
291            {
292                e.Effect = DragDropEffects.None;
293                description = S._("Cannot add the selected items");
294            }
295            else
296            {
297                e.Effect = DragDropEffects.Copy;
298                description = S._("Add {0}");
299            }
300
301            TaskDragDropHelper.OnDragEnter(this, e, description, paths);
302        }
303
304        private void data_DragLeave(object sender, EventArgs e)
305        {
306            DropTargetHelper.DragLeave((Control)sender);
307        }
308
309        private void data_DragOver(object sender, DragEventArgs e)
310        {
311            DropTargetHelper.DragOver(new Point(e.X, e.Y), e.Effect);
312        }
313
314        private void data_DragDrop(object sender, DragEventArgs e)
315        {
316            TaskDragDropHelper.OnDrop(e);
317            if (e.Effect == DragDropEffects.None)
318                return;
319
320            //Determine our action.
321            bool recycleBin = false;
322            List<string> paths = new List<string>(TaskDragDropHelper.GetFiles(e, out recycleBin));
323
324            //Add the targets
325            foreach (ErasureTarget target in TaskDragDropHelper.GetTargets(paths, recycleBin))
326            {
327                ListViewItem item = data.Items.Add(target.UIText);
328                item.SubItems.Add(target.Method == ErasureMethodRegistrar.Default ?
329                    S._("(default)") : target.Method.Name);
330                item.Tag = target;
331                Task.Targets.Add(target);
332
333                errorProvider.Clear();
334            }
335        }
336
337        /// <summary>
338        /// Generated when the user right-clicks on the data selection list-view.
339        /// </summary>
340        /// <param name="sender">The menu being opened.</param>
341        /// <param name="e">Event argument.</param>
342        private void dataContextMenuStrip_Opening(object sender, CancelEventArgs e)
343        {
344            if (data.SelectedIndices.Count == 0)
345            {
346                e.Cancel = true;
347                return;
348            }
349        }
350
351        /// <summary>
352        /// Generated when the user selects the menu itm to remove the selected
353        /// data from the list of data to erase.
354        /// </summary>
355        /// <param name="sender">The object triggering the event.</param>
356        /// <param name="e">Event argument.</param>
357        private void deleteDataToolStripMenuItem_Click(object sender, EventArgs e)
358        {
359            if (data.SelectedIndices.Count == 0)
360                return;
361
362            foreach (ListViewItem obj in data.SelectedItems)
363            {
364                task.Targets.Remove((ErasureTarget)obj.Tag);
365                data.Items.Remove(obj);
366            }
367        }
368
369        /// <summary>
370        /// Generated when the task schedule type changes.
371        /// </summary>
372        /// <param name="sender">The object triggering the event.</param>
373        /// <param name="e">Event argument.</param>
374        private void taskType_CheckedChanged(object sender, EventArgs e)
375        {
376            scheduleTimeLbl.Enabled = scheduleTime.Enabled = schedulePattern.Enabled =
377                scheduleDaily.Enabled = scheduleWeekly.Enabled =
378                scheduleMonthly.Enabled = typeRecurring.Checked;
379            nonRecurringPanel.Visible = !typeRecurring.Checked;
380           
381            scheduleSpan_CheckedChanged(sender, e);
382        }
383
384        /// <summary>
385        /// Generated when any of the schedule spans have been clicked.
386        /// </summary>
387        /// <param name="sender">The radio button triggering the event.</param>
388        /// <param name="e">Event argument.</param>
389        private void scheduleSpan_Clicked(object sender, EventArgs e)
390        {
391            //Check the selected radio button
392            scheduleDaily.Checked = sender == scheduleDaily;
393            scheduleWeekly.Checked = sender == scheduleWeekly;
394            scheduleMonthly.Checked = sender == scheduleMonthly;
395
396            //Then trigger the checked changed event.
397            scheduleSpan_CheckedChanged(sender, e);
398        }
399
400        /// <summary>
401        /// Generated when the scheduling frequency is changed.
402        /// </summary>
403        /// <param name="sender">The object triggering the event.</param>
404        /// <param name="e">Event argument.</param>
405        private void scheduleSpan_CheckedChanged(object sender, EventArgs e)
406        {
407            if (((RadioButton)sender).Checked)
408            {
409                RadioButton[] group = new RadioButton[] {
410                    scheduleDaily, scheduleWeekly, scheduleMonthly
411                };
412                foreach (RadioButton button in group)
413                    if (button != sender)
414                        button.Checked = false;
415            }
416
417            scheduleDailyByDay.Enabled = scheduleDailyByDayLbl.Enabled =
418                scheduleDailyByWeekday.Enabled = scheduleDaily.Checked &&
419                typeRecurring.Checked;
420            scheduleWeeklyLbl.Enabled = scheduleWeeklyFreq.Enabled =
421                scheduleWeeklyFreqLbl.Enabled = scheduleWeeklyMonday.Enabled =
422                scheduleWeeklyTuesday.Enabled = scheduleWeeklyWednesday.Enabled =
423                scheduleWeeklyThursday.Enabled = scheduleWeeklyFriday.Enabled =
424                scheduleWeeklySaturday.Enabled = scheduleWeeklySunday.Enabled =
425                scheduleWeekly.Checked && typeRecurring.Checked;
426            scheduleMonthlyLbl.Enabled = scheduleMonthlyDayNumber.Enabled =
427                scheduleMonthlyEveryLbl.Enabled = scheduleMonthlyFreq.Enabled =
428                scheduleMonthlyMonthLbl.Enabled = scheduleMonthly.Checked &&
429                typeRecurring.Checked;
430
431            scheduleDailySpan_CheckedChanged(sender, e);
432        }
433
434        /// <summary>
435        /// Generated when any of the daily frequency radio buttons are clicked.
436        /// </summary>
437        /// <param name="sender">The radio button which triggers the event.</param>
438        /// <param name="e">Event argument.</param>
439        private void scheduleDailySpan_Clicked(object sender, EventArgs e)
440        {
441            scheduleDailyByDay.CheckedChanged -= scheduleDailySpan_CheckedChanged;
442            scheduleDailyByWeekday.CheckedChanged -= scheduleDailySpan_CheckedChanged;
443
444            scheduleDailyByDay.Checked = sender == scheduleDailyByDay;
445            scheduleDailyByWeekday.Checked = sender == scheduleDailyByWeekday;
446
447            scheduleDailyByDay.CheckedChanged += scheduleDailySpan_CheckedChanged;
448            scheduleDailyByWeekday.CheckedChanged += scheduleDailySpan_CheckedChanged;
449           
450            scheduleDailySpan_CheckedChanged(sender, e);
451        }
452
453        /// <summary>
454        /// Generated when the daily frequency argument is changed.
455        /// </summary>
456        /// <param name="sender">The object triggering the event.</param>
457        /// <param name="e">Event argument.</param>
458        private void scheduleDailySpan_CheckedChanged(object sender, EventArgs e)
459        {
460            scheduleDailyByDayLbl.Enabled = scheduleDailyByDayFreq.Enabled =
461                scheduleDailyByDay.Checked && scheduleDaily.Checked && typeRecurring.Checked;
462        }
463
464        /// <summary>
465        /// Generated when the dialog is closed.
466        /// </summary>
467        /// <param name="sender">The object triggering the event.</param>
468        /// <param name="e">Event argument.</param>
469        private void ok_Click(object sender, EventArgs e)
470        {
471            if (data.Items.Count == 0)
472            {
473                errorProvider.SetIconPadding(data, -16);
474                errorProvider.SetIconAlignment(data, ErrorIconAlignment.BottomRight);
475                errorProvider.SetError(data, S._("The task has no data to erase."));
476                container.SelectedIndex = 0;
477                return;
478            }
479            else if (typeRecurring.Checked && scheduleWeekly.Checked)
480            {
481                if (!scheduleWeeklyMonday.Checked && !scheduleWeeklyTuesday.Checked &&
482                    !scheduleWeeklyWednesday.Checked && !scheduleWeeklyThursday.Checked &&
483                    !scheduleWeeklyFriday.Checked && !scheduleWeeklySaturday.Checked &&
484                    !scheduleWeeklySunday.Checked)
485                {
486                    errorProvider.SetIconPadding(scheduleWeeklyDays, -16);
487                    errorProvider.SetError(scheduleWeeklyDays, S._("The task needs to run " +
488                        "on at least one day a week"));
489                    container.SelectedIndex = 1;
490                    return;
491                }
492            }
493
494            errorProvider.Clear();
495
496            //Close the dialog
497            DialogResult = DialogResult.OK;
498            Close();
499        }
500
501        /// <summary>
502        /// The task being edited.
503        /// </summary>
504        private Task task = new Task();
505    }
506}
Note: See TracBrowser for help on using the repository browser.