Gaurav » vista

Multiple ways to open PowerShell in the current Explorer window

Gaurav — Tue, 14 Oct 2008 16:42:35 +0000

These techniques are generic and can be used for other items like command prompt as well. A word of caution, everything given below involves fiddling with the registry so please backup your system’s registry or create a restore point before trying this out.

1) Adding it to Vista Explorer’s toolbar:

This is the most convenient one in my opinion, but requires most work to enable it.

Firstly, navigate to the following registry key:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\explorer\FolderTypes\{7d49d726-3c21-4f05-99aa-fdc2c9474656}

Its should have the following items:

Note that it has following two items:

TasksItemsSelected: Enabled when an item is selected in the view.
TasksNoItemsSelected: Enabled when nothing is selected in the view.

Each of these keys have multiple items inside them each pointing to separate shortcut inside the toolbar.

Import the following registry file so that the PowerShell icon appears in the toolbar:

Download From Skydrive

Before importing I will also point out that I am assuming the a batch file exists at the following path:

C:\\Users\\Gaurav\\Programs\\shortcuts\\psh_launch.bat %2

The content of this file should be:

@echo off
pushd %1
%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe
@echo

You can search and replace the location of this file to your custom location inside the just downloaded registry file. Its being used in two places.

Also, remember to take a backup of this registry key or make a restore point before importing this registry key.

That’s it. Now a PowerShell Icon should appear inside the every folder.

The PowerShell icon still doesn’t appear?

Actually the registry file only modifies the folders of Document Type and the PowerShell icon will appear only inside folders of Document Type.

An easy way to make all the folders inside a Drive Document Type:

right click on drive/partition –> select Properties –> select Customize tab-> and select following options:

So this way we just forced all the folders in the drive to be of Document Type.

The same procedure can be used to add multiple items on the toolbar. Its a lot of work but the end result is worth it :)

2) Using AutoHotKey

AutoHotKey is used for creating keyboard macros.

AutoHotKey will use the same batch file that was created to launch PowerShell in the current directory.

Here is the script:

!p::
IfWinActive ahk_class CabinetWClass
{
WinGetClass explorerClass, A
ControlGetText currentPath, Edit1, ahk_class %explorerClass%
run C:\\Users\\Gaurav\\Programs\\shortcuts\\psh_launch.bat "%currentPath%"
}
return

Just fix path to the batch file, save and reload AutoHotKey.

Now press Alt + P to launch PowerShell inside the current explorer window.

3) Right Click Menu

To add PowerShell to right click menu navigate to following registry entry:

HKEY_CLASSES_ROOT\Directory\Background\shell

and create a key with name powershell inside shell and a key with name command inside it. Edit the default value of command key to:

C:\Users\Gaurav\Programs\shortcuts\psh_launch.bat “%V”

This is same batch file created earlier and the exact path needs to be fixed.

or just import this file into your registry and fix the path to the batch file:

Download from Skydrive

That’s it, now PowerShell should show up in you right-click menu inside any directory.

Context sensitive auto-completion using PowerShell, PowerTab and GIT

Gaurav — Mon, 13 Oct 2008 19:33:46 +0000

Powertab is an Awesome PowerShell TabExpansion extension. It extends the default PowerShell autocompletion and shows the results like:

The best part is that it is easily customizable.

One way to customize it is by editing it Tab Expansion database file which is located in your powershell profile directory:

TabExpansion.xml

To display some simple git commands in autocompletion all the following entries to it:

<Custom>
  <Filter>gitFilter>
  <Text>statusText>
  <Type>CustomType>
Custom>
<Custom>
  <Filter>gitFilter>
  <Text>add .Text>
  <Type>CustomType>
Custom>
<Custom>
  <Filter>gitFilter>
  <Text>pullText>
  <Type>CustomType>
Custom>
<Custom>
  <Filter>gitFilter>
  <Text>pushText>
  <Type>CustomType>
Custom>
<Custom>
  <Filter>gitFilter>
  <Text>commit -m ""Text>
  <Type>CustomType>
Custom>
<Custom>
  <Filter>gitFilter>
  <Text>commit -a -m ""Text>
  <Type>CustomType>
