{"id":54653,"date":"2009-01-08T11:52:00","date_gmt":"2009-01-08T11:52:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/01\/08\/hey-scripting-guy-how-can-i-configure-the-cmd-console-via-the-registry\/"},"modified":"2009-01-08T11:52:00","modified_gmt":"2009-01-08T11:52:00","slug":"hey-scripting-guy-how-can-i-configure-the-cmd-console-via-the-registry","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-how-can-i-configure-the-cmd-console-via-the-registry\/","title":{"rendered":"Hey, Scripting Guy! How Can I Configure the Cmd Console via the Registry?"},"content":{"rendered":"

\"Hey, <\/h2>\n

Hey, Scripting Guy! You know, it just dawned on me that Windows PowerShell uses the old-fashioned Fred Flintstone<\/a> cmd console for its host application. Because this thing has been around forever, are there any registry settings I can use to configure this beast? The reason I am asking is that every time I go to a new machine, I need to right-click the little icon, open up the property page, and make my configuration settings. I would love to be able to run a script that would set things up the way I wish. Can you help?<\/p>\n

– BP<\/p>\n

\"Spacer\"\"Hey,<\/p>\n

Hi BP,<\/p>\n

Fred Flintstone does DOS (dinosaur operating system). You are, however, correct that Windows PowerShell uses the old-fashioned cmd console and as such can be configured via the registry. But before we get too far into answering your question, please stand by for a few words from our sponsors. <\/p>\n\n<\/thead>\n\n\n
\n

Standard disclaimer<\/b>: The script today talks about editing the registry. Microsoft does not support editing the registry, because you can really mess stuff up if you are not careful.<\/b> If your script causes your computer to jump off your desk and bite the postman, please send us the script because we would love to see something like that. If you gain massive amounts of weight and all your hair falls out, don\u2019t send us your script; we already have enough problems in that arena. If your pet rabbit gets an unquenchable desire for Anzak biscuits<\/a> and starts listening to Olivia Newton John songs, don’t say we didn’t warn you. Please back up your registry before proceeding to run the script.<\/b> Back up everything you don’t want to lose just to be on the safe side. <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

<\/div>\n

The first thing you should do before working with the registry is make sure you are either working in a virtual machine that allows you to roll back changes if you wish, or ensure you have a good backup of the registry. Jerry Honeycutt has written a number of good books about the registry<\/a> for Microsoft Press, as well as a number of excellent articles such as this one<\/a>. By the way, in case you do not know, you can download Microsoft Virtual PC 2007<\/a> for free. <\/p>\n

For a good overview of the registry, you can refer to this article<\/a>. To explore the registry, you can use the Tweakomatic<\/a>, which produces scripts in VBScript. Here is a good Sesame Script article<\/a> that gives an overview of the registry. And here is the Script Center registry archive<\/a>. <\/p>\n

Today’s script allows us to retrieve and configure a number of console settings. In this script, we will also illustrate using a class from the .NET Framework. Here\u2019s today\u2019s script:<\/p>\n

Param([switch]$get,[switch]$set)\nFunction Get-Settings()\n{\n $hklm = \"HKEY_CURRENT_USER\"\n $key = \"Console\"\n $properties = \"QuickEdit\",\"FullScreen\",\"InsertMode\"\n Foreach ($property in $properties)\n  {\n   $property + \": \" + [Microsoft.Win32.Registry]::GetValue(\"$hklm\\$key\",$property,$null)\n  }\n} #end Get-Settings\nFunction Set-Settings()\n{\n $hklm = \"HKEY_CURRENT_USER\"\n $key = \"Console\"\n $hash = @{\"QuickEdit\" = 1 ; \"FullScreen\" = 0 ; \"InsertMode\" = 1 }\n Foreach($name in $hash.keys)\n {\n  \"Changing \" + $name + \" to \" + $hash[$name]\n  [Microsoft.Win32.Registry]::SetValue(\"$hklm\\$key\",$name,$hash[$name])\n }\n} #end Set-Settings\n# *** Entry Point To Script ***\nif($get) {Get-Settings}\nif($set) {Set-Settings}\n<\/pre>\n
As mentioned earlier, the cmd console has a number of properties that can be configured via the registry. These settings are seen here:<\/p>\n
\"Image<\/p>\n
 <\/p>\n
In our script, the first thing we do is create a couple of command-line parameters. To do this, we use the Param<\/b> statement. This statement must be the first non-commented line in the script. We use the switchparameter<\/b> structure, which has a type alias of [switch]<\/b> to convert our command-line parameter into a switched parameter. A switched parameter only has effect when it is present on the command line. Suppose, for example, we run the script with a command line such as the one seen here:<\/p>\n
GetSetConsoleSettings.ps1 \u2013get<\/pre>\n
Then the script will only retrieve the console settings. If we run it with the \u2013set<\/b> switch, it will only set the console settings. One of the cool things about command-line parameters is that you do not need to type the entire parameter name. You can, for instance, run the script as shown here: <\/p>\n
GetSetConsoleSettings.ps1 \u2013g -s<\/pre>\n
The line of code that creates the command-line parameters is shown here: <\/p>\n
Param([switch]$get,[switch]$set)<\/pre>\n
We now need to create the Get-Settings<\/b> function. To do this, we use the function<\/b> key word as illustrated here: <\/p>\n
Function Get-Settings()<\/pre>\n
We then create a few variables. The first variable, $hklm<\/b>, represents the registry hive of HKEY_CURRENT_USER, although we could have called it anything we wish. The second variable is the registry key we wish to work with, which is the console key. These two variables are seen here:<\/p>\n
 $hklm = \"HKEY_CURRENT_USER\"\n $key = \"Console\"\n<\/pre>\n
We also create an array of property names. This will allow us to minimize the amount of code that we need to write, and it is actually a pretty cool way to retrieve the property values. To create an array in Windows PowerShell, we need only assign more than one item to the variable. As seen here, when we assign multiple items to the variable, it is automatically an array. When we query the variable, it will spit out all of the items by default:<\/p>\n
PS C:\\> $a = 1,2,3\nPS C:\\> $a\n1\n2\n3\n<\/pre>\n
If we need to retrieve a specific item from the array, we can do so by using the element number, beginning with 0. This is seen here: <\/p>\n
PS C:\\> $a[0]\n1\nPS C:\\> $a[1]\n2\nPS C:\\> $a[2]\n3\n<\/pre>\n
If we are interested in seeing all of the items, one element at a time, we could use the For\u2026Next<\/b> loop (except that Windows PowerShell does not use a next<\/b> at the end of the for<\/b> loop; so I guess it is really only a for<\/b> loop.) This is seen here:<\/p>\n
for($i = 0 ; $i -le $a.length -1 ; $i++) {$a[$i]}<\/pre>\n
It might make more sense, if we used the foreach<\/b> statement. This is because the foreach<\/b> statement does not require us to increment a counter variable, as the for<\/b> statement did. Notice how much simpler this code appears:<\/p>\n
PS C:\\> Foreach($i in $a) {$i}\n1\n2\n3\n<\/pre>\n
The array of property names is shown here: <\/p>\n
 $properties = \"QuickEdit\",\"FullScreen\",\"InsertMode\"<\/pre>\n
To work through the array of property names, we decide to use the foreach<\/b> statement, as seen here: <\/p>\n
 Foreach ($property in $properties)<\/pre>\n
Then we call the static GetValue<\/b> method from the Microsoft.Win32.Registry<\/b> .NET Framework class. When we do this, we need to give the GetValue<\/b> the registry root name with the key name, the property name, and a default value for the registry key, if it is not present. Valid root names are listed here:<\/p>\n\n\n\n\n\n\n\n\n\n
\u2022<\/td>\n\n
HKEY_CURRENT_USER<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_LOCAL_MACHINE<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_CLASSES_ROOT<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_USERS<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_PERFORMANCE_DATA<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_CURRENT_CONFIG<\/p>\n<\/td>\n<\/tr>\n
\u2022<\/td>\n\n
HKEY_DYN_DATA<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
In our script, we are interested in printing out the value that is contained in the registry key property. We use the variable $property<\/b> and concatenate the string with the value returned from the GetValue<\/b> static method. This is shown here: <\/p>\n
  {\n   $property + \": \" + [Microsoft.Win32.Registry]::GetValue(\"$hklm\\$key\",$property,$null)\n  }\n} #end Get-Settings\n<\/pre>\n
It is time to create the Set-Settings<\/b> function. We once again use the function key word: <\/p>\n
Function Set-Settings()<\/pre>\n
You can probably guess what comes next. Sure, we need to define some more variables and set their associated values. These are the same two variables we used in the previous function:<\/p>\n
{\n $hklm = \"HKEY_CURRENT_USER\"\n $key = \"Console\"\n<\/pre>\n
Now let’s get a bit more sophisticated. Yes, it is time for a spot of tea in my new tea pot the Scripting Wife gave me for Christmas, complete with an assortment of loose leaf teas in their own little tin canisters. I think that Earl Grey tea will do nicely on this rainy Charlotte, NC, USA, afternoon. If only I could steal some Anzak biscuits from the neighbor\u2019s pet rabbit. I am back. The little dude ate all the biscuits. Oh, well.<\/p>\n
When we create a hash table, we use a variable to hold it, and use the special ampersand character followed with a couple of curly brackets. Each name\/value pair is assigned by using the equal sign and separated by a semicolon. As seen here, when you call the variable by itself, it prints out all the name\/value pairs: <\/p>\n
PS C:\\> $hash = @{\"QuickEdit\" = 1 ; \"FullScreen\" = 0 ; \"InsertMode\" = 1 }\nPS C:\\> $hash\nName                           Value\n----                           -----\nInsertMode                     1\nQuickEdit                      1\nFullScreen                     0\n<\/pre>\n
Because this is Windows PowerShell and everything in Windows PowerShell is an object, this means that the $hash<\/b> variable contains an object. In fact, it is the same object you would use in C# or in VB.NET: the System.Collections.Hashtable<\/b> class. The System.Collections.Hashtable<\/b> class has the members shown in Table 1.<\/p>\n
Table 1 WMI registry tree values<\/b><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Name<\/td>\nMember Type<\/td>\nDefinition<\/td>\n<\/tr>\n<\/thead>\n
\n
Add<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void Add(Object key, Object value)<\/p>\n<\/td>\n<\/tr>\n
\n
Clear<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void Clear()<\/p>\n<\/td>\n<\/tr>\n
\n
Clone<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Object Clone()<\/p>\n<\/td>\n<\/tr>\n
\n
Contains<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean Contains(Object key)<\/p>\n<\/td>\n<\/tr>\n
\n
ContainsKey<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean ContainsKey(Object key)<\/p>\n<\/td>\n<\/tr>\n
\n
ContainsValue<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean ContainsValue(Object value)<\/p>\n<\/td>\n<\/tr>\n
\n
CopyTo<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void CopyTo(Array array, Int32 arrayIndex)<\/p>\n<\/td>\n<\/tr>\n
\n
Equals<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean Equals(Object obj)<\/p>\n<\/td>\n<\/tr>\n
\n
GetEnumerator<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Collections.IDictionaryEnumerator GetEnumerator()<\/p>\n<\/td>\n<\/tr>\n
\n
GetHashCode<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Int32 GetHashCode()<\/p>\n<\/td>\n<\/tr>\n
\n
GetObjectData<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void GetObjectData(SerializationInfo info, StreamingContext context)<\/p>\n<\/td>\n<\/tr>\n
\n
GetType<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Type GetType()<\/p>\n<\/td>\n<\/tr>\n
\n
get_Count<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Int32 get_Count()<\/p>\n<\/td>\n<\/tr>\n
\n
get_IsFixedSize<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean get_IsFixedSize()<\/p>\n<\/td>\n<\/tr>\n
\n
get_IsReadOnly<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean get_IsReadOnly()<\/p>\n<\/td>\n<\/tr>\n
\n
get_IsSynchronized<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Boolean get_IsSynchronized()<\/p>\n<\/td>\n<\/tr>\n
\n
get_Item<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Object get_Item(Object key)<\/p>\n<\/td>\n<\/tr>\n
\n
get_Keys<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Collections.ICollection get_Keys()<\/p>\n<\/td>\n<\/tr>\n
\n
get_SyncRoot<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Object get_SyncRoot()<\/p>\n<\/td>\n<\/tr>\n
\n
get_Values<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Collections.ICollection get_Values()<\/p>\n<\/td>\n<\/tr>\n
\n
On_Deserialization<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void OnDeserialization(Object sender)<\/p>\n<\/td>\n<\/tr>\n
\n
Remove<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void Remove(Object key)<\/p>\n<\/td>\n<\/tr>\n
\n
set_Item<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.Void set_Item(Object key, Object value)<\/p>\n<\/td>\n<\/tr>\n
\n
ToString<\/p>\n<\/td>\n
\n
Method<\/p>\n<\/td>\n
\n
System.String ToString()<\/p>\n<\/td>\n<\/tr>\n
\n
Item<\/p>\n<\/td>\n
\n
ParameterizedProperty<\/p>\n<\/td>\n
\n
System.Object Item(Object key) {get;set;}<\/p>\n<\/td>\n<\/tr>\n
\n
Count<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Int32 Count {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
IsFixedSize<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Boolean IsFixedSize {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
IsReadOnly<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Boolean IsReadOnly {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
IsSynchronized<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Boolean IsSynchronized {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
Keys<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Collections.ICollection Keys {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
SyncRoot<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Object SyncRoot {get;}<\/p>\n<\/td>\n<\/tr>\n
\n
Values<\/p>\n<\/td>\n
\n
Property<\/p>\n<\/td>\n
\n
System.Collections.ICollection Values {get;} <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
<\/div>\n
By playing around with the methods and properties from the HashTable<\/b> class, you can leverage this object to allow you to do some rather clever things. As an example, see how easy it is to find out if we have the value 5<\/b> in our hash table:<\/p>\n
PS C:\\> $hash.ContainsValue(1)\nTrue\nPS C:\\> $hash.ContainsValue(5)\nFalse\n<\/pre>\n
At any rate, here is the line of code that creates the HashTable<\/b> for our script:<\/p>\n
$hash = @{\"QuickEdit\" = 1 ; \"FullScreen\" = 0 ; \"InsertMode\" = 1 }<\/pre>\n
To walk through the HashTable<\/b>, we can use this trick<\/a> from the VBScript days. We obtain a collection of all the keys in the HashTable<\/b> by using the keys property, and we use the $name<\/b> variable with the foreach<\/b> statement as our enumerator. This is seen here: <\/p>\n
 Foreach($name in $hash.keys)<\/pre>\n
We now print out just a bit of confirmation by indexing into the HashTable<\/b> via the $name<\/b> variable. We also concatenate the $name<\/b> variable with the value associated with name from the hash table. This is seen here: <\/p>\n
 {  \"Changing \" + $name + \" to \" + $hash[$name] <\/pre>\n
Next we use the SetValue<\/b> static method from the Microsoft.Win32.Registry<\/b> .NET Framework class. The SetValue<\/b> static method takes the registry hive and registry key in the first position. The second position is the name of the property, and the third position is the value to assign to that property. This is seen here: <\/p>\n
  [Microsoft.Win32.Registry]::SetValue(\"$hklm\\$key\",$name,$hash[$name])\n }\n} #end Set-Settings\n<\/pre>\n
Now we need to check the command-line parameters. To do this, we use an if<\/b> statement. If the variable exists, we call the appropriate function. This is seen here:<\/p>\n
if($get) {Get-Settings}\nif($set) {Set-Settings}\n<\/pre>\n
Well BP, I hope you have enjoyed registry week. I tried to show you different ways to do the same kinds of things. Along the way, we also picked up some decent tricks for working with Windows PowerShell. Join us tomorrow for Quick-Hits Friday where we will explore some more hot topics fresh from the scripter@microsoft.com<\/b> inbox (I have finally caught it up by the way). Until then, take care and don’t download any dancing babies<\/a>.<\/p>\n
Ed Wilson and Craig Liebendorfer, Scripting Guys<\/b><\/b><\/span><\/font><\/p>\n
<\/b><\/font><\/p>\n","protected":false},"excerpt":{"rendered":"
Hey, Scripting Guy! You know, it just dawned on me that Windows PowerShell uses the old-fashioned Fred Flintstone cmd console for its host application. Because this thing has been around forever, are there any registry settings I can use to configure this beast? The reason I am asking is that every time I go to […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[16,31,26,3,45],"class_list":["post-54653","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-desktop-management","tag-operating-system","tag-registry","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"
Hey, Scripting Guy! You know, it just dawned on me that Windows PowerShell uses the old-fashioned Fred Flintstone cmd console for its host application. Because this thing has been around forever, are there any registry settings I can use to configure this beast? The reason I am asking is that every time I go to […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54653","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=54653"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54653\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=54653"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=54653"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=54653"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}