Terminal control/Dimensions: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program terminalSize64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

Program start

Program normal end.

</pre>

=={{header|Applesoft BASIC}}==

 

=={{header|Arturo}}==

 

 

=={{header|AutoHotkey}}==

{{trans|C}}

AutoHotkey is not built for the console (it is GUI oriented) so we must call the WinAPI directly.

hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 )

 

columns := right - left + 1

rows := bottom - top + 1

 

=={{header|Axe}}==

BaCon supports functions to retrieve the current number of <code>ROWS</code> and <code>COLUMNS</code>.

 

X = COLUMNS

Y = ROWS

 

 

=={{header|Batch File}}==

'''Screen Buffer Size:'''

 

for /f "tokens=1,2 delims= " %%A in ('mode con') do (

echo Lines: %line%

echo Columns: %cols%

{{Out}}

<pre>>Size.Bat

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

{{works with|all BBC BASIC}}

This has the side effect of scrolling the viewport up one line.

{{works with|BBC BASIC where VDU() is supported}}

This has the side effect of scrolling the viewport up one line.

 

 

{{works with|BSD|4.4}}

#include <err.h> /* err */

#include <fcntl.h> /* open */

close(fd);

return 0;

 

=== [[Windows]] ===

 

{{works with|MinGW}}

#include <wchar.h>

 

 

return 0;

 

=={{header|C sharp|C#}}==

WindowHeight and WindowWidth are simply the size of the window, it only represents the active viewing area which may be larger or more commonly smaller than the size of the buffer.

 

static void Main(string[] args)

{

Console.ReadLine();

}

 

On the author's system this results in the following output:

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. terminal-dimensions.

 

 

GOBACK

 

=={{header|Common Lisp}}==

==={{header|ncurses}}===

To interface the ncurses C library from Lisp, the ''croatoan'' library is used.

(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)

(let ((width (width scr))

(refresh scr)

;; wait for keypress

 

=={{header|Euphoria}}==

 

sequence vc

 

printf(1,"Terminal height is %d\n",term_height)

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

let bufferHeight = Console.BufferHeight

Console.Write("Window Width: ")

Console.WriteLine(windowWidth)

 

=={{header|Forth}}==

{{works with|GNU Forth}} {{works with|SwiftForth}}

 

variable term-height

 

get-size ( width height ) swap

[then]

 

 

=={{header|FreeBASIC}}==

Dim driver_name As String

Screeninfo w, h, p, bpp, , tasa

Print " Tasa de refresco: "; tasa; " (Hz)"

Print " Nombre del driver: "; driver_name

 

=={{header|Go}}==

===Sub-repository===

{{libheader|Go sub-repositories}}

 

import (

}

fmt.Println(h, w)

 

===External command===

 

import (

fmt.Sscan(string(d), &h, &w)

fmt.Println(h, w)

===Ncurses===

{{libheader|curses}}

 

import (

height, width := s.MaxYX()

fmt.Println(height, width)

 

=={{header|J}}==

Nevertheless, assuming J version 6 in its usual environment, to determine its width and height, in pixels, you can use:

 

 

Note also that this will typically include 37 extra pixels horizontally and 79 extra pixels vertically, which are not available to display text. In other words, if the result was 700 500 you would really have 663 pixels of width and 421 pixels of height.

 

=={{header|Julia}}==

julia> using Gtk

 

 

julia>

 

=={{header|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

/*

println("Lines = $lines")

println("Columns = $columns")

 

{{out}}

Locomotive BASIC has no built-in command to get window dimensions, but there is a firmware call to &bb69 (TXT_GET_WINDOW) for this. So we have to use a snippet of Z80 machine code to call the firmware and copy the results from the DE and HL registers to RAM. It looks like this when disassembled:

 

4001 e5 push hl

4002 cd 69 bb call &bb69

400c e1 pop hl

400d d1 pop de

 

This routine gets POKEd into RAM (starting at address &4000) and CALLed from Locomotive BASIC, then the results are retrieved with PEEK:

 

20 FOR i=0 to 14:READ a:POKE s+i,a:NEXT

30 DATA &d5,&e5,&cd,&69,&bb,&ed,&53,&20,&40,&22,&22,&40,&e1,&d1,&c9

50 h=PEEK(&4020)-PEEK(&4022)+1

60 w=PEEK(&4021)-PEEK(&4023)+1

 

In practice, one would prefer to write the machine code routine as a slightly more elaborate RSX ('''r'''esident '''s'''ystem e'''x'''tension) which is a freely relocatable and therefore more reusable Locomotive BASIC extension. The RSX routine might be called "getwh" and accept pointers to integers, which would simplify the BASIC code to:

 

20 |getwh,@w%,@h% ' call RSX and pass variables as pointers

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|Nim}}==

 

 

let (width, height) = terminalSize()

 

echo "Terminal width: ", width

 

{{out}}

Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal] in the interactive loop:

 

 

# let width, height = ANSITerminal.size () ;;

val width : int = 126

 

=={{header|Perl}}==

 

 

($cols, $rows) = Term::Size::chars;

 

=={{header|Phix}}==

The buffer is usually somewhat larger (and never smaller) than the current physical screen size. I would guess that most applications are more interested in the latter.

{{out}}

<pre>

 

=={{header|PicoLisp}}==

Width (in '(tput cols) (read))

 

=={{header|PureBasic}}==

 

This code is for Windows only.

GetStdHandle_( #STD_OUTPUT_HANDLE )

EndMacro

;

Print(#CRLF$+"Press ENTER to exit"):Input()

 

=={{header|Python}}==

This uses the [http://python.net/crew/theller/ctypes/ ctypes library] in order to get the console dimensions on Windows. This code is a slight refactoring of an [http://code.activestate.com/recipes/440694-determine-size-of-console-window-on-windows/ ActiveState Recipe]. For Linux, the tput utility is used.

 

 

def get_windows_terminal():

 

print get_linux_terminal() if os.name == 'posix' else get_windows_terminal()

 

=={{header|Racket}}==

#lang racket

(require (planet neil/charterm:3:0))

(with-charterm

(charterm-screen-size))

 

=={{header|Raku}}==

(formerly Perl 6)

Using <i>stty</i> just for the heck of it.

my $lines = $stty.match(/ 'rows ' <( \d+/);

my $cols = $stty.match(/ 'columns ' <( \d+/);

 

=={{header|Retro}}==

This information is provided by Retro in the '''ch''' (height) and '''cw''' (width) variables. You can manually obtain it using the io ports.

 

 

=={{header|REXX}}==

 

Some REXX interpreters don't provide basic [[terminal control]] as part of the language. However, it's possible to determine the size of the terminal window by using external system commands:

height = 'tput'( 'lines' )

 

say 'The terminal is' width 'characters wide'

 

===LINESIZE===

The <code>LINESIZE</code> built-in function returns the (terminal) screen's width. &nbsp; It is supported by most (classic) REXX interpreters (and some others) such as: CMS REXX, TSO REXX, VSE REXX, the IBM REXX compiler, PC/REXX, Personal REXX, REXX/imc, R4 and ROO. &nbsp; A sample usage of it is:

The above example makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

<br>The &nbsp; '''LINESIZE.REX''' &nbsp; REXX program is included here ──► [[LINESIZE.REX]].

===SCRSIZE===

<code>SCRSIZE</code> is another built-in function, and returns two integers: the screen depth and the screen width. &nbsp; A few classic REXX interpreters support it: &nbsp; PC/REXX, Personal REXX, R4 and ROO.

The above example makes use of &nbsp; '''SCRSIZE''' &nbsp; REXX program (of BIF) which is used to determine the screen size of the terminal (console).

<br>The &nbsp; '''SCRSIZE.REX''' &nbsp; REXX program is included here ──► [[SCRSIZE.REX]].<br>

 

=={{header|Ring}}==

system("mode 50,20")

 

=={{header|Ruby}}==

# Ruby 1.9.3 added 'io/console' to the standard library.

require 'io/console'

 

rows, cols = winsize

 

==={{libheader|curses}}===

<code>Curses.lines</code> and <code>Curses.cols</code> return the size of the terminal. The program ''must'' call <code>Curses.init_screen</code>, because without this call, Curses might report 0 lines and 0 columns. Beware that <code>Curses.init_screen</code> also switches the terminal to screen-oriented mode, and fails on those terminals that cannot support curses.

 

 

begin

ensure

Curses.close_screen

 

=={{header|Scala}}==

{{Works with|Ubuntu|14.04}}

First execute the terminal command: 'export COLUMNS LINES'

before running this program for it to work (returned 'null' sizes otherwise).

 

val (lines, columns) = (System.getenv("LINES"), System.getenv("COLUMNS"))

 

=={{header|Seed7}}==

''Height'' and ''width'' are based on terminfo respectively the Windows console API.

 

include "console.s7i";

 

# the program waits until Return/Enter is pressed.

readln;

 

=={{header|Sidef}}==

{{trans|Raku}}

var lines = stty.match(/\brows\h+(\d+)/);

var cols = stty.match(/\bcolumns\h+(\d+)/);

{{out}}

<pre>

=={{header|Tcl}}==

{{trans|UNIX Shell}}

set height [exec tput lines]

 

=== Alternative ===

'''Requires''': GNU coreutils

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

WIDTH=`tput cols`

HEIGHT=`tput lines`

 

==={{libheader|termcap}}===

<div style="background-color: #ffc;">termcap is obsolete.</div>

WIDTH=`tput co`

HEIGHT=`tput li`

 

==={{header|C Shell}}===

set WIDTH=`tput cols`

set HEIGHT=`tput lines`

 

{{trans|C#}}

 

Sub Main()

End Sub

 

{{Out}}

I put the built application in Desktop:

=={{header|Wren}}==

As there is currently no way to obtain this information via Wren CLI, we instead embed a Wren script in a C application and ask the host program to get it for us.

 

class C {

System.print("The dimensions of the terminal are:")

System.print(" Width = %(w)")

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <stdio.h>

#include <string.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

 

=={{header|XPL0}}==

int W, H;

[W:= Peek($40, $4A); \IBM-PC BIOS data

Text(0, "Terminal width and height = ");

IntOut(0, W); ChOut(0, ^x); IntOut(0, H);

 

Output:

 

=={{header|Yabasic}}==

w = peek("screenwidth")

h = peek("screenheight")

print " Ancho de la pantalla: ", w, " (pixel)"

print "Altura de la pantalla: ", h, " (pixel)\n"

 

 

Unix specific solution:

{{trans|GO}}

{{out}}<pre>91 x 24</pre>