Animation: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* Programme assembleur ARM Raspberry ou Android */

/* programme animletter64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

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

BYTE i

CRSINH=0 ;show cursor

{{out}}

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

=={{header|ActionScript}}==

var textBox:TextField = new TextField();

addChild(textBox);

//event handler to register clicks

textBox.addEventListener(MouseEvent.MOUSE_DOWN, function(){goingRight = !goingRight;});

=={{header|Ada}}==

animation.adb:

with Gtk.Handlers;

with Gtk.Label;

Gtk.Window.Show_All (Widget => Main_Window);

Gtk.Main.Main;

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

20 D = 1: VTAB INT (( PEEK (35) - PEEK (34)) / 2) + 1: FOR R = 1 TO 0 STEP 0

30 HTAB INT (( PEEK (33) - L) / 2) + 1: PRINT MID$ (T$,P,L);

50 IF P < 1 THEN P = L

60 R = PEEK (49152) < 128: FOR I = 1 TO 5:B = PEEK (49249) > 127: IF B < > BO THEN BO = B: IF B = 0 THEN D = - D

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI or android 32 bits with termux application */

/* program animLetter.s */

/***************************************************/

.include "../affichage.inc"

=={{header|AutoHotkey}}==

String := "Hello World "

Gui, Add, Text, vS gRev, %String%

Rev: ; Runs whenever user clicks on the text control

Reverse := !Reverse

=={{header|BASIC256}}==

direction=0 #value of 0: to the right, 1: to the left.

tlx=10 #Top left x

end if

clickclear

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

{{works with|BBC BASIC for Windows}}

txt$ = "Hello World! "

direction% = TRUE

ENDIF

WAIT 20

=={{header|C}}==

{{libheader|GTK}}

(NB: implicitly, through GTK, it uses also Pango library)

#include <string.h>

#include <gtk/gtk.h>

gtk_main();

return 0;

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

using System.Drawing;

using System.Windows.Forms;

}

}

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

{{libheader|Qt}}

Contents of animationwidget.cpp:

#include <QLabel>

void AnimationWidget::mousePressEvent(QMouseEvent*) {

right_ = !right_;

Contents of animationwidget.h:

#define ANIMATIONWIDGET_H

};

Contents of main.cpp:

#include <QApplication>

w.show();

return a.exec();

=={{header|Ceylon}}==

module.ceylon

module animation "1.0.0" {

import java.desktop "8";

}

run.ceylon

JFrame,

JLabel,

frame.pack();

frame.visible = true;

=={{header|Clojure}}==

Clojure is a JVM language so this example uses Swing, and illustrates Clojure's platform integration.

(import '[java.awt.event MouseAdapter])

(.setVisible true))

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

There is no window management in the stock version of BASIC V2 on the Commodore 64 or VIC 20. This example below is generic enough to use on all Commodore variants. Note: Asterisks (*) may be replaced with Commodore graphics characters for a more decorative "window".

1 rem rosetta code

2 rem task: animation

1000 t$=right$(t$,len(t$)-1)+left$(t$,1):return

1010 t$=right$(t$,1)+left$(t$,len(t$)-1):return

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

The ltk package provides a lisp interface to Tk for creating graphical interfaces. Assuming ''ltk'' has been installed somewhere the following will work as per the Tcl example.

{{libheader|Tk}}

(defparameter *message* "Hello World! ")

(ltk:mainloop))))

=={{header|D}}==

{{libheader|SDL_ttf}}

{{libheader|tools}}

import qd, SDL_ttf, tools.time;

) dir = !dir;

}

=={{header|Dart}}==

{{libheader|Flutter}}

view it on dartpad!

import 'dart:async' show Timer;

}

===HTML DOM===

{{libheader|Html Dom}}

import 'dart:async';

}

}

=={{header|Delphi}}==

{{libheader| Winapi.Windows}}

{{libheader| Vcl.StdCtrls}}

{{libheader| Vcl.ExtCtrls}}

unit Main;

Caption := Shift(Caption, Reverse);

end;

Form resource:

object Form1: TForm1

ClientHeight = 132

end

end

=={{header|E}}==

{{works with|E-on-Java}} (Java Swing; tested on Mac OS X 10.5.7)

var text := "Hello World! "

var leftward := false

# Start everything

w.show()

