GUI/Maximum window dimensions: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(Added Processing implementation) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(8 intermediate revisions by 7 users not shown) | |||
Line 22:
{{libheader|GTK}}
{{libheader|GtkAda}}
<
with Glib;
with Gtk.Window; use Gtk.Window;
Line 48:
New_Line;
Hid := Gtk.Main.Quit_Add_Destroy (0, Win);
end Max_Size;</
Output (on a 1280 x 800 screen with Windows XP):
<pre>Maximum dimensions of window : W 1280 x H 734
Line 56:
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%
Line 70:
. "`nRight:`t" MonitorRight " (" MonitorWorkAreaRight " work)"
. "`nBottom:`t" MonitorBottom " (" MonitorWorkAreaBottom " work)"
}</
'''Output:'''
<pre>Monitor Count: 1
Line 86:
Because Axe is currently (6/22/2015) only available on the TI-83/84 black and white calculators, the screen dimensions are fixed at 96 by 64 pixels.
=={{header|
==={{header|BaCon}}===
Requires BaCon version 4.0.1 or higher, using GTK3.
<
PRAGMA GUI gtk3
Line 115 ⟶ 116:
gui = Define_Window()
ALARM Print_Dimensions, 500
event$ = GUIEVENT$(gui)</
{{out}}
Result when executed using my 1600x900 screen:
<pre>1600-838</pre>
==={{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%
PRINT "Maximum height = " ; rc.b% - rc.t%</
'''Output:'''
<pre>
Line 136 ⟶ 137:
===Windows===
The following implementation has been tested on Windows 8.1, may not work on Linux systems.
<syntaxhighlight lang="c">
#include<windows.h>
#include<stdio.h>
Line 145 ⟶ 146:
return 0;
}
</syntaxhighlight>
Output :
<pre>
Line 162 ⟶ 163:
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;
Line 176 ⟶ 177:
Console.WriteLine($"Primary screen working area: {workingArea.Width}x{workingArea.Height}");
}
}</
{{out}}
Line 184 ⟶ 185:
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;
Line 198 ⟶ 199:
}
}
}</
{{out}}
Line 204 ⟶ 205:
=={{header|Creative Basic}}==
<syntaxhighlight lang="creative basic">
DEF Win:WINDOW
DEF Close:CHAR
Line 239 ⟶ 240:
Output: Maximum drawing area values: width is 1280 and height is 749.
</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| Winapi.Windows}}
{{libheader| System.SysUtils}}
{{libheader| Vcl.Forms}}
<syntaxhighlight lang="delphi">
unit Main;
Line 274 ⟶ 275:
end;
end.</
Resources from form:
<
OnCreate = FormCreate
end</
=={{header|EGL}}==
Line 310 ⟶ 311:
</pre>
Usage of the Browser external type in a RuiHandler.
<syntaxhighlight lang="egl">
browser Browser{};
bvh int = browser.getViewportHeight();
Line 316 ⟶ 317:
SysLib.writeStdout("ViewportHeight: " + bvh);
SysLib.writeStdout("ViewportWidth: " + bvw);
</syntaxhighlight>
Output
<pre>
Line 325 ⟶ 326:
=={{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
END EVENTS</
Alternatively, one can obtain the unobscured area's dimensions using the following console script:
<
#INCLUDE <Include\Windows.inc>
Line 345 ⟶ 346:
PRINT "width = ", rc.Right - rc.Left, ", height = ", rc.Bottom - rc.Top
PAUSE</
A typical output for a 1680x1050 primary monitor will be:
Line 353 ⟶ 354:
=={{header|FreeBASIC}}==
<
' Using SystemParametersInfo function in Win32 API
Line 371 ⟶ 372:
Print
Print "Press any key to quit"
Sleep</
Output for my machine:
{{out}}
<pre>
Maximum usable desktop area : W 1366 x H 728 pixels
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">include "NSLog.incl"
CGRect r
r = fn ScreenVisibleFrame( fn ScreenMainScreen )
NSLog(@"x:%.0f, y:%.0f, w:%.0f, h:%.0f",r.origin.x,r.origin.y,r.size.width,r.size.height)
HandleEvents</syntaxhighlight>
{{out}}
<pre>
x:0, y:50, w:1728, h:1029
</pre>
Line 388 ⟶ 402:
From with the project create a form (FMain) with the following properties set:
<
FMain.Visible = False ' The form can be invisible</
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
Line 399 ⟶ 413:
PUBLIC SUB Form_Open()
END</
=== Adding the form resize event ===
Line 405 ⟶ 419:
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
END</
=={{header|Gambas}}==
<
Print Desktop.Width
Print Desktop.Height
End</
Output:
<pre>
Line 424 ⟶ 438:
=={{header|Go}}==
{{libheader|RobotGo}}
<
import (
Line 442 ⟶ 456:
fmt.Printf("Max usable : %d x %d\n", w, h)
}
}</
On my machine the figures are:
Line 451 ⟶ 465:
=={{header|Groovy}}==
<
println "width: $window.width, height: $window.height"</
=={{header|Haskell}}==
<
import Control.Monad (when)
import Control.Monad.Trans (liftIO)
Line 507 ⟶ 521:
liftIO $ putStrLn ("The inner window region is now " ++ show x ++
" pixels wide and " ++ show y ++ " pixels tall.")
return True</
=={{header|Icon}} and {{header|Unicon}}==
Raise and query a hidden window.
<
procedure main() # Window size
Line 521 ⟶ 535:
write("The display size is w=",dw,", h=",dh)
end</
{{improve|Icon|Need to handle window borders which will vary from system to system and handle or comment on additional requirements.}}
=={{header|IWBASIC}}==
<syntaxhighlight lang="iwbasic">
DEF Win:WINDOW
DEF Close:CHAR
Line 562 ⟶ 576:
Output: Maximum drawing area values: width is 1280 and height is 749.
</syntaxhighlight>
=={{header|J}}==
For this task, we can create a temporary window, and subtract its usable area from its size. This gives us the size (in pixels) used for decorations. Then we can query the screen size and subtract the size of those decorations.
For example:
<syntaxhighlight lang="j"> (".wd 'qscreen') -&(2 3&{) (wd'pclose') ]-/".'qform',:&wd 'pc a; cc g isidraw; pshow; qchildxywh g'
1348 750</syntaxhighlight>
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;
Line 587 ⟶ 612:
System.out.println("Max available: " + screenSize);
}
}</
Output:
Line 597 ⟶ 622:
=={{header|Julia}}==
Uses the Gtk library.
<
win = GtkWindow("hello", 100, 100)
fullscreen(win)
Line 603 ⟶ 628:
println(width(win), " ", height(win))
destroy(win)
</syntaxhighlight>
{{output}} <pre>
1920 1080
Line 610 ⟶ 635:
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.awt.Toolkit
Line 633 ⟶ 658:
fun main(args: Array<String>) {
Test()
}</
Sample output:
{{out}}
Line 643 ⟶ 668:
=={{header|Lingo}}==
<
-- [rect(0, 0, 1360, 768), rect(1360, 0, 2960, 1024)]</
=={{header|Lua}}==
<syntaxhighlight lang="lua">nw = require("nw")
win = nw:app():window(320, 240)
win:show()
win:maximize()
cw, ch = win:client_size()
print(cw .. " x " .. ch)</syntaxhighlight>
On a 1920 x 1080 screen..
{{out}}
<pre>1920 x 1017</pre>
=={{header|M2000 Interpreter}}==
Line 654 ⟶ 690:
We can read twipsX and twipsY as twips per pixel in X and Y direction
<syntaxhighlight lang="m2000 interpreter">
Module CheckAllMonitors {
mode 16 ' font size
Line 728 ⟶ 764:
}
CheckAllMonitors
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Example output on a 1280x1024 system.
<
->{{1260, 951}}</
=={{header|Nim}}==
Line 739 ⟶ 775:
{{libheader|Gtk2}}
Getting the screen size, ignoring borders, is as easy as:
<
gtk2, gdk2
Line 745 ⟶ 781:
var w = gdk2.screen_width()
var h = gdk2.screen_height()
echo("WxH=",w,"x",h)</
{{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.} =
Line 766 ⟶ 802:
discard g_timeout_add(100, printSize, addr(window[]))
main()</
{{out}}
<pre>W x H = 1920 x 1031</pre>
Line 773 ⟶ 809:
{{libheader|gintro}}
This is the translation of Gtk2 program to Gtk3 using “gintro” bindings.
<
var window: ApplicationWindow
Line 800 ⟶ 836:
let app = newApplication(Application, "Rosetta.ScreenSize")
discard app.connect("activate", activate)
discard app.run()</
{{out}}
<pre>W x H = 1920 x 1031</pre>
Line 806 ⟶ 842:
===With IUP===
{{libheader|IUP}}
<
iup
Line 827 ⟶ 863:
#discard iup.mainloop()
iup.close()</
{{out}}
<pre>1280x800
Line 837 ⟶ 873:
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Perl}}==
==={{libheader|Perl/Tk}}===
<syntaxhighlight lang="perl">
use strict;
use warnings;
Line 850 ⟶ 886:
return ($mw->maxsize);
}
</syntaxhighlight>
get_size returns (1425,870) here.
Line 856 ⟶ 892:
{{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>
Line 872 ⟶ 908:
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<!--</
{{Out}}
<pre>
Line 881 ⟶ 917:
=={{header|PicoLisp}}==
The following works on ErsatzLisp, the Java version of PicoLisp.
<
(java Frame 'setExtendedState
(java (public "javax.swing.JFrame" 'MAXIMIZED_BOTH)) )
Line 889 ⟶ 925:
(prinl "Width: " (java (public Size 'width)))
(prinl "Height: " (java (public Size 'height))) )
(java Frame 'dispose) )</
Output (on a 1024x768 screen):
<pre>Width: 1010
Line 898 ⟶ 934:
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.
<syntaxhighlight lang="java">
//Aamrun, 26th June 2022
Line 906 ⟶ 942:
text("Screen Height : " + str(height), 100, 100);
text("Screen Width : " + str(width), 100, 200);
</syntaxhighlight>
=={{header|PureBasic}}==
<
maxX = WindowWidth(0)
maxY = WindowHeight(0)
CloseWindow(0)
MessageRequester("Result", "Maximum Window Width: " + Str(maxX) + ", Maximum Window Height: " + Str(maxY))
EndIf</
Sample output for a screen area 1600 x 1200:
<pre>Maximum Window Width: 1600, Maximum Window Height: 1181</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">
#!/usr/bin/env python3
Line 930 ⟶ 966:
font=("Helvetica", 25)).pack() # add a label and set the size to text.
root.mainloop()
</syntaxhighlight>
Sample output for 1366 x 768 screen:
<pre>1366 x 706</pre>
=={{header|Racket}}==
<
#lang racket/gui
(define-values [W H]
Line 942 ⟶ 978:
(send f show #f))))
(printf "~ax~a\n" W H)
</syntaxhighlight>
=={{header|Raku}}==
Line 949 ⟶ 985:
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.
<syntaxhighlight lang="raku"
my $xdo = Xdo.new;
Line 955 ⟶ 991:
my ($dw, $dh) = $xdo.get-desktop-dimensions( 0 );
say "Desktop viewport dimensions: (maximum-fullscreen size) $dw x $dh";</
{{out|On my system returns}}
<pre>Desktop viewport dimensions: (maximum-fullscreen size) 1920 x 1080</pre>
Line 970 ⟶ 1,006:
=={{header|Ring}}==
<
load "guilib.ring"
new qApp {
Line 982 ⟶ 1,018:
exec()
}
</syntaxhighlight>
Output:
Line 992 ⟶ 1,028:
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>"
Line 1,026 ⟶ 1,062:
var x = winSize();
//--></script>
"</
=={{header|Scala}}==
<
import javax.swing.JFrame
Line 1,048 ⟶ 1,084:
new MaxWindowDims
}
}</
=={{header|Sidef}}==
Using the Tk library:
<
func max_window_size() -> (Number, Number) {
Line 1,059 ⟶ 1,095:
var (width, height) = max_window_size();
say (width, 'x', height);</
{{out}}
Line 1,068 ⟶ 1,104:
=={{header|Tcl}}==
{{libheader|Tk}}
<
proc maxSize {} {
# Need a dummy window; max window can be changed by scripts
Line 1,078 ⟶ 1,114:
# 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].
Line 1,087 ⟶ 1,123:
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
Line 1,101 ⟶ 1,137:
syswindow.screenheight=Screen.Height / Screen.TwipsPerPixelY
' Make adjustments for window decorations and menubars</
=== Method 2 ===
Line 1,117 ⟶ 1,153:
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
Line 1,128 ⟶ 1,164:
Console.WriteLine($"Primary screen working area: {workingArea.Width}x{workingArea.Height}")
End Sub
End Module</
{{out}}
Line 1,136 ⟶ 1,172:
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
Line 1,150 ⟶ 1,186:
End Using
End Sub
End Module</
{{out}}
<pre>Size of maximized borderless form: 1714x1143</pre>
=={{header|V (Vlang)}}==
Graphical
<syntaxhighlight lang="Zig">
import ui
import gg
import gx
[heap]
struct App {
mut:
window &ui.Window = unsafe {nil}
}
fn main() {
mut app := &App{}
app.window = ui.window(
width: gg.screen_size().width
height: gg.screen_size().height
bg_color: gx.white
title: "Maximum Window"
mode: .resizable
layout: ui.row(
spacing: 5
margin_: 10
widths: ui.stretch
heights: ui.stretch
children: [
ui.label(
id: "info"
text: "Window dimensions: W ${gg.screen_size().width} x H ${gg.screen_size().height}"
),
]
)
)
ui.run(app.window)
}
</syntaxhighlight>
=={{header|Wren}}==
{{libheader|DOME}}
<
import "dome" for Window, Process
import "graphics" for Canvas, Color
Line 1,174 ⟶ 1,248:
static draw(alpha) {}
}</
{{out}}
Line 1,184 ⟶ 1,258:
=={{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}}
|