Home Aktuell Meine lieblings HTML Tastatur

Meine lieblings HTML Tastatur

Hey Leute, in meinem aller ersten Blogeintrag will ich euch mein lieblings Keyboard auf html Basis nahelegen. Ich benutze sie gerne und denke deshalbt, dass sie auch für euch perfekt sind.

Da ich noch nicht so viel Erfahrung mit langen Texten habe, fange ich einfach direkt mal an 

//********************************************************************
//  Keyboard.java       Author: Lewis and Loftus
//
//  Facilitates keyboard input by abstracting details about input
//  parsing, conversions, and exception handling.
//********************************************************************

import java.io.*;
import java.util.*;


public class Keyboard 
{
    //*************  Error Handling Section  **************************

    private static boolean printErrors = true;
    private static int errorCount = 0;

    //-----------------------------------------------------------------
    //  Returns the current error count.
    //-----------------------------------------------------------------
    public static int getErrorCount() {
        return errorCount;
    }

    //-----------------------------------------------------------------
    //  Resets the current error count to zero.
    //-----------------------------------------------------------------
    public static void resetErrorCount(int count) {
        errorCount = 0;
    }

    //-----------------------------------------------------------------
    //  Returns a boolean indicating whether input errors are
    //  currently printed to standard output.
    //-----------------------------------------------------------------
    public static boolean getPrintErrors() {
        return printErrors;
    }

    //-----------------------------------------------------------------
    //  Sets a boolean indicating whether input errors are to be
    //  printed to standard output.
    //-----------------------------------------------------------------
    public static void setPrintErrors(boolean flag) {
        printErrors = flag;
    }

    //-----------------------------------------------------------------
    //  Increments the error count and prints the error message if
    //  appropriate.
    //-----------------------------------------------------------------
    private static void error(String str)  
    {  
        errorCount++;
        if (printErrors) {
            System.out.println(str);
        }
    }


    //*************  Tokenized Input Stream Section  ******************

    private static String current_token = null;
    private static StringTokenizer reader;
    private static BufferedReader in 
        = new BufferedReader (new InputStreamReader(System.in));

    //-----------------------------------------------------------------
    //  Gets the next input token assuming it may be on subsequent
    //  input lines.
    //-----------------------------------------------------------------
    private static String getNextToken() {
        return getNextToken(true);
    }

    //-----------------------------------------------------------------
    //  Gets the next input token, which may already have been read.
    //-----------------------------------------------------------------
    private static String getNextToken(boolean skip) 
    {  
        String token;
        if (current_token == null) {  
            token = getNextInputToken(skip);
        }
        else
        {  
            token = current_token;
            current_token = null;
        }

        return token;
    }

    //-----------------------------------------------------------------
    //  Gets the next token from the input, which may come from the
    //  current input line or a subsequent one. The parameter
    //  determines if subsequent lines are used.
    //-----------------------------------------------------------------
    private static String getNextInputToken(boolean skip) 
    {  
        final String delimiters = " \t\n\r\f";
        String token = null;
        try 
        {  
            if (reader == null) { 
                reader = new StringTokenizer(in.readLine(), delimiters, true);
            }

            while (token == null || ((delimiters.indexOf (token) >= 0) && skip))
            {  
                while ( !reader.hasMoreTokens() ) {
                    reader = new StringTokenizer(in.readLine(),delimiters,true);
                }
                
                token = reader.nextToken();
            }
        }
        catch (Exception exception) {
            token = null;
        }

        return token;

    }

    //-----------------------------------------------------------------
    //  Returns true if there are no more tokens to read on the
    //  current input line.
    //-----------------------------------------------------------------
    public static boolean endOfLine() {
        return !reader.hasMoreTokens();
    }


    //*************  Reading Section  *********************************

    //-----------------------------------------------------------------
    //  Returns a string read from standard input.
    //-----------------------------------------------------------------
    public static String readString() 
    {  
        String str;
        try 
        {  
            str = getNextToken(false);
            while ( !endOfLine() ) {  
                str = str + getNextToken(false);
            }

        }
        catch (Exception exception) 
        {  
            error("Error reading String data, null value returned.");
            str = null;
        }

        return str;
    }

    //-----------------------------------------------------------------
    //  Returns a space-delimited substring (a word) read from
    //  standard input.
    //-----------------------------------------------------------------
    public static String readWord() 
    {  
        String token;
        try {  
            token = getNextToken();
        } 
        catch (Exception exception) 
        {  
            error ("Error reading String data, null value returned.");
            token = null;
        }

        return token;
    }

