[DEV] 2.4 tools
This commit is contained in:
402
java/common/cstr/util/PaintCache.java
Normal file
402
java/common/cstr/util/PaintCache.java
Normal file
@@ -0,0 +1,402 @@
|
||||
|
||||
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
|
||||
// \\
|
||||
// Centre for Speech Technology Research \\
|
||||
// University of Edinburgh, UK \\
|
||||
// Copyright (c) 1996,1997 \\
|
||||
// All Rights Reserved. \\
|
||||
// Permission is hereby granted, free of charge, to use and distribute \\
|
||||
// this software and its documentation without restriction, including \\
|
||||
// without limitation the rights to use, copy, modify, merge, publish, \\
|
||||
// distribute, sublicense, and/or sell copies of this work, and to \\
|
||||
// permit persons to whom this work is furnished to do so, subject to \\
|
||||
// the following conditions: \\
|
||||
// 1. The code must retain the above copyright notice, this list of \\
|
||||
// conditions and the following disclaimer. \\
|
||||
// 2. Any modifications must be clearly marked as such. \\
|
||||
// 3. Original authors' names are not deleted. \\
|
||||
// 4. The authors' names are not used to endorse or promote products \\
|
||||
// derived from this software without specific prior written \\
|
||||
// permission. \\
|
||||
// THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK \\
|
||||
// DISCLAIM ALL WARRANTIES With REGARD TO THIS SOFTWARE, INCLUDING \\
|
||||
// ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT \\
|
||||
// SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE \\
|
||||
// FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES \\
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN \\
|
||||
// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, \\
|
||||
// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF \\
|
||||
// THIS SOFTWARE. \\
|
||||
// \\
|
||||
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
|
||||
// \\
|
||||
// Author: Richard Caley (rjc@cstr.ed.ac.uk) \\
|
||||
// -------------------------------------------------------------------- \\
|
||||
// An abstration which stands between a component and the AWT to cache \\
|
||||
// the information painted in an array of images. \\
|
||||
// \\
|
||||
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
|
||||
|
||||
|
||||
package cstr.util ;
|
||||
|
||||
import java.lang.*;
|
||||
import java.util.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
|
||||
public class PaintCache
|
||||
{
|
||||
protected Image [] chunks;
|
||||
protected Thread [] threads;
|
||||
protected int chunkSize;
|
||||
protected int numChunks;
|
||||
protected Painter painter;
|
||||
protected Component comp;
|
||||
protected int width;
|
||||
protected int height;
|
||||
protected int running;
|
||||
protected int topPriority;
|
||||
Image dummy;
|
||||
|
||||
public PaintCache(Component c, Painter p)
|
||||
{
|
||||
this(c, p, 400);
|
||||
}
|
||||
|
||||
public PaintCache(Component c, Painter p, int cs)
|
||||
{
|
||||
comp=c;
|
||||
painter=p;
|
||||
chunkSize=cs;
|
||||
chunks=null;
|
||||
running=0;
|
||||
topPriority=Thread.currentThread().getPriority()-1;
|
||||
}
|
||||
|
||||
protected void finalize()
|
||||
{
|
||||
if (threads!=null)
|
||||
for(int i=0; i<threads.length; i++)
|
||||
if (threads[i]!= null)
|
||||
threads[i].stop();
|
||||
}
|
||||
|
||||
public synchronized void updated(int w, int h)
|
||||
{
|
||||
if (w != width || h != height)
|
||||
{
|
||||
width = w;
|
||||
height = h;
|
||||
|
||||
if (threads!=null)
|
||||
for(int i=0; i<threads.length; i++)
|
||||
if (threads[i]!= null)
|
||||
threads[i].stop();
|
||||
|
||||
running=0;
|
||||
|
||||
numChunks = w / chunkSize+1;
|
||||
if (numChunks*chunkSize < w)
|
||||
numChunks++;
|
||||
|
||||
chunks = new Image[numChunks+1];
|
||||
threads = new Thread[numChunks+1];
|
||||
|
||||
dummy = comp.createImage(chunkSize, height);
|
||||
Graphics ig = dummy.getGraphics();
|
||||
|
||||
ig.setColor(Color.red);
|
||||
|
||||
ig.drawLine(0,0,chunkSize,height);
|
||||
ig.drawLine(0,height,chunkSize,0);
|
||||
}
|
||||
}
|
||||
|
||||
protected synchronized Image dummyImage()
|
||||
{
|
||||
return dummy;
|
||||
}
|
||||
|
||||
protected synchronized void dumpP()
|
||||
{
|
||||
System.out.print("Threads: ");
|
||||
for(int i=0; i<threads.length; i++)
|
||||
if (threads[i]!= null && threads[i].isAlive())
|
||||
System.out.print(threads[i].getPriority());
|
||||
else
|
||||
System.out.print("_");
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
public synchronized void zap(int i)
|
||||
{
|
||||
if (i<threads.length && threads[i] == Thread.currentThread())
|
||||
{
|
||||
int op=threads[i].getPriority();
|
||||
threads[i]=null;
|
||||
int maxi=-1, max=0;
|
||||
|
||||
for(int ti=0; ti<threads.length; ti++)
|
||||
if (threads[ti]!= null && threads[ti].isAlive())
|
||||
{
|
||||
int p = threads[ti].getPriority();
|
||||
// if (p>Thread.MIN_PRIORITY && p < op)
|
||||
//threads[ti].setPriority(p+1);
|
||||
if (p>max)
|
||||
{
|
||||
max=p;
|
||||
maxi=ti;
|
||||
}
|
||||
}
|
||||
if (maxi>=0)
|
||||
{
|
||||
// System.out.println("top="+maxi+"="+topPriority);
|
||||
threads[maxi].setPriority(topPriority);
|
||||
}
|
||||
|
||||
// dumpP();
|
||||
}
|
||||
}
|
||||
|
||||
protected synchronized void checkChunk(int i, Graphics g)
|
||||
{
|
||||
if (i<chunks.length)
|
||||
{
|
||||
if (chunks[i] == null)
|
||||
{
|
||||
if (painter instanceof ImagePainter)
|
||||
{
|
||||
ImagePainter ipainter = (ImagePainter)painter;
|
||||
|
||||
chunks[i] = dummy;
|
||||
|
||||
Rectangle r = new Rectangle(i*chunkSize, 0,
|
||||
chunkSize, height);
|
||||
|
||||
Thread pt = new Thread(new IPaintingThread(i,
|
||||
ipainter,
|
||||
r,
|
||||
this,
|
||||
g,
|
||||
chunkSize,
|
||||
height));
|
||||
|
||||
|
||||
threads[i]=pt;
|
||||
pt.start();
|
||||
pt.setPriority(Thread.MIN_PRIORITY);
|
||||
}
|
||||
else
|
||||
{
|
||||
PaintPainter ppainter = (PaintPainter)painter;
|
||||
chunks[i] = comp.createImage(chunkSize, height);
|
||||
|
||||
Graphics ig = chunks[i].getGraphics();
|
||||
|
||||
ig.setColor(Color.red);
|
||||
|
||||
ig.drawLine(0,0,chunkSize,height);
|
||||
ig.drawLine(0,height,chunkSize,0);
|
||||
|
||||
ig.setColor(g.getColor());
|
||||
|
||||
Rectangle r = new Rectangle(i*chunkSize, 0, chunkSize, height);
|
||||
|
||||
Thread pt = new Thread(new PaintingThread(i,
|
||||
ppainter,
|
||||
r,
|
||||
ig,
|
||||
this,
|
||||
g,
|
||||
chunkSize,
|
||||
height));
|
||||
|
||||
|
||||
threads[i]=pt;
|
||||
pt.start();
|
||||
pt.setPriority(Thread.MIN_PRIORITY);
|
||||
}
|
||||
}
|
||||
else if (threads[i] != null && threads[i].isAlive())
|
||||
{
|
||||
for(int ti=0; ti<threads.length; ti++)
|
||||
{
|
||||
Thread t = threads[ti];
|
||||
if (t != null && t.isAlive())
|
||||
{
|
||||
int p;
|
||||
if (i!=ti)
|
||||
{
|
||||
int op = t.getPriority();
|
||||
if (op> Thread.MIN_PRIORITY)
|
||||
// p= topPriority-1;
|
||||
p= Thread.MIN_PRIORITY+1;
|
||||
else
|
||||
p =Thread.MIN_PRIORITY;
|
||||
}
|
||||
else
|
||||
p = topPriority;
|
||||
// p = Thread.MAX_PRIORITY;
|
||||
|
||||
if (p>=Thread.MIN_PRIORITY)
|
||||
t.setPriority(p);
|
||||
}
|
||||
}
|
||||
// dumpP();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void paint(Graphics g)
|
||||
{
|
||||
Rectangle r = g.getClipBounds();
|
||||
|
||||
int c1 = r.x / chunkSize;
|
||||
int cn = (r.x+r.width) / chunkSize;
|
||||
|
||||
if (cn >= chunks.length)
|
||||
cn = chunks.length-1;
|
||||
|
||||
if ( c1 == cn)
|
||||
{
|
||||
checkChunk(c1, g);
|
||||
int ix = r.x % chunkSize;
|
||||
g.drawImage(chunks[c1],
|
||||
r.x, r.y, r.x+r.width, r.y+r.height,
|
||||
ix, r.y, ix+r.width, r.y+r.height,
|
||||
comp);
|
||||
}
|
||||
else
|
||||
{
|
||||
int ix = r.x % chunkSize;
|
||||
int wx = r.x;
|
||||
int w = chunkSize - ix;
|
||||
checkChunk(c1, g);
|
||||
g.drawImage(chunks[c1],
|
||||
wx, r.y, wx+w, r.y+r.height,
|
||||
ix, r.y, ix+w, r.y+r.height,
|
||||
comp);
|
||||
|
||||
for(int c = c1+1; c < cn; c++)
|
||||
{
|
||||
ix = 0;
|
||||
wx = c * chunkSize;
|
||||
w = chunkSize;
|
||||
|
||||
checkChunk(c, g);
|
||||
g.drawImage(chunks[c],
|
||||
wx, r.y, wx+w, r.y+r.height,
|
||||
ix, r.y, ix+w, r.y+r.height,
|
||||
comp);
|
||||
}
|
||||
|
||||
ix = 0;
|
||||
wx = cn * chunkSize;
|
||||
w = (r.x + r.width) % chunkSize;
|
||||
|
||||
checkChunk(cn, g);
|
||||
g.drawImage(chunks[cn],
|
||||
wx, r.y, wx+w, r.y+r.height,
|
||||
ix, r.y, ix+w, r.y+r.height,
|
||||
comp);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
protected synchronized void blit(Graphics g, int i)
|
||||
{
|
||||
g.setClip(0,0, width, height);
|
||||
if (i<chunks.length)
|
||||
g.drawImage(chunks[i],
|
||||
i*chunkSize, 0,
|
||||
Color.green,
|
||||
null);
|
||||
}
|
||||
|
||||
class PaintingThread implements Runnable
|
||||
{
|
||||
int index;
|
||||
PaintPainter painter;
|
||||
Rectangle rect;
|
||||
Graphics ig;
|
||||
PaintCache parent;
|
||||
Graphics g;
|
||||
int w,h;
|
||||
|
||||
public PaintingThread(int i,
|
||||
PaintPainter i_painter,
|
||||
Rectangle i_rect,
|
||||
Graphics i_ig,
|
||||
PaintCache i_parent,
|
||||
Graphics i_g,
|
||||
int i_w,
|
||||
int i_h)
|
||||
{
|
||||
index=i;
|
||||
painter=i_painter;
|
||||
rect=i_rect;
|
||||
ig=i_ig.create();
|
||||
parent=i_parent;
|
||||
g=i_g.create();
|
||||
w=i_w;
|
||||
h=i_h;
|
||||
}
|
||||
|
||||
public void run()
|
||||
{
|
||||
// System.out.println("start "+rect.x);
|
||||
painter.real_paint(ig, rect);
|
||||
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
|
||||
parent.zap(index);
|
||||
parent.blit(g, index);
|
||||
// System.out.println("end "+rect.x);
|
||||
}
|
||||
}
|
||||
|
||||
class IPaintingThread implements Runnable
|
||||
{
|
||||
int index;
|
||||
ImagePainter painter;
|
||||
Rectangle rect;
|
||||
PaintCache parent;
|
||||
Graphics g;
|
||||
int w,h;
|
||||
|
||||
public IPaintingThread(int i,
|
||||
ImagePainter i_painter,
|
||||
Rectangle i_rect,
|
||||
PaintCache i_parent,
|
||||
Graphics i_g,
|
||||
int i_w,
|
||||
int i_h)
|
||||
{
|
||||
index=i;
|
||||
painter=i_painter;
|
||||
rect=i_rect;
|
||||
parent=i_parent;
|
||||
g=i_g.create();
|
||||
w=i_w;
|
||||
h=i_h;
|
||||
}
|
||||
|
||||
public void run()
|
||||
{
|
||||
ImageProducer src = painter.make_image(rect);
|
||||
|
||||
if (src==null)
|
||||
chunks[index] = parent.dummyImage();
|
||||
else
|
||||
chunks[index] = comp.createImage(src);
|
||||
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
|
||||
parent.zap(index);
|
||||
parent.blit(g, index);
|
||||
// System.out.println("end "+rect.x);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user