private ContextMenu CreateMenu()
        {
            ContextMenu menu = new ContextMenu();

            MenuItem stackedAxesMenuItem = new MenuItem("Stacked Axes");

            _stackedAxes          = new UserOption("stackedAxes", true, stackedAxesMenuItem, _settings);
            _stackedAxes.Changed += (sender, e) =>
            {
                UpdateAxesPosition();
                InvalidatePlot();
            };
            menu.MenuItems.Add(stackedAxesMenuItem);

            MenuItem timeWindow = new MenuItem("Time Window");

            MenuItem[] timeWindowMenuItems =
            { new MenuItem("Auto",       (s, e) => { _timeAxis.Zoom(0, double.NaN); InvalidatePlot();    }),
              new MenuItem("5 min",  (s, e) => { _timeAxis.Zoom(0,        5 * 60); InvalidatePlot(); }),
              new MenuItem("10 min", (s, e) => { _timeAxis.Zoom(0,       10 * 60); InvalidatePlot(); }),
              new MenuItem("20 min", (s, e) => { _timeAxis.Zoom(0,       20 * 60); InvalidatePlot(); }),
              new MenuItem("30 min", (s, e) => { _timeAxis.Zoom(0,       30 * 60); InvalidatePlot(); }),
              new MenuItem("45 min", (s, e) => { _timeAxis.Zoom(0,       45 * 60); InvalidatePlot(); }),
              new MenuItem("1 h",    (s, e) => { _timeAxis.Zoom(0,       60 * 60); InvalidatePlot(); }),
              new MenuItem("1.5 h",  (s, e) => { _timeAxis.Zoom(0, 1.5 * 60 * 60); InvalidatePlot(); }),
              new MenuItem("2 h",    (s, e) => { _timeAxis.Zoom(0,   2 * 60 * 60); InvalidatePlot(); }),
              new MenuItem("3 h",    (s, e) => { _timeAxis.Zoom(0,   3 * 60 * 60); InvalidatePlot(); }),
              new MenuItem("6 h",    (s, e) => { _timeAxis.Zoom(0,   6 * 60 * 60); InvalidatePlot(); }),
              new MenuItem("12 h",   (s, e) => { _timeAxis.Zoom(0,  12 * 60 * 60); InvalidatePlot(); }),
              new MenuItem("24 h",   (s, e) => { _timeAxis.Zoom(0,  24 * 60 * 60); InvalidatePlot(); }) };
            foreach (MenuItem mi in timeWindowMenuItems)
            {
                timeWindow.MenuItems.Add(mi);
            }
            menu.MenuItems.Add(timeWindow);
            return(menu);
        }
