Colour bars/Display: Difference between revisions

=={{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.

tax

tay ;clear regs

jmp loop

exit:

=={{header|Action!}}==

BYTE

i,

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Colour_bars_display.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

package {

}

=={{header|Ada}}==

{{libheader|SDLAda}}

with SDL.Video.Renderers.Makers;

with SDL.Video.Palettes;

Window.Finalize;

SDL.Finalise;

=={{header|AutoHotkey}}==

{{libheader|GDI+}} (available at http://www.autohotkey.net/~tic/Gdip.ahk)

#NoEnv

SetBatchLines, -1

Gdip_Shutdown(pToken)

ExitApp

=={{header|AWK}}==

BEGIN {

nrcolors = 8

}

}

=={{header|BASIC}}==

==={{header|AmigaBASIC}}===

WINDOW 2,"Color bars",(0,10)-(297,186),15,1

FOR a=0 TO 300

LINE (a,0)-(a,186),(a+10)/10

NEXT

==={{header|Applesoft BASIC}}===

2 HOME : GR : FOR I = 1 TO 7

3 READ C(I) : NEXT

4 FOR I = 0 TO 39

5 COLOR= C(I / 5)

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

{{works with|BBC BASIC for Windows}}

SYS "ShowWindow", @hwnd%, SW_MAXIMIZE

VDU 26

RECTANGLE FILL C%*W%, 0, W%, H%

NEXT

==={{header|Commodore BASIC}}===

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.

10 print chr$(147);:dim co(17):c=1

20 read co(c):if co(c)>0 then c=c+1:goto 20

305 rem omit or rem the next line for vic-20

310 data 129,149,150,151,152,153,154,155

==={{header|Liberty BASIC}}===

colors$="black red green blue pink cyan yellow white"

WindowWidth=DisplayWidth:WindowHeight=DisplayHeight

wait

[quit] close #main:end

==={{header|Locomotive Basic}}===

Show the default MODE 0 palette (includes two blinking colors at the end):

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

==={{header|PureBasic}}===

Press Enter or Escape to exit the program.

color(0) = RGB($00, $00, $00) ;black

color(1) = RGB($FF, $00, $00) ;red

Until KeyboardPushed(#PB_Key_Escape) Or KeyboardPushed(#PB_Key_Return)

CloseScreen()

====Alternate method using console====

;Black, Red, Green, Blue, Magenta, Cyan, Yellow, White

Data.i 0, 12, 10, 9, 13, 11, 14, 15

ConsoleTitle("Press ENTER to exit"): Input()

CloseConsole()

==={{header|Run BASIC}}===

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

<pre>Output</pre>

==={{header|ZX Spectrum Basic}}===

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

60 NEXT c

70 REM at this point the cursor has wrapped, so we don't need a newline

=={{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.

v_:"P"/"["39*,, :55+/68v

v,,,";1H" ,+*86%+55 ,+*<

73654210v,,\,,,*93"[4m"<

>$:55+%#v_:1-"P"%55+/3g^

=={{header|C}}==

===Text Mode===

The required functions and structures are in conio.h

#include<conio.h>

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>

return 0;

}

=={{header|C++}}==

file <code>colorbars.h</code>:

#define MYWIDGET_H

#include <QWidget>

const int colornumber ;

} ;

file <code>colorbars.cpp</code>:

#include "colorbars.h"

xstart += rectwidth + 1 ;

}

file <code>main.cpp</code>:

#include "colorbars.h"

window.show( ) ;

return app.exec( ) ;

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. terminal-colour-bars.

GOBACK

=={{header|Common Lisp}}==

==={{header|ncurses}}===

To interface the ncurses C library from Lisp, the ''croatoan'' library is used.

(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)

(dotimes (i (height scr))

(refresh scr)

;; wait for keypress

=={{header|Delphi}}==

{{libheader| Winapi.Windows}}

{{libheader| Vcl.Graphics}}

{{libheader| Vcl.Forms}}

unit Colour_barsDisplay;

Invalidate;

end;

Form resource:

object fmColourBar: TfmColourBar

Caption = 'fmColourBar'

OnResize = FormResize

end

=={{header|EasyLang}}==

[https://easylang.online/apps/_color_bars.html Run it]

w = 100.0 / len col[]

for i range len col[]

move w * i 0

rect w 100

=={{header|Factor}}==

ui.gadgets ui.gadgets.tracks ui.pens.solid ;

IN: rosetta-code.colour-bars-display

"bars" open-window

] with-ui ;

=={{header|Forth}}==

<br> The color bars are shown in Society of Motion Picture and Television Engineers (SMPTE) order.

\ Color Bars for TI-99 CAMEL99 Forth

=={{header|FreeBASIC}}==

' Draw the color bars on an 80 x 25 console using the system palette of 16 colors

' restore default settings

Locate ,, 1 '' turn cursor on

=={{header|Gambas}}==

Dim iColour As Integer[] = [Color.Black, Color.red, Color.Green, Color.Magenta, Color.Cyan, Color.Yellow, Color.white]

Dim hPanel As Panel

Next

=={{header|Go}}==

{{libheader|Go Graphics}}

import "github.com/fogleman/gg"

drawBars(dc)

dc.SavePNG("color_bars.png")

{{out}}

Terminal-based version.

-- stack --resolver lts-7.0 --install-ghc runghc --package vty -- -threaded

_ -> return ()

showBars bounds

Graphical version using SFML.

-- the CSFML C library. (For example, "brew install csfml" on OS X.)

withResource (createRenderWindow vMode "color bars" wStyle Nothing) $

\wnd -> withResources (mapM (makeBar $ barSize vMode) $ zip colors [0..]) $

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

The procedure below is generalized to take a description of a ''test card'' and display it.

[[File:Colourbars_Simple_Unicon.png|thumb|right]]

procedure main() # generalized colour bars

bar(width) ] ),

band(height) ])

