Source code for hashardware.cs

```
using System;
```
```
using System.Collections.Generic;
```
```
using System.Linq;
```
```
using System.Management;
```
```
 
```
```
 
```
```
namespace RobvanderWoude
```
```
{
```
```
	internal class HasHardware
```
```
	{
```

		static readonly string progver = "1.05";

```
 
```
```
 
```
```
		#region Global Variables
```
```
 
```
```
		static bool analog = false;
```
```
		static bool continueonerrors = false;
```
```
		static bool digital = false;
```
```
		static bool errors = false;
```
```
		static bool hideerrors = false;
```
```
		static bool includekeyboards = false;
```
```
		static bool includemice = false;
```
```
		static bool includemonitors = false;
```
```
		static bool ps2 = false;
```
```
		static bool quiet = false;
```
```
		static bool serial = false;
```
```
		static bool usb = false;
```
```
		static bool verbose = false;
```
```
		static bool yesno = false;
```
```
		static int keyboardcount = 0;
```
```
		static int monitorcount = 0;
```
```
		static int mousecount = 0;
```
```
		static string keyboardquery;
```
```
		static string keyboardtype;
```
```
		static string mousequery;
```
```
		static string mousetype;
```

		static List<SortedList<string, string>> monitors = new List<SortedList<string, string>>( );

		static SortedList<string, string> monitor;

		// Monitor/mouse/keyboard availability (root\CIMV2)

		static readonly Dictionary<int, string> Availability = new Dictionary<int, string>

```
		{
```
```
			{ 1, "Other" },
```
```
			{ 2, "Unknown" },
```
```
			{ 3, "Running/Full Power" },
```
```
			{ 4, "Warning" },
```
```
			{ 5, "In Test" },
```
```
			{ 6, "Not Applicable" },
```
```
			{ 7, "Power Off" },
```
```
			{ 8, "Off Line" },
```
```
			{ 9, "Off Duty" },
```
```
			{ 10, "Degraded" },
```
```
			{ 11, "Not Installed" },
```
```
			{ 12, "Install Error" },
```
```
			{ 13, "Power Save - Unknown" },
```

			{ 14, "Power Save - Low Power Mode" },

```
			{ 15, "Power Save - Standby" },
```
```
			{ 16, "Power Cycle" },
```
```
			{ 17, "Power Save - Warning" },
```
```
			{ 18, "Paused" },
```
```
			{ 19, "Not Ready" },
```
```
			{ 20, "Not Configured" },
```
```
			{ 21, "Quiesced" }
```
```
		};
```

		// Keyboard and mouse connector type (root\WMI)

		static readonly Dictionary<int, string> ConnectorType = new Dictionary<int, string>

```
		{
```
```
			{ 0, "PS/2" },
```
```
			{ 1, "Serial" },
```
```
			{ 2, "USB" },
```
```
		};
```

		// Mouse device interface (root\CIMV2)

		static readonly Dictionary<int, string> DeviceInterface = new Dictionary<int, string>

```
		{
```
```
			{ 1,"Other" },
```
```
			{ 2, "Unknown" },
```
```
			{ 3, "Serial" },
```
```
			{ 4, "PS/2" },
```
```
			{ 5, "Infrared" },
```
```
			{ 6, "HP-HIL" },
```
```
			{ 7, "Bus mouse" },
```
```
			{ 8, "ADB (Apple Desktop Bus)" },
```
```
			{ 160, "Bus mouse DB-9" },
```
```
			{ 161, "Bus mouse micro-DIN" },
```
```
			{ 162, "USB" }
```
```
		};
```
```
		// Mouse hardware type (root\WMI)
```

		static readonly Dictionary<int, string> HardwareType = new Dictionary<int, string>

```
		{
```
```
			{ 0, "Standard Mouse" },
```
```
			{ 1, "Standard Pointer" },
```
```
			{ 2, "Standard Absolute Pointer" },
```
```
			{ 3, "Tablet" },
```
```
			{ 4, "Touch Screen" },
```
```
			{ 5, "Pen" },
```
```
			{ 6, "Track Ball" },
```
```
			{ 256, "Other" }
```
```
		};
```
```
 
```
```
		#endregion Global Variables
```
```
 
```
```
 
```
```
		static int Main( string[] args )
```
```
		{
```
```
			#region Initialize Variables
```
```
 
```
```
			keyboardtype = string.Empty;
```

			keyboardquery = "SELECT * FROM MsKeyboard_PortInformation";

```
			string monitortype = string.Empty;
```

			string monitorquery = "SELECT * FROM Win32_DesktopMonitor WHERE NOT MonitorType='Default Monitor' AND MonitorManufacturer IS NOT NULL"; // common PNPDeviceID

			string monitordetails = "SELECT * FROM WmiMonitorBasicDisplayParams"; // common InstanceName

