/*

   This Source Code Form is subject to the terms of the Mozilla Public

   License, v. 2.0. If a copy of the MPL was not distributed with this

   file, You can obtain one at http://mozilla.org/MPL/2.0/.

   Copyright (C) 2009-2013 Michael Möller <mmoeller@openhardwaremonitor.org>

 	Copyright (C) 2010 Paul Werelds <paul@werelds.net>

 	Copyright (C) 2012 Prince Samuel <prince.samuel@gmail.com>

 */

 using System;

 using System.Collections.Generic;

 using System.Collections.ObjectModel;

 using System.ComponentModel;

 using System.Drawing;

 using System.IO;

 using System.Reflection;

 using System.Windows.Forms;

 using System.Windows;

 using Aga.Controls.Tree;

 using Aga.Controls.Tree.NodeControls;

 using OpenHardwareMonitor.Hardware;

 using OpenHardwareMonitor.WMI;

 using OpenHardwareMonitor.Utilities;

 namespace OpenHardwareMonitor.GUI {

   public partial class MainForm : Form {

     private PersistentSettings settings;

     private UnitManager unitManager;

     private Computer computer;

     private Node root;

     private TreeModel treeModel;

     private IDictionary<ISensor, Color> sensorPlotColors = 

       new Dictionary<ISensor, Color>();

     private Color[] plotColorPalette;

     private SystemTray systemTray;

     private SoundGraphDisplay soundGraphDisplay;

     private bool displayTick;

     private StartupManager startupManager = new StartupManager();

     private UpdateVisitor updateVisitor = new UpdateVisitor();

     private SensorGadget gadget;

     private Form plotForm;

     private PlotPanel plotPanel;

     private UserOption showHiddenSensors;

     private UserOption showPlot;

     private UserOption showValue;

     private UserOption showMin;

     private UserOption showMax;

     private UserOption startMinimized;

     private UserOption minimizeToTray;

     private UserOption minimizeOnClose;

     private UserOption autoStart;

     private UserOption frontViewPacked; //Tells whether FrontView should cycle or pack sensors

     private UserOption frontViewDisplayTime; //Tells whether or not FrontView should display current time

     private UserOption readMainboardSensors;

     private UserOption readCpuSensors;

     private UserOption readRamSensors;

     private UserOption readGpuSensors;

     private UserOption readFanControllersSensors;

     private UserOption readHddSensors;

     private UserOption showGadget;

     private UserRadioGroup plotLocation;

     private WmiProvider wmiProvider;

     private UserOption runWebServer;

     private HttpServer server;

     private UserOption logSensors;

     private UserRadioGroup loggingInterval;

     private Logger logger;

     private bool selectionDragging = false;

     public MainForm() {      

       InitializeComponent();

       // check if the OpenHardwareMonitorLib assembly has the correct version

       if (Assembly.GetAssembly(typeof(Computer)).GetName().Version !=

         Assembly.GetExecutingAssembly().GetName().Version) {

         MessageBox.Show(

           "The version of the file OpenHardwareMonitorLib.dll is incompatible.",

           "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

         Environment.Exit(0);

       }

       this.settings = new PersistentSettings();      

       this.settings.Load(Path.ChangeExtension(

         Application.ExecutablePath, ".config"));

       this.unitManager = new UnitManager(settings);

       // make sure the buffers used for double buffering are not disposed 

       // after each draw call

       BufferedGraphicsManager.Current.MaximumBuffer =

         Screen.PrimaryScreen.Bounds.Size;  

       // set the DockStyle here, to avoid conflicts with the MainMenu

       this.splitContainer.Dock = DockStyle.Fill;

       this.Font = SystemFonts.MessageBoxFont;

       treeView.Font = SystemFonts.MessageBoxFont;

       plotPanel = new PlotPanel(settings, unitManager);

       plotPanel.Font = SystemFonts.MessageBoxFont;

       plotPanel.Dock = DockStyle.Fill;

       nodeCheckBox.IsVisibleValueNeeded += nodeCheckBox_IsVisibleValueNeeded;

       nodeTextBoxText.DrawText += nodeTextBoxText_DrawText;

       nodeTextBoxValue.DrawText += nodeTextBoxText_DrawText;

       nodeTextBoxMin.DrawText += nodeTextBoxText_DrawText;

       nodeTextBoxMax.DrawText += nodeTextBoxText_DrawText;

       nodeTextBoxText.EditorShowing += nodeTextBoxText_EditorShowing;

       foreach (TreeColumn column in treeView.Columns) 

         column.Width = Math.Max(20, Math.Min(400,

           settings.GetValue("treeView.Columns." + column.Header + ".Width",

           column.Width)));

       treeModel = new TreeModel();

       root = new Node(System.Environment.MachineName);

       root.Image = Utilities.EmbeddedResources.GetImage("computer.png");

       treeModel.Nodes.Add(root);

       treeView.Model = treeModel;

       this.computer = new Computer(settings);

       systemTray = new SystemTray(computer, settings, unitManager);

       systemTray.HideShowCommand += hideShowClick;

       systemTray.ExitCommand += exitClick;

       soundGraphDisplay = new SoundGraphDisplay(computer, settings, unitManager);

       int p = (int)Environment.OSVersion.Platform;

       if ((p == 4) || (p == 128)) { // Unix

         treeView.RowHeight = Math.Max(treeView.RowHeight, 18); 

         splitContainer.BorderStyle = BorderStyle.None;

         splitContainer.Border3DStyle = Border3DStyle.Adjust;

         splitContainer.SplitterWidth = 4;

         treeView.BorderStyle = BorderStyle.Fixed3D;

         plotPanel.BorderStyle = BorderStyle.Fixed3D;

         gadgetMenuItem.Visible = false;

         minCloseMenuItem.Visible = false;

         minTrayMenuItem.Visible = false;

         startMinMenuItem.Visible = false;

       } else { // Windows

         treeView.RowHeight = Math.Max(treeView.Font.Height + 1, 18); 

         gadget = new SensorGadget(computer, settings, unitManager);

         gadget.HideShowCommand += hideShowClick;

         wmiProvider = new WmiProvider(computer);

       }

       logger = new Logger(computer);

       plotColorPalette = new Color[13];

       plotColorPalette[0] = Color.Blue;

       plotColorPalette[1] = Color.OrangeRed;

       plotColorPalette[2] = Color.Green;

       plotColorPalette[3] = Color.LightSeaGreen;

       plotColorPalette[4] = Color.Goldenrod;

       plotColorPalette[5] = Color.DarkViolet;

       plotColorPalette[6] = Color.YellowGreen;

       plotColorPalette[7] = Color.SaddleBrown;

       plotColorPalette[8] = Color.RoyalBlue;

       plotColorPalette[9] = Color.DeepPink;

       plotColorPalette[10] = Color.MediumSeaGreen;

       plotColorPalette[11] = Color.Olive;

       plotColorPalette[12] = Color.Firebrick;

       computer.HardwareAdded += new HardwareEventHandler(HardwareAdded);

       computer.HardwareRemoved += new HardwareEventHandler(HardwareRemoved);        

       computer.Open();

       timer.Enabled = true;

       showHiddenSensors = new UserOption("hiddenMenuItem", false,

         hiddenMenuItem, settings);

       showHiddenSensors.Changed += delegate(object sender, EventArgs e) {

         treeModel.ForceVisible = showHiddenSensors.Value;

       };

       showValue = new UserOption("valueMenuItem", true, valueMenuItem,

         settings);

       showValue.Changed += delegate(object sender, EventArgs e) {

         treeView.Columns[1].IsVisible = showValue.Value;

       };

       showMin = new UserOption("minMenuItem", false, minMenuItem, settings);

       showMin.Changed += delegate(object sender, EventArgs e) {

         treeView.Columns[2].IsVisible = showMin.Value;

       };

       showMax = new UserOption("maxMenuItem", true, maxMenuItem, settings);

       showMax.Changed += delegate(object sender, EventArgs e) {

         treeView.Columns[3].IsVisible = showMax.Value;

       };

       startMinimized = new UserOption("startMinMenuItem", false,

         startMinMenuItem, settings);

       minimizeToTray = new UserOption("minTrayMenuItem", true,

         minTrayMenuItem, settings);

       minimizeToTray.Changed += delegate(object sender, EventArgs e) {

         systemTray.IsMainIconEnabled = minimizeToTray.Value;

       };

       minimizeOnClose = new UserOption("minCloseMenuItem", false,

         minCloseMenuItem, settings);

       autoStart = new UserOption(null, startupManager.Startup,

         startupMenuItem, settings);

       autoStart.Changed += delegate(object sender, EventArgs e) {

         try {

           startupManager.Startup = autoStart.Value;

         } catch (InvalidOperationException) {

           MessageBox.Show("Updating the auto-startup option failed.", "Error", 

             MessageBoxButtons.OK, MessageBoxIcon.Error);

           autoStart.Value = startupManager.Startup;

         }

       };

       frontViewPacked = new UserOption("frontViewPackedMenuItem", false, frontViewPackedMenuItem, settings);

       frontViewDisplayTime = new UserOption("frontViewDisplayTimeMenuItem", false, frontViewDisplayTimeMenuItem, settings);

       readMainboardSensors = new UserOption("mainboardMenuItem", true, 

         mainboardMenuItem, settings);

       readMainboardSensors.Changed += delegate(object sender, EventArgs e) {

         computer.MainboardEnabled = readMainboardSensors.Value;

       };

       readCpuSensors = new UserOption("cpuMenuItem", true,

         cpuMenuItem, settings);

       readCpuSensors.Changed += delegate(object sender, EventArgs e) {

         computer.CPUEnabled = readCpuSensors.Value;

       };

       readRamSensors = new UserOption("ramMenuItem", true,

         ramMenuItem, settings);

       readRamSensors.Changed += delegate(object sender, EventArgs e) {

         computer.RAMEnabled = readRamSensors.Value;

       };

       readGpuSensors = new UserOption("gpuMenuItem", true,

         gpuMenuItem, settings);

       readGpuSensors.Changed += delegate(object sender, EventArgs e) {

         computer.GPUEnabled = readGpuSensors.Value;

       };

       readFanControllersSensors = new UserOption("fanControllerMenuItem", true,

         fanControllerMenuItem, settings);

       readFanControllersSensors.Changed += delegate(object sender, EventArgs e) {

         computer.FanControllerEnabled = readFanControllersSensors.Value;

       };

       readHddSensors = new UserOption("hddMenuItem", true, hddMenuItem,

         settings);

       readHddSensors.Changed += delegate(object sender, EventArgs e) {

         computer.HDDEnabled = readHddSensors.Value;

       };

       showGadget = new UserOption("gadgetMenuItem", false, gadgetMenuItem,

         settings);

       showGadget.Changed += delegate(object sender, EventArgs e) {

         if (gadget != null) 

           gadget.Visible = showGadget.Value;

       };

       celsiusMenuItem.Checked = 

         unitManager.TemperatureUnit == TemperatureUnit.Celsius;

       fahrenheitMenuItem.Checked = !celsiusMenuItem.Checked;

       server = new HttpServer(root, this.settings.GetValue("listenerPort", 8085));

       if (server.PlatformNotSupported) {

         webMenuItemSeparator.Visible = false;

         webMenuItem.Visible = false;

       }

       runWebServer = new UserOption("runWebServerMenuItem", false,

         runWebServerMenuItem, settings);

       runWebServer.Changed += delegate(object sender, EventArgs e) {

         if (runWebServer.Value)

           server.StartHTTPListener();

         else

           server.StopHTTPListener();

       };

       logSensors = new UserOption("logSensorsMenuItem", false, logSensorsMenuItem,

         settings);

       loggingInterval = new UserRadioGroup("loggingInterval", 0,

         new[] { log1sMenuItem, log2sMenuItem, log5sMenuItem, log10sMenuItem,

         log30sMenuItem, log1minMenuItem, log2minMenuItem, log5minMenuItem, 

         log10minMenuItem, log30minMenuItem, log1hMenuItem, log2hMenuItem, 

         log6hMenuItem},

         settings);

       loggingInterval.Changed += (sender, e) => {

         switch (loggingInterval.Value) {

           case 0: logger.LoggingInterval = new TimeSpan(0, 0, 1); break;

           case 1: logger.LoggingInterval = new TimeSpan(0, 0, 2); break;

           case 2: logger.LoggingInterval = new TimeSpan(0, 0, 5); break;

           case 3: logger.LoggingInterval = new TimeSpan(0, 0, 10); break;

           case 4: logger.LoggingInterval = new TimeSpan(0, 0, 30); break;

           case 5: logger.LoggingInterval = new TimeSpan(0, 1, 0); break;

           case 6: logger.LoggingInterval = new TimeSpan(0, 2, 0); break;

           case 7: logger.LoggingInterval = new TimeSpan(0, 5, 0); break;

           case 8: logger.LoggingInterval = new TimeSpan(0, 10, 0); break;

           case 9: logger.LoggingInterval = new TimeSpan(0, 30, 0); break;

           case 10: logger.LoggingInterval = new TimeSpan(1, 0, 0); break;

           case 11: logger.LoggingInterval = new TimeSpan(2, 0, 0); break;

           case 12: logger.LoggingInterval = new TimeSpan(6, 0, 0); break;

         }

       };

       InitializePlotForm();

       soundGraphDisplay.Init();

       startupMenuItem.Visible = startupManager.IsAvailable;

       if (startMinMenuItem.Checked) {

         if (!minTrayMenuItem.Checked) {

           WindowState = FormWindowState.Minimized;

           Show();

         }

       } else {

         Show();

       }

       // Create a handle, otherwise calling Close() does not fire FormClosed     

       IntPtr handle = Handle;

       // Make sure the settings are saved when the user logs off

       Microsoft.Win32.SystemEvents.SessionEnded += delegate {

         computer.Close();

         SaveConfiguration();

         if (runWebServer.Value) 

           server.Quit();

       };

     }

     private void InitializePlotForm() {

       plotForm = new Form();

       plotForm.FormBorderStyle = FormBorderStyle.SizableToolWindow;

       plotForm.ShowInTaskbar = false;

       plotForm.StartPosition = FormStartPosition.Manual;

       this.AddOwnedForm(plotForm);

       plotForm.Bounds = new Rectangle {

         X = settings.GetValue("plotForm.Location.X", -100000),

         Y = settings.GetValue("plotForm.Location.Y", 100),

         Width = settings.GetValue("plotForm.Width", 600),

         Height = settings.GetValue("plotForm.Height", 400)

       };

       showPlot = new UserOption("plotMenuItem", false, plotMenuItem, settings);

       plotLocation = new UserRadioGroup("plotLocation", 0,

         new[] { plotWindowMenuItem, plotBottomMenuItem, plotRightMenuItem },

         settings);

       showPlot.Changed += delegate(object sender, EventArgs e) {

         if (plotLocation.Value == 0) {

           if (showPlot.Value && this.Visible)

             plotForm.Show();

           else

             plotForm.Hide();

         } else {

           splitContainer.Panel2Collapsed = !showPlot.Value;

         }

         treeView.Invalidate();

       };

       plotLocation.Changed += delegate(object sender, EventArgs e) {

         switch (plotLocation.Value) {

           case 0:

             splitContainer.Panel2.Controls.Clear();

             splitContainer.Panel2Collapsed = true;

             plotForm.Controls.Add(plotPanel);

             if (showPlot.Value && this.Visible)

               plotForm.Show();

             break;

           case 1:

             plotForm.Controls.Clear();

             plotForm.Hide();

             splitContainer.Orientation = Orientation.Horizontal;

             splitContainer.Panel2.Controls.Add(plotPanel);

             splitContainer.Panel2Collapsed = !showPlot.Value;

             break;

           case 2:

             plotForm.Controls.Clear();

             plotForm.Hide();

             splitContainer.Orientation = Orientation.Vertical;

             splitContainer.Panel2.Controls.Add(plotPanel);

             splitContainer.Panel2Collapsed = !showPlot.Value;

             break;

         }

       };

       plotForm.FormClosing += delegate(object sender, FormClosingEventArgs e) {

         if (e.CloseReason == CloseReason.UserClosing) {

           // just switch off the plotting when the user closes the form

           if (plotLocation.Value == 0) {

             showPlot.Value = false;

           }

           e.Cancel = true;

         }

       };

       EventHandler moveOrResizePlotForm = delegate(object sender, EventArgs e) {

         if (plotForm.WindowState != FormWindowState.Minimized) {

           settings.SetValue("plotForm.Location.X", plotForm.Bounds.X);

           settings.SetValue("plotForm.Location.Y", plotForm.Bounds.Y);

           settings.SetValue("plotForm.Width", plotForm.Bounds.Width);

           settings.SetValue("plotForm.Height", plotForm.Bounds.Height);

         }

       };

       plotForm.Move += moveOrResizePlotForm;

       plotForm.Resize += moveOrResizePlotForm;

       plotForm.VisibleChanged += delegate(object sender, EventArgs e) {

         Rectangle bounds = new Rectangle(plotForm.Location, plotForm.Size);

         Screen screen = Screen.FromRectangle(bounds);

         Rectangle intersection =

           Rectangle.Intersect(screen.WorkingArea, bounds);

         if (intersection.Width < Math.Min(16, bounds.Width) ||

             intersection.Height < Math.Min(16, bounds.Height)) {

           plotForm.Location = new Point(

             screen.WorkingArea.Width / 2 - bounds.Width / 2,

             screen.WorkingArea.Height / 2 - bounds.Height / 2);

         }

       };

       this.VisibleChanged += delegate(object sender, EventArgs e) {

         if (this.Visible && showPlot.Value && plotLocation.Value == 0)

           plotForm.Show();

         else

           plotForm.Hide();

       };

     }

     private void InsertSorted(Collection<Node> nodes, HardwareNode node) {

       int i = 0;

       while (i < nodes.Count && nodes[i] is HardwareNode &&

         ((HardwareNode)nodes[i]).Hardware.HardwareType < 

           node.Hardware.HardwareType)

         i++;

       nodes.Insert(i, node);

     }

     private void SubHardwareAdded(IHardware hardware, Node node) {

       HardwareNode hardwareNode = 

         new HardwareNode(hardware, settings, unitManager);

       hardwareNode.PlotSelectionChanged += PlotSelectionChanged;

       InsertSorted(node.Nodes, hardwareNode);

       foreach (IHardware subHardware in hardware.SubHardware)

         SubHardwareAdded(subHardware, hardwareNode);  

     }

     private void HardwareAdded(IHardware hardware) {      

       SubHardwareAdded(hardware, root);

       PlotSelectionChanged(this, null);

     }

     private void HardwareRemoved(IHardware hardware) {

       List<HardwareNode> nodesToRemove = new List<HardwareNode>();

       foreach (Node node in root.Nodes) {

         HardwareNode hardwareNode = node as HardwareNode;

         if (hardwareNode != null && hardwareNode.Hardware == hardware)

           nodesToRemove.Add(hardwareNode);

       }

       foreach (HardwareNode hardwareNode in nodesToRemove) {

         root.Nodes.Remove(hardwareNode);

         hardwareNode.PlotSelectionChanged -= PlotSelectionChanged;

       }

       PlotSelectionChanged(this, null);

     }

     private void nodeTextBoxText_DrawText(object sender, DrawEventArgs e) {       

       Node node = e.Node.Tag as Node;

       if (node != null) {

         Color color;

         if (node.IsVisible) {

           SensorNode sensorNode = node as SensorNode;

           if (plotMenuItem.Checked && sensorNode != null &&

             sensorPlotColors.TryGetValue(sensorNode.Sensor, out color))

             e.TextColor = color;

           //If displayed in FrontView draw background in green

           if (sensorNode != null && settings.GetValue(new Identifier(sensorNode.Sensor.Identifier, "FrontView").ToString(), false))

           {

               SolidBrush greenBrush = new SolidBrush(Color.FromName("mediumspringgreen"));

               e.BackgroundBrush = greenBrush;

           }

         } else {

           e.TextColor = Color.DarkGray;

         }

       }

     }

     private void PlotSelectionChanged(object sender, EventArgs e) {

       List<ISensor> selected = new List<ISensor>();

       IDictionary<ISensor, Color> colors = new Dictionary<ISensor, Color>();

       int colorIndex = 0;

       foreach (TreeNodeAdv node in treeView.AllNodes) {

         SensorNode sensorNode = node.Tag as SensorNode;

         if (sensorNode != null) {

           if (sensorNode.Plot) {

             colors.Add(sensorNode.Sensor,

               plotColorPalette[colorIndex % plotColorPalette.Length]);

             selected.Add(sensorNode.Sensor);

           }

           colorIndex++;

         }

       }

       sensorPlotColors = colors;

       plotPanel.SetSensors(selected, colors);

     }

     private void nodeTextBoxText_EditorShowing(object sender,

       CancelEventArgs e) 

     {

       e.Cancel = !(treeView.CurrentNode != null &&

         (treeView.CurrentNode.Tag is SensorNode || 

          treeView.CurrentNode.Tag is HardwareNode));

     }

     private void nodeCheckBox_IsVisibleValueNeeded(object sender, 

       NodeControlValueEventArgs e) {

       SensorNode node = e.Node.Tag as SensorNode;

       e.Value = (node != null) && plotMenuItem.Checked;

     }

     private void exitClick(object sender, EventArgs e) {

       Close();

     }

     private int delayCount = 0;

     private void timer_Tick(object sender, EventArgs e) {

       computer.Accept(updateVisitor);

       treeView.Invalidate();

       plotPanel.InvalidatePlot();

       systemTray.Redraw();

       if (gadget != null)

         gadget.Redraw();

       if (wmiProvider != null)

         wmiProvider.Update();

       if (soundGraphDisplay != null)

       {

           soundGraphDisplay.Redraw();

           /*

           displayTick=!displayTick;

           if (displayTick)

           {

               soundGraphDisplay.SetText("       ---", "");

           }

           else

           {

               soundGraphDisplay.SetText("       -+-", "");

           }

           */

       }  

       if (logSensors != null && logSensors.Value && delayCount >= 4)

         logger.Log();

       if (delayCount < 4)

         delayCount++;

     }

     private void SaveConfiguration() {

       plotPanel.SetCurrentSettings();

       foreach (TreeColumn column in treeView.Columns)

         settings.SetValue("treeView.Columns." + column.Header + ".Width",

           column.Width);

       this.settings.SetValue("listenerPort", server.ListenerPort);

       string fileName = Path.ChangeExtension(

           System.Windows.Forms.Application.ExecutablePath, ".config");

       try {

         settings.Save(fileName);

       } catch (UnauthorizedAccessException) {

         MessageBox.Show("Access to the path '" + fileName + "' is denied. " +

           "The current settings could not be saved.",

           "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

       } catch (IOException) {

         MessageBox.Show("The path '" + fileName + "' is not writeable. " +

           "The current settings could not be saved.",

           "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

       }

     }

     private void MainForm_Load(object sender, EventArgs e) {

       Rectangle newBounds = new Rectangle {

         X = settings.GetValue("mainForm.Location.X", Location.X),

         Y = settings.GetValue("mainForm.Location.Y", Location.Y),

         Width = settings.GetValue("mainForm.Width", 470),

         Height = settings.GetValue("mainForm.Height", 640)

       };

       Rectangle fullWorkingArea = new Rectangle(int.MaxValue, int.MaxValue,

         int.MinValue, int.MinValue);

       foreach (Screen screen in Screen.AllScreens)

         fullWorkingArea = Rectangle.Union(fullWorkingArea, screen.Bounds);

       Rectangle intersection = Rectangle.Intersect(fullWorkingArea, newBounds);

       if (intersection.Width < 20 || intersection.Height < 20 ||

         !settings.Contains("mainForm.Location.X")

       ) {

         newBounds.X = (Screen.PrimaryScreen.WorkingArea.Width / 2) -

                       (newBounds.Width/2);

         newBounds.Y = (Screen.PrimaryScreen.WorkingArea.Height / 2) -

                       (newBounds.Height / 2);

       }

       this.Bounds = newBounds;

     }

     private void MainForm_FormClosed(object sender, FormClosedEventArgs e) {

       Visible = false;      

       systemTray.IsMainIconEnabled = false;

       timer.Enabled = false;            

       computer.Close();

       SaveConfiguration();

       if (runWebServer.Value)

           server.Quit();

       systemTray.Dispose();

       soundGraphDisplay.Dispose();

     }

     private void aboutMenuItem_Click(object sender, EventArgs e) {

       new AboutBox().ShowDialog();

     }

     private void treeView_Click(object sender, EventArgs e) {

       MouseEventArgs m = e as MouseEventArgs;

       if (m == null || m.Button != MouseButtons.Right)

         return;

       NodeControlInfo info = treeView.GetNodeControlInfoAt(

         new Point(m.X, m.Y)

       );

       treeView.SelectedNode = info.Node;

       if (info.Node != null) {

         SensorNode node = info.Node.Tag as SensorNode;

         if (node != null && node.Sensor != null) {

           treeContextMenu.MenuItems.Clear();

           if (node.Sensor.Parameters.Length > 0) {

             MenuItem item = new MenuItem("Parameters...");

             item.Click += delegate(object obj, EventArgs args) {

               ShowParameterForm(node.Sensor);

             };

             treeContextMenu.MenuItems.Add(item);

           }

           if (nodeTextBoxText.EditEnabled) {

             MenuItem item = new MenuItem("Rename");

             item.Click += delegate(object obj, EventArgs args) {

               nodeTextBoxText.BeginEdit();

             };

             treeContextMenu.MenuItems.Add(item);

           }

           if (node.IsVisible) {

             MenuItem item = new MenuItem("Hide");

             item.Click += delegate(object obj, EventArgs args) {

               node.IsVisible = false;

             };

             treeContextMenu.MenuItems.Add(item);

           } else {

             MenuItem item = new MenuItem("Unhide");

             item.Click += delegate(object obj, EventArgs args) {

               node.IsVisible = true;

             };

             treeContextMenu.MenuItems.Add(item);

           }

           treeContextMenu.MenuItems.Add(new MenuItem("-"));

           {

             MenuItem item = new MenuItem("Show in Tray");

             item.Checked = systemTray.Contains(node.Sensor);

             item.Click += delegate(object obj, EventArgs args) {

               if (item.Checked)

                 systemTray.Remove(node.Sensor);

               else

                 systemTray.Add(node.Sensor, true);

             };

             treeContextMenu.MenuItems.Add(item);

           }

           {

               MenuItem item = new MenuItem("Show in iMON FrontView");

               item.Checked = soundGraphDisplay.Contains(node.Sensor);

               item.Click += delegate(object obj, EventArgs args)

               {

                   if (item.Checked)

                       soundGraphDisplay.Remove(node.Sensor);

                   else

                       soundGraphDisplay.Add(node.Sensor, true);

               };

               treeContextMenu.MenuItems.Add(item);

           }

           if (gadget != null) {

             MenuItem item = new MenuItem("Show in Gadget");

             item.Checked = gadget.Contains(node.Sensor);

             item.Click += delegate(object obj, EventArgs args) {

               if (item.Checked) {

                 gadget.Remove(node.Sensor);

               } else {

                 gadget.Add(node.Sensor);

               }

             };

             treeContextMenu.MenuItems.Add(item);

           }

           if (node.Sensor.Control != null) {

             treeContextMenu.MenuItems.Add(new MenuItem("-"));

             IControl control = node.Sensor.Control;

             MenuItem controlItem = new MenuItem("Control");

             MenuItem defaultItem = new MenuItem("Default");

             defaultItem.Checked = control.ControlMode == ControlMode.Default;

             controlItem.MenuItems.Add(defaultItem);

             defaultItem.Click += delegate(object obj, EventArgs args) {

               control.SetDefault();

             };

             MenuItem manualItem = new MenuItem("Manual");

             controlItem.MenuItems.Add(manualItem);

             manualItem.Checked = control.ControlMode == ControlMode.Software;

             for (int i = 0; i <= 100; i += 5) {

               if (i <= control.MaxSoftwareValue &&

                   i >= control.MinSoftwareValue) {

                 MenuItem item = new MenuItem(i + " %");

                 item.RadioCheck = true;

                 manualItem.MenuItems.Add(item);

                 item.Checked = control.ControlMode == ControlMode.Software &&

                   Math.Round(control.SoftwareValue) == i;

                 int softwareValue = i;

                 item.Click += delegate(object obj, EventArgs args) {

                   control.SetSoftware(softwareValue);

                 };

               }

             }

             treeContextMenu.MenuItems.Add(controlItem);

           }

           treeContextMenu.Show(treeView, new Point(m.X, m.Y));

         }

         HardwareNode hardwareNode = info.Node.Tag as HardwareNode;

         if (hardwareNode != null && hardwareNode.Hardware != null) {

           treeContextMenu.MenuItems.Clear();

           if (nodeTextBoxText.EditEnabled) {

             MenuItem item = new MenuItem("Rename");

             item.Click += delegate(object obj, EventArgs args) {

               nodeTextBoxText.BeginEdit();

             };

             treeContextMenu.MenuItems.Add(item);

           }

           treeContextMenu.Show(treeView, new Point(m.X, m.Y));

         }

       }

     }

     private void saveReportMenuItem_Click(object sender, EventArgs e) {

       string report = computer.GetReport();

       if (saveFileDialog.ShowDialog() == DialogResult.OK) {

         using (TextWriter w = new StreamWriter(saveFileDialog.FileName)) {

           w.Write(report);

         }

       }

     }

     private void SysTrayHideShow() {

       Visible = !Visible;

       if (Visible)

         Activate();    

     }

     protected override void WndProc(ref Message m) {

       const int WM_SYSCOMMAND = 0x112;

       const int SC_MINIMIZE = 0xF020;

       const int SC_CLOSE = 0xF060;

       if (minimizeToTray.Value &&

         m.Msg == WM_SYSCOMMAND && m.WParam.ToInt64() == SC_MINIMIZE)

       {

           SysTrayHideShow();

       }

       else if (minimizeOnClose.Value &&

       m.Msg == WM_SYSCOMMAND && m.WParam.ToInt64() == SC_CLOSE)

       {

           /*

            * Apparently the user wants to minimize rather than close

            * Now we still need to check if we're going to the tray or not

            * 

            * Note: the correct way to do this would be to send out SC_MINIMIZE,

            * but since the code here is so simple,

            * that would just be a waste of time.

            */

           if (minimizeToTray.Value)

               SysTrayHideShow();

           else

               WindowState = FormWindowState.Minimized;

       }

       else

       {

           base.WndProc(ref m);

       }

     }

     private void hideShowClick(object sender, EventArgs e) {

       SysTrayHideShow();

     }

     private void ShowParameterForm(ISensor sensor) {

       ParameterForm form = new ParameterForm();

       form.Parameters = sensor.Parameters;

       form.captionLabel.Text = sensor.Name;

       form.ShowDialog();

     }

     private void treeView_NodeMouseDoubleClick(object sender, 

       TreeNodeAdvMouseEventArgs e) {

       SensorNode node = e.Node.Tag as SensorNode;

       if (node != null && node.Sensor != null && 

         node.Sensor.Parameters.Length > 0) {

         ShowParameterForm(node.Sensor);

       }

     }

     private void celsiusMenuItem_Click(object sender, EventArgs e) {

       celsiusMenuItem.Checked = true;

       fahrenheitMenuItem.Checked = false;

       unitManager.TemperatureUnit = TemperatureUnit.Celsius;

     }

     private void fahrenheitMenuItem_Click(object sender, EventArgs e) {

       celsiusMenuItem.Checked = false;

       fahrenheitMenuItem.Checked = true;

       unitManager.TemperatureUnit = TemperatureUnit.Fahrenheit;

     }

     private void sumbitReportMenuItem_Click(object sender, EventArgs e) 

     {

       ReportForm form = new ReportForm();

       form.Report = computer.GetReport();

       form.ShowDialog();      

     }

     private void resetMinMaxMenuItem_Click(object sender, EventArgs e) {

       computer.Accept(new SensorVisitor(delegate(ISensor sensor) {

         sensor.ResetMin();

         sensor.ResetMax();

       }));

     }

     private void MainForm_MoveOrResize(object sender, EventArgs e) {

       if (WindowState != FormWindowState.Minimized) {

         settings.SetValue("mainForm.Location.X", Bounds.X);

         settings.SetValue("mainForm.Location.Y", Bounds.Y);

         settings.SetValue("mainForm.Width", Bounds.Width);

         settings.SetValue("mainForm.Height", Bounds.Height);

       }

     }

     private void resetClick(object sender, EventArgs e) {

       // disable the fallback MainIcon during reset, otherwise icon visibility

       // might be lost 

       systemTray.IsMainIconEnabled = false;

       computer.Close();

       computer.Open();

       // restore the MainIcon setting

       systemTray.IsMainIconEnabled = minimizeToTray.Value;

     }

     private void treeView_MouseMove(object sender, MouseEventArgs e) {

       selectionDragging = selectionDragging &

         (e.Button & (MouseButtons.Left | MouseButtons.Right)) > 0; 

       if (selectionDragging)

         treeView.SelectedNode = treeView.GetNodeAt(e.Location);     

     }

     private void treeView_MouseDown(object sender, MouseEventArgs e) {

       selectionDragging = true;

     }

     private void treeView_MouseUp(object sender, MouseEventArgs e) {

       selectionDragging = false;

     }

     private void serverPortMenuItem_Click(object sender, EventArgs e) {

       new PortForm(this).ShowDialog();

     }

     public HttpServer Server {

       get { return server; }

     }

   }

 }