    //-----------------------------------------------------------------
    //  Returns a boolean read from standard input.
    //-----------------------------------------------------------------
    public static boolean readBoolean() 
    {  
        String token = getNextToken();
        boolean bool;
        try
        {  
            if (token.toLowerCase().equals("true")) {
                bool = true;
            }
            else if (token.toLowerCase().equals("false")) {
                bool = false;
            }
            else 
            {  
                error ("Error reading boolean data, false value returned.");
                bool = false;
            }
        }
        catch (Exception exception)
        {  
            error ("Error reading boolean data, false value returned.");
            bool = false;
        }

        return bool;
    }

    //-----------------------------------------------------------------
    //  Returns a character read from standard input.
    //-----------------------------------------------------------------
    public static char readChar() 
    {  
        String token = getNextToken(false);
        char value;
        try 
        {  
            if (token.length() > 1) {   
                current_token = token.substring (1, token.length());
            }   
            else { 
                current_token = null;
            }
            
            value = token.charAt (0);
        } 
        catch (Exception exception) 
        {  
            error ("Error reading char data, MIN_VALUE value returned.");
            value = Character.MIN_VALUE;
        }

        return value;
    }

    //-----------------------------------------------------------------
    //  Returns an integer read from standard input.
    //-----------------------------------------------------------------
    public static int readInt() 
    {  
        String token = getNextToken();
        int value;
        try {  
            value = Integer.parseInt (token);
        } 
        catch (Exception exception) 
        {  
            error ("Error reading int data, MIN_VALUE value returned.");
            value = Integer.MIN_VALUE;
        }

        return value;
    }

    //-----------------------------------------------------------------
    //  Returns a long integer read from standard input.
    //-----------------------------------------------------------------
    public static long readLong() 
    {  
        String token = getNextToken();
        long value;
        try {  
            value = Long.parseLong (token);
        } 
        catch (Exception exception) 
        {  
            error ("Error reading long data, MIN_VALUE value returned.");
            value = Long.MIN_VALUE;
        }

        return value;
    }

    //-----------------------------------------------------------------
    //  Returns a float read from standard input.
    //-----------------------------------------------------------------
    public static float readFloat() 
    {  
        String token = getNextToken();
        float value;
        try {  
            value = (new Float(token)).floatValue();
        } 
        catch (Exception exception) 
        {  
            error ("Error reading float data, NaN value returned.");
            value = Float.NaN;
        }

        return value;
    }

    //-----------------------------------------------------------------
    //  Returns a double read from standard input.
    //-----------------------------------------------------------------
    public static double readDouble() 
    {  
        String token = getNextToken();
        double value;

        try {  
            value = (new Double(token)).doubleValue();
        } 
        catch (Exception exception) 
        {  
            error ("Error reading double data, NaN value returned.");
            value = Double.NaN;
        }

        return value;
    }

} // end class

Dieses schicke Teil habe ich vor einiger Zeit gefunden. 

Nach eigenem Testen ist mein Fazit, dass es sehr gut funktioniert und den Input des Keyboards vollkommen aufnimmt. Echt stark! 

Kopiert euch das Ding gerne raus, so erspart ihr euch Coden und Denken. Schließlich sind wir doch alle faul. 

Meine nächsten Posts werden etwas ausführlicher und besser, wie gesagt, ich bin ganz frisch dabei und habe wirkloch gar keine Erfahrung mit dem Bloggen. 

Habt also ein wenig Nachsicht mit mir. Ich hoffe dennoch, dass euch mein erster Post gefallen hat und das ihr auch beim zweiten wieder am Start sein werdet. 

Zum Schlus möchte ich noch Credits an den Autor dieses Dokumentes geben. Wie am Kopf des Scrhiftstückes zu sehen ist, gebührt die volle Aufmerksamkeit Lewis und Loftus, wer auch immer das sein mag.

Vielen Dank fürs Lesen und tschau bis zum nächsten mal.


Mehr

Umgestaltung des Blogs

Hey Leute, ich habe mir einige Gedanken zum Bloggen gemacht und deshalb möchte ich, bevor ich viele Leser habe direkt eine etwas drastische Maßnahme...

Java Newsticker

Hey Leute, ich habe mir Gedanken gemacht, ob ich wohl einen Newsticker rund um Java hier auf meiner Seite seperat aufmachen will.  Aufgrund meines Studiums...

Mousover Script

Hey Leute! mal was ganz anders, Mousover Skript! Fachsprachlich auch onmouseover Event genannt. Hierbei handelt es sich um eine Aktion welche ausgeführt wird, sobal dein Curser...

Eliza html

Hey Leute! Mir macht das schreiben und die Arbeit an meinem neuen Projekt so viel Spaß, ich muss einfach weiter machen! Ich sprudele for...