示例#2
0
        private ContextMenuStrip CreateMenu()
        {
            ContextMenuStrip menu = new ContextMenuStrip();

            ToolStripMenuItem stackedAxesMenuItem = new ToolStripMenuItem("Stacked Axes");

            _stackedAxes          = new UserOption("stackedAxes", true, stackedAxesMenuItem, _settings);
            _stackedAxes.Changed += (sender, e) =>
            {
                UpdateAxesPosition();
                InvalidatePlot();
            };
            menu.Items.Add(stackedAxesMenuItem);

            ToolStripMenuItem showAxesLabelsMenuItem = new ToolStripMenuItem("Show Axes Labels");

            _showAxesLabels          = new UserOption("showAxesLabels", true, showAxesLabelsMenuItem, _settings);
            _showAxesLabels.Changed += (sender, e) =>
            {
                if (_showAxesLabels.Value)
                {
                    _model.PlotMargins = new OxyThickness(double.NaN);
                }
                else
                {
                    _model.PlotMargins = new OxyThickness(0);
                }
            };
            menu.Items.Add(showAxesLabelsMenuItem);

            ToolStripMenuItem timeAxisMenuItem = new ToolStripMenuItem("Time Axis");

            ToolStripMenuItem[] timeAxisMenuItems =
            { new ToolStripMenuItem("Enable Zoom"),
              new ToolStripMenuItem("Auto",    null,  (s, e) => { TimeAxisZoom(0, double.NaN);    }),
              new ToolStripMenuItem("5 min",   null,  (s, e) => { TimeAxisZoom(0,        5 * 60); }),
              new ToolStripMenuItem("10 min",  null,  (s, e) => { TimeAxisZoom(0,       10 * 60); }),
              new ToolStripMenuItem("20 min",  null,  (s, e) => { TimeAxisZoom(0,       20 * 60); }),
              new ToolStripMenuItem("30 min",  null,  (s, e) => { TimeAxisZoom(0,       30 * 60); }),
              new ToolStripMenuItem("45 min",  null,  (s, e) => { TimeAxisZoom(0,       45 * 60); }),
              new ToolStripMenuItem("1 h",     null,  (s, e) => { TimeAxisZoom(0,       60 * 60); }),
              new ToolStripMenuItem("1.5 h",   null,  (s, e) => { TimeAxisZoom(0, 1.5 * 60 * 60); }),
              new ToolStripMenuItem("2 h",     null,  (s, e) => { TimeAxisZoom(0,   2 * 60 * 60); }),
              new ToolStripMenuItem("3 h",     null,  (s, e) => { TimeAxisZoom(0,   3 * 60 * 60); }),
              new ToolStripMenuItem("6 h",     null,  (s, e) => { TimeAxisZoom(0,   6 * 60 * 60); }),
              new ToolStripMenuItem("12 h",    null,  (s, e) => { TimeAxisZoom(0,  12 * 60 * 60); }),
              new ToolStripMenuItem("24 h",    null,  (s, e) => { TimeAxisZoom(0,  24 * 60 * 60); }) };

            foreach (ToolStripItem mi in timeAxisMenuItems)
            {
                timeAxisMenuItem.DropDownItems.Add(mi);
            }
            menu.Items.Add(timeAxisMenuItem);

            _timeAxisEnableZoom          = new UserOption("timeAxisEnableZoom", true, timeAxisMenuItems[0], _settings);
            _timeAxisEnableZoom.Changed += (sender, e) =>
            {
                _timeAxis.IsZoomEnabled = _timeAxisEnableZoom.Value;
            };

            ToolStripMenuItem yAxesMenuItem = new ToolStripMenuItem("Value Axes");

            ToolStripMenuItem[] yAxesMenuItems =
            { new ToolStripMenuItem("Enable Zoom"),
              new ToolStripMenuItem("Autoscale All", null, (s, e) => { AutoscaleAllYAxes(); }) };

            foreach (ToolStripItem mi in yAxesMenuItems)
            {
                yAxesMenuItem.DropDownItems.Add(mi);
            }
            menu.Items.Add(yAxesMenuItem);

            _yAxesEnableZoom          = new UserOption("yAxesEnableZoom", true, yAxesMenuItems[0], _settings);
            _yAxesEnableZoom.Changed += (sender, e) =>
            {
                foreach (LinearAxis axis in _axes.Values)
                {
                    axis.IsZoomEnabled = _yAxesEnableZoom.Value;
                }
            };

            return(menu);
        }
