xref: /external/sl4a/ScriptingLayerForAndroid/src/org/connectbot/service/TerminalBridge.java

/*
 * ConnectBot: simple, powerful, open-source SSH client for Android
 * Copyright 2007 Kenny Root, Jeffrey Sharkey
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.connectbot.service;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.Bitmap.Config;
import android.graphics.Paint.FontMetrics;
import android.text.ClipboardManager;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.View;
import android.view.ContextMenu.ContextMenuInfo;

import com.googlecode.android_scripting.Log;
import com.googlecode.android_scripting.R;
import com.googlecode.android_scripting.facade.ui.UiFacade;
import com.googlecode.android_scripting.interpreter.InterpreterProcess;
import com.googlecode.android_scripting.jsonrpc.RpcReceiverManager;
import com.googlecode.android_scripting.jsonrpc.RpcReceiverManagerFactory;

import de.mud.terminal.VDUBuffer;
import de.mud.terminal.VDUDisplay;
import de.mud.terminal.vt320;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.LinkedList;
import java.util.List;

import org.connectbot.TerminalView;
import org.connectbot.transport.AbsTransport;
import org.connectbot.util.Colors;
import org.connectbot.util.PreferenceConstants;
import org.connectbot.util.SelectionArea;

/**
 * Provides a bridge between a MUD terminal buffer and a possible TerminalView. This separation
 * allows us to keep the TerminalBridge running in a background service. A TerminalView shares down
 * a bitmap that we can use for rendering when available.
 *
 *
 */
public class TerminalBridge implements VDUDisplay, OnSharedPreferenceChangeListener {

  private final static int FONT_SIZE_STEP = 2;

  private final int[] color = new int[Colors.defaults.length];

  private final TerminalManager manager;

  private final InterpreterProcess mProcess;

  private int mDefaultFgColor;
  private int mDefaultBgColor;

  private int scrollback;

  private String delKey;
  private String encoding;

  private AbsTransport transport;

  private final Paint defaultPaint;

  private Relay relay;

  private Bitmap bitmap = null;
  private final VDUBuffer buffer;

  private TerminalView parent = null;
  private final Canvas canvas = new Canvas();

  private boolean forcedSize = false;
  private int columns;
  private int rows;

  private final TerminalKeyListener keyListener;

  private boolean selectingForCopy = false;
  private final SelectionArea selectionArea;
  private ClipboardManager clipboard;

  public int charWidth = -1;
  public int charHeight = -1;
  private int charTop = -1;

  private float fontSize = -1;

  private final List<FontSizeChangedListener> fontSizeChangedListeners;

  /**
   * Flag indicating if we should perform a full-screen redraw during our next rendering pass.
   */
  private boolean fullRedraw = false;

  private final PromptHelper promptHelper;

  /**
   * Create a new terminal bridge suitable for unit testing.
   */
  public TerminalBridge() {
    buffer = new vt320() {
      @Override
      public void write(byte[] b) {
      }

      @Override
      public void write(int b) {
      }

      @Override
      public void sendTelnetCommand(byte cmd) {
      }

      @Override
      public void setWindowSize(int c, int r) {
      }

      @Override
      public void debug(String s) {
      }
    };

    manager = null;

    defaultPaint = new Paint();

    selectionArea = new SelectionArea();
    scrollback = 1;

    fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();

    transport = null;

    keyListener = new TerminalKeyListener(manager, this, buffer, null);

    mProcess = null;

    mDefaultFgColor = 0;
    mDefaultBgColor = 0;
    promptHelper = null;

    updateCharset();
  }

