Förbättrad variant
Det är inte så intelligent att "hårdkoda" bildernas namn och antal i programmet.
Det skulle vara mycket bättre att
kunna ange bildernas namn när programmet körs.
Nedan kommer en variant på ImageBlaster klassen som kan
få angivet vilka bilder som skall användas.
Skapa en ny klass:
När du har ImageBlaster.java öppen i editorn så väljer du File, Save As, och ger den namnet
ImageBlaster2.java. Den borde dyka upp i samma projekt som den tidigare filen.
Modifiera även Page1.htm filen. Du kan gärna sätta till en applet till på samma sida. Koden
för att få in ImageBlaster2 finns nedan.
Page1.htm
<applet
code=ImageBlaster2.class
name=ImageBlaster2
width=200
height=100>
<param name="imagecount" value="5">
<param name="basename" value="images/anim">
<param name="filetype" value="jpg">
<param name="background" value="images/background.gif">
<param name="delay" value="1000">
</applet>
ImageBlaster2.java
import java.applet.Applet;
import java.awt.*;
//--------------------------------------------------------------
public class ImageBlaster2 extends Applet
implements Runnable // för att få ett flertrådigt program
{
// ----------------------------------------------------------
// ett antal variabler
// för enkelhetens skull ger vi dem samma startvärden som i
// i föregåennde ImageBlaster
String basename = "images/anim";
String filetype = "jpg";
String background = "images/background.gif";
int delay = 1000;
int imagecount = 5;
// ----------------------------------------------------------
// MediaTrackern kan hålla reda på om alla bilder är laddade
MediaTracker tracker;
// bakgrundsbilden
Image bg;
// en array med (för tillfället ) okänt antal Images
// OBS! Ändrad.
// ----------------------------------------------------------
Image anim[] ;
// ----------------------------------------------------------
// nuvarande bild
int index;
// en separat tråd
Thread animator;
// hämta bilden för bakgrunden (id = 0)
// och de fem bilderna som skall animeras (id == 1)
// och lägg in dem i MediaTrackern så att vi vet
// när de är laddade
// init är fortfarande startpunkten för Appletten
public void init()
{
// skapa en MediaTracker som skall meddela oss
// när bilderna är laddade
tracker = new MediaTracker(this);
// ----------------------------------------------------------
String param; // en sträng att läsa in parametrar i
// kolla om det fanns en rad med
// <param name="basename" value="... i applet taggen
param = this.getParameter("basename");
// om det fanns så sätter vi det värdet in i variabeln basename
if ( param.length() > 0 )
basename = param;
// sedan kollar vi på motsvarande sätt de övriga parametrarna
param = this.getParameter("filetype");
if ( param.length() > 0 )
filetype = param;
param = this.getParameter("background");
if ( param.length() > 0 )
background = param;
param = this.getParameter("imagecount");
if ( param.length() > 0 )
imagecount = Integer.parseInt(param); // siffra
param = this.getParameter("delay");
if ( param.length() > 0 )
delay = Integer.parseInt(param); // siffra
// nu vet vi hur många bilder vi skall ha
anim = new Image[imagecount];
// ----------------------------------------------------------
// ----------------------------------------------------------
// delvis ändrad
// dels använder vi background variabeln
// dels så har jag satt dit en kompletterande kod som gör att bilden
// alltid fyller ut hela appleten - oavsett dess storlek
bg = getImage( getDocumentBase(),
background ).getScaledInstance(
this.getSize().width,
this.getSize().height,
Image.SCALE_SMOOTH );
// ----------------------------------------------------------
// eftersom bilden inte laddas ommeddelbart så
// säger vi åt vår MediaTracker att den skall meddela oss
// när den finns tillgänglig
tracker.addImage( bg, 0 );
// hämta resten av bilderna som antas finnas i en images katalog
// ----------------------------------------------------------
// observera att 5:an är ändrad till imagecount i loopen
for ( int i = 0; i < imagecount; i++ )
// ----------------------------------------------------------
{
// ----------------------------------------------------------
// delvis ändrad
// dels använder vi basename och filetype variablerna
// dels så har jag satt dit en kompletterande kod som gör att
// bilderna alltid fyller ut nästan hela appleten - oavsett
// dess storlek
anim[i] = getImage( getDocumentBase(),
basename + i + "." + filetype ).getScaledInstance(
this.getSize().width-20,
this.getSize().height-20,
Image.SCALE_SMOOTH );
// ----------------------------------------------------------
// säg åt MediaTrackern at den skall meddela oss när
// bilderna är tillgängliga
tracker.addImage( anim[i], 1 );
}
}
// start behövs om man har implements Runnable
// dvs om man har ett flertrådigt program
public void start()
{
// skap en till tråd och sätt den i animator objektet
animator = new Thread(this);
// starta denna tråd
animator.start();
}
// stop behövs om man har implements Runnable
public void stop()
{
// stopp tråden
animator.stop();
// och döda den
animator = null;
}
// Kör animeringstråden
// men vänta först på att alla bilder är laddade
public void run()
{
// felhanteringen i Java fungerar med try - catch systemet
// som i C++
// vi försöker således vänta på att bakgrunden är laddad
// för att sedan vänta på att de övriga bilderna blivit
// laddade
try {
tracker.waitForID(0);
tracker.waitForID(1);
}
// någonting har gått fel - avbryt körningen
catch (InterruptedException e)
{
return;
}
// Kolla vilken tråd vi kör
// och sätt undan denna i en Thread
Thread me = Thread.currentThread();
// så länge som den körda tråden är animerings tråden
// kommer att snurra på så länge som Appleten är igång
while (animator == me)
{
// försök stoppa tråden ett antal millisekunder
try {
// ---------------------------------------------
// delvis ändrad
Thread.sleep( delay );
// ---------------------------------------------
}
// om det inte gick så avbryter vi loopen
catch (InterruptedException e)
{
break;
}
// vi skall öka på index för vilken bild som skall visas
// För att undvika att någon annan del av programmet
// försöker göra någonting åt index variabeln så
// använder vi ordet synchronized, som betyder att
// denna kod måste bli färdig innan någon annan tråd eller
// del av programmet får röra index variabeln
synchronized (this)
{
index++;
if (index >= anim.length)
{
// om vi har den sista bilden så tar vi som nästa
// den första
index = 0;
}
}
// rita om Appletten
repaint();
}
}
// vid uppdatering så ritar vi om allt
public void update(Graphics g)
{
paint(g);
}
// Rita en röd bakgrund om bilderna inte kunde hämtas
// I annat fall så ritar vi dit bakgrundsbilden
public void paint(Graphics g)
{
// har någonting gått fel vid bildhämtningen?
if ((tracker.statusAll(false) & MediaTracker.ERRORED) != 0)
{
// röd färg över hela bakgrunden
g.setColor(Color.red);
g.fillRect(0, 0, getSize().width, getSize().height);
// och bort härifrån
return;
}
// kom vi hit borde vi ha en bakgrundsbild som vi
// då kan rita ut
g.drawImage(bg, 0, 0, this);
// har vi hunnit ladda alla andra bilder?
if (tracker.statusID(1, false) == MediaTracker.COMPLETE)
{
// om så är fallet så kan vi rita ut den som
// är aktuell. Om index är 1 kommer således
// anim1.gif att ritas
g.drawImage(anim[index], 10, 10, this);
}
}
}
Java
Top
Animerade bilder