source: branches/eraser6/Eraser/MainForm.cs @ 773

Revision 773, 10.6 KB checked in by lowjoel, 6 years ago (diff)

Eraser now takes two command parameters for GUI mode: --atRestart and --quiet.

  • --atRestart tells Eraser that the program was started at a system boot and should run the erase at restart tasks
  • --quiet tells Eraser to run without displaying any UI and to hide itself in the system notification area
  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008 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.Drawing.Drawing2D;
28using System.Text;
29using System.Windows.Forms;
30using Eraser.Util;
31using Eraser.Manager;
32using Eraser.Properties;
33
34namespace Eraser
35{
36    public partial class MainForm : Form
37    {
38        public enum Pages
39        {
40            SCHEDULER = 0,
41            SETTINGS
42        }
43
44        private ToolBar ToolBar = new ToolBar();
45        private BasePanel CurrPage = null;
46        private SchedulerPanel SchedulerPage = new SchedulerPanel();
47        private SettingsPanel SettingsPage = new SettingsPanel();
48
49        public MainForm()
50        {
51            InitializeComponent();
52
53            //Connect to the executor task processing and processed events.
54            Program.eraserClient.TaskProcessing +=
55                new Executor.TaskProcessingEvent(OnTaskProcessing);
56            Program.eraserClient.TaskProcessed +=
57                new Executor.TaskProcessedEvent(OnTaskProcessed);
58
59            //Check the notification area context menu's minimise to tray item.
60            hideWhenMinimiseToolStripMenuItem.Checked = HideWhenMinimised;
61
62            //Create the toolbar control
63            ToolBar.Name = "toolBar";
64            ToolBar.Location = new Point(14, 27);
65            ToolBar.Size = new Size(500, 26);
66            ToolBar.TabIndex = 1;
67            Controls.Add(ToolBar);
68
69            ToolBarItem schedule = new ToolBarItem();
70            schedule.Bitmap = Properties.Resources.ToolbarSchedule;
71            schedule.Text = S._("Erase Schedule");
72            schedule.Menu = toolbarScheduleMenu;
73            schedule.ToolbarItemClicked += delegate(object sender, EventArgs args)
74            {
75                ChangePage(Pages.SCHEDULER);
76            };
77            ToolBar.Items.Add(schedule);
78
79            ToolBarItem settings = new ToolBarItem();
80            settings.Bitmap = Properties.Resources.ToolbarSettings;
81            settings.Text = S._("Settings");
82            settings.ToolbarItemClicked += delegate(object sender, EventArgs args)
83            {
84                ChangePage(Pages.SETTINGS);
85            };
86            ToolBar.Items.Add(settings);
87
88            ToolBarItem help = new ToolBarItem();
89            help.Bitmap = Properties.Resources.ToolbarHelp;
90            help.Text = S._("Help");
91            help.Menu = toolbarHelpMenu;
92            ToolBar.Items.Add(help);
93
94            //Set the docking style for each of the pages
95            SchedulerPage.Dock = DockStyle.Fill;
96
97            //Show the default page.
98            ChangePage(Pages.SCHEDULER);
99        }
100
101        /// <summary>
102        /// Diplays the given title, message and icon as a system notification area balloon.
103        /// </summary>
104        /// <param name="title">The title of the balloon.</param>
105        /// <param name="message">The message to display.</param>
106        /// <param name="icon">The icon to show.</param>
107        public void ShowNotificationBalloon(string title, string message, ToolTipIcon icon)
108        {
109            notificationIcon.BalloonTipTitle = title;
110            notificationIcon.BalloonTipText = message;
111            notificationIcon.BalloonTipIcon = icon;
112            notificationIcon.ShowBalloonTip(0);
113        }
114
115        /// <summary>
116        /// Changes the active page displayed in the form.
117        /// </summary>
118        /// <param name="page">The new page to change to. No action is done when the
119        /// current page is the same as the new page requested</param>
120        public void ChangePage(Pages page)
121        {
122            BasePanel oldPage = CurrPage;
123            switch (page)
124            {
125                case Pages.SCHEDULER:
126                    CurrPage = SchedulerPage;
127                    break;
128                case Pages.SETTINGS:
129                    CurrPage = SettingsPage;
130                    break;
131            }
132
133            if (oldPage != CurrPage)
134            {
135                contentPanel.SuspendLayout();
136                contentPanel.Controls.Remove(oldPage);
137                contentPanel.Controls.Add(CurrPage);
138
139                if (CurrPage.Dock == DockStyle.None)
140                {
141                    CurrPage.Anchor = AnchorStyles.Left | AnchorStyles.Right |
142                        AnchorStyles.Top;
143                    CurrPage.Left = 0;
144                    CurrPage.Top = 0;
145                    CurrPage.Width = contentPanel.Width;
146                }
147                contentPanel.ResumeLayout();
148            }
149        }
150
151        private static GraphicsPath CreateRoundRect(float X, float Y, float width,
152            float height, float radius)
153        {
154            GraphicsPath result = new GraphicsPath();
155
156            //Top line.
157            result.AddLine(X + radius, Y, X + width - 2 * radius, Y);
158
159            //Top-right corner
160            result.AddArc(X + width - 2 * radius, Y, 2 * radius, 2 * radius, 270, 90);
161
162            //Right line.
163            result.AddLine(X + width, Y + radius, X + width, Y + height - 2 * radius);
164
165            //Bottom-right corner
166            result.AddArc(X + width - 2 * radius, Y + height - 2 * radius, 2 * radius, 2 * radius, 0, 90);
167
168            //Bottom line.
169            result.AddLine(X + width - 2 * radius, Y + height, X + radius, Y + height);
170
171            //Bottom-left corner
172            result.AddArc(X, Y + height - 2 *radius, 2 * radius, 2 * radius, 90, 90);
173
174            //Left line
175            result.AddLine(X, Y + height - 2 * radius, X, Y + radius);
176
177            //Top-left corner
178            result.AddArc(X, Y, 2 * radius, 2 * radius, 180, 90);
179            result.CloseFigure();
180
181            return result;
182        }
183
184        private void DrawBackground(Graphics dc)
185        {
186            //Draw the base background
187            dc.FillRectangle(new SolidBrush(Color.FromArgb(unchecked((int)0xFF292929))),
188                new Rectangle(new Point(0, 0), Size));
189
190            //Then the side gradient
191            dc.FillRectangle(new LinearGradientBrush(new Rectangle(0, 0, 338, Math.Max(1, ClientSize.Height)),
192                    Color.FromArgb(unchecked((int)0xFF363636)),
193                    Color.FromArgb(unchecked((int)0xFF292929)), 0.0),
194                0, 0, 338, ClientSize.Height);
195
196            //Draw the top background
197            dc.FillRectangle(new SolidBrush(Color.FromArgb(unchecked((int)0xFF414141))),
198                new Rectangle(0, 0, ClientSize.Width, 32));
199
200            //The top gradient
201            dc.DrawImage(Properties.Resources.BackgroundGradient, new Point(0, 0));
202
203            //And the logo
204            Bitmap logo = Properties.Resources.BackgroundLogo;
205            dc.DrawImage(logo, new Rectangle(ClientSize.Width - logo.Width - 10,
206                (contentPanel.Top - logo.Height) / 2, logo.Width, logo.Height));
207
208            dc.SmoothingMode = SmoothingMode.AntiAlias;
209            dc.FillPath(Brushes.White, CreateRoundRect(11, 74, contentPanel.Width + 8, ClientSize.Height - 85, 3));
210        }
211
212        private void MainForm_Paint(object sender, PaintEventArgs e)
213        {
214            e.Graphics.SetClip(new Rectangle(0, 0, Width, Height), CombineMode.Intersect);
215            DrawBackground(e.Graphics);
216        }
217
218        private void MainForm_Resize(object sender, EventArgs e)
219        {
220            if (WindowState != FormWindowState.Minimized)
221            {
222                Bitmap bmp = new Bitmap(Width, Height);
223                Graphics dc = Graphics.FromImage(bmp);
224                DrawBackground(dc);
225
226                CreateGraphics().DrawImage(bmp, new Point(0, 0));
227            }
228            else if (HideWhenMinimised)
229            {
230                Hide();
231            }
232        }
233
234        private void newTaskToolStripMenuItem_Click(object sender, EventArgs e)
235        {
236            ToolStripDropDownItem item = sender as ToolStripDropDownItem;
237            using (TaskPropertiesForm form = new TaskPropertiesForm())
238            {
239                if (form.ShowDialog() == DialogResult.OK)
240                {
241                    Task task = form.Task;
242                    Program.eraserClient.AddTask(ref task);
243                }
244            }
245        }
246
247        private void checkForUpdatesToolStripMenuItem_Click(object sender, EventArgs e)
248        {
249            using (UpdateForm form = new UpdateForm())
250            {
251                form.ShowDialog();
252            }
253        }
254
255        private void aboutEraserToolStripMenuItem_Click(object sender, EventArgs e)
256        {
257            using (AboutForm form = new AboutForm(this))
258            {
259                form.ShowDialog();
260            }
261        }
262
263        #region Task processing code (for notification area animation)
264        void OnTaskProcessing(Eraser.Manager.Task task)
265        {
266            if (InvokeRequired)
267            {
268                Invoke(new Executor.TaskProcessingEvent(OnTaskProcessing), task);
269                return;
270            }
271
272            string iconText = S._("Eraser") + " - " + S._("Processing:") + ' ' + task.UIText;
273            if (iconText.Length >= 64)
274                iconText = iconText.Remove(60) + "...";
275
276            ProcessingAnimationFrame = 0;
277            notificationIcon.Text = iconText;
278            notificationIconTimer.Enabled = true;
279        }
280
281        void OnTaskProcessed(Eraser.Manager.Task task)
282        {
283            if (InvokeRequired)
284            {
285                Invoke(new Executor.TaskProcessedEvent(OnTaskProcessed), task);
286                return;
287            }
288
289            //Reset the notification area icon.
290            notificationIconTimer.Enabled = false;
291            if (notificationIcon.Icon != null)
292            {
293                ComponentResourceManager resources = new ComponentResourceManager(typeof(MainForm));
294                resources.ApplyResources(notificationIcon, "notificationIcon");
295            }
296        }
297
298        private void notificationIconTimer_Tick(object sender, EventArgs e)
299        {
300            notificationIcon.Icon = ProcessingAnimationFrames[ProcessingAnimationFrame++];
301            if (ProcessingAnimationFrame == ProcessingAnimationFrames.Length)
302                ProcessingAnimationFrame = 0;
303        }
304
305        private int ProcessingAnimationFrame = 0;
306        private Icon[] ProcessingAnimationFrames = new Icon[] {
307            Resources.NotifyBusy1,
308            Resources.NotifyBusy2,
309            Resources.NotifyBusy3,
310            Resources.NotifyBusy4,
311            Resources.NotifyBusy5,
312            Resources.NotifyBusy4,
313            Resources.NotifyBusy3,
314            Resources.NotifyBusy2,
315            Resources.NotifyBusy1
316        };
317        #endregion
318
319        #region Minimise to tray code
320        private bool HideWhenMinimised
321        {
322            get
323            {
324                Manager.Settings settings =
325                    ManagerLibrary.Instance.SettingsManager.ModuleSettings;
326                return settings["HideWhenMinimised"] == null ? true :
327                    (bool)settings["HideWhenMinimised"];
328            }
329
330            set
331            {
332                Manager.Settings settings =
333                    ManagerLibrary.Instance.SettingsManager.ModuleSettings;
334                settings["HideWhenMinimised"] = hideWhenMinimiseToolStripMenuItem.Checked;
335            }
336        }
337
338        private bool closedFromNotificationIcon = false;
339        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
340        {
341            if (HideWhenMinimised && (
342                !closedFromNotificationIcon || e.CloseReason != CloseReason.UserClosing))
343            {
344                e.Cancel = true;
345                Hide();
346            }
347        }
348
349        private void openToolStripMenuItem_Click(object sender, EventArgs e)
350        {
351            Visible = true;
352            WindowState = FormWindowState.Normal;
353            Activate();
354        }
355
356        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
357        {
358            closedFromNotificationIcon = true;
359            Close();
360            Application.Exit();
361        }
362
363        private void hideWhenMinimiseToolStripMenuItem_Click(object sender, EventArgs e)
364        {
365            HideWhenMinimised = hideWhenMinimiseToolStripMenuItem.Checked;
366        }
367        #endregion
368    }
369}
Note: See TracBrowser for help on using the repository browser.