Text-only version (no Java dependency; no clicking, use reverse() and stop() to control):

var text := "Hello World! "

var leftward := false

anim.start()

[def _() { leftward := !leftward; null }, anim.stop]

=={{header|Elm}}==

import Browser

[ text <| rotate message model.time ]

]

=={{header|F Sharp|F#}}==

{{libheader|Windows Presentation Foundation}}

let str = "Hello world! "

button.Content <- str.[i..] + str.[..i-1]

Media.CompositionTarget.Rendering.Add update

=={{header|Factor}}==

ui.gadgets ui.gadgets.labels ui.gestures ;

FROM: models => change-model ;

[ sentence <model> <animated-label> "Rosetta" open-window ] with-ui ;

=={{header|Fantom}}==

using concurrent

using fwt

}

}

=={{header|FBSL}}==

FBSLSETTEXT(ME, "Hello world! ")

END IF

FBSLSETTEXT(ME, caption)

=={{header|FreeBASIC}}==

To exit, push the window's closing cross. (255 + 107 is the combination that is passed to INKEY$ by that button.)

DIM DIRECTION AS BYTE = 0

DIM AS INTEGER X, Y, BTNS

SLEEP 100, 1

=={{header|Gambas}}==

hLabel As Label 'Label needed to display the 'Hello World! " message

hLabel.text = sString 'Display the result

'''[http://www.cogier.com/gambas/Animation.png Click here for image of running code]'''

=={{header|Go}}==

import (

}

}

=={{header|Haskell}}==

Using simple graphics {{libheader|HGL}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Graphics.HGL.Draw.Monad (Graphic, )

import Graphics.HGL.Draw.Text

loop t' d

Run within interpreter GHCi:

=={{header|HicEst}}==

WINDOW(WINdowhandle=wh, Height=1, X=1, TItle="left/right click to rotate left/right, Y-click-position sets milliseconds period")

SUBROUTINE Mouse_callback()

direction = button_type ! 4 == left button up, 8 == right button up

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

The following code uses features exclusive to Unicon.

$include "guih.icn"

w.show_modal ()

end

The following code uses features exclusive to Icon.

link graphics

}

end

=={{header|J}}==

{{works with|J8}}

MESSAGE =: 'Hello World! '

)

{{works with|J6}}

MESSAGE =: 'Hello World! '

)

=={{header|Java}}==

{{libheader|Swing}}

import java.awt.event.MouseEvent;

import java.awt.event.WindowAdapter;

return String.valueOf(rotated);

}

=={{header|JavaScript}} + {{header|HTML}}==

<title>RC: Basic Animation</title>

<script type="text/javascript">

</head> <body onload="animate('target')">

<pre id="target">Hello World! </pre>

=={{header|JavaScript}} + {{header|SVG}}==

width="100" height="40">

<script type="text/javascript">

<rect width="100" height="40" fill="yellow"/>

<text x="2" y="20" onload="animate(this);">Hello World! </text>

=={{header|Julia}}==

{{libheader|Julia/Tk}}

using Tk

windowanim(frameinterval)

{{libheader|Julia/Gtk}}

using Gtk.ShortNames

textanimation(frameinterval)

=={{header|Kotlin}}==

{{trans|Java}}

import java.awt.Dimension

}

Timer(false).schedule(task, 0, 500)

=={{header|LabVIEW}}==

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

txtLength = len(txt$)

direction=1

timer 0

close #demo

=={{header|Logo}}==

{{works with|UCB Logo}}

output lput first :thing butfirst :thing

end

hideturtle

=={{header|Lua}}==

{{works with|LÖVE}}

text = "Hello World! "

length = string.len(text)

function love.mousepressed( x, y, button, istouch, presses )

right_direction = not right_direction

=={{header|M2000 Interpreter}}==

Any Button can use a blink, a timer which return a changed value, true or false, but here we didn't use it (so we didn't Read from event's stack of values. We can place Stack statement to view this stack in console).

