Beispiel #1
0
        private void OnApplyTemplate(object sender, EventArgs e)
        {
            var settings = Properties.Settings.Default;

            settings.InfluxUrl      = Url.Text;
            settings.InfluxDatabase = Database.Text;
            settings.InfluxUser     = InfluxUser.Text;
            InfluxHelper.SaveObfuscatedInfluxPassword(InfluxPassword.Text);
            UpdateJson();
            InfluxHelper.StartMetrics();
        }
Beispiel #2
0
        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;

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

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

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

            InfluxHelper.SetMustachioModel(Properties.Settings.Default.TemplatePath);
            InfluxHelper.ParseTagsSettings();
            InfluxHelper.StartMetrics();
        }