GUI/Maximum window dimensions: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(J) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(6 intermediate revisions by 6 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}}==
Line 570 ⟶ 584:
For example:
<
1348 750</
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 598 ⟶ 612:
System.out.println("Max available: " + screenSize);
}
}</
Output:
Line 608 ⟶ 622:
=={{header|Julia}}==
Uses the Gtk library.
<
win = GtkWindow("hello", 100, 100)
fullscreen(win)
Line 614 ⟶ 628:
println(width(win), " ", height(win))
destroy(win)
</syntaxhighlight>
{{output}} <pre>
1920 1080
Line 621 ⟶ 635:
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.awt.Toolkit
Line 644 ⟶ 658:
fun main(args: Array<String>) {
Test()
}</
Sample output:
{{out}}
Line 654 ⟶ 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 665 ⟶ 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 739 ⟶ 764:
}
CheckAllMonitors
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Example output on a 1280x1024 system.
<
->{{1260, 951}}</
=={{header|Nim}}==
Line 750 ⟶ 775:
{{libheader|Gtk2}}
Getting the screen size, ignoring borders, is as easy as:
<
gtk2, gdk2
Line 756 ⟶ 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 777 ⟶ 802:
discard g_timeout_add(100, printSize, addr(window[]))
main()</
{{out}}
<pre>W x H = 1920 x 1031</pre>
Line 784 ⟶ 809:
{{libheader|gintro}}
This is the translation of Gtk2 program to Gtk3 using “gintro” bindings.
<
var window: ApplicationWindow
Line 811 ⟶ 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 817 ⟶ 842:
===With IUP===
{{libheader|IUP}}
<
iup
Line 838 ⟶ 863:
#discard iup.mainloop()
iup.close()</
{{out}}
<pre>1280x800
Line 848 ⟶ 873:
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Perl}}==
==={{libheader|Perl/Tk}}===
<syntaxhighlight lang="perl">
use strict;
use warnings;
Line 861 ⟶ 886:
return ($mw->maxsize);
}
</syntaxhighlight>
get_size returns (1425,870) here.
Line 867 ⟶ 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 883 ⟶ 908:
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<!--</
{{Out}}
<pre>
Line 892 ⟶ 917:
=={{header|PicoLisp}}==
The following works on ErsatzLisp, the Java version of PicoLisp.
<
(java Frame 'setExtendedState
(java (public "javax.swing.JFrame" 'MAXIMIZED_BOTH)) )
Line 900 ⟶ 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 909 ⟶ 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.
<
//Aamrun, 26th June 2022
Line 917 ⟶ 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 941 ⟶ 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 953 ⟶ 978:
(send f show #f))))
(printf "~ax~a\n" W H)
</syntaxhighlight>
=={{header|Raku}}==
Line 960 ⟶ 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 966 ⟶ 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 981 ⟶ 1,006:
=={{header|Ring}}==
<
load "guilib.ring"
new qApp {
Line 993 ⟶ 1,018:
exec()
}
</syntaxhighlight>
Output:
Line 1,003 ⟶ 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,037 ⟶ 1,062:
var x = winSize();
//--></script>
"</
=={{header|Scala}}==
<
import javax.swing.JFrame
Line 1,059 ⟶ 1,084:
new MaxWindowDims
}
}</
=={{header|Sidef}}==
Using the Tk library:
<
func max_window_size() -> (Number, Number) {
Line 1,070 ⟶ 1,095:
var (width, height) = max_window_size();
say (width, 'x', height);</
{{out}}
Line 1,079 ⟶ 1,104:
=={{header|Tcl}}==
{{libheader|Tk}}
<
proc maxSize {} {
# Need a dummy window; max window can be changed by scripts
Line 1,089 ⟶ 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,098 ⟶ 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,112 ⟶ 1,137:
syswindow.screenheight=Screen.Height / Screen.TwipsPerPixelY
' Make adjustments for window decorations and menubars</
=== Method 2 ===
Line 1,128 ⟶ 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,139 ⟶ 1,164:
Console.WriteLine($"Primary screen working area: {workingArea.Width}x{workingArea.Height}")
End Sub
End Module</
{{out}}
Line 1,147 ⟶ 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,161 ⟶ 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,185 ⟶ 1,248:
static draw(alpha) {}
}</
{{out}}
Line 1,195 ⟶ 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}}
|