/[classpath]/classpath/javax/swing/ProgressMonitorInputStream.java
ViewVC logotype

Diff of /classpath/javax/swing/ProgressMonitorInputStream.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2.2.2 by gnu_andrew, Tue Aug 2 20:12:37 2005 UTC revision 1.2.2.3 by gnu_andrew, Tue Sep 20 18:46:32 2005 UTC
# Line 1  Line 1 
1  /* ProgressMonitorInputStream.java --  /* ProgressMonitorInputStream.java --
2     Copyright (C) 2002, 2004 Free Software Foundation, Inc.     Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
3    
4  This file is part of GNU Classpath.  This file is part of GNU Classpath.
5    
# Line 39  exception statement from your version. * Line 39  exception statement from your version. *
39  package javax.swing;  package javax.swing;
40    
41  import java.awt.Component;  import java.awt.Component;
42    
43  import java.io.FilterInputStream;  import java.io.FilterInputStream;
 import java.io.IOException;  
44  import java.io.InputStream;  import java.io.InputStream;
45    import java.io.InterruptedIOException;
46    import java.io.IOException;
47    
48  /**  /**
49   * ProgressMonitorInputStream   * ProgressMonitorInputStream
50   * @author      Andrew Selkirk   * @author      Andrew Selkirk
51   * @version     1.0   * @author  Robert Schuster (robertschuster@fsfe.org)
52     * @status updated to 1.2
53     * @since 1.2
54   */   */
55  public class ProgressMonitorInputStream extends FilterInputStream {  public class ProgressMonitorInputStream extends FilterInputStream
56    {
         //-------------------------------------------------------------  
         // Variables --------------------------------------------------  
         //-------------------------------------------------------------  
   
         /**  
          * monitor  
          */  
         private ProgressMonitor monitor;  
   
         /**  
          * nread  
          */  
         private int nread;  
   
         /**  
          * size  
          */  
         private int size;  
   
   
         //-------------------------------------------------------------  
         // Initialization ---------------------------------------------  
         //-------------------------------------------------------------  
   
         /**  
          * Constructor ProgressMonitorInputStream  
          * @param component TODO  
          * @param message TODO  
          * @param stream TODO  
          */  
         public ProgressMonitorInputStream(Component component, Object message,  
                         InputStream stream) {  
                 super(stream);  
                 // TODO  
         } // ProgressMonitorInputStream()  
   
   
         //-------------------------------------------------------------  
         // Methods ----------------------------------------------------  
         //-------------------------------------------------------------  
   
         /**  
          * reset  
          * @exception IOException TODO  
          */  
         public synchronized void reset() throws IOException {  
                 // TODO  
         } // reset()  
   
         /**  
          * read  
          * @exception IOException TODO  
          * @returns int  
          */  
         public int read() throws IOException {  
                 return 0; // TODO  
         } // read()  
   
         /**  
          * read  
          * @param data TODO  
          * @exception IOException TODO  
          * @returns int  
          */  
         public int read(byte[] data) throws IOException {  
                 return 0; // TODO  
         } // read()  
   
         /**  
          * read  
          * @param data TODO  
          * @param offset TODO  
          * @param length TODO  
          * @exception IOException TODO  
          * @returns int  
          */  
         public int read(byte[] data, int offset, int length) throws IOException {  
                 return 0; // TODO  
         } // read()  
   
         /**  
          * skip  
          * @param length TODO  
          * @exception IOException TODO  
          * @returns long  
          */  
         public long skip(long length) throws IOException {  
                 return 0; // TODO  
         } // skip()  
   
         /**  
          * close  
          * @exception IOException TODO  
          */  
         public void close() throws IOException {  
                 // TODO  
         } // close()  
   
         /**  
          * getProgressMonitor  
          * @returns ProgressMonitor  
          */  
         public ProgressMonitor getProgressMonitor() {  
                 return null; // TODO  
         } // getProgressMonitor()  
57    
58      /**
59       * monitor
60       */
61      private ProgressMonitor monitor;
62    
63      /**
64       * read
65       */
66      private int read;
67    
68      /**
69       * Constructor ProgressMonitorInputStream
70       * @param component TODO
71       * @param message TODO
72       * @param stream TODO
73       */
74      public ProgressMonitorInputStream(Component component, Object message,
75                                        InputStream stream)
76      {
77        super(stream);
78    
79        int max = 0;
80            
81        try
82          {
83            max = stream.available();
84          }
85        catch ( IOException ioe )
86          {
87            // Behave like the JDK here.
88          }
89    
90        monitor = new ProgressMonitor(
91          component, message, null, 0, max );
92      }
93    
94      /**
95       * reset
96       * @exception IOException TODO
97       */
98      public void reset() throws IOException
99      {
100        super.reset();
101    
102        checkMonitorCanceled();
103    
104        // TODO: The docs says the monitor should be resetted. But to which
105        // value? (mark is not overridden)
106      }
107    
108      /**
109       * read
110       * @exception IOException TODO
111       * @returns int
112       */
113      public int read() throws IOException
114      {
115        int t = super.read();
116    
117        monitor.setProgress(++read);
118    
119        checkMonitorCanceled();
120    
121        return t;
122      }
123    
124      /**
125       * read
126       * @param data TODO
127       * @exception IOException TODO
128       * @returns int
129       */
130      public int read(byte[] data) throws IOException
131      {
132        int t = super.read(data);
133    
134        if ( t > 0 )
135          {
136            read += t;
137            monitor.setProgress(read);
138    
139            checkMonitorCanceled();
140          }
141        else
142          {
143            monitor.close();
144          }
145    
146        return t;
147      }
148    
149      /**
150       * read
151       * @param data TODO
152       * @param offset TODO
153       * @param length TODO
154       * @exception IOException TODO
155       * @returns int
156       */
157      public int read(byte[] data, int offset, int length) throws IOException
158      {
159        int t = super.read(data, offset, length);
160    
161        if ( t > 0 )
162          {
163            read += t;
164            monitor.setProgress(read);
165    
166            checkMonitorCanceled();
167          }
168        else
169          {
170            monitor.close();
171          }
172    
173        return t;
174      }
175    
176      /**
177       * skip
178       * @param length TODO
179       * @exception IOException TODO
180       * @returns long
181       */
182      public long skip(long length) throws IOException
183      {
184        long t = super.skip(length);
185    
186        // 'read' may overflow here in rare situations.
187        assert ( (long) read + t <= (long) Integer.MAX_VALUE );
188    
189        read += (int) t;
190    
191        monitor.setProgress(read);
192    
193        checkMonitorCanceled();
194    
195        return t;
196      }
197    
198      /**
199       * close
200       * @exception IOException TODO
201       */
202      public void close() throws IOException
203      {
204        super.close();
205        monitor.close();
206      }
207    
208      /**
209       * getProgressMonitor
210       * @returns ProgressMonitor
211       */
212      public ProgressMonitor getProgressMonitor()
213      {
214        return monitor;
215      }
216    
217      private void checkMonitorCanceled() throws InterruptedIOException
218      {
219        if ( monitor.isCanceled() )
220          {
221            throw new InterruptedIOException("ProgressMonitor was canceled");
222          }
223      }
224    
225  } // ProgressMonitorInputStream  }

Legend:
Removed from v.1.2.2.2  
changed lines
  Added in v.1.2.2.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26