Video display modes: Difference between revisions
m
→{{header|Wren}}: Removed a blank line
Puppydrum64 (talk | contribs) |
m (→{{header|Wren}}: Removed a blank line) |
||
| (17 intermediate revisions by 6 users not shown) | |||
Line 4:
===Apple II===
* Change to 80-column display:
<
JSR $FE95</
* Change to 40-column display:
<
JSR $FE95</
For the following, the value stored to these memory locations does not matter. It is the mere act of writing to them that causes the Apple II to change modes. You can read from them as well to do the same, but there's really no reason to do so, as both <code>LDA $????</code> and <code>STA $????</code> both take 4 clock cycles, and you've only got 3 registers you can use so there's no sense in wiping the accumulator with a garbage value that has no actual meaning.
{{trans|Applesoft BASIC}}
*
*
* <code>STA $C052</code>:Change to full screen (whatever mode you're "in" takes up the whole screen)
* <code>STA $C053</code>:Change to mixed screen (graphics mode is the majority of the screen, but there's 4 rows of text on the bottom)
* <code>STA $C054</code>:Display page 1 of video memory
* <code>STA $C055</code>:Display page 2 of video memory
* <code>STA $C056</code>:Change graphics mode to low-resolution (16-color) mode
* <code>STA $C057</code>:Change graphics mode to hi-resolution (6-color) mode
===Nintendo Entertainment System===
[https://nesdev-wiki.nes.science/wikipages/PPU_registers.xhtml NES Picture Processing Unit Registers]
=={{header|8086 Assembly}}==
{{works with|MS-DOS}}
<
mov al,videoMode
int 10h</
There are quite a few valid values for <code>videoMode</code>, here are a few of them:
Line 40 ⟶ 47:
=={{header|Action!}}==
<
CARD w, BYTE h,
CARD size,
Line 111 ⟶ 118:
ShowMode(30,0,1,160,192,3840,"2 colors")
ShowMode(31,0,1,160,192,7680,"4 colors")
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Video_display_modes.png Screenshot from Atari 8-bit computer]
Line 117 ⟶ 124:
=={{header|AmigaBASIC}}==
<
This command creates a new screen #1 (4 max) with 320x200 pixels and 5 bits per pixel (for a total of 2⁵=32 colors). The final parameter, 1, sets the monitor to 320x200 (NTSC Amiga) or 320x256 (PAL Amiga) non-interlaced mode. If set to 2, it would use 640*200/640*256, while 3 and 4 would result in corresponding interlaced modes with twice the vertical resolution.
The screen can be closed again with
<syntaxhighlight lang
=={{header|Applesoft BASIC}}==
Line 136 ⟶ 143:
hgr, page 2, 280 x 160, 6 colors, mixed with four lines of text
<syntaxhighlight lang="applesoftbasic">10 GR
20 FOR I = 0 TO 15 : COLOR = I : PLOT I,I : NEXT
30 HGR
Line 155 ⟶ 162:
180 IF A$ = "G" THEN POKE -16304,0 : REM GRAPHICS
190 IF A$ <> "Q" THEN 100
200 TEXT</
=={{header|ARM Assembly}}==
Line 164 ⟶ 171:
For example, to set the screen to Mode 3 with Background 2 visible:
<syntaxhighlight lang="arm assembly">
MOV R1,#0x04000000
MOV R0,#0x403
STR r0,[r1] ;the game boy advance is little-endian, so I would have expected this not to work. However it does indeed work.
</syntaxhighlight>
=={{header|BBC BASIC}}==
<
=={{header|Commodore BASIC}}==
Line 264 ⟶ 271:
====Program Listing====
<
15 rem rosetta code
20 print chr$(147);chr$(14):poke 53280,0:poke 53281,0:poke 646,1
Line 368 ⟶ 375:
9000 print "Press any key for next screen.";
9010 get k$:if k$="" then 9010
9020 return</
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Delphi is primarily a language used under advanced operating systems such as Windows, Linux and iOS. Under Windows, the video resolution and color depth is controlled by Windows, the monitor, the video card and the choices of the user. These days, color is almost always set to 32-bit pixels with 8-bits for Red, Green and Blue, plus an alpha channel for transparency. Most people run their displays at 1080P resolution or higher. So under Windows, you typically have the highest possible resolution. Given these resolutions and the size of monitors these days, there is so much graphics real estate on the average display, that most programs only need to use a portion of the screen to display all their information.
Under these circumstances, the only way you could change the screen resolution or color depth would be to change it downward. The only reason you'd ever want lower resolution displays is if you were simulating the pixelated, low quality graphics of old computers. And, if you really want to display a low graphics, it is pretty easy to simulate it with high resolution graphics.
Delphi supports working in the world of high resolution displays by allowing you to easily create windows that are sizable by the programmer or the user. It supports putting text in a window with components like the "TMemo" object. Likewise, you can draw or put images into a window with the "TImage" component.
As an example of how this works, here is some code that would wrote text into a text window:
<syntaxhighlight lang="Delphi">
begin
Memo.Line.Add('Hello World');
end;
</syntaxhighlight>
Here's an example of drawing lines in a graphics window;
<syntaxhighlight lang="Delphi">
begin
Image.Canvas.MoveTo(0,0);
Image.Canvas.LineTo(100,100);
end;
</syntaxhighlight>
{{out}}
[[File:DelphiMemoWindow.png|frame|none]]
[[File:DelphiImageWindow.png|frame|none]]
<pre>
</pre>
=={{header|ERRE}}==
Line 384 ⟶ 428:
=={{header|FreeBASIC}}==
<
for i = 0 to 21
Line 405 ⟶ 449:
'see https://documentation.help/FreeBASIC/KeyPgScreengraphics.html
'for more information
</syntaxhighlight>
=={{header|Go}}==
{{trans|UNIX Shell}}
{{works with|Ubuntu 16.04}}
<
import (
Line 440 ⟶ 484:
log.Fatal(err)
}
}</
{{out}}
Line 468 ⟶ 512:
{{trans|Kotlin}}
{{works with|Ubuntu 14.04}}
<
invoke("xrandr -q")
Line 476 ⟶ 520:
Thread.sleep(3000)
invoke("xrandr -s 1366x768")</
{{out}}
Line 498 ⟶ 542:
GWBASIC version used: 3.23'''
<
20 SCREEN 18: REM Mode 12h 640x480 16 colour graphics</
=={{header|Icon}} and {{header|Unicon}}==
Line 507 ⟶ 551:
{{trans|UNIX Shell}}
<
mode := A[1]
if \mode then system("xrandr -s " || \mode || " >/dev/null")
else system("xrandr -q") # Display available modes
end</
Output with no arguments:
Line 539 ⟶ 583:
640x480 75.0 59.9
->
</pre>
=={{header|J}}==
{{omit from|J}} This isn't a J issue, it's an OS issue. Thus, for example, we could use <code>2!:0'xrandr -s 640x480'</code> on an operating system where that provides meaningful behavior. And, we could use <code>shell'mode CON: COLS=40 LINES=100'[require'task'</code> on an operating system where that provides meaningful behavior (and <tt>2!:0</tt> does not work on windows -- on linux this <tt>shell</tt> command is equivalent to <tt>2!:0</tt>). But these won't work in the general case of an arbitrary operating system and arbitrary video hardware, and it's probably best handle such tasks before starting J.
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.awt.Color;
import java.awt.DisplayMode;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.util.concurrent.TimeUnit;
import javax.swing.JFrame;
import javax.swing.JLabel;
public final class VideoDisplay {
public static void main(String[] aArgs) throws InterruptedException {
GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] screens = environment.getScreenDevices();
System.out.println("Number of video screens: " + screens.length + System.lineSeparator());
for ( GraphicsDevice screen : screens ) {
System.out.println("Full screen display is supported: "
+ screen.isFullScreenSupported() + System.lineSeparator());
GraphicsConfiguration[] configurations = screen.getConfigurations();
System.out.println("This screen has number of configurations: " + configurations.length);
for ( GraphicsConfiguration config : configurations ) {
System.out.println("Configuration supports translucency: " + config.isTranslucencyCapable());
}
DisplayMode[] modes = screen.getDisplayModes();
System.out.println(System.lineSeparator() + "This screen has " + modes.length + " modes of operation");
for ( DisplayMode mode : modes ) {
System.out.println(mode.getWidth() + " X " + mode.getHeight()
+ " with refresh rate " + mode.getRefreshRate() + " Hz");
}
}
// Uncomment the line below to see an example of programmatically changing the video display.
// new VideoDisplay();
}
private VideoDisplay() throws InterruptedException {
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Video Display Demonstration");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setBackground(Color.LIGHT_GRAY);
frame.add( new JLabel(MESSAGE) );
frame.setSize(800, 600);
GraphicsDevice screen = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
DisplayMode originalDisplayMode = screen.getDisplayMode();
screen.setFullScreenWindow(frame);
screen.setDisplayMode( new DisplayMode(800, 600, 32, 60) );
frame.setVisible(true);
TimeUnit.SECONDS.sleep(3);
screen.setDisplayMode(originalDisplayMode);
TimeUnit.SECONDS.sleep(3);
Runtime.getRuntime().exit(0);
}
private static final String MESSAGE = "Please wait for a few seconds."
+ " Your video display will then be returned to its original setting.";
}
</syntaxhighlight>
{{ out }}
<pre>
Number of video screens: 1
Full screen display is supported: true
This screen has number of configurations: 1
Configuration supports translucency: true
This screen has 11 modes of operation
640 X 480 with refresh rate 60 Hz
800 X 600 with refresh rate 60 Hz
1024 X 768 with refresh rate 60 Hz
1128 X 634 with refresh rate 60 Hz
1280 X 720 with refresh rate 60 Hz
1280 X 1024 with refresh rate 60 Hz
1366 X 768 with refresh rate 60 Hz
1600 X 900 with refresh rate 60 Hz
1680 X 1050 with refresh rate 60 Hz
1760 X 990 with refresh rate 60 Hz
1920 X 1080 with refresh rate 60 Hz
</pre>
=={{header|Julia}}==
{{trans|Phix}}
<
if Base.Sys.islinux()
run(`xrandr -s 640x480`)
Line 553 ⟶ 696:
run(`mode CON: COLS=100 LINES=50`)
end
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|UNIX Shell}}
{{works with|Ubuntu 14.04}}
<
import java.util.Scanner
Line 582 ⟶ 725:
// change it back again to 1366x768 (or whatever is optimal for your system)
runSystemCommand("xrandr -s 1366x768")
}</
{{out}}
Line 607 ⟶ 750:
* Mode 2 - Graphics: 640x200 Text: 80x25 Colours: 2
Note that text can be displayed using conventional means in all display modes.
<
=={{header|Lua}}==
Certain terminals may support the following..
<
print("\33[?3l") -- 80-column text</
=={{header|Nim}}==
{{works with|Linux}}
Using the command "xrandr" on Linux systems.
<
# Retrieve video modes.
Line 647 ⟶ 790:
echo "\nSwitching back to ", prevMode
sleep 2000
discard execProcess("xrandr", "", ["-s", prevMode], nil, {poUsePath})</
{{out}}
Line 681 ⟶ 824:
Same caveats as with Raku.
{{trans|Raku}}
<
my @info = `xrandr -q`;
Line 699 ⟶ 842:
}
system("xrandr -s $current");
print "\rResolution returned to $current.\n";</
=={{header|Phix}}==
<!--<
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (system, system_exec, sleep)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">LINUX</span> <span style="color: #008080;">then</span>
Line 714 ⟶ 857:
<span style="color: #7060A8;">system</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"mode CON: COLS=80 LINES=25"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</
Obviously running xrandr -q or mode -? will tell you more.
Line 722 ⟶ 865:
{{libheader|win32pywintypes}}
This program changes the resolution the screen is running at to 640x480.
<
import win32con
import pywintypes
Line 729 ⟶ 872:
devmode.PelsHeight=480
devmode.Fields=win32con.DM_PELSWIDTH | win32con.DM_PELSHEIGHT
win32api.ChangeDisplaySettings(devmode,0)</
=={{header|QBasic}}==
'''This example is wrong! QBASIC can use EGA/VGA Graphics until SCREEN 13 (320x200 - 256 colors) or SCREEN 12 (640x480 - 16 colors).QBASIC version used: 1.1'''
<
SCREEN 18 'Mode 12h 640x480 16 colour graphics</
=={{header|Raku}}==
Line 744 ⟶ 887:
{{works with|Rakudo|2018.05}}
<syntaxhighlight lang="raku"
@info[0] ~~ /<?after 'current '>(\d+) ' x ' (\d+)/;
Line 759 ⟶ 902:
}
QX("xrandr -s $current");
say "\rResolution returned to {$current}. ";</
=={{header|REXX}}==
Line 769 ⟶ 912:
===version 1: no checking for which OS===
<
parse arg cols lines .
'MODE' "CON: COLS="cols 'LINES='lines
/*stick a fork in it, we're done.*/</
===version 2: checks for which OS===
The prologue code (at the bottom of the program) is a collection of some general-purpose subroutines which determine:
Line 789 ⟶ 932:
All the prologue was left intact to give a general feel of the scope of the boilerplate code.
The prologue code is in many REXX programs and it's easier to keep them on one line for copying purposes and sorting.
<
parse arg !; if !all() then exit /*exit if documentation specified*/
if \!dos & \!os2 then exit /*if this isn't DOS, then exit. */
Line 804 ⟶ 947:
!rex:parse upper version !ver !vernum !verdate .;!brexx='BY'==!vernum;!kexx='KEXX'==!ver;!pcrexx='REXX/PERSONAL'==!ver|'REXX/PC'==!ver;!r4='REXX-R4'==!ver;!regina='REXX-REGINA'==left(!ver,11);!roo='REXX-ROO'==!ver;call !env;return
!sys:!cms=!sys=='CMS';!os2=!sys=='OS2';!tso=!sys=='TSO'|!sys=='MVS';!vse=!sys=='VSE';!dos=pos('DOS',!sys)\==0|pos('WIN',!sys)\==0|!sys=='CMD';call !rex;return
!var:call !fid;if !kexx then return space(dosenv(arg(1)));return space(value(arg(1),,!env))</
=={{header|Ring}}==
<
system("mode 40, 25")
</syntaxhighlight>
=={{header|Scala}}==
{{trans|UNIX Shell}}
{{works with|Ubuntu 14.04}}
<
import java.util.Scanner
Line 840 ⟶ 983:
runSystemCommand("xrandr -s 1366x768")
}</
=={{header|smart BASIC}}==
Line 851 ⟶ 994:
'''EXAMPLE:'''
<
FILL RECT 50,50 SIZE 50
GRAPHICS MODE CLEAR
FILL RECT 50,50 SIZE 25</
=={{header|UNIX Shell}}==
If the system runs X11 and supports XRANDR, then
<syntaxhighlight lang
lists the available modes, and
<syntaxhighlight lang
sets the screen to the given size.
Line 867 ⟶ 1,010:
=={{header|Wren}}==
The ability to call external processes such as ''xrandr'' is expected to be added to Wren-cli in the next release. In the meantime, we embed the following Wren script in a minimal C host (no error checking) to complete this task.
<
class C {
Line 888 ⟶ 1,031:
// change it back again to 1920x1080
System.print("\nReverting to 1920 x 1080 mode.")
C.xrandr("-s 1920x1080")</
<br>
We now embed this in the following C program, compile and run it.
<syntaxhighlight lang="c">/* gcc Video_display_modes.c -o Video_display_modes -lwren -lm */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 948 ⟶ 1,093:
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "
char *script = readFile(fileName);
wrenInterpret(vm, module, script);
Line 954 ⟶ 1,099:
free(script);
return 0;
}</
{{out}}
Line 1,016 ⟶ 1,161:
=={{header|XPL0}}==
<
SetVid(Mode)</
Any display mode supported by the IBM-PC-compatible hardware and by the VGA or VESA standards can be enabled by calling the SetVid intrinsic routine. This works without problem on computers booted into DOS and under versions of Windows up until XP. DOSBox[http://www.dosbox.com/] gets around most of the incompatibilities introduced by WinXP and later versions.
| |||