```
			mousetype = string.Empty;
```

			mousequery = "SELECT * FROM MSMouse_PortInformation";

```
 
```
```
			#endregion Initialize Variables
```
```
 
```
```
 
```
```
			#region Parse Command Line
```
```
 
```
```
			foreach ( string arg in args )
```
```
			{
```
```
				switch ( arg.ToUpper( ) )
```
```
				{
```
```
					case "/?":
```
```
						return ShowHelp( );
```
```
					case "/A":
```
```
						CheckArg( ref analog, arg );
```
```
						break;
```
```
					case "/C":
```

						CheckArg( ref continueonerrors, arg );

```
						break;
```
```
					case "/D":
```
```
						CheckArg( ref digital, arg );
```
```
						break;
```
```
					case "/H":
```
```
						CheckArg( ref hideerrors, arg );
```
```
						break;
```
```
					case "/I":
```

						CheckArg( ref includemonitors, arg );

```
						break;
```
```
					case "/K":
```

						CheckArg( ref includekeyboards, arg );

```
						break;
```
```
					case "/M":
```
```
						CheckArg( ref includemice, arg );
```
```
						break;
```
```
					case "/P":
```
```
						CheckArg( ref ps2, arg );
```
```
						break;
```
```
					case "/Q":
```
```
						CheckArg( ref quiet, arg );
```
```
						break;
```
```
					case "/S":
```
```
						CheckArg( ref serial, arg );
```
```
						break;
```
```
					case "/U":
```
```
						CheckArg( ref usb, arg );
```
```
						break;
```
```
					case "/V":
```
```
						CheckArg( ref verbose, arg );
```
```
						break;
```
```
					case "/Y":
```
```
						CheckArg( ref yesno, arg );
```
```
						break;
```
```
					default:
```

						return ShowHelp( "Invalid command line argument \"{0}\"", arg );

```
				}
```
```
			}
```
```
 
```

			continueonerrors = continueonerrors || hideerrors;

```
 
```
```
			if ( quiet && verbose )
```
```
			{
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( "Command line switches /Q and /V are mutually exclusive" );

```
				Console.ResetColor( );
```
```
				errors = true;
```
```
			}
```
```
 
```
```
			if ( errors )
```
```
			{
```
```
				return ShowHelp( );
```
```
			}
```
```
 
```

			if ( !includekeyboards && !includemice && !includemonitors )

```
			{
```
```
				includekeyboards = true;
```
```
				includemice = true;
```
```
				includemonitors = true;
```
```
			}
```
```
 
```

			if ( includekeyboards || includemice )

```
			{
```
```
				if ( !ps2 && !serial && !usb )
```
```
				{
```
```
					ps2 = true;
```
```
					serial = true;
```
```
					usb = true;
```
```
				}
```
```
			}
```
```
 
```
```
			#endregion Parse Command Line
```
```
 
```
```
 
```

			if ( includekeyboards || includemice )

```
			{
```
```
				ConnectorTypeQuery( );
```
```
			}
```
```
 
```
```
 
```
```
			if ( includekeyboards )
```
```
			{
```
```
				#region Count Keyboards
```
```
 
```
```
				try
```
```
				{
```

					ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", keyboardquery );

					ManagementObjectCollection colItems = searcher.Get( );

```
					keyboardcount = colItems.Count;
```
```
					if ( !quiet )
```
```
					{
```

						ShowCount( keyboardcount, "keyboard", keyboardtype, "keyboards" );

```
					}
```
```
 
```
```
 
```
```
					#region Show Keyboards Details
```
```
 
```

					if ( verbose && keyboardcount > 0 )

```
					{
```

						foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
						{
```

							int connectortype = int.Parse( queryObj["ConnectorType"].ToString( ) );

							Console.WriteLine( "\tConnector Type : {0}", ConnectorType[connectortype] );

							Console.WriteLine( "\tFunction Keys  : {0}", queryObj["FunctionKeys"] );

							Console.WriteLine( "\tIndicators     : {0}", queryObj["Indicators"] );

```
							Console.WriteLine( );
```
```
							queryObj.Dispose( );
```
```
						}
```
```
					}
```
```
 
```
```
					#endregion Show Keyboards Details
```
```
				}
```
```
				catch ( ManagementException e )
```
```
				{
```
```
					if ( hideerrors )
```
```
					{
```
```
						errors = true;
```

						// Plan B: use root\CIMV2 if access to root\WMI is denied

```
						Win32_Keyboard( );
```
```
					}
```
```
					else if ( continueonerrors )
```
```
					{
```

						Console.ForegroundColor = ConsoleColor.Red;

						Console.Error.Write( "\nERROR:\t" );

```
						Console.ResetColor( );
```

						Console.Error.WriteLine( "{0} (namespace: root/WMI; class: MsKeyboard_PortInformation)", e.Message );

						Console.WriteLine( "      \tTrying alternative query (namespace: root/CIMV2; class: Win32_Keyboard)\n" );

```
						errors = true;
```

						// Plan B: use root\CIMV2 if access to root\WMI is denied

```
						Win32_Keyboard( );
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "{0} (namespace: root/WMI; class: MsKeyboard_PortInformation)", e.Message );

```
					}
```
```
				}
```
```
 
```
```
				#endregion Count Keyboards
```
```
			}