The following example is a wee tiny bit more interesting.

[[File:Colourbars_SMPTE_Unicon.png|thumb|right]]

return testcard(,"SMPTE TV Test Card",width := 672,height := 504,

[ band( 1, [ bar( 1, "#c0c0c0"),

bar(width) ] ),

band(height) ])

{{libheader|Icon Programming Library}}

=={{header|J}}==

size=: 2{.".wd'qm' NB. J6

size=: getscreenwh_jgtk_ '' NB. J7

Note: You need to pick an implementation of <code>size</code> based on the version of J you are using.

=={{header|Java}}==

import java.awt.Color;

import java.awt.Graphics;

}

}

=={{header|Julia}}==

{{works with|Julia|0.6}}

colors = [colorant"black", colorant"red", colorant"green", colorant"darkblue",

img[:, j:j+wcol] = col

end

=={{header|Kotlin}}==

{{trans|Java}}

import java.awt.Graphics

import javax.swing.JFrame

fun main(args: Array<String>) {

ColorFrame(400, 400)

Editing Babbage problem

{{libheader|nw}}

{{libheader|cairo}}

local app = nw:app()

local cw, ch = 320, 240

end

win:show()

=={{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.

Module Checkit {

Module Bars {

}

Checkit

=={{header|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)])

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

ConstantArray[{Black, Red, Green, Blue, Magenta, Cyan, Yellow,

[[File:ColourBarsMathematica.png]]

=={{header|Nim}}==

{{libheader|gintro}}

const

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

discard app.connect("activate", activate)

=={{header|OCaml}}==

let round x =

) colors;

ignore (read_key ());

execute with:

=={{header|Perl}}==

use strict ;

use GD ;

binmode DISPLAY ;

print DISPLAY $image->png ;

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

<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>

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

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{header|PHP}}==

{{trans|Perl}}

Will output result directly to the browser. Use it as CGI/BIN script.

$colors = array(array( 0, 0, 0), // black

array(255, 0, 0), // red

header('Content-type:image/png');

imagepng($image);

Alternately, with HTML output:

$colors = array(

"000000", // black

echo '<td style="background-color: #'.$color.'; height: 100px; width: 20px;"></td>';

}

=={{header|PicoLisp}}==

{{trans|UNIX Shell}}

(let Width (in '(tput cols) (read))

(prinl) ) )

=={{header|Plain English}}==

Start up.

Clear the screen.

Draw the bar using the cyan color and move it over.

Draw the bar using the yellow color and move it over.

=={{header|PowerShell}}==

[string[]]$colors = "Black" , "DarkBlue" , "DarkGreen" , "DarkCyan",

"DarkRed" , "DarkMagenta", "DarkYellow", "Gray",

Write-Host

}

=={{header|Processing}}==

noStroke();

color[] cs = {

fill(cs[i]);

rect(i*width/8,0,width/8,height);

=={{header|Python}}==

#!/usr/bin/env python

#vertical coloured stripes in window in Python 2.7.1

end_graphics()

=={{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]]

pal <- c("black", "red", "green", "blue", "magenta", "cyan", "yellow", "white")

par(mar = rep(0, 4))

image(matrix(1:8), col = pal, axes = FALSE)

=={{header|Racket}}==

#lang racket/gui

(void (new full-frame%))

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2018.10}}

my @colors = map -> $r, $g, $b { Buf.new: |(($r, $g, $b) xx $x div 8) },

}

=={{header|REXX}}==

Programming note: &nbsp; because of the way the REXX interpreters &nbsp; (being used for this example) &nbsp; ensure screen output fidelity, &nbsp; if ninety characters are displayed on a ninety-byte wide screen, &nbsp; REXX apparently forces an extra blank, &nbsp; causing to what appears to be a blank line after the line displayed. &nbsp; Because of this, &nbsp; the last color bar &nbsp; ('''_.8''') &nbsp; has been shortened by one byte.

parse value scrsize() with sd sw . /*the screen depth and width. */

barWidth=sw%8 /*calculate the bar width. */

say $ /*have REXX display line of bars. */

end /*k*/ /* [↑] Note: SD could be zero. */

This REXX program makes use of &nbsp; '''scrsize''' &nbsp; REXX program (or BIF) which is used to determine the screen size of the terminal (console).

=={{header|Ring}}==

load "guilib.ring"

}

label1 { setpicture(p1) show() }

Output :

[https://lh3.googleusercontent.com/-_y0FSmg0NAs/V1xBPvGV2tI/AAAAAAAAAKk/TXYSJnpdZ346aQLd05yE9vLM8V9lEht1QCLcB/s1600/CalmoSoftColourBars.jpg Colour bars]

{{libheader|JRubyArt}}

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

end

end

=={{header|Rust}}==

{{libheader|pixels}}

renders into a borderless fullscreen window on the primary display. press ESC to close

use winit::event::*; // 0.24.0

use winit::event_loop::{ControlFlow, EventLoop};

}

});

=={{header|Scala}}==

import scala.swing._

}

}

Open window:

[[File:colorbars_scala.png|thumb|right]]

title="Color bars"

visible=true

preferredSize=new Dimension(640, 320)

contents=new ColorBars()

=={{header|Sidef}}==

{{trans|Perl}}

var colors = Hash.new(

};

=={{header|SmileBASIC}}==

READ R,G,B

GFILL I*50,0,I*50+49,239,RGB(R,G,B)

DATA 0,255,255

DATA 255,255,0

=={{header|Tcl}}==

{{libheader|Tk}}

package require Tk 8.5

-fill [lindex $colors 0] -outline {}

set colors [list {*}[lrange $colors 1 end] [lindex $colors 0]]

=={{header|UNIX Shell}}==

clear

WIDTH=`tput cols`

done

=={{header|Wren}}==

{{trans|Go}}

{{libheader|DOME}}

import "dome" for Window

static draw(dt) {}

=={{header|XPL0}}==

int W, X0, X1, Y, C;

[SetVid($13); \320x200x8 graphics

C:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

{{omit from|Axe}}