Colour bars/Display: Difference between revisions
No edit summary |
→{{header|AmigaBASIC}}: add screenshot |
||
(139 intermediate revisions by 60 users not shown) | |||
Line 1: | Line 1: | ||
{{task}} |
{{task}} |
||
The task is to display a series of vertical color bars across the width of the display. The color bars should either use the system palette, or the sequence of colors: Black, Red, Green, Blue, Magenta, Cyan, Yellow, White. |
|||
;Task: |
|||
Display a series of vertical color bars across the width of the display. |
|||
The color bars should either use: |
|||
:::* the system palette, or |
|||
:::* the sequence of colors: |
|||
::::::* black |
|||
::::::* red |
|||
::::::* green |
|||
::::::* blue |
|||
::::::* magenta |
|||
::::::* cyan |
|||
::::::* yellow |
|||
::::::* white |
|||
<br> |
|||
=={{header|6502 Assembly}}== |
|||
Implemented using Easy6502, this displays a pinstripe using the system palette. There are 16 colors, and the bottom 4 bits of A are the color index. |
|||
<syntaxhighlight lang="6502asm">lda #0 |
|||
tax |
|||
tay ;clear regs |
|||
;video ram on Easy6502 is four pages ranging from $0200-$0500 |
|||
loop: |
|||
sta $0200,x |
|||
sta $0220,x |
|||
sta $0240,x |
|||
sta $0260,x |
|||
sta $0280,x |
|||
sta $02A0,x |
|||
sta $02C0,x |
|||
sta $02E0,x |
|||
sta $0300,x |
|||
sta $0320,x |
|||
sta $0340,x |
|||
sta $0360,x |
|||
sta $0380,x |
|||
sta $03A0,x |
|||
sta $03C0,x |
|||
sta $03E0,x |
|||
sta $0400,x |
|||
sta $0420,x |
|||
sta $0440,x |
|||
sta $0460,x |
|||
sta $0480,x |
|||
sta $04A0,x |
|||
sta $04C0,x |
|||
sta $04E0,x |
|||
sta $0500,x |
|||
sta $0520,x |
|||
sta $0540,x |
|||
sta $0560,x |
|||
sta $0580,x |
|||
sta $05A0,x |
|||
sta $05C0,x |
|||
sta $05E0,x |
|||
inx |
|||
txa ;effectively increment A |
|||
cpx #$20 ;32 columns of video memory |
|||
beq exit |
|||
jmp loop |
|||
exit: |
|||
brk ;on easy6502 this terminates a program. </syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">PROC Main() |
|||
BYTE |
|||
i, |
|||
CH=$02FC, ;Internal hardware value for last key pressed |
|||
PALNTSC=$D014, ;To check if PAL or NTSC system is used |
|||
PCOLR0=$02C0,PCOLR1=$02C1, |
|||
PCOLR2=$02C2,PCOLR3=$02C3, |
|||
COLOR0=$02C4,COLOR1=$02C5, |
|||
COLOR2=$02C6,COLOR3=$02C7, |
|||
COLOR4=$02C8 |
|||
Graphics(10) |
|||
PCOLR0=$04 ;gray |
|||
PCOLR1=$00 ;black |
|||
IF PALNTSC=15 THEN |
|||
PCOLR2=$42 ;red for NTSC |
|||
PCOLR3=$C6 ;green for NTSC |
|||
COLOR0=$84 ;blue for NTSC |
|||
COLOR1=$66 ;magenta for NTSC |
|||
COLOR2=$A6 ;cyan for NTSC |
|||
COLOR3=$FC ;yellow for NTSC |
|||
ELSE |
|||
PCOLR2=$22 ;red for PAL |
|||
PCOLR3=$B6 ;green for PAL |
|||
COLOR0=$74 ;blue for PAL |
|||
COLOR1=$48 ;magenta for PAL |
|||
COLOR2=$96 ;cyan for PAL |
|||
COLOR3=$EC ;yellow for PAL |
|||
FI |
|||
COLOR4=$0F ;white |
|||
FOR i=0 TO 79 |
|||
DO |
|||
Color=i/10+1 |
|||
Plot(i,0) |
|||
DrawTo(i,191) |
|||
OD |
|||
DO UNTIL CH#$FF OD |
|||
CH=$FF |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Colour_bars_display.png Screenshot from Atari 8-bit computer] |
|||
=={{header|ActionScript}}== |
|||
<syntaxhighlight lang="actionscript3"> |
|||
package { |
|||
import flash.display.Sprite; |
|||
import flash.events.Event; |
|||
public class ColourBars extends Sprite { |
|||
public function ColourBars():void { |
|||
if (stage) init(); |
|||
else addEventListener(Event.ADDED_TO_STAGE, init); |
|||
} |
|||
private function init(e:Event = null):void { |
|||
var colours:Array = [ 0x000000, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFF00, 0xFFFFFF ]; |
|||
var w:Number = stage.stageWidth / 8, h:Number = stage.stageHeight; |
|||
var x:Number = 0, i:uint, c:uint; |
|||
for ( i = 0; i < 8; i++ ) { |
|||
c = colours[i]; |
|||
graphics.beginFill(c); |
|||
graphics.drawRect(w * i, 0, w, h); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Ada}}== |
|||
{{libheader|SDLAda}} |
|||
<syntaxhighlight lang="ada">with SDL.Video.Windows.Makers; |
|||
with SDL.Video.Renderers.Makers; |
|||
with SDL.Video.Palettes; |
|||
with SDL.Events.Events; |
|||
with SDL.Events.Keyboards; |
|||
procedure Colour_Bars_Display is |
|||
use type SDL.Events.Event_Types; |
|||
use SDL.C; |
|||
Colours : constant array (0 .. 7) of SDL.Video.Palettes.Colour := |
|||
((0, 0, 0, 255), (255, 0, 0, 255), |
|||
(0, 255, 0, 255), (0, 0, 255, 255), |
|||
(255, 0, 255, 255), (0, 255, 255, 255), |
|||
(255, 255, 0, 255), (255, 255, 255, 255)); |
|||
Window : SDL.Video.Windows.Window; |
|||
Renderer : SDL.Video.Renderers.Renderer; |
|||
Event : SDL.Events.Events.Events; |
|||
Bar_Width : int; |
|||
begin |
|||
if not SDL.Initialise (Flags => SDL.Enable_Screen) then |
|||
return; |
|||
end if; |
|||
SDL.Video.Windows.Makers.Create (Win => Window, |
|||
Title => "", |
|||
Position => SDL.Natural_Coordinates'(0, 0), |
|||
Size => SDL.Positive_Sizes'(0, 0), |
|||
Flags => SDL.Video.Windows.Full_Screen_Desktop); |
|||
SDL.Video.Renderers.Makers.Create (Renderer, Window.Get_Surface); |
|||
Bar_Width := Window.Get_Size.Width / 8; |
|||
for A in Colours'Range loop |
|||
Renderer.Set_Draw_Colour (Colour => Colours (A)); |
|||
Renderer.Fill (Rectangle => (X => SDL.C.int (A) * Bar_Width, Y => 0, |
|||
Width => Bar_Width, |
|||
Height => Window.Get_Size.Height)); |
|||
end loop; |
|||
Window.Update_Surface; |
|||
Wait_Loop : loop |
|||
while SDL.Events.Events.Poll (Event) loop |
|||
exit Wait_Loop when Event.Common.Event_Type = SDL.Events.Keyboards.Key_Down; |
|||
end loop; |
|||
delay 0.050; |
|||
end loop Wait_Loop; |
|||
Window.Finalize; |
|||
SDL.Finalise; |
|||
end Colour_Bars_Display;</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
{{libheader|GDI+}} (available at http://www.autohotkey.net/~tic/Gdip.ahk) |
{{libheader|GDI+}} (available at http://www.autohotkey.net/~tic/Gdip.ahk) |
||
< |
<syntaxhighlight lang="autohotkey">#SingleInstance, Force |
||
#NoEnv |
#NoEnv |
||
SetBatchLines, -1 |
SetBatchLines, -1 |
||
Line 96: | Line 296: | ||
Gdip_Shutdown(pToken) |
Gdip_Shutdown(pToken) |
||
ExitApp |
ExitApp |
||
Return</ |
Return</syntaxhighlight> |
||
=={{header| |
=={{header|AWK}}== |
||
<syntaxhighlight lang="awk"> |
|||
BEGIN { |
|||
nrcolors = 8 |
|||
for (height=0; height<20; height++) { |
|||
for (width=0; width<nrcolors; width++) { |
|||
# print (ANSI) basic color and amount of spaces |
|||
printf("\033[%dm%*s", width + 40, 64 / nrcolors, " ") |
|||
} |
|||
# reset color and print newline |
|||
printf("\033[0m\n") |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|BASIC}}== |
|||
==={{header|AmigaBASIC}}=== |
|||
[[File:Amigabasic color bars.png|thumb|Output]] |
|||
<syntaxhighlight lang="amigabasic">SCREEN 1,320,200,5,1 |
|||
WINDOW 2,"Color bars",(0,10)-(297,186),15,1 |
|||
FOR a=0 TO 300 |
|||
LINE (a,0)-(a,186),(a+10)/10 |
|||
NEXT |
|||
loop: GOTO loop</syntaxhighlight> |
|||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight lang="applesoftbasic">1 DATA1,12,6,3,14,13,15 |
|||
2 HOME : GR : FOR I = 1 TO 7 |
|||
3 READ C(I) : NEXT |
|||
4 FOR I = 0 TO 39 |
|||
5 COLOR= C(I / 5) |
|||
6 VLIN 0,39 AT I : NEXT</syntaxhighlight> |
|||
==={{header|BBC BASIC}}=== |
|||
{{works with|BBC BASIC for Windows}} |
{{works with|BBC BASIC for Windows}} |
||
< |
<syntaxhighlight lang="bbcbasic"> SW_MAXIMIZE = 3 |
||
SYS "ShowWindow", @hwnd%, SW_MAXIMIZE |
SYS "ShowWindow", @hwnd%, SW_MAXIMIZE |
||
VDU 26 |
VDU 26 |
||
Line 119: | Line 354: | ||
RECTANGLE FILL C%*W%, 0, W%, H% |
RECTANGLE FILL C%*W%, 0, W%, H% |
||
NEXT |
NEXT |
||
</syntaxhighlight> |
|||
</lang> |
|||
==={{header|Chipmunk Basic}}=== |
|||
The sequence of colors. |
|||
<syntaxhighlight lang="basic"> |
|||
100 rem Colour bars/Display |
|||
110 graphics 0 : graphics cls |
|||
120 for i = 0 to 7 |
|||
130 read r,g,b |
|||
140 graphics color r,g,b |
|||
150 for j = 0 to 79 |
|||
160 x = i*80+j |
|||
170 graphics moveto x,0 |
|||
180 graphics lineto x,399 |
|||
190 next j |
|||
200 next i |
|||
500 data 0,0,0 : rem black |
|||
510 data 100,0,0 : rem red |
|||
520 data 0,100,0 : rem green |
|||
530 data 0,0,100 : rem blue |
|||
540 data 100,0,100 : rem magenta |
|||
550 data 0,100,100 : rem cyan |
|||
560 data 100,100,0 : rem yellow |
|||
570 data 100,100,100 : rem white |
|||
</syntaxhighlight> |
|||
==={{header|Commodore BASIC}}=== |
|||
This task achieved only on Commodore computers with color capabilities. The example below tested as-is in VICE on the following machines: |
|||
* Commodore 64 |
|||
* Commodore 128 |
|||
* Commodore Plus 4 |
|||
* Commodore CBM-II (with VIC-II video) |
|||
* Commodore SX-64 |
|||
It will also work well on the VIC-20 if you either omit line 310 or comment (REM) it out as the VIC-20 has only an eight-color palette. |
|||
This cross-compatibility is achieved by using the PETSCII control codes (CHR$(x)) for changing color, which are generally the same across all platforms, although the system palettes themselves may differ. This is combined with printing a "reverse video" space (solid block) character in the color selected. |
|||
<syntaxhighlight lang="gwbasic">5 rem color bars program |
|||
10 print chr$(147);:dim co(17):c=1 |
|||
20 read co(c):if co(c)>0 then c=c+1:goto 20 |
|||
25 sp$=" ":h=22:c=c-1:rem sp$=5 spaces |
|||
30 for r=1 to c step int(c/2) |
|||
40 for h=1 to 10 |
|||
50 for b=r to (r+int(c/2))-1 |
|||
60 print chr$(18);chr$(co(b));sp$; |
|||
70 next b |
|||
75 rem check if palette is only 8 (vic-20). |
|||
76 rem if so, we need to fill the last two spaces. |
|||
80 if c<=8 then print " "; |
|||
90 next h:next r |
|||
100 get k$:if k$="" then 100 |
|||
110 end |
|||
280 rem because the control codes for color are non-sequential, |
|||
285 rem we put them into a sequential array for use |
|||
300 data 144,5,28,159,156,30,31,158 |
|||
305 rem omit or rem the next line for vic-20 |
|||
310 data 129,149,150,151,152,153,154,155 |
|||
320 data 0:rem data terminato</syntaxhighlight> |
|||
==={{header|FreeBASIC}}=== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
' Draw the color bars on an 80 x 25 console using the system palette of 16 colors |
|||
' i.e. 5 columns per color |
|||
Width 80, 25 |
|||
Shell "cls" |
|||
Locate ,, 0 '' turn cursor off |
|||
For clr As UInteger = 0 To 15 |
|||
Color 0, clr |
|||
For row As Integer = 1 to 25 |
|||
Locate row, clr * 5 + 1 |
|||
Print Space(5); |
|||
Next row |
|||
Next clr |
|||
Sleep |
|||
' restore default settings |
|||
Locate ,, 1 '' turn cursor on |
|||
Color 7, 0 '' white text on black background</syntaxhighlight> |
|||
==={{header|FutureBasic}}=== |
|||
[[File:ColorBarsDisplayFB300.png|right]] |
|||
<syntaxhighlight lang="futurebasic"> |
|||
void local fn DoIt |
|||
long index, x = 0 |
|||
CFArrayRef colors = @[fn ColorBlack,fn ColorRed, |
|||
fn ColorGreen,fn ColorBlue,fn ColorMagenta, |
|||
fn ColorCyan,fn ColorYellow,fn ColorWhite] |
|||
window 1, @"Color bars/Display", (0,0,480,270), NSWindowStyleMaskTitled |
|||
pen -1 |
|||
for index = 0 to len(colors) - 1 |
|||
rect fill (x,0,60,270), colors[index] |
|||
x += 60 |
|||
next |
|||
end fn |
|||
fn DoIt |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
==={{header|Gambas}}=== |
|||
<syntaxhighlight lang="gambas">Public Sub Form_Open() |
|||
Dim iColour As Integer[] = [Color.Black, Color.red, Color.Green, Color.Magenta, Color.Cyan, Color.Yellow, Color.white] |
|||
Dim hPanel As Panel |
|||
Dim siCount As Short |
|||
With Me |
|||
.Arrangement = Arrange.Horizontal |
|||
.Height = 300 |
|||
.Width = 400 |
|||
End With |
|||
For siCount = 0 To 6 |
|||
hpanel = New Panel(Me) |
|||
hpanel.Expand = True |
|||
hpanel.H = 500 |
|||
HPanel.Background = iColour[siCount] |
|||
Next |
|||
End</syntaxhighlight> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 GRAPHICS LORES 16 |
|||
110 SET PALETTE BLACK,RED,GREEN,BLUE,MAGENTA,CYAN,YELLOW,WHITE |
|||
120 FOR I=1 TO 7 |
|||
130 CALL BAR(I) |
|||
140 NEXT |
|||
150 DEF BAR(C) |
|||
160 SET INK C |
|||
170 PLOT C*160,0;C*160,719;C*160+152,719;C*160+152,0;C*160,0 |
|||
180 PLOT C*160+16,16,PAINT |
|||
190 END DEF</syntaxhighlight> |
|||
==={{header|Liberty BASIC}}=== |
|||
<syntaxhighlight lang="lb">nomainwin |
|||
colors$="black red green blue pink cyan yellow white" |
|||
WindowWidth=DisplayWidth:WindowHeight=DisplayHeight |
|||
UpperLeftX=1:UpperLeftY=1 |
|||
barWidth=DisplayWidth/8 |
|||
graphicbox #main.g, 0,0,DisplayWidth,DisplayHeight |
|||
open "" for window_popup as #main |
|||
#main "trapclose [quit]" |
|||
#main.g "down; setfocus; when characterInput [quit]" |
|||
#main.g "when leftButtonUp [quit]" |
|||
#main.g "size ";barWidth |
|||
for x = barWidth/2 to DisplayWidth step barWidth |
|||
i=i+1 |
|||
if i>8 then i=1 |
|||
col$=word$(colors$,i) |
|||
#main.g "color ";col$;"; line ";x;" 0 ";x;" ";DisplayHeight |
|||
next |
|||
wait |
|||
[quit] close #main:end |
|||
</syntaxhighlight> |
|||
==={{header|Locomotive Basic}}=== |
|||
[[File:CPC color bars.png|thumb|right]] |
|||
Show the default MODE 0 palette (includes two blinking colors at the end): |
|||
<syntaxhighlight lang="locobasic">10 MODE 0:BORDER 23 |
|||
20 FOR x=0 TO 15 |
|||
30 ORIGIN x*40,0 |
|||
40 FOR z=0 TO 39 STEP 4:MOVE z,0:DRAW z,400,x:NEXT z |
|||
50 NEXT x |
|||
60 CALL &bb06 ' wait for key press</syntaxhighlight> |
|||
==={{header|PureBasic}}=== |
|||
Press Enter or Escape to exit the program. |
|||
<syntaxhighlight lang="purebasic">Dim color(7) |
|||
color(0) = RGB($00, $00, $00) ;black |
|||
color(1) = RGB($FF, $00, $00) ;red |
|||
color(2) = RGB($00, $FF, $00) ;green |
|||
color(3) = RGB($00, $00, $FF) ;blue |
|||
color(4) = RGB($FF, $00, $FF) ;magenta |
|||
color(5) = RGB($00, $FF, $FF) ;cyan |
|||
color(6) = RGB($FF, $FF, $00) ;yellow |
|||
color(7) = RGB($FF, $FF, $FF) ;white |
|||
If Not InitKeyboard(): End: EndIf ;can't init keyboard |
|||
If Not InitSprite(): End: EndIf ;can't init sprite/screen library |
|||
If Not ExamineDesktops(): End: EndIf ;can't retrieve information about desktop |
|||
height = DesktopHeight(0) |
|||
width = DesktopWidth(0) |
|||
depth = DesktopDepth(0) |
|||
If OpenScreen(width, height, depth, "Press ENTER to exit") |
|||
StartDrawing(ScreenOutput()) |
|||
For c = 0 To 7 |
|||
Box((width * c) / 8, 0, width / 8, height, color(c)) |
|||
Next |
|||
StopDrawing() |
|||
FlipBuffers() |
|||
Repeat |
|||
Delay(10) |
|||
ExamineKeyboard() |
|||
Until KeyboardPushed(#PB_Key_Escape) Or KeyboardPushed(#PB_Key_Return) |
|||
CloseScreen() |
|||
EndIf</syntaxhighlight> |
|||
====Alternate method using console==== |
|||
<syntaxhighlight lang="purebasic">DataSection |
|||
;Black, Red, Green, Blue, Magenta, Cyan, Yellow, White |
|||
Data.i 0, 12, 10, 9, 13, 11, 14, 15 |
|||
EndDataSection |
|||
Dim colors(7) |
|||
For c = 0 To 7 |
|||
Read.i colors(c) |
|||
Next |
|||
If OpenConsole() |
|||
;The console display is 80 columns wide by 25 rows |
|||
For r = 0 To 24 |
|||
For c = 0 To 7 |
|||
ConsoleColor(colors(c), colors(c)) |
|||
Print(Space(80 / 8)) |
|||
Next |
|||
Next |
|||
EnableGraphicalConsole(1) |
|||
ConsoleLocate(0, 0) |
|||
ConsoleTitle("Press ENTER to exit"): Input() |
|||
CloseConsole() |
|||
EndIf</syntaxhighlight> |
|||
==={{header|Run BASIC}}=== |
|||
<syntaxhighlight lang="runbasic">colors$ = "black,red,green,blue,magenta,cyan,yellow,white" |
|||
html "<TABLE BORDER=1 CELLPADDING=0 CELLSPACING=4><tr height=70>" |
|||
for i = 1 to 8 |
|||
html "<td width=20 bgcolor='";word$(colors$,i,",");"'</td>" |
|||
next i |
|||
html "</tr></table>"</syntaxhighlight> |
|||
<pre>Output</pre> |
|||
[[File:ColorBarRunBasic.png]] |
|||
==={{header|SmileBASIC}}=== |
|||
<syntaxhighlight lang="smilebasic">FOR I=0 TO 7 |
|||
READ R,G,B |
|||
GFILL I*50,0,I*50+49,239,RGB(R,G,B) |
|||
NEXT |
|||
REPEAT UNTIL BUTTON(0) AND #B |
|||
DATA 0,0,0 |
|||
DATA 255,0,0 |
|||
DATA 0,255,0 |
|||
DATA 0,0,255 |
|||
DATA 255,0,255 |
|||
DATA 0,255,255 |
|||
DATA 255,255,0 |
|||
DATA 255,255,255</syntaxhighlight> |
|||
==={{header|TI Basic}}=== |
|||
<syntaxhighlight lang="basic">100 REM SMPTE Format Color Bars |
|||
110 REM with 400 Hz reference tone |
|||
120 CALL CLEAR |
|||
130 CALL SCREEN(2) |
|||
140 CALL COLOR(8,15,1) |
|||
150 CALL COLOR(9,11,1) |
|||
160 CALL COLOR(10,8,1) |
|||
170 CALL COLOR(11,13,1) |
|||
180 CALL COLOR(12,14,1) |
|||
190 CALL COLOR(13,10,1) |
|||
200 CALL COLOR(14,5,1) |
|||
210 CALL COLOR(15,2,1) |
|||
220 CALL COLOR(16,16,1) |
|||
230 GOSUB 510 |
|||
240 REM color bars |
|||
250 CALL VCHAR(1,3,88,96) |
|||
260 CALL VCHAR(1,7,96,96) |
|||
270 CALL VCHAR(1,11,104,96) |
|||
280 CALL VCHAR(1,15,112,96) |
|||
290 CALL VCHAR(1,19,120,96) |
|||
300 CALL VCHAR(1,23,128,96) |
|||
310 CALL VCHAR(1,27,136,96) |
|||
320 REM BLACK BAR |
|||
330 CALL HCHAR(19,1,144,224) |
|||
340 REM WHITE BOX |
|||
350 FOR I=19 TO 24 |
|||
360 CALL HCHAR(I,8,152,6) |
|||
370 NEXT I |
|||
410 REM SMPTE Complementary boxes |
|||
420 CALL HCHAR(18,3,136,4) |
|||
430 CALL HCHAR(18,7,144,4) |
|||
440 CALL HCHAR(18,11,120,4) |
|||
450 CALL HCHAR(18,15,144,4) |
|||
460 CALL HCHAR(18,19,104,4) |
|||
470 CALL HCHAR(18,23,144,4) |
|||
480 CALL HCHAR(18,27,88,4) |
|||
490 CALL SOUND(3000,400,12) |
|||
500 GOTO 490 |
|||
510 SQUARE$="FFFFFFFFFFFFFFFF" |
|||
520 FOR I = 88 TO 152 STEP 8 |
|||
530 CALL CHAR(I,SQUARE$) |
|||
540 NEXT I |
|||
590 RETURN |
|||
</syntaxhighlight> |
|||
==={{header|ZX Spectrum Basic}}=== |
|||
<syntaxhighlight lang="zxbasic">10 REM The ZX Spectrum display is 32 columns wide, so we have 8 columns of 4 spaces |
|||
20 FOR r=0 TO 20: REM There are 21 rows |
|||
30 FOR c=0 TO 7: REM We use the native colour sequence here |
|||
40 PAPER c: REM set the background colour for the spaces to be printed |
|||
50 PRINT " ";: REM four spaces, the semicolon prevents newline |
|||
60 NEXT c |
|||
70 REM at this point the cursor has wrapped, so we don't need a newline |
|||
80 NEXT r</syntaxhighlight> |
|||
=={{header|Befunge}}== |
|||
Assuming a terminal with support for ANSI escape sequences, this fills the screen with the colour sequence: black, red, green, blue, magenta, cyan, yellow and white. It then waits for the user to press ''Enter'' before terminating. |
|||
<syntaxhighlight lang="befunge"><v%"P": <<*"(2" |
|||
v_:"P"/"["39*,, :55+/68v |
|||
v,,,";1H" ,+*86%+55 ,+*< |
|||
73654210v,,\,,,*93"[4m"< |
|||
>$:55+%#v_:1-"P"%55+/3g^ |
|||
39*,,,~@>48*,1-:#v_$"m["</syntaxhighlight> |
|||
=={{header|C}}== |
|||
This task requires functionality which allows the code to communicate to the video device. This will vary from vendor to vendor. The following examples show two ways of doing this, in the text and graphics mode, using Borland's Turbo C. |
|||
===Text Mode=== |
|||
The required functions and structures are in conio.h |
|||
<syntaxhighlight lang="c"> |
|||
#include<conio.h> |
|||
#define COLOURS 8 |
|||
int main() |
|||
{ |
|||
int colour=0,i,j,MAXROW,MAXCOL; |
|||
struct text_info tInfo; |
|||
gettextinfo(&tInfo); |
|||
MAXROW = tInfo.screenheight; |
|||
MAXCOL = tInfo.screenwidth; |
|||
textbackground(BLACK); //8 colour constants are defined |
|||
clrscr(); |
|||
for(colour=0;colour<COLOURS;colour++) |
|||
{ |
|||
getch(); //waits for a key hit |
|||
gotoxy(1+colour*MAXCOL/COLOURS,1); |
|||
textbackground(colour); |
|||
for(j=0;j<MAXROW;j++){ |
|||
for(i=0;i<MAXCOL/COLOURS;i++){ |
|||
cprintf(" "); |
|||
} |
|||
gotoxy(1+colour*MAXCOL/COLOURS,1+j); |
|||
} |
|||
} |
|||
getch(); |
|||
textbackground(BLACK); |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
===Graphics Mode=== |
|||
The required functions and structures are in graphics.h, conio.h is included for getch(). |
|||
<syntaxhighlight lang="c"> |
|||
#include<graphics.h> |
|||
#include<conio.h> |
|||
int main() |
|||
{ |
|||
int d=DETECT,m,maxX,maxY,maxColours,i; |
|||
initgraph(&d,&m,"c:/turboc3/bgi"); |
|||
maxX = getmaxx(); |
|||
maxY = getmaxy(); |
|||
maxColours = getmaxcolor(); |
|||
for(i=0;i<maxColours;i++) |
|||
{ |
|||
setfillstyle(SOLID_FILL,i); |
|||
bar(i*maxX/maxColours,0,(i+1)*maxX/maxColours,maxY); |
|||
} |
|||
getch(); |
|||
closegraph(); |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
using Qt 4.6 |
using Qt 4.6 |
||
<PRE>file colorbars.h</PRE> |
|||
file <code>colorbars.h</code>: |
|||
<lang cpp>#ifndef MYWIDGET_H |
|||
<syntaxhighlight lang="cpp">#ifndef MYWIDGET_H |
|||
#define MYWIDGET_H |
#define MYWIDGET_H |
||
#include <QWidget> |
#include <QWidget> |
||
Line 141: | Line 764: | ||
const int colornumber ; |
const int colornumber ; |
||
} ; |
} ; |
||
#endif</ |
#endif</syntaxhighlight> |
||
<PRE>file colorbars.cpp</PRE> |
|||
file <code>colorbars.cpp</code>: |
|||
<lang cpp>#include <QtGui> |
|||
<syntaxhighlight lang="cpp">#include <QtGui> |
|||
#include "colorbars.h" |
#include "colorbars.h" |
||
Line 169: | Line 794: | ||
xstart += rectwidth + 1 ; |
xstart += rectwidth + 1 ; |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
<PRE>file main.cpp</PRE> |
|||
file <code>main.cpp</code>: |
|||
<lang cpp>#include <QApplication> |
|||
<syntaxhighlight lang="cpp">#include <QApplication> |
|||
#include "colorbars.h" |
#include "colorbars.h" |
||
Line 180: | Line 807: | ||
window.show( ) ; |
window.show( ) ; |
||
return app.exec( ) ; |
return app.exec( ) ; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|COBOL}}== |
|||
{{works with|OpenCOBOL}} |
|||
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. terminal-colour-bars. |
|||
DATA DIVISION. |
|||
WORKING-STORAGE SECTION. |
|||
01 width PIC 9(3). |
|||
01 height PIC 9(3). |
|||
01 interval PIC 9(3). |
|||
01 colours-area. |
|||
03 colour-values. |
|||
05 FILLER PIC 9 VALUE 0. *> Black |
|||
05 FILLER PIC 9 VALUE 4. *> Red |
|||
05 FILLER PIC 9 VALUE 2. *> Green |
|||
05 FILLER PIC 9 VALUE 1. *> Blue |
|||
05 FILLER PIC 9 VALUE 5. *> Magneta |
|||
05 FILLER PIC 9 VALUE 3. *> Cyan |
|||
05 FILLER PIC 9 VALUE 6. *> Yellow |
|||
05 FILLER PIC 9 VALUE 7. *> White |
|||
03 colour-table REDEFINES colour-values. |
|||
05 colours PIC 9 OCCURS 8 TIMES INDEXED BY colour-index. |
|||
01 i PIC 9(3). |
|||
01 j PIC 9(3). |
|||
PROCEDURE DIVISION. |
|||
ACCEPT width FROM COLUMNS |
|||
ACCEPT height FROM LINES |
|||
DIVIDE width BY 8 GIVING interval |
|||
PERFORM VARYING i FROM 1 BY 1 UNTIL height < i |
|||
PERFORM VARYING j FROM 1 BY 1 UNTIL width < j |
|||
COMPUTE colour-index = (j / interval) + 1 |
|||
IF 8 < colour-index |
|||
SET colour-index TO 8 |
|||
END-IF |
|||
*> Some colours come a bit darker than they |
|||
*> should, with the yellow being orange and the white |
|||
*> being light-grey. |
|||
DISPLAY SPACE AT LINE i COLUMN j |
|||
WITH BACKGROUND-COLOR colours (colour-index) |
|||
END-PERFORM |
|||
END-PERFORM |
|||
ACCEPT i *> Prevent ncurses returning to console immediately. |
|||
GOBACK |
|||
.</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
|||
==={{header|ncurses}}=== |
|||
To interface the ncurses C library from Lisp, the ''croatoan'' library is used. |
|||
<syntaxhighlight lang="lisp">(defun color-bars () |
|||
(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil) |
|||
(dotimes (i (height scr)) |
|||
(move scr i 0) |
|||
(dolist (color '(:red :green :yellow :blue :magenta :cyan :white :black)) |
|||
(add-char scr #\space :bgcolor color :n (floor (/ (width scr) 8))))) |
|||
(refresh scr) |
|||
;; wait for keypress |
|||
(get-char scr)))</syntaxhighlight> |
|||
=={{header|Delphi}}== |
|||
{{libheader| Winapi.Windows}} |
|||
{{libheader| System.SysUtils}} |
|||
{{libheader| System.Classes}} |
|||
{{libheader| Vcl.Graphics}} |
|||
{{libheader| Vcl.Forms}} |
|||
<syntaxhighlight lang="delphi"> |
|||
unit Colour_barsDisplay; |
|||
interface |
|||
uses |
|||
Winapi.Windows, System.SysUtils, System.Classes, Vcl.Graphics, Vcl.Forms; |
|||
type |
|||
TfmColourBar = class(TForm) |
|||
procedure FormPaint(Sender: TObject); |
|||
procedure FormResize(Sender: TObject); |
|||
private |
|||
{ Private declarations } |
|||
public |
|||
{ Public declarations } |
|||
end; |
|||
var |
|||
fmColourBar: TfmColourBar; |
|||
Colors: array of TColor = [clblack, clred, clgreen, clblue, clFuchsia, clAqua, |
|||
clyellow, clwhite]; |
|||
implementation |
|||
{$R *.dfm} |
|||
procedure TfmColourBar.FormPaint(Sender: TObject); |
|||
var |
|||
w, h, i: Integer; |
|||
r: TRect; |
|||
begin |
|||
w := ClientWidth div length(Colors); |
|||
h := ClientHeight; |
|||
r := Rect(0, 0, w, h); |
|||
with Canvas do |
|||
for i := 0 to High(Colors) do |
|||
begin |
|||
Brush.Color := Colors[i]; |
|||
FillRect(r); |
|||
r.Offset(w, 0); |
|||
end; |
|||
end; |
|||
procedure TfmColourBar.FormResize(Sender: TObject); |
|||
begin |
|||
Invalidate; |
|||
end; |
|||
end.</syntaxhighlight> |
|||
Form resource: |
|||
<syntaxhighlight lang="delphi"> |
|||
object fmColourBar: TfmColourBar |
|||
Caption = 'fmColourBar' |
|||
OldCreateOrder = False |
|||
OnPaint = FormPaint |
|||
OnResize = FormResize |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|EasyLang}}== |
|||
[https://easylang.dev/show/#cod=TYyxCoAwDET3fsWNKqjpmMEvKZ1KhUK1UER/34uTQ7i7l0tSqyFiQ4CIQDmiHFF6pacyKzW6hz3PxoqaTyS7dHvrKMZxtR8GzHBnsXz5aHfGgwlDwQw/Qoz2nC5SvnWLewE= Run it] |
|||
<syntaxhighlight lang="text"> |
|||
col[] = [ 000 900 090 009 909 099 990 999 ] |
|||
w = 100 / len col[] |
|||
for i = 1 to len col[] |
|||
color col[i] |
|||
move w * (i - 1) 0 |
|||
rect w 100 |
|||
. |
|||
</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
<syntaxhighlight lang="factor">USING: accessors colors.constants kernel math sequences ui |
|||
ui.gadgets ui.gadgets.tracks ui.pens.solid ; |
|||
IN: rosetta-code.colour-bars-display |
|||
: colors ( -- ) [ |
|||
horizontal <track> |
|||
{ |
|||
COLOR: black |
|||
COLOR: red |
|||
COLOR: green |
|||
COLOR: blue |
|||
COLOR: magenta |
|||
COLOR: cyan |
|||
COLOR: yellow |
|||
COLOR: white |
|||
} |
|||
[ <solid> gadget new swap >>interior ] map |
|||
dup length recip |
|||
[ track-add ] curry each |
|||
{ 640 480 } >>pref-dim |
|||
"bars" open-window |
|||
] with-ui ; |
|||
MAIN: colors</syntaxhighlight> |
|||
=={{header|Forth}}== |
|||
This program extends ANS Forth to control the TMS9918 Video display processor in the TI-99 computer. |
|||
<br> The color bars are shown in Society of Motion Picture and Television Engineers (SMPTE) order. |
|||
<syntaxhighlight lang="forth"> |
|||
\ Color Bars for TI-99 CAMEL99 Forth |
|||
NEEDS HCHAR FROM DSK1.GRAFIX \ TMS9918 control lexicon |
|||
NEEDS CHARSET FROM DSK1.CHARSET \ restores default character data |
|||
NEEDS ENUM FROM DSK1.ENUM \ add simple enumerator to Forth |
|||
\ Name TI-99 colors |
|||
1 ENUM CLR ENUM BLK ENUM MGRN ENUM LGRN |
|||
ENUM BLU ENUM LBLU ENUM RED ENUM CYAN |
|||
ENUM MRED ENUM LRED ENUM YEL ENUM LYEL |
|||
ENUM GRN ENUM MAG ENUM GRY ENUM WHT |
|||
DROP |
|||
\ square character data |
|||
HEX |
|||
CREATE SQUARE FFFF , FFFF , FFFF , FFFF , |
|||
DECIMAL |
|||
: COLOR-BARS ( -- ) |
|||
24 0 DO |
|||
\ col row char wid |
|||
\ --- --- ---- --- |
|||
2 I 88 4 HCHAR |
|||
6 I 96 4 HCHAR |
|||
10 I 104 4 HCHAR |
|||
14 I 112 4 HCHAR |
|||
18 I 120 4 HCHAR |
|||
22 I 128 4 HCHAR |
|||
26 I 136 4 HCHAR |
|||
LOOP ; |
|||
DECIMAL |
|||
: DEFCHARS ( pattern first last -- ) |
|||
1+ SWAP ?DO DUP I CHARDEF 8 +LOOP DROP ; |
|||
: SET-COLORS ( -- ) |
|||
\ charset fg bg |
|||
\ ------- -- -- |
|||
88 SET# GRY CLR COLOR |
|||
96 SET# YEL CLR COLOR |
|||
104 SET# CYAN CLR COLOR |
|||
112 SET# GRN CLR COLOR |
|||
120 SET# MAG CLR COLOR |
|||
128 SET# RED CLR COLOR |
|||
136 SET# BLU CLR COLOR |
|||
144 SET# BLK CLR COLOR ; |
|||
\ restore characters and colors |
|||
: DEFAULTS |
|||
8 SCREEN |
|||
4 19 BLK CLR COLORS |
|||
CLEAR |
|||
CHARSET ; |
|||
: BARS |
|||
CLEAR BLK SCREEN |
|||
SET-COLORS |
|||
SQUARE 88 152 DEFCHARS |
|||
COLOR-BARS |
|||
BEGIN ?TERMINAL UNTIL |
|||
DEFAULTS |
|||
; |
|||
CR .( Done. Type BARS to run) |
|||
</syntaxhighlight> |
|||
=={{header|Go}}== |
|||
{{libheader|Go Graphics}} |
|||
<syntaxhighlight lang="go">package main |
|||
import "github.com/fogleman/gg" |
|||
var colors = [8]string{ |
|||
"000000", // black |
|||
"FF0000", // red |
|||
"00FF00", // green |
|||
"0000FF", // blue |
|||
"FF00FF", // magenta |
|||
"00FFFF", // cyan |
|||
"FFFF00", // yellow |
|||
"FFFFFF", // white |
|||
} |
|||
func drawBars(dc *gg.Context) { |
|||
w := float64(dc.Width() / len(colors)) |
|||
h := float64(dc.Height()) |
|||
for i := range colors { |
|||
dc.SetHexColor(colors[i]) |
|||
dc.DrawRectangle(w*float64(i), 0, w, h) |
|||
dc.Fill() |
|||
} |
|||
} |
|||
func main() { |
|||
dc := gg.NewContext(400, 400) |
|||
drawBars(dc) |
|||
dc.SavePNG("color_bars.png") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Image similar to R entry. |
|||
</pre> |
|||
=={{header|Haskell}}== |
|||
Terminal-based version. |
|||
<syntaxhighlight lang="haskell">#!/usr/bin/env stack |
|||
-- stack --resolver lts-7.0 --install-ghc runghc --package vty -- -threaded |
|||
import Graphics.Vty |
|||
colorBars :: Int -> [(Int, Attr)] -> Image |
|||
colorBars h bars = horizCat $ map colorBar bars |
|||
where colorBar (w, attr) = charFill attr ' ' w h |
|||
barWidths :: Int -> Int -> [Int] |
|||
barWidths nBars totalWidth = map barWidth [0..nBars-1] |
|||
where fracWidth = fromIntegral totalWidth / fromIntegral nBars |
|||
barWidth n = |
|||
let n' = fromIntegral n :: Double |
|||
in floor ((n' + 1) * fracWidth) - floor (n' * fracWidth) |
|||
barImage :: Int -> Int -> Image |
|||
barImage w h = colorBars h $ zip (barWidths nBars w) attrs |
|||
where attrs = map color2attr colors |
|||
nBars = length colors |
|||
colors = [black, brightRed, brightGreen, brightBlue, brightMagenta, brightCyan, brightYellow, brightWhite] |
|||
color2attr c = Attr Default Default (SetTo c) |
|||
main :: IO () |
|||
main = do |
|||
cfg <- standardIOConfig |
|||
vty <- mkVty cfg |
|||
let output = outputIface vty |
|||
bounds <- displayBounds output |
|||
let showBars (w,h) = do |
|||
let img = barImage w h |
|||
pic = picForImage img |
|||
update vty pic |
|||
e <- nextEvent vty |
|||
case e of |
|||
EvResize w' h' -> showBars (w',h') |
|||
_ -> return () |
|||
showBars bounds |
|||
shutdown vty</syntaxhighlight> |
|||
[[File:Haskell_Colourbars_A_0.png|700px]] |
|||
Graphical version using SFML. |
|||
<syntaxhighlight lang="haskell">-- Before you can install the SFML Haskell library, you need to install |
|||
-- the CSFML C library. (For example, "brew install csfml" on OS X.) |
|||
-- This program runs in fullscreen mode. |
|||
-- Press any key or mouse button to exit. |
|||
import Control.Exception |
|||
import SFML.Graphics |
|||
import SFML.SFResource |
|||
import SFML.Window hiding (width, height) |
|||
withResource :: SFResource a => IO a -> (a -> IO b) -> IO b |
|||
withResource acquire = bracket acquire destroy |
|||
withResources :: SFResource a => IO [a] -> ([a] -> IO b) -> IO b |
|||
withResources acquire = bracket acquire (mapM_ destroy) |
|||
colors :: [Color] |
|||
colors = [black, red, green, magenta, cyan, yellow, white] |
|||
makeBar :: (Float, Float) -> (Color, Int) -> IO RectangleShape |
|||
makeBar (barWidth, height) (c, i) = do |
|||
bar <- err $ createRectangleShape |
|||
setPosition bar $ Vec2f (fromIntegral i * barWidth) 0 |
|||
setSize bar $ Vec2f barWidth height |
|||
setFillColor bar c |
|||
return bar |
|||
barSize :: VideoMode -> (Float, Float) |
|||
barSize (VideoMode w h _ ) = ( fromIntegral w / fromIntegral (length colors) |
|||
, fromIntegral h ) |
|||
loop :: RenderWindow -> [RectangleShape] -> IO () |
|||
loop wnd bars = do |
|||
mapM_ (\x -> drawRectangle wnd x Nothing) bars |
|||
display wnd |
|||
evt <- waitEvent wnd |
|||
case evt of |
|||
Nothing -> return () |
|||
Just SFEvtClosed -> return () |
|||
Just (SFEvtKeyPressed {}) -> return () |
|||
Just (SFEvtMouseButtonPressed {}) -> return () |
|||
_ -> loop wnd bars |
|||
main :: IO () |
|||
main = do |
|||
vMode <- getDesktopMode |
|||
let wStyle = [SFFullscreen] |
|||
withResource (createRenderWindow vMode "color bars" wStyle Nothing) $ |
|||
\wnd -> withResources (mapM (makeBar $ barSize vMode) $ zip colors [0..]) $ |
|||
\bars -> loop wnd bars</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
The procedure below is generalized to take a description of a ''test card'' and display it. |
The procedure below is generalized to take a description of a ''test card'' and display it. |
||
[[File:Colourbars_Simple_Unicon.png|thumb|right]] |
[[File:Colourbars_Simple_Unicon.png|thumb|right]] |
||
< |
<syntaxhighlight lang="icon">link graphics,printf |
||
procedure main() # generalized colour bars |
procedure main() # generalized colour bars |
||
Line 221: | Line 1,229: | ||
bar(width) ] ), |
bar(width) ] ), |
||
band(height) ]) |
band(height) ]) |
||
end</ |
end</syntaxhighlight> |
||
The following example is a wee tiny bit more interesting. |
The following example is a wee tiny bit more interesting. |
||
[[File:Colourbars_SMPTE_Unicon.png|thumb|right]] |
[[File:Colourbars_SMPTE_Unicon.png|thumb|right]] |
||
< |
<syntaxhighlight lang="icon">procedure SMPTE_TestCard() #: return structure with 480i(ish) testcard |
||
return testcard(,"SMPTE TV Test Card",width := 672,height := 504, |
return testcard(,"SMPTE TV Test Card",width := 672,height := 504, |
||
[ band( 1, [ bar( 1, "#c0c0c0"), |
[ band( 1, [ bar( 1, "#c0c0c0"), |
||
Line 253: | Line 1,261: | ||
bar(width) ] ), |
bar(width) ] ), |
||
band(height) ]) |
band(height) ]) |
||
end</ |
end</syntaxhighlight> |
||
{{libheader|Icon Programming Library}} |
{{libheader|Icon Programming Library}} |
||
Line 261: | Line 1,269: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j"> load 'viewmat' |
||
size=: 2{.".wd'qm' NB. J6 |
size=: 2{.".wd'qm' NB. J6 |
||
size=: getscreenwh_jgtk_ '' NB. J7 |
size=: getscreenwh_jgtk_ '' NB. J7 |
||
'rgb'viewmat (|.size){. (>.&.(%&160)|.size)$ 20# 256#.255*#:i.8</ |
'rgb'viewmat (|.size){. (>.&.(%&160)|.size)$ 20# 256#.255*#:i.8</syntaxhighlight> |
||
Note: You need to pick an implementation of <code>size</code> based on the version of J you are using. |
Note: You need to pick an implementation of <code>size</code> based on the version of J you are using. |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java"> |
||
import java.awt.Color; |
import java.awt.Color; |
||
import java.awt.Graphics; |
import java.awt.Graphics; |
||
Line 298: | Line 1,306: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Liberty BASIC}}== |
|||
<lang lb>nomainwin |
|||
colors$="black red green blue pink cyan yellow white" |
|||
WindowWidth=DisplayWidth:WindowHeight=DisplayHeight |
|||
UpperLeftX=1:UpperLeftY=1 |
|||
barWidth=DisplayWidth/8 |
|||
graphicbox #main.g, 0,0,DisplayWidth,DisplayHeight |
|||
open "" for window_popup as #main |
|||
#main "trapclose [quit]" |
|||
#main.g "down; setfocus; when characterInput [quit]" |
|||
#main.g "when leftButtonUp [quit]" |
|||
#main.g "size ";barWidth |
|||
=={{header|Julia}}== |
|||
for x = barWidth/2 to DisplayWidth step barWidth |
|||
{{works with|Julia|0.6}} |
|||
i=i+1 |
|||
if i>8 then i=1 |
|||
col$=word$(colors$,i) |
|||
#main.g "color ";col$;"; line ";x;" 0 ";x;" ";DisplayHeight |
|||
next |
|||
wait |
|||
[quit] close #main:end |
|||
</lang> |
|||
<syntaxhighlight lang="julia">using Images |
|||
=={{header|Locomotive Basic}}== |
|||
colors = [colorant"black", colorant"red", colorant"green", colorant"darkblue", |
|||
[[File:CPC color bars.png|thumb|right]] |
|||
colorant"purple", colorant"blue", colorant"yellow", colorant"white"] |
|||
wcol = 60 # width of each color bar |
|||
h, w = 150, wcol * length(colors) + 1 |
|||
img = Matrix{RGB{N0f8}}(h, w); |
|||
for (j, col) in zip(1:wcol:w, colors) |
|||
img[:, j:j+wcol] = col |
|||
end |
|||
save("data/colourbars.jpg", img)</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
Show the default MODE 0 palette (includes two blinking colors at the end): |
|||
{{trans|Java}} |
|||
<syntaxhighlight lang="scala">import java.awt.Color |
|||
import java.awt.Graphics |
|||
import javax.swing.JFrame |
|||
class ColorFrame(width: Int, height: Int): JFrame() { |
|||
<lang locobasic>10 MODE 0:BORDER 23 |
|||
init { |
|||
20 FOR x=0 TO 15 |
|||
defaultCloseOperation = EXIT_ON_CLOSE |
|||
30 ORIGIN x*40,0 |
|||
setSize(width, height) |
|||
40 GRAPHICS PEN x |
|||
isVisible = true |
|||
50 FOR z=0 TO 39 STEP 4:MOVE z,0:DRAW z,400:NEXT |
|||
} |
|||
60 NEXT |
|||
70 CALL &bb06 ' wait for key press</lang> |
|||
override fun paint(g: Graphics) { |
|||
val colors = listOf(Color.black, Color.red, Color.green, Color.blue, |
|||
Color.pink, Color.cyan, Color.yellow, Color.white) |
|||
val size = colors.size |
|||
for (i in 0 until size) { |
|||
g.color = colors[i] |
|||
g.fillRect(width / size * i, 0, width / size, height) |
|||
} |
|||
} |
|||
} |
|||
fun main(args: Array<String>) { |
|||
ColorFrame(400, 400) |
|||
}</syntaxhighlight> |
|||
Editing Babbage problem |
|||
=={{header|Lua}}== |
|||
{{libheader|nw}} |
|||
{{libheader|cairo}} |
|||
<syntaxhighlight lang="lua">local nw = require("nw") |
|||
local app = nw:app() |
|||
local cw, ch = 320, 240 |
|||
local win = app:window(cw, ch, "Color Bars", false) |
|||
local colors = {{0,0,0}, {1,0,0}, {0,1,0}, {0,0,1}, {1,0,1}, {0,1,1}, {1,1,0}, {1,1,1}} |
|||
local unpack = unpack or table.unpack -- polyfill 5.2 vs 5.3 |
|||
function win:repaint() |
|||
local cr = win:bitmap():cairo() |
|||
for i = 1, #colors do |
|||
cr:rectangle((i-1)*cw/#colors, 0, cw/#colors, ch) |
|||
cr:rgb(unpack(colors[i])) |
|||
cr:fill() |
|||
end |
|||
end |
|||
win:show() |
|||
app:run()</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
Calling a module can be done by using name or call name. The later used for recursive call. Here we use it for beautify the code. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Checkit { |
|||
Module Bars { |
|||
barwidth=x.twips div 8 |
|||
barheight=y.twips |
|||
barcolors=(0,#ff0000,#00ff00, #0000ff, #FF00FF, #00ffff, #ffff00, #ffffff) |
|||
For i=0 to 7 |
|||
Move i*barwidth, 0 |
|||
\\ gradient fill. Here second color are the same as first color |
|||
Fill barwidth, barheight, array(barcolors, i), array(barcolors, i) |
|||
Next i |
|||
} |
|||
\\ first draw on console |
|||
Call Bars |
|||
Declare Form1 Form |
|||
Layer Form1 { |
|||
window 12, 10000,8000; |
|||
\\ now draw on Form1 layer, above console, in a window |
|||
Call Bars |
|||
} |
|||
Method Form1, "Show", 1 ' open modal |
|||
Declare Form1 Nothing |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="maple"> |
|||
with(plottools): |
|||
plots:-display([rectangle([0, 0], [.3, 2.1], color = black), rectangle([.3, 0], [.6, 2.1], color = red), rectangle([.6, 0], [.9, 2.1], color = green), rectangle([.9, 0], [1.2, 2.1], color = magenta), rectangle([1.2, 0], [1.5, 2.1], color = cyan), rectangle([1.5, 0], [1.8, 2.1], color = white), rectangle([1.8, 0], [2.1, 2.1], color = yellow)]) |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">ArrayPlot[ |
|||
ConstantArray[{Black, Red, Green, Blue, Magenta, Cyan, Yellow, |
|||
White}, 5]]</syntaxhighlight> |
|||
[[File:ColourBarsMathematica.png]] |
|||
=={{header|Nim}}== |
|||
{{libheader|gintro}} |
|||
<syntaxhighlight lang="nim">import gintro/[glib, gobject, gtk, gio, cairo] |
|||
const |
|||
Width = 400 |
|||
Height = 300 |
|||
#--------------------------------------------------------------------------------------------------- |
|||
proc draw(area: DrawingArea; context: Context) = |
|||
## Draw the color bars. |
|||
const Colors = [[0.0, 0.0, 0.0], [255.0, 0.0, 0.0], |
|||
[0.0, 255.0, 0.0], [0.0, 0.0, 255.0], |
|||
[255.0, 0.0, 255.0], [0.0, 255.0, 255.0], |
|||
[255.0, 255.0, 0.0], [255.0, 255.0, 255.0]] |
|||
const |
|||
RectWidth = float(Width div Colors.len) |
|||
RectHeight = float(Height) |
|||
var x = 0.0 |
|||
for color in Colors: |
|||
context.rectangle(x, 0, RectWidth, RectHeight) |
|||
context.setSource(color) |
|||
context.fill() |
|||
x += RectWidth |
|||
#--------------------------------------------------------------------------------------------------- |
|||
proc onDraw(area: DrawingArea; context: Context; data: pointer): bool = |
|||
## Callback to draw/redraw the drawing area contents. |
|||
area.draw(context) |
|||
result = true |
|||
#--------------------------------------------------------------------------------------------------- |
|||
proc activate(app: Application) = |
|||
## Activate the application. |
|||
let window = app.newApplicationWindow() |
|||
window.setSizeRequest(Width, Height) |
|||
window.setTitle("Color bars") |
|||
# Create the drawing area. |
|||
let area = newDrawingArea() |
|||
window.add(area) |
|||
# Connect the "draw" event to the callback to draw the spiral. |
|||
discard area.connect("draw", ondraw, pointer(nil)) |
|||
window.showAll() |
|||
#——————————————————————————————————————————————————————————————————————————————————————————————————— |
|||
let app = newApplication(Application, "Rosetta.ColorBars") |
|||
discard app.connect("activate", activate) |
|||
discard app.run()</syntaxhighlight> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">open Graphics |
||
let round x = |
let round x = |
||
Line 357: | Line 1,496: | ||
) colors; |
) colors; |
||
ignore (read_key ()); |
ignore (read_key ()); |
||
;;</ |
;;</syntaxhighlight> |
||
execute with: |
execute with: |
||
Line 363: | Line 1,502: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
<syntaxhighlight lang="perl">use strict; |
|||
<lang Perl>#!/usr/bin/perl -w |
|||
use |
use warnings; |
||
use GD |
use GD; |
||
my %colors = ( |
my %colors = ( |
||
white => [255,255,255], red => [255, 0, 0], green => [ 0,255, 0], blue => [ 0, 0,255], |
|||
magenta => [255, 0,255], yellow => [255,255, 0], cyan => [ 0,255,255], black => [ 0, 0, 0]); |
|||
cyan => [ 0 , 255 , 255 ] , black => [ 0 , 0 , 0 ] ) ; |
|||
my $ |
my $start = 0; |
||
my $ |
my $barwidth = 160 / 8; |
||
my $ |
my $image = GD::Image->new( 160 , 100 ); |
||
foreach my $rgb ( values %colors ) { |
|||
for my $rgb ( values %colors ) { |
|||
my $paintcolor = $image->colorAllocate( @$rgb ) ; |
|||
$image->filledRectangle( $start * $barwidth , 0 , $start * $barwidth + |
$image->filledRectangle( $start * $barwidth , 0 , $start * $barwidth + |
||
$barwidth - 1 , 99 , $ |
$barwidth - 1 , 99 , $image->colorAllocate( @$rgb ) ); |
||
$start++ ; |
$start++ ; |
||
} |
} |
||
open ( DISPLAY , ">" , " |
open ( DISPLAY , ">" , "bars.png" ) or die; |
||
binmode DISPLAY |
binmode DISPLAY; |
||
print DISPLAY $image->png |
print DISPLAY $image->png; |
||
close DISPLAY |
close DISPLAY;</syntaxhighlight> |
||
</lang> |
|||
=={{header| |
=={{header|Phix}}== |
||
{{ |
{{libheader|Phix/pGUI}} |
||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<lang PicoLisp>(call 'clear) |
|||
<span style="color: #000080;font-style:italic;">-- demo\rosetta\Colour_bars.exw</span> |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
(let Width (in '(tput cols) (read)) |
|||
<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> |
|||
(do (in '(tput lines) (read)) |
|||
(for B (range 0 7) |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">colours</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #004600;">CD_BLACK</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_RED</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_GREEN</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_BLUE</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_MAGENTA</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_CYAN</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_YELLOW</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_WHITE</span><span style="color: #0000FF;">}</span> |
|||
(call 'tput 'setab B) |
|||
(space (/ Width 8)) ) |
|||
<span style="color: #004080;">Ihandle</span> <span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">canvas</span> |
|||
(prinl) ) ) |
|||
<span style="color: #004080;">cdCanvas</span> <span style="color: #000000;">cdcanvas</span> |
|||
<span style="color: #008080;">function</span> <span style="color: #000000;">redraw_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih*/</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000080;font-style:italic;">/*posx*/</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">/*posy*/</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">width</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">height</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetIntInt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"DRAWSIZE"</span><span style="color: #0000FF;">),</span> |
|||
<span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">lc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">colours</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">cdCanvasActivate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">lc</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">((</span><span style="color: #000000;">width</span><span style="color: #0000FF;">-</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)/(</span><span style="color: #000000;">lc</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))</span> |
|||
<span style="color: #7060A8;">cdCanvasSetForeground</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">colours</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span> |
|||
<span style="color: #7060A8;">cdCanvasBox</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">+</span><span style="color: #000000;">w</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">height</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #000000;">x</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">w</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #7060A8;">cdCanvasFlush</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span> |
|||
<span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #000000;">canvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupCanvas</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"redraw_cb"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"RASTERSIZE=600x400"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- initial size</span> |
|||
<span style="color: #000000;">dlg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span><span style="color: #008000;">`TITLE="Colour bars"`</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">IupMap</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #000000;">cdcanvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">cdCreateCanvas</span><span style="color: #0000FF;">(</span><span style="color: #004600;">CD_IUP</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">canvas</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">IupSetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"RASTERSIZE"</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">NULL</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- release the minimum limitation</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<!--</syntaxhighlight>--> |
|||
(call 'tput 'sgr0) # reset</lang> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
{{trans|Perl}} |
{{trans|Perl}} |
||
Will output result directly to the browser. Use it as CGI/BIN script. |
Will output result directly to the browser. Use it as CGI/BIN script. |
||
< |
<syntaxhighlight lang="php"><?php |
||
$colors = array(array( |
$colors = array(array( 0, 0, 0), // black |
||
array(255, 0, 0), // red |
array(255, 0, 0), // red |
||
array( 0, 255, 0), // green |
array( 0, 255, 0), // green |
||
array( 0, 0, 255), // blue |
array( 0, 0, 255), // blue |
||
array(255, 0, 255), // magenta |
array(255, 0, 255), // magenta |
||
array( 0, 255, 255), // cyan |
|||
array(255, 255, 0), // yellow |
array(255, 255, 0), // yellow |
||
array( |
array(255, 255, 255)); // white |
||
array( 0, 0, 0)); // black |
|||
define('BARWIDTH', 640 / count($colors)); |
define('BARWIDTH', 640 / count($colors)); |
||
Line 425: | Line 1,590: | ||
header('Content-type:image/png'); |
header('Content-type:image/png'); |
||
imagepng($image); |
imagepng($image); |
||
imagedestroy($image);</ |
imagedestroy($image);</syntaxhighlight> |
||
Alternately, with HTML output: |
|||
=={{header|PureBasic}}== |
|||
Press Enter or Escape to exit the program. |
|||
<lang PureBasic>Dim color(7) |
|||
color(0) = RGB($00, $00, $00) ;black |
|||
color(1) = RGB($FF, $00, $00) ;red |
|||
color(2) = RGB($00, $FF, $00) ;green |
|||
color(3) = RGB($00, $00, $FF) ;blue |
|||
color(4) = RGB($FF, $00, $FF) ;magenta |
|||
color(5) = RGB($00, $FF, $FF) ;cyan |
|||
color(6) = RGB($FF, $FF, $00) ;yellow |
|||
color(7) = RGB($FF, $FF, $FF) ;white |
|||
<syntaxhighlight lang="php"><?php |
|||
If Not InitKeyboard(): End: EndIf ;can't init keyboard |
|||
$colors = array( |
|||
If Not InitSprite(): End: EndIf ;can't init sprite/screen library |
|||
"000000", // black |
|||
If Not ExamineDesktops(): End: EndIf ;can't retrieve information about desktop |
|||
"FF0000", // red |
|||
"00FF00", // green |
|||
"0000FF", // blue |
|||
"FF00FF", // magenta |
|||
"00FFFF", // cyan |
|||
"FFFF00", // yellow |
|||
"FFFFFF", // white |
|||
); |
|||
echo '<table style="border: 1px solid black; border-spacing: 0;"><tr>'; |
|||
height = DesktopHeight(0) |
|||
foreach ($colors as $color) { |
|||
width = DesktopWidth(0) |
|||
echo '<td style="background-color: #'.$color.'; height: 100px; width: 20px;"></td>'; |
|||
depth = DesktopDepth(0) |
|||
} |
|||
If OpenScreen(width, height, depth, "Press ENTER to exit") |
|||
echo '</tr></table>';</syntaxhighlight> |
|||
StartDrawing(ScreenOutput()) |
|||
For c = 0 To 7 |
|||
Box((width * c) / 8, 0, width / 8, height, color(c)) |
|||
Next |
|||
StopDrawing() |
|||
FlipBuffers() |
|||
=={{header|PicoLisp}}== |
|||
Repeat |
|||
{{trans|UNIX Shell}} |
|||
Delay(10) |
|||
<syntaxhighlight lang="picolisp">(call 'clear) |
|||
ExamineKeyboard() |
|||
Until KeyboardPushed(#PB_Key_Escape) Or KeyboardPushed(#PB_Key_Return) |
|||
CloseScreen() |
|||
EndIf</lang> |
|||
===Alternate method using console=== |
|||
<lang PureBasic>DataSection |
|||
;Black, Red, Green, Blue, Magenta, Cyan, Yellow, White |
|||
Data.i 0, 12, 10, 9, 13, 11, 14, 15 |
|||
EndDataSection |
|||
(let Width (in '(tput cols) (read)) |
|||
Dim colors(7) |
|||
(do (in '(tput lines) (read)) |
|||
For c = 0 To 7 |
|||
(for B (range 0 7) |
|||
Read.i colors(c) |
|||
(call 'tput 'setab B) |
|||
Next |
|||
(space (/ Width 8)) ) |
|||
(prinl) ) ) |
|||
(call 'tput 'sgr0) # reset</syntaxhighlight> |
|||
If OpenConsole() |
|||
;The console display is 80 columns wide by 25 rows |
|||
For r = 0 To 24 |
|||
For c = 0 To 7 |
|||
ConsoleColor(colors(c), colors(c)) |
|||
Print(Space(80 / 8)) |
|||
Next |
|||
Next |
|||
EnableGraphicalConsole(1) |
|||
ConsoleLocate(0, 0) |
|||
ConsoleTitle("Press ENTER to exit"): Input() |
|||
CloseConsole() |
|||
EndIf</lang> |
|||
=={{header|Plain English}}== |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
Start up. |
|||
Clear the screen. |
|||
Divide the screen width by 8 giving a bar width. |
|||
Make a bar with 0 and 0 and the bar width and the screen's bottom. |
|||
Draw the color bars using the bar. |
|||
Refresh the screen. |
|||
Wait for the escape key. |
|||
Shut down. |
|||
To divide the screen width by a number giving a width: |
|||
=={{header|Run BASIC}}== |
|||
Put the screen's right into the width. |
|||
<lang runbasic>dim color$(8) |
|||
Divide the width by the number. |
|||
color$(1) = "black" |
|||
color$(2) = "red" |
|||
color$(3) = "green" |
|||
color$(4) = "blue" |
|||
color$(5) = "magenta" |
|||
color$(6) = "cyan" |
|||
color$(7) = "yellow" |
|||
color$(8) = "white" |
|||
html "<TABLE BORDER=1 CELLPADDING=0 CELLSPACING=4><tr height=70>" |
|||
for i = 1 to 8 |
|||
html "<td width=20 bgcolor='";color$(i);"'</td>" |
|||
next i |
|||
html "</tr></table>"</lang> |
|||
<pre>Output</pre> |
|||
A bar is a box. |
|||
[[File:ColorBarRunBasic.png]] |
|||
To draw a bar using a color and move it over: |
|||
Draw and fill the bar with the color. |
|||
Move the bar right the bar's width. |
|||
To draw the color bars using a bar: |
|||
Draw the bar using the black color and move it over. |
|||
Draw the bar using the red color and move it over. |
|||
Draw the bar using the green color and move it over. |
|||
Draw the bar using the blue color and move it over. |
|||
Draw the bar using the magenta color and move it over. |
|||
Draw the bar using the cyan color and move it over. |
|||
Draw the bar using the yellow color and move it over. |
|||
Draw and fill the bar using the white color.</syntaxhighlight> |
|||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell"> |
|||
[string[]]$colors = "Black" , "DarkBlue" , "DarkGreen" , "DarkCyan", |
|||
"DarkRed" , "DarkMagenta", "DarkYellow", "Gray", |
|||
"DarkGray", "Blue" , "Green" , "Cyan", |
|||
"Red" , "Magenta" , "Yellow" , "White" |
|||
for ($i = 0; $i -lt 64; $i++) |
|||
{ |
|||
for ($j = 0; $j -lt $colors.Count; $j++) |
|||
{ |
|||
Write-Host (" " * 12) -BackgroundColor $colors[$j] -NoNewline |
|||
} |
|||
Write-Host |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Processing}}== |
|||
<syntaxhighlight lang="processing">fullScreen(); |
|||
noStroke(); |
|||
color[] cs = { |
|||
color(0), // black |
|||
color(255,0,0), // red |
|||
color(0,255,0), // green |
|||
color(255,0,255), // magenta |
|||
color(0,255,255), // cyan |
|||
color(255,255,0), // yellow |
|||
color(255) // white |
|||
}; |
|||
for(int i=0; i<7; i++) { |
|||
fill(cs[i]); |
|||
rect(i*width/8,0,width/8,height); |
|||
}</syntaxhighlight> |
|||
=={{header|Python}}== |
|||
<syntaxhighlight lang="python"> |
|||
#!/usr/bin/env python |
|||
#vertical coloured stripes in window in Python 2.7.1 |
|||
from livewires import * |
|||
horiz=640; vert=480 |
|||
begin_graphics(width=horiz,height=vert,title="v_stripes",background=Colour.black) |
|||
NameColors=["black","red","green","dark_blue","purple","blue","yellow","white"] |
|||
stepik=horiz/len(NameColors) |
|||
for index,each in enumerate(NameColors): |
|||
ExcStrng="set_colour(Colour."+each+")" |
|||
exec ExcStrng |
|||
box(index*stepik,0,(index+1)*stepik,vert,filled=1) |
|||
while keys_pressed() != ['x']: # press x key to terminate program |
|||
pass |
|||
end_graphics() |
|||
</syntaxhighlight> |
|||
=={{header|R}}== |
|||
Create the color palette, set margins to zero so the image will fill the display, and use image to create the graphic: |
|||
[[File:ColorBarR.png|thumb|right]] |
|||
<syntaxhighlight lang="r"> |
|||
pal <- c("black", "red", "green", "blue", "magenta", "cyan", "yellow", "white") |
|||
par(mar = rep(0, 4)) |
|||
image(matrix(1:8), col = pal, axes = FALSE) |
|||
</syntaxhighlight> |
|||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket"> |
|||
#lang racket/gui |
|||
(define-values [W H] (get-display-size #t)) |
|||
(define colors |
|||
'("Black" "Red" "Green" "Blue" "Magenta" "Cyan" "Yellow" "White")) |
|||
(define (paint-pinstripe canvas dc) |
|||
(send dc set-pen "black" 0 'transparent) |
|||
(for ([x (in-range 0 W (/ W (length colors)))] [c colors]) |
|||
(send* dc (set-brush c 'solid) (draw-rectangle x 0 W H)))) |
|||
(define full-frame% |
|||
(class frame% |
|||
(define/override (on-subwindow-char r e) |
|||
(when (eq? 'escape (send e get-key-code)) |
|||
(send this show #f))) |
|||
(super-new |
|||
[label "Color bars"] [width W] [height H] |
|||
[style '(no-caption no-resize-border hide-menu-bar no-system-menu)]) |
|||
(define c (new canvas% [parent this] [paint-callback paint-pinstripe])) |
|||
(send this show #t))) |
|||
(void (new full-frame%)) |
|||
</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo|2018.10}} |
|||
<syntaxhighlight lang="raku" line>my ($x,$y) = 1280, 720; |
|||
my @colors = map -> $r, $g, $b { Buf.new: |(($r, $g, $b) xx $x div 8) }, |
|||
0, 0, 0, |
|||
255, 0, 0, |
|||
0, 255, 0, |
|||
0, 0, 255, |
|||
255, 0, 255, |
|||
0, 255, 255, |
|||
255, 255, 0, |
|||
255, 255, 255; |
|||
my $img = open "colorbars.ppm", :w orelse die "Can't create colorbars.ppm: $_"; |
|||
$img.print: qq:to/EOH/; |
|||
P6 |
|||
# colorbars.ppm |
|||
$x $y |
|||
255 |
|||
EOH |
|||
for ^$y { |
|||
for ^@colors -> $h { |
|||
$img.write: @colors[$h]; |
|||
} |
|||
} |
|||
$img.close;</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
{{works with|PC REXX}} |
|||
{{works with|Personal REXX}} |
|||
{{works with|R4}} |
|||
{{works with|ROO}} |
|||
<br> |
|||
Programming note: because of the way the REXX interpreters (being used for this example) ensure screen output fidelity, if ninety characters are displayed on a ninety-byte wide screen, REXX apparently forces an extra blank, causing to what appears to be a blank line after the line displayed. Because of this, the last color bar ('''_.8''') has been shortened by one byte. |
|||
<syntaxhighlight lang="rexx">/*REXX program displays eight colored vertical bars on a full screen. */ |
|||
parse value scrsize() with sd sw . /*the screen depth and width. */ |
|||
barWidth=sw%8 /*calculate the bar width. */ |
|||
_.=copies('db'x, barWidth) /*the bar, full width. */ |
|||
_.8=left(_.,barWidth-1) /*the last bar width, less one. */ |
|||
$ = x2c('1b5b73') || x2c("1b5b313b33376d") /* the preamble, and the header. */ |
|||
hdr.1 = x2c('1b5b303b33306d') /* " color black. */ |
|||
hdr.2 = x2c('1b5b313b33316d') /* " color red. */ |
|||
hdr.3 = x2c('1b5b313b33326d') /* " color green. */ |
|||
hdr.4 = x2c('1b5b313b33346d') /* " color blue. */ |
|||
hdr.5 = x2c('1b5b313b33356d') /* " color magenta. */ |
|||
hdr.6 = x2c('1b5b313b33366d') /* " color cyan. */ |
|||
hdr.7 = x2c('1b5b313b33336d') /* " color yellow. */ |
|||
hdr.8 = x2c('1b5b313b33376d') /* " color white. */ |
|||
tail = x2c('1b5b751b5b303b313b33363b34303b306d') /* " epilogue, and the trailer.*/ |
|||
/* [↓] last bar width is shrunk. */ |
|||
do j=1 for 8 /*build the line, color by color. */ |
|||
$=$ || hdr.j || _.j /*append the color header + bar. */ |
|||
end /*j*/ /* [↑] color order is the list. */ |
|||
/* [↓] the tail is overkill. */ |
|||
$=$ || tail /*append the epilogue (trailer). */ |
|||
/* [↓] show full screen of bars. */ |
|||
do k=1 for sd /*SD = screen depth (from above). */ |
|||
say $ /*have REXX display line of bars. */ |
|||
end /*k*/ /* [↑] Note: SD could be zero. */ |
|||
/*stick a fork in it, we're done. */</syntaxhighlight> |
|||
This REXX program makes use of '''scrsize''' REXX program (or BIF) which is used to determine the screen size of the terminal (console). |
|||
The '''SCRSIZE.REX''' REXX program is included here ──► [[SCRSIZE.REX]]. <br><br> |
|||
'''output''' appears identical to the output for '''Icon and Unicon''', '''Mathematica''', and '''R''' examples. |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
load "guilib.ring" |
|||
new qapp |
|||
{ |
|||
win1 = new qwidget() { |
|||
setwindowtitle("drawing using qpainter") |
|||
setwinicon(self,"C:\Ring\bin\image\browser.png") |
|||
setgeometry(100,100,500,600) |
|||
label1 = new qlabel(win1) { |
|||
setgeometry(10,10,400,400) |
|||
settext("") |
|||
} |
|||
new qpushbutton(win1) { |
|||
setgeometry(200,400,100,30) |
|||
settext("draw") |
|||
setclickevent("draw()") |
|||
} |
|||
show() |
|||
} |
|||
exec() |
|||
} |
|||
func draw |
|||
p1 = new qpicture() |
|||
color = new qcolor() { |
|||
setrgb(0,0,255,255) |
|||
} |
|||
pen = new qpen() { |
|||
setcolor(color) |
|||
setwidth(1) |
|||
} |
|||
new qpainter() { |
|||
begin(p1) |
|||
setpen(pen) |
|||
//Black, Red, Green, Blue, Magenta, Cyan, Yellow, White |
|||
for n = 1 to 8 |
|||
color2 = new qcolor(){ |
|||
switch n |
|||
on 1 r=0 g=0 b=0 |
|||
on 2 r=255 g=0 b=0 |
|||
on 3 r=0 g=255 b=0 |
|||
on 4 r=0 g=0 b=255 |
|||
on 5 r=255 g=0 b=255 |
|||
on 6 r=0 g=255 b=255 |
|||
on 7 r=255 g=255 b=0 |
|||
on 8 r=255 g=255 b=255 |
|||
off |
|||
setrgb(r,g,b,255) |
|||
} |
|||
mybrush = new qbrush() {setstyle(1) setcolor(color2)} |
|||
setbrush(mybrush) |
|||
drawrect(n*25,25,25,70) |
|||
next |
|||
endpaint() |
|||
} |
|||
label1 { setpicture(p1) show() } |
|||
</syntaxhighlight> |
|||
Output : |
|||
[https://lh3.googleusercontent.com/-_y0FSmg0NAs/V1xBPvGV2tI/AAAAAAAAAKk/TXYSJnpdZ346aQLd05yE9vLM8V9lEht1QCLcB/s1600/CalmoSoftColourBars.jpg Colour bars] |
|||
=={{header|Ruby}}== |
|||
{{libheader|RubyGems}} |
|||
{{libheader|JRubyArt}} |
|||
JRubyArt is a port of Processing to the ruby language |
|||
<syntaxhighlight lang="ruby"> |
|||
# Array of web colors black, red, green, blue, magenta, cyan, yellow, white |
|||
PALETTE = %w[#000000 #ff0000 #00ff00 #0000ff #ff00ff #00ffff #ffffff].freeze |
|||
def settings |
|||
full_screen |
|||
end |
|||
def setup |
|||
PALETTE.each_with_index do |col, idx| |
|||
fill color(col) |
|||
rect(idx * width / 8, 0, width / 8, height) |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
{{libheader|winit}} |
|||
{{libheader|pixels}} |
|||
renders into a borderless fullscreen window on the primary display. press ESC to close |
|||
<syntaxhighlight lang="rust">use pixels::{Pixels, SurfaceTexture}; // 0.2.0 |
|||
use winit::event::*; // 0.24.0 |
|||
use winit::event_loop::{ControlFlow, EventLoop}; |
|||
use winit::window::{Fullscreen, WindowBuilder}; |
|||
fn main() { |
|||
let event_loop = EventLoop::new(); |
|||
let window = WindowBuilder::new() |
|||
.with_title("Colour Bars") |
|||
.with_decorations(false) |
|||
.with_fullscreen(Some(Fullscreen::Borderless(None))) |
|||
.build(&event_loop).unwrap(); |
|||
let size = window.inner_size(); |
|||
let texture = SurfaceTexture::new(size.width, size.height, &window); |
|||
let mut image_buffer = Pixels::new(8, 1, texture).unwrap(); |
|||
let frame = image_buffer.get_frame(); |
|||
frame.copy_from_slice(&[ |
|||
0x00, 0x00, 0x00, 0xFF, // black |
|||
0xFF, 0x00, 0x00, 0xFF, // red |
|||
0x00, 0xFF, 0x00, 0xFF, // green |
|||
0x00, 0x00, 0xFF, 0xFF, // blue |
|||
0xFF, 0x00, 0xFF, 0xFF, // magenta |
|||
0x00, 0xFF, 0xFF, 0xFF, // cyan |
|||
0xFF, 0xFF, 0x00, 0xFF, // yellow |
|||
0xFF, 0xFF, 0xFF, 0xFF, // white |
|||
]); |
|||
image_buffer.render().unwrap(); |
|||
event_loop.run(move |ev, _, flow| { |
|||
match ev { |
|||
Event::WindowEvent { |
|||
event: WindowEvent::KeyboardInput { input, .. }, .. |
|||
} => { |
|||
if input.virtual_keycode == Some(VirtualKeyCode::Escape) { |
|||
*flow = ControlFlow::Exit; |
|||
} |
|||
} |
|||
Event::RedrawRequested(_) | Event::WindowEvent { |
|||
event: WindowEvent::Focused(true), .. |
|||
} => { |
|||
image_buffer.render().unwrap(); |
|||
} |
|||
_ => {} |
|||
} |
|||
}); |
|||
}</syntaxhighlight> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
< |
<syntaxhighlight lang="scala">import java.awt.Color |
||
import scala.swing._ |
import scala.swing._ |
||
Line 522: | Line 1,978: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
Open window: |
Open window: |
||
[[File:colorbars_scala.png|thumb|right]] |
[[File:colorbars_scala.png|thumb|right]] |
||
< |
<syntaxhighlight lang="scala">new MainFrame(){ |
||
title="Color bars" |
title="Color bars" |
||
visible=true |
visible=true |
||
preferredSize=new Dimension(640, 320) |
preferredSize=new Dimension(640, 320) |
||
contents=new ColorBars() |
contents=new ColorBars() |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Sidef}}== |
|||
{{trans|Perl}} |
|||
<syntaxhighlight lang="ruby">require('GD'); |
|||
var colors = Hash.new( |
|||
white => [255, 255, 255], |
|||
red => [255, 0, 0], |
|||
green => [0, 255, 0], |
|||
blue => [0, 0, 255], |
|||
magenta => [255, 0, 255], |
|||
yellow => [255, 255, 0], |
|||
cyan => [0, 255, 255], |
|||
black => [0, 0, 0], |
|||
); |
|||
var barwidth = 160/8; |
|||
var image = %s'GD::Image'.new(160, 100); |
|||
var start = 0; |
|||
colors.values.each { |rgb| |
|||
var paintcolor = image.colorAllocate(rgb...); |
|||
image.filledRectangle(start * barwidth, 0, start*barwidth + barwidth - 1, 99, paintcolor); |
|||
start++; |
|||
}; |
|||
%f'colorbars.png'.open('>:raw').print(image.png);</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
{{libheader|Tk}} |
{{libheader|Tk}} |
||
< |
<syntaxhighlight lang="tcl">package require Tcl 8.5 |
||
package require Tk 8.5 |
package require Tk 8.5 |
||
Line 545: | Line 2,028: | ||
-fill [lindex $colors 0] -outline {} |
-fill [lindex $colors 0] -outline {} |
||
set colors [list {*}[lrange $colors 1 end] [lindex $colors 0]] |
set colors [list {*}[lrange $colors 1 end] [lindex $colors 0]] |
||
}</ |
}</syntaxhighlight> |
||
== |
=={{header|UNIX Shell}}== |
||
< |
<syntaxhighlight lang="sh">#!/bin/sh |
||
clear |
clear |
||
WIDTH=`tput cols` |
WIDTH=`tput cols` |
||
Line 571: | Line 2,054: | ||
done |
done |
||
tput sgr0 # reset</ |
tput sgr0 # reset</syntaxhighlight> |
||
=={{header|Uxntal}}== |
|||
<syntaxhighlight lang="uxntal">( uxnasm color-bars.tal color-bars.rom && uxnemu color-bars.rom ) |
|||
|00 @System &vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1 |
|||
|20 @Screen &vector $2 &width $2 &height $2 &auto $1 &pad $1 &x $2 &y $2 &addr $2 &pixel $1 &sprite $1 |
|||
|0100 |
|||
( set 4 color theme |
|||
rgb |
|||
color0: 000 - black |
|||
color1: f00 - red |
|||
color2: 0f0 - green |
|||
color3: 00f - blue ) |
|||
#0f00 .System/r DEO2 |
|||
#00f0 .System/g DEO2 |
|||
#000f .System/b DEO2 |
|||
( store bars width ) |
|||
.Screen/width DEI2 #0004 DIV2 ,&quarter STR2 |
|||
( set starting position ) |
|||
#0000 .Screen/y DEO2 |
|||
( draw bars ) |
|||
#00 |
|||
&loop |
|||
#00 OVR [ LIT2 &quarter $2 ] MUL2 |
|||
.Screen/x DEO2 |
|||
DUP #80 ORA .Screen/pixel DEO |
|||
INC DUP #04 NEQ ?&loop |
|||
BRK</syntaxhighlight> |
|||
[[File:Color-bars.png|alt=Color bars task implemented in Uxntal.|thumb|Color bars task implemented in Uxntal.|none]] |
|||
=={{header|Wren}}== |
|||
{{trans|Go}} |
|||
{{libheader|DOME}} |
|||
<syntaxhighlight lang="wren">import "graphics" for Canvas, Color |
|||
import "dome" for Window |
|||
class Game { |
|||
static init() { |
|||
Window.title = "Color bars" |
|||
__width = 400 |
|||
__height = 400 |
|||
Canvas.resize(__width, __height) |
|||
Window.resize(__width, __height) |
|||
var colors = [ |
|||
Color.hex("000000"), // black |
|||
Color.hex("FF0000"), // red |
|||
Color.hex("00FF00"), // green |
|||
Color.hex("0000FF"), // blue |
|||
Color.hex("FF00FF"), // magenta |
|||
Color.hex("00FFFF"), // cyan |
|||
Color.hex("FFFF00"), // yellow |
|||
Color.hex("FFFFFF") // white |
|||
] |
|||
drawBars(colors) |
|||
} |
|||
static drawBars(colors) { |
|||
var w = __width / colors.count |
|||
var h = __height |
|||
for (i in 0...colors.count) { |
|||
Canvas.rectfill(w*i, 0, w, h, colors[i]) |
|||
} |
|||
} |
|||
static update() {} |
|||
static draw(dt) {} |
|||
}</syntaxhighlight> |
|||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic code declarations |
||
int W, X0, X1, Y, C; |
int W, X0, X1, Y, C; |
||
[SetVid($13); \320x200x8 graphics |
[SetVid($13); \320x200x8 graphics |
||
Line 585: | Line 2,138: | ||
C:= ChIn(1); \wait for keystroke |
C:= ChIn(1); \wait for keystroke |
||
SetVid(3); \restore normal text mode |
SetVid(3); \restore normal text mode |
||
]</ |
]</syntaxhighlight> |
||
== {{header|ZX Spectrum Basic}} == |
|||
<lang zxbasic>10 REM The ZX Spectrum display is 32 columns wide, so we have 8 columns of 4 spaces |
|||
20 FOR r=0 TO 20: REM There are 21 rows |
|||
30 FOR c=0 TO 7: REM We use the native colour sequence here |
|||
40 PAPER c: REM set the background colour for the spaces to be printed |
|||
50 PRINT " ";: REM four spaces, the semicolon prevents newline |
|||
60 NEXT c |
|||
70 REM at this point the cursor has wrapped, so we don't need a newline |
|||
80 NEXT r</lang> |
|||
{{omit from|Axe}} |
|||
{{omit from|GUISS}} |
{{omit from|GUISS}} |
||
{{omit from|Minimal BASIC}} |
|||
[[Category:Test card]] |
[[Category:Test card]] |
Revision as of 20:04, 30 June 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Display a series of vertical color bars across the width of the display.
The color bars should either use:
- the system palette, or
- the sequence of colors:
- black
- red
- green
- blue
- magenta
- cyan
- yellow
- white
6502 Assembly
Implemented using Easy6502, this displays a pinstripe using the system palette. There are 16 colors, and the bottom 4 bits of A are the color index.
lda #0
tax
tay ;clear regs
;video ram on Easy6502 is four pages ranging from $0200-$0500
loop:
sta $0200,x
sta $0220,x
sta $0240,x
sta $0260,x
sta $0280,x
sta $02A0,x
sta $02C0,x
sta $02E0,x
sta $0300,x
sta $0320,x
sta $0340,x
sta $0360,x
sta $0380,x
sta $03A0,x
sta $03C0,x
sta $03E0,x
sta $0400,x
sta $0420,x
sta $0440,x
sta $0460,x
sta $0480,x
sta $04A0,x
sta $04C0,x
sta $04E0,x
sta $0500,x
sta $0520,x
sta $0540,x
sta $0560,x
sta $0580,x
sta $05A0,x
sta $05C0,x
sta $05E0,x
inx
txa ;effectively increment A
cpx #$20 ;32 columns of video memory
beq exit
jmp loop
exit:
brk ;on easy6502 this terminates a program.
Action!
PROC Main()
BYTE
i,
CH=$02FC, ;Internal hardware value for last key pressed
PALNTSC=$D014, ;To check if PAL or NTSC system is used
PCOLR0=$02C0,PCOLR1=$02C1,
PCOLR2=$02C2,PCOLR3=$02C3,
COLOR0=$02C4,COLOR1=$02C5,
COLOR2=$02C6,COLOR3=$02C7,
COLOR4=$02C8
Graphics(10)
PCOLR0=$04 ;gray
PCOLR1=$00 ;black
IF PALNTSC=15 THEN
PCOLR2=$42 ;red for NTSC
PCOLR3=$C6 ;green for NTSC
COLOR0=$84 ;blue for NTSC
COLOR1=$66 ;magenta for NTSC
COLOR2=$A6 ;cyan for NTSC
COLOR3=$FC ;yellow for NTSC
ELSE
PCOLR2=$22 ;red for PAL
PCOLR3=$B6 ;green for PAL
COLOR0=$74 ;blue for PAL
COLOR1=$48 ;magenta for PAL
COLOR2=$96 ;cyan for PAL
COLOR3=$EC ;yellow for PAL
FI
COLOR4=$0F ;white
FOR i=0 TO 79
DO
Color=i/10+1
Plot(i,0)
DrawTo(i,191)
OD
DO UNTIL CH#$FF OD
CH=$FF
RETURN
- Output:
Screenshot from Atari 8-bit computer
ActionScript
package {
import flash.display.Sprite;
import flash.events.Event;
public class ColourBars extends Sprite {
public function ColourBars():void {
if (stage) init();
else addEventListener(Event.ADDED_TO_STAGE, init);
}
private function init(e:Event = null):void {
var colours:Array = [ 0x000000, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFF00, 0xFFFFFF ];
var w:Number = stage.stageWidth / 8, h:Number = stage.stageHeight;
var x:Number = 0, i:uint, c:uint;
for ( i = 0; i < 8; i++ ) {
c = colours[i];
graphics.beginFill(c);
graphics.drawRect(w * i, 0, w, h);
}
}
}
}
Ada
with SDL.Video.Windows.Makers;
with SDL.Video.Renderers.Makers;
with SDL.Video.Palettes;
with SDL.Events.Events;
with SDL.Events.Keyboards;
procedure Colour_Bars_Display is
use type SDL.Events.Event_Types;
use SDL.C;
Colours : constant array (0 .. 7) of SDL.Video.Palettes.Colour :=
((0, 0, 0, 255), (255, 0, 0, 255),
(0, 255, 0, 255), (0, 0, 255, 255),
(255, 0, 255, 255), (0, 255, 255, 255),
(255, 255, 0, 255), (255, 255, 255, 255));
Window : SDL.Video.Windows.Window;
Renderer : SDL.Video.Renderers.Renderer;
Event : SDL.Events.Events.Events;
Bar_Width : int;
begin
if not SDL.Initialise (Flags => SDL.Enable_Screen) then
return;
end if;
SDL.Video.Windows.Makers.Create (Win => Window,
Title => "",
Position => SDL.Natural_Coordinates'(0, 0),
Size => SDL.Positive_Sizes'(0, 0),
Flags => SDL.Video.Windows.Full_Screen_Desktop);
SDL.Video.Renderers.Makers.Create (Renderer, Window.Get_Surface);
Bar_Width := Window.Get_Size.Width / 8;
for A in Colours'Range loop
Renderer.Set_Draw_Colour (Colour => Colours (A));
Renderer.Fill (Rectangle => (X => SDL.C.int (A) * Bar_Width, Y => 0,
Width => Bar_Width,
Height => Window.Get_Size.Height));
end loop;
Window.Update_Surface;
Wait_Loop : loop
while SDL.Events.Events.Poll (Event) loop
exit Wait_Loop when Event.Common.Event_Type = SDL.Events.Keyboards.Key_Down;
end loop;
delay 0.050;
end loop Wait_Loop;
Window.Finalize;
SDL.Finalise;
end Colour_Bars_Display;
AutoHotkey
(available at http://www.autohotkey.net/~tic/Gdip.ahk)
#SingleInstance, Force
#NoEnv
SetBatchLines, -1
; Uncomment if Gdip.ahk is not in your standard library
;#Include, Gdip.ahk
; Start gdi+
If !pToken := Gdip_Startup()
{
message =
( LTrim
gdiplus error!, Gdiplus failed to start.
Please ensure you have gdiplus on your system.
)
MsgBox, 48, %message%
ExitApp
}
OnExit, Exit
; Set the width and height we want as our drawing area, to draw everything in.
; This will be the dimensions of our bitmap
Width := A_ScreenWidth, Height := A_ScreenHeight
; Create a layered window
; (+E0x80000 : must be used for UpdateLayeredWindow to work!)
; that is always on top (+AlwaysOnTop), has no taskbar entry or caption
Gui, 1: -Caption +E0x80000 +LastFound +OwnDialogs +Owner +AlwaysOnTop
; Show the window
Gui, 1: Show, NA
; Get a handle to this window we have created in order to update it later
hwnd1 := WinExist()
; Create a gdi bitmap with width and height of what we are going to
; draw into it. This is the entire drawing area for everything
hbm := CreateDIBSection(Width, Height)
; Get a device context compatible with the screen
hdc := CreateCompatibleDC()
; Select the bitmap into the device context
obm := SelectObject(hdc, hbm)
; Get a pointer to the graphics of the bitmap, for use with drawing functions
G := Gdip_GraphicsFromHDC(hdc)
; ARGB = Transparency, Red, Green, Blue
Colors := "0xFF000000,0xFFFF0000,0xFF00FF00,0xFF0000FF"
Colors .= ",0xFFFF00FF,0xFF00FFFF,0xFFFFFF00,0xFFFFFFFF"
; This list ^ is Black, Red, Green, Blue, Magenta, Cyan, Yellow, White
StringSplit Colors, Colors, `,
w := Width // Colors0
Loop % Colors0
{
; Create a brush to draw a rectangle
pBrush := Gdip_BrushCreateSolid(Colors%A_Index%)
; Fill the graphics of the bitmap with a rectangle using the brush created
Gdip_FillRectangle(G, pBrush, w*(A_Index-1), 0, w, height)
; Delete the brush as it is no longer needed and wastes memory
Gdip_DeleteBrush(pBrush)
}
; Update the specified window we have created (hwnd1) with a handle to our
; bitmap (hdc), specifying the x,y,w,h we want it positioned on our screen
; So this will position our gui at (0,0) with the Width and
; Height specified earlier
UpdateLayeredWindow(hwnd1, hdc, 0, 0, Width, Height)
; Select the object back into the hdc
SelectObject(hdc, obm)
; Now the bitmap may be deleted
DeleteObject(hbm)
; Also the device context related to the bitmap may be deleted
DeleteDC(hdc)
; The graphics may now be deleted
Gdip_DeleteGraphics(G)
Return
;#######################################################################
GuiEscape:
Exit:
; gdi+ may now be shutdown on exiting the program
Gdip_Shutdown(pToken)
ExitApp
Return
AWK
BEGIN {
nrcolors = 8
for (height=0; height<20; height++) {
for (width=0; width<nrcolors; width++) {
# print (ANSI) basic color and amount of spaces
printf("\033[%dm%*s", width + 40, 64 / nrcolors, " ")
}
# reset color and print newline
printf("\033[0m\n")
}
}
BASIC
AmigaBASIC
SCREEN 1,320,200,5,1
WINDOW 2,"Color bars",(0,10)-(297,186),15,1
FOR a=0 TO 300
LINE (a,0)-(a,186),(a+10)/10
NEXT
loop: GOTO loop
Applesoft BASIC
1 DATA1,12,6,3,14,13,15
2 HOME : GR : FOR I = 1 TO 7
3 READ C(I) : NEXT
4 FOR I = 0 TO 39
5 COLOR= C(I / 5)
6 VLIN 0,39 AT I : NEXT
BBC BASIC
SW_MAXIMIZE = 3
SYS "ShowWindow", @hwnd%, SW_MAXIMIZE
VDU 26
W% = @vdu%!208 / 4
H% = @vdu%!212 * 2
COLOUR 1,9
COLOUR 2,10
COLOUR 3,12
COLOUR 4,13
COLOUR 5,14
COLOUR 6,11
COLOUR 7,15
FOR C% = 0 TO 7
GCOL C%
RECTANGLE FILL C%*W%, 0, W%, H%
NEXT
Chipmunk Basic
The sequence of colors.
100 rem Colour bars/Display
110 graphics 0 : graphics cls
120 for i = 0 to 7
130 read r,g,b
140 graphics color r,g,b
150 for j = 0 to 79
160 x = i*80+j
170 graphics moveto x,0
180 graphics lineto x,399
190 next j
200 next i
500 data 0,0,0 : rem black
510 data 100,0,0 : rem red
520 data 0,100,0 : rem green
530 data 0,0,100 : rem blue
540 data 100,0,100 : rem magenta
550 data 0,100,100 : rem cyan
560 data 100,100,0 : rem yellow
570 data 100,100,100 : rem white
Commodore BASIC
This task achieved only on Commodore computers with color capabilities. The example below tested as-is in VICE on the following machines:
- Commodore 64
- Commodore 128
- Commodore Plus 4
- Commodore CBM-II (with VIC-II video)
- Commodore SX-64
It will also work well on the VIC-20 if you either omit line 310 or comment (REM) it out as the VIC-20 has only an eight-color palette.
This cross-compatibility is achieved by using the PETSCII control codes (CHR$(x)) for changing color, which are generally the same across all platforms, although the system palettes themselves may differ. This is combined with printing a "reverse video" space (solid block) character in the color selected.
5 rem color bars program
10 print chr$(147);:dim co(17):c=1
20 read co(c):if co(c)>0 then c=c+1:goto 20
25 sp$=" ":h=22:c=c-1:rem sp$=5 spaces
30 for r=1 to c step int(c/2)
40 for h=1 to 10
50 for b=r to (r+int(c/2))-1
60 print chr$(18);chr$(co(b));sp$;
70 next b
75 rem check if palette is only 8 (vic-20).
76 rem if so, we need to fill the last two spaces.
80 if c<=8 then print " ";
90 next h:next r
100 get k$:if k$="" then 100
110 end
280 rem because the control codes for color are non-sequential,
285 rem we put them into a sequential array for use
300 data 144,5,28,159,156,30,31,158
305 rem omit or rem the next line for vic-20
310 data 129,149,150,151,152,153,154,155
320 data 0:rem data terminato
FreeBASIC
' FB 1.05.0 Win64
' Draw the color bars on an 80 x 25 console using the system palette of 16 colors
' i.e. 5 columns per color
Width 80, 25
Shell "cls"
Locate ,, 0 '' turn cursor off
For clr As UInteger = 0 To 15
Color 0, clr
For row As Integer = 1 to 25
Locate row, clr * 5 + 1
Print Space(5);
Next row
Next clr
Sleep
' restore default settings
Locate ,, 1 '' turn cursor on
Color 7, 0 '' white text on black background
FutureBasic
void local fn DoIt
long index, x = 0
CFArrayRef colors = @[fn ColorBlack,fn ColorRed,
fn ColorGreen,fn ColorBlue,fn ColorMagenta,
fn ColorCyan,fn ColorYellow,fn ColorWhite]
window 1, @"Color bars/Display", (0,0,480,270), NSWindowStyleMaskTitled
pen -1
for index = 0 to len(colors) - 1
rect fill (x,0,60,270), colors[index]
x += 60
next
end fn
fn DoIt
HandleEvents
Gambas
Public Sub Form_Open()
Dim iColour As Integer[] = [Color.Black, Color.red, Color.Green, Color.Magenta, Color.Cyan, Color.Yellow, Color.white]
Dim hPanel As Panel
Dim siCount As Short
With Me
.Arrangement = Arrange.Horizontal
.Height = 300
.Width = 400
End With
For siCount = 0 To 6
hpanel = New Panel(Me)
hpanel.Expand = True
hpanel.H = 500
HPanel.Background = iColour[siCount]
Next
End
IS-BASIC
100 GRAPHICS LORES 16
110 SET PALETTE BLACK,RED,GREEN,BLUE,MAGENTA,CYAN,YELLOW,WHITE
120 FOR I=1 TO 7
130 CALL BAR(I)
140 NEXT
150 DEF BAR(C)
160 SET INK C
170 PLOT C*160,0;C*160,719;C*160+152,719;C*160+152,0;C*160,0
180 PLOT C*160+16,16,PAINT
190 END DEF
Liberty BASIC
nomainwin
colors$="black red green blue pink cyan yellow white"
WindowWidth=DisplayWidth:WindowHeight=DisplayHeight
UpperLeftX=1:UpperLeftY=1
barWidth=DisplayWidth/8
graphicbox #main.g, 0,0,DisplayWidth,DisplayHeight
open "" for window_popup as #main
#main "trapclose [quit]"
#main.g "down; setfocus; when characterInput [quit]"
#main.g "when leftButtonUp [quit]"
#main.g "size ";barWidth
for x = barWidth/2 to DisplayWidth step barWidth
i=i+1
if i>8 then i=1
col$=word$(colors$,i)
#main.g "color ";col$;"; line ";x;" 0 ";x;" ";DisplayHeight
next
wait
[quit] close #main:end
Locomotive Basic
Show the default MODE 0 palette (includes two blinking colors at the end):
10 MODE 0:BORDER 23
20 FOR x=0 TO 15
30 ORIGIN x*40,0
40 FOR z=0 TO 39 STEP 4:MOVE z,0:DRAW z,400,x:NEXT z
50 NEXT x
60 CALL &bb06 ' wait for key press
PureBasic
Press Enter or Escape to exit the program.
Dim color(7)
color(0) = RGB($00, $00, $00) ;black
color(1) = RGB($FF, $00, $00) ;red
color(2) = RGB($00, $FF, $00) ;green
color(3) = RGB($00, $00, $FF) ;blue
color(4) = RGB($FF, $00, $FF) ;magenta
color(5) = RGB($00, $FF, $FF) ;cyan
color(6) = RGB($FF, $FF, $00) ;yellow
color(7) = RGB($FF, $FF, $FF) ;white
If Not InitKeyboard(): End: EndIf ;can't init keyboard
If Not InitSprite(): End: EndIf ;can't init sprite/screen library
If Not ExamineDesktops(): End: EndIf ;can't retrieve information about desktop
height = DesktopHeight(0)
width = DesktopWidth(0)
depth = DesktopDepth(0)
If OpenScreen(width, height, depth, "Press ENTER to exit")
StartDrawing(ScreenOutput())
For c = 0 To 7
Box((width * c) / 8, 0, width / 8, height, color(c))
Next
StopDrawing()
FlipBuffers()
Repeat
Delay(10)
ExamineKeyboard()
Until KeyboardPushed(#PB_Key_Escape) Or KeyboardPushed(#PB_Key_Return)
CloseScreen()
EndIf
Alternate method using console
DataSection
;Black, Red, Green, Blue, Magenta, Cyan, Yellow, White
Data.i 0, 12, 10, 9, 13, 11, 14, 15
EndDataSection
Dim colors(7)
For c = 0 To 7
Read.i colors(c)
Next
If OpenConsole()
;The console display is 80 columns wide by 25 rows
For r = 0 To 24
For c = 0 To 7
ConsoleColor(colors(c), colors(c))
Print(Space(80 / 8))
Next
Next
EnableGraphicalConsole(1)
ConsoleLocate(0, 0)
ConsoleTitle("Press ENTER to exit"): Input()
CloseConsole()
EndIf
Run BASIC
colors$ = "black,red,green,blue,magenta,cyan,yellow,white"
html "<TABLE BORDER=1 CELLPADDING=0 CELLSPACING=4><tr height=70>"
for i = 1 to 8
html "<td width=20 bgcolor='";word$(colors$,i,",");"'</td>"
next i
html "</tr></table>"
Output
SmileBASIC
FOR I=0 TO 7
READ R,G,B
GFILL I*50,0,I*50+49,239,RGB(R,G,B)
NEXT
REPEAT UNTIL BUTTON(0) AND #B
DATA 0,0,0
DATA 255,0,0
DATA 0,255,0
DATA 0,0,255
DATA 255,0,255
DATA 0,255,255
DATA 255,255,0
DATA 255,255,255
TI Basic
100 REM SMPTE Format Color Bars
110 REM with 400 Hz reference tone
120 CALL CLEAR
130 CALL SCREEN(2)
140 CALL COLOR(8,15,1)
150 CALL COLOR(9,11,1)
160 CALL COLOR(10,8,1)
170 CALL COLOR(11,13,1)
180 CALL COLOR(12,14,1)
190 CALL COLOR(13,10,1)
200 CALL COLOR(14,5,1)
210 CALL COLOR(15,2,1)
220 CALL COLOR(16,16,1)
230 GOSUB 510
240 REM color bars
250 CALL VCHAR(1,3,88,96)
260 CALL VCHAR(1,7,96,96)
270 CALL VCHAR(1,11,104,96)
280 CALL VCHAR(1,15,112,96)
290 CALL VCHAR(1,19,120,96)
300 CALL VCHAR(1,23,128,96)
310 CALL VCHAR(1,27,136,96)
320 REM BLACK BAR
330 CALL HCHAR(19,1,144,224)
340 REM WHITE BOX
350 FOR I=19 TO 24
360 CALL HCHAR(I,8,152,6)
370 NEXT I
410 REM SMPTE Complementary boxes
420 CALL HCHAR(18,3,136,4)
430 CALL HCHAR(18,7,144,4)
440 CALL HCHAR(18,11,120,4)
450 CALL HCHAR(18,15,144,4)
460 CALL HCHAR(18,19,104,4)
470 CALL HCHAR(18,23,144,4)
480 CALL HCHAR(18,27,88,4)
490 CALL SOUND(3000,400,12)
500 GOTO 490
510 SQUARE$="FFFFFFFFFFFFFFFF"
520 FOR I = 88 TO 152 STEP 8
530 CALL CHAR(I,SQUARE$)
540 NEXT I
590 RETURN
ZX Spectrum Basic
10 REM The ZX Spectrum display is 32 columns wide, so we have 8 columns of 4 spaces
20 FOR r=0 TO 20: REM There are 21 rows
30 FOR c=0 TO 7: REM We use the native colour sequence here
40 PAPER c: REM set the background colour for the spaces to be printed
50 PRINT " ";: REM four spaces, the semicolon prevents newline
60 NEXT c
70 REM at this point the cursor has wrapped, so we don't need a newline
80 NEXT r
Befunge
Assuming a terminal with support for ANSI escape sequences, this fills the screen with the colour sequence: black, red, green, blue, magenta, cyan, yellow and white. It then waits for the user to press Enter before terminating.
<v%"P": <<*"(2"
v_:"P"/"["39*,, :55+/68v
v,,,";1H" ,+*86%+55 ,+*<
73654210v,,\,,,*93"[4m"<
>$:55+%#v_:1-"P"%55+/3g^
39*,,,~@>48*,1-:#v_$"m["
C
This task requires functionality which allows the code to communicate to the video device. This will vary from vendor to vendor. The following examples show two ways of doing this, in the text and graphics mode, using Borland's Turbo C.
Text Mode
The required functions and structures are in conio.h
#include<conio.h>
#define COLOURS 8
int main()
{
int colour=0,i,j,MAXROW,MAXCOL;
struct text_info tInfo;
gettextinfo(&tInfo);
MAXROW = tInfo.screenheight;
MAXCOL = tInfo.screenwidth;
textbackground(BLACK); //8 colour constants are defined
clrscr();
for(colour=0;colour<COLOURS;colour++)
{
getch(); //waits for a key hit
gotoxy(1+colour*MAXCOL/COLOURS,1);
textbackground(colour);
for(j=0;j<MAXROW;j++){
for(i=0;i<MAXCOL/COLOURS;i++){
cprintf(" ");
}
gotoxy(1+colour*MAXCOL/COLOURS,1+j);
}
}
getch();
textbackground(BLACK);
return 0;
}
Graphics Mode
The required functions and structures are in graphics.h, conio.h is included for getch().
#include<graphics.h>
#include<conio.h>
int main()
{
int d=DETECT,m,maxX,maxY,maxColours,i;
initgraph(&d,&m,"c:/turboc3/bgi");
maxX = getmaxx();
maxY = getmaxy();
maxColours = getmaxcolor();
for(i=0;i<maxColours;i++)
{
setfillstyle(SOLID_FILL,i);
bar(i*maxX/maxColours,0,(i+1)*maxX/maxColours,maxY);
}
getch();
closegraph();
return 0;
}
C++
using Qt 4.6
file colorbars.h
:
#ifndef MYWIDGET_H
#define MYWIDGET_H
#include <QWidget>
class QPaintEvent ;
class MyWidget : public QWidget {
public :
MyWidget( ) ;
protected :
void paintEvent( QPaintEvent * ) ;
private :
int width ;
int height ;
const int colornumber ;
} ;
#endif
file colorbars.cpp
:
#include <QtGui>
#include "colorbars.h"
MyWidget::MyWidget( ) :
width( 640 ) ,
height( 240 ) ,
colornumber( 8 ) {
setGeometry( 0, 0 , width , height ) ;
}
void MyWidget::paintEvent ( QPaintEvent * ) {
int rgbtriplets[ ] = { 0 , 0 , 0 , 255 , 0 , 0 , 0 , 255 , 0 ,
0 , 0 , 255 , 255 , 0 , 255 , 0 , 255 , 255 , 255 , 255 , 0 ,
255 , 255 , 255 } ;
QPainter myPaint( this ) ;
int rectwidth = width / colornumber ; //width of one rectangle
int xstart = 1 ; //x coordinate of the first rectangle
int offset = -1 ; //to allow for ++offset to define the red value even in the first run of the loop below
for ( int i = 0 ; i < colornumber ; i++ ) {
QColor rectColor ;
rectColor.setRed( rgbtriplets[ ++offset ] ) ;
rectColor.setGreen( rgbtriplets[ ++offset ] ) ;
rectColor.setBlue( rgbtriplets[ ++offset ] ) ;
myPaint.fillRect( xstart , 0 , rectwidth , height - 1 , rectColor ) ;
xstart += rectwidth + 1 ;
}
}
file main.cpp
:
#include <QApplication>
#include "colorbars.h"
int main( int argc, char * argv[ ] ) {
QApplication app( argc , argv ) ;
MyWidget window ;
window.setWindowTitle( QApplication::translate( "colorslides" , "color slides demonstration" ) ) ;
window.show( ) ;
return app.exec( ) ;
}
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. terminal-colour-bars.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 width PIC 9(3).
01 height PIC 9(3).
01 interval PIC 9(3).
01 colours-area.
03 colour-values.
05 FILLER PIC 9 VALUE 0. *> Black
05 FILLER PIC 9 VALUE 4. *> Red
05 FILLER PIC 9 VALUE 2. *> Green
05 FILLER PIC 9 VALUE 1. *> Blue
05 FILLER PIC 9 VALUE 5. *> Magneta
05 FILLER PIC 9 VALUE 3. *> Cyan
05 FILLER PIC 9 VALUE 6. *> Yellow
05 FILLER PIC 9 VALUE 7. *> White
03 colour-table REDEFINES colour-values.
05 colours PIC 9 OCCURS 8 TIMES INDEXED BY colour-index.
01 i PIC 9(3).
01 j PIC 9(3).
PROCEDURE DIVISION.
ACCEPT width FROM COLUMNS
ACCEPT height FROM LINES
DIVIDE width BY 8 GIVING interval
PERFORM VARYING i FROM 1 BY 1 UNTIL height < i
PERFORM VARYING j FROM 1 BY 1 UNTIL width < j
COMPUTE colour-index = (j / interval) + 1
IF 8 < colour-index
SET colour-index TO 8
END-IF
*> Some colours come a bit darker than they
*> should, with the yellow being orange and the white
*> being light-grey.
DISPLAY SPACE AT LINE i COLUMN j
WITH BACKGROUND-COLOR colours (colour-index)
END-PERFORM
END-PERFORM
ACCEPT i *> Prevent ncurses returning to console immediately.
GOBACK
.
Common Lisp
ncurses
To interface the ncurses C library from Lisp, the croatoan library is used.
(defun color-bars ()
(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)
(dotimes (i (height scr))
(move scr i 0)
(dolist (color '(:red :green :yellow :blue :magenta :cyan :white :black))
(add-char scr #\space :bgcolor color :n (floor (/ (width scr) 8)))))
(refresh scr)
;; wait for keypress
(get-char scr)))
Delphi
unit Colour_barsDisplay;
interface
uses
Winapi.Windows, System.SysUtils, System.Classes, Vcl.Graphics, Vcl.Forms;
type
TfmColourBar = class(TForm)
procedure FormPaint(Sender: TObject);
procedure FormResize(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
fmColourBar: TfmColourBar;
Colors: array of TColor = [clblack, clred, clgreen, clblue, clFuchsia, clAqua,
clyellow, clwhite];
implementation
{$R *.dfm}
procedure TfmColourBar.FormPaint(Sender: TObject);
var
w, h, i: Integer;
r: TRect;
begin
w := ClientWidth div length(Colors);
h := ClientHeight;
r := Rect(0, 0, w, h);
with Canvas do
for i := 0 to High(Colors) do
begin
Brush.Color := Colors[i];
FillRect(r);
r.Offset(w, 0);
end;
end;
procedure TfmColourBar.FormResize(Sender: TObject);
begin
Invalidate;
end;
end.
Form resource:
object fmColourBar: TfmColourBar
Caption = 'fmColourBar'
OldCreateOrder = False
OnPaint = FormPaint
OnResize = FormResize
end
EasyLang
col[] = [ 000 900 090 009 909 099 990 999 ]
w = 100 / len col[]
for i = 1 to len col[]
color col[i]
move w * (i - 1) 0
rect w 100
.
Factor
USING: accessors colors.constants kernel math sequences ui
ui.gadgets ui.gadgets.tracks ui.pens.solid ;
IN: rosetta-code.colour-bars-display
: colors ( -- ) [
horizontal <track>
{
COLOR: black
COLOR: red
COLOR: green
COLOR: blue
COLOR: magenta
COLOR: cyan
COLOR: yellow
COLOR: white
}
[ <solid> gadget new swap >>interior ] map
dup length recip
[ track-add ] curry each
{ 640 480 } >>pref-dim
"bars" open-window
] with-ui ;
MAIN: colors
Forth
This program extends ANS Forth to control the TMS9918 Video display processor in the TI-99 computer.
The color bars are shown in Society of Motion Picture and Television Engineers (SMPTE) order.
\ Color Bars for TI-99 CAMEL99 Forth
NEEDS HCHAR FROM DSK1.GRAFIX \ TMS9918 control lexicon
NEEDS CHARSET FROM DSK1.CHARSET \ restores default character data
NEEDS ENUM FROM DSK1.ENUM \ add simple enumerator to Forth
\ Name TI-99 colors
1 ENUM CLR ENUM BLK ENUM MGRN ENUM LGRN
ENUM BLU ENUM LBLU ENUM RED ENUM CYAN
ENUM MRED ENUM LRED ENUM YEL ENUM LYEL
ENUM GRN ENUM MAG ENUM GRY ENUM WHT
DROP
\ square character data
HEX
CREATE SQUARE FFFF , FFFF , FFFF , FFFF ,
DECIMAL
: COLOR-BARS ( -- )
24 0 DO
\ col row char wid
\ --- --- ---- ---
2 I 88 4 HCHAR
6 I 96 4 HCHAR
10 I 104 4 HCHAR
14 I 112 4 HCHAR
18 I 120 4 HCHAR
22 I 128 4 HCHAR
26 I 136 4 HCHAR
LOOP ;
DECIMAL
: DEFCHARS ( pattern first last -- )
1+ SWAP ?DO DUP I CHARDEF 8 +LOOP DROP ;
: SET-COLORS ( -- )
\ charset fg bg
\ ------- -- --
88 SET# GRY CLR COLOR
96 SET# YEL CLR COLOR
104 SET# CYAN CLR COLOR
112 SET# GRN CLR COLOR
120 SET# MAG CLR COLOR
128 SET# RED CLR COLOR
136 SET# BLU CLR COLOR
144 SET# BLK CLR COLOR ;
\ restore characters and colors
: DEFAULTS
8 SCREEN
4 19 BLK CLR COLORS
CLEAR
CHARSET ;
: BARS
CLEAR BLK SCREEN
SET-COLORS
SQUARE 88 152 DEFCHARS
COLOR-BARS
BEGIN ?TERMINAL UNTIL
DEFAULTS
;
CR .( Done. Type BARS to run)
Go
package main
import "github.com/fogleman/gg"
var colors = [8]string{
"000000", // black
"FF0000", // red
"00FF00", // green
"0000FF", // blue
"FF00FF", // magenta
"00FFFF", // cyan
"FFFF00", // yellow
"FFFFFF", // white
}
func drawBars(dc *gg.Context) {
w := float64(dc.Width() / len(colors))
h := float64(dc.Height())
for i := range colors {
dc.SetHexColor(colors[i])
dc.DrawRectangle(w*float64(i), 0, w, h)
dc.Fill()
}
}
func main() {
dc := gg.NewContext(400, 400)
drawBars(dc)
dc.SavePNG("color_bars.png")
}
- Output:
Image similar to R entry.
Haskell
Terminal-based version.
#!/usr/bin/env stack
-- stack --resolver lts-7.0 --install-ghc runghc --package vty -- -threaded
import Graphics.Vty
colorBars :: Int -> [(Int, Attr)] -> Image
colorBars h bars = horizCat $ map colorBar bars
where colorBar (w, attr) = charFill attr ' ' w h
barWidths :: Int -> Int -> [Int]
barWidths nBars totalWidth = map barWidth [0..nBars-1]
where fracWidth = fromIntegral totalWidth / fromIntegral nBars
barWidth n =
let n' = fromIntegral n :: Double
in floor ((n' + 1) * fracWidth) - floor (n' * fracWidth)
barImage :: Int -> Int -> Image
barImage w h = colorBars h $ zip (barWidths nBars w) attrs
where attrs = map color2attr colors
nBars = length colors
colors = [black, brightRed, brightGreen, brightBlue, brightMagenta, brightCyan, brightYellow, brightWhite]
color2attr c = Attr Default Default (SetTo c)
main :: IO ()
main = do
cfg <- standardIOConfig
vty <- mkVty cfg
let output = outputIface vty
bounds <- displayBounds output
let showBars (w,h) = do
let img = barImage w h
pic = picForImage img
update vty pic
e <- nextEvent vty
case e of
EvResize w' h' -> showBars (w',h')
_ -> return ()
showBars bounds
shutdown vty
Graphical version using SFML.
-- Before you can install the SFML Haskell library, you need to install
-- the CSFML C library. (For example, "brew install csfml" on OS X.)
-- This program runs in fullscreen mode.
-- Press any key or mouse button to exit.
import Control.Exception
import SFML.Graphics
import SFML.SFResource
import SFML.Window hiding (width, height)
withResource :: SFResource a => IO a -> (a -> IO b) -> IO b
withResource acquire = bracket acquire destroy
withResources :: SFResource a => IO [a] -> ([a] -> IO b) -> IO b
withResources acquire = bracket acquire (mapM_ destroy)
colors :: [Color]
colors = [black, red, green, magenta, cyan, yellow, white]
makeBar :: (Float, Float) -> (Color, Int) -> IO RectangleShape
makeBar (barWidth, height) (c, i) = do
bar <- err $ createRectangleShape
setPosition bar $ Vec2f (fromIntegral i * barWidth) 0
setSize bar $ Vec2f barWidth height
setFillColor bar c
return bar
barSize :: VideoMode -> (Float, Float)
barSize (VideoMode w h _ ) = ( fromIntegral w / fromIntegral (length colors)
, fromIntegral h )
loop :: RenderWindow -> [RectangleShape] -> IO ()
loop wnd bars = do
mapM_ (\x -> drawRectangle wnd x Nothing) bars
display wnd
evt <- waitEvent wnd
case evt of
Nothing -> return ()
Just SFEvtClosed -> return ()
Just (SFEvtKeyPressed {}) -> return ()
Just (SFEvtMouseButtonPressed {}) -> return ()
_ -> loop wnd bars
main :: IO ()
main = do
vMode <- getDesktopMode
let wStyle = [SFFullscreen]
withResource (createRenderWindow vMode "color bars" wStyle Nothing) $
\wnd -> withResources (mapM (makeBar $ barSize vMode) $ zip colors [0..]) $
\bars -> loop wnd bars
Icon and Unicon
The procedure below is generalized to take a description of a test card and display it.
The following example is a wee tiny bit more interesting.
graphics.icn provides graphics printf.icn provides sprintf
J
load 'viewmat'
size=: 2{.".wd'qm' NB. J6
size=: getscreenwh_jgtk_ '' NB. J7
'rgb'viewmat (|.size){. (>.&.(%&160)|.size)$ 20# 256#.255*#:i.8
Note: You need to pick an implementation of size
based on the version of J you are using.
Java
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
public class ColorFrame extends JFrame {
public ColorFrame(int width, int height) {
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(width, height);
this.setVisible(true);
}
@Override
public void paint(Graphics g) {
Color[] colors = { Color.black, Color.red, Color.green, Color.blue,
Color.pink, Color.CYAN, Color.yellow, Color.white };
for (int i = 0; i < colors.length; i++) {
g.setColor(colors[i]);
g.fillRect(this.getWidth() / colors.length * i, 0, this.getWidth()
/ colors.length, this.getHeight());
}
}
public static void main(String args[]) {
new ColorFrame(200, 200);
}
}
Julia
using Images
colors = [colorant"black", colorant"red", colorant"green", colorant"darkblue",
colorant"purple", colorant"blue", colorant"yellow", colorant"white"]
wcol = 60 # width of each color bar
h, w = 150, wcol * length(colors) + 1
img = Matrix{RGB{N0f8}}(h, w);
for (j, col) in zip(1:wcol:w, colors)
img[:, j:j+wcol] = col
end
save("data/colourbars.jpg", img)
Kotlin
import java.awt.Color
import java.awt.Graphics
import javax.swing.JFrame
class ColorFrame(width: Int, height: Int): JFrame() {
init {
defaultCloseOperation = EXIT_ON_CLOSE
setSize(width, height)
isVisible = true
}
override fun paint(g: Graphics) {
val colors = listOf(Color.black, Color.red, Color.green, Color.blue,
Color.pink, Color.cyan, Color.yellow, Color.white)
val size = colors.size
for (i in 0 until size) {
g.color = colors[i]
g.fillRect(width / size * i, 0, width / size, height)
}
}
}
fun main(args: Array<String>) {
ColorFrame(400, 400)
}
Editing Babbage problem
Lua
local nw = require("nw")
local app = nw:app()
local cw, ch = 320, 240
local win = app:window(cw, ch, "Color Bars", false)
local colors = {{0,0,0}, {1,0,0}, {0,1,0}, {0,0,1}, {1,0,1}, {0,1,1}, {1,1,0}, {1,1,1}}
local unpack = unpack or table.unpack -- polyfill 5.2 vs 5.3
function win:repaint()
local cr = win:bitmap():cairo()
for i = 1, #colors do
cr:rectangle((i-1)*cw/#colors, 0, cw/#colors, ch)
cr:rgb(unpack(colors[i]))
cr:fill()
end
end
win:show()
app:run()
M2000 Interpreter
Calling a module can be done by using name or call name. The later used for recursive call. Here we use it for beautify the code.
Module Checkit {
Module Bars {
barwidth=x.twips div 8
barheight=y.twips
barcolors=(0,#ff0000,#00ff00, #0000ff, #FF00FF, #00ffff, #ffff00, #ffffff)
For i=0 to 7
Move i*barwidth, 0
\\ gradient fill. Here second color are the same as first color
Fill barwidth, barheight, array(barcolors, i), array(barcolors, i)
Next i
}
\\ first draw on console
Call Bars
Declare Form1 Form
Layer Form1 {
window 12, 10000,8000;
\\ now draw on Form1 layer, above console, in a window
Call Bars
}
Method Form1, "Show", 1 ' open modal
Declare Form1 Nothing
}
Checkit
Maple
with(plottools):
plots:-display([rectangle([0, 0], [.3, 2.1], color = black), rectangle([.3, 0], [.6, 2.1], color = red), rectangle([.6, 0], [.9, 2.1], color = green), rectangle([.9, 0], [1.2, 2.1], color = magenta), rectangle([1.2, 0], [1.5, 2.1], color = cyan), rectangle([1.5, 0], [1.8, 2.1], color = white), rectangle([1.8, 0], [2.1, 2.1], color = yellow)])
Mathematica / Wolfram Language
ArrayPlot[
ConstantArray[{Black, Red, Green, Blue, Magenta, Cyan, Yellow,
White}, 5]]
Nim
import gintro/[glib, gobject, gtk, gio, cairo]
const
Width = 400
Height = 300
#---------------------------------------------------------------------------------------------------
proc draw(area: DrawingArea; context: Context) =
## Draw the color bars.
const Colors = [[0.0, 0.0, 0.0], [255.0, 0.0, 0.0],
[0.0, 255.0, 0.0], [0.0, 0.0, 255.0],
[255.0, 0.0, 255.0], [0.0, 255.0, 255.0],
[255.0, 255.0, 0.0], [255.0, 255.0, 255.0]]
const
RectWidth = float(Width div Colors.len)
RectHeight = float(Height)
var x = 0.0
for color in Colors:
context.rectangle(x, 0, RectWidth, RectHeight)
context.setSource(color)
context.fill()
x += RectWidth
#---------------------------------------------------------------------------------------------------
proc onDraw(area: DrawingArea; context: Context; data: pointer): bool =
## Callback to draw/redraw the drawing area contents.
area.draw(context)
result = true
#---------------------------------------------------------------------------------------------------
proc activate(app: Application) =
## Activate the application.
let window = app.newApplicationWindow()
window.setSizeRequest(Width, Height)
window.setTitle("Color bars")
# Create the drawing area.
let area = newDrawingArea()
window.add(area)
# Connect the "draw" event to the callback to draw the spiral.
discard area.connect("draw", ondraw, pointer(nil))
window.showAll()
#———————————————————————————————————————————————————————————————————————————————————————————————————
let app = newApplication(Application, "Rosetta.ColorBars")
discard app.connect("activate", activate)
discard app.run()
OCaml
open Graphics
let round x =
int_of_float (floor (x +. 0.5))
let () =
open_graph "";
let cols = size_x () in
let rows = size_y () in
let colors = [| black; red; green; blue; magenta; cyan; yellow; white |] in
let n = Array.length colors in
let bar_width = (float cols) /. (float n) in
Array.iteri (fun i color ->
let x1 = bar_width *. (float i) in
let x2 = bar_width *. (float (succ i)) in
set_color color;
fill_rect (round x1) 0 (round x2) rows;
) colors;
ignore (read_key ());
;;
execute with:
$ ocaml graphics.cma display_colour_bars.ml
Perl
use strict;
use warnings;
use GD;
my %colors = (
white => [255,255,255], red => [255, 0, 0], green => [ 0,255, 0], blue => [ 0, 0,255],
magenta => [255, 0,255], yellow => [255,255, 0], cyan => [ 0,255,255], black => [ 0, 0, 0]);
my $start = 0;
my $barwidth = 160 / 8;
my $image = GD::Image->new( 160 , 100 );
for my $rgb ( values %colors ) {
$image->filledRectangle( $start * $barwidth , 0 , $start * $barwidth +
$barwidth - 1 , 99 , $image->colorAllocate( @$rgb ) );
$start++ ;
}
open ( DISPLAY , ">" , "bars.png" ) or die;
binmode DISPLAY;
print DISPLAY $image->png;
close DISPLAY;
Phix
-- demo\rosetta\Colour_bars.exw with javascript_semantics include pGUI.e constant colours = {CD_BLACK, CD_RED, CD_GREEN, CD_BLUE, CD_MAGENTA, CD_CYAN, CD_YELLOW, CD_WHITE} Ihandle dlg, canvas cdCanvas cdcanvas function redraw_cb(Ihandle /*ih*/, integer /*posx*/, /*posy*/) integer {width, height} = IupGetIntInt(canvas, "DRAWSIZE"), x = 0, lc = length(colours) cdCanvasActivate(cdcanvas) for i=1 to lc do integer w = floor((width-x)/(lc-i+1)) cdCanvasSetForeground(cdcanvas, colours[i]) cdCanvasBox(cdcanvas, x, x+w, 0, height) x += w end for cdCanvasFlush(cdcanvas) return IUP_DEFAULT end function IupOpen() canvas = IupCanvas(Icallback("redraw_cb"),"RASTERSIZE=600x400") -- initial size dlg = IupDialog(canvas,`TITLE="Colour bars"`) IupMap(dlg) cdcanvas = cdCreateCanvas(CD_IUP, canvas) IupShow(dlg) IupSetAttribute(canvas, "RASTERSIZE", NULL) -- release the minimum limitation if platform()!=JS then IupMainLoop() IupClose() end if
PHP
Will output result directly to the browser. Use it as CGI/BIN script.
<?php
$colors = array(array( 0, 0, 0), // black
array(255, 0, 0), // red
array( 0, 255, 0), // green
array( 0, 0, 255), // blue
array(255, 0, 255), // magenta
array( 0, 255, 255), // cyan
array(255, 255, 0), // yellow
array(255, 255, 255)); // white
define('BARWIDTH', 640 / count($colors));
define('HEIGHT', 480);
$image = imagecreate(BARWIDTH * count($colors), HEIGHT);
foreach ($colors as $position => $color) {
$color = imagecolorallocate($image, $color[0], $color[1], $color[2]);
imagefilledrectangle($image, $position * BARWIDTH, 0,
$position * BARWIDTH + BARWIDTH - 1,
HEIGHT - 1, $color);
}
header('Content-type:image/png');
imagepng($image);
imagedestroy($image);
Alternately, with HTML output:
<?php
$colors = array(
"000000", // black
"FF0000", // red
"00FF00", // green
"0000FF", // blue
"FF00FF", // magenta
"00FFFF", // cyan
"FFFF00", // yellow
"FFFFFF", // white
);
echo '<table style="border: 1px solid black; border-spacing: 0;"><tr>';
foreach ($colors as $color) {
echo '<td style="background-color: #'.$color.'; height: 100px; width: 20px;"></td>';
}
echo '</tr></table>';
PicoLisp
(call 'clear)
(let Width (in '(tput cols) (read))
(do (in '(tput lines) (read))
(for B (range 0 7)
(call 'tput 'setab B)
(space (/ Width 8)) )
(prinl) ) )
(call 'tput 'sgr0) # reset
Plain English
To run:
Start up.
Clear the screen.
Divide the screen width by 8 giving a bar width.
Make a bar with 0 and 0 and the bar width and the screen's bottom.
Draw the color bars using the bar.
Refresh the screen.
Wait for the escape key.
Shut down.
To divide the screen width by a number giving a width:
Put the screen's right into the width.
Divide the width by the number.
A bar is a box.
To draw a bar using a color and move it over:
Draw and fill the bar with the color.
Move the bar right the bar's width.
To draw the color bars using a bar:
Draw the bar using the black color and move it over.
Draw the bar using the red color and move it over.
Draw the bar using the green color and move it over.
Draw the bar using the blue color and move it over.
Draw the bar using the magenta color and move it over.
Draw the bar using the cyan color and move it over.
Draw the bar using the yellow color and move it over.
Draw and fill the bar using the white color.
PowerShell
[string[]]$colors = "Black" , "DarkBlue" , "DarkGreen" , "DarkCyan",
"DarkRed" , "DarkMagenta", "DarkYellow", "Gray",
"DarkGray", "Blue" , "Green" , "Cyan",
"Red" , "Magenta" , "Yellow" , "White"
for ($i = 0; $i -lt 64; $i++)
{
for ($j = 0; $j -lt $colors.Count; $j++)
{
Write-Host (" " * 12) -BackgroundColor $colors[$j] -NoNewline
}
Write-Host
}
Processing
fullScreen();
noStroke();
color[] cs = {
color(0), // black
color(255,0,0), // red
color(0,255,0), // green
color(255,0,255), // magenta
color(0,255,255), // cyan
color(255,255,0), // yellow
color(255) // white
};
for(int i=0; i<7; i++) {
fill(cs[i]);
rect(i*width/8,0,width/8,height);
}
Python
#!/usr/bin/env python
#vertical coloured stripes in window in Python 2.7.1
from livewires import *
horiz=640; vert=480
begin_graphics(width=horiz,height=vert,title="v_stripes",background=Colour.black)
NameColors=["black","red","green","dark_blue","purple","blue","yellow","white"]
stepik=horiz/len(NameColors)
for index,each in enumerate(NameColors):
ExcStrng="set_colour(Colour."+each+")"
exec ExcStrng
box(index*stepik,0,(index+1)*stepik,vert,filled=1)
while keys_pressed() != ['x']: # press x key to terminate program
pass
end_graphics()
R
Create the color palette, set margins to zero so the image will fill the display, and use image to create the graphic:
pal <- c("black", "red", "green", "blue", "magenta", "cyan", "yellow", "white")
par(mar = rep(0, 4))
image(matrix(1:8), col = pal, axes = FALSE)
Racket
#lang racket/gui
(define-values [W H] (get-display-size #t))
(define colors
'("Black" "Red" "Green" "Blue" "Magenta" "Cyan" "Yellow" "White"))
(define (paint-pinstripe canvas dc)
(send dc set-pen "black" 0 'transparent)
(for ([x (in-range 0 W (/ W (length colors)))] [c colors])
(send* dc (set-brush c 'solid) (draw-rectangle x 0 W H))))
(define full-frame%
(class frame%
(define/override (on-subwindow-char r e)
(when (eq? 'escape (send e get-key-code))
(send this show #f)))
(super-new
[label "Color bars"] [width W] [height H]
[style '(no-caption no-resize-border hide-menu-bar no-system-menu)])
(define c (new canvas% [parent this] [paint-callback paint-pinstripe]))
(send this show #t)))
(void (new full-frame%))
Raku
(formerly Perl 6)
my ($x,$y) = 1280, 720;
my @colors = map -> $r, $g, $b { Buf.new: |(($r, $g, $b) xx $x div 8) },
0, 0, 0,
255, 0, 0,
0, 255, 0,
0, 0, 255,
255, 0, 255,
0, 255, 255,
255, 255, 0,
255, 255, 255;
my $img = open "colorbars.ppm", :w orelse die "Can't create colorbars.ppm: $_";
$img.print: qq:to/EOH/;
P6
# colorbars.ppm
$x $y
255
EOH
for ^$y {
for ^@colors -> $h {
$img.write: @colors[$h];
}
}
$img.close;
REXX
Programming note: because of the way the REXX interpreters (being used for this example) ensure screen output fidelity, if ninety characters are displayed on a ninety-byte wide screen, REXX apparently forces an extra blank, causing to what appears to be a blank line after the line displayed. Because of this, the last color bar (_.8) has been shortened by one byte.
/*REXX program displays eight colored vertical bars on a full screen. */
parse value scrsize() with sd sw . /*the screen depth and width. */
barWidth=sw%8 /*calculate the bar width. */
_.=copies('db'x, barWidth) /*the bar, full width. */
_.8=left(_.,barWidth-1) /*the last bar width, less one. */
$ = x2c('1b5b73') || x2c("1b5b313b33376d") /* the preamble, and the header. */
hdr.1 = x2c('1b5b303b33306d') /* " color black. */
hdr.2 = x2c('1b5b313b33316d') /* " color red. */
hdr.3 = x2c('1b5b313b33326d') /* " color green. */
hdr.4 = x2c('1b5b313b33346d') /* " color blue. */
hdr.5 = x2c('1b5b313b33356d') /* " color magenta. */
hdr.6 = x2c('1b5b313b33366d') /* " color cyan. */
hdr.7 = x2c('1b5b313b33336d') /* " color yellow. */
hdr.8 = x2c('1b5b313b33376d') /* " color white. */
tail = x2c('1b5b751b5b303b313b33363b34303b306d') /* " epilogue, and the trailer.*/
/* [↓] last bar width is shrunk. */
do j=1 for 8 /*build the line, color by color. */
$=$ || hdr.j || _.j /*append the color header + bar. */
end /*j*/ /* [↑] color order is the list. */
/* [↓] the tail is overkill. */
$=$ || tail /*append the epilogue (trailer). */
/* [↓] show full screen of bars. */
do k=1 for sd /*SD = screen depth (from above). */
say $ /*have REXX display line of bars. */
end /*k*/ /* [↑] Note: SD could be zero. */
/*stick a fork in it, we're done. */
This REXX program makes use of scrsize REXX program (or BIF) which is used to determine the screen size of the terminal (console).
The SCRSIZE.REX REXX program is included here ──► SCRSIZE.REX.
output appears identical to the output for Icon and Unicon, Mathematica, and R examples.
Ring
load "guilib.ring"
new qapp
{
win1 = new qwidget() {
setwindowtitle("drawing using qpainter")
setwinicon(self,"C:\Ring\bin\image\browser.png")
setgeometry(100,100,500,600)
label1 = new qlabel(win1) {
setgeometry(10,10,400,400)
settext("")
}
new qpushbutton(win1) {
setgeometry(200,400,100,30)
settext("draw")
setclickevent("draw()")
}
show()
}
exec()
}
func draw
p1 = new qpicture()
color = new qcolor() {
setrgb(0,0,255,255)
}
pen = new qpen() {
setcolor(color)
setwidth(1)
}
new qpainter() {
begin(p1)
setpen(pen)
//Black, Red, Green, Blue, Magenta, Cyan, Yellow, White
for n = 1 to 8
color2 = new qcolor(){
switch n
on 1 r=0 g=0 b=0
on 2 r=255 g=0 b=0
on 3 r=0 g=255 b=0
on 4 r=0 g=0 b=255
on 5 r=255 g=0 b=255
on 6 r=0 g=255 b=255
on 7 r=255 g=255 b=0
on 8 r=255 g=255 b=255
off
setrgb(r,g,b,255)
}
mybrush = new qbrush() {setstyle(1) setcolor(color2)}
setbrush(mybrush)
drawrect(n*25,25,25,70)
next
endpaint()
}
label1 { setpicture(p1) show() }
Output : Colour bars
Ruby
JRubyArt is a port of Processing to the ruby language
# Array of web colors black, red, green, blue, magenta, cyan, yellow, white
PALETTE = %w[#000000 #ff0000 #00ff00 #0000ff #ff00ff #00ffff #ffffff].freeze
def settings
full_screen
end
def setup
PALETTE.each_with_index do |col, idx|
fill color(col)
rect(idx * width / 8, 0, width / 8, height)
end
end
Rust
renders into a borderless fullscreen window on the primary display. press ESC to close
use pixels::{Pixels, SurfaceTexture}; // 0.2.0
use winit::event::*; // 0.24.0
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::{Fullscreen, WindowBuilder};
fn main() {
let event_loop = EventLoop::new();
let window = WindowBuilder::new()
.with_title("Colour Bars")
.with_decorations(false)
.with_fullscreen(Some(Fullscreen::Borderless(None)))
.build(&event_loop).unwrap();
let size = window.inner_size();
let texture = SurfaceTexture::new(size.width, size.height, &window);
let mut image_buffer = Pixels::new(8, 1, texture).unwrap();
let frame = image_buffer.get_frame();
frame.copy_from_slice(&[
0x00, 0x00, 0x00, 0xFF, // black
0xFF, 0x00, 0x00, 0xFF, // red
0x00, 0xFF, 0x00, 0xFF, // green
0x00, 0x00, 0xFF, 0xFF, // blue
0xFF, 0x00, 0xFF, 0xFF, // magenta
0x00, 0xFF, 0xFF, 0xFF, // cyan
0xFF, 0xFF, 0x00, 0xFF, // yellow
0xFF, 0xFF, 0xFF, 0xFF, // white
]);
image_buffer.render().unwrap();
event_loop.run(move |ev, _, flow| {
match ev {
Event::WindowEvent {
event: WindowEvent::KeyboardInput { input, .. }, ..
} => {
if input.virtual_keycode == Some(VirtualKeyCode::Escape) {
*flow = ControlFlow::Exit;
}
}
Event::RedrawRequested(_) | Event::WindowEvent {
event: WindowEvent::Focused(true), ..
} => {
image_buffer.render().unwrap();
}
_ => {}
}
});
}
Scala
import java.awt.Color
import scala.swing._
class ColorBars extends Component {
override def paintComponent(g:Graphics2D)={
val colors=List(Color.BLACK, Color.RED, Color.GREEN, Color.BLUE, Color.MAGENTA, Color.CYAN, Color.YELLOW, Color.WHITE)
val colCount=colors.size
val deltaX=size.width.toDouble/colCount
for(x <- 0 until colCount){
val startX=(deltaX*x).toInt
val endX=(deltaX*(x+1)).toInt
g.setColor(colors(x))
g.fillRect(startX, 0, endX-startX, size.height)
}
}
}
Open window:
new MainFrame(){
title="Color bars"
visible=true
preferredSize=new Dimension(640, 320)
contents=new ColorBars()
}
Sidef
require('GD');
var colors = Hash.new(
white => [255, 255, 255],
red => [255, 0, 0],
green => [0, 255, 0],
blue => [0, 0, 255],
magenta => [255, 0, 255],
yellow => [255, 255, 0],
cyan => [0, 255, 255],
black => [0, 0, 0],
);
var barwidth = 160/8;
var image = %s'GD::Image'.new(160, 100);
var start = 0;
colors.values.each { |rgb|
var paintcolor = image.colorAllocate(rgb...);
image.filledRectangle(start * barwidth, 0, start*barwidth + barwidth - 1, 99, paintcolor);
start++;
};
%f'colorbars.png'.open('>:raw').print(image.png);
Tcl
package require Tcl 8.5
package require Tk 8.5
wm attributes . -fullscreen 1
pack [canvas .c -highlightthick 0] -fill both -expand 1
set colors {black red green blue magenta cyan yellow white}
for {set x 0} {$x < [winfo screenwidth .c]} {incr x 8} {
.c create rectangle $x 0 [expr {$x+7}] [winfo screenheight .c] \
-fill [lindex $colors 0] -outline {}
set colors [list {*}[lrange $colors 1 end] [lindex $colors 0]]
}
UNIX Shell
#!/bin/sh
clear
WIDTH=`tput cols`
HEIGHT=`tput lines`
NUMBARS=8
BARWIDTH=`expr $WIDTH / $NUMBARS`
l="1" # Set the line counter to 1
while [ "$l" -lt $HEIGHT ]; do
b="0" # Bar counter
while [ "$b" -lt $NUMBARS ]; do
tput setab $b
s="0"
while [ "$s" -lt $BARWIDTH ]; do
echo -n " "
s=`expr $s + 1`
done
b=`expr $b + 1`
done
echo # newline
l=`expr $l + 1`
done
tput sgr0 # reset
Uxntal
( uxnasm color-bars.tal color-bars.rom && uxnemu color-bars.rom )
|00 @System &vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1
|20 @Screen &vector $2 &width $2 &height $2 &auto $1 &pad $1 &x $2 &y $2 &addr $2 &pixel $1 &sprite $1
|0100
( set 4 color theme
rgb
color0: 000 - black
color1: f00 - red
color2: 0f0 - green
color3: 00f - blue )
#0f00 .System/r DEO2
#00f0 .System/g DEO2
#000f .System/b DEO2
( store bars width )
.Screen/width DEI2 #0004 DIV2 ,&quarter STR2
( set starting position )
#0000 .Screen/y DEO2
( draw bars )
#00
&loop
#00 OVR [ LIT2 &quarter $2 ] MUL2
.Screen/x DEO2
DUP #80 ORA .Screen/pixel DEO
INC DUP #04 NEQ ?&loop
BRK
Wren
import "graphics" for Canvas, Color
import "dome" for Window
class Game {
static init() {
Window.title = "Color bars"
__width = 400
__height = 400
Canvas.resize(__width, __height)
Window.resize(__width, __height)
var colors = [
Color.hex("000000"), // black
Color.hex("FF0000"), // red
Color.hex("00FF00"), // green
Color.hex("0000FF"), // blue
Color.hex("FF00FF"), // magenta
Color.hex("00FFFF"), // cyan
Color.hex("FFFF00"), // yellow
Color.hex("FFFFFF") // white
]
drawBars(colors)
}
static drawBars(colors) {
var w = __width / colors.count
var h = __height
for (i in 0...colors.count) {
Canvas.rectfill(w*i, 0, w, h, colors[i])
}
}
static update() {}
static draw(dt) {}
}
XPL0
include c:\cxpl\codes; \intrinsic code declarations
int W, X0, X1, Y, C;
[SetVid($13); \320x200x8 graphics
W:= 320/8; \width of color bar (pixels)
for C:= 0 to 8-1 do
[X0:= W*C; X1:= X0+W-1;
for Y:= 0 to 200-1 do
[Move(X0, Y); Line(X1, Y, C)];
];
C:= ChIn(1); \wait for keystroke
SetVid(3); \restore normal text mode
]
- Programming Tasks
- Solutions by Programming Task
- 6502 Assembly
- Action!
- ActionScript
- Ada
- SDLAda
- AutoHotkey
- GDI+
- AWK
- BASIC
- AmigaBASIC
- Applesoft BASIC
- BBC BASIC
- Chipmunk Basic
- Commodore BASIC
- FreeBASIC
- FutureBasic
- Gambas
- IS-BASIC
- Liberty BASIC
- Locomotive Basic
- PureBasic
- Run BASIC
- SmileBASIC
- TI Basic
- ZX Spectrum Basic
- Befunge
- C
- C++
- COBOL
- Common Lisp
- Ncurses
- Delphi
- Winapi.Windows
- System.SysUtils
- System.Classes
- Vcl.Graphics
- Vcl.Forms
- EasyLang
- Factor
- Forth
- Go
- Go Graphics
- Haskell
- Icon
- Unicon
- Icon Programming Library
- J
- Java
- Julia
- Kotlin
- Lua
- Nw
- Cairo
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- Nim
- Gintro
- OCaml
- Perl
- Phix
- Phix/pGUI
- PHP
- PicoLisp
- Plain English
- PowerShell
- Processing
- Python
- R
- Racket
- Raku
- REXX
- Ring
- Ruby
- RubyGems
- JRubyArt
- Rust
- Winit
- Pixels
- Scala
- Sidef
- Tcl
- Tk
- UNIX Shell
- Uxntal
- Pages with broken file links
- Wren
- DOME
- XPL0
- Axe/Omit
- GUISS/Omit
- Minimal BASIC/Omit
- Test card
- Terminal control