```
```
 
```
```
 
```
```
			if ( includemonitors )
```
```
			{
```
```
				#region Prepare Monitor Query
```
```
 
```
```
				if ( analog != digital )
```
```
				{
```
```
					if ( analog )
```
```
					{
```

						monitordetails += " WHERE VideoInputType='0'";

```
						monitortype += " analog";
```
```
					}
```
```
					else
```
```
					{
```

						monitordetails += " WHERE VideoInputType='1'";

```
						monitortype += " digital";
```
```
					}
```
```
				}
```
```
 
```
```
				#endregion Prepare Monitor Query
```
```
 
```
```
 
```
```
				#region Count Monitors
```
```
 
```

				ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", monitordetails );

				ManagementObjectCollection colItems = searcher.Get( );

```
				monitorcount = colItems.Count;
```
```
				if ( !quiet )
```
```
				{
```

					ShowCount( monitorcount, "monitor", monitortype, "monitors" );

```
				}
```
```
 
```
```
				#endregion Count Monitors
```
```
 
```
```
 
```

				#region Prepare Monitor Details Queries

```
 
```

				searcher = new ManagementObjectSearcher( @"root\CIMV2", monitorquery );

```
				colItems = searcher.Get( );
```
```
				if ( verbose )
```
```
				{
```

					foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
					{
```

						monitor = new SortedList<string, string>( );

						int availability = int.Parse( queryObj["Availability"].ToString( ) );

						monitor.Add( "Availability", Availability[availability] );

						monitor.Add( "Manufacturer", queryObj["MonitorManufacturer"].ToString( ) );

						monitor.Add( "Description", queryObj["MonitorType"].ToString( ) );

						string deviceid = queryObj["PNPDeviceID"].ToString( ).Replace( "&amp;", "&" );

						monitor.Add( "PnP Device ID", deviceid );

						monitor.Add( "Screen Height (px)", queryObj["ScreenHeight"].ToString( ) );

						monitor.Add( "Screen Width (px)", queryObj["ScreenWidth"].ToString( ) );

						monitor.Add( "Status", queryObj["Status"].ToString( ) );

```
						queryObj.Dispose( );
```
```
						WMIMonitorID( deviceid );
```

						string inputtype = monitor["Video Input (Monitor)"].ToLower( );

						if ( ( analog == digital ) || ( inputtype == "analog" && analog ) || ( inputtype == "digital" && digital ) )

```
						{
```
```
							monitors.Add( monitor );
```
```
						}
```
```
						//monitor.Clear( );
```
```
					}
```
```
 
```
```
					// determine left column width
```
```
					int columnwidth = 0;
```
```
					foreach ( var mon in monitors )
```
```
					{
```

						foreach ( string key in mon.Keys )

```
						{
```

							columnwidth = Math.Max( columnwidth, key.Length );

```
						}
```
```
					}
```
```
 
```

					// list a selection of all properties and values

```
					foreach ( var mon in monitors )
```
```
					{
```

						foreach ( string key in mon.Keys )

```
						{
```

							Console.WriteLine( "\t{0,-" + columnwidth + "} : {1}", key, mon[key] );

```
						}
```
```
						Console.WriteLine( );
```
```
					}
```
```
				}
```
```
 
```

				#endregion Prepare Monitor Details Queries

```
			}
```
```
 
```
```
 
```
```
			if ( includemice )
```
```
			{
```
```
				#region Count Mice
```
```
 
```
```
				try
```
```
				{
```

					ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", mousequery );

					ManagementObjectCollection colItems = searcher.Get( );

```
					mousecount = colItems.Count;
```
```
					if ( !quiet )
```
```
					{
```

						ShowCount( mousecount, "mouse", mousetype, "mice" );

```
					}
```
```
 
```
```
 
```
```
					#region Show Mice Details
```
```
 
```
```
					if ( verbose && mousecount > 0 )
```
```
					{
```

						foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
						{
```

							Console.WriteLine( "\tButtons        : {0}", queryObj["Buttons"] );

							int connectortype = int.Parse( queryObj["ConnectorType"].ToString( ) );

							Console.WriteLine( "\tConnector Type : {0}", ConnectorType[connectortype] );

							int hardwaretype = int.Parse( queryObj["HardwareType"].ToString( ) );

							Console.WriteLine( "\tHardware Type  : {0}", HardwareType[hardwaretype] );

```
							Console.WriteLine( );
```
```
							queryObj.Dispose( );
```
```
						}
```
```
					}
```
```
 
```
```
					#endregion Show Mice Details
```
```
				}