  /**
   * Create new terminal bridge with following parameters.
   */
  public TerminalBridge(final TerminalManager manager, InterpreterProcess process, AbsTransport t)
      throws IOException {
    this.manager = manager;
    transport = t;
    mProcess = process;

    String string = manager.getStringParameter(PreferenceConstants.SCROLLBACK, null);
    if (string != null) {
      scrollback = Integer.parseInt(string);
    } else {
      scrollback = PreferenceConstants.DEFAULT_SCROLLBACK;
    }

    string = manager.getStringParameter(PreferenceConstants.FONTSIZE, null);
    if (string != null) {
      fontSize = Float.parseFloat(string);
    } else {
      fontSize = PreferenceConstants.DEFAULT_FONT_SIZE;
    }

    mDefaultFgColor =
        manager.getIntParameter(PreferenceConstants.COLOR_FG, PreferenceConstants.DEFAULT_FG_COLOR);
    mDefaultBgColor =
        manager.getIntParameter(PreferenceConstants.COLOR_BG, PreferenceConstants.DEFAULT_BG_COLOR);

    delKey = manager.getStringParameter(PreferenceConstants.DELKEY, PreferenceConstants.DELKEY_DEL);

    // create prompt helper to relay password and hostkey requests up to gui
    promptHelper = new PromptHelper(this);

    // create our default paint
    defaultPaint = new Paint();
    defaultPaint.setAntiAlias(true);
    defaultPaint.setTypeface(Typeface.MONOSPACE);
    defaultPaint.setFakeBoldText(true); // more readable?

    fontSizeChangedListeners = new LinkedList<FontSizeChangedListener>();

    setFontSize(fontSize);

    // create terminal buffer and handle outgoing data
    // this is probably status reply information
    buffer = new vt320() {
      @Override
      public void debug(String s) {
        Log.d(s);
      }

      @Override
      public void write(byte[] b) {
        try {
          if (b != null && transport != null) {
            transport.write(b);
          }
        } catch (IOException e) {
          Log.e("Problem writing outgoing data in vt320() thread", e);
        }
      }

      @Override
      public void write(int b) {
        try {
          if (transport != null) {
            transport.write(b);
          }
        } catch (IOException e) {
          Log.e("Problem writing outgoing data in vt320() thread", e);
        }
      }

      // We don't use telnet sequences.
      @Override
      public void sendTelnetCommand(byte cmd) {
      }

      // We don't want remote to resize our window.
      @Override
      public void setWindowSize(int c, int r) {
      }

      @Override
      public void beep() {
        if (parent.isShown()) {
          manager.playBeep();
        }
      }
    };

    // Don't keep any scrollback if a session is not being opened.

    buffer.setBufferSize(scrollback);

    resetColors();
    buffer.setDisplay(this);

    selectionArea = new SelectionArea();

    keyListener = new TerminalKeyListener(manager, this, buffer, encoding);

    updateCharset();

    manager.registerOnSharedPreferenceChangeListener(this);

  }

  /**
   * Spawn thread to open connection and start login process.
   */
  protected void connect() {
    transport.setBridge(this);
    transport.setManager(manager);
    transport.connect();

    ((vt320) buffer).reset();

    // previously tried vt100 and xterm for emulation modes
    // "screen" works the best for color and escape codes
    ((vt320) buffer).setAnswerBack("screen");

    if (PreferenceConstants.DELKEY_BACKSPACE.equals(delKey)) {
      ((vt320) buffer).setBackspace(vt320.DELETE_IS_BACKSPACE);
    } else {
      ((vt320) buffer).setBackspace(vt320.DELETE_IS_DEL);
    }

    // create thread to relay incoming connection data to buffer
    relay = new Relay(this, transport, (vt320) buffer, encoding);
    Thread relayThread = new Thread(relay);
    relayThread.setDaemon(true);
    relayThread.setName("Relay");
    relayThread.start();

    // force font-size to make sure we resizePTY as needed
    setFontSize(fontSize);

  }

  private void updateCharset() {
    encoding =
        manager.getStringParameter(PreferenceConstants.ENCODING, Charset.defaultCharset().name());
    if (relay != null) {
      relay.setCharset(encoding);
    }
    keyListener.setCharset(encoding);
  }

  /**
   * Inject a specific string into this terminal. Used for post-login strings and pasting clipboard.
   */
  public void injectString(final String string) {
    if (string == null || string.length() == 0) {
      return;
    }

    Thread injectStringThread = new Thread(new Runnable() {
      public void run() {
        try {
          transport.write(string.getBytes(encoding));
        } catch (Exception e) {
          Log.e("Couldn't inject string to remote host: ", e);
        }
      }
    });
    injectStringThread.setName("InjectString");
    injectStringThread.start();
  }

