Exemplo n.º 1
0
  /**
   * Read a character from the console.
   *
   * @return the character, or -1 if an EOF is received.
   */
  public final int readVirtualKey() throws IOException {
    int c = terminal.readVirtualKey(in);

    if (debugger != null) {
      debug("keystroke: " + c + "");
    }

    // clear any echo characters
    clearEcho(c);

    return c;
  }
Exemplo n.º 2
0
  /** Clear the echoed characters for the specified character code. */
  int clearEcho(int c) throws IOException {
    // if the terminal is not echoing, then just return...
    if (!terminal.getEcho()) {
      return 0;
    }

    // otherwise, clear
    int num = countEchoCharacters((char) c);
    back(num);
    drawBuffer(num);

    return num;
  }
Exemplo n.º 3
0
  /** Clear the screen by issuing the ANSI "clear screen" code. */
  public boolean clearScreen() throws IOException {
    if (!terminal.isANSISupported()) {
      return false;
    }

    // send the ANSI code to clear the screen
    printString(((char) 27) + "[2J");
    flushConsole();

    // then send the ANSI code to go to position 1,1
    printString(((char) 27) + "[1;1H");
    flushConsole();

    redrawLine();

    return true;
  }
Exemplo n.º 4
0
  // ================================ main ===============================
  //
  // You can use command line arguments to have the output and/or input
  // come from a file versus the command line.
  //
  // If there are two arguments then the first one is the file from where
  // the input is read and the second is the file where a transcript is
  // saved.
  //
  // If there is just one argument then it is the file where a transcript
  // is saved.
  public static void main(String args[]) {
    XYPoint points[];

    if (args.length >= 1) {
      Terminal.startTranscript(args[0]);
    }
    if (args.length >= 2) {
      // Read points from file
      points = PointReader.readXYPoints(args[1]);
    } else {
      // You can change "" to something else when testing,
      // but it MUST  be "3861" for your submitted output!

      java.util.Random randseq = new java.util.Random(3861);

      // Use this line if you want a different random set of
      // points for each run.  This code uses the system
      // clock as the seed to the random number generator.
      //
      // java.util.Random randseq = new java.util.Random();

      Terminal.println("How many points? ");

      int nPoints = Terminal.readInt();

      points = genPointsAtRandom(nPoints, randseq);
    }

    XComparator lessThanX = new XComparator();
    YComparator lessThanY = new YComparator();

    Date startTime = new Date();

    //////////////////////////////////////////////////////////////////////
    // CLOSEST-PAIR ALGORITHM STARTS HERE

    // The algorithm expects two arrays containing the same points.
    XYPoint pointsByX[] = new XYPoint[points.length];
    XYPoint pointsByY[] = new XYPoint[points.length];
    for (int j = 0; j < points.length; j++) {
      pointsByX[j] = points[j];
      pointsByY[j] = points[j];
    }
    // Ensure sorting precondition for divide-and-conquer CP algorithm.
    // You should *not* have to call msort() in your own code!
    Sort.msort(pointsByX, lessThanX); // sort by x-coord
    Sort.msort(pointsByY, lessThanY); // sort by y-coord

    Result rMin = ClosestPair.findClosestPair(pointsByX, pointsByY);
    rMin.print();

    // CLOSEST-PAIR ALGORITHM ENDS HERE
    //////////////////////////////////////////////////////////////////////

    Date endTime = new Date();
    long elapsedTime = endTime.getTime() - startTime.getTime();
    Terminal.println(
        "For n = " + points.length + ", the elapsed time is " + elapsedTime + " milliseconds.\n");

    // *** NOTE: for your submitted output for Part Two, you MUST print
    // *** the closest pair of points and the distance between them!

    //////////////////////////////////////////////////////////////////////
    // THE FOLLOWING LINES DEMONSTRATE HOW TO USE THE PROVIDED
    // PLOTTER ROUTINE.  Uncomment them as you wish for debugging
    // purposes, or use them in your closest pair code to inspect
    // the point arrays at any time.  For example, you could color
    // all points in the left half red and all points in the right
    // half blue and then visually check that you divided them
    // properly by calling the plotter before you recurse.  Note
    // that if you make several calls, all the plots will
    // initially be on top of each other -- just move them so you
    // can see everything.
    //

    // Here the points are plotted and labelled by X-coordinate

    // new Plotter(pointsByY, true, "Sorted by X-coordinate");

    // Here the points are plotted and labelled by Y-coordinate

    // new Plotter(pointsByY, true, "Sorted by Y-coordinate");

    // Here's a call to the plot routine in which the points
    // aren't labeled. A nice thing to do at this point (if you
    // computed the two closest points) would be to color the two
    // closest points a different color For a XYPoint p, you could
    // color p (say red) with the line:
    //
    // p.color = Color.red;

    // new Plotter(pointsByX, true, "Output");
  }