示例#3
0
        public MainForm()
        {
            InitializeComponent();

            // check if the LibreHardwareMonitorLib assembly has the correct version
            if (Assembly.GetAssembly(typeof(Computer)).GetName().Version != Assembly.GetExecutingAssembly().GetName().Version)
            {
                MessageBox.Show("The version of the file LibreHardwareMonitorLib.dll is incompatible.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Environment.Exit(0);
            }

            _settings = new PersistentSettings();
            _settings.Load(Path.ChangeExtension(Application.ExecutablePath, ".config"));

            _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
            splitContainer.Dock = DockStyle.Fill;

            Font          = SystemFonts.MessageBoxFont;
            treeView.Font = SystemFonts.MessageBoxFont;

            // Set the bounds immediately, so that our child components can be
            // properly placed.
            Bounds = 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)
            };

            _plotPanel = new PlotPanel(_settings, _unitManager)
            {
                Font = SystemFonts.MessageBoxFont, 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 treeModel = new TreeModel();

            _root = new Node(Environment.MachineName)
            {
                Image = EmbeddedResources.GetImage("computer.png")
            };

            treeModel.Nodes.Add(_root);
            treeView.Model = treeModel;

            _computer = new Computer(_settings);

            _systemTray = new SystemTray(_computer, _settings, _unitManager);
            _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);
            }

            _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   += HardwareAdded;
            _computer.HardwareRemoved += HardwareRemoved;
            _computer.Open();

            timer.Enabled = true;

            UserOption showHiddenSensors = new UserOption("hiddenMenuItem", false, hiddenMenuItem, _settings);

            showHiddenSensors.Changed += delegate
            {
                treeModel.ForceVisible = showHiddenSensors.Value;
            };

            UserOption showValue = new UserOption("valueMenuItem", true, valueMenuItem, _settings);

            showValue.Changed += delegate
            {
                treeView.Columns[1].IsVisible = showValue.Value;
            };

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

            showMin.Changed += delegate
            {
                treeView.Columns[2].IsVisible = showMin.Value;
            };

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

            showMax.Changed += delegate
            {
                treeView.Columns[3].IsVisible = showMax.Value;
            };

            var _ = new UserOption("startMinMenuItem", false, startMinMenuItem, _settings);

            _minimizeToTray          = new UserOption("minTrayMenuItem", true, minTrayMenuItem, _settings);
            _minimizeToTray.Changed += delegate
            {
                _systemTray.IsMainIconEnabled = _minimizeToTray.Value;
            };

            _minimizeOnClose = new UserOption("minCloseMenuItem", false, minCloseMenuItem, _settings);

            _autoStart          = new UserOption(null, _startupManager.Startup, startupMenuItem, _settings);
            _autoStart.Changed += delegate
            {
                try
                {
                    _startupManager.Startup = _autoStart.Value;
                }
                catch (InvalidOperationException)
                {
                    MessageBox.Show("Updating the auto-startup option failed.", "Error",
                                    MessageBoxButtons.OK, MessageBoxIcon.Error);
                    _autoStart.Value = _startupManager.Startup;
                }
            };

            _readMainboardSensors          = new UserOption("mainboardMenuItem", true, mainboardMenuItem, _settings);
            _readMainboardSensors.Changed += delegate
            {
                _computer.IsMotherboardEnabled = _readMainboardSensors.Value;
            };

            _readCpuSensors          = new UserOption("cpuMenuItem", true, cpuMenuItem, _settings);
            _readCpuSensors.Changed += delegate
            {
                _computer.IsCpuEnabled = _readCpuSensors.Value;
            };

            _readRamSensors          = new UserOption("ramMenuItem", true, ramMenuItem, _settings);
            _readRamSensors.Changed += delegate
            {
                _computer.IsMemoryEnabled = _readRamSensors.Value;
            };

            _readGpuSensors          = new UserOption("gpuMenuItem", true, gpuMenuItem, _settings);
            _readGpuSensors.Changed += delegate
            {
                _computer.IsGpuEnabled = _readGpuSensors.Value;
            };

            _readFanControllersSensors          = new UserOption("fanControllerMenuItem", true, fanControllerMenuItem, _settings);
            _readFanControllersSensors.Changed += delegate
            {
                _computer.IsControllerEnabled = _readFanControllersSensors.Value;
            };

            _readHddSensors          = new UserOption("hddMenuItem", true, hddMenuItem, _settings);
            _readHddSensors.Changed += delegate
            {
                _computer.IsStorageEnabled = _readHddSensors.Value;
            };

            _readNicSensors          = new UserOption("nicMenuItem", true, nicMenuItem, _settings);
            _readNicSensors.Changed += delegate
            {
                _computer.IsNetworkEnabled = _readNicSensors.Value;
            };

            _showGadget          = new UserOption("gadgetMenuItem", false, gadgetMenuItem, _settings);
            _showGadget.Changed += delegate
            {
                if (_gadget != null)
                {
                    _gadget.Visible = _showGadget.Value;
                }
            };

            celsiusMenuItem.Checked    = _unitManager.TemperatureUnit == TemperatureUnit.Celsius;
            fahrenheitMenuItem.Checked = !celsiusMenuItem.Checked;

            Server = new HttpServer(_root, _settings.GetValue("listenerPort", 8085));
            if (Server.PlatformNotSupported)
            {
                webMenuItemSeparator.Visible = false;
                webMenuItem.Visible          = false;
            }

            _runWebServer          = new UserOption("runWebServerMenuItem", false, runWebServerMenuItem, _settings);
            _runWebServer.Changed += delegate
            {
                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;
                }
            };

            _sensorValuesTimeWindow = new UserRadioGroup("sensorValuesTimeWindow", 10,
                                                         new[] { timeWindow30sMenuItem, timeWindow1minMenuItem, timeWindow2minMenuItem,
                                                                 timeWindow5minMenuItem, timeWindow10minMenuItem, timeWindow30minMenuItem,
                                                                 timeWindow1hMenuItem, timeWindow2hMenuItem, timeWindow6hMenuItem,
                                                                 timeWindow12hMenuItem, timeWindow24hMenuItem }, _settings);
            _sensorValuesTimeWindow.Changed += (sender, e) =>
            {
                TimeSpan timeWindow = TimeSpan.Zero;
                switch (_sensorValuesTimeWindow.Value)
                {
                case 0: timeWindow = new TimeSpan(0, 0, 30); break;

                case 1: timeWindow = new TimeSpan(0, 1, 0); break;

                case 2: timeWindow = new TimeSpan(0, 2, 0); break;

                case 3: timeWindow = new TimeSpan(0, 5, 0); break;

                case 4: timeWindow = new TimeSpan(0, 10, 0); break;

                case 5: timeWindow = new TimeSpan(0, 30, 0); break;

                case 6: timeWindow = new TimeSpan(1, 0, 0); break;

                case 7: timeWindow = new TimeSpan(2, 0, 0); break;

                case 8: timeWindow = new TimeSpan(6, 0, 0); break;

                case 9: timeWindow = new TimeSpan(12, 0, 0); break;

                case 10: timeWindow = new TimeSpan(24, 0, 0); break;
                }

                _computer.Accept(new SensorVisitor(delegate(ISensor sensor)
                {
                    sensor.ValuesTimeWindow = timeWindow;
                }));
            };

            InitializePlotForm();
            InitializeSplitter();

            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

            // Make sure the settings are saved when the user logs off
            Microsoft.Win32.SystemEvents.SessionEnded += delegate
            {
                _computer.Close();
                SaveConfiguration();
                if (_runWebServer.Value)
                {
                    Server.Quit();
                }
            };
        }
