Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2010, 2011 SAP AG All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: Lazar Kirchev, SAP AG - initial API and implementation /
 
 
 package org.eclipse.equinox.console.common;
 
 import java.util.Map;
 import java.util.Set;
 
This class performs the processing of the input special characters, and updates respectively what is displayed in the output. It handles escape sequences, delete, backspace, arrows, insert, home, end, pageup, pagedown, tab completion.
 
 public class ConsoleInputScanner extends Scanner {
 
 	private static final byte TAB = 9;
     private boolean isCR = false;
     private boolean replace = false;
     private boolean isCompletionMode = false;
     // shows if command history should be saved - it is turned off in cases when passwords are to be entered
     private boolean isHistoryEnabled = true;
 
     private final HistoryHolder history;
     private final SimpleByteBuffer buffer;
     private CommandSession session;
     private BundleContext context;
     private Candidates candidates;
     private int originalCursorPos;
 
     public ConsoleInputScanner(ConsoleInputStream toShellOutputStream toTelnet) {
         super(toShelltoTelnet);
          = new HistoryHolder();
          = new SimpleByteBuffer();
     }
     
     public void toggleHistoryEnabled(boolean isEnabled) {
     	 = isEnabled;
     }
     
     public void setSession(CommandSession session) {
     	this. = session
     }
 
     public void setContext(BundleContext context) {
     	this. = context;
     }
     
     public void scan(int bthrows IOException {
         b &= 0xFF;
         if () {
              = false;
             if (b == ) {
                 return;
             }
         }
         
         if (b != ) {
     		if ( == true) {
     			 = false;
     			 = null;
     			 = 0;
     		}
     	}
         
         if () {
             scanEsc(b);
         } else {
             if (b == getBackspace()) {
         		backSpace();
         	} else if(b == ) {
         		if ( == false) {
         			 = true;
         			processTab();
         		} else {
         			processNextTab();
         		}
         	} else if (b == ) {
         		 = true;
         		processData();
         	} else if (b == ) {
         		processData();
         	} else if (b == ) {
         		startEsc();
             } else if (b == getDel()) {
        		delete();
        	} else {
        		if (b >=  && b < ) {
        			newChar(b);
        		}
        	}
        }
    }
    private void delete() throws IOException {
        clearLine();
        .delete();
        echoBuff();
        flush();
    }
    private void backSpace() throws IOException {
        clearLine();
        .backSpace();
        echoBuff();
        flush();
    }
    protected void clearLine() throws IOException {
        int size = .getSize();
        int pos = .getPos();
        for (int i = size - posi < sizei++) {
            echo();
        }
        for (int i = 0; i < sizei++) {
            echo();
        }
        for (int i = 0; i < sizei++) {
            echo();
        }
    }
    protected void echoBuff() throws IOException {
        byte[] data = .copyCurrentData();
        for (byte b : data) {
            echo(b);
        }
        int pos = .getPos();
        for (int i = data.lengthi > posi--) {
            echo();
        }
    }
    protected void newChar(int bthrows IOException {
        if (.getPos() < .getSize()) {
            if () {
                .replace(b);
            } else {
                .insert(b);
            }
            clearLine();
            echoBuff();
            flush();
        } else {
            if () {
                .replace(b);
            } else {
                .insert(b);
            }
        }
    }
    
    protected void processTab() throws IOException {
    	CompletionHandler completionHandler = new CompletionHandler();
    	Map<StringIntegercompletionCandidates = completionHandler.getCandidates(.copyCurrentData(), .getPos());
    	
    	if (completionCandidates.size() == 1) {	
            completeSingleCandidate(completionCandidates);   
             = false;
            return;
        }
    	printNewLine();
        if (completionCandidates.size() == 0) {
            printCompletionError();
             = false;
        } else {
        	processCandidates(completionCandidates);
        }
        printNewLine();
        printPrompt();
    }
    
    protected void processCandidates(Map<StringIntegercompletionCandidatesthrows IOException{
    	Set<StringcandidatesNamesSet = completionCandidates.keySet();
        String[] candidatesNames = (candidatesNamesSet.toArray(new String[0]));
    	String[] candidateSuffixes = new String[candidatesNames.length];
        for (int i = 0; i < candidatesNames.lengthi++) {
        	String candidateName = candidatesNames[i];
        	candidateSuffixes[i] = getCandidateSuffix(candidateNamecompletionCandidates.get(candidateName), );
            for (byte symbol : candidateName.getBytes()) {
                echo(symbol);
            }
            printNewLine();
        }
        
        String commonPrefix = getCommonPrefix(candidateSuffixes);
         = new Candidates(removeCommonPrefix(candidateSuffixescommonPrefix));
        printString(commonPrefixfalse);
         = .getPos();
    }
    
    protected void processNextTab() throws IOException {
    	if ( == null) {
    		return;
    	}
    	
    	while ( < .getPos()) {
    	}
    	
    	String candidate = .getCurrent();
    	if(!candidate.equals("")) {
    		printString(candidatetrue);
    	}
    }
    
    protected void printCandidate(String candidateint startIndexint completionIndexthrows IOException {
    	String suffix = getCandidateSuffix(candidatestartIndexcompletionIndex);
    	if(suffix.equals("")) {
    		return;
    	}
        printString(suffixtrue);
    }
    
    protected void printString(String stboolean isEchothrows IOException {
    	for (byte symbol : st.getBytes()) {
            .insert(symbol);
            if (isEcho){
            	echo(symbol);
            }
        }
        flush();
    }
    
    protected String getCommonPrefix(String[] names) {
    	if (names.length == 0) {
    		return "";
    	}
    	
    	if (names.length == 1) {
    		return names[0];
    	}
    	
    	StringBuilder builder = new StringBuilder();
    	char[] name = names[0].toCharArray();
    	for(char c : name) {
    		String prefix = builder.append(c).toString();
    		for (int i = 1; i < names.lengthi ++) {
    			if (!names[i].startsWith(prefix)) {
    				return prefix.substring(0, prefix.length() - 1);
    			}
    		}
    	}
    	
    	return builder.toString();
    }
    
    protected String[] removeCommonPrefix(String [] namesString commonPrefix){
    	ArrayList<Stringresult = new ArrayList<String>();
    	for (String name : names) {
    		String nameWithoutPrefix = name.substring(commonPrefix.length());
    		if (nameWithoutPrefix.length() > 0) {
    			result.add(nameWithoutPrefix);
    		}
    	}
    	result.add("");
    	return result.toArray(new String[0]);
    }
    
    protected String getCandidateSuffix(String candidateint startIndexint completionIndex) {
    	int partialLength = completionIndex - startIndex;
        if (partialLength >= candidate.length()) {
        	return "";
        }
        return candidate.substring(partialLength);
    }
    
    protected void completeSingleCandidate(Map<StringIntegercompletionCandidatesthrows IOException {
    	Set<Stringkeys = completionCandidates.keySet();
        String key = (keys.toArray(new String[0]))[0];
        int startIndex = completionCandidates.get(key);
        printCandidate(keystartIndex.getPos()); 
    }
    
    protected void printCompletionError() throws IOException {
    	byte[] curr = .getCurrentData();
        if ( == true) {
        	.add(curr);
        }
        
        String errorMessage = "No completion available";
        for (byte symbol : errorMessage.getBytes()) {
            echo(symbol);
        }
    }
    
    protected void printNewLine() throws IOException{
    	echo();
        echo();
        flush();
    }
    
    protected void printPrompt() throws IOException{
    	echo('o');
        echo('s');
        echo('g');
        echo('i');
        echo('>');
        echo();
        echoBuff();
        flush();
    }
    private void processData() throws IOException {
//        buffer.add(CR);
        .add();
        echo();
        echo();
        flush();
        byte[] curr = .getCurrentData();
        if ( == true) {
        	.add(curr);
        }
        .add(curr);
    }
    public void resetHistory() {
        .reset();
    }
    protected void scanEsc(final int bthrows IOException {
         += (charb;
        KEYS key = checkEscape();
        if (key == .) {
            return;
        }
        if (key == .) {
             = false;
            scan(b);
            return;
        }
         = false;
        switch (key) {
            case :
                processUpArrow();
                break;
            case :
                processDownArrow();
                break;
            case :
                processRightArrow();
                break;
            case :
                processLeftArrow();
                break;
            case :
                processHome();
                break;
            case :
                processEnd();
                break;
            case :
                processPgUp();
                break;
            case :
                processPgDn();
                break;
            case :
                processIns();
                break;
            case :
                delete();
                break;
            default//CENTER
                break;
        }
    }
    private static final byte[] INVERSE_ON = {'[''7''m'};
    private static final byte[] INVERSE_OFF = {'[''2''7''m'};
    private void echo(byte[] datathrows IOException {
        for (byte b : data) {
            echo(b);
        }
    }
    private void processIns() throws IOException {
         = !;
        int b = .getCurrentChar();
        echo();
        echo( ? 'R' : 'I');
        flush();
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            //do not care $JL-EXC$
        }
        echo();
        echo();
        echo(b == -1 ?  : b);
        echo();
        flush();
    }
    private void processPgDn() throws IOException {
        byte[] last = .last();
        if (last != null) {
            clearLine();
            .set(last);
            echoBuff();
            flush();
        }
    }
    private void processPgUp() throws IOException {
        byte[] first = .first();
        if (first != null) {
            clearLine();
            .set(first);
            echoBuff();
            flush();
        }
    }
    private void processHome() throws IOException {
        int pos = .resetPos();
        if (pos > 0) {
            for (int i = 0; i < posi++) {
                echo();
            }
            flush();
        }
    }
    private void processEnd() throws IOException {
        int b;
        while ((b = .goRight()) != -1) {
            echo(b);
        }
        flush();
    }
    private void processLeftArrow() throws IOException {
        if (.goLeft()) {
            echo();
            flush();
        }
    }
    private void processRightArrow() throws IOException {
        int b = .goRight();
        if (b != -1) {
            echo(b);
            flush();
        }
    }
    private void processDownArrow() throws IOException {
        byte[] next = .next();
        if (next != null) {
            clearLine();
            .set(next);
            echoBuff();
            flush();
        }
    }
    private void processUpArrow() throws IOException {
        clearLine();
        byte[] prev = .prev();
        .set(prev);
        echoBuff();
        flush();
    }
    
    private static class Candidates {
    	private String[] candidates;
    	private int currentCandidateIndex = 0;
    	
    	public Candidates(String[] candidates) {
    		this. = candidates.clone();
    	}
    	
    	public String getCurrent() {
    			 = 0;
    		}
    		
    	}
    }
New to GrepCode? Check out our FAQ X