Module UseBlink {

Def boolean direction=True

UseBlink

===Using Every Statement===

We can use console as window too. Although we don't have events for this window, we can read mouse button. Also we use split screen so first line (line 0) has the title, and all other lines are cleared before we print on it, every 200ms

Module UseEvery {

Window 16, 6000,4000;

}

UseEvery

===Using Thread===

When a thread created saves the current layer, to use it in each iteration.

Module UseThread {

Def boolean direction=True

}

UseThread

=={{header|Maple}}==

First, create a textbox, and by right-clicking it, and selecting component properties, change its name to "Text". Then, create 2 buttons, changing the caption on one to "Reverse", and the other to "Forward". In the edit click action of each respective button, you will put:

ScrollText(GP("Text",value),"Forward",65);

and:

ScrollText(GP("Text",value),"Reverse",65);

Then in the startup actions, accessed by clicking the 2 gears, add this:

macro(SP=DocumentTools:-SetProperty, GP=DocumentTools:-GetProperty);

SP("Text",value,"Hello World! ");

end do:

end proc:

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

Scroll[str_, dir_] := StringJoin @@ RotateLeft[str // Characters, dir];

GiveString[dir_] := (mystring = Scroll[mystring, dir]);

Refresh[GiveString[direction], UpdateInterval -> 1/8]],

TrackedSymbols -> {}], {"MouseClicked" :> (direction *= -1)}]]

=={{header|MAXScript}}==

Creates a window with a rotating label and 2 buttons to change the direction.

try destroydialog animGUI catch ()

createdialog animGUI

=={{header|MiniScript}}==

{{works with|Mini Micro}}

text.inverse = true

s = "Hello World! "

end while

text.inverse = false

=={{header|Nim}}==

{{libheader|gintro}}

type

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

discard app.connect("activate", activate)

=={{header|Oz}}==

import

Application

{Start}

=={{header|Pascal}}==

===LCL (Lazarus)===

uses {$IFDEF UNIX} {$IFDEF UseCThreads}

Application.CreateForm(TFrmHelloWorldAnim, FrmHelloWorldAnim);

Application.Run;

Example can be compiled by FreePascal/Lazarus.

Did all in one file, normally you have the project-file, the form-unit- and the form-resource-file.

=={{header|Perl}}==

use Time::HiRes qw(sleep);

$mw->update();

}

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

Clicking on the label changes the animation direction.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Animation.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

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

=={{header|PicoLisp}}==

===Plain text===

A plain text version. The following script works in an XTerm window.

(prin "^[[?9h") # Mouse reporting on

(setq Dir (if (= 1 Dir) 12 1)) )

(key) (key) )

===HTML/JavaScript===

The standard PicoLisp GUI is HTTP based. Connect your browser to

The scrolling text is displayed in a button. Clicking on the button

reverses the scroll direction.

(load "@ext.l" "@lib/http.l" "@lib/xhtml.l" "@lib/form.l")

(server 8080 "!start")

===Java/Swing===

This solution works on ErsatzLisp, the Java version of PicoLisp.

(setq

(loop

(wait 200)

=={{header|Processing}}==

boolean dir = true;

}

return String.valueOf(rotated);

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

When the user clicks on the (windowed) text, it should reverse its direction.

left = True

rotated = text[startIdx:] + text[:startIdx]

return rotated

=={{header|Prolog}}==

SWI-Prolog has a grapghic interface XPCE.

animation :-

get(S, delete_prefix, Str, V),

get(V, append, Str, S1).

=={{header|PureBasic}}==

text$ = "Hello World! "

tick = ElapsedMilliseconds()

EndIf

=={{header|Python}}==

===Using PyQt===

{{libheader|PyQt5}}

import sys

- w.rect().center())

w.show()

===Using pygame===

{{libheader|pygame}}

from pygame.locals import *

pygame.init()

while True:

input(pygame.event.wait())

===Using Tkinter===

def scroll_text(s, how_many):

tk.title('Python Animation')

tki.mainloop()

=={{header|Quick BASIC}}==

{{libheader|QB.QLB / QBX.QLB}}

'here accordingly to the version, QB or QBX

REM $INCLUDE: 'QBX.BI'

IF TIMER < I THEN I = I - 86400 'midnight checking

LOOP

=={{header|R}}==

The basic principle is:create a window with a label in it, then add a handler to the label for rotating the string, and another for changing direction on a click. Use of the tag function allows you to store the text flow direction as an attribute of the label.

rotate_string <- function(x, forwards)