  /**
   * @return whether a session is open or not
   */
  public boolean isSessionOpen() {
    if (transport != null) {
      return transport.isSessionOpen();
    }
    return false;
  }

  /**
   * Force disconnection of this terminal bridge.
   */
  public void dispatchDisconnect(boolean immediate) {

    // Cancel any pending prompts.
    promptHelper.cancelPrompt();

    if (immediate) {
      manager.closeConnection(TerminalBridge.this, true);
    } else {
      Thread disconnectPromptThread = new Thread(new Runnable() {
        public void run() {
          String prompt = null;
          if (transport != null && transport.isConnected()) {
            prompt = manager.getResources().getString(R.string.prompt_confirm_exit);
          } else {
            prompt = manager.getResources().getString(R.string.prompt_process_exited);
          }
          Boolean result = promptHelper.requestBooleanPrompt(null, prompt);

          if (transport != null && transport.isConnected()) {
            manager.closeConnection(TerminalBridge.this, result != null && result.booleanValue());
          } else if (result != null && result.booleanValue()) {
            manager.closeConnection(TerminalBridge.this, false);
          }
        }
      });
      disconnectPromptThread.setName("DisconnectPrompt");
      disconnectPromptThread.setDaemon(true);
      disconnectPromptThread.start();
    }
  }

  public void setSelectingForCopy(boolean selectingForCopy) {
    this.selectingForCopy = selectingForCopy;
  }

  public boolean isSelectingForCopy() {
    return selectingForCopy;
  }

  public SelectionArea getSelectionArea() {
    return selectionArea;
  }

  public synchronized void tryKeyVibrate() {
    manager.tryKeyVibrate();
  }

  /**
   * Request a different font size. Will make call to parentChanged() to make sure we resize PTY if
   * needed.
   */
  /* package */final void setFontSize(float size) {
    if (size <= 0.0) {
      return;
    }

    defaultPaint.setTextSize(size);
    fontSize = size;

    // read new metrics to get exact pixel dimensions
    FontMetrics fm = defaultPaint.getFontMetrics();
    charTop = (int) Math.ceil(fm.top);

    float[] widths = new float[1];
    defaultPaint.getTextWidths("X", widths);
    charWidth = (int) Math.ceil(widths[0]);
    charHeight = (int) Math.ceil(fm.descent - fm.top);

    // refresh any bitmap with new font size
    if (parent != null) {
      parentChanged(parent);
    }

    for (FontSizeChangedListener ofscl : fontSizeChangedListeners) {
      ofscl.onFontSizeChanged(size);
    }
    forcedSize = false;
  }

  /**
   * Add an {@link FontSizeChangedListener} to the list of listeners for this bridge.
   *
   * @param listener
   *          listener to add
   */
  public void addFontSizeChangedListener(FontSizeChangedListener listener) {
    fontSizeChangedListeners.add(listener);
  }

  /**
   * Remove an {@link FontSizeChangedListener} from the list of listeners for this bridge.
   *
   * @param listener
   */
  public void removeFontSizeChangedListener(FontSizeChangedListener listener) {
    fontSizeChangedListeners.remove(listener);
  }

  /**
   * Something changed in our parent {@link TerminalView}, maybe it's a new parent, or maybe it's an
   * updated font size. We should recalculate terminal size information and request a PTY resize.
   */
  public final synchronized void parentChanged(TerminalView parent) {
    if (manager != null && !manager.isResizeAllowed()) {
      Log.d("Resize is not allowed now");
      return;
    }

    this.parent = parent;
    final int width = parent.getWidth();
    final int height = parent.getHeight();

    // Something has gone wrong with our layout; we're 0 width or height!
    if (width <= 0 || height <= 0) {
      return;
    }

    clipboard = (ClipboardManager) parent.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
    keyListener.setClipboardManager(clipboard);

    if (!forcedSize) {
      // recalculate buffer size
      int newColumns, newRows;

      newColumns = width / charWidth;
      newRows = height / charHeight;

      // If nothing has changed in the terminal dimensions and not an intial
      // draw then don't blow away scroll regions and such.
      if (newColumns == columns && newRows == rows) {
        return;
      }

      columns = newColumns;
      rows = newRows;
    }

    // reallocate new bitmap if needed
    boolean newBitmap = (bitmap == null);
    if (bitmap != null) {
      newBitmap = (bitmap.getWidth() != width || bitmap.getHeight() != height);
    }

    if (newBitmap) {
      discardBitmap();
      bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);
      canvas.setBitmap(bitmap);
    }

