Colour bars/Display: Difference between revisions

::::::*   white

<br>

 

=={{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|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 task achieved only on Commodore computers with color capabilities. The example below tested as-is in VICE on the following machines:

* Commodore 64

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

 

 

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

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

WindowWidth=DisplayWidth:WindowHeight=DisplayHeight

wait

[quit] close #main:end

 

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

[[File:CPC color bars.png|thumb|right]]

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

20 FOR x=0 TO 15

30 ORIGIN x*40,0

 

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

 

[[File:ColorBarRunBasic.png]]

 

==={{header|TI Basic}}===

110 REM with 400 Hz reference tone

120 CALL CLEAR

540 NEXT I

590 RETURN

 

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

 

 

 

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

 

 

CR .( Done. Type BARS to run)

 

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

 

where attrs = map color2attr colors

nBars = length colors

color2attr c = Attr Default Default (SetTo c)

 

main = do

cfg <- standardIOConfig

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

 

=={{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|OCaml}}==

 

 

let round x =

) colors;

ignore (read_key ());

 

execute with:

 

=={{header|Perl}}==

 

$image->filledRectangle( $start * $barwidth , 0 , $start * $barwidth +

$start++ ;

}

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

 

=={{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|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|Tcl}}==

{{libheader|Tk}}

package require Tk 8.5

 

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

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

 

clear

WIDTH=`tput cols`

done

 

 

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

{{omit from|GUISS}}

 

[[Category:Test card]]