/*

  Version: MPL 1.1/GPL 2.0/LGPL 2.1

  The contents of this file are subject to the Mozilla Public License Version

  1.1 (the "License"); you may not use this file except in compliance with

  the License. You may obtain a copy of the License at

  http://www.mozilla.org/MPL/

  Software distributed under the License is distributed on an "AS IS" basis,

  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

  for the specific language governing rights and limitations under the License.

  The Original Code is the Open Hardware Monitor code.

  The Initial Developer of the Original Code is 

  Michael Möller <m.moeller@gmx.ch>.

  Portions created by the Initial Developer are Copyright (C) 2009-2012

  the Initial Developer. All Rights Reserved.

  Contributor(s): Paul Werelds

  Alternatively, the contents of this file may be used under the terms of

  either the GNU General Public License Version 2 or later (the "GPL"), or

  the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

  in which case the provisions of the GPL or the LGPL are applicable instead

  of those above. If you wish to allow use of your version of this file only

  under the terms of either the GPL or the LGPL, and not to allow others to

  use your version of this file under the terms of the MPL, indicate your

  decision by deleting the provisions above and replace them with the notice

  and other provisions required by the GPL or the LGPL. If you do not delete

  the provisions above, a recipient may use your version of this file under

  the terms of any one of the MPL, the GPL or the LGPL.

*/

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.IO;

using System.Reflection;

using System.Windows.Forms;

using Aga.Controls.Tree;

using Aga.Controls.Tree.NodeControls;

using OpenHardwareMonitor.Hardware;

using OpenHardwareMonitor.WMI;

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 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 readHddSensors;

    private UserOption showGadget;

    private UserRadioGroup plotLocation;

    private WmiProvider wmiProvider;

    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);

      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);

      systemTray.HideShowCommand += hideShowClick;

      systemTray.ExitCommand += exitClick;

      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);

      }

      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;

        }

      };

      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;

      InitializePlotForm();

      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 {

        SaveConfiguration();

      };

    }

    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 SubHardwareAdded(IHardware hardware, Node node) {

      HardwareNode hardwareNode = 

        new HardwareNode(hardware, settings, unitManager);

      hardwareNode.PlotSelectionChanged += PlotSelectionChanged;

      node.Nodes.Add(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;

        } 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 &&

          sensorNode.Sensor.SensorType == SensorType.Temperature) {

          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) && 

        (node.Sensor.SensorType == SensorType.Temperature) && 

        plotMenuItem.Checked;

    }

    private void exitClick(object sender, EventArgs e) {

      Close();

    }

    private void timer_Tick(object sender, EventArgs e) {

      computer.Accept(updateVisitor);

      treeView.Invalidate();

      plotPanel.Invalidate();

      systemTray.Redraw();

      if (gadget != null)

        gadget.Redraw();

      if (wmiProvider != null)

        wmiProvider.Update();

    }

    private void SaveConfiguration() {

      foreach (TreeColumn column in treeView.Columns)

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

          column.Width);

      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();

      systemTray.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);

          }

          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 + " %");

                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;

    }

  }

}