Igor Zeta

How to avoid system.exit(0)

Great!
I've found the answer my own!

A good happening in a dark day

I've found the answer on the Sun site

21 years ago

How to avoid system.exit(0)

attached with the previous task
about how to launch an ant job from java code,
I'm asking myself why after the execution ends
my swing gui program exit?
Any suggestion on how to avoid ant System.exit()?
Please give me some Chink of light!

21 years ago

Launching ant from java code

I'm trying to launch an ant statement
that succeed from command line but not
from a java code.
this is what I do from command line

and I get:

init:
[deltree] DEPRECATED - The deltree task is deprecated. Use delete instead.
[deltree] Deleting: D:\igor\work\DBAccessOutput\veicoli\build
[deltree] DEPRECATED - The deltree task is deprecated. Use delete instead.
[deltree] Deleting: D:\igor\work\DBAccessOutput\veicoli\dist
[mkdir] Created dir: D:\igor\work\DBAccessOutput\veicoli\build
compile:
[javac] Compiling 14 source files to D:\igor\work\DBAccessOutput\veicoli\build
[javac] Note: Some input files use or override a deprecated API.
[javac] Note: Recompile with -deprecation for details.
distribution:
[mkdir] Created dir: D:\igor\work\DBAccessOutput\veicoli\dist\lib
[jar] Building jar: D:\igor\work\DBAccessOutput\veicoli\dist\lib\MyProject-20031009.jar
BUILD SUCCESSFUL
Total time: 13 seconds

and this is what I get from java code:

and I get
BuildFile: build.xml does not exist!
or
bad arguments
Any suggestion?

21 years ago

Error Message: nonpublic method marked untrusted...

Generating gant images

I've found some usefull library
for example
JfreeChart
that answer to my question e does many other chart related stuffs.
hoping it will help someone too.

21 years ago

Java in General

Generating gant images

Hello all,
I'm looking for something (possibly free)
for build gif or jpeg or any other kind
of image in order to represent "gant" charts
In other words project time appraisal charts.

day 1 day2 ....
-------
-------
-------
---------
-----------
-----------

or something similar.
I will be very glad if you show me the right way

21 years ago

Java in General

I've an applet that have to do some stuff
about digital sign, after, it should write
the decoded string in the client file-system.
But I guess I couldn't write on the client f.s.
from an applet.
Before this error I had that my needed class
imported in order to achieve the main stuff
had not been instantiated, having anyway mentioned
all the jar I needed.
regards.

[ September 03, 2003: Message edited by: Igor Zeta ]

21 years ago

Applets

Ok,
now I do all that I wanted.
I've added the options for chosing colors from a JColorChooser,more you have to pay attention to the starting image color(currentColor var) that you must define in the code.
I give you the entire modified code.