示例#4
0
        private void InitializePlotForm()
        {
            _plotForm = new Form {
                FormBorderStyle = FormBorderStyle.SizableToolWindow, ShowInTaskbar = false, StartPosition = FormStartPosition.Manual
            };
            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
            {
                if (_plotLocation.Value == 0)
                {
                    if (_showPlot.Value && Visible)
                    {
                        _plotForm.Show();
                    }
                    else
                    {
                        _plotForm.Hide();
                    }
                }
                else
                {
                    splitContainer.Panel2Collapsed = !_showPlot.Value;
                }
                treeView.Invalidate();
            };
            _plotLocation.Changed += delegate
            {
                switch (_plotLocation.Value)
                {
                case 0:
                    splitContainer.Panel2.Controls.Clear();
                    splitContainer.Panel2Collapsed = true;
                    _plotForm.Controls.Add(_plotPanel);
                    if (_showPlot.Value && 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;
                }
            };


            void MoveOrResizePlotForm(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
            {
                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);
                }
            };

            VisibleChanged += delegate
            {
                if (Visible && _showPlot.Value && _plotLocation.Value == 0)
                {
                    _plotForm.Show();
                }
                else
                {
                    _plotForm.Hide();
                }
            };
        }
示例#5
0
        public SensorGadget(IComputer computer, PersistentSettings settings, UnitManager unitManager)
        {
            _unitManager              = unitManager;
            _settings                 = settings;
            computer.HardwareAdded   += HardwareAdded;
            computer.HardwareRemoved += HardwareRemoved;

            _darkWhite    = new SolidBrush(Color.FromArgb(0xF0, 0xF0, 0xF0));
            _stringFormat = new StringFormat {
                FormatFlags = StringFormatFlags.NoWrap
            };
            _trimStringFormat = new StringFormat {
                Trimming = StringTrimming.EllipsisCharacter, FormatFlags = StringFormatFlags.NoWrap
            };
            _alignRightStringFormat = new StringFormat {
                Alignment = StringAlignment.Far, FormatFlags = StringFormatFlags.NoWrap
            };

            if (File.Exists("gadget_background.png"))
            {
                try
                {
                    Image newBack = new Bitmap("gadget_background.png");
                    _back.Dispose();
                    _back = newBack;
                }
                catch { }
            }

            if (File.Exists("gadget_image.png"))
            {
                try
                {
                    _image = new Bitmap("gadget_image.png");
                }
                catch { }
            }

            if (File.Exists("gadget_foreground.png"))
            {
                try
                {
                    _fore = new Bitmap("gadget_foreground.png");
                }
                catch { }
            }

            if (File.Exists("gadget_bar_background.png"))
            {
                try
                {
                    Image newBarBack = new Bitmap("gadget_bar_background.png");
                    _barBack.Dispose();
                    _barBack = newBarBack;
                }
                catch { }
            }

            if (File.Exists("gadget_bar_foreground.png"))
            {
                try
                {
                    Image newBarColor = new Bitmap("gadget_bar_foreground.png");
                    _barFore.Dispose();
                    _barFore = newBarColor;
                }
                catch { }
            }

            Location         = new Point(settings.GetValue("sensorGadget.Location.X", 100), settings.GetValue("sensorGadget.Location.Y", 100));
            LocationChanged += delegate
            {
                settings.SetValue("sensorGadget.Location.X", Location.X);
                settings.SetValue("sensorGadget.Location.Y", Location.Y);
            };

            // get the custom to default dpi ratio
            using (Bitmap b = new Bitmap(1, 1))
            {
                _scale = b.HorizontalResolution / 96.0f;
            }

            SetFontSize(settings.GetValue("sensorGadget.FontSize", 7.5f));
            Resize(settings.GetValue("sensorGadget.Width", Size.Width));

            ContextMenuStrip  contextMenuStrip  = new ContextMenuStrip();
            ToolStripMenuItem hardwareNamesItem = new ToolStripMenuItem("Hardware Names");

            contextMenuStrip.Items.Add(hardwareNamesItem);
            ToolStripMenuItem fontSizeMenu = new ToolStripMenuItem("Font Size");

            for (int i = 0; i < 4; i++)
            {
                float  size;
                string name;
                switch (i)
                {
                case 0: size = 6.5f; name = "Small"; break;

                case 1: size = 7.5f; name = "Medium"; break;

                case 2: size = 9f; name = "Large"; break;

                case 3: size = 11f; name = "Very Large"; break;

                default: throw new NotImplementedException();
                }

                ToolStripItem item = new ToolStripMenuItem(name)
                {
                    Checked = _fontSize == size
                };
                item.Click += delegate
                {
                    SetFontSize(size);
                    settings.SetValue("sensorGadget.FontSize", size);
                    foreach (ToolStripMenuItem mi in fontSizeMenu.DropDownItems)
                    {
                        mi.Checked = mi == item;
                    }
                };
                fontSizeMenu.DropDownItems.Add(item);
            }
            contextMenuStrip.Items.Add(fontSizeMenu);
            contextMenuStrip.Items.Add(new ToolStripSeparator());
            ToolStripMenuItem lockItem = new ToolStripMenuItem("Lock Position and Size");

            contextMenuStrip.Items.Add(lockItem);
            contextMenuStrip.Items.Add(new ToolStripSeparator());
            ToolStripMenuItem alwaysOnTopItem = new ToolStripMenuItem("Always on Top");

            contextMenuStrip.Items.Add(alwaysOnTopItem);
            ToolStripMenuItem opacityMenu = new ToolStripMenuItem("Opacity");

            contextMenuStrip.Items.Add(opacityMenu);
            Opacity = (byte)settings.GetValue("sensorGadget.Opacity", 255);

            for (int i = 0; i < 5; i++)
            {
                ToolStripMenuItem item = new ToolStripMenuItem((20 * (i + 1)).ToString() + " %");
                byte o = (byte)(51 * (i + 1));
                item.Checked = Opacity == o;
                item.Click  += delegate
                {
                    Opacity = o;
                    settings.SetValue("sensorGadget.Opacity", Opacity);
                    foreach (ToolStripMenuItem mi in opacityMenu.DropDownItems)
                    {
                        mi.Checked = mi == item;
                    }
                };
                opacityMenu.DropDownItems.Add(item);
            }
            ContextMenuStrip = contextMenuStrip;

            _hardwareNames          = new UserOption("sensorGadget.Hardwarenames", true, hardwareNamesItem, settings);
            _hardwareNames.Changed += delegate
            {
                Resize();
            };

            UserOption alwaysOnTop = new UserOption("sensorGadget.AlwaysOnTop", false, alwaysOnTopItem, settings);

            alwaysOnTop.Changed += delegate
            {
                AlwaysOnTop = alwaysOnTop.Value;
            };
            UserOption lockPositionAndSize = new UserOption("sensorGadget.LockPositionAndSize", false, lockItem, settings);

            lockPositionAndSize.Changed += delegate
            {
                LockPositionAndSize = lockPositionAndSize.Value;
            };

            HitTest += delegate(object sender, HitTestEventArgs e)
            {
                if (lockPositionAndSize.Value)
                {
                    return;
                }

                if (e.Location.X < LeftBorder)
                {
                    e.HitResult = HitResult.Left;
                    return;
                }
                if (e.Location.X > Size.Width - 1 - RightBorder)
                {
                    e.HitResult = HitResult.Right;
                }
            };

            SizeChanged += delegate
            {
                settings.SetValue("sensorGadget.Width", Size.Width);
                Redraw();
            };

            VisibleChanged += delegate
            {
                Rectangle bounds       = new Rectangle(Location, 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))
                {
                    Location = new Point(screen.WorkingArea.Width / 2 - bounds.Width / 2, screen.WorkingArea.Height / 2 - bounds.Height / 2);
                }
            };

            MouseDoubleClick += delegate
            {
                SendHideShowCommand();
            };
        }