```
```
				catch ( ManagementException e )
```
```
				{
```
```
					if ( hideerrors )
```
```
					{
```
```
						errors = true;
```
```
						Win32_PointingDevice( );
```
```
					}
```
```
					else if ( continueonerrors )
```
```
					{
```

						Console.ForegroundColor = ConsoleColor.Red;

						Console.Error.Write( "\nERROR:\t" );

```
						Console.ResetColor( );
```

						Console.Error.WriteLine( "{0} (namespace: root/WMI; class: MSMouse_PortInformation)", e.Message );

						Console.WriteLine( "      \tTrying alternative query (namespace: root/CIMV2; class: Win32_PointingDevice)\n" );

```
						errors = true;
```
```
						Win32_PointingDevice( );
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "{0} (namespace: root/WMI; class: MSMouse_PortInformation)", e.Message );

```
					}
```
```
				}
```
```
 
```
```
				#endregion Count Mice
```
```
			}
```
```
 
```
```
 
```
```
			// calculate return code
```
```
			if ( errors && !hideerrors )
```
```
			{
```
```
				return -1;
```
```
			}
```
```
			else if ( yesno )
```
```
			{
```
```
				int rc = 0;
```
```
				if ( keyboardcount > 0 )
```
```
				{
```
```
					rc += 100;
```
```
				}
```
```
				if ( monitorcount > 0 )
```
```
				{
```
```
					rc += 10;
```
```
				}
```
```
                if ( mousecount > 0 )
```
```
                {
```
```
					rc += 1;
```
```
                }
```
```
                return rc;
```
```
			}
```
```
			else
```
```
			{
```

				return keyboardcount + monitorcount + mousecount;

```
			}
```
```
		}
```
```
 
```
```
 
```

		static string Chain( UInt16[] chararray )

```
		{
```
```
			string charstring = null;
```
```
			foreach ( UInt16 chr in chararray )
```
```
			{
```
```
				if ( chr == 0 )
```
```
				{
```
```
					return charstring;
```
```
				}
```
```
				else
```
```
				{
```

					charstring += ( (char)chr ).ToString( );

```
				}
```
```
			}
```
```
			return charstring;
```
```
		}
```
```
 
```
```
 
```

		public static void CheckArg( ref bool variable, string argument )

```
		{
```
```
			if ( variable )
```
```
			{
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( "Duplicate command line switch {0}", argument.ToUpper( ) );

```
				Console.ResetColor( );
```
```
				errors = true;
```
```
			}
```
```
			else