Exemplo n.º 5
0
  /**
   * Read a line from the <i>in</i> {@link InputStream}, and return the line (without any trailing
   * newlines).
   *
   * @param prompt the prompt to issue to the console, may be null.
   * @return a line that is read from the terminal, or null if there was null input (e.g.,
   *     <i>CTRL-D</i> was pressed).
   */
  public String readLine(final String prompt, final Character mask) throws IOException {
    this.mask = mask;
    if (prompt != null) this.prompt = prompt;

    try {
      terminal.beforeReadLine(this, this.prompt, mask);

      if ((this.prompt != null) && (this.prompt.length() > 0)) {
        out.write(this.prompt);
        out.flush();
      }

      // if the terminal is unsupported, just use plain-java reading
      if (!terminal.isSupported()) {
        return readLine(in);
      }

      while (true) {
        int[] next = readBinding();

        if (next == null) {
          return null;
        }

        int c = next[0];
        int code = next[1];

        if (c == -1) {
          return null;
        }

        boolean success = true;

        switch (code) {
          case EXIT: // ctrl-d
            if (buf.buffer.length() == 0) {
              return null;
            }

          case COMPLETE: // tab
            success = complete();
            break;

          case MOVE_TO_BEG:
            success = setCursorPosition(0);
            break;

          case KILL_LINE: // CTRL-K
            success = killLine();
            break;

          case CLEAR_SCREEN: // CTRL-L
            success = clearScreen();
            break;

          case KILL_LINE_PREV: // CTRL-U
            success = resetLine();
            break;

          case NEWLINE: // enter
            moveToEnd();
            printNewline(); // output newline
            return finishBuffer();

          case DELETE_PREV_CHAR: // backspace
            success = backspace();
            break;

          case DELETE_NEXT_CHAR: // delete
            success = deleteCurrentCharacter();
            break;

          case MOVE_TO_END:
            success = moveToEnd();
            break;

          case PREV_CHAR:
            success = moveCursor(-1) != 0;
            break;

          case NEXT_CHAR:
            success = moveCursor(1) != 0;
            break;

          case NEXT_HISTORY:
            success = moveHistory(true);
            break;

          case PREV_HISTORY:
            success = moveHistory(false);
            break;

          case REDISPLAY:
            break;

          case PASTE:
            success = paste();
            break;

          case DELETE_PREV_WORD:
            success = deletePreviousWord();
            break;

          case PREV_WORD:
            success = previousWord();
            break;

          case NEXT_WORD:
            success = nextWord();
            break;

          case START_OF_HISTORY:
            success = history.moveToFirstEntry();
            if (success) setBuffer(history.current());
            break;

          case END_OF_HISTORY:
            success = history.moveToLastEntry();
            if (success) setBuffer(history.current());
            break;

          case CLEAR_LINE:
            moveInternal(-(buf.buffer.length()));
            killLine();
            break;

          case INSERT:
            buf.setOvertyping(!buf.isOvertyping());
            break;

          case UNKNOWN:
          default:
            if (c != 0) { // ignore null chars
              ActionListener action =
                  (ActionListener) triggeredActions.get(new Character((char) c));
              if (action != null) action.actionPerformed(null);
              else putChar(c, true);
            } else success = false;
        }

        if (!(success)) {
          beep();
        }

        flushConsole();
      }
    } finally {
      terminal.afterReadLine(this, this.prompt, mask);
    }
  }
Exemplo n.º 6
0
 /**
  * Query the terminal to find the current width;
  *
  * @see Terminal#getTerminalHeight
  * @return the height of the current terminal.
  */
 public int getTermheight() {
   return Terminal.setupTerminal().getTerminalHeight();
 }
Exemplo n.º 7
0
 /**
  * Query the terminal to find the current width;
  *
  * @see Terminal#getTerminalWidth
  * @return the width of the current terminal.
  */
 public int getTermwidth() {
   return Terminal.setupTerminal().getTerminalWidth();
 }
Exemplo n.º 8
0
  /**
   * Create a new reader.
   *
   * @param in the input
   * @param out the output
   * @param bindings the key bindings to use
   * @param term the terminal to use
   */
  public ConsoleReader(InputStream in, Writer out, InputStream bindings, Terminal term)
      throws IOException {
    this.terminal = term;
    setInput(in);
    this.out = out;

    if (bindings == null) {
      try {
        String bindingFile =
            System.getProperty(
                "jline.keybindings",
                new File(System.getProperty("user.home", ".jlinebindings.properties"))
                    .getAbsolutePath());

        if (new File(bindingFile).isFile()) {
          bindings = new FileInputStream(new File(bindingFile));
        }
      } catch (Exception e) {
        // swallow exceptions with option debugging
        if (debugger != null) {
          e.printStackTrace(debugger);
        }
      }
    }

    if (bindings == null) {
      bindings = terminal.getDefaultBindings();
    }

    this.keybindings = new short[Character.MAX_VALUE * 2];

    Arrays.fill(this.keybindings, UNKNOWN);

    /**
     * Loads the key bindings. Bindings file is in the format:
     *
     * <p>keycode: operation name
     */
    if (bindings != null) {
      Properties p = new Properties();
      p.load(bindings);
      bindings.close();

      for (Iterator i = p.keySet().iterator(); i.hasNext(); ) {
        String val = (String) i.next();

        try {
          Short code = new Short(val);
          String op = (String) p.getProperty(val);

          Short opval = (Short) KEYMAP_NAMES.get(op);

          if (opval != null) {
            keybindings[code.shortValue()] = opval.shortValue();
          }
        } catch (NumberFormatException nfe) {
          consumeException(nfe);
        }
      }

      // hardwired arrow key bindings
      // keybindings[VK_UP] = PREV_HISTORY;
      // keybindings[VK_DOWN] = NEXT_HISTORY;
      // keybindings[VK_LEFT] = PREV_CHAR;
      // keybindings[VK_RIGHT] = NEXT_CHAR;
    }
  }
Exemplo n.º 9
0
 public ConsoleReader(final InputStream in, final Writer out, final InputStream bindings)
     throws IOException {
   this(in, out, bindings, Terminal.getTerminal());
 }