Créer une console "Commande"

Vous pouvez exécuter des commandes arbitraires avec Plexus à l'aide de commandes de commande. Il gère l'échappement des arguments, une exécution spécifique à l'environnement et vous permet de joindre les consommateurs à STDOUT et STDOUT, vous laissant vous concentrer sur la manipulation.

Voici un lien vers Une autre réponse R I a donné, montrant comment vous pouvez configurer une commande de commande et gérer la sortie.

Jetez un coup d'œil au Console Groovy . C'est à quoi cela ressemble:

Console Groovy http://groovy.codehaus.org/download/attachity /36800/groovyconsole.gif

Bien que ce soit une console pour des commandes groovy plutôt que des commandes arbitraires, vous devriez être capable d'adapter des idées et / ou de le code pour obtenir ce dont vous avez besoin.

Si je comprends votre question correctement, vous cherchez à exécuter des commandes spécifiques à votre application. Mon conseil serait, si tel est en fait le cas, d'utiliser deux textaes, une seule ligne et une seule ligne qui prend le reste de l'espace. Ajoutez des gestionnaires d'événements KeyPress au petit, ce qui serait éditable et rendrait l'autre lecture seule. Si vous devez avoir une zone de texte unique, vous pouvez le faire en lecture seule, puis ajouter quelques manipulateurs de frappes pour gérer les touches de caractères et les touches haut / bas.

J'espère que j'ai bien compris votre question correctement, bonne chance.

Je ne voudrais pas essayer des raccourcis (comme Groovy / Beanshell) à moins qu'ils ne correspondent exactement à vos besoins. Essayer de faire un outil de haut niveau faire ce que vous voulez quand ce n'est pas ce que cela peut déjà être la chose la plus frustrante à propos de la programmation.

Il devrait être assez facile de prendre une zone de texte et "en faire le vôtre", mais il serait beaucoup plus facile de le faire en tant que quelqu'un d'autre suggéré et d'utiliser une commande de texte à une ligne combinée à une zone d'affichage multi-lignes.

Dans les deux cas, vous souhaitez garder un contrôle assez étroit sur l'ensemble du système, intercepter et filtrer certaines touches de frappe, désactiver l'entrée dans la zone "Affichage" si vous décidez d'y aller, forcer un clic sur votre zone d'affichage pour envoyer la mise au point à votre champ de saisie, ...

Si vous faites la seule chose de la boîte, vous voudrez vous assurer que votre entrée est toujours au bas de la boîte et que vous contrôlez leur positionnement du curseur (vous ne le souhaitez probablement pas de ne faire aucune entrée à aucun ligne sauf la dernière ligne).

Je suggère que vous n'assumez pas un seul contrôle consiste simplement à travailler sans modification, attendez-vous à faire les devoirs et tout ira bien.

Essayez ce code:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

/**
 *
 * @author Alistair
 */
public class Console extends JPanel implements KeyListener {

    private static final long serialVersionUID = -4538532229007904362L;
    private JLabel keyLabel;
    private String prompt = "";
    public boolean ReadOnly = false;
    private ConsoleVector vec = new ConsoleVector();
    private ConsoleListener con = null;
    private String oldTxt = "";
    private Vector history = new Vector();
    private int history_index = -1;
    private boolean history_mode = false;

    public Console() {
        super();
        setSize(300, 200);
        setLayout(new FlowLayout(FlowLayout.CENTER));
        keyLabel = new JLabel("");
        setFocusable(true);
        keyLabel.setFocusable(true);
        keyLabel.addKeyListener(this);
        addKeyListener(this);
        add(keyLabel);
        setVisible(true);
    }

    public void registerConsoleListener(ConsoleListener c) {
        this.con = c;
    }

    public String getPrompt() {
        return this.prompt;
    }

    public void setPrompt(String s) {
        this.prompt = s;
    }

    private void backspace() {
        if (!this.vec.isEmpty()) {
            this.vec.remove(this.vec.size() - 1);
            this.print();
        }
    }

    @SuppressWarnings("unchecked")
    private void enter() {
        String com = this.vec.toString();
        String return$ = "";
        if (this.con != null) {
            return$ = this.con.receiveCommand(com);
        }

        this.history.add(com);
        this.vec.clear();
        if (!return$.equals("")) {
            return$ = return$ + "<br>";
        }
        // <HTML> </HTML>
        String h = this.keyLabel.getText().substring(6, this.keyLabel.getText().length() - 7);
        this.oldTxt = h.substring(0, h.length() - 1) + "<BR>" + return$;
        this.keyLabel.setText("<HTML>" + this.oldTxt + this.prompt + "_</HTML>");
    }

    private void print() {
        this.keyLabel.setText("<HTML>" + this.oldTxt + this.prompt + this.vec.toString() + "_</HTML>");
        this.repaint();
    }

    @SuppressWarnings("unchecked")
    private void print(String s) {
        this.vec.add(s);
        this.print();
    }

