FileViewer.java Source code

Introduction

Here is the source code for FileViewer.java

Source

/******************************************************************************
 * All Right Reserved. 
 * Copyright (c) 1998, 2004 Jackwind Li Guojie
 * 
 * Created on 2004-5-13 10:10:07 by JACK
 * $Id$
 * 
 *****************************************************************************/
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.StatusLineManager;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class FileViewer extends ApplicationWindow {
    // The text control used to display the file content.
    Text text;

    String content;
    String lineDelimiter;

    IRunnableWithProgress runnableWithProgress = new IRunnableWithProgress() {
        public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
            System.out.println("Running from thread: " + Thread.currentThread().getName());

            getShell().getDisplay().syncExec(new Runnable() {
                public void run() {
                    content = text.getText();
                    lineDelimiter = text.getLineDelimiter();
                }
            });

            monitor.beginTask("Counting total number of lines", content.length());
            int lines = 1;
            for (int i = 0; i < content.length(); i++) {
                if (monitor.isCanceled()) { // checks whether the operation has been cancelled.
                    monitor.done();
                    System.out.println("Action cancelled");
                    return;
                }

                // Checks the existance of the line delimiter.
                if (i + lineDelimiter.length() < content.length()) {
                    if (lineDelimiter.equals(content.substring(i, i + lineDelimiter.length()))) {
                        lines++;
                    }
                }

                monitor.worked(1);
                Thread.sleep(1); // 1ms
            }

            monitor.done();
            System.out.println("Total number of lines: " + lines);
        }
    };

    Action actionCount = new Action("Count", ImageDescriptor.createFromFile(null, "icons/run.gif")) {
        public void run() {
            try {
                FileViewer.this.run(true, true, runnableWithProgress);
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

    /**
     * @param parentShell
     */
    public FileViewer(Shell parentShell) {
        super(parentShell);
        addMenuBar();
        addStatusLine();
        addToolBar(SWT.FLAT);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.Composite)
     */
    protected Control createContents(Composite parent) {
        getShell().setText("FileViewer v2.0");
        setStatus("Ready");

        text = new Text(parent, SWT.MULTI | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
        text.setSize(300, 200);
        return text;
    }

    Action actionOpenFile = new Action("Open", ImageDescriptor.createFromFile(null, "icons/open.gif")) {
        public void run() {
            FileDialog dialog = new FileDialog(getShell(), SWT.OPEN);
            final String file = dialog.open();
            if (file != null) {
                try {
                    String content = readFileAsAString(new File(file));
                    text.setText(content);
                    setStatus("File loaded successfully: " + file);
                } catch (IOException e) {
                    e.printStackTrace();
                    setStatus("Failed to load file: " + file);
                }
            }
        }
    };

    /* (non-Javadoc)
     * @see org.eclipse.jface.window.ApplicationWindow#createMenuManager()
     */
    protected MenuManager createMenuManager() {
        MenuManager menuManager = new MenuManager("");

        MenuManager fileMenuManager = new MenuManager("&File");
        fileMenuManager.add(actionOpenFile);

        menuManager.add(fileMenuManager);

        MenuManager toolsMenuManager = new MenuManager("&Tools");
        toolsMenuManager.add(actionCount);
        menuManager.add(toolsMenuManager);

        return menuManager;
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.window.ApplicationWindow#createStatusLineManager()
     */
    protected StatusLineManager createStatusLineManager() {
        return super.createStatusLineManager();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.window.ApplicationWindow#createToolBarManager(int)
     */
    protected ToolBarManager createToolBarManager(int style) {
        ToolBarManager toolBarManager = new ToolBarManager(style);
        toolBarManager.add(actionOpenFile);
        toolBarManager.add(actionCount);

        return toolBarManager;
    }

    public static void main(String[] args) {
        ApplicationWindow viewer = new FileViewer(null);
        viewer.setBlockOnOpen(true);
        viewer.open();
    }

    /**
     * Reads the content of a file into a String. 
     * @param file file to be read
     * @return
     * @throws IOException
     */
    public static String readFileAsAString(File file) throws IOException {
        return new String(getBytesFromFile(file));
    }

    /**
     * Returns the contents of the file in a byte array. 
     * @param file
     * @return
     * @throws IOException
     */
    public static byte[] getBytesFromFile(File file) throws IOException {
        InputStream is = new FileInputStream(file);

        // Get the size of the file
        long length = file.length();

        // You cannot create an array using a long type.
        // It needs to be an int type.
        // Before converting to an int type, check
        // to ensure that file is not larger than Integer.MAX_VALUE.
        if (length > Integer.MAX_VALUE) {
            // File is too large
            throw new IllegalArgumentException("File is too large! (larger or equal to 2G)");
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[(int) length];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;
        while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
            offset += numRead;
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file " + file.getName());
        }

        // Close the input stream and return bytes
        is.close();
        return bytes;
    }
}