{

handle_rotate_label(lab)

handle_change_direction_on_click(lab)

=={{header|Racket}}==

#lang racket/gui

(send frame show #t)

This is a more functional approach - there is no explicit mutation, everything is handled through event callbacks.

#lang racket

(require racket/match)

[on-tick update]

[on-mouse handle-mouse])

=={{header|Raku}}==

{{works with|Rakudo|2019.03}}

use GTK::Simple::App;

$app.set-content($vbox);

=={{header|REBOL}}==

Title: "Basic Animation"

URL: http://rosettacode.org/wiki/Basic_Animation

]

]

=={{header|Red}}==

rev: false

roule: does [e: back tail s: t/text either rev [move e s] [move s e]]

=={{header|REXX}}==

This REXX version <u>only</u> works with REXX/Personal or REXX/PC.

parse upper version !ver !vernum .; !pcRexx= 'REXX/PERSONAL'==!ver | 'REXX/PC'==!ver

if \!pcRexx then do

else $= right($, 1)substr($, 1, length($) - 1) /* ··· the other·*/

end /*until*/

=={{header|Ring}}==

# Project : Animation

next

see nl

Output:

<pre>

{{trans|Tcl}}

{{libheader|Ruby/Tk}}

$str = TkVariable.new("Hello World! ")

$dir = :right

animate

{{libheader|Shoes}}

@direction = 1

@label = para "Hello World! ", :family => 'monospace'

@label.text = @direction > 0 ? t[-1] + t[0..-2] : t[1..-1] + t[0]

end

=={{header|Rust}}==

==={{libheader|GTK}}===

mod graphical {

extern crate gtk;

#[cfg(not(feature = "gtk"))]

=={{header|Scala}}==

{{works with|Scala|2.8}}

import scala.actors.TIMEOUT

import scala.swing.{SimpleSwingApplication, MainFrame, Label}

case _ : MouseClicked => rotator ! Revert

}

=={{header|Scratch}}==

=={{header|smart BASIC}}==

word$="Hello World! "

'use button window with text

=={{header|Standard ML}}==

Works with PolyML interpreter. Add loop for compilation.

open Motif ;

)

call

=={{header|Suneido}}==

{

Xmin: 50

super.Destroy()

}

=={{header|SVG}}==

This animation is defined as a smooth movement rather than by moving whole characters, because that is more natural in SVG (without scripting); by characters would require 13 different text elements displayed in sequence.

<g id="all">

<rect width="100%" height="100%" fill="yellow"/>

</g>

</g>

(Does not work in Safari 4.0.2 because it apparently does not implement toggled animations correctly ([http://www.w3.org/TR/2001/REC-smil-animation-20010904/#RestartAttribute see spec]). Dreadful workaround: set the two animations to <code>id="a" begin="0s;all.click" end="all.mousedown"</code> and <code>begin="a.end" end="all.click"</code>, respectively.)

=={{header|Tcl}}==

{{libheader|Tk}}

set s "Hello World! "

set dir 0

bind .l <Button-1> {set dir [expr {!$dir}]}

# Start the animation

=={{header|TI-89 BASIC}}==

=={{header|Vedit macro language}}==

It is not possible to detect mouse clicks while a macro is running. Therefore, the direction is controlled with Caps Lock key.

Win_Create(Buf_Num, 1, 1, 2, 14)

Ins_Text("Hello World! ")

Update()

Sleep(2)

=={{header|Visual Basic}}==

This example shows code that is hidden by the IDE. (Form creation is done graphically within the IDE, not at runtime.)

Begin VB.Form Form1

Begin VB.Timer Timer1

End If

Label1.Caption = x

=={{header|Wren}}==

{{libheader|DOME}}

import "dome" for Window

import "input" for Mouse

}

=={{header|XPL0}}==

int CpuReg, Dir, I, J;

char Str;

if CpuReg(1) then Dir:= -Dir;

until KeyHit; \any keystroke terminates program

=={{header|Yabasic}}==

open window 400, 150

backcolor 0, 0, 0

texto$ = right$(texto$, 1) + left$(texto$, l-1)

end if

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

{{trans|BBC BASIC}}

Replaces the detection of mouse click by pressing a key (Spectrum does not detect this device by default).

20 LET direction=1

30 PRINT AT 0,0;t$

50 LET t$=t$(lt)+t$( TO lt-1)

60 IF INKEY$<>"" THEN LET direction=NOT direction

{{omit from|ACL2}}