import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.ImageObserver;
import java.awt.image.MemoryImageSource;
import java.awt.image.PixelGrabber;
import net.jmge.gif.Gif89Encoder;//DOWNLOAD AT HTTP:\\WWW.ACME.COM\JAVA
import java.io.*;
public class ImageColorer extends Frame implements ItemListener {
private ColorCanvas canvas;
private CheckboxGroup colors;
private Checkbox redCB;
private Checkbox greenCB;
private Checkbox blueCB;
private Color currentColor = new Color(132,148,0);//MODIFY IT AS YOUR STARTING IMAGE COLOR
JColorChooser colorChooser=new JColorChooser(currentColor);
JButton Submit = new JButton();
JButton WriteToFile = new JButton();
public ImageColorer() {
super( "ImageColorer" );
Image i = Toolkit.getDefaultToolkit().getImage("D:/Image.png");
canvas= new ColorCanvas( i );
Panel buttonPanel = new Panel();
Submit.setBounds(new Rectangle(22, 457, 498, 27));
Submit.setText("Choose a color");
Submit.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
Submit_actionPerformed(e);
}
});
WriteToFile.setBounds(new Rectangle(22, 457, 498, 27));
WriteToFile.setText("Write To File");
WriteToFile.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
WriteToFile_actionPerformed(e);
}
});
buttonPanel.add(Submit);
buttonPanel.add(WriteToFile);
add( canvas, BorderLayout.CENTER);
add( buttonPanel, BorderLayout.SOUTH );
}
void Submit_actionPerformed(ActionEvent e){
Color oldColor = currentColor;
currentColor = colorChooser.showDialog(this,"Select backround color",currentColor);
canvas.replaceColor( oldColor, currentColor );
}
void WriteToFile_actionPerformed(ActionEvent e){
try {
// saveToPNGFile(canvas.image,"C:/windows/Desktop/prova.png");
writeNormalGIF(canvas.image,"",0,false,new FileOutputStream("C:/windows/Desktop/FILE_OUT.gif"));
}
catch (Exception ex) {
ex.printStackTrace();
}
}
static void writeNormalGIF(Image img,
String annotation,
int transparent_index, // pass -1 for none
boolean interlaced,
OutputStream out) throws IOException
{
Gif89Encoder gifenc = new Gif89Encoder(img);
gifenc.setComments(annotation);
gifenc.setTransparentIndex(transparent_index);
gifenc.getFrameAt(0).setInterlaced(interlaced);
gifenc.encode(out);
}
public void saveToPNGFile(Image img,String path){
byte[] pngbytes;
PngEncoder png = new PngEncoder( img );
try
{
FileOutputStream outfile = new FileOutputStream( path);
pngbytes = png.pngEncode();
if (pngbytes == null)
{
System.out.println("Null image");
}
else
{
outfile.write( pngbytes );
}
outfile.flush();
outfile.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
public void itemStateChanged( ItemEvent evt ) {
if ( evt.getStateChange() == ItemEvent.SELECTED ) {
Color oldColor = currentColor;
if ( evt.getSource() == redCB ) {
currentColor = Color.red;
}else if ( evt.getSource() == greenCB ) {
currentColor = Color.green;
}else if ( evt.getSource()== blueCB ) {
currentColor = Color.blue;
}
canvas.replaceColor( oldColor, currentColor );
}
}
public static void main(String[] args) {
Frame f = new ImageColorer();
f.setSize( 300, 300 );
f.addWindowListener( new WindowAdapter(){
public void windowClosing( WindowEvent e ) {
System.exit( 0 );
}
} );
f.setVisible( true );
}
public void replaceColorAndWriteDown(String pathFrom,String pathTo, Color newColor ) {
Image img = Toolkit.getDefaultToolkit().getImage(pathFrom);
Color oldColor = currentColor;
int width = img.getWidth( this );
int height = img.getHeight( this );
int[] pixels = new int[ width* height ];
PixelGrabber pg = new PixelGrabber( img, 0, 0,width, height, pixels, 0, width );
try {
pg.grabPixels();
}catch ( InterruptedException x ) {
x.printStackTrace();
return;
}
if(( pg.getStatus() & ImageObserver.ABORT ) != 0 ) {
System.err.println("image fetch aborted or errored");
return;
}
for ( int i = 0; i < width * height; i++ ) {
if ( pixels[i]== oldColor.getRGB() ) {
pixels[i] = newColor.getRGB();
}
}
MemoryImageSource source= new MemoryImageSource( width, height, pixels, 0, width );
img= createImage( source );
try {
writeNormalGIF(img,"created by little product",0,false,new FileOutputStream(pathTo));
}
catch (Exception ex) {
ex.printStackTrace();
}
//repaint();
}
private class ColorCanvas extends Canvas {
private Image image;
private Image buffer;
private Graphics bg;
public ColorCanvas( Image i ) {
image = i;
}
public void update( Graphics g ) {
paint(g );
}
public void paint( Graphics g ) {
int width = getSize().width;
int height = getSize().height;
if ( buffer == null || buffer.getWidth( this ) != width || buffer.getHeight(this ) != height ) {
buffer = createImage( width, height);
bg = buffer.getGraphics();
}
bg.setColor(getBackground() );
bg.fillRect( 0, 0, width, height );
int imageX = ( width - image.getWidth( this ) ) / 2;
int imageY = ( height - image.getHeight( this ) ) / 2;
bg.drawImage(image, imageX, imageY, this );
g.drawImage( buffer, 0, 0, this);
}
public void replaceColor( Color oldColor, Color newColor ) {
int width = image.getWidth( this );
int height = image.getHeight( this );
int[] pixels = new int[ width* height ];
PixelGrabber pg = new PixelGrabber( image, 0, 0,width, height, pixels, 0, width );
try {
pg.grabPixels();
}catch ( InterruptedException x ) {
x.printStackTrace();
return;
}
if(( pg.getStatus() & ImageObserver.ABORT ) != 0 ) {
System.err.println("image fetch aborted or errored");
return;
}
for ( int i = 0; i < width * height; i++ ) {
if ( pixels[i]== oldColor.getRGB() ) {
pixels[i] = newColor.getRGB();
}
}
MemoryImageSource source= new MemoryImageSource( width, height, pixels, 0, width );
image= createImage( source );
repaint();
}
}
}
/**
* PngEncoder takes a Java Image object and creates a byte string which can be saved as a PNG file.
* The Image is presumed to use the DirectColorModel.
*
* Thanks to Jay Denny at KeyPoint Software
* <a href="http://www.keypoint.com/" target="_blank" rel="nofollow">http://www.keypoint.com/</a>
* who let me develop this code on company time.
*
* You may contact me with (probably very-much-needed) improvements,
* comments, and bug fixes at:
*
* david@catcode.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
* A copy of the GNU LGPL may be found at
* <a href="http://www.gnu.org/copyleft/lesser.html," target="_blank" rel="nofollow">http://www.gnu.org/copyleft/lesser.html,</a>
*
* @author J. David Eisenberg
* @version 1.4, 31 March 2000
*/
import java.awt.*;
import java.awt.image.*;
import java.util.*;
import java.util.zip.*;
import java.io.*;
public class PngEncoder extends Object
{
/** Constant specifying that alpha channel should be encoded. */
public static final boolean ENCODE_ALPHA=true;
/** Constant specifying that alpha channel should not be encoded. */
public static final boolean NO_ALPHA=false;
/** Constants for filters */
public static final int FILTER_NONE = 0;
public static final int FILTER_SUB = 1;
public static final int FILTER_UP = 2;
public static final int FILTER_LAST = 2;
protected byte[] pngBytes;
protected byte[] priorRow;
protected byte[] leftBytes;
protected Image image;
protected int width, height;
protected int bytePos, maxPos;
protected int hdrPos, dataPos, endPos;
protected CRC32 crc = new CRC32();
protected long crcValue;
protected boolean encodeAlpha;
protected int filter;
protected int bytesPerPixel;
protected int compressionLevel;
/**
* Class constructor
*
*/
public PngEncoder()
{
this( null, false, FILTER_NONE, 0 );
}
/**
* Class constructor specifying Image to encode, with no alpha channel encoding.
*
* @param image A Java Image object which uses the DirectColorModel
* @see java.awt.Image
*/
public PngEncoder( Image image )
{
this(image, false, FILTER_NONE, 0);
}
/**
* Class constructor specifying Image to encode, and whether to encode alpha.
*
* @param image A Java Image object which uses the DirectColorModel
* @param encodeAlpha Encode the alpha channel? false=no; true=yes
* @see java.awt.Image
*/
public PngEncoder( Image image, boolean encodeAlpha )
{
this(image, encodeAlpha, FILTER_NONE, 0);
}
/**
* Class constructor specifying Image to encode, whether to encode alpha, and filter to use.
*
* @param image A Java Image object which uses the DirectColorModel
* @param encodeAlpha Encode the alpha channel? false=no; true=yes
* @param whichFilter 0=none, 1=sub, 2=up
* @see java.awt.Image
*/
public PngEncoder( Image image, boolean encodeAlpha, int whichFilter )
{
this( image, encodeAlpha, whichFilter, 0 );
}
/**
* Class constructor specifying Image source to encode, whether to encode alpha, filter to use, and compression level.
*
* @param image A Java Image object
* @param encodeAlpha Encode the alpha channel? false=no; true=yes
* @param whichFilter 0=none, 1=sub, 2=up
* @param compLevel 0..9
* @see java.awt.Image
*/
public PngEncoder( Image image, boolean encodeAlpha, int whichFilter,
int compLevel)
{
this.image = image;
this.encodeAlpha = encodeAlpha;
setFilter( whichFilter );
if (compLevel >=0 && compLevel <=9)
{
this.compressionLevel = compLevel;
}
}
/**
* Set the image to be encoded
*
* @param image A Java Image object which uses the DirectColorModel
* @see java.awt.Image
* @see java.awt.image.DirectColorModel
*/
public void setImage( Image image )
{
this.image = image;
pngBytes = null;
}
/**
* Creates an array of bytes that is the PNG equivalent of the current image, specifying whether to encode alpha or not.
*
* @param encodeAlpha boolean false=no alpha, true=encode alpha
* @return an array of bytes, or null if there was a problem
*/
public byte[] pngEncode( boolean encodeAlpha )
{
byte[] pngIdBytes = { -119, 80, 78, 71, 13, 10, 26, 10 };
int i;
if (image == null)
{
return null;
}
width = image.getWidth( null );
height = image.getHeight( null );
this.image = image;
/*
* start with an array that is big enough to hold all the pixels
* (plus filter bytes), and an extra 200 bytes for header info
*/
pngBytes = new byte[((width+1) * height * 3) + 200];
/*
* keep track of largest byte written to the array
*/
maxPos = 0;
bytePos = writeBytes( pngIdBytes, 0 );
hdrPos = bytePos;
writeHeader();
dataPos = bytePos;
if (writeImageData())
{
writeEnd();
pngBytes = resizeByteArray( pngBytes, maxPos );
}
else
{
pngBytes = null;
}
return pngBytes;
}
/**
* Creates an array of bytes that is the PNG equivalent of the current image.
* Alpha encoding is determined by its setting in the constructor.
*
* @return an array of bytes, or null if there was a problem
*/
public byte[] pngEncode()
{
return pngEncode( encodeAlpha );
}
/**
* Set the alpha encoding on or off.
*
* @param encodeAlpha false=no, true=yes
*/
public void setEncodeAlpha( boolean encodeAlpha )
{
this.encodeAlpha = encodeAlpha;
}
/**
* Retrieve alpha encoding status.
*
* @return boolean false=no, true=yes
*/
public boolean getEncodeAlpha()
{
return encodeAlpha;
}
/**
* Set the filter to use
*
* @param whichFilter from constant list
*/
public void setFilter( int whichFilter )
{
this.filter = FILTER_NONE;
if ( whichFilter <= FILTER_LAST )
{
this.filter = whichFilter;
}
}
/**
* Retrieve filtering scheme
*
* @return int (see constant list)
*/
public int getFilter()
{
return filter;
}
/**
* Set the compression level to use
*
* @param level 0 through 9
*/
public void setCompressionLevel( int level )
{
if ( level >= 0 && level <= 9)
{
this.compressionLevel = level;
}
}
/**
* Retrieve compression level
*
* @return int in range 0-9
*/
public int getCompressionLevel()
{
return compressionLevel;
}
/**
* Increase or decrease the length of a byte array.
*
* @param array The original array.
* @param newLength The length you wish the new array to have.
* @return Array of newly desired length. If shorter than the
* original, the trailing elements are truncated.
*/
protected byte[] resizeByteArray( byte[] array, int newLength )
{
byte[] newArray = new byte[newLength];
int oldLength = array.length;
System.arraycopy( array, 0, newArray, 0,
Math.min( oldLength, newLength ) );
return newArray;
}
/**
* Write an array of bytes into the pngBytes array.
* Note: This routine has the side effect of updating
* maxPos, the largest element written in the array.
* The array is resized by 1000 bytes or the length
* of the data to be written, whichever is larger.
*
* @param data The data to be written into pngBytes.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
*/
protected int writeBytes( byte[] data, int offset )
{
maxPos = Math.max( maxPos, offset + data.length );
if (data.length + offset > pngBytes.length)
{
pngBytes = resizeByteArray( pngBytes, pngBytes.length +
Math.max( 1000, data.length ) );
}
System.arraycopy( data, 0, pngBytes, offset, data.length );
return offset + data.length;
}
/**
* Write an array of bytes into the pngBytes array, specifying number of bytes to write.
* Note: This routine has the side effect of updating
* maxPos, the largest element written in the array.
* The array is resized by 1000 bytes or the length
* of the data to be written, whichever is larger.
*
* @param data The data to be written into pngBytes.
* @param nBytes The number of bytes to be written.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
*/
protected int writeBytes( byte[] data, int nBytes, int offset )
{
maxPos = Math.max( maxPos, offset + nBytes );
if (nBytes + offset > pngBytes.length)
{
pngBytes = resizeByteArray( pngBytes, pngBytes.length +
Math.max( 1000, nBytes ) );
}
System.arraycopy( data, 0, pngBytes, offset, nBytes );
return offset + nBytes;
}
/**
* Write a two-byte integer into the pngBytes array at a given position.
*
* @param n The integer to be written into pngBytes.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
*/
protected int writeInt2( int n, int offset )
{
byte[] temp = { (byte)((n >> 8) & 0xff),
(byte) (n & 0xff) };
return writeBytes( temp, offset );
}
/**
* Write a four-byte integer into the pngBytes array at a given position.
*
* @param n The integer to be written into pngBytes.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
*/
protected int writeInt4( int n, int offset )
{
byte[] temp = { (byte)((n >> 24) & 0xff),
(byte) ((n >> 16) & 0xff ),
(byte) ((n >> 8) & 0xff ),
(byte) ( n & 0xff ) };
return writeBytes( temp, offset );
}
/**
* Write a single byte into the pngBytes array at a given position.
*
* @param n The integer to be written into pngBytes.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
*/
protected int writeByte( int b, int offset )
{
byte[] temp = { (byte) b };
return writeBytes( temp, offset );
}
/**
* Write a string into the pngBytes array at a given position.
* This uses the getBytes method, so the encoding used will
* be its default.
*
* @param n The integer to be written into pngBytes.
* @param offset The starting point to write to.
* @return The next place to be written to in the pngBytes array.
* @see java.lang.String#getBytes()
*/
protected int writeString( String s, int offset )
{
return writeBytes( s.getBytes(), offset );
}
/**
* Write a PNG "IHDR" chunk into the pngBytes array.
*/
protected void writeHeader()
{
int startPos;
startPos = bytePos = writeInt4( 13, bytePos );
bytePos = writeString( "IHDR", bytePos );
width = image.getWidth( null );
height = image.getHeight( null );
bytePos = writeInt4( width, bytePos );
bytePos = writeInt4( height, bytePos );
bytePos = writeByte( 8, bytePos ); // bit depth
bytePos = writeByte( (encodeAlpha) ? 6 : 2, bytePos ); // direct model
bytePos = writeByte( 0, bytePos ); // compression method
bytePos = writeByte( 0, bytePos ); // filter method
bytePos = writeByte( 0, bytePos ); // no interlace
crc.reset();
crc.update( pngBytes, startPos, bytePos-startPos );
crcValue = crc.getValue();
bytePos = writeInt4( (int) crcValue, bytePos );
}
/**
* Perform "sub" filtering on the given row.
* Uses temporary array leftBytes to store the original values
* of the previous pixels. The array is 16 bytes long, which
* will easily hold two-byte samples plus two-byte alpha.
*
* @param pixels The array holding the scan lines being built
* @param startPos Starting position within pixels of bytes to be filtered.
* @param width Width of a scanline in pixels.
*/
protected void filterSub( byte[] pixels, int startPos, int width )
{
int i;
int offset = bytesPerPixel;
int actualStart = startPos + offset;
int nBytes = width * bytesPerPixel;
int leftInsert = offset;
int leftExtract = 0;
byte current_byte;
for (i=actualStart; i < startPos + nBytes; i++)
{
leftBytes[leftInsert] = pixels[i];
pixels[i] = (byte) ((pixels[i] - leftBytes[leftExtract]) % 256);
leftInsert = (leftInsert+1) % 0x0f;
leftExtract = (leftExtract + 1) % 0x0f;
}
}
/**
* Perform "up" filtering on the given row.
* Side effect: refills the prior row with current row
*
* @param pixels The array holding the scan lines being built
* @param startPos Starting position within pixels of bytes to be filtered.
* @param width Width of a scanline in pixels.
*/
protected void filterUp( byte[] pixels, int startPos, int width )
{
int i, nBytes;
byte current_byte;
nBytes = width * bytesPerPixel;
for (i=0; i < nBytes; i++)
{
current_byte = pixels[startPos + i];
pixels[startPos + i] = (byte) ((pixels[startPos + i] - priorRow[i]) % 256);
priorRow[i] = current_byte;
}
}
/**
* Write the image data into the pngBytes array.
* This will write one or more PNG "IDAT" chunks. In order
* to conserve memory, this method grabs as many rows as will
* fit into 32K bytes, or the whole image; whichever is less.
*
*
* @return true if no errors; false if error grabbing pixels
*/
protected boolean writeImageData()
{
int rowsLeft = height; // number of rows remaining to write
int startRow = 0; // starting row to process this time through
int nRows; // how many rows to grab at a time
byte[] scanLines; // the scan lines to be compressed
int scanPos; // where we are in the scan lines
int startPos; // where this line's actual pixels start (used for filtering)
byte[] compressedLines; // the resultant compressed lines
int nCompressed; // how big is the compressed area?
int depth; // color depth ( handle only 8 or 32 )
PixelGrabber pg;
bytesPerPixel = (encodeAlpha) ? 4 : 3;
Deflater scrunch = new Deflater( compressionLevel );
ByteArrayOutputStream outBytes =
new ByteArrayOutputStream(1024);
DeflaterOutputStream compBytes =
new DeflaterOutputStream( outBytes, scrunch );
try
{
while (rowsLeft > 0)
{
nRows = Math.min( 32767 / (width*(bytesPerPixel+1)), rowsLeft );
// nRows = rowsLeft;
int[] pixels = new int[width * nRows];
pg = new PixelGrabber(image, 0, startRow,
width, nRows, pixels, 0, width);
try {
pg.grabPixels();
}
catch (Exception e) {
System.err.println("interrupted waiting for pixels!");
return false;
}
if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
System.err.println("image fetch aborted or errored");
return false;
}
/*
* Create a data chunk. scanLines adds "nRows" for
* the filter bytes.
*/
scanLines = new byte[width * nRows * bytesPerPixel + nRows];
if (filter == FILTER_SUB)
{
leftBytes = new byte[16];
}
if (filter == FILTER_UP)
{
priorRow = new byte[width*bytesPerPixel];
}
scanPos = 0;
startPos = 1;
for (int i=0; i<width*nRows; i++)
{
if (i % width == 0)
{
scanLines[scanPos++] = (byte) filter;
startPos = scanPos;
}
scanLines[scanPos++] = (byte) ((pixels[i] >> 16) & 0xff);
scanLines[scanPos++] = (byte) ((pixels[i] >> 8) & 0xff);
scanLines[scanPos++] = (byte) ((pixels[i] ) & 0xff);
if (encodeAlpha)
{
scanLines[scanPos++] = (byte) ((pixels[i] >> 24) & 0xff );
}
if ((i % width == width-1) && (filter != FILTER_NONE))
{
if (filter == FILTER_SUB)
{
filterSub( scanLines, startPos, width );
}
if (filter == FILTER_UP)
{
filterUp( scanLines, startPos, width );
}
}
}
/*
* Write these lines to the output area
*/
compBytes.write( scanLines, 0, scanPos );
startRow += nRows;
rowsLeft -= nRows;
}
compBytes.close();
/*
* Write the compressed bytes
*/
compressedLines = outBytes.toByteArray();
nCompressed = compressedLines.length;
crc.reset();
bytePos = writeInt4( nCompressed, bytePos );
bytePos = writeString("IDAT", bytePos );
crc.update("IDAT".getBytes());
bytePos = writeBytes( compressedLines, nCompressed, bytePos );
crc.update( compressedLines, 0, nCompressed );
crcValue = crc.getValue();
bytePos = writeInt4( (int) crcValue, bytePos );
scrunch.finish();
return true;
}
catch (IOException e)
{
System.err.println( e.toString());
return false;
}
}
/**
* Write a PNG "IEND" chunk into the pngBytes array.
*/
protected void writeEnd()
{
bytePos = writeInt4( 0, bytePos );
bytePos = writeString( "IEND", bytePos );
crc.reset();
crc.update("IEND".getBytes());
crcValue = crc.getValue();
bytePos = writeInt4( (int) crcValue, bytePos );
}
}

[ April 28, 2003: Message edited by: Igor Zeta ]

22 years ago

creating Image

Hi,
If you want to write the image using the gif format you can use GIF89Encoder that you can find on the acme site
I've found it very simple to use. I give you a snippet of code

Hope it helps!

22 years ago

Now, looking for some problems related to palettes I've decided to work with png that can store more colours occuping low memory size.
Have you some snippet of code for write down to
a png file format from an Image?
In few words using your code...

thanks!
[ March 24, 2003: Message edited by: Igor Zeta ]

22 years ago

Ok,
very usefull post.
Now I read, modify the colour and write to a gif
format.
But, Do you know why some gif I'm not able to modify and other yes.
I've been finding that it's a problem related to the image palette.Or not?
Any suggestion?
thanks!

22 years ago

I've to change colour of five images.
I've already setted up the chain that
get the user able to choose the colour
and generate the output with the desired
colours of other html elements.
Now I need to change the colour of gif images.
In other words I need to load in memory a gif image change the colour and write down to the file system.
I've come through sun site and I've found
something about MediaTracker but I'm not sure it's what I'm looking for...
I've seen something about JAI...
Some example?Some suggestion?
thanks

22 years ago

how to have an image painted having in input the same image.
Any suggestion?

22 years ago