public Dimension requestResize( final Dimension newSize, final RequestOrigin origin, int cursorY, JediTerminal.ResizeHandler resizeHandler) { if (!newSize.equals(myTermSize)) { myTerminalTextBuffer.lock(); try { myTerminalTextBuffer.resize(newSize, origin, cursorY, resizeHandler, mySelection); myTermSize = (Dimension) newSize.clone(); final Dimension pixelDimension = new Dimension(getPixelWidth(), getPixelHeight()); setPreferredSize(pixelDimension); if (myTerminalPanelListener != null) { myTerminalPanelListener.onPanelResize(pixelDimension, origin); } SwingUtilities.invokeLater( new Runnable() { @Override public void run() { updateScrolling(); } }); } finally { myTerminalTextBuffer.unlock(); } } return new Dimension(getPixelWidth(), getPixelHeight()); }
public void clearLines(final int beginY, final int endY) { myTerminalTextBuffer.lock(); try { myTerminalTextBuffer.clearLines(beginY, endY); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void deleteLines(int count) { myTerminalTextBuffer.lock(); try { myTerminalTextBuffer.deleteLines(myCursorY - 1, count, myScrollRegionBottom); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void scrollDown(int count) { myTerminalTextBuffer.lock(); try { scrollArea(myScrollRegionTop, scrollingRegionSize(), count); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void insertBlankCharacters(int count) { myTerminalTextBuffer.lock(); try { final int extent = Math.min(count, myTerminalWidth - myCursorX); myTerminalTextBuffer.insertBlankCharacters(myCursorX, myCursorY - 1, extent); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void cursorUp(final int countY) { myTerminalTextBuffer.lock(); try { myCursorY -= countY; myCursorY = Math.max(myCursorY, scrollingRegionTop()); myDisplay.setCursor(myCursorX, myCursorY); } finally { myTerminalTextBuffer.unlock(); } }
private void wrapLines() { if (myCursorX >= myTerminalWidth) { myCursorX = 0; // clear the end of the line in the text buffer myTerminalTextBuffer.getLine(myCursorY - 1).deleteCharacters(myTerminalWidth); if (isAutoWrap()) { myTerminalTextBuffer.getLine(myCursorY - 1).setWrapped(true); myCursorY += 1; } } }
@Override public void cursorDown(final int dY) { myTerminalTextBuffer.lock(); try { myCursorY += dY; myCursorY = Math.min(myCursorY, scrollingRegionBottom()); myDisplay.setCursor(myCursorX, myCursorY); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void eraseCharacters(int count) { // Clear the next n characters on the cursor's line, including the cursor's // position. myTerminalTextBuffer.lock(); try { final int extent = Math.min(count, myTerminalWidth - myCursorX); myTerminalTextBuffer.eraseCharacters(myCursorX, myCursorX + extent, myCursorY - 1); } finally { myTerminalTextBuffer.unlock(); } }
private void doWriteString(String string) { myTerminalTextBuffer.lock(); try { wrapLines(); scrollY(); myTerminalTextBuffer.writeString(myCursorX, myCursorY, string); myCursorX += string.length(); finishText(); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void fillScreen(final char c) { myTerminalTextBuffer.lock(); try { final char[] chars = new char[myTerminalWidth]; Arrays.fill(chars, c); final String str = new String(chars); for (int row = 1; row <= myTerminalHeight; row++) { myTerminalTextBuffer.writeString(0, row, str); } } finally { myTerminalTextBuffer.unlock(); } }
@Override public void nextLine() { myTerminalTextBuffer.lock(); try { myCursorX = 0; if (myCursorY == myScrollRegionBottom) { scrollArea(myScrollRegionTop, scrollingRegionSize(), -1); } else { myCursorY += 1; } myDisplay.setCursor(myCursorX, myCursorY); } finally { myTerminalTextBuffer.unlock(); } }
public void scrollY() { myTerminalTextBuffer.lock(); try { if (myCursorY > myScrollRegionBottom) { final int dy = myScrollRegionBottom - myCursorY; myCursorY = myScrollRegionBottom; scrollArea(myScrollRegionTop, scrollingRegionSize(), dy); myDisplay.setCursor(myCursorX, myCursorY); } if (myCursorY < myScrollRegionTop) { myCursorY = myScrollRegionTop; } } finally { myTerminalTextBuffer.unlock(); } }
private void writeCharacters(final char[] chosenBuffer, final int start, final int length) { myTerminalTextBuffer.lock(); try { wrapLines(); scrollY(); if (length != 0) { myTerminalTextBuffer.writeBytes(myCursorX, myCursorY, chosenBuffer, start, length); } myCursorX += CharUtils.getTextLength(chosenBuffer, start, length); finishText(); } finally { myTerminalTextBuffer.unlock(); } }
@Override public void reverseIndex() { // Moves the cursor up one line in the same // column. If the cursor is at the top margin, // the page scrolls down. myTerminalTextBuffer.lock(); try { if (myCursorY == myScrollRegionTop) { scrollArea(myScrollRegionTop, scrollingRegionSize(), 1); } else { myCursorY -= 1; myDisplay.setCursor(myCursorX, myCursorY); } } finally { myTerminalTextBuffer.unlock(); } }
@Override public void index() { // Moves the cursor down one line in the // same column. If the cursor is at the // bottom margin, the page scrolls up myTerminalTextBuffer.lock(); try { if (myCursorY == myScrollRegionBottom) { scrollArea(myScrollRegionTop, scrollingRegionSize(), -1); } else { myCursorY += 1; myDisplay.setCursor(myCursorX, myCursorY); } } finally { myTerminalTextBuffer.unlock(); } }
private void clearBuffer() { if (!myTerminalTextBuffer.isUsingAlternateBuffer()) { myTerminalTextBuffer.clearHistory(); if (myCoordsAccessor != null && myCoordsAccessor.getY() > 0) { TerminalLine line = myTerminalTextBuffer.getLine(myCoordsAccessor.getY() - 1); myTerminalTextBuffer.clearAll(); myCoordsAccessor.setY(0); myCursor.setY(1); myTerminalTextBuffer.addLine(line); } updateScrolling(); myClientScrollOrigin = myBoundedRangeModel.getValue(); } }
@Override public void eraseInDisplay(final int arg) { myTerminalTextBuffer.lock(); try { int beginY; int endY; switch (arg) { case 0: // Initial line if (myCursorX < myTerminalWidth) { myTerminalTextBuffer.eraseCharacters(myCursorX, myTerminalWidth, myCursorY - 1); } // Rest beginY = myCursorY; endY = myTerminalHeight; break; case 1: // initial line myTerminalTextBuffer.eraseCharacters(0, myCursorX + 1, myCursorY - 1); beginY = 0; endY = myCursorY - 1; break; case 2: beginY = 0; endY = myTerminalHeight; break; default: LOG.error("Unsupported erase in display mode:" + arg); beginY = 1; endY = 1; break; } // Rest of lines if (beginY != endY) { clearLines(beginY, endY); } } finally { myTerminalTextBuffer.unlock(); } }
private void updateScrolling() { if (myScrollingEnabled) { myBoundedRangeModel.setRangeProperties( 0, myTermSize.height, -myTerminalTextBuffer.getHistoryBuffer().getLineCount(), myTermSize.height, false); } else { myBoundedRangeModel.setRangeProperties(0, myTermSize.height, 0, myTermSize.height, false); } }
public void eraseInLine(int arg) { myTerminalTextBuffer.lock(); try { switch (arg) { case 0: if (myCursorX < myTerminalWidth) { myTerminalTextBuffer.eraseCharacters(myCursorX, myTerminalWidth, myCursorY - 1); } // delete to the end of line : line is no more wrapped myTerminalTextBuffer.getLine(myCursorY - 1).setWrapped(false); break; case 1: final int extent = Math.min(myCursorX + 1, myTerminalWidth); myTerminalTextBuffer.eraseCharacters(0, extent, myCursorY - 1); break; case 2: myTerminalTextBuffer.eraseCharacters(0, myTerminalWidth, myCursorY - 1); break; default: LOG.error("Unsupported erase in line mode:" + arg); break; } } finally { myTerminalTextBuffer.unlock(); } }
public TerminalPanel( @NotNull SettingsProvider settingsProvider, @NotNull TerminalTextBuffer terminalTextBuffer, @NotNull StyleState styleState) { mySettingsProvider = settingsProvider; myTerminalTextBuffer = terminalTextBuffer; myStyleState = styleState; myTermSize.width = terminalTextBuffer.getWidth(); myTermSize.height = terminalTextBuffer.getHeight(); myMaxFPS = mySettingsProvider.maxRefreshRate(); updateScrolling(); enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.INPUT_METHOD_EVENT_MASK); enableInputMethods(true); terminalTextBuffer.addModelListener( new TerminalModelListener() { @Override public void modelChanged() { repaint(); } }); }
@Override public void reset() { myGraphicSetState.resetState(); myStyleState.reset(); myTerminalTextBuffer.clearAll(); myDisplay.setScrollingEnabled(true); initModes(); initMouseModes(); cursorPosition(1, 1); }
@Override public void horizontalTab() { if (myCursorX >= myTerminalWidth) { return; } int length = myTerminalTextBuffer.getLine(myCursorY - 1).getText().length(); int stop = myTabulator.nextTab(myCursorX); myCursorX = Math.max(myCursorX, length); if (myCursorX < stop) { char[] chars = new char[stop - myCursorX]; Arrays.fill(chars, CharUtils.EMPTY_CHAR); doWriteString(new String(chars)); } else { myCursorX = stop; } myDisplay.setCursor(myCursorX, myCursorY); }
@Override public void paintComponent(final Graphics g) { final Graphics2D gfx = (Graphics2D) g; setupAntialiasing(gfx); gfx.setColor(getBackground()); gfx.fillRect(0, 0, getWidth(), getHeight()); myTerminalTextBuffer.processHistoryAndScreenLines( myClientScrollOrigin, new StyledTextConsumer() { final int columnCount = getColumnCount(); @Override public void consume( int x, int y, @NotNull TextStyle style, @NotNull CharBuffer characters, int startRow) { int row = y - startRow; drawCharacters(x, row, style, characters, gfx); if (mySelection != null) { Pair<Integer, Integer> interval = mySelection.intersect(x, row + myClientScrollOrigin, characters.length()); if (interval != null) { TextStyle selectionStyle = getSelectionStyle(style); CharBuffer selectionChars = characters.subBuffer(interval.first - x, interval.second); drawCharacters(interval.first, row, selectionStyle, selectionChars, gfx); } } } @Override public void consumeNul( int x, int y, int nulIndex, TextStyle style, CharBuffer characters, int startRow) { int row = y - startRow; if (mySelection != null) { // compute intersection with all NUL areas, non-breaking Pair<Integer, Integer> interval = mySelection.intersect( nulIndex, row + myClientScrollOrigin, columnCount - nulIndex); if (interval != null) { TextStyle selectionStyle = getSelectionStyle(style); drawCharacters(x, row, selectionStyle, characters, gfx); return; } } drawCharacters(x, row, style, characters, gfx); } @Override public void consumeQueue(int x, int y, int nulIndex, int startRow) { if (x < columnCount) { consumeNul( x, y, nulIndex, TextStyle.EMPTY, new CharBuffer(CharUtils.EMPTY_CHAR, columnCount - x), startRow); } } }); int cursorY = myCursor.getCoordY(); if (myClientScrollOrigin + getRowCount() > cursorY) { int cursorX = myCursor.getCoordX(); Pair<Character, TextStyle> sc = myTerminalTextBuffer.getStyledCharAt(cursorX, cursorY); TextStyle normalStyle = sc.second != null ? sc.second : myStyleState.getCurrent(); TextStyle selectionStyle = getSelectionStyle(normalStyle); boolean inSelection = inSelection(cursorX, cursorY); myCursor.drawCursor(sc.first, gfx, inSelection ? selectionStyle : normalStyle); } drawInputMethodUncommitedChars(gfx); drawMargins(gfx, getWidth(), getHeight()); }
public LinesBuffer getScrollBuffer() { return myTerminalTextBuffer.getHistoryBuffer(); }
private void scrollArea(int scrollRegionTop, int scrollRegionSize, int dy) { myDisplay.scrollArea(scrollRegionTop, scrollRegionSize, dy); myTerminalTextBuffer.scrollArea(scrollRegionTop, dy, scrollRegionTop + scrollRegionSize - 1); }
@Override public void useAlternateBuffer(boolean enabled) { myTerminalTextBuffer.useAlternateBuffer(enabled); myDisplay.setScrollingEnabled(!enabled); }