--- a/dwt/internal/image/PngLzBlockReader.d	Fri Sep 12 13:53:21 2008 +0200
+++ b/dwt/internal/image/PngLzBlockReader.d	Sun Sep 14 01:45:57 2008 +0200
@@ -1,4 +1,4 @@
-/*******************************************************************************
+/*******************************************************************************
  * Copyright (c) 2000, 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
@@ -7,10 +7,13 @@
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
+ * Port to the D programming language:
+ *     Frank Benoit <benoit@tionex.de>
  *******************************************************************************/
-module dwt.internal.image;
+module dwt.internal.image.PngLzBlockReader;
 
-import java.io.IOException;
+import dwt.internal.image.PngDecodingDataStream;
+import dwt.internal.image.PngHuffmanTables;
 
 public class PngLzBlockReader {
     bool isLastBlock;
@@ -18,41 +21,41 @@
     int uncompressedBytesRemaining;
     PngDecodingDataStream stream;
     PngHuffmanTables huffmanTables;
-    
+
     byte[] window;
     int windowIndex;
     int copyIndex;
     int copyBytesRemaining;
-    
-    static final int UNCOMPRESSED = 0;
-    static final int COMPRESSED_FIXED = 1;
-    static final int COMPRESSED_DYNAMIC = 2;
+
+    static const int UNCOMPRESSED = 0;
+    static const int COMPRESSED_FIXED = 1;
+    static const int COMPRESSED_DYNAMIC = 2;
 
-    static final int END_OF_COMPRESSED_BLOCK = 256;
-    static final int FIRST_LENGTH_CODE = 257;
-    static final int LAST_LENGTH_CODE = 285;
-    static final int FIRST_DISTANCE_CODE = 1;
-    static final int LAST_DISTANCE_CODE = 29;
-    static final int FIRST_CODE_LENGTH_CODE = 4;
-    static final int LAST_CODE_LENGTH_CODE = 19;
+    static const int END_OF_COMPRESSED_BLOCK = 256;
+    static const int FIRST_LENGTH_CODE = 257;
+    static const int LAST_LENGTH_CODE = 285;
+    static const int FIRST_DISTANCE_CODE = 1;
+    static const int LAST_DISTANCE_CODE = 29;
+    static const int FIRST_CODE_LENGTH_CODE = 4;
+    static const int LAST_CODE_LENGTH_CODE = 19;
 
-    static final int[] lengthBases = {
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 
+    static const int[] lengthBases = [
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27,
         31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
-    } ; 
-    static final int[] extraLengthBits = {
-        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 
+    ];
+    static const int[] extraLengthBits = [
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
         3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,
-    };
-    static final int[] distanceBases = {
+    ];
+    static const int[] distanceBases = [
         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129,
         193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097,
         6145, 8193, 12289, 16385, 24577,
-    };
-    static final int[] extraDistanceBits = {
+    ];
+    static const int[] extraDistanceBits = [
         0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7,  7,
         8,  8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
-    };  
+    ];
 
 
 this(PngDecodingDataStream stream) {
@@ -62,13 +65,13 @@
 
 void setWindowSize(int windowSize) {
     window = new byte[windowSize];
-}   
+}
 
-void readNextBlockHeader() {
+void readNextBlockHeader()  {
     isLastBlock = stream.getNextIdatBit() !is 0;
     compressionType = cast(byte)(stream.getNextIdatBits(2) & 0xFF);
-    if (compressionType > 2) stream.error();    
-    
+    if (compressionType > 2) stream.error();
+
     if (compressionType is UNCOMPRESSED) {
         byte b1 = stream.getNextIdatByte();
         byte b2 = stream.getNextIdatByte();
@@ -83,7 +86,7 @@
     }
 }
 
-byte getNextByte() {
+byte getNextByte()  {
     if (compressionType is UNCOMPRESSED) {
         if (uncompressedBytesRemaining is 0) {
             readNextBlockHeader();
@@ -103,43 +106,43 @@
     }
 }
 
-private void assertBlockAtEnd() {
+private void assertBlockAtEnd()  {
     if (compressionType is UNCOMPRESSED) {
         if (uncompressedBytesRemaining > 0) stream.error();
     } else if (copyBytesRemaining > 0 ||
-        (huffmanTables.getNextLiteralValue(stream) !is END_OF_COMPRESSED_BLOCK)) 
+        (huffmanTables.getNextLiteralValue(stream) !is END_OF_COMPRESSED_BLOCK))
     {
-        stream.error();     
+        stream.error();
     }
 }
-void assertCompressedDataAtEnd() {
-    assertBlockAtEnd();     
+void assertCompressedDataAtEnd()  {
+    assertBlockAtEnd();
     while (!isLastBlock) {
         readNextBlockHeader();
         assertBlockAtEnd();
-    }   
+    }
 }
 
-private byte getNextCompressedByte() {
+private byte getNextCompressedByte()  {
     if (copyBytesRemaining > 0) {
         byte value = window[copyIndex];
         window[windowIndex] = value;
         copyBytesRemaining--;
-        
+
         copyIndex++;
-        windowIndex++;      
+        windowIndex++;
         if (copyIndex is window.length) copyIndex = 0;
         if (windowIndex is window.length) windowIndex = 0;
 
-        return value;       
+        return value;
     }
-    
+
     int value = huffmanTables.getNextLiteralValue(stream);
     if (value < END_OF_COMPRESSED_BLOCK) {
         window[windowIndex] = cast(byte) (value & 0xFF);
         windowIndex++;
         if (windowIndex >= window.length) windowIndex = 0;
-        return cast(byte) (value & 0xFF);       
+        return cast(byte) (value & 0xFF);
     } else if (value is END_OF_COMPRESSED_BLOCK) {
         readNextBlockHeader();
         return getNextByte();
@@ -149,7 +152,7 @@
         if (extraBits > 0) {
             length += stream.getNextIdatBits(extraBits);
         }
-        
+
         value = huffmanTables.getNextDistanceValue(stream);
         if (value > LAST_DISTANCE_CODE) stream.error();
         extraBits = extraDistanceBits[value];
@@ -157,7 +160,7 @@
         if (extraBits > 0) {
             distance += stream.getNextIdatBits(extraBits);
         }
-        
+
         copyIndex = windowIndex - distance;
         if (copyIndex < 0) copyIndex += window.length;
 
@@ -168,5 +171,5 @@
         return 0;
     }
 }
-    
+
 }