| /* |
| * 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. |
| * |
| * @author ConnectBot Dev Team |
| * @author raaar |
| * |
| */ |
| 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); |
| } |
| } |
| } |
| } |