    // clear out any old buffer information
    defaultPaint.setColor(Color.BLACK);
    canvas.drawPaint(defaultPaint);

    // Stroke the border of the terminal if the size is being forced;
    if (forcedSize) {
      int borderX = (columns * charWidth) + 1;
      int borderY = (rows * charHeight) + 1;

      defaultPaint.setColor(Color.GRAY);
      defaultPaint.setStrokeWidth(0.0f);
      if (width >= borderX) {
        canvas.drawLine(borderX, 0, borderX, borderY + 1, defaultPaint);
      }
      if (height >= borderY) {
        canvas.drawLine(0, borderY, borderX + 1, borderY, defaultPaint);
      }
    }

    try {
      // request a terminal pty resize
      synchronized (buffer) {
        buffer.setScreenSize(columns, rows, true);
      }

      if (transport != null) {
        transport.setDimensions(columns, rows, width, height);
      }
    } catch (Exception e) {
      Log.e("Problem while trying to resize screen or PTY", e);
    }

    // force full redraw with new buffer size
    fullRedraw = true;
    redraw();

    parent.notifyUser(String.format("%d x %d", columns, rows));

    Log.i(String.format("parentChanged() now width=%d, height=%d", columns, rows));
  }

  /**
   * Somehow our parent {@link TerminalView} was destroyed. Now we don't need to redraw anywhere,
   * and we can recycle our internal bitmap.
   */
  public synchronized void parentDestroyed() {
    parent = null;
    discardBitmap();
  }

  private void discardBitmap() {
    if (bitmap != null) {
      bitmap.recycle();
    }
    bitmap = null;
  }

  public void onDraw() {
    int fg, bg;
    synchronized (buffer) {
      boolean entireDirty = buffer.update[0] || fullRedraw;
      boolean isWideCharacter = false;

      // walk through all lines in the buffer
      for (int l = 0; l < buffer.height; l++) {

        // check if this line is dirty and needs to be repainted
        // also check for entire-buffer dirty flags
        if (!entireDirty && !buffer.update[l + 1]) {
          continue;
        }

        // reset dirty flag for this line
        buffer.update[l + 1] = false;

        // walk through all characters in this line
        for (int c = 0; c < buffer.width; c++) {
          int addr = 0;
          int currAttr = buffer.charAttributes[buffer.windowBase + l][c];
          // check if foreground color attribute is set
          if ((currAttr & VDUBuffer.COLOR_FG) != 0) {
            int fgcolor = ((currAttr & VDUBuffer.COLOR_FG) >> VDUBuffer.COLOR_FG_SHIFT) - 1;
            if (fgcolor < 8 && (currAttr & VDUBuffer.BOLD) != 0) {
              fg = color[fgcolor + 8];
            } else {
              fg = color[fgcolor];
            }
          } else {
            fg = mDefaultFgColor;
          }

          // check if background color attribute is set
          if ((currAttr & VDUBuffer.COLOR_BG) != 0) {
            bg = color[((currAttr & VDUBuffer.COLOR_BG) >> VDUBuffer.COLOR_BG_SHIFT) - 1];
          } else {
            bg = mDefaultBgColor;
          }

          // support character inversion by swapping background and foreground color
          if ((currAttr & VDUBuffer.INVERT) != 0) {
            int swapc = bg;
            bg = fg;
            fg = swapc;
          }

          // set underlined attributes if requested
          defaultPaint.setUnderlineText((currAttr & VDUBuffer.UNDERLINE) != 0);

          isWideCharacter = (currAttr & VDUBuffer.FULLWIDTH) != 0;

          if (isWideCharacter) {
            addr++;
          } else {
            // determine the amount of continuous characters with the same settings and print them
            // all at once
            while (c + addr < buffer.width
                && buffer.charAttributes[buffer.windowBase + l][c + addr] == currAttr) {
              addr++;
            }
          }

          // Save the current clip region
          canvas.save(Canvas.CLIP_SAVE_FLAG);

          // clear this dirty area with background color
          defaultPaint.setColor(bg);
          if (isWideCharacter) {
            canvas.clipRect(c * charWidth, l * charHeight, (c + 2) * charWidth, (l + 1)
                * charHeight);
          } else {
            canvas.clipRect(c * charWidth, l * charHeight, (c + addr) * charWidth, (l + 1)
                * charHeight);
          }
          canvas.drawPaint(defaultPaint);

          // write the text string starting at 'c' for 'addr' number of characters
          defaultPaint.setColor(fg);
          if ((currAttr & VDUBuffer.INVISIBLE) == 0) {
            canvas.drawText(buffer.charArray[buffer.windowBase + l], c, addr, c * charWidth,
                (l * charHeight) - charTop, defaultPaint);
          }

          // Restore the previous clip region
          canvas.restore();

          // advance to the next text block with different characteristics
          c += addr - 1;
          if (isWideCharacter) {
            c++;
          }
        }
      }

      // reset entire-buffer flags
      buffer.update[0] = false;
    }
    fullRedraw = false;
  }

  public void redraw() {
    if (parent != null) {
      parent.postInvalidate();
    }
  }

  // We don't have a scroll bar.
  public void updateScrollBar() {
  }

  /**
   * Resize terminal to fit [rows]x[cols] in screen of size [width]x[height]
   *
   * @param rows
   * @param cols
   * @param width
   * @param height
   */
  public synchronized void resizeComputed(int cols, int rows, int width, int height) {
    float size = 8.0f;
    float step = 8.0f;
    float limit = 0.125f;

    int direction;

    while ((direction = fontSizeCompare(size, cols, rows, width, height)) < 0) {
      size += step;
    }

    if (direction == 0) {
      Log.d(String.format("Fontsize: found match at %f", size));
      return;
    }

    step /= 2.0f;
    size -= step;

    while ((direction = fontSizeCompare(size, cols, rows, width, height)) != 0 && step >= limit) {
      step /= 2.0f;
      if (direction > 0) {
        size -= step;
      } else {
        size += step;
      }
    }

    if (direction > 0) {
      size -= step;
    }

    columns = cols;
    this.rows = rows;
    setFontSize(size);
    forcedSize = true;
  }

  private int fontSizeCompare(float size, int cols, int rows, int width, int height) {
    // read new metrics to get exact pixel dimensions
    defaultPaint.setTextSize(size);
    FontMetrics fm = defaultPaint.getFontMetrics();

    float[] widths = new float[1];
    defaultPaint.getTextWidths("X", widths);
    int termWidth = (int) widths[0] * cols;
    int termHeight = (int) Math.ceil(fm.descent - fm.top) * rows;

    Log.d(String.format("Fontsize: font size %f resulted in %d x %d", size, termWidth, termHeight));

    // Check to see if it fits in resolution specified.
    if (termWidth > width || termHeight > height) {
      return 1;
    }

    if (termWidth == width || termHeight == height) {
      return 0;
    }

    return -1;
  }

  /*
   * (non-Javadoc)
   *
   * @see de.mud.terminal.VDUDisplay#setVDUBuffer(de.mud.terminal.VDUBuffer)
   */
  @Override
  public void setVDUBuffer(VDUBuffer buffer) {
  }

  /*
   * (non-Javadoc)
   *
   * @see de.mud.terminal.VDUDisplay#setColor(byte, byte, byte, byte)
   */
  public void setColor(int index, int red, int green, int blue) {
    // Don't allow the system colors to be overwritten for now. May violate specs.
    if (index < color.length && index >= 16) {
      color[index] = 0xff000000 | red << 16 | green << 8 | blue;
    }
  }

  public final void resetColors() {
    System.arraycopy(Colors.defaults, 0, color, 0, Colors.defaults.length);
  }

  public TerminalKeyListener getKeyHandler() {
    return keyListener;
  }

  public void resetScrollPosition() {
    // if we're in scrollback, scroll to bottom of window on input
    if (buffer.windowBase != buffer.screenBase) {
      buffer.setWindowBase(buffer.screenBase);
    }
  }

  public void increaseFontSize() {
    setFontSize(fontSize + FONT_SIZE_STEP);
  }

  public void decreaseFontSize() {
    setFontSize(fontSize - FONT_SIZE_STEP);
  }

  public int getId() {
    return mProcess.getPort();
  }

  public String getName() {
    return mProcess.getName();
  }

  public InterpreterProcess getProcess() {
    return mProcess;
  }

  public int getForegroundColor() {
    return mDefaultFgColor;
  }

  public int getBackgroundColor() {
    return mDefaultBgColor;
  }

  public VDUBuffer getVDUBuffer() {
    return buffer;
  }

  public PromptHelper getPromptHelper() {
    return promptHelper;
  }

  public Bitmap getBitmap() {
    return bitmap;
  }

  public AbsTransport getTransport() {
    return transport;
  }

  public Paint getPaint() {
    return defaultPaint;
  }

  public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    if (mProcess.isAlive()) {
      RpcReceiverManagerFactory rpcReceiverManagerFactory = mProcess.getRpcReceiverManagerFactory();
      for (RpcReceiverManager manager : rpcReceiverManagerFactory.getRpcReceiverManagers().values()) {
        UiFacade facade = manager.getReceiver(UiFacade.class);
        facade.onCreateContextMenu(menu, v, menuInfo);
      }
    }
  }

  public boolean onPrepareOptionsMenu(Menu menu) {
    boolean returnValue = false;
    if (mProcess.isAlive()) {
      RpcReceiverManagerFactory rpcReceiverManagerFactory = mProcess.getRpcReceiverManagerFactory();
      for (RpcReceiverManager manager : rpcReceiverManagerFactory.getRpcReceiverManagers().values()) {
        UiFacade facade = manager.getReceiver(UiFacade.class);
        returnValue = returnValue || facade.onPrepareOptionsMenu(menu);
      }
      return returnValue;
    }
    return false;
  }

  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
    if (PreferenceConstants.ENCODING.equals(key)) {
      updateCharset();
    } else if (PreferenceConstants.FONTSIZE.equals(key)) {
      String string = manager.getStringParameter(PreferenceConstants.FONTSIZE, null);
      if (string != null) {
        fontSize = Float.parseFloat(string);
      } else {
        fontSize = PreferenceConstants.DEFAULT_FONT_SIZE;
      }
      setFontSize(fontSize);
      fullRedraw = true;
    } else if (PreferenceConstants.SCROLLBACK.equals(key)) {
      String string = manager.getStringParameter(PreferenceConstants.SCROLLBACK, null);
      if (string != null) {
        scrollback = Integer.parseInt(string);
      } else {
        scrollback = PreferenceConstants.DEFAULT_SCROLLBACK;
      }
      buffer.setBufferSize(scrollback);
    } else if (PreferenceConstants.COLOR_FG.equals(key)) {
      mDefaultFgColor =
          manager.getIntParameter(PreferenceConstants.COLOR_FG,
              PreferenceConstants.DEFAULT_FG_COLOR);
      fullRedraw = true;
    } else if (PreferenceConstants.COLOR_BG.equals(key)) {
      mDefaultBgColor =
          manager.getIntParameter(PreferenceConstants.COLOR_BG,
              PreferenceConstants.DEFAULT_BG_COLOR);
      fullRedraw = true;
    }
    if (PreferenceConstants.DELKEY.equals(key)) {
      delKey =
          manager.getStringParameter(PreferenceConstants.DELKEY, PreferenceConstants.DELKEY_DEL);
      if (PreferenceConstants.DELKEY_BACKSPACE.equals(delKey)) {
        ((vt320) buffer).setBackspace(vt320.DELETE_IS_BACKSPACE);
      } else {
        ((vt320) buffer).setBackspace(vt320.DELETE_IS_DEL);
      }
    }
  }
}