GUI/Maximum window dimensions: Difference between revisions

{{libheader|GTK}}

{{libheader|GtkAda}}

with Glib;

with Gtk.Window; use Gtk.Window;

New_Line;

Hid := Gtk.Main.Quit_Add_Destroy (0, Win);

Output (on a 1280 x 800 screen with Windows XP):

<pre>Maximum dimensions of window : W 1280 x H 734

This is a modified example taken from the AutoHotkey documentation for the [http://ahkscript.org/docs/commands/SysGet.htm SysGet] command.

Also, the built in variables [http://ahkscript.org/docs/Variables.htm#Screen A_ScreenHeight] and [http://ahkscript.org/docs/Variables.htm#Screen A_ScreenWidth] contain the width and height of the primary monitor, in pixels.

SysGet, MonitorPrimary, MonitorPrimary

MsgBox, Monitor Count:`t%MonitorCount%`nPrimary Monitor:`t%MonitorPrimary%

. "`nRight:`t" MonitorRight " (" MonitorWorkAreaRight " work)"

. "`nBottom:`t" MonitorBottom " (" MonitorWorkAreaBottom " work)"

'''Output:'''

<pre>Monitor Count: 1

=={{header|BaCon}}==

Requires BaCon version 4.0.1 or higher, using GTK3.

PRAGMA GUI gtk3

gui = Define_Window()

ALARM Print_Dimensions, 500

{{out}}

Result when executed using my 1600x900 screen:

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

{{works with|BBC BASIC for Windows}}

DIM rc{l%,t%,r%,b%}

SYS "SystemParametersInfo", SPI_GETWORKAREA, 0, rc{}, 0

PRINT "Maximum width = " ; rc.r% - rc.l%

'''Output:'''

<pre>

===Windows===

The following implementation has been tested on Windows 8.1, may not work on Linux systems.

#include<windows.h>

#include<stdio.h>

return 0;

}

Output :

<pre>

Bounds are the screen's dimensions; working area is the is the region that excludes "taskbars, docked windows, and docked tool bars" (from Framework documentation).

using System.Drawing;

using System.Windows.Forms;

Console.WriteLine($"Primary screen working area: {workingArea.Width}x{workingArea.Height}");

}

{{out}}

Alternatively, use the dimensions of a borderless form with WindowState set to FormWindowState.Maximized (i.e. a full-screen window that is shown above the taskbar).

using System.Drawing;

using System.Windows.Forms;

}

}

{{out}}

=={{header|Creative Basic}}==

DEF Win:WINDOW

DEF Close:CHAR

Output: Maximum drawing area values: width is 1280 and height is 749.

=={{header|Delphi}}==

{{libheader| Winapi.Windows}}

{{libheader| System.SysUtils}}

{{libheader| Vcl.Forms}}

unit Main;

end;

Resources from form:

OnCreate = FormCreate

=={{header|EGL}}==

</pre>

Usage of the Browser external type in a RuiHandler.

browser Browser{};

bvh int = browser.getViewportHeight();

SysLib.writeStdout("ViewportHeight: " + bvh);

SysLib.writeStdout("ViewportWidth: " + bvw);

Output

<pre>

=={{header|FBSL}}==

In the graphics mode, Windows does it all automatically and displays a form that fills the entire area not obscured by the taskbar on your primary monitor:

ShowWindow(ME, SW_MAXIMIZE)

BEGIN EVENTS

Alternatively, one can obtain the unobscured area's dimensions using the following console script:

#INCLUDE <Include\Windows.inc>

PRINT "width = ", rc.Right - rc.Left, ", height = ", rc.Bottom - rc.Top

A typical output for a 1680x1050 primary monitor will be:

=={{header|FreeBASIC}}==

' Using SystemParametersInfo function in Win32 API

Print

Print "Press any key to quit"

Output for my machine:

{{out}}

From with the project create a form (FMain) with the following properties set:

From within the projectview, rightclick the FMain form and select Edit class from the contextmenu. This will display a form class file (FMain.class) as follows:

END

PUBLIC SUB Form_Open()

=== Adding the form resize event ===

We can now add a Form_Resize() event to the class file with the necessary code to obtain the screen dimensions as follows:

PRINT "The maximum window size that can be used without scrolling is "; FMain.Width; " x "; FMain.Height

=={{header|Gambas}}==

Print Desktop.Width

Print Desktop.Height

Output:

<pre>

=={{header|Go}}==

{{libheader|RobotGo}}

import (

fmt.Printf("Max usable : %d x %d\n", w, h)

}

On my machine the figures are:

=={{header|Groovy}}==

=={{header|Haskell}}==

import Control.Monad (when)

import Control.Monad.Trans (liftIO)

liftIO $ putStrLn ("The inner window region is now " ++ show x ++

" pixels wide and " ++ show y ++ " pixels tall.")

=={{header|Icon}} and {{header|Unicon}}==

Raise and query a hidden window.

procedure main() # Window size

write("The display size is w=",dw,", h=",dh)

{{improve|Icon|Need to handle window borders which will vary from system to system and handle or comment on additional requirements.}}

=={{header|IWBASIC}}==

DEF Win:WINDOW

DEF Close:CHAR

Output: Maximum drawing area values: width is 1280 and height is 749.

=={{header|J}}==

For example:

Here, we had a screen with 1366 by 768 pixels (width and height), and space for decorations subtract 18 from each of those dimensions.

=={{header|Java}}==

import javax.swing.JFrame;

System.out.println("Max available: " + screenSize);

}

Output:

=={{header|Julia}}==

Uses the Gtk library.

win = GtkWindow("hello", 100, 100)

fullscreen(win)

println(width(win), " ", height(win))

destroy(win)

{{output}} <pre>

1920 1080

=={{header|Kotlin}}==

{{trans|Java}}

import java.awt.Toolkit

fun main(args: Array<String>) {

Test()

Sample output:

{{out}}

=={{header|Lingo}}==

=={{header|Lua}}==

win = nw:app():window(320, 240)

win:show()

win:maximize()

cw, ch = win:client_size()

On a 1920 x 1080 screen..

{{out}}

We can read twipsX and twipsY as twips per pixel in X and Y direction

Module CheckAllMonitors {

mode 16 ' font size

}

CheckAllMonitors

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

Example output on a 1280x1024 system.

=={{header|Nim}}==

{{libheader|Gtk2}}

Getting the screen size, ignoring borders, is as easy as:

gtk2, gdk2

var w = gdk2.screen_width()

var h = gdk2.screen_height()

{{out}}

<pre>WxH=1920x1080</pre>

But getting the real size excluding borders is more difficult, at least with Gtk. We need to draw a window at maximum size and wait enough time before asking for its size. The following program does the job:

proc printSize(window: PWindow): guint {.cdecl.} =

discard g_timeout_add(100, printSize, addr(window[]))

{{out}}

<pre>W x H = 1920 x 1031</pre>

{{libheader|gintro}}

This is the translation of Gtk2 program to Gtk3 using “gintro” bindings.

var window: ApplicationWindow

let app = newApplication(Application, "Rosetta.ScreenSize")

discard app.connect("activate", activate)

{{out}}

<pre>W x H = 1920 x 1031</pre>

===With IUP===

{{libheader|IUP}}

iup

#discard iup.mainloop()

{{out}}

<pre>1280x800

=={{header|PARI/GP}}==

=={{header|Perl}}==

==={{libheader|Perl/Tk}}===

use strict;

use warnings;

return ($mw->maxsize);

}

get_size returns (1425,870) here.

{{trans|Nim}}

{{libheader|Phix/pGUI}}

<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

{{Out}}

<pre>

=={{header|PicoLisp}}==

The following works on ErsatzLisp, the Java version of PicoLisp.

(java Frame 'setExtendedState

(java (public "javax.swing.JFrame" 'MAXIMIZED_BOTH)) )

(prinl "Width: " (java (public Size 'width)))

(prinl "Height: " (java (public Size 'height))) )

Output (on a 1024x768 screen):

<pre>Width: 1010

fullScreen() is the recommended approach to draw a window covering the entire screen from Processing 3.0+ onwards. The implementation below first creates a window and then prints the dimensions onto the canvas.

//Aamrun, 26th June 2022

text("Screen Height : " + str(height), 100, 100);

text("Screen Width : " + str(width), 100, 200);

=={{header|PureBasic}}==

maxX = WindowWidth(0)

maxY = WindowHeight(0)

CloseWindow(0)

MessageRequester("Result", "Maximum Window Width: " + Str(maxX) + ", Maximum Window Height: " + Str(maxY))

Sample output for a screen area 1600 x 1200:

<pre>Maximum Window Width: 1600, Maximum Window Height: 1181</pre>

=={{header|Python}}==

#!/usr/bin/env python3

font=("Helvetica", 25)).pack() # add a label and set the size to text.

root.mainloop()

Sample output for 1366 x 768 screen:

<pre>1366 x 706</pre>

=={{header|Racket}}==

#lang racket/gui

(define-values [W H]

(send f show #f))))

(printf "~ax~a\n" W H)

=={{header|Raku}}==

This is kind-of a silly task. The maximum window size is going to depend on your OS, hardware, display server and graphics toolkit, not your programming language. Taken at face value, using a Linux system running an X11 display server, the maximum displayable window size is the resolution of your monitor. Basically, the size of your desktop viewport. The Raku module X11::libxdo returns the desktop viewport size for get-desktop-dimensions which is the effective maximum window size.

my $xdo = Xdo.new;

my ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );

{{out|On my system returns}}

<pre>Desktop viewport dimensions: (maximum-fullscreen size) 1920 x 1080</pre>

=={{header|Ring}}==

load "guilib.ring"

new qApp {

exec()

}

Output:

IE browser uses different functions than everyone else.

So you write code for the world, and also for IE

html "<INPUT TYPE='HIDDEN' id='winHigh' name='winHigh' VALUE='";winHigh;"'></input>"

html "<INPUT TYPE='HIDDEN' id='winWide' name='winWide' VALUE='";winWide;"'></input>"

var x = winSize();

//--></script>

=={{header|Scala}}==

import javax.swing.JFrame

new MaxWindowDims

}

=={{header|Sidef}}==

Using the Tk library:

func max_window_size() -> (Number, Number) {

var (width, height) = max_window_size();

{{out}}

=={{header|Tcl}}==

{{libheader|Tk}}

proc maxSize {} {

# Need a dummy window; max window can be changed by scripts

# Default max size of window is value we want

return [wm maxsize $top]

On this system, that returns <code>1440 836</code>. Further discussion of related matters, including platform limitations, is on [http://wiki.tcl.tk/10872 the Tcler's Wiki].

The first method involves querying the screen dimensions and then subtracting pixels used by the frame and desktop bars:

screenheight AS INTEGER

screenwidth AS INTEGER

syswindow.screenheight=Screen.Height / Screen.TwipsPerPixelY

=== Method 2 ===

Bounds are the screen's dimensions; working area is the is the region that excludes "taskbars, docked windows, and docked tool bars" (from Framework documentation).

Imports System.Windows.Forms

Console.WriteLine($"Primary screen working area: {workingArea.Width}x{workingArea.Height}")

End Sub

{{out}}

Alternatively, use the dimensions of a borderless form with WindowState set to FormWindowState.Maximized (i.e. a full-screen window that is shown above the taskbar).

Imports System.Windows.Forms

End Using

End Sub

{{out}}

=={{header|Wren}}==

{{libheader|DOME}}

import "dome" for Window, Process

import "graphics" for Canvas, Color

static draw(alpha) {}

{{out}}

=={{header|XPL0}}==

GetFB is a built-in function available on the Raspberry Pi that returns information about the current frame buffer.

[A:= GetFB;

Text(0, "Width = "); IntOut(0, A(0)); CrLf(0);

Text(0, "Height = "); IntOut(0, A(1)); CrLf(0);

{{out}}