    @Override
    public void keyTyped(KeyEvent e) {
    }

    @Override
    public void keyPressed(KeyEvent e) {
    }

    @Override
    public void keyReleased(KeyEvent e) {
        this.handleKey(e);
    }

    private void history(int dir) {
        if (this.history.isEmpty()) {
            return;
        }
        if (dir == 1) {
            this.history_mode = true;
            this.history_index++;
            if (this.history_index > this.history.size() - 1) {
                this.history_index = 0;
            }
            // System.out.println(this.history_index);
            this.vec.clear();
            String p = (String) this.history.get(this.history_index);
            this.vec.fromString(p.split(""));

        } else if (dir == 2) {
            this.history_index--;
            if (this.history_index < 0) {
                this.history_index = this.history.size() - 1;
            }
            // System.out.println(this.history_index);
            this.vec.clear();
            String p = (String) this.history.get(this.history_index);
            this.vec.fromString(p.split(""));
        }

        print();
    }

    private void handleKey(KeyEvent e) {

        if (!this.ReadOnly) {
            if (e.getKeyCode() == 38 | e.getKeyCode() == 40) {
                if (e.getKeyCode() == 38) {
                    history(1);
                } else if (e.getKeyCode() == 40 & this.history_mode != false) {
                    history(2);
                }
            } else {
                this.history_index = -1;
                this.history_mode = false;
                if (e.getKeyCode() == 13 | e.getKeyCode() == 10) {
                    enter();
                } else if (e.getKeyCode() == 8) {
                    this.backspace();
                } else {
                    if (e.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
                        this.print(String.valueOf(e.getKeyChar()));
                    }
                }
            }
        }
    }
}


class ConsoleVector extends Vector {

    private static final long serialVersionUID = -5527403654365278223L;

    @SuppressWarnings("unchecked")
    public void fromString(String[] p) {
        for (int i = 0; i < p.length; i++) {
            this.add(p[i]);
        }
    }

    public ConsoleVector() {
        super();
    }

    @Override
    public String toString() {
        StringBuffer s = new StringBuffer();
        for (int i = 0; i < this.size(); i++) {
            s.append(this.get(i));
        }
        return s.toString();
    }
}

public interface ConsoleListener {
    public String receiveCommand(String command);
}

BeanShell fournit une console d'entrée de ligne de commande avec les caractéristiques suivantes:

• un curseur clignotant li>
• Historique de la commande LI>
• Couper / Copier / Coller, Sélection avec Ctrl + Touches fléchées Li>
• COMMUNIQUE COMMUNIQUE LI>
• Entrée de caractères Unicode li>
• Sortie de texte colorée li>
• ... et tout est livré dans une vitre de défilement. Li> ul>

  Les pots BeanShell sont disponibles auprès de http://www.beanshell.org/download. HTML et la source est disponible via SVN à partir de SVN CO http://ikayzo.org/svn/beanshell for Plus d'infos sur JConsole voir http://www.beanshell.org/manual/jconsole.html p>

  ici est un exemple d'utilisation JConsole de BeanShell dans votre application: P>

  import java.awt.Color;
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.Reader;
  
  import javax.swing.JFrame;
  
  import bsh.util.GUIConsoleInterface;
  import bsh.util.JConsole;
  
  /** 
   * Example of using the BeanShell project's JConsole in
   * your own application.
   * 
   * JConsole is a command line input console that has support 
   * for command history, cut/copy/paste, a blinking cursor, 
   * command completion, Unicode character input, coloured text 
   * output and comes wrapped in a scroll pane.
   * 
   * For more info, see http://www.beanshell.org/manual/jconsole.html
   * 
   * @author tukushan
   */
  public class JConsoleExample {
  
      public static void main(String[] args) {
  
          //define a frame and add a console to it
          JFrame frame = new JFrame("JConsole example");
  
          JConsole console = new JConsole();
  
          frame.getContentPane().add(console);
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setSize(600,400);
  
          frame.setVisible(true);
  
          inputLoop(console, "JCE (type 'quit' to exit): ");
  
          System.exit(0);
      }
  
      /**
       * Print prompt and echos commands entered via the JConsole
       * 
       * @param console a GUIConsoleInterface which in addition to 
       *         basic input and output also provides coloured text
       *         output and name completion
       * @param prompt text to display before each input line
       */
      private static void inputLoop(GUIConsoleInterface console, String prompt) {
          Reader input = console.getIn();
          BufferedReader bufInput = new BufferedReader(input);
  
          String newline = System.getProperty("line.separator");
  
          console.print(prompt, Color.BLUE);
  
          String line;
          try {
              while ((line = bufInput.readLine()) != null) {
                  console.print("You typed: " + line + newline, Color.ORANGE);
  
                  // try to sync up the console
                  //System.out.flush();
                  //System.err.flush();
                  //Thread.yield();  // this helps a little
  
                  if (line.equals("quit")) break; 
                  console.print(prompt, Color.BLUE);
              }
              bufInput.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
  
      }
  }