```
```
			{
```
```
				variable = true;
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		public static void ConnectorTypeQuery( )

```
		{
```
```
			string query = string.Empty;
```
```
			string type = string.Empty;
```
```
 
```
```
			if ( ps2 && serial && usb )
```
```
			{
```
```
				ps2 = false;
```
```
				serial = false;
```
```
				usb = false;
```
```
			}
```
```
 
```
```
			if ( ps2 || serial || usb )
```
```
			{
```
```
				if ( ps2 )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```
```
						query += " OR ConnectorType='0'";
```
```
					}
```
```
					else
```
```
					{
```

						query += " WHERE ConnectorType='0'";

```
					}
```

					if ( string.IsNullOrWhiteSpace( type ) )

```
					{
```
```
						type += " PS/2";
```
```
					}
```
```
					else
```
```
					{
```
```
						type += " or PS/2";
```
```
					}
```
```
				}
```
```
				if ( serial )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```
```
						query += " OR ConnectorType='1'";
```
```
					}
```
```
					else
```
```
					{
```

						query += " WHERE ConnectorType='1'";

```
					}
```

					if ( string.IsNullOrWhiteSpace( type ) )

```
					{
```
```
						type += " serial";
```
```
					}
```
```
					else
```
```
					{
```
```
						type += " or serial";
```
```
					}
```
```
				}
```
```
				if ( usb )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```
```
						query += " OR ConnectorType='2'";
```
```
					}
```
```
					else
```
```
					{
```

						query += " WHERE ConnectorType='2'";

```
					}
```

					if ( string.IsNullOrWhiteSpace( type ) )

```
					{
```
```
						type += " USB";
```
```
					}
```
```
					else
```
```
					{
```
```
						type += " or USB";
```
```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			keyboardquery += query;
```
```
			keyboardtype += type;
```
```
			mousequery += query;
```
```
			mousetype += type;
```
```
		}
```
```
 
```
```
 
```

		public static void ShowCount( int count, string deviceclass, string devicetype, string plural )

```
		{
```
```
			if ( !quiet )
```
```
			{
```
```
				if ( count == 0 )
```
```
				{
```

					Console.ForegroundColor = ConsoleColor.Red;

```
					Console.Write( "No" );
```
```
					Console.ResetColor( );
```

					Console.WriteLine( "{0} {1} detected", devicetype, deviceclass );

```
					if ( verbose )
```
```
					{
```
```
						Console.WriteLine( );
```
```
					}
```
```
				}
```
```
				else if ( count == 1 )
```
```
				{
```

					Console.ForegroundColor = ConsoleColor.Green;

```
					Console.Write( "1" );
```
```
					Console.ResetColor( );
```

					Console.Write( "{0} {1} detected", devicetype, deviceclass );

```
					if ( verbose )
```
```
					{
```
```
						Console.Write( ":" );
```
```
					}
```
```
					Console.WriteLine( );
```
```
				}
```
```
				else
```
```
				{
```

					Console.ForegroundColor = ConsoleColor.Green;

```
					Console.Write( count );
```
```
					Console.ResetColor( );
```

					Console.Write( "{0} {1} detected", devicetype, plural );

```
					if ( verbose )
```
```
					{
```
```
						Console.Write( ":" );
```
```
					}
```
```
					Console.WriteLine( );
```
```
				}
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		public static int ShowHelp( params string[] errmsg )

```
		{
```
```
			#region Error Message
```
```
 
```
```
			if ( errmsg.Length > 0 )
```
```
			{
```

				List<string> errargs = new List<string>( errmsg );

```
				errargs.RemoveAt( 0 );
```
```
				Console.Error.WriteLine( );
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );

```
				Console.ResetColor( );
```
```
			}
```
```
 
```
```
			#endregion Error Message
```
```
 
```
```
 
```
```
			#region Help Text
```
```
 
```
```
			/*
```
```
			HasHardware.exe,  Version 1.03
```

			Check the actual number of connected input and video devices available

```
 
```

			Usage:    HasHardware.exe  [ hardware  [ type ] ]  [ output ]

```
 
```

			Hardware: /I  check dIsplay (monitors) only (default: keyboard, monitor, mouse)

					  /K  check Keyboards only          (default: keyboard, monitor, mouse)

					  /M  check Mice only               (default: keyboard, monitor, mouse)

```
 
```

			Type:     /A  count Analog (VGA) monitors only          (default: all types)

					  /D  count Digital (DVI/HDMI/DP) monitors only (default: all types)

					  /P  count PS/2 mice and/or keyboards only     (default: all types)

					  /S  count Serial mice and/or keyboards only   (default: all types)

					  /U  count USB mice and/or keyboards only      (default: all types)

```
 
```

			Output:   /C  Continue on (access denied) errors (default: terminate on error)

			          /H  Hide (access denied) errors        (default: terminate on error)

			          /Q  Quiet mode: no screen output       (default: # per device class)

					  /V  Verbose output: display properties (default: # per device class)

					  /Y  YesNo mode: available or not?      (see Notes)

```
 
```

			Notes:    This program requires elevated privileges.

					  Hardware and types can be combined, e.g. /K /M /P /U for PS/2 and

					  USB keyboards and mice; if no type is specified, all types will be

```
			          listed.
```

					  Command line switches /Q and /V are mutually exclusive.

			          In case of access denied errors, switches /C and /H will use

			          alternative WMI queries to count keyboards and/or mice; with /C an

			          error message will be displayed, followed by the "plan B count", and

			          return code will be -1; with /H the "plan B count" will be shown

			          without error message, and return code will not be affected; the

			          alternative WMI queries may return less details, e.g. there is no way

			          to determine the keyboard connector type without elevated privileges.

					  Return code equals the sum of detected matching devices, or with /Y

			          100 x K + 10 x V + M (K = keyboard count, V = monitors, M = mice),

			          or -1 in case of command line or access denied errors.

```
 
```
```
			Examples:   HasHardware
```

			            Show keyboards, monitors and mice (all types)

			            Return code equals total number of matching devices

```
 
```
```
			            HasHardware /Y
```

			            Show keyboards, monitors and mice

			            Return code 111 if at least 1 keyboard and at least 1 monitor and

			            at least 1 mouse were detected

```
 
```
```
			            HasHardware /M /K /U /Y
```

			            Show USB keyboards and mice, ignore monitors

			            Return code 101 if at least 1 USB keyboard and at least 1 USB mouse

```
			            were detected
```
```
 
```
```
			            HasHardware /U /D
```

			            Show USB keyboards and mice and digital moitors

			            Return code equals total number of matching devices

```
 
```
```
			Written by Rob van der Woude
```
```
			https://www.robvanderwoude.com
```
```
			*/
```
```
 
```
```
			#endregion Help Text
```
```
 
```
```
 
```
```
			#region Display Help Text
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "HasHardware.exe,  Version {0}", progver );

```
 
```

			Console.Error.WriteLine( "Check the actual number of connected input and video devices available" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Usage:    " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "HasHardware.exe  [ hardware  [ type ] ]  [ output ]" );

```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Hardware: " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/I" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  check d" );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "I" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "splay (monitors) only (default: keyboard, monitor, mouse)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /K" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  check " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "K" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "eyboards only          (default: keyboard, monitor, mouse)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /M" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  check " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "M" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ice only               (default: keyboard, monitor, mouse)" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Type:     " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/A" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  count " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "A" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "nalog (VGA) monitors only          (default: all types)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /D" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  count " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "D" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "igital (DVI/HDMI/DP) monitors only (default: all types)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /P" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  count " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "P" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "S/2 mice and/or keyboards only     (default: all types)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /S" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  count " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "S" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "erial mice and/or keyboards only   (default: all types)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /U" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  count " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "U" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "SB mice and/or keyboards only      (default: all types)" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Output:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/C  C" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ontinue on (access denied) errors (default: terminate on error)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /H  H" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ide (access denied) errors        (default: terminate on error)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /Q  Q" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "uiet mode: no screen output       (default: # per device class)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /V  V" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "erbose output: display properties (default: # per device class)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /Y  Y" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "esNo mode: available or not?      (see Notes)" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Notes:    This program requires elevated privileges." );

```
 
```

			Console.Error.Write( "          Hardware and types can be combined, e.g. " );

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "/K /M /P /U" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " for PS/2 and" );

```
 
```

			Console.Error.WriteLine( "          USB keyboards and mice; if no type is specified, all types will be" );

```
 
```

			Console.Error.WriteLine( "          listed." );

```
 
```

			Console.Error.Write( "          Command line switches " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/Q" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.Write( " and " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/V" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " are mutually exclusive." );

```
 
```

			Console.Error.Write( "          In case of access denied errors, switches " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/C" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.Write( " and " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/H" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " will use" );

```
 
```

			Console.Error.Write( "          alternative WMI queries to count keyboards and/or mice; with " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/C" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.WriteLine( " an" );
```
```
 
```

			Console.Error.WriteLine( "          error message will be displayed, followed by the \"plan B count\", and" );

```
 
```

			Console.Error.Write( "          return code will equal -1; with " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "/H" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " the \"plan B count\" will be shown" );

```
 
```

			Console.Error.WriteLine( "          without error message, and return code will not be affected; the" );

```
 
```

			Console.Error.WriteLine( "          alternative WMI queries may return less details, e.g. there is no way" );

```
 
```

			Console.Error.WriteLine( "          to determine the keyboard connector type without elevated privileges." );

```
 
```

			Console.Error.Write( "          Return code equals the sum of detected matching devices, or with " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.WriteLine( "/Y" );
```
```
 
```

			Console.Error.Write( "          100 x K + 10 x V + M" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "  (K = keyboards, V = monitors, M = mice)," );

```
 
```

			Console.Error.WriteLine( "          or -1 in case of command line or access denied errors." );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.Write( "Examples:   " );

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "HasHardware" );

```
			Console.ResetColor( );
```
```
 
```

			Console.Error.WriteLine( "            Show keyboards, monitors and mice (all types)" );

```
 
```

			Console.Error.WriteLine( "            Return code equals total number of matching devices" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "            HasHardware /Y" );

```
			Console.ResetColor( );
```
```
 
```

			Console.Error.WriteLine( "            Show keyboards, monitors and mice" );

```
 
```

			Console.Error.WriteLine( "            Return code 111 if at least 1 keyboard and at least 1 monitor and" );

```
 
```

			Console.Error.WriteLine( "            at least 1 mouse were detected" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "            HasHardware /M /K /U /Y" );

```
			Console.ResetColor( );
```
```
 
```

			Console.Error.WriteLine( "            Show USB keyboards and mice, ignore monitors" );

```
 
```

			Console.Error.WriteLine( "            Return code 101 if at least 1 USB keyboard and at least 1 USB mouse" );

```
 
```

			Console.Error.WriteLine( "            were detected" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "            HasHardware /U /D" );

```
			Console.ResetColor( );
```
```
 
```

			Console.Error.WriteLine( "            Show USB keyboards and mice and digital moitors" );

```
 
```

			Console.Error.WriteLine( "            Return code equals total number of matching devices" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Written by Rob van der Woude" );

```
 
```

			Console.Error.WriteLine( "https://www.robvanderwoude.com" );

```
 
```
```
			#endregion Display Help Text
```
```
 
```
```
 
```
```
			return -1;
```
```
		}
```
```
 
```
```
 
```

		static string VideoOutputTechnology( string id )

```
		{
```
```
			string result = null;
```
```
 
```

			Dictionary<long, string> VideoOutputTechnology = new Dictionary<long, string>

```
			{
```
```
				{ -2, "unknown connector(s)" },
```
```
				{ -1, "other connector(s)" },
```
```
				{ 0, "HD15 (VGA) connector" },
```
```
				{ 1, "S-video connector" },
```

				{ 2, "composite video connectors" },

				{ 3, "component video connectors" },

				{ 4, "Digital Video Interface (DVI) connector" },

				{ 5, "High-Definition Multimedia Interface (HDMI) connector" },

				{ 6, "Low Voltage Differential Swing (LVDS) or Mobile Industry Processor Interface (MIPI) Digital Serial Interface (DSI) connector" },

```
				{ 8, "D-Jpn connector" },
```
```
				{ 9, "SDI connector" },
```
```
				{ 10, "external display port" },
```
```
				{ 11, "embedded display port" },
```

				{ 12, "external Unified Display Interface (UDI)" },

				{ 13, "embedded Unified Display Interface (UDI)" },

				{ 14, "dongle cable that supports SDTV" },

```
				{ 15, "wireless Miracast" },
```
```
				{ 16, "wired indirect" },
```

				{ 0x80000000, "internal connection (e.g. laptop)" }

```
			};
```
```
 
```

			// This query gets the monitor connector type ON THE VIDEO CARD SIDE

			string query = string.Format( "SELECT * FROM WmiMonitorConnectionParams WHERE InstanceName='{0}'", id ).Replace( @"\", @"\\" );

			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", query );

			ManagementObjectCollection colItems = searcher.Get( );

			foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
			{
```

				long videooutputtechnology = long.Parse( queryObj["VideoOutputTechnology"].ToString( ) );

				result = VideoOutputTechnology[videooutputtechnology];

```
				queryObj.Dispose( );
```
```
			}
```
```
 
```
```
			return result;
```
```
		}
```
```
 
```
```
 
```
```
		static void Win32_Keyboard( )
```
```
		{
```

			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\CIMV2", "SELECT * FROM Win32_Keyboard" );

			ManagementObjectCollection colItems = searcher.Get( );

```
			keyboardcount = colItems.Count;
```

			ShowCount( keyboardcount, "keyboard", string.Empty, "keyboards" ); // unable to determine connector type without elevated privileges

```
			if ( verbose && keyboardcount > 0 )
```
```
			{
```

				foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
				{
```

					int availability = 2; // default: Unknown

					if ( !( queryObj["Availability"] is null ) )

```
					{
```

						availability = int.Parse( queryObj["Availability"].ToString( ) );

```
					}
```

					Console.WriteLine( "\tAvailability            : {0}", Availability[availability] );

					Console.WriteLine( "\tCaption                 : {0}", queryObj["Caption"] );

					Console.WriteLine( "\tDescription             : {0}", queryObj["Description"] );

					Console.WriteLine( "\tLayout                  : {0}", queryObj["Layout"] );

					Console.WriteLine( "\tName                    : {0}", queryObj["Name"] );

					Console.WriteLine( "\tNumber of Function Keys : {0}", queryObj["NumberOfFunctionKeys"] );

					Console.WriteLine( "\tPnP Device ID           : {0}", queryObj["PNPDeviceID"] );

					Console.WriteLine( "\tStatus                  : {0}", queryObj["Status"] );

```
					Console.WriteLine( );
```
```
					queryObj.Dispose( );
```
```
				}
```
```
				Console.WriteLine( );
```
```
			}
```
```
		}
```
```
 
```
```
 
```
```
		static void Win32_PointingDevice( )
```
```
		{
```

			string query = "SELECT * FROM Win32_PointingDevice";

			if ( !( ps2 && serial && usb ) || ps2 || serial || usb )

```
			{
```
```
				if ( ps2 )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```

						query += " OR DeviceInterface='4'";

```
					}
```
```
					else
```
```
					{
```

						query += " WHERE DeviceInterface='4'";

```
					}
```
```
				}
```
```
				if ( serial )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```

						query += " OR DeviceInterface='3'";

```
					}
```
```
					else
```
```
					{
```

						query += " WHERE DeviceInterface='3'";

```
					}
```
```
				}
```
```
				if ( usb )
```
```
				{
```
```
					if ( query.Contains( "WHERE" ) )
```
```
					{
```

						query += " OR DeviceInterface='162'";

```
					}
```
```
					else
```
```
					{
```

						query += " WHERE DeviceInterface='162'";

```
					}
```
```
				}
```
```
			}
```

			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\CIMV2", query );

			ManagementObjectCollection colItems = searcher.Get( );

```
			mousecount = colItems.Count;
```

			ShowCount( mousecount, "mouse", mousetype, "mice" );

```
			if ( verbose && mousecount > 0 )
```
```
			{
```

				foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
				{
```

					int availability = 2; // default: Unknown

					if ( !( queryObj["Availability"] is null ) )

```
					{
```

						availability = int.Parse( queryObj["Availability"].ToString( ) );

```
					}
```

					Console.WriteLine( "\tAvailability      : {0}", Availability[availability] );

					int deviceinterface = int.Parse( queryObj["DeviceInterface"].ToString( ) );

					Console.WriteLine( "\tDevice Interface  : {0}", DeviceInterface[deviceinterface] );

					Console.WriteLine( "\tHardware Type     : {0}", queryObj["HardwareType"] );

					Console.WriteLine( "\tManufacturer      : {0}", queryObj["Manufacturer"] );

					Console.WriteLine( "\tNumber of Buttons : {0}", queryObj["NumberOfButtons"] );

					Console.WriteLine( "\tPnP Device ID     : {0}", queryObj["PNPDeviceID"] );

					Console.WriteLine( "\tPointing Type     : {0}", queryObj["PointingType"] );

					Console.WriteLine( "\tStatus            : {0}", queryObj["Status"] );

```
					queryObj.Dispose( );
```
```
				}
```
```
				Console.WriteLine( );
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		static void WmiMonitorBasicDisplayParams( string id )

```
		{
```

			SortedList<int, string> VideoInputType = new SortedList<int, string>

```
			{
```
```
				{ 0, "Analog" },
```
```
				{ 1, "Digital" }
```
```
			};
```
```
 
```
```
			int videoinputtype;
```

			string query = string.Format( "SELECT * FROM WmiMonitorBasicDisplayParams WHERE InstanceName='{0}'", id ).Replace( @"\", @"\\" );

			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", query );

			ManagementObjectCollection colItems = searcher.Get( );

			foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
			{
```

				monitor.Add( "Screen Width (cm)", queryObj["MaxHorizontalImageSize"].ToString( ) );

				monitor.Add( "Screen Height (cm)", queryObj["MaxVerticalImageSize"].ToString( ) );

				videoinputtype = int.Parse( queryObj["VideoInputType"].ToString( ) );

				monitor.Add( "Video Input (Monitor)", VideoInputType[videoinputtype] );

```
			}
```
```
		}
```
```
 
```
```
 
```
```
		static void WMIMonitorID( string id )
```
```
		{
```

			string query = string.Format( "SELECT * FROM WmiMonitorID WHERE InstanceName LIKE '{0}%'", id ).Replace( @"\", @"\\" );

			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\WMI", query );

			ManagementObjectCollection colItems = searcher.Get( );

			foreach ( ManagementObject queryObj in colItems.Cast<ManagementObject>( ) )

```
			{
```

				monitor.Add( "Active", queryObj["Active"].ToString( ) );

				string instancename = queryObj["InstanceName"].ToString( );

				monitor.Add( "Product Code", Chain( (UInt16[])queryObj["ProductCodeID"] ) );

				monitor.Add( "Serial Number", Chain( (UInt16[])queryObj["SerialNumberID"] ) );

				monitor.Add( "Monitor Type", Chain( (UInt16[])queryObj["UserFriendlyName"] ) );

				monitor.Add( "Video Output (Display Adapter)", VideoOutputTechnology( instancename ) );

				monitor.Add( "Week of Manufacture", queryObj["WeekOfManufacture"].ToString( ) );

				monitor.Add( "Year of Manufacture", queryObj["YearOfManufacture"].ToString( ) );

```
				queryObj.Dispose( );
```

				WmiMonitorBasicDisplayParams( instancename );

```
			}
```
```
		}
```
```
	}
```
```
}
```