Custom>

To invoke this list add the following to TabExpansion.ps1 file which should be in the source directory:

'git(.*)' {
  if(Test-Path .git) {
    $global:dsTabExpansion.Tables['Custom'].select("filter = 'git' AND type = 'Custom'") | % {$_.text} | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
  }
}

This should be added in the Main tabcompletion block inside the switch statement. The function is basically matching the current command name with git and then invoking autocompletion.

Now when you type git then the output should look like below:

I am sure this is not the best way to do custom autocompletion but i couldn’t find an easier way.

This is all static stuff. To add dynamic autocompletion (like providing branch names) add following to the TabExpansion.ps1 file:

'git(.*)' {
  if(Test-Path .git) {
    # git checkout
    if($lastBlock -match 'git checkout'){
      git branch | %{ if($_ -match "^\*?\s*(.*)"){ $matches[1] } } | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
    else{
      $global:dsTabExpansion.Tables['Custom'].select("filter = 'git' AND type = 'Custom'") | % {$_.text} | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
  }
}

Now when you type git checkout then it should show the following in the autocomplete list:

This function checks if the user has entered git checkout as the command then it runs the git branch command, parses it and shows the result as autocomplete list.

Here are couple more commands that I wrote while trying this out:

'git(.*)' {
  if(Test-Path .git) {
    # git checkout
    if($lastBlock -match 'git checkout'){
      git branch | %{ if($_ -match "^\*?\s*(.*)"){ $matches[1] } } | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
    
    # git add
    Elseif($lastBlock -match 'git add'){
      $s = $False ; git status | %{ if($s -eq $True -and $_ -match "^#\s{1,1}(\S.+)$"){ $matches[1] } ElseIf($_ -match 'Untracked files:'){ $s = $True } } | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
    
    # git rm
    Elseif($lastBlock -match 'git rm'){
      git status | %{ if($_ -match "^#\s+deleted:\s+(\S.+)$"){ $matches[1] } } | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
    
    else{
      $global:dsTabExpansion.Tables['Custom'].select("filter = 'git' AND type = 'Custom'") | % {$_.text} | Invoke-TabItemSelector  -SelectionHandler $SelectionHandler
    }
  }
}

These will autocomplete parameters for git add and git rm commands by running the git status command and parsing the output.

For example:

I think a lot more interesting stuff can be created using PowerTab and GIT.

Update 1:

Turns out as pointed by MOW that there is a much easier way to add custom expansions instead of editing the TabExpansion.xml file.

Just run this command inside PowerShell:

Invoke-TabExpansionEditor

It will open up a dialog box like:

Here custom items can be added by clicking the Custom link and then the database change can by saved by running the command:

Export-tabExpansionDataBase

Displaying GIT Branch on your PowerShell prompt

Gaurav — Sun, 12 Oct 2008 07:48:28 +0000

PowerShell is a command line shell like the command prompt (cmd.exe) but with a lot more features. It can be downloaded from here.

One of the features is that you can change the default prompt. Prompt can be changed by overriding the function with name “prompt”.

This function can be declared inside the PowerShell profile file which has the path:

C:\Users\Gaurav\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1

If the file does not exist then you will need to create this file. Declaring the following function inside the profile file will change the prompt.

function prompt {
  return "prompt> "
}

to:

Now, to display the git branch as a prompt change the function to the following:

function prompt {
  $host.ui.rawui.WindowTitle = $(get-location)
  
  $prompt_string = ""
  
  if(Test-Path .git) {
    $prompt_string = "GIT"
    git branch | foreach {
      if ($_ -match "^\*(.*)"){
        $prompt_string += $matches[1] + "> "
      }
    }
  }
  else{
    $prompt_string = "PS> "
  }
  
  Write-Host ($prompt_string) -nonewline -foregroundcolor yellow
  return " "
}

and the prompt will look like:

The code basically is checking if current directory is a git project. This can be done by checking if there is a directory with name “.git” in the current directory. If yes then it runs the “git branch” command and then passes the result through a regular expression to get the current branch.

Here is my full PowerShell prompt function:

$Global:CurrentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent()
$UserType = "User"
$CurrentUser.Groups | foreach { if($_.value -eq "S-1-5-32-544") {$UserType = "Admin"} }
  
function prompt {
  if($UserType -eq "Admin") {
    $host.ui.rawui.WindowTitle = "" + $(get-location) + " : Admin"
    $host.UI.RawUI.ForegroundColor = "Yellow"
  }
  else {
    $host.ui.rawui.WindowTitle = $(get-location)
  }
  
  Write-Host("")
  
  $status_string = ""
  
  if(Test-Path .git) {
    $status_string = "GIT"
    git branch | foreach {
      if ($_ -match "^\*(.*)"){
        $status_string += $matches[1]
      }
    }
    
    $git_create_count = 0
    $git_update_count = 0
    $git_delete_count = 0
    
    git status | foreach {
      if($_ -match "modified:"){ 
        $git_update_count += 1
      }
      elseif($_ -match "deleted:"){ 
        $git_delete_count += 1
      }
      elseif($_ -match "added:"){ 
        $git_create_count += 1
      }
    }
    $status_string += " u:" + $git_update_count + " d:" + $git_delete_count + ">"
  }
  else{
    $status_string = "PS>"
  }
  
  Write-Host ($status_string) -nonewline -foregroundcolor yellow
  return " "
}

This function also displays updated and deleted files in the current git project.

Scripts execution in PowerShell is disabled?

If you just created the profile file then PowerShell may display the following error message when loading this profile we just created:

File C:\Users\Gaurav\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1 cannot be loaded because the execution of scripts is disabled on this system. Please see “get-help about_signing” for more details.
At line:1 char:2
+ . <<<< ‘C:\Users\Gaurav\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1′

This is because PowerShell does not allow the execution of scripts by default. To fix this open PowerShell in Admin mode and set the execution policy to unrestricted by running the following command:

   1: Set-ExecutionPolicy Unrestricted

Compiling and Installing GIT on windows under cygwin

Gaurav — Fri, 11 Apr 2008 19:56:10 +0000

Using GIT was one of the requirements of one of the project that I am doing. Here is how I installed GIT on Windows.

So What is GIT?

The supplied documentation of GIT says that:

Git is a fast, scalable, distributed revision control system with an unusually rich command set that provides both high-level operations and full access to internals.

Here is the link for the wikipedia entry.

Where can I download GIT?

Here is the link.

Before following the given steps you will need to install cygwin on your system, and add its bin directory to the system path (so that all the cygwin commands are available from inside the command prompt).

So after installing cygwin run setup.exe inside the cygwin installation folder and make sure the following modules are installed.

make
gcc c anc c++ compilers
openssl-devel
curl-devel
Any other dependencies that are missing..

All these packages are located inside the Devel branch of the package tree. Required dependencies will be selected automatically.

Click next to install selected packages.

Compiling GIT form source

Untar the GIT source you downloaded using the command “tar xvzf git-1.5.5.tar.gz” .

Navigate to the untarred directory using a command prompt. Now run the “make” command inside the GIT source directory.

If it runs successfully then run “make install”.

Before running the command make sure you have Perl (language) installed. You can check it by running the command:

perl -MCPAN -e 'shell'

and then running the following inside the cpan shell:

install blib

it should show no error. I am not sure if this is the best way to do this as I am not much of a Perl guy.

So as I mentioned before you need to run the following two command to make and install Perl:

   1: make
   2: make install

If these two steps complete successfully then your GIT is ready to go :). You can test this by running the “git” command. This command is located inside the “C:/cygwin/home/gaurav/bin”. You might to add this folder to the system path too.

Pre-configured version

Here is a cygwin version pre-configured to compile GIT. It is installed on my system and works fine. Cygwin 1.5.25 and GIT 1.5.5 are preinstalled in this archive. Just decompress this archive under folder “C:\cygwin” and add “C:\cygwin\bin” and “C:/cygwin/home/gaurav/bin” to your system path and GIT should work form any command window.

del.icio.us Tags: GIT,open source,perl,vista,windows,cygwin

New and Improved Sudo for Vista (now remembers credentials)

Gaurav — Wed, 02 Apr 2008 11:02:14 +0000

In one of my earlier blog post I shared source code for a simple utility that I had made. It could be used to launch elevated processes from the command line.

So opening a Elevated command prompt was as simple as writing

sudo cmd

Actually the code for this is very simple as it just executes a well documented system function ShellExecute.

I have made some changes to the script and now it remembers the credentials. So once you execute any command, Vista will ask you confirmation only once and any subsequent call won’t ask for the confirmation with the UAC dialog box.

The concept behind this is very simple too:

A process launched from any elevated process will be (by default) automatically elevated at administrative assess. So what this script (client) does is launch a elevated Ruby server first time you run it, so it will Vista will prompt you for confirmation. For any subsequent call it will just see that the server is already running and it will just use that server for elevating launched processes.

How it works:

When you write “sudo cmd” in the command prompt (or run it any where else):

Check if the “sudo server” process is running. If not then start it. (This will result in a UAC prompt).
Connect to the server using TCP and ask it to run the command “sudo cmd”.
The server will launch the elevated process.

The code for Client and the Server is in Ruby and thus can easily be improved upon. One can easily add code to kill the server after a specific time interval or after running a fixed number of commands. Actually I am not sure if this is the correct way to handle this, so any comments will be welcome.

Download Here

Just un-rar this file anywhere and add it to system path. To run it just write sudo in “command prompt” of in the “Run dialog box”. Example to run notepad: “sudo notepad”

This code was written with ruby 1.8.6.

Tabs for windows explorer

Gaurav — Sat, 01 Dec 2007 14:31:20 +0000

QT Tab Bar is a new software that I have come across that alows you to have tabs on windows explorer.

It integrates very well in the windows interface and adds features that are normally associated to a web browser like firefox. When you middle click on a folder it opens in a new tab, middle click opens a tab and it also stores a history for tabs.

You can optionally make many more changes to the explorer making more usable and easier to navigate.

The download link is on this page.

Sudo for Vista

Gaurav — Wed, 28 Nov 2007 05:16:40 +0000

The following ruby script when given any executable file path as the argument runs it in administrative mode.

   1: require 'Win32API'

2:

   3: def shell_execute(process_name)

   4:     process = ''

   5:     process.replace(process_name)

   6:     se = Win32API.new("shell32", "ShellExecute", ['P','P','P','P','P','I'], 'I')

   7:     se.Call(nil,"runas",process,nil,nil,5)

   8: end

9:

  10: shell_execute(ARGV[0])

In Vista you can do the same by right clicking on the file and selecting “Run as Administrator” but this script allows you to run a process in admin mode using the command line.

The ShellExecute function resides in the shell32.dll and is documented here.

By just giving “runas” as the second parameter to the function the process is executed in the administrative mode.

Periodically changing desktop wallpaper using Ruby

Gaurav — Tue, 27 Nov 2007 16:46:15 +0000

Here is small ruby script that picks up a random image from a given folder and sets it as the desktop wallpaper.

require 'Win32API'
  
SPI_SETDESKWALLPAPER = 20
SPIF_SENDCHANGE = 0x2
SOURCE_FOLDER = "C:\\Users\\Gaurav\\Pictures\\Best\\"
  
files = Dir.entries(SOURCE_FOLDER) - [".", ".."]
file = files[rand(files.length)]
  
systemParametersInfo = Win32API.new("user32","SystemParametersInfo",["I", "I", "P", "I"],"I")
p systemParametersInfo.call(SPI_SETDESKWALLPAPER, 1, SOURCE_FOLDER + file, SPIF_SENDCHANGE)

The constant SOURCE_FOLDER can be changed to point at the folder which contain all your wallpaper and the script then randomly chooses a wallpaper from the collection.

You can also set your task scheduler to run this script automatically after a fixed interval so that your desktop wallpaper keeps changing.

Here is the pastie.

Windows XP SP3 boasts speed boost, testers claim

Gaurav — Tue, 27 Nov 2007 04:45:32 +0000

According to this link http://www.computerworld.com/action/article.do?command=printArticleBasic&articleId=9048658 SP3 has made XP significantly faster.

Like users needed another reason for not migrating to VISTA.