How can I measure the window height (number of lines) in powershell?

Question

The maximum number of lines in my environment is 47.

Can I measure this value programmatically?

Answer 1

To complement Christian.K's helpful answer:

• A simpler and slightly more efficient method for obtaining the host object is to use the $Host automatic variable rather than the Get-Host cmdlet.

• You're only guaranteed to have access to window-size information in the PowerShell console host, i.e., when running in a console (terminal) window

  • It is at a given host's discretion whether to expose this information, and, as Christian states, the PowerShell ISE does not - even though it arguably should, given that it has a console subsystem built in.

• To test whether your code is running in a console (a.k.a terminal) or not, use
  $Host.UI.SupportsVirtualTerminal - $True indicates that the host is a console.

---

If running in the PowerShell console host:

You can access the console's properties either:

• via $Host.UI.RawUI (as in Christian's answer), which is an object of type [System.Management.Automation.Internal.Host.InternalHostRawUserInterface] that - in the PowerShell console host only - wraps the .NET [Console] class (see below).

• via the .NET [Console] class; e.g., to get the window height (count of rows) this way, use:

  • [Console]::WindowHeight

Sample $Host.UI.RawUI output:

PS> $Host.UI.RawUI

ForegroundColor       : DarkYellow
BackgroundColor       : DarkMagenta
CursorPosition        : 0,58
WindowPosition        : 0,0
CursorSize            : 25
BufferSize            : 160,9999
WindowSize            : 160,75
MaxWindowSize         : 160,94
MaxPhysicalWindowSize : 303,94
KeyAvailable          : True
WindowTitle           : Windows PowerShell

---

If running in the PowerShell ISE:

^{Written as of PowerShell version 5.1}

Most of the properties in $Host.UI.RawUI are not populated and will return their data type's default value:

PS> $Host.UI.RawUI  # in the ISE

ForegroundColor       : -1
BackgroundColor       : -1
CursorPosition        : 0,0
WindowPosition        : 
CursorSize            : 
BufferSize            : 166,0
WindowSize            : 
MaxWindowSize         : 
MaxPhysicalWindowSize : 
KeyAvailable          : 
WindowTitle           : Windows PowerShell ISE

The only size-related information that is available is the buffer width (166 in the sample output above).

There is no point in trying to use the .NET [Console] class in the ISE, except to query / set the character encoding used for communication with external programs, [Console]::OutputEncoding:^[1]

• Initially in a session, trying to use the window-related members of [Console] causes exceptions, because the ISE does not allocate a console window on startup:

  # In a pristine session.
  PS> [Console]::WindowHeight
  The handle is invalid.     # EXCEPTION
  

• While the ISE allocates a - hidden - console window on demand, namely the first time you run a console application in your session, that hidden console window's properties, as then reported on via [Console], do not reflect the properties of the simulated console that the ISE presents to the user.

  # chcp is a console application, so when it is run, 
  # the ISE allocates a (hidden) console window, 
  # after which the [Console] API becomes technically usable, 
  # but DOESN'T REPORT MEANINGFUL VALUES.
  PS> chcp >$null; [Console]::WindowHeight
  72  # No exception, but the value is meaningless.
  

---

^{[1] Note that the ISE defaults to the system's legacy ANSI code page, whereas regular console windows default to the OEM code page. Thus, these two environments decode output from external programs differently by default.}

Answer 2

The functionality I really need is git status, git diff in powershell_ise with highlight and output paging. It seems that the current version of powershell_ise does not solve the problem itself.

Although not completely satisfactory, I have devised a practical solution and created the following function.

source code

function hhd-git-diff
{
    [CmdletBinding()]
    param
    (
    )

    $res = git diff
    hhd-git-colored-output -INPUT_OBJECT $res
}



function hhd-git-status
{
    [CmdletBinding()]
    param
    (
    )

    $res = git status
    hhd-git-colored-output -INPUT_OBJECT $res
}



function hhd-git-colored-output
{
    [CmdletBinding()]
    param
    (
        [Parameter(Mandatory=$true, ValueFromPipeline=$true, ValueFromPipelinebyPropertyName=$true)]
        [System.Object]
        $INPUT_OBJECT
    )



    $lineNum = 1



    $INPUT_OBJECT | 
    Out-String | 
    foreach {

        $_ -split "\n" |

        foreach {

            if($lineNum % [Console]::WindowHeight -eq 0)
            {
                Read-Host "continue? press any key..."
            }

            $lineNum++

            if($_ -like "diff --git *")
            {
                Write-Host ""
                Write-Host ""
                Write-Host ""
                Write-Host ("#"*80) -ForegroundColor Cyan
                Write-Host $_ -ForegroundColor Cyan
                Write-Host ("#"*80) -ForegroundColor Cyan
                Read-Host "continue? press any key..."
                $lineNum = 1
            }
            elseif($_ -like "--- *")
            {
            }
            elseif($_ -like "+++ *")
            {
            }
            elseif($_ -like "-*")
            {
                Write-Host $_ -ForegroundColor Red
            }
            elseif($_ -like "+*")
            {
                Write-Host $_ -ForegroundColor Green
            }
            elseif($_ -like "On branch *")
            {
                Write-Host ("#"*80) -ForegroundColor Cyan
                Write-Host $_ -ForegroundColor Cyan
            }
            elseif($_ -like "Your branch is*")
            {
                Write-Host $_ -ForegroundColor Cyan
                Write-Host ("#"*80) -ForegroundColor Cyan
            }
            elseif($_ -like "Changes to be committed:*")
            {
                Write-Host ("-"*80) -ForegroundColor Green
                Write-Host $_ -ForegroundColor Green
            }
            elseif($_ -like "Changes not staged for commit:*")
            {
                Write-Host ("-"*80) -ForegroundColor Red
                Write-Host $_ -ForegroundColor Red
            }
            elseif($_ -like "Untracked files:*")
            {
                Write-Host ("-"*80) -ForegroundColor Black
                Write-Host $_ -ForegroundColor Black
            }
            elseif($_ -like "*modified:*")
            {
                Write-Host $_ -ForegroundColor Yellow
            }
            elseif($_ -like "*deleted:*")
            {
                Write-Host $_ -ForegroundColor Red
            }
            else
            {
                Write-Host $_ -ForegroundColor Gray
            }
        }
    }



}

screen shot

Answer 3

You could try something like

$(Get-Host).UI.RawUI.WindowSize.Height

Note a couple of things however:

• Using the RawUI might not be particular "portable", depending on where your script runs. In "ISE" for example, that property returns nothing, while on the console it will work.

  For more difference here between the console and ISE, run $(Get-Host).UI.RawUI and compare the output.

  In other PowerShell hosts, besides the console or ISE, it might yet be still different.

• There is also a BufferSize, which can be bigger than the WindowSize. The later being only the part that is currently "viewable" by the user.

Your question sounds a little like a xy problem. Consider explaining (as an edit to your question or a new question), what you're actually trying to achieve, i.e. why you need to know the number of lines?