Draw a clock: Difference between revisions

 

=={{header|ActionScript}}==

package {

 

}

 

=={{header|Ada}}==

{{libheader|SDLAda}}

with Ada.Calendar.Formatting;

with Ada.Calendar.Time_Zones;

Window.Finalize;

SDL.Finalise;

 

=={{header|AutoHotkey}}==

this code from http://www.autohotkey.com/forum/viewtopic.php?p=231836#231836

draws a very nice clock with GDI+

; Parts based on examples from Tic's GDI+ Tutorials and of course on his GDIP.ahk

 

Gdip_Shutdown(pToken)

ExitApp

 

=={{header|AWK}}==

# syntax: GAWK -f DRAW_A_CLOCK.AWK [-v xc="*"]

BEGIN {

}

}

{{out|Sample run and output}}

<pre>

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

 

CIRCLE (xp,yp),size,,,,.5

lasth=0:lastm=0:lasts=0

LINE (xp,yp)-(xp+2*ms*SIN(lastm),yp-ms*COS(lastm)),1

LINE (xp,yp)-(xp+2*ss*SIN(lasts),yp-ss*COS(lasts)),2

 

==={{header|BaCon}}===

Using GTK3 as a graphical toolkit.

PRAGMA GUI gtk3

 

 

ENDSUB

 

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

CLS

xp=320:yp=160:size=150

LINE xp, yp, xp+2*ss*SIN(lasts), yp+ss*COS(lasts)

ENDPROC

 

 

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

To be entered in upper/lowercase mode but run in uppercase + graphics mode.

20 ti$ = "123456"

25 rem do some other stuff after this line

1540 z$(4) = "B B B B B B BB BB B B"

1550 z$(5) = "JCKCCCJCCCCK BCCKJCKJCK CK"

 

==={{header|IS-BASIC}}===

110 OPTION ANGLE DEGREES

120 LET CH=1:LET CH2=2

290 CLOSE #2

300 CLOSE #1

 

=={{header|Batch File}}==

::Batch File Implementation

::

echo.

timeout /t 1 /nobreak >nul

{{Out}}

<pre>

=={{header|C}}==

Draws a crude clock in terminal. C99, compiled with <code>gcc -std=c99</code>.

#include <stdlib.h>

#include <math.h>

draw(s);

return 0;

===Clock in xlib (for X windows)===

 

// # Makefile

}

 

 

=={{header|C sharp|C#}}==

using System.Drawing;

using System.Drawing.Drawing2D;

Application.Run(new Clock());

}

 

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

[[File:clock_cpp.png]]

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

 

=={{header|ContextFree}}==

startshape START

 

}

 

 

=={{header|Delphi}}==

Form application

 

unit main;

 

end.

 

 

Resources:

object Clock: TClock

Left = 0

end

end

 

 

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

 

#

func draw hour min sec . .

timer 0.1

.

 

=={{header|F_Sharp|F#}}==

 

let numberTemplate = """

System.Console.ReadLine() |> ignore // Until return is hit

showTime ()

{{out}}

<pre> _ _ _ _ __

3. Assumes a 16 bit CPU.<BR>

4. Assumes big-endian memory organization.<BR>

HEX

8379 CONSTANT TICKER \ address of 1/60 second counter

?TERMINAL

UNTIL

 

=={{header|Fortran}}==

Uses system commands to clear the screen, sleep and obtain time

 

!Digital Text implemented as in C version - Anant Dixit (Oct, 2014)

program clock

 

end subroutine

 

Preview:

 

=={{header|FreeBASIC}}==

' compile with: fbc -s gui

 

ImageDestroy(clockdial)

 

 

=={{header|FunL}}==

 

 

val ROW = 10

 

if not $os.startsWith( 'Windows' )

 

{{out}}

 

=={{header|Go}}==

 

import (

y := float64(radius) * math.Sin(theta)

return int(x) + 256, int(y) + 256

The following html file, 'clock.html', should be in the same folder as the wsclock binary.

<meta charset="utf-8" />

<title>Clock</title>

</body>

 

=={{header|GUISS}}==

 

 

 

=={{header|Haskell}}==

{{libheader|ansi-terminal}}

import Data.List

import System.Time

setCursorColumn 0

cursorUp 5

Output:<pre> ██ ██████ ██████ ██████ ██████ ██████

██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██

1. Clock using conventional Graphics

 

link graphics

 

end

 

 

2. Clock using Turtle Graphics

link graphics, turtle

 

draw("r", xsize/2 * 0.25, 8 * xsize / 800, ws - 180)

end

 

=={{header|J}}==

Graphical clock (tested on jqt -- j903):

 

require'gl2'

coinsert 'jgl2'

pshow;

}}

 

Some alternatives:

 

Note'rudimentary 4 second clock'

advances an arrow at roughly 1 second intervals,

 

tic=: (>. draw Pass_y <.) ([: seconds 0 $ delay@1:)

The result of 3.18... is the session time at which the example began.

<pre>

Here's a graphical variant (caution: this update mechanism fails on newer J implementations, partially because of version drift in the underlying Qt mechanisms and how those shortcomings have resulted in interface changes):

 

N=:0.01*i.629

O=: [: j./ 1 2 o./ ]

delay=:6!:3 NB. "sleep"

clock=: [: plot (O N),N*/~0.07 0.11 0.15(*O) 2r24p1 2r60p1 2r60p1*_3{.6!:0 bind ''

 

=={{header|Java}}==

{{works with|Java|8}}

import java.awt.event.*;

import static java.lang.Math.*;

});

}

 

=={{header|JavaScript}}==

Tested on Gecko. Put the following in a &lt;script> tag somewhere, and call <code>init_clock()</code> after body load.

function update_clock() {

var t = new Date();

 

window.setInterval(update_clock, 200);

 

=== digital ===

<html lang="en">

<head>

 

</body>

 

=={{header|Julia}}==

using Gtk, Colors, Graphics, Dates

 

sleep(1.0)

end

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

f.isVisible = true

}

 

=={{header|Lambdatalk}}==

The {watch} expression displays three thick arc of circles, red for hours, green for minutes and blue for seconds, growing from 0° to 360° according to the time, and the full date inside following this format yyy/mm/dd hh:mm:ss. The output can be seen in http://lambdaway.free.fr/lambdawalks/?view=watch

 

1) lambdatalk code

{watch} // displays the watch

};

}

 

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

LB has a timer to call a routine at regular intervals. The example is a cut-down version of the full clock supplied with LB as an example.

WindowWidth =120

WindowHeight =144

 

end

 

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

Because the Amstrad CPC does not have an RTC, we first have to ask the user for the current time. The seconds hand is drawn in XOR ink mode so that it can be removed without affecting the other hands.

 

20 input "Current time (HH:MM)";t$

30 h=val(mid$(t$,1,2))

440 if a>0 then frame:move 0,0:draw .8*r*sin(a-6),.8*r*cos(a-6),3,1

450 frame:move 0,0:draw .8*r*sin(a),.8*r*cos(a),3,1

 

=={{header|Lua}}==

 

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

 

=={{header|MATLAB}} / {{header|Octave}}==

 

while(1)

s = mod(now*60*24,1)*2*pi;

plot([0,sin(s)],[0,cos(s)],'-',sin(u),cos(u),'k-');

pause(1);

 

=={{header|MiniScript}}==

This solution works with [https://miniscript.org/MiniMicro Mini Micro], and uses its default SpriteDisplay.

 

gfx.clear color.clear

gfx.fillPoly [[60,5], [64,10], [128,5], [64,0]], color.yellow

hand.rotation = 90 - floor(time) % 60 * 6

wait

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols binary

 

repaint()

return

 

=={{header|Nim}}==

==={{header|Text}}===

{{trans|Raku}}

 

const

for c in x: stdout.write b[c.ord - '0'.ord]

echo ""

 

==={{header|Using SDL}}===

{{libheader|SDL2}}

 

import sdl2, times, math

 

destroy render

 

=={{header|OCaml}}==

Using only the standard library of OCaml with its [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Graphics.html Graphics] module:

 

#load "unix.cma"

#load "graphics.cma"

in

try loop ()

 

 

unix.cmxa lablgtk.cmxa cairo.cmxa cairo_lablgtk.cmxa gtkInit.cmx gtkclock.ml

 

let angle v max = float v /. max *. 2.0 *. pi

 

animate area;

w#show ();

 

=={{header|ooRexx}}==

<br>https://www.dropbox.com/sh/h0dycdshv04c5lz/5oHFfI3t14?n=132389230

<br>It runs nicely on Windows 7 with ooRexx installed.

* 09.02.2014 Walter Pachl with a little, well considerable, help from

* a friend (Mark Miesfeld)

Parse Arg x,y

If y=0 Then Return '??'

 

===version 2 runs under Windows, Linux, and MacOSX===

A screenshot of this clock can be seen on my dropbox (clocka.jpg)

<br>https://www.dropbox.com/sh/h0dycdshv04c5lz/5oHFfI3t14?n=132389230

Name: clock.rxj

Purpose: create a graphical clock that shows the current time

::method actionPerformed -- this event will be caused every second by the swing Timer

use arg eventObj, slotDir

[[out}}

<pre>... [2017-01-26T17:17:51.527000] Rexx main program, now waiting until JFrame gets closed ...

=={{header|Perl}}==

{{trans|Raku}}

binmode STDOUT, ':utf8'; # allow printing wide chars without warning

$|++; # disable output buffering

 

sub clear { print "\e[H\e[J" }

 

{{out}}

Resizeable, appearance similar to Mathematica.

You can run this online [http://phix.x10.mx/p2js/clock.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Clock.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

The distribution also contains demo\tinEWGdemo\tindemo\clock.exw, which is a win32-only digital affair (whereas the above should be fine on 32/64 and win/lnx).

 

=={{header|PicoLisp}}==

(for L Lst

(for X L

(bigBox (% (cadr Time) 5))

(draw (+ (10 . -) + (10 . -) + (10 . -) + (10 . -) +)) )

<pre> _____

/ \

This simple example of an analog wall clock uses the Processing built-in time functions second(), minute(), and hour(). For each hand it rotates the sketch canvas and then draws a straight line.

 

drawClock();

}

strokeWeight(4);

line(0, 0, 0, -width*0.2);

 

The sketch redraws at Processing's default 60fps. To redraw the screen only when the second hand changes, add a global variable and change draw() as follows:

 

void draw() {

if (lastSec!=second()) {

lastSec=second();

}

 

One of the official Processing language examples is a more graphically detailed [https://processing.org/examples/clock.html Clock example].

 

==={{header|Processing Python mode}}===

last_sec = second()

 

rotate(-m + h)

strokeWeight(4)

 

=={{header|PureBasic}}==

[[File:PureBasic_Clock.png|thumb|Sample display of PureBasic solution]]

#MiddleY = #MiddleX

#len_sh = (#MiddleX - 8) * 0.97 ;length of second-hand

SetGadgetState(#clock_gad, ImageID(#clockFace_img))

EndIf

 

=={{header|Python}}==

===Textmode===

 

 

def chunks(l, n=5):

print bin_bit(y[1])

print

 

==={{libheader|VPython}}===

Draws an analog clock in a new GUI window:

 

#lang racket/gui

 

 

(send f show #t)

 

=={{header|Raku}}==

(formerly Perl 6)

my $v = floor $rows / 2;

my $h = floor $cols / 2 - 16;

print "\e[H";

sleep 1;

{{out}}

<pre>⠀⢺⠀ ⢀⠔⡇ ⠀⠶⠀ ⠊⠉⡱ ⠊⣉⡱ ⠀⠶⠀ ⣏⣉⡉ ⡎⢉⢵

=={{header|Red}}==

===Minimalistic===

view [t: h4 rate 1 on-time [t/data: now/time]]

{{out}}

[https://raw.githubusercontent.com/Palaing/redlib/master/games/images/miniclock.png mini clock image]

 

===Analog===

Needs: 'View

Purpose: {simple analog clock based on Nenad Rakocevic's eve-clock.red,

sec/2: 6 * time/second

]]

{{out}}

[https://raw.githubusercontent.com/Palaing/redlib/master/games/images/analogclock.png analog clock image]

:::* &nbsp; '''ROO'''

the color of the display can be specified.

trace off /*turn off tracing/possible host errors*/

parse arg ! /*obtain optional arguments from the CL*/

noValue: !sigl= sigl; call er 17,!fid(2) !fid(3) !sigl condition('D') sourceline(!sigl)

p: return word( arg(1), 1)

;Programming notes:

The &nbsp; '''$CLOCK.REX''' &nbsp; REXX program makes use of &nbsp; '''$T.REX''' &nbsp; REXX program which is used to display text and/or create big blocked characters.

{{libheader|Shoes}}

[[File:shoes_clock.png|thumb|Sample display of Ruby solution]]

def draw_ray(width, start, stop, ratio)

angle = Math::PI * 2 * ratio - Math::PI/2

 

animate(5) {update}

 

Inspired by the PicoLisp solution, here's an implementation of the Berlin-Uhr clock.

[[File:berlin_uhr.rb.png|thumb|Berlin-Uhr clock]]

background lightgrey

 

end

end

 

{{libheader|RubyGems}}

{{libheader|JRubyArt}}

JRubyArt is port of processing to ruby

def setup

sketch_title 'Clock'

end

 

 

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

[[File:Rb_clock.png|thumb|Sample display of RB solution]]

' clock. I got nothing but time

' ---------------------------------------------

#g2 circle(2)

#g2 line(100,100,px,py)

 

=={{header|Rust}}==

extern crate time;

 

fn clear_screen() {

println!("{}[H{}[J", 27 as char, 27 as char);

 

=={{header|Scala}}==

===Circular ASCII clock===

Generates and prints a simple ASCII clock every second

import java.time.LocalTime

import scala.math._

}

(new Timer).schedule(timerTask, 0, 1000)

===Berliner Uhr===

See [[http://en.wikipedia.org/wiki/Mengenlehreuhr The Berlin set theory clock]]

import java.awt.{ Color, Graphics }

 

}

}

 

=={{header|Scheme}}==

The program displays an analogue clock with three hands, updating once a second.

 

(import (scheme base)

(scheme inexact)

(hands canvas))

(tk-event-loop tk))

 

=={{header|Scratch}}==

=={{header|Seed7}}==

The example program clock3.sd7 from the Seed7 package can be used for this task.

include "float.s7i";

include "math.s7i";

command := busy_getc(KEYBOARD);

end while;

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var (rows, cols) = `stty size`.nums...

print position(1, 1)

Sys.sleep(0.1)

{{out}}

<pre>

 

=={{header|SVG}}==

<circle cx="50" cy="50" r="48" style="fill:peru; stroke:black; stroke-width:2" />

<g transform="translate(50,50) rotate(0)" style="fill:none; stroke-linecap:round">

<circle cx="50" cy="50" r="4" style="fill:gold; stroke:black; stroke-width:1" />

</svg>

 

=={{header|Tcl}}==

[[File:Clock tcltk.png|thumb|Sample display of Tcl solution]]

{{libheader|Tk}}

package require Tk

 

}

}

Note that though this code does poll the system timer approximately four times a second, this is a cheap operation; the GUI update (the relatively expensive part) only happens once a second. The amount of system processing power consumed by this code isn't noticeable on my system; it vanishes with respect to the other processing normally happening.

 

=={{header|VBScript}}==

The only way to do animation in VBScript is to use ANSI codes in the console. The program will work only in Windows 10 or up. Should be invoked from cscript

'ANSI Clock

 

wend

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

import "math" for Math

}

 

 

=={{header|Yabasic}}==

open window 300,100

backcolor 0, 0, 0

until(upper$(inkey$(.01))="ESC")

exit

 

=={{header|zkl}}==

{{trans|Nim}}

t=T("⡎⢉⢵","⠀⢺⠀","⠊⠉⡱","⠊⣉⡱","⢀⠔⡇","⣏⣉⡉","⣎⣉⡁","⠊⢉⠝","⢎⣉⡱","⡎⠉⢱","⠀⠶⠀"),

b=T("⢗⣁⡸","⢀⣸⣀","⣔⣉⣀","⢄⣀⡸","⠉⠉⡏","⢄⣀⡸","⢇⣀⡸","⢰⠁⠀","⢇⣀⡸","⢈⣉⡹","⠀⠶ ");

println(x.pump(String,t.get),"\n",x.pump(String,b.get));

Atomic.sleep(1);

{{out}}

<pre>

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

Chapter 18 of the BASIC manual supplied with the ZX Spectrum includes two programs to implement a clock - each uses different timing methods. The first - using a PAUSE command to hold for a second - is far less accurate, while the second - reading the three-byte system frames counter - is more CPU hungry (since ZX Spectrum Basic can't multitask, this doesn't really matter). With a tweak, the second is shown below.

20 FOR n=1 TO 12

30 PRINT AT 10-10*COS (n/6*PI),16+10*SIN (n/6*PI);n

210 IF INT t<=INT t1 THEN GO TO 200: REM wait for time for next hand; the INTs were not in the original but force it to wait for the next second

220 PLOT 131,91: DRAW OVER 1;sx,sy: REM rub out old hand

 

{{omit from|ACL2|No access to system time}}