A rootless Android app that boots Alpine Linux: run containers (Podman/Docker/LXC) and GUI desktop apps.
feat(terminal): vendor MatanZ/sixel4 fork; image protocols + modern features
ExTvf893a01eccd0
diff --git a/.gitignore b/.gitignoreindex b8c95c0..1ce707e 100644--- a/.gitignore+++ b/.gitignore@@ -1,6 +1,8 @@# Build outputs/build//app/build/+/terminal-emulator/build/+/terminal-view/build/*.apk*.aabdiff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex 57c2f66..5432be7 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -83,9 +83,6 @@ android {// It must be extracted to disk so ProcessBuilder can execute it.jniLibs {useLegacyPackaging = true- // libtermux.so is rebuilt locally with 16KB page alignment (see build-termux-android.sh).- // pickFirsts makes Gradle prefer src/main/jniLibs/ over the copy inside the Termux AAR.- pickFirsts += "lib/arm64-v8a/libtermux.so"}}}@@ -123,9 +120,9 @@ dependencies {// DataStore (app settings)implementation(libs.androidx.datastore.preferences)- // Termux terminal emulator & view- implementation(libs.termux.terminal.emulator)- implementation(libs.termux.terminal.view)+ // Vendored Termux terminal emulator & view (MatanZ/termux-app:sixel4 — Sixel + iTerm2 image support)+ implementation(project(":terminal-emulator"))+ implementation(project(":terminal-view"))// TestingtestImplementation(libs.junit)diff --git a/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt b/app/src/main/java/com/excp/podroid/engine/PodroidQemu.ktindex ae3b056..855ff00 100644--- a/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt+++ b/app/src/main/java/com/excp/podroid/engine/PodroidQemu.kt@@ -1,6 +1,6 @@/** Podroid - Rootless Podman for Android- * Copyright (C) 2024 Podroid contributors+ * Copyright (C) 2024-2026 Podroid contributors** QEMU engine for Podroid. Manages the VM lifecycle and exposes three Unix* sockets for the terminal layer:@@ -108,7 +108,9 @@ class PodroidQemu @Inject constructor(override fun onBell(s: TerminalSession) { sessionClientDelegate?.onBell(s) }override fun onColorsChanged(s: TerminalSession) { sessionClientDelegate?.onColorsChanged(s) }override fun onTerminalCursorStateChange(state: Boolean) { sessionClientDelegate?.onTerminalCursorStateChange(state) }+ override fun setTerminalShellPid(s: TerminalSession, pid: Int) { sessionClientDelegate?.setTerminalShellPid(s, pid) }override fun getTerminalCursorStyle(): Int = sessionClientDelegate?.terminalCursorStyle ?: 0+ override fun getTerminalVersionString(): String? = sessionClientDelegate?.terminalVersionStringoverride fun logError(tag: String?, msg: String?) = LogProxy.error(tag, TAG, msg)override fun logWarn(tag: String?, msg: String?) = LogProxy.warn(tag, TAG, msg)override fun logInfo(tag: String?, msg: String?) = LogProxy.info(tag, TAG, msg)@@ -156,7 +158,8 @@ class PodroidQemu @Inject constructor(2000,proxySessionClient,)- sess.updateSize(80, 24)+ // Cell pixel dims default to 0 — TerminalView.updateSize() pushes real values once measured.+ sess.updateSize(80, 24, 0, 0)_terminalSession = sessLog.d(TAG, "Bridge auto-started on terminal.sock")}@@ -186,7 +189,8 @@ class PodroidQemu @Inject constructor(proxySessionClient,)- sess.updateSize(80, 24)+ // Cell pixel dims default to 0 — TerminalView.updateSize() pushes real values once measured.+ sess.updateSize(80, 24, 0, 0)_terminalSession = sessLog.d(TAG, "Terminal session created in Qemu singleton")@@ -540,7 +544,7 @@ class PodroidQemu @Inject constructor(// xattrs on the host file instead of being applied directly.// Falls back gracefully on filesystems without xattr support.args += "-fsdev"- args += "local,id=fsdev0,path=${downloadsDir.absolutePath},security_model=mapped-xattr"+ args += "local,id=fsdev0,path=${downloadsDir.absolutePath},security_model=none"args += "-device"args += "virtio-9p-pci,fsdev=fsdev0,mount_tag=downloads"}diff --git a/podroid-bridge.c b/podroid-bridge.cindex 3914aa2..e2a4671 100644--- a/podroid-bridge.c+++ b/podroid-bridge.c@@ -153,7 +153,10 @@ int main(int argc, char *argv[]) {signal(SIGTERM, on_term);signal(SIGPIPE, SIG_IGN);- char buf[8192];+ /* 64 KB matches the sixel4 fork's main-thread PTY drain buffer and the new+ * 64 KB reader on the TerminalSession side — fewer syscalls for chunked+ * VM output (large `cat`, btop redraws, sixel images). */+ char buf[65536];for (;;) {if (g_shutdown) break;diff --git a/settings.gradle.kts b/settings.gradle.ktsindex 44f4938..274fa00 100644--- a/settings.gradle.kts+++ b/settings.gradle.kts@@ -24,4 +24,4 @@ dependencyResolutionManagement {}rootProject.name = "Podroid"-include(":app")+include(":app", ":terminal-emulator", ":terminal-view")diff --git a/terminal-emulator/build.gradle.kts b/terminal-emulator/build.gradle.ktsnew file mode 100644index 0000000..825dc8f--- /dev/null+++ b/terminal-emulator/build.gradle.kts@@ -0,0 +1,38 @@+plugins {+ alias(libs.plugins.android.library)+}++android {+ namespace = "com.termux.emulator"+ compileSdk = 36++ defaultConfig {+ minSdk = 28++ externalNativeBuild {+ ndkBuild {+ cFlags += listOf("-std=c11", "-Wall", "-Wextra", "-Werror", "-Os", "-fno-stack-protector")+ // Linker flags (16 KB page alignment + gc-sections) live in Android.mk via LOCAL_LDFLAGS.+ }+ }++ ndk {+ abiFilters += "arm64-v8a"+ }+ }++ externalNativeBuild {+ ndkBuild {+ path = file("src/main/jni/Android.mk")+ }+ }++ compileOptions {+ sourceCompatibility = JavaVersion.VERSION_17+ targetCompatibility = JavaVersion.VERSION_17+ }+}++dependencies {+ implementation("androidx.annotation:annotation:1.9.0")+}diff --git a/terminal-emulator/proguard-rules.pro b/terminal-emulator/proguard-rules.pronew file mode 100644index 0000000..2e56e60--- /dev/null+++ b/terminal-emulator/proguard-rules.pro@@ -0,0 +1,25 @@+# Add project specific ProGuard rules here.+# By default, the flags in this file are appended to flags specified+# in /Users/fornwall/lib/android-sdk/tools/proguard/proguard-android.txt+# You can edit the include path and order by changing the proguardFiles+# directive in build.gradle.+#+# For more details, see+# http://developer.android.com/guide/developing/tools/proguard.html++# Add any project specific keep options here:++# If your project uses WebView with JS, uncomment the following+# and specify the fully qualified class name to the JavaScript interface+# class:+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {+# public *;+#}++# Uncomment this to preserve the line number information for+# debugging stack traces.+#-keepattributes SourceFile,LineNumberTable++# If you keep the line number information, uncomment this to+# hide the original source file name.+#-renamesourcefileattribute SourceFilediff --git a/terminal-emulator/src/main/AndroidManifest.xml b/terminal-emulator/src/main/AndroidManifest.xmlnew file mode 100644index 0000000..bdae66c--- /dev/null+++ b/terminal-emulator/src/main/AndroidManifest.xml@@ -0,0 +1,2 @@+<manifest>+</manifest>diff --git a/terminal-emulator/src/main/java/com/termux/terminal/AndroidUtils.java b/terminal-emulator/src/main/java/com/termux/terminal/AndroidUtils.javanew file mode 100644index 0000000..2f762c7--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/AndroidUtils.java@@ -0,0 +1,65 @@+package com.termux.terminal;++import java.io.BufferedReader;+import java.io.IOException;+import java.io.InputStream;+import java.io.InputStreamReader;+import java.util.Properties;+import java.util.regex.Matcher;+import java.util.regex.Pattern;++public class AndroidUtils {++ /**+ * Get system properties as {@link Properties} from `/system/bin/getprop` command output+ * that reads the `/system/build.prop` file.+ *+ * Sourced from https://github.com/termux/termux-app/blob/30ebb2dee381d292ade0f2868cfde0f9f20b89fe/termux-shared/src/main/java/com/termux/shared/android/AndroidUtils.java#L170.+ */+ public static Properties getSystemProperties(String logTag) {+ Properties systemProperties = new Properties();++ // getprop commands returns values in the format `[key]: [value]`+ // Regex matches string starting with a literal `[`,+ // followed by one or more characters that do not match a closing square bracket as the key,+ // followed by a literal `]: [`,+ // followed by one or more characters as the value,+ // followed by string ending with literal `]`+ // multiline values will be ignored+ Pattern propertiesPattern = Pattern.compile("^\\[([^]]+)]: \\[(.+)]$");++ try {+ Process process = new ProcessBuilder()+ .command("/system/bin/getprop")+ .redirectErrorStream(true)+ .start();++ InputStream inputStream = process.getInputStream();+ BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));+ String line, key, value;++ while ((line = bufferedReader.readLine()) != null) {+ Matcher matcher = propertiesPattern.matcher(line);+ if (matcher.matches()) {+ key = matcher.group(1);+ value = matcher.group(2);+ if (key != null && value != null && !key.isEmpty() && !value.isEmpty())+ systemProperties.put(key, value);+ }+ }++ bufferedReader.close();+ process.destroy();++ } catch (IOException e) {+ Logger.logStackTraceWithMessage(null, logTag, "Failed to get run \"/system/bin/getprop\" to get system properties.", e);+ }++ //for (String key : systemProperties.stringPropertyNames()) {+ // Logger.logVerbose(null, logTag, key + ": " + systemProperties.get(key));+ //}++ return systemProperties;+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/ByteQueue.java b/terminal-emulator/src/main/java/com/termux/terminal/ByteQueue.javanew file mode 100644index 0000000..adfdfa8--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/ByteQueue.java@@ -0,0 +1,108 @@+package com.termux.terminal;++/** A circular byte buffer allowing one producer and one consumer thread. */+final class ByteQueue {++ private final byte[] mBuffer;+ private int mHead;+ private int mStoredBytes;+ private boolean mOpen = true;++ public ByteQueue(int size) {+ mBuffer = new byte[size];+ }++ public synchronized void close() {+ mOpen = false;+ notify();+ }++ public synchronized int read(byte[] buffer, boolean block) {+ while (mStoredBytes == 0 && mOpen) {+ if (block) {+ try {+ wait();+ } catch (InterruptedException e) {+ // Ignore.+ }+ } else {+ return 0;+ }+ }+ if (!mOpen) return -1;++ int totalRead = 0;+ int bufferLength = mBuffer.length;+ boolean wasFull = bufferLength == mStoredBytes;+ int length = buffer.length;+ int offset = 0;+ while (length > 0 && mStoredBytes > 0) {+ int oneRun = Math.min(bufferLength - mHead, mStoredBytes);+ int bytesToCopy = Math.min(length, oneRun);+ System.arraycopy(mBuffer, mHead, buffer, offset, bytesToCopy);+ mHead += bytesToCopy;+ if (mHead >= bufferLength) mHead = 0;+ mStoredBytes -= bytesToCopy;+ length -= bytesToCopy;+ offset += bytesToCopy;+ totalRead += bytesToCopy;+ }+ if (wasFull) notify();+ return totalRead;+ }++ /**+ * Attempt to write the specified portion of the provided buffer to the queue.+ * <p/>+ * Returns whether the output was totally written, false if it was closed before.+ */+ public boolean write(byte[] buffer, int offset, int lengthToWrite) {+ if (lengthToWrite + offset > buffer.length) {+ throw new IllegalArgumentException("length + offset > buffer.length");+ } else if (lengthToWrite <= 0) {+ throw new IllegalArgumentException("length <= 0");+ }++ final int bufferLength = mBuffer.length;++ synchronized (this) {+ while (lengthToWrite > 0) {+ while (bufferLength == mStoredBytes && mOpen) {+ try {+ wait();+ } catch (InterruptedException e) {+ // Ignore.+ }+ }+ if (!mOpen) return false;+ final boolean wasEmpty = mStoredBytes == 0;+ int bytesToWriteBeforeWaiting = Math.min(lengthToWrite, bufferLength - mStoredBytes);+ lengthToWrite -= bytesToWriteBeforeWaiting;++ while (bytesToWriteBeforeWaiting > 0) {+ int tail = mHead + mStoredBytes;+ int oneRun;+ if (tail >= bufferLength) {+ // Buffer: [.............]+ // ________________H_______T+ // =>+ // Buffer: [.............]+ // ___________T____H+ // onRun= _____----_+ tail = tail - bufferLength;+ oneRun = mHead - tail;+ } else {+ oneRun = bufferLength - tail;+ }+ int bytesToCopy = Math.min(oneRun, bytesToWriteBeforeWaiting);+ System.arraycopy(buffer, offset, mBuffer, tail, bytesToCopy);+ offset += bytesToCopy;+ bytesToWriteBeforeWaiting -= bytesToCopy;+ mStoredBytes += bytesToCopy;+ }+ if (wasEmpty) notify();+ }+ }+ return true;+ }+}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/ITermImage.java b/terminal-emulator/src/main/java/com/termux/terminal/ITermImage.javanew file mode 100644index 0000000..b8da113--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/ITermImage.java@@ -0,0 +1,399 @@+package com.termux.terminal;++import android.util.Base64;++import java.util.Arrays;++/**+ * An iTerm image received via `OSC 1337`.+ *+ * - https://iterm2.com/documentation-images.html+ */+public class ITermImage {++ public static final String LOG_TAG = "ITermImage";++++ /** The {@link Enum} that defines {@link ITermImage} state. */+ public enum ImageState {++ INIT("init", 0),+ ARGUMENTS_READ("arguments_read", 1),+ IMAGE_READING("image_reading", 2),+ IMAGE_READ("image_read", 3),+ IMAGE_DECODED("image_decoded", 4),+ FAILED("Failed", 5);++ private final String name;+ private final int value;++ ImageState(final String name, final int value) {+ this.name = name;+ this.value = value;+ }++ public String getName() {+ return name;+ }++ public int getValue() {+ return value;+ }++ }++++ protected final TerminalSessionClient mClient;++ protected final boolean mIsMultipart;++ protected int mWidth = -1;+ protected int mHeight = -1;++ protected boolean mInline = false;++ protected boolean mPreserveAspectRatio = true;++ protected final StringBuilder mEncodedImage = new StringBuilder(/* Initial capacity. */ 4096);+ protected byte[] mDecodedImage;++ /** The current state of the {@link ImageState}. */+ protected ImageState mCurrentState = ImageState.INIT;+ /** The previous state of the {@link ImageState}. */+ protected ImageState mPreviousState = ImageState.INIT;++++ protected ITermImage(TerminalSessionClient client, boolean isMultiPart) {+ mClient = client;++ mIsMultipart = isMultiPart;+ }++++ public TerminalSessionClient getClient() {+ return mClient;+ }+++ public boolean isMultipart() {+ return mIsMultipart;+ }+++ public int getWidth() {+ return mWidth;+ }++ public int getHeight() {+ return mHeight;+ }+++ public boolean isInline() {+ return mInline;+ }+++ public boolean shouldPreserveAspectRatio() {+ return mPreserveAspectRatio;+ }+++ public String getEncodedImage() {+ return mEncodedImage.toString();+ }++ public byte[] getDecodedImage() {+ return mDecodedImage;+ }+++ public synchronized ImageState getCurrentState() {+ return mCurrentState;+ }++ public synchronized ImageState getPreviousState() {+ return mPreviousState;+ }+++ protected synchronized boolean setState(ImageState newState) {+ // The state transition cannot go back or change if already at `ImageState.IMAGE_DECODED`+ if (newState.getValue() < mCurrentState.getValue() || mCurrentState == ImageState.IMAGE_DECODED) {+ Logger.logError(mClient, LOG_TAG,+ "Invalid image state transition from \"" + mCurrentState.getName() + "\" to " + "\"" + newState.getName() + "\"");+ return false;+ }++ // The `ImageState.FAILED` can be set again, like to add more errors, but we don't update+ // `mPreviousState` with the `mCurrentState` value if its at `ImageState.FAILED` to+ // preserve the last valid state.+ if (mCurrentState != ImageState.FAILED)+ mPreviousState = mCurrentState;++ mCurrentState = newState;+ return true;+ }+++ protected synchronized boolean setStateFailed(String error) {+ if (error != null) {+ Logger.logError(mClient, LOG_TAG, error);+ }+ return setState(ImageState.FAILED);+ }+++ protected synchronized boolean ensureState(ImageState expectedState) {+ return ensureState(expectedState, null);+ }++ protected synchronized boolean ensureState(ImageState expectedState, String functionName) {+ if (mCurrentState != expectedState) {+ Logger.logError(mClient, LOG_TAG,+ "The current image state is \"" + mCurrentState.getName() + "\" but expected \"" + expectedState.getName() + "\"" ++ (functionName != null ? " while calling '" + functionName : "'") ++ " for " + (!mIsMultipart ? "singlepart" : "multipart") + " image");+ return false;+ }+ return true;+ }+++ public synchronized boolean isArgumentsRead() {+ return mCurrentState == ImageState.ARGUMENTS_READ;+ }++ public synchronized boolean isImageReading() {+ return mCurrentState == ImageState.IMAGE_READING;+ }++ public synchronized boolean isImageRead() {+ return mCurrentState == ImageState.IMAGE_READ;+ }++ public synchronized boolean isImageDecoded() {+ return mCurrentState == ImageState.IMAGE_DECODED;+ }++++ public synchronized int readArguments(TerminalEmulator terminalEmulator, StringBuilder oscArgs, int index) {+ if (!ensureState(ImageState.INIT, "ImageState.readArguments()")) {+ return -1;+ }++ boolean lastParam = false;+ while (index < oscArgs.length()) {+ char ch = oscArgs.charAt(index);+ // End of optional arguments.+ if (ch == ':' && !mIsMultipart) {+ break;+ } else if (ch == ' ') {+ index++;+ continue;+ }++ int keyEndIndex = oscArgs.indexOf("=", index);+ if (keyEndIndex == -1) {+ setStateFailed("The key for an argument not found after index " + index + " in osc argument string: " + oscArgs);+ return -1;+ }+ String argKey = oscArgs.substring(index, keyEndIndex);++ int valueEndIndex = oscArgs.indexOf(";", keyEndIndex);+ if (valueEndIndex == -1) {+ if (!mIsMultipart) {+ // The last key value for `File=` command arguments may end with a colon `:` instead of a semi colon `;`.+ valueEndIndex = oscArgs.indexOf(":", keyEndIndex);+ if (valueEndIndex == -1) {+ setStateFailed("The value for an argument not found after index " + index + " in osc argument string: " + oscArgs);+ return -1;+ } else {+ index = valueEndIndex;+ lastParam = true;+ }+ } else {+ // The last key value for `MultipartFile=` command arguments may end without a semi colon `;`.+ valueEndIndex = oscArgs.length();+ index = valueEndIndex;+ }+ } else {+ index = valueEndIndex + 1;+ }++ if (valueEndIndex <= keyEndIndex) {+ setStateFailed("The argument key end index " + keyEndIndex ++ " is <= value end index " + valueEndIndex + " in osc argument string: " + oscArgs);+ return -1;+ }++ String argValue = oscArgs.substring(keyEndIndex + 1, valueEndIndex);++ if (argKey.equalsIgnoreCase("inline")) {+ mInline = argValue.equals("1");+ }+ else if (argKey.equalsIgnoreCase("preserveAspectRatio")) {+ mPreserveAspectRatio = !argValue.equals("0");+ }+ else if (argKey.equalsIgnoreCase("width")) {+ double factor = terminalEmulator.getCellWidthPixels();+ int intValueEndIndex = argValue.length();+ if (argValue.endsWith("px")) {+ factor = 1;+ intValueEndIndex -= 2;+ } else if (argValue.endsWith("%")) {+ factor = 0.01 * terminalEmulator.getCellWidthPixels() * terminalEmulator.getColumns();+ intValueEndIndex -= 1;+ }+ try {+ mWidth = (int) (factor * Integer.parseInt(argValue.substring(0, intValueEndIndex)));+ } catch (Exception e) {+ }+ }+ else if (argKey.equalsIgnoreCase("height")) {+ double factor = terminalEmulator.getCellHeightPixels();+ int intValueEndIndex = argValue.length();+ if (argValue.endsWith("px")) {+ factor = 1;+ intValueEndIndex -= 2;+ } else if (argValue.endsWith("%")) {+ factor = 0.01 * terminalEmulator.getCellHeightPixels() * terminalEmulator.getRows();+ intValueEndIndex -= 1;+ }+ try {+ mHeight = (int) (factor * Integer.parseInt(argValue.substring(0, intValueEndIndex)));+ } catch (Exception e) {+ }+ } else {+ // `name` and `size` keys are not supported.+ }++ if (lastParam) {+ break;+ }+ }++ setState(ImageState.ARGUMENTS_READ);++ return index;+ }+++ public synchronized boolean readImage(StringBuilder oscArgs, int index) {+ if (!mIsMultipart) {+ if (!ensureState(ImageState.ARGUMENTS_READ, "ImageState.readImage()")) {+ return false;+ }++ if (index < oscArgs.length()) {+ int colonIndex = oscArgs.indexOf(":", index);+ if (colonIndex >= 0 && colonIndex + 1 < oscArgs.length()) {+ setState(ImageState.IMAGE_READING);+ int imageStartIndex = colonIndex + 1;++ try {+ // Appending can cause an increase in capacity and cause an OOM.+ mEncodedImage.append(oscArgs.substring(imageStartIndex));+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ setStateFailed("Collecting singlepart image" + " in osc argument string failed: " + t.getMessage());+ return false;+ }++ setState(ImageState.IMAGE_READ);+ return true;+ }+ }++ setStateFailed("Failed to read singlepart image from index " + index + " in osc argument string: " + oscArgs);+ return false;+ } else {+ if (mCurrentState != ImageState.IMAGE_READING &&+ !ensureState(ImageState.ARGUMENTS_READ, "ImageState.readImage()")) {+ return false;+ }++ // An empty `FilePart=` command could be received as well, so change state before `if` below.+ setState(ImageState.IMAGE_READING);++ if (index < oscArgs.length()) {+ try {+ // Appending can cause an increase in capacity and cause an OOM.+ mEncodedImage.append(oscArgs.substring(index));+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ setStateFailed("Collecting multipart image" + " in osc argument string failed: " + t.getMessage());+ return false;+ }+ return true;+ }++ setStateFailed("Failed to read multipart image" + " in osc argument string: " + oscArgs);+ return false;+ }+ }++ public synchronized boolean setMultiPartImageRead() {+ if (!mIsMultipart) {+ Logger.logError(mClient, LOG_TAG, "Attempting to call 'ImageState.setMultiPartImageRead()' for a singlepart image");+ return false;+ }++ // A `FileEnd` command may have been received without a `FilePart=` command preceding it.+ if (!ensureState(ImageState.IMAGE_READING, "ImageState.setMultiPartImageRead()")) {+ return false;+ }++ setState(ImageState.IMAGE_READ);+ return true;+ }+++ public synchronized boolean decodeImage() {+ if (!ensureState(ImageState.IMAGE_READ, "ImageState.decodeImage()")) {+ return false;+ }++ String encodedImageString = null;+ try {+ if (mEncodedImage.length() < 1) {+ setStateFailed("Cannot decoded an empty image");+ return false;+ }++ while (mEncodedImage.length() % 4 != 0) {+ mEncodedImage.append('=');+ }++ encodedImageString = mEncodedImage.toString();++ // Clear original encoded image from memory as it is no longer needed.+ mEncodedImage.setLength(0);+ mEncodedImage.trimToSize();++ mDecodedImage = Base64.decode(encodedImageString, Base64.DEFAULT);+ if (mDecodedImage == null || mDecodedImage.length < 2) {+ setStateFailed("The decoded image is not valid: " + Arrays.toString(mDecodedImage) + "\nimage: " + encodedImageString);+ return false;+ }++ setState(ImageState.IMAGE_DECODED);+ return true;+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) {+ Logger.logError(mClient, LOG_TAG, "Failed to decode image: " + t.getMessage());+ System.gc();+ } else {+ Logger.logStackTraceWithMessage(mClient, LOG_TAG, "Failed to decode image: " + encodedImageString, t);+ }+ setStateFailed(null);+ return false;+ }+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/JNI.java b/terminal-emulator/src/main/java/com/termux/terminal/JNI.javanew file mode 100644index 0000000..e2fc477--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/JNI.java@@ -0,0 +1,41 @@+package com.termux.terminal;++/**+ * Native methods for creating and managing pseudoterminal subprocesses. C code is in jni/termux.c.+ */+final class JNI {++ static {+ System.loadLibrary("termux");+ }++ /**+ * Create a subprocess. Differs from {@link ProcessBuilder} in that a pseudoterminal is used to communicate with the+ * subprocess.+ * <p/>+ * Callers are responsible for calling {@link #close(int)} on the returned file descriptor.+ *+ * @param cmd The command to execute+ * @param cwd The current working directory for the executed command+ * @param args An array of arguments to the command+ * @param envVars An array of strings of the form "VAR=value" to be added to the environment of the process+ * @param processId A one-element array to which the process ID of the started process will be written.+ * @return the file descriptor resulting from opening /dev/ptmx master device. The sub process will have opened the+ * slave device counterpart (/dev/pts/$N) and have it as stdint, stdout and stderr.+ */+ public static native int createSubprocess(String cmd, String cwd, String[] args, String[] envVars, int[] processId, int rows, int columns, int cellWidth, int cellHeight);++ /** Set the window size for a given pty, which allows connected programs to learn how large their screen is. */+ public static native void setPtyWindowSize(int fd, int rows, int cols, int cellWidth, int cellHeight);++ /**+ * Causes the calling thread to wait for the process associated with the receiver to finish executing.+ *+ * @return if >= 0, the exit status of the process. If < 0, the signal causing the process to stop negated.+ */+ public static native int waitFor(int processId);++ /** Close a file descriptor through the close(2) system call. */+ public static native void close(int fileDescriptor);++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/KeyHandler.java b/terminal-emulator/src/main/java/com/termux/terminal/KeyHandler.javanew file mode 100644index 0000000..8ecfb63--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/KeyHandler.java@@ -0,0 +1,373 @@+package com.termux.terminal;++import java.util.HashMap;+import java.util.Map;++import static android.view.KeyEvent.KEYCODE_BACK;+import static android.view.KeyEvent.KEYCODE_BREAK;+import static android.view.KeyEvent.KEYCODE_DEL;+import static android.view.KeyEvent.KEYCODE_DPAD_CENTER;+import static android.view.KeyEvent.KEYCODE_DPAD_DOWN;+import static android.view.KeyEvent.KEYCODE_DPAD_LEFT;+import static android.view.KeyEvent.KEYCODE_DPAD_RIGHT;+import static android.view.KeyEvent.KEYCODE_DPAD_UP;+import static android.view.KeyEvent.KEYCODE_ENTER;+import static android.view.KeyEvent.KEYCODE_ESCAPE;+import static android.view.KeyEvent.KEYCODE_F1;+import static android.view.KeyEvent.KEYCODE_F10;+import static android.view.KeyEvent.KEYCODE_F11;+import static android.view.KeyEvent.KEYCODE_F12;+import static android.view.KeyEvent.KEYCODE_F2;+import static android.view.KeyEvent.KEYCODE_F3;+import static android.view.KeyEvent.KEYCODE_F4;+import static android.view.KeyEvent.KEYCODE_F5;+import static android.view.KeyEvent.KEYCODE_F6;+import static android.view.KeyEvent.KEYCODE_F7;+import static android.view.KeyEvent.KEYCODE_F8;+import static android.view.KeyEvent.KEYCODE_F9;+import static android.view.KeyEvent.KEYCODE_FORWARD_DEL;+import static android.view.KeyEvent.KEYCODE_INSERT;+import static android.view.KeyEvent.KEYCODE_MOVE_END;+import static android.view.KeyEvent.KEYCODE_MOVE_HOME;+import static android.view.KeyEvent.KEYCODE_NUMPAD_0;+import static android.view.KeyEvent.KEYCODE_NUMPAD_1;+import static android.view.KeyEvent.KEYCODE_NUMPAD_2;+import static android.view.KeyEvent.KEYCODE_NUMPAD_3;+import static android.view.KeyEvent.KEYCODE_NUMPAD_4;+import static android.view.KeyEvent.KEYCODE_NUMPAD_5;+import static android.view.KeyEvent.KEYCODE_NUMPAD_6;+import static android.view.KeyEvent.KEYCODE_NUMPAD_7;+import static android.view.KeyEvent.KEYCODE_NUMPAD_8;+import static android.view.KeyEvent.KEYCODE_NUMPAD_9;+import static android.view.KeyEvent.KEYCODE_NUMPAD_ADD;+import static android.view.KeyEvent.KEYCODE_NUMPAD_COMMA;+import static android.view.KeyEvent.KEYCODE_NUMPAD_DIVIDE;+import static android.view.KeyEvent.KEYCODE_NUMPAD_DOT;+import static android.view.KeyEvent.KEYCODE_NUMPAD_ENTER;+import static android.view.KeyEvent.KEYCODE_NUMPAD_EQUALS;+import static android.view.KeyEvent.KEYCODE_NUMPAD_MULTIPLY;+import static android.view.KeyEvent.KEYCODE_NUMPAD_SUBTRACT;+import static android.view.KeyEvent.KEYCODE_NUM_LOCK;+import static android.view.KeyEvent.KEYCODE_PAGE_DOWN;+import static android.view.KeyEvent.KEYCODE_PAGE_UP;+import static android.view.KeyEvent.KEYCODE_SPACE;+import static android.view.KeyEvent.KEYCODE_SYSRQ;+import static android.view.KeyEvent.KEYCODE_TAB;++public final class KeyHandler {++ public static final int KEYMOD_ALT = 0x80000000;+ public static final int KEYMOD_CTRL = 0x40000000;+ public static final int KEYMOD_SHIFT = 0x20000000;+ public static final int KEYMOD_NUM_LOCK = 0x10000000;++ private static final Map<String, Integer> TERMCAP_TO_KEYCODE = new HashMap<>();++ static {+ // terminfo: http://pubs.opengroup.org/onlinepubs/7990989799/xcurses/terminfo.html+ // termcap: http://man7.org/linux/man-pages/man5/termcap.5.html+ TERMCAP_TO_KEYCODE.put("%i", KEYMOD_SHIFT | KEYCODE_DPAD_RIGHT);+ TERMCAP_TO_KEYCODE.put("#2", KEYMOD_SHIFT | KEYCODE_MOVE_HOME); // Shifted home+ TERMCAP_TO_KEYCODE.put("#4", KEYMOD_SHIFT | KEYCODE_DPAD_LEFT);+ TERMCAP_TO_KEYCODE.put("*7", KEYMOD_SHIFT | KEYCODE_MOVE_END); // Shifted end key++ TERMCAP_TO_KEYCODE.put("k1", KEYCODE_F1);+ TERMCAP_TO_KEYCODE.put("k2", KEYCODE_F2);+ TERMCAP_TO_KEYCODE.put("k3", KEYCODE_F3);+ TERMCAP_TO_KEYCODE.put("k4", KEYCODE_F4);+ TERMCAP_TO_KEYCODE.put("k5", KEYCODE_F5);+ TERMCAP_TO_KEYCODE.put("k6", KEYCODE_F6);+ TERMCAP_TO_KEYCODE.put("k7", KEYCODE_F7);+ TERMCAP_TO_KEYCODE.put("k8", KEYCODE_F8);+ TERMCAP_TO_KEYCODE.put("k9", KEYCODE_F9);+ TERMCAP_TO_KEYCODE.put("k;", KEYCODE_F10);+ TERMCAP_TO_KEYCODE.put("F1", KEYCODE_F11);+ TERMCAP_TO_KEYCODE.put("F2", KEYCODE_F12);+ TERMCAP_TO_KEYCODE.put("F3", KEYMOD_SHIFT | KEYCODE_F1);+ TERMCAP_TO_KEYCODE.put("F4", KEYMOD_SHIFT | KEYCODE_F2);+ TERMCAP_TO_KEYCODE.put("F5", KEYMOD_SHIFT | KEYCODE_F3);+ TERMCAP_TO_KEYCODE.put("F6", KEYMOD_SHIFT | KEYCODE_F4);+ TERMCAP_TO_KEYCODE.put("F7", KEYMOD_SHIFT | KEYCODE_F5);+ TERMCAP_TO_KEYCODE.put("F8", KEYMOD_SHIFT | KEYCODE_F6);+ TERMCAP_TO_KEYCODE.put("F9", KEYMOD_SHIFT | KEYCODE_F7);+ TERMCAP_TO_KEYCODE.put("FA", KEYMOD_SHIFT | KEYCODE_F8);+ TERMCAP_TO_KEYCODE.put("FB", KEYMOD_SHIFT | KEYCODE_F9);+ TERMCAP_TO_KEYCODE.put("FC", KEYMOD_SHIFT | KEYCODE_F10);+ TERMCAP_TO_KEYCODE.put("FD", KEYMOD_SHIFT | KEYCODE_F11);+ TERMCAP_TO_KEYCODE.put("FE", KEYMOD_SHIFT | KEYCODE_F12);++ TERMCAP_TO_KEYCODE.put("kb", KEYCODE_DEL); // backspace key++ TERMCAP_TO_KEYCODE.put("kd", KEYCODE_DPAD_DOWN); // terminfo=kcud1, down-arrow key+ TERMCAP_TO_KEYCODE.put("kh", KEYCODE_MOVE_HOME);+ TERMCAP_TO_KEYCODE.put("kl", KEYCODE_DPAD_LEFT);+ TERMCAP_TO_KEYCODE.put("kr", KEYCODE_DPAD_RIGHT);++ // K1=Upper left of keypad:+ // t_K1 <kHome> keypad home key+ // t_K3 <kPageUp> keypad page-up key+ // t_K4 <kEnd> keypad end key+ // t_K5 <kPageDown> keypad page-down key+ TERMCAP_TO_KEYCODE.put("K1", KEYCODE_MOVE_HOME);+ TERMCAP_TO_KEYCODE.put("K3", KEYCODE_PAGE_UP);+ TERMCAP_TO_KEYCODE.put("K4", KEYCODE_MOVE_END);+ TERMCAP_TO_KEYCODE.put("K5", KEYCODE_PAGE_DOWN);++ TERMCAP_TO_KEYCODE.put("ku", KEYCODE_DPAD_UP);++ TERMCAP_TO_KEYCODE.put("kB", KEYMOD_SHIFT | KEYCODE_TAB); // termcap=kB, terminfo=kcbt: Back-tab+ TERMCAP_TO_KEYCODE.put("kD", KEYCODE_FORWARD_DEL); // terminfo=kdch1, delete-character key+ TERMCAP_TO_KEYCODE.put("kDN", KEYMOD_SHIFT | KEYCODE_DPAD_DOWN); // non-standard shifted arrow down+ TERMCAP_TO_KEYCODE.put("kF", KEYMOD_SHIFT | KEYCODE_DPAD_DOWN); // terminfo=kind, scroll-forward key+ TERMCAP_TO_KEYCODE.put("kI", KEYCODE_INSERT);+ TERMCAP_TO_KEYCODE.put("kP", KEYCODE_PAGE_UP);+ TERMCAP_TO_KEYCODE.put("kN", KEYCODE_PAGE_DOWN);+ TERMCAP_TO_KEYCODE.put("kR", KEYMOD_SHIFT | KEYCODE_DPAD_UP); // terminfo=kri, scroll-backward key+ TERMCAP_TO_KEYCODE.put("kUP", KEYMOD_SHIFT | KEYCODE_DPAD_UP); // non-standard shifted up++ TERMCAP_TO_KEYCODE.put("@7", KEYCODE_MOVE_END);+ TERMCAP_TO_KEYCODE.put("@8", KEYCODE_NUMPAD_ENTER);+ }++ static String getCodeFromTermcap(String termcap, boolean cursorKeysApplication, boolean keypadApplication) {+ Integer keyCodeAndMod = TERMCAP_TO_KEYCODE.get(termcap);+ if (keyCodeAndMod == null) return null;+ int keyCode = keyCodeAndMod;+ int keyMod = 0;+ if ((keyCode & KEYMOD_SHIFT) != 0) {+ keyMod |= KEYMOD_SHIFT;+ keyCode &= ~KEYMOD_SHIFT;+ }+ if ((keyCode & KEYMOD_CTRL) != 0) {+ keyMod |= KEYMOD_CTRL;+ keyCode &= ~KEYMOD_CTRL;+ }+ if ((keyCode & KEYMOD_ALT) != 0) {+ keyMod |= KEYMOD_ALT;+ keyCode &= ~KEYMOD_ALT;+ }+ if ((keyCode & KEYMOD_NUM_LOCK) != 0) {+ keyMod |= KEYMOD_NUM_LOCK;+ keyCode &= ~KEYMOD_NUM_LOCK;+ }+ return getCode(keyCode, keyMod, cursorKeysApplication, keypadApplication);+ }++ public static String getCode(int keyCode, int keyMode, boolean cursorApp, boolean keypadApplication) {+ boolean numLockOn = (keyMode & KEYMOD_NUM_LOCK) != 0;+ keyMode &= ~KEYMOD_NUM_LOCK;+ switch (keyCode) {+ case KEYCODE_DPAD_CENTER:+ return "\015";++ case KEYCODE_DPAD_UP:+ return (keyMode == 0) ? (cursorApp ? "\033OA" : "\033[A") : transformForModifiers("\033[1", keyMode, 'A');+ case KEYCODE_DPAD_DOWN:+ return (keyMode == 0) ? (cursorApp ? "\033OB" : "\033[B") : transformForModifiers("\033[1", keyMode, 'B');+ case KEYCODE_DPAD_RIGHT:+ return (keyMode == 0) ? (cursorApp ? "\033OC" : "\033[C") : transformForModifiers("\033[1", keyMode, 'C');+ case KEYCODE_DPAD_LEFT:+ return (keyMode == 0) ? (cursorApp ? "\033OD" : "\033[D") : transformForModifiers("\033[1", keyMode, 'D');++ case KEYCODE_MOVE_HOME:+ // Note that KEYCODE_HOME is handled by the system and never delivered to applications.+ // On a Logitech k810 keyboard KEYCODE_MOVE_HOME is sent by FN+LeftArrow.+ return (keyMode == 0) ? (cursorApp ? "\033OH" : "\033[H") : transformForModifiers("\033[1", keyMode, 'H');+ case KEYCODE_MOVE_END:+ return (keyMode == 0) ? (cursorApp ? "\033OF" : "\033[F") : transformForModifiers("\033[1", keyMode, 'F');++ // An xterm can send function keys F1 to F4 in two modes: vt100 compatible or+ // not. Because Vim may not know what the xterm is sending, both types of keys+ // are recognized. The same happens for the <Home> and <End> keys.+ // normal vt100 ~+ // <F1> t_k1 <Esc>[11~ <xF1> <Esc>OP *<xF1>-xterm*+ // <F2> t_k2 <Esc>[12~ <xF2> <Esc>OQ *<xF2>-xterm*+ // <F3> t_k3 <Esc>[13~ <xF3> <Esc>OR *<xF3>-xterm*+ // <F4> t_k4 <Esc>[14~ <xF4> <Esc>OS *<xF4>-xterm*+ // <Home> t_kh <Esc>[7~ <xHome> <Esc>OH *<xHome>-xterm*+ // <End> t_@7 <Esc>[4~ <xEnd> <Esc>OF *<xEnd>-xterm*+ case KEYCODE_F1:+ return (keyMode == 0) ? "\033OP" : transformForModifiers("\033[1", keyMode, 'P');+ case KEYCODE_F2:+ return (keyMode == 0) ? "\033OQ" : transformForModifiers("\033[1", keyMode, 'Q');+ case KEYCODE_F3:+ return (keyMode == 0) ? "\033OR" : transformForModifiers("\033[1", keyMode, 'R');+ case KEYCODE_F4:+ return (keyMode == 0) ? "\033OS" : transformForModifiers("\033[1", keyMode, 'S');+ case KEYCODE_F5:+ return transformForModifiers("\033[15", keyMode, '~');+ case KEYCODE_F6:+ return transformForModifiers("\033[17", keyMode, '~');+ case KEYCODE_F7:+ return transformForModifiers("\033[18", keyMode, '~');+ case KEYCODE_F8:+ return transformForModifiers("\033[19", keyMode, '~');+ case KEYCODE_F9:+ return transformForModifiers("\033[20", keyMode, '~');+ case KEYCODE_F10:+ return transformForModifiers("\033[21", keyMode, '~');+ case KEYCODE_F11:+ return transformForModifiers("\033[23", keyMode, '~');+ case KEYCODE_F12:+ return transformForModifiers("\033[24", keyMode, '~');++ case KEYCODE_SYSRQ:+ return "\033[32~"; // Sys Request / Print+ // Is this Scroll lock? case Cancel: return "\033[33~";+ case KEYCODE_BREAK:+ return "\033[34~"; // Pause/Break++ case KEYCODE_ESCAPE:+ case KEYCODE_BACK:+ return "\033";++ case KEYCODE_INSERT:+ return transformForModifiers("\033[2", keyMode, '~');+ case KEYCODE_FORWARD_DEL:+ return transformForModifiers("\033[3", keyMode, '~');++ case KEYCODE_PAGE_UP:+ return transformForModifiers("\033[5", keyMode, '~');+ case KEYCODE_PAGE_DOWN:+ return transformForModifiers("\033[6", keyMode, '~');+ case KEYCODE_DEL:+ String prefix = ((keyMode & KEYMOD_ALT) == 0) ? "" : "\033";+ // Just do what xterm and gnome-terminal does:+ return prefix + (((keyMode & KEYMOD_CTRL) == 0) ? "\u007F" : "\u0008");+ case KEYCODE_NUM_LOCK:+ if (keypadApplication) {+ return "\033OP";+ } else {+ return null;+ }+ case KEYCODE_SPACE:+ // If ctrl is not down, return null so that it goes through normal input processing (which may e.g. cause a+ // combining accent to be written):+ return ((keyMode & KEYMOD_CTRL) == 0) ? null : "\0";+ case KEYCODE_TAB:+ // This is back-tab when shifted:+ return (keyMode & KEYMOD_SHIFT) == 0 ? "\011" : "\033[Z";+ case KEYCODE_ENTER:+ return ((keyMode & KEYMOD_ALT) == 0) ? "\r" : "\033\r";++ case KEYCODE_NUMPAD_ENTER:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'M') : "\n";+ case KEYCODE_NUMPAD_MULTIPLY:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'j') : "*";+ case KEYCODE_NUMPAD_ADD:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'k') : "+";+ case KEYCODE_NUMPAD_COMMA:+ return ",";+ case KEYCODE_NUMPAD_DOT:+ if (numLockOn) {+ return keypadApplication ? "\033On" : ".";+ } else {+ // DELETE+ return transformForModifiers("\033[3", keyMode, '~');+ }+ case KEYCODE_NUMPAD_SUBTRACT:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'm') : "-";+ case KEYCODE_NUMPAD_DIVIDE:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'o') : "/";+ case KEYCODE_NUMPAD_0:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'p') : "0";+ } else {+ // INSERT+ return transformForModifiers("\033[2", keyMode, '~');+ }+ case KEYCODE_NUMPAD_1:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'q') : "1";+ } else {+ // END+ return (keyMode == 0) ? (cursorApp ? "\033OF" : "\033[F") : transformForModifiers("\033[1", keyMode, 'F');+ }+ case KEYCODE_NUMPAD_2:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'r') : "2";+ } else {+ // DOWN+ return (keyMode == 0) ? (cursorApp ? "\033OB" : "\033[B") : transformForModifiers("\033[1", keyMode, 'B');+ }+ case KEYCODE_NUMPAD_3:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 's') : "3";+ } else {+ // PGDN+ return "\033[6~";+ }+ case KEYCODE_NUMPAD_4:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 't') : "4";+ } else {+ // LEFT+ return (keyMode == 0) ? (cursorApp ? "\033OD" : "\033[D") : transformForModifiers("\033[1", keyMode, 'D');+ }+ case KEYCODE_NUMPAD_5:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'u') : "5";+ case KEYCODE_NUMPAD_6:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'v') : "6";+ } else {+ // RIGHT+ return (keyMode == 0) ? (cursorApp ? "\033OC" : "\033[C") : transformForModifiers("\033[1", keyMode, 'C');+ }+ case KEYCODE_NUMPAD_7:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'w') : "7";+ } else {+ // HOME+ return (keyMode == 0) ? (cursorApp ? "\033OH" : "\033[H") : transformForModifiers("\033[1", keyMode, 'H');+ }+ case KEYCODE_NUMPAD_8:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'x') : "8";+ } else {+ // UP+ return (keyMode == 0) ? (cursorApp ? "\033OA" : "\033[A") : transformForModifiers("\033[1", keyMode, 'A');+ }+ case KEYCODE_NUMPAD_9:+ if (numLockOn) {+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'y') : "9";+ } else {+ // PGUP+ return "\033[5~";+ }+ case KEYCODE_NUMPAD_EQUALS:+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'X') : "=";+ }++ return null;+ }++ private static String transformForModifiers(String start, int keymod, char lastChar) {+ int modifier;+ switch (keymod) {+ case KEYMOD_SHIFT:+ modifier = 2;+ break;+ case KEYMOD_ALT:+ modifier = 3;+ break;+ case (KEYMOD_SHIFT | KEYMOD_ALT):+ modifier = 4;+ break;+ case KEYMOD_CTRL:+ modifier = 5;+ break;+ case KEYMOD_SHIFT | KEYMOD_CTRL:+ modifier = 6;+ break;+ case KEYMOD_ALT | KEYMOD_CTRL:+ modifier = 7;+ break;+ case KEYMOD_SHIFT | KEYMOD_ALT | KEYMOD_CTRL:+ modifier = 8;+ break;+ default:+ return start + lastChar;+ }+ return start + (";" + modifier) + lastChar;+ }+}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/Logger.java b/terminal-emulator/src/main/java/com/termux/terminal/Logger.javanew file mode 100644index 0000000..d4d502e--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/Logger.java@@ -0,0 +1,80 @@+package com.termux.terminal;++import android.util.Log;++import java.io.IOException;+import java.io.PrintWriter;+import java.io.StringWriter;++public class Logger {++ public static void logError(TerminalSessionClient client, String logTag, String message) {+ if (client != null)+ client.logError(logTag, message);+ else+ Log.e(logTag, message);+ }++ public static void logWarn(TerminalSessionClient client, String logTag, String message) {+ if (client != null)+ client.logWarn(logTag, message);+ else+ Log.w(logTag, message);+ }++ public static void logInfo(TerminalSessionClient client, String logTag, String message) {+ if (client != null)+ client.logInfo(logTag, message);+ else+ Log.i(logTag, message);+ }++ public static void logDebug(TerminalSessionClient client, String logTag, String message) {+ if (client != null)+ client.logDebug(logTag, message);+ else+ Log.d(logTag, message);+ }++ public static void logVerbose(TerminalSessionClient client, String logTag, String message) {+ if (client != null)+ client.logVerbose(logTag, message);+ else+ Log.v(logTag, message);+ }++ public static void logStackTraceWithMessage(TerminalSessionClient client, String tag, String message, Throwable throwable) {+ logError(client, tag, getMessageAndStackTraceString(message, throwable));+ }++ public static String getMessageAndStackTraceString(String message, Throwable throwable) {+ if (message == null && throwable == null)+ return null;+ else if (message != null && throwable != null)+ return message + ":\n" + getStackTraceString(throwable);+ else if (throwable == null)+ return message;+ else+ return getStackTraceString(throwable);+ }++ public static String getStackTraceString(Throwable throwable) {+ if (throwable == null) return null;++ String stackTraceString = null;++ try {+ StringWriter errors = new StringWriter();+ PrintWriter pw = new PrintWriter(errors);+ throwable.printStackTrace(pw);+ pw.close();+ stackTraceString = errors.toString();+ errors.close();+ } catch (IOException e) {+ e.printStackTrace();+ }++ return stackTraceString;+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalBitmap.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalBitmap.javanew file mode 100644index 0000000..0a95f33--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalBitmap.java@@ -0,0 +1,462 @@+package com.termux.terminal;++import android.app.WallpaperManager;+import android.graphics.Bitmap;+import android.graphics.BitmapFactory;+import android.graphics.Canvas;+import android.graphics.Paint;+import android.graphics.RecordingCanvas;+import android.graphics.Rect;+import android.graphics.RectF;+import android.os.Build;++import java.util.Properties;++/**+ * A terminal bitmap for images.+ */+public class TerminalBitmap {++ public static final String LOG_TAG = "TerminalBitmap";++ private static int initMaxBitmapSize() {+ int defaultSize =+ Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM ?+ 150 * 1024 * 1024 : // 150 MB+ 100 * 1024 * 1024; // 100 MB++ Properties systemProperties = AndroidUtils.getSystemProperties(LOG_TAG);+ String maxTextureSizeString = systemProperties.getProperty("ro.hwui.max_texture_allocation_size");++ if (maxTextureSizeString == null) return defaultSize;++ try {+ int maxTextureSize = Integer.parseInt(maxTextureSizeString);+ return maxTextureSize > 0 ? maxTextureSize : defaultSize;+ }+ catch (Exception e) {+ return defaultSize;+ }+ }++ /**+ * The max size of a Terminal {@link Bitmap} for its pixels. The limit is defined as per how+ * `RecordingCanvas.MAX_BITMAP_SIZE` value is defined, check below for details. The value should+ * normally be between `100-200MB` depending on device and Android version.+ *+ * Each pixel is stored on 4 bytes for a {@link Bitmap.Config#ARGB_8888} bitmap color config.+ * The bitmap will have following memory usage for its respective resolution (`width x height x 4`).+ * - 1280x720 (HD): 3,686,400 bytes/3.6MB.+ * - 1920x1080 (FHD): 8,294,400 bytes/8MB.+ * - 2560x1440 (QHD): 14,745,600 bytes/14.7MB.+ * - 3840x2160 (4K UHD): 33,177,600 bytes/33MB.+ * - 7680x4320 (8K UHD): 132,710,400 bytes/132MB.+ * .+ * - https://en.wikipedia.org/wiki/Display_resolution_standards#High-definition+ *+ * The terminal uses {@link Canvas#drawBitmap(Bitmap, Rect, RectF, Paint)} to draw the bitmap+ * when `TerminalRenderer.render()` is called.+ *+ * The {@link Canvas} class defines `Canvas.MAXIMUM_BITMAP_SIZE` for the maximum dimension+ * for a bitmap which is returned by {@link Canvas#getMaximumBitmapWidth()} and+ * {@link Canvas#getMaximumBitmapHeight()}. It is hardcoded with the value `32766` as defined by+ * Skia (2D graphics library), which technically has the limit `32767` as it requires supporting+ * math on 16-bit buffers.+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/f61970fc79e9c5cf340fa942597628242361864a+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/graphics/java/android/graphics/Canvas.java;l=76-78+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:external/skia/src/shaders/SkImageShader.cpp;l=254-267+ *+ * The {@link RecordingCanvas} class defines `RecordingCanvas.MAX_BITMAP_SIZE` for the+ * maximum size (not dimension) for a bitmap, which is checked by+ * `RecordingCanvas.throwIfCannotDraw()` when `BaseRecordingCanvas.drawBitmap()` is called.+ * The `RecordingCanvas` is a specialized implementation of the `Canvas` class that is designed+ * to record draw commands for deferred rendering instead of executing draw commands instantly.+ * By recording draw commands, they can be cached so that complex views can be efficiently+ * re-drawn without recalculating them again for every frame. The caching part is similar to+ * how a terminal behaves, where it stores all the bitmaps for rendering depending on scroll+ * position. So both {@link RecordingCanvas} and a terminal require similar limits on bitmap+ * sizes considering memory consumption limits of apps, and multiple bitmaps being loaded+ * instead of a single one like for wallpapers, hence why `TerminalBitmap.MAX_BITMAP_SIZE` is+ * synced with {@link RecordingCanvas}.+ * The `RecordingCanvas.MAX_BITMAP_SIZE` is set from `ro.hwui.max_texture_allocation_size`+ * system property if set for Android `>= 12`, otherwise `150MB` (`100MB` for Android `10-14`).+ * The values `>= 150MB` are enough to support `7680x4320` (8K UHD) bitmaps.+ * Some devices like larger xiaomi devices have `ro.hwui.max_texture_allocation_size` set to `209715200` (`200MB`).+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/e4d011201cea40d46cb2b2eef401db8fddc5c9c6+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/0e717a9d06ded980908649393bd73e46ffafcd54+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/97396260ed06cc9d1834d4d8e4e649a3ef09f1f3+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/graphics/java/android/graphics/RecordingCanvas.java;l=42-50+ *+ * The Android wallpaper manager service also checks if dimensions of cropped wallpaper exceeds+ * max texture size that the GPU can support, otherwise it will cause System UI to keep crashing+ * because it can not initialize EGL with an appropriate surface. The `GLHelper.getMaxTextureSize()`+ * returns the max texture size, which is defined by `sys.max_texture_size` system property if set,+ * otherwise by value for `GL_MAX_TEXTURE_SIZE`. The `sys.max_texture_size` defines the maximum+ * width or height of a texture, not total size. Its value can be low like `2048` or high like+ * `16384` for 16K support.+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/32c6a7c691b0d91085c1ed13fe6f1c473c94b4c8+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperCropper.java;l=461+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/GLHelper.java;l=145+ * - https://developer.android.com/reference/android/opengl/GLES10#GL_MAX_TEXTURE_SIZE+ *+ * The {@link WallpaperManager#getDesiredMinimumWidth()} and {@link WallpaperManager#getDesiredMinimumHeight()}+ * can also be called to get minimum suggested width and height of the wallpaper that an app+ * should use when setting the wallpaper. This normally is equal to the width and height of the+ * current device display, but the width can be higher than display width if the homescreen is+ * scrollable horizontally with multiple pages, in which case the width returned is equal to+ * entire workspace width. The launcher apps can provide Android their desired width and height+ * dimensions depending on the homescreen pages config by calling+ * {@link WallpaperManager#suggestDesiredDimensions(int, int)}, which also ensures that values+ * passed are scaled down to `sys.max_texture_size` system property if its set.+ * - https://cs.android.com/android/_/android/platform/frameworks/base/+/289c273ec49462c7bfdbf6238e9016936da7307c+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/core/java/android/app/WallpaperManager.java;l=2737-2794+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java;l=2330-2366+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperDisplayHelper.java;l=108-115+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/core/java/android/view/Display.java;l=1052-1063+ *+ * If an app specifies `largeHeap=true` in its `AndroidManifest.xml`, then it can be allocated+ * larger heap memory to load larger bitmaps maps instead of resulting in an OOM. The Termux app+ * does not have it enabled, and hence is more likely to have OOMs when loading larger bitmaps.+ * - https://developer.android.com/guide/topics/manifest/application-element#largeHeap+ * - https://developer.android.com/topic/performance/memory+ */+ public static final int MAX_BITMAP_SIZE = initMaxBitmapSize();++++ protected final TerminalSessionClient mClient;++ protected int mBitmapNum;+ protected Bitmap mBitmap;++ protected int mCellWidth;+ protected int mCellHeight;++ protected int mScrollLines;++ protected int[] mCursorDelta;+++ protected TerminalBitmap(TerminalSessionClient client, int bitmapNum, Bitmap bitmap,+ int cellWidth, int cellHeight,+ int scrollLines, int[] cursorDelta) {+ mClient = client;++ mBitmapNum = bitmapNum;+ mBitmap = bitmap;++ mCellWidth = cellWidth;+ mCellHeight = cellHeight;++ mScrollLines = scrollLines;+ mCursorDelta = cursorDelta;+ }++++ /** Build a {@link TerminalBitmap} from a {@link TerminalSixel}. */+ public static TerminalBitmap build(TerminalBuffer terminalBuffer, int bitmapNum, TerminalSixel terminalSixel,+ int x, int y, int cellWidth, int cellHeight) {+ try {+ Bitmap bitmap = terminalSixel.getBitmap();+ bitmap = resizeBitmapConstrained(LOG_TAG, "sixel", terminalBuffer.getClient(), bitmap,+ terminalSixel.getWidth(), terminalSixel.getHeight(), cellWidth, cellHeight,+ terminalBuffer.mColumns - x);+ if (bitmap == null) {+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from terminal sixel failed");+ return null;+ }++ return buildOrThrow(terminalBuffer, bitmapNum, bitmap,+ x, y, cellWidth, cellHeight);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from terminal sixel failed: " + t.getMessage());+ return null;+ }+ }+++ /** Build a {@link TerminalBitmap} from an image `byte[]`. */+ public static TerminalBitmap build(TerminalBuffer terminalBuffer, int bitmapNum, byte[] image,+ int x, int y, int cellWidth, int cellHeight,+ int width, int height, boolean shouldPreserveAspectRatio) {+ try {+ Bitmap newBitmap;+ int imageHeight;+ int imageWidth;+ int newWidth = width;+ int newHeight = height;++ if (height > 0 || width > 0) {+ // Get image dimensions without creating a bitmap.+ BitmapFactory.Options options = new BitmapFactory.Options();+ options.inJustDecodeBounds = true;+ try {+ BitmapFactory.decodeByteArray(image, 0, image.length, options);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logWarn(terminalBuffer.getClient(), LOG_TAG,+ "Decode bitmap failed while creating" ++ " terminal bitmap " + bitmapNum + " from image byte array: " + t.getMessage());+ }+++ imageHeight = options.outHeight;+ imageWidth = options.outWidth;+ if (shouldPreserveAspectRatio) {+ double wFactor = 9999.0;+ double hFactor = 9999.0;+ if (width > 0) {+ wFactor = (double) width / imageWidth;+ }+ if (height > 0) {+ hFactor = (double) height / imageHeight;+ }+ double factor = Math.min(wFactor, hFactor);+ newWidth = (int) (factor * imageWidth);+ newHeight = (int) (factor * imageHeight);+ } else {+ if (height <= 0) {+ newHeight = imageHeight;+ }+ if (width <= 0) {+ newWidth = imageWidth;+ }+ }++ int scaleFactor = 1;+ while (imageHeight >= 2 * newHeight * scaleFactor && imageWidth >= 2 * newWidth * scaleFactor) {+ scaleFactor = scaleFactor * 2;+ }+++ // Create bitmap from image.+ BitmapFactory.Options scaleOptions = new BitmapFactory.Options();+ // Subsample the original image to get a smaller image to save memory.+ scaleOptions.inSampleSize = scaleFactor;+ try {+ newBitmap = BitmapFactory.decodeByteArray(image, 0, image.length, scaleOptions);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed:" ++ " Decode scaled bitmap failed: " + t.getMessage());+ return null;+ }+ if (newBitmap == null) {+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed:" ++ " Decoded scaled bitmap not set");+ return null;+ }+++ // Crop the bitmap if it exceeds terminal bounds.+ int maxWidth = (terminalBuffer.mColumns - x) * cellWidth;+ if (newWidth > maxWidth) {+ int cropWidth = newBitmap.getWidth() * maxWidth / newWidth;+ try {+ newBitmap = Bitmap.createBitmap(newBitmap, 0, 0, cropWidth, newBitmap.getHeight());+ newWidth = maxWidth;+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) {+ // This is just a memory optimization. If it fails,+ // continue (and probably fail later).+ System.gc();+ }++ }+ }+++ // Create final scaled bitmap.+ try {+ newBitmap = Bitmap.createScaledBitmap(newBitmap, newWidth, newHeight, true);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed:" ++ " Create scaled bitmap failed: " + t.getMessage());+ return null;+ }+ } else {+ // Create bitmap from image.+ try {+ newBitmap = BitmapFactory.decodeByteArray(image, 0, image.length);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed:" ++ " Create full bitmap failed: " + t.getMessage());+ return null;+ }+ }++ if (newBitmap == null) {+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed: New bitmap not set");+ return null;+ }+++ newBitmap = resizeBitmapConstrained(LOG_TAG, "image byte array", terminalBuffer.getClient(), newBitmap,+ newBitmap.getWidth(), newBitmap.getHeight(), cellWidth, cellHeight,+ terminalBuffer.mColumns - x);+ TerminalBitmap terminalBitmap = build(terminalBuffer, bitmapNum, newBitmap, x, y, cellWidth, cellHeight);+ if (terminalBitmap == null) {+ return terminalBitmap;+ }++ terminalBitmap.setCursorDelta(new int[] {+ terminalBitmap.getScrollLines(),+ (terminalBitmap.getBitmap().getWidth() + cellWidth - 1) / cellWidth});++ return terminalBitmap;+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from image byte array failed: " + t.getMessage());+ return null;+ }+ }+++ /** Build a {@link TerminalBitmap} from a {@link Bitmap}. */+ public static TerminalBitmap build(TerminalBuffer terminalBuffer, int bitmapNum, Bitmap bitmap,+ int x, int y, int cellWidth, int cellHeight) {+ try {+ return buildOrThrow(terminalBuffer, bitmapNum, bitmap, x, y, cellWidth, cellHeight);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(terminalBuffer.getClient(), LOG_TAG,+ "Create terminal bitmap " + bitmapNum + " from bitmap failed: " + t.getMessage());+ return null;+ }+ }++ /** Build a {@link TerminalBitmap} from a {@link Bitmap}. */+ public static TerminalBitmap buildOrThrow(TerminalBuffer terminalBuffer, int bitmapNum, Bitmap bitmap,+ int x, int y, int cellWidth, int cellHeight) throws Throwable {+ if (bitmap == null) {+ throw new IllegalArgumentException("Cannot create terminal bitmap from an unset bitmap");+ }++ int bitmapWidth = bitmap.getWidth();+ int bitmapHeight = bitmap.getHeight();+ int width = Math.min(terminalBuffer.mColumns - x, (bitmapWidth + cellWidth - 1) / cellWidth);+ int height = (bitmapHeight + cellHeight - 1) / cellHeight;+ int s = 0;++ for (int i = 0; i < height; i++) {+ if (y + i - s == terminalBuffer.mScreenRows) {+ terminalBuffer.scrollDownOneLine(0, terminalBuffer.mScreenRows, TextStyle.NORMAL);+ s++;+ }+ for (int j = 0; j < width ; j++) {+ terminalBuffer.setChar(x + j, y + i - s, '+', TextStyle.encodeTerminalBitmap(bitmapNum, j, i));+ }+ }++ if (width * cellWidth < bitmapWidth) {+ bitmap = Bitmap.createBitmap(bitmap, 0, 0, width * cellWidth, bitmapHeight);+ }++ int scrollLines = height - s;++ return new TerminalBitmap(terminalBuffer.getClient(), bitmapNum, bitmap,+ cellWidth, cellHeight, scrollLines, null);+ }++++ public TerminalSessionClient getClient() {+ return mClient;+ }+++ public int getBitmapNum() {+ return mBitmapNum;+ }++ public Bitmap getBitmap() {+ return mBitmap;+ }+++ public int getCellWidth() {+ return mCellWidth;+ }++ public int getCellHeight() {+ return mCellHeight;+ }+++ public int getScrollLines() {+ return mScrollLines;+ }+++ public int[] getCursorDelta() {+ return mCursorDelta;+ }++ public void setCursorDelta(int[] cursorDelta) {+ mCursorDelta = cursorDelta;+ }++++++ public static Bitmap resizeBitmap(String logTag, String label, TerminalSessionClient client, Bitmap bitmap,+ int bitmapWidth, int bitmapHeight) {++ Bitmap newBitmap;+ try {+ int newBitmapSize = bitmapWidth * bitmapHeight * 4;+ if (newBitmapSize < 0 || newBitmapSize > MAX_BITMAP_SIZE) {+ Logger.logError(client, logTag, "The new " + label + " bitmap after resize with" ++ " width " + bitmapWidth + " and height " + bitmapHeight ++ " has size " + newBitmapSize + " greater than max bitmap size " + MAX_BITMAP_SIZE);+ return null;+ }++ int[] pixels = new int[bitmap.getAllocationByteCount()];+ bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());++ newBitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888);++ int newWidth = Math.min(bitmap.getWidth(), bitmapWidth);+ int newHeight = Math.min(bitmap.getHeight(), bitmapHeight);+ newBitmap.setPixels(pixels, 0, bitmap.getWidth(), 0, 0, newWidth, newHeight);+ return newBitmap;+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(client, logTag, "Resize " + label + " bitmap to" ++ " width " + bitmapWidth + " and height " + bitmapHeight + " failed: " + t.getMessage());+ return null;+ }+ }++ public static Bitmap resizeBitmapConstrained(String logTag, String label, TerminalSessionClient client, Bitmap bitmap,+ int bitmapWidth, int bitmapHeight,+ int cellWidth, int cellHeight, int columns) {+ // Width and height must be multiples of the cell width and height.+ // Bitmap should not extend beyond screen width.+ Bitmap originalBitmap = bitmap;+ if (bitmapWidth > cellWidth * columns || (bitmapWidth % cellWidth) != 0 || (bitmapHeight % cellHeight) != 0) {+ int newBitmapWidth = Math.min(cellWidth * columns, ((bitmapWidth - 1) / cellWidth) * cellWidth + cellWidth);+ int newBitmapHeight = ((bitmapHeight - 1) / cellHeight) * cellHeight + cellHeight;+ bitmap = resizeBitmap(logTag, label, client, originalBitmap, newBitmapWidth, newBitmapHeight);+ // Only a minor display glitch if resize failed.+ return bitmap != null ? bitmap : originalBitmap;+ } else {+ return originalBitmap;+ }+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalBuffer.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalBuffer.javanew file mode 100644index 0000000..a284996--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalBuffer.java@@ -0,0 +1,837 @@+package com.termux.terminal;++import java.util.Arrays;+import java.util.HashSet;+import java.util.Set;+import java.util.HashMap;++import android.graphics.Bitmap;+import android.graphics.Rect;++import android.os.SystemClock;++/**+ * A circular buffer of {@link TerminalRow}:s which keeps notes about what is visible on a logical screen and the scroll+ * history.+ * <p>+ * See {@link #externalToInternalRow(int)} for how to map from logical screen rows to array indices.+ */+public final class TerminalBuffer {++ public static final String LOG_TAG = "TerminalBuffer";++++ private TerminalSessionClient mClient;++ TerminalRow[] mLines;+ /** The length of {@link #mLines}. */+ int mTotalRows;+ /** The number of rows and columns visible on the screen. */+ int mScreenRows, mColumns;+ /** The number of rows kept in history. */+ private int mActiveTranscriptRows = 0;+ /** The index in the circular buffer where the visible screen starts. */+ private int mScreenFirstRow = 0;+++ /**+ * The {@link TerminalSixel} if a sixel command is being processed, from which the final+ * {@link TerminalBitmap} is created.+ */+ private TerminalSixel mTerminalSixel;+++ /** The map for bitmap number to the {@link TerminalBitmap} loaded in the terminal. */+ private final HashMap<Integer, TerminalBitmap> mTerminalBitmaps;++ /** The time since last garbage collection for all the {@link TerminalBitmap} that are loaded in the terminal. */+ private long mTerminalBitmapsLastGC;++ /**+ * The bitmap number start for {@link #mTerminalBitmaps} keys.+ *+ * The bitmap number and coordinates are encoded in the `long` {@link TerminalRow#mStyle} for+ * the `TerminalRow` character of a column by+ * {@link TerminalBitmap#buildOrThrow(TerminalBuffer, int, Bitmap, int, int, int, int)} by+ * getting encoded value from {@link TextStyle#encodeTerminalBitmap(int, int, int)}.+ * The `TerminalRenderer.render()` then checks during rendering terminal output whether a+ * character at a row/coloumn index is a bitmap instead of text by calling+ * `TextStyle.isTerminalBitmap()`.+ */+ public static final int TERMINAL_BITMAP__NUM_START = 0;++ /**+ * The bitmap number end for {@link #mTerminalBitmaps} keys.+ */+ public static final int TERMINAL_BITMAP__NUM_END = Integer.MAX_VALUE;+++ // ── OSC 8 hyperlinks ─────────────────────────────────────────────────────+ // Tracks one region per `\e]8;;<url>\e\` … `\e]8;;\e\` pair. Stored as+ // (startRow, startCol) → (endRow, endCol) using *internal* row indices so+ // they survive scroll. Capped at HYPERLINK_REGIONS_MAX; FIFO eviction.+ public static final class HyperlinkRegion {+ public final int startInternalRow, startCol, endInternalRow, endCol;+ public final String url;+ HyperlinkRegion(int sR, int sC, int eR, int eC, String u) {+ startInternalRow = sR; startCol = sC; endInternalRow = eR; endCol = eC; url = u;+ }+ }++ private static final int HYPERLINK_REGIONS_MAX = 1024;+ private final java.util.ArrayDeque<HyperlinkRegion> mHyperlinks = new java.util.ArrayDeque<>();+ private String mPendingHyperlinkUrl;+ private int mPendingHyperlinkStartInternalRow = -1;+ private int mPendingHyperlinkStartCol = -1;++ /** Called by emulator when `\e]8;;<url>\e\` opens. cursor is in external coords. */+ public void beginHyperlink(String url, int cursorRow, int cursorCol) {+ endHyperlink(cursorRow, cursorCol); // close any previous+ if (url == null || url.isEmpty()) return;+ mPendingHyperlinkUrl = url;+ mPendingHyperlinkStartInternalRow = externalToInternalRow(cursorRow);+ mPendingHyperlinkStartCol = cursorCol;+ }++ /** Called by emulator when `\e]8;;\e\` closes (or a new hyperlink begins). */+ public void endHyperlink(int cursorRow, int cursorCol) {+ if (mPendingHyperlinkUrl == null) return;+ int endInternal = externalToInternalRow(cursorRow);+ if (mHyperlinks.size() >= HYPERLINK_REGIONS_MAX) mHyperlinks.removeFirst();+ mHyperlinks.addLast(new HyperlinkRegion(+ mPendingHyperlinkStartInternalRow, mPendingHyperlinkStartCol,+ endInternal, cursorCol, mPendingHyperlinkUrl));+ mPendingHyperlinkUrl = null;+ }++ /** Lookup URL at an external (visible) cell position, or null. */+ public String getHyperlinkAt(int externalRow, int col) {+ int target = externalToInternalRow(externalRow);+ // Reverse iterate: most recent matches first.+ java.util.Iterator<HyperlinkRegion> it = mHyperlinks.descendingIterator();+ while (it.hasNext()) {+ HyperlinkRegion r = it.next();+ if (containsCell(r, target, col)) return r.url;+ }+ return null;+ }++ private boolean containsCell(HyperlinkRegion r, int internalRow, int col) {+ // Single-line region.+ if (r.startInternalRow == r.endInternalRow) {+ return internalRow == r.startInternalRow && col >= r.startCol && col < r.endCol;+ }+ // Multi-line region — wrap-aware in the ring buffer.+ // Walk forward from start to end through the ring; check membership.+ int row = r.startInternalRow;+ while (true) {+ if (row == internalRow) {+ if (row == r.startInternalRow) return col >= r.startCol;+ if (row == r.endInternalRow) return col < r.endCol;+ return true; // middle row — full width+ }+ if (row == r.endInternalRow) return false;+ row = (row + 1) % mTotalRows;+ }+ }+++ public TerminalBuffer(int columns, int totalRows, int screenRows) {+ this(null, columns, totalRows, screenRows);+ }++ /**+ * Create a transcript screen.+ *+ * @param client the {@link TerminalSessionClient}.+ * @param columns the width of the screen in characters.+ * @param totalRows the height of the entire text area, in rows of text.+ * @param screenRows the height of just the screen, not including the transcript that holds lines that have scrolled off+ * the top of the screen.+ */+ public TerminalBuffer(TerminalSessionClient client, int columns, int totalRows, int screenRows) {+ mClient = client;++ mColumns = columns;+ mTotalRows = totalRows;+ mScreenRows = screenRows;+ mLines = new TerminalRow[totalRows];++ blockSet(0, 0, columns, screenRows, ' ', TextStyle.NORMAL);+ mTerminalBitmaps = new HashMap<>();+ mTerminalBitmapsLastGC = SystemClock.uptimeMillis();+ }++++ public TerminalSessionClient getClient() {+ return mClient;+ }+++ public String getTranscriptText() {+ return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows).trim();+ }++ public String getTranscriptTextWithoutJoinedLines() {+ return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows, false).trim();+ }++ public String getTranscriptTextWithFullLinesJoined() {+ return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows, true, true).trim();+ }++ public String getSelectedText(int selX1, int selY1, int selX2, int selY2) {+ return getSelectedText(selX1, selY1, selX2, selY2, true);+ }++ public String getSelectedText(int selX1, int selY1, int selX2, int selY2, boolean joinBackLines) {+ return getSelectedText(selX1, selY1, selX2, selY2, joinBackLines, false);+ }++ public String getSelectedText(int selX1, int selY1, int selX2, int selY2, boolean joinBackLines, boolean joinFullLines) {+ final StringBuilder builder = new StringBuilder();+ final int columns = mColumns;++ if (selY1 < -getActiveTranscriptRows()) selY1 = -getActiveTranscriptRows();+ if (selY2 >= mScreenRows) selY2 = mScreenRows - 1;++ for (int row = selY1; row <= selY2; row++) {+ int x1 = (row == selY1) ? selX1 : 0;+ int x2;+ if (row == selY2) {+ x2 = selX2 + 1;+ if (x2 > columns) x2 = columns;+ } else {+ x2 = columns;+ }+ TerminalRow lineObject = mLines[externalToInternalRow(row)];+ int x1Index = lineObject.findStartOfColumn(x1);+ int x2Index = (x2 < mColumns) ? lineObject.findStartOfColumn(x2) : lineObject.getSpaceUsed();+ if (x2Index == x1Index) {+ // Selected the start of a wide character.+ x2Index = lineObject.findStartOfColumn(x2 + 1);+ }+ char[] line = lineObject.mText;+ int lastPrintingCharIndex = -1;+ int i;+ boolean rowLineWrap = getLineWrap(row);+ if (rowLineWrap && x2 == columns) {+ // If the line was wrapped, we shouldn't lose trailing space:+ lastPrintingCharIndex = x2Index - 1;+ } else {+ for (i = x1Index; i < x2Index; ++i) {+ char c = line[i];+ if (c != ' ') lastPrintingCharIndex = i;+ }+ }++ int len = lastPrintingCharIndex - x1Index + 1;+ if (lastPrintingCharIndex != -1 && len > 0)+ builder.append(line, x1Index, len);++ boolean lineFillsWidth = lastPrintingCharIndex == x2Index - 1;+ if ((!joinBackLines || !rowLineWrap) && (!joinFullLines || !lineFillsWidth)+ && row < selY2 && row < mScreenRows - 1) builder.append('\n');+ }+ return builder.toString();+ }++ public String getWordAtLocation(int x, int y) {+ // Set y1 and y2 to the lines where the wrapped line starts and ends.+ // I.e. if a line that is wrapped to 3 lines starts at line 4, and this+ // is called with y=5, then y1 would be set to 4 and y2 would be set to 6.+ int y1 = y;+ int y2 = y;+ while (y1 > 0 && !getSelectedText(0, y1 - 1, mColumns, y, true, true).contains("\n")) {+ y1--;+ }+ while (y2 < mScreenRows && !getSelectedText(0, y, mColumns, y2 + 1, true, true).contains("\n")) {+ y2++;+ }++ // Get the text for the whole wrapped line+ String text = getSelectedText(0, y1, mColumns, y2, true, true);+ // The index of x in text+ int textOffset = (y - y1) * mColumns + x;++ if (textOffset >= text.length()) {+ // The click was to the right of the last word on the line, so+ // there's no word to return+ return "";+ }++ // Set x1 and x2 to the indices of the last space before x and the+ // first space after x in text respectively+ int x1 = text.lastIndexOf(' ', textOffset);+ int x2 = text.indexOf(' ', textOffset);+ if (x2 == -1) {+ x2 = text.length();+ }++ if (x1 == x2) {+ // The click was on a space, so there's no word to return+ return "";+ }+ return text.substring(x1 + 1, x2);+ }++ public int getActiveTranscriptRows() {+ return mActiveTranscriptRows;+ }++ public int getActiveRows() {+ return mActiveTranscriptRows + mScreenRows;+ }++ /**+ * Convert a row value from the public external coordinate system to our internal private coordinate system.+ *+ * <pre>+ * - External coordinate system: -mActiveTranscriptRows to mScreenRows-1, with the screen being 0..mScreenRows-1.+ * - Internal coordinate system: the mScreenRows lines starting at mScreenFirstRow comprise the screen, while the+ * mActiveTranscriptRows lines ending at mScreenFirstRow-1 form the transcript (as a circular buffer).+ *+ * External ↔ Internal:+ *+ * [ ... ] [ ... ]+ * [ -mActiveTranscriptRows ] [ mScreenFirstRow - mActiveTranscriptRows ]+ * [ ... ] [ ... ]+ * [ 0 (visible screen starts here) ] ↔ [ mScreenFirstRow ]+ * [ ... ] [ ... ]+ * [ mScreenRows-1 ] [ mScreenFirstRow + mScreenRows-1 ]+ * </pre>+ *+ * @param externalRow a row in the external coordinate system.+ * @return The row corresponding to the input argument in the private coordinate system.+ */+ public int externalToInternalRow(int externalRow) {+ if (externalRow < -mActiveTranscriptRows || externalRow > mScreenRows)+ throw new IllegalArgumentException("extRow=" + externalRow + ", mScreenRows=" + mScreenRows + ", mActiveTranscriptRows=" + mActiveTranscriptRows);+ final int internalRow = mScreenFirstRow + externalRow;+ return (internalRow < 0) ? (mTotalRows + internalRow) : (internalRow % mTotalRows);+ }++ public void setLineWrap(int row) {+ mLines[externalToInternalRow(row)].mLineWrap = true;+ }++ public boolean getLineWrap(int row) {+ return mLines[externalToInternalRow(row)].mLineWrap;+ }++ public void clearLineWrap(int row) {+ mLines[externalToInternalRow(row)].mLineWrap = false;+ }++ /**+ * Resize the screen which this transcript backs. Currently, this only works if the number of columns does not+ * change or the rows expand (that is, it only works when shrinking the number of rows).+ *+ * @param newColumns The number of columns the screen should have.+ * @param newRows The number of rows the screen should have.+ * @param cursor An int[2] containing the (column, row) cursor location.+ */+ public void resize(int newColumns, int newRows, int newTotalRows, int[] cursor, long currentStyle, boolean altScreen) {+ // newRows > mTotalRows should not normally happen since mTotalRows is TRANSCRIPT_ROWS (10000):+ if (newColumns == mColumns && newRows <= mTotalRows) {+ // Fast resize where just the rows changed.+ int shiftDownOfTopRow = mScreenRows - newRows;+ if (shiftDownOfTopRow > 0 && shiftDownOfTopRow < mScreenRows) {+ // Shrinking. Check if we can skip blank rows at bottom below cursor.+ for (int i = mScreenRows - 1; i > 0; i--) {+ if (cursor[1] >= i) break;+ int r = externalToInternalRow(i);+ if (mLines[r] == null || mLines[r].isBlank()) {+ if (--shiftDownOfTopRow == 0) break;+ }+ }+ } else if (shiftDownOfTopRow < 0) {+ // Negative shift down = expanding. Only move screen up if there is transcript to show:+ int actualShift = Math.max(shiftDownOfTopRow, -mActiveTranscriptRows);+ if (shiftDownOfTopRow != actualShift) {+ // The new lines revealed by the resizing are not all from the transcript. Blank the below ones.+ for (int i = 0; i < actualShift - shiftDownOfTopRow; i++)+ allocateFullLineIfNecessary((mScreenFirstRow + mScreenRows + i) % mTotalRows).clear(currentStyle);+ shiftDownOfTopRow = actualShift;+ }+ }+ mScreenFirstRow += shiftDownOfTopRow;+ mScreenFirstRow = (mScreenFirstRow < 0) ? (mScreenFirstRow + mTotalRows) : (mScreenFirstRow % mTotalRows);+ mTotalRows = newTotalRows;+ mActiveTranscriptRows = altScreen ? 0 : Math.max(0, mActiveTranscriptRows + shiftDownOfTopRow);+ cursor[1] -= shiftDownOfTopRow;+ mScreenRows = newRows;+ } else {+ // Copy away old state and update new:+ TerminalRow[] oldLines = mLines;+ mLines = new TerminalRow[newTotalRows];+ for (int i = 0; i < newTotalRows; i++)+ mLines[i] = new TerminalRow(newColumns, currentStyle);++ final int oldActiveTranscriptRows = mActiveTranscriptRows;+ final int oldScreenFirstRow = mScreenFirstRow;+ final int oldScreenRows = mScreenRows;+ final int oldTotalRows = mTotalRows;+ mTotalRows = newTotalRows;+ mScreenRows = newRows;+ mActiveTranscriptRows = mScreenFirstRow = 0;+ mColumns = newColumns;++ int newCursorRow = -1;+ int newCursorColumn = -1;+ int oldCursorRow = cursor[1];+ int oldCursorColumn = cursor[0];+ boolean newCursorPlaced = false;++ int currentOutputExternalRow = 0;+ int currentOutputExternalColumn = 0;++ // Loop over every character in the initial state.+ // Blank lines should be skipped only if at end of transcript (just as is done in the "fast" resize), so we+ // keep track how many blank lines we have skipped if we later on find a non-blank line.+ int skippedBlankLines = 0;+ for (int externalOldRow = -oldActiveTranscriptRows; externalOldRow < oldScreenRows; externalOldRow++) {+ // Do what externalToInternalRow() does but for the old state:+ int internalOldRow = oldScreenFirstRow + externalOldRow;+ internalOldRow = (internalOldRow < 0) ? (oldTotalRows + internalOldRow) : (internalOldRow % oldTotalRows);++ TerminalRow oldLine = oldLines[internalOldRow];+ boolean cursorAtThisRow = externalOldRow == oldCursorRow;+ // The cursor may only be on a non-null line, which we should not skip:+ if (oldLine == null || (!(!newCursorPlaced && cursorAtThisRow)) && oldLine.isBlank()) {+ skippedBlankLines++;+ continue;+ } else if (skippedBlankLines > 0) {+ // After skipping some blank lines we encounter a non-blank line. Insert the skipped blank lines.+ for (int i = 0; i < skippedBlankLines; i++) {+ if (currentOutputExternalRow == mScreenRows - 1) {+ scrollDownOneLine(0, mScreenRows, currentStyle);+ } else {+ currentOutputExternalRow++;+ }+ currentOutputExternalColumn = 0;+ }+ skippedBlankLines = 0;+ }++ int lastNonSpaceIndex = 0;+ boolean justToCursor = false;+ if (cursorAtThisRow || oldLine.mLineWrap) {+ // Take the whole line, either because of cursor on it, or if line wrapping.+ lastNonSpaceIndex = oldLine.getSpaceUsed();+ if (cursorAtThisRow) justToCursor = true;+ } else {+ for (int i = 0; i < oldLine.getSpaceUsed(); i++)+ // NEWLY INTRODUCED BUG! Should not index oldLine.mStyle with char indices+ if (oldLine.mText[i] != ' '/* || oldLine.mStyle[i] != currentStyle */)+ lastNonSpaceIndex = i + 1;+ }++ int currentOldCol = 0;+ long styleAtCol = 0;+ for (int i = 0; i < lastNonSpaceIndex; i++) {+ // Note that looping over java character, not cells.+ char c = oldLine.mText[i];+ int codePoint = (Character.isHighSurrogate(c)) ? Character.toCodePoint(c, oldLine.mText[++i]) : c;+ int displayWidth = WcWidth.width(codePoint);+ // Use the last style if this is a zero-width character:+ if (displayWidth > 0) styleAtCol = oldLine.getStyle(currentOldCol);++ // Line wrap as necessary:+ if (currentOutputExternalColumn + displayWidth > mColumns) {+ setLineWrap(currentOutputExternalRow);+ if (currentOutputExternalRow == mScreenRows - 1) {+ if (newCursorPlaced) newCursorRow--;+ scrollDownOneLine(0, mScreenRows, currentStyle);+ } else {+ currentOutputExternalRow++;+ }+ currentOutputExternalColumn = 0;+ }++ int offsetDueToCombiningChar = ((displayWidth <= 0 && currentOutputExternalColumn > 0) ? 1 : 0);+ int outputColumn = currentOutputExternalColumn - offsetDueToCombiningChar;+ setChar(outputColumn, currentOutputExternalRow, codePoint, styleAtCol);++ if (displayWidth > 0) {+ if (oldCursorRow == externalOldRow && oldCursorColumn == currentOldCol) {+ newCursorColumn = currentOutputExternalColumn;+ newCursorRow = currentOutputExternalRow;+ newCursorPlaced = true;+ }+ currentOldCol += displayWidth;+ currentOutputExternalColumn += displayWidth;+ if (justToCursor && newCursorPlaced) break;+ }+ }+ // Old row has been copied. Check if we need to insert newline if old line was not wrapping:+ if (externalOldRow != (oldScreenRows - 1) && !oldLine.mLineWrap) {+ if (currentOutputExternalRow == mScreenRows - 1) {+ if (newCursorPlaced) newCursorRow--;+ scrollDownOneLine(0, mScreenRows, currentStyle);+ } else {+ currentOutputExternalRow++;+ }+ currentOutputExternalColumn = 0;+ }+ }++ cursor[0] = newCursorColumn;+ cursor[1] = newCursorRow;+ }++ // Handle cursor scrolling off screen:+ if (cursor[0] < 0 || cursor[1] < 0) cursor[0] = cursor[1] = 0;+ }++ /**+ * Block copy lines and associated metadata from one location to another in the circular buffer, taking wraparound+ * into account.+ *+ * @param srcInternal The first line to be copied.+ * @param len The number of lines to be copied.+ */+ private void blockCopyLinesDown(int srcInternal, int len) {+ if (len == 0) return;+ int totalRows = mTotalRows;++ int start = len - 1;+ // Save away line to be overwritten:+ TerminalRow lineToBeOverWritten = mLines[(srcInternal + start + 1) % totalRows];+ // Do the copy from bottom to top.+ for (int i = start; i >= 0; --i)+ mLines[(srcInternal + i + 1) % totalRows] = mLines[(srcInternal + i) % totalRows];+ // Put back overwritten line, now above the block:+ mLines[(srcInternal) % totalRows] = lineToBeOverWritten;+ }++ /**+ * Scroll the screen down one line. To scroll the whole screen of a 24 line screen, the arguments would be (0, 24).+ *+ * @param topMargin First line that is scrolled.+ * @param bottomMargin One line after the last line that is scrolled.+ * @param style the style for the newly exposed line.+ */+ public void scrollDownOneLine(int topMargin, int bottomMargin, long style) {+ if (topMargin > bottomMargin - 1 || topMargin < 0 || bottomMargin > mScreenRows)+ throw new IllegalArgumentException("topMargin=" + topMargin + ", bottomMargin=" + bottomMargin + ", mScreenRows=" + mScreenRows);++ // Copy the fixed topMargin lines one line down so that they remain on screen in same position:+ blockCopyLinesDown(mScreenFirstRow, topMargin);+ // Copy the fixed mScreenRows-bottomMargin lines one line down so that they remain on screen in same+ // position:+ blockCopyLinesDown(externalToInternalRow(bottomMargin), mScreenRows - bottomMargin);++ // Update the screen location in the ring buffer:+ mScreenFirstRow = (mScreenFirstRow + 1) % mTotalRows;+ // Note that the history has grown if not already full:+ if (mActiveTranscriptRows < mTotalRows - mScreenRows) mActiveTranscriptRows++;++ // Blank the newly revealed line above the bottom margin:+ int blankRow = externalToInternalRow(bottomMargin - 1);+ if (mLines[blankRow] == null) {+ mLines[blankRow] = new TerminalRow(mColumns, style);+ } else {+ // Remove bitmaps that are completely scrolled out.+ if(mLines[blankRow].mHasTerminalBitmap) {+ removeScrolledOutTerminalBitmaps(blankRow);+ }+ mLines[blankRow].clear(style);+ }+ }++ /**+ * Block copy characters from one position in the screen to another. The two positions can overlap. All characters+ * of the source and destination must be within the bounds of the screen, or else an InvalidParameterException will+ * be thrown.+ *+ * @param sx source X coordinate+ * @param sy source Y coordinate+ * @param w width+ * @param h height+ * @param dx destination X coordinate+ * @param dy destination Y coordinate+ */+ public void blockCopy(int sx, int sy, int w, int h, int dx, int dy) {+ if (w == 0) return;+ if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows || dx < 0 || dx + w > mColumns || dy < 0 || dy + h > mScreenRows)+ throw new IllegalArgumentException();+ boolean copyingUp = sy > dy;+ for (int y = 0; y < h; y++) {+ int y2 = copyingUp ? y : (h - (y + 1));+ TerminalRow sourceRow = allocateFullLineIfNecessary(externalToInternalRow(sy + y2));+ allocateFullLineIfNecessary(externalToInternalRow(dy + y2)).copyInterval(sourceRow, sx, sx + w, dx);+ }+ }++ /**+ * Block set characters. All characters must be within the bounds of the screen, or else and+ * InvalidParemeterException will be thrown. Typically this is called with a "val" argument of 32 to clear a block+ * of characters.+ */+ public void blockSet(int sx, int sy, int w, int h, int val, long style) {+ if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows) {+ throw new IllegalArgumentException(+ "Illegal arguments! blockSet(" + sx + ", " + sy + ", " + w + ", " + h + ", " + val + ", " + mColumns + ", " + mScreenRows + ")");+ }+ for (int y = 0; y < h; y++) {+ for (int x = 0; x < w; x++)+ setChar(sx + x, sy + y, val, style);+ if (sx + w == mColumns && val == ' ') {+ clearLineWrap(sy + y);+ }+ }+ }++ public TerminalRow allocateFullLineIfNecessary(int row) {+ return (mLines[row] == null) ? (mLines[row] = new TerminalRow(mColumns, 0)) : mLines[row];+ }++ public void setChar(int column, int row, int codePoint, long style) {+ if (row < 0 || row >= mScreenRows || column < 0 || column >= mColumns)+ throw new IllegalArgumentException("TerminalBuffer.setChar(): row=" + row + ", column=" + column + ", mScreenRows=" + mScreenRows + ", mColumns=" + mColumns);+ row = externalToInternalRow(row);+ allocateFullLineIfNecessary(row).setChar(column, codePoint, style);+ }++ public long getStyleAt(int externalRow, int column) {+ return allocateFullLineIfNecessary(externalToInternalRow(externalRow)).getStyle(column);+ }++ /** Support for http://vt100.net/docs/vt510-rm/DECCARA and http://vt100.net/docs/vt510-rm/DECCARA */+ public void setOrClearEffect(int bits, boolean setOrClear, boolean reverse, boolean rectangular, int leftMargin, int rightMargin, int top, int left,+ int bottom, int right) {+ for (int y = top; y < bottom; y++) {+ TerminalRow line = mLines[externalToInternalRow(y)];+ int startOfLine = (rectangular || y == top) ? left : leftMargin;+ int endOfLine = (rectangular || y + 1 == bottom) ? right : rightMargin;+ for (int x = startOfLine; x < endOfLine; x++) {+ long currentStyle = line.getStyle(x);+ int foreColor = TextStyle.decodeForeColor(currentStyle);+ int backColor = TextStyle.decodeBackColor(currentStyle);+ int effect = TextStyle.decodeEffect(currentStyle);+ if (reverse) {+ // Clear out the bits to reverse and add them back in reversed:+ effect = (effect & ~bits) | (bits & ~effect);+ } else if (setOrClear) {+ effect |= bits;+ } else {+ effect &= ~bits;+ }+ line.mStyle[x] = TextStyle.encode(foreColor, backColor, effect);+ }+ }+ }++ public synchronized void clearTranscript() {+ if (mScreenFirstRow < mActiveTranscriptRows) {+ Arrays.fill(mLines, mTotalRows + mScreenFirstRow - mActiveTranscriptRows, mTotalRows, null);+ Arrays.fill(mLines, 0, mScreenFirstRow, null);+ } else {+ Arrays.fill(mLines, mScreenFirstRow - mActiveTranscriptRows, mScreenFirstRow, null);+ }+ mActiveTranscriptRows = 0;+ clearTerminalBitmaps();+ }++++ public synchronized TerminalBitmap getTerminalBitmap(long style) {+ int bitmapNum = TextStyle.getTerminalBitmapNum(style);+ return bitmapNum >= TERMINAL_BITMAP__NUM_START ? mTerminalBitmaps.get(bitmapNum): null;+ }++ public synchronized void clearTerminalBitmaps() {+ mTerminalBitmaps.clear();+ }++ public synchronized Bitmap getSixelBitmap(long style) {+ TerminalBitmap terminalBitmap = getTerminalBitmap(style);+ return terminalBitmap != null ? terminalBitmap.mBitmap : null;+ }+++ public synchronized Rect getSixelRect(long style) {+ TerminalBitmap terminalBitmap = getTerminalBitmap(style);+ if (terminalBitmap == null) {+ return null;+ }++ int x = TextStyle.getTerminalBitmapX(style);+ int y = TextStyle.getTerminalBitmapY(style);+ return new Rect(+ x * terminalBitmap.mCellWidth,+ y * terminalBitmap.mCellHeight,+ (x + 1) * terminalBitmap.mCellWidth,+ (y + 1) * terminalBitmap.mCellHeight);+ }+++ public synchronized void sixelStart(int width, int height) {+ mTerminalSixel = TerminalSixel.build(getClient(), width, height);+ }++ public synchronized int sixelEnd(int x, int y, int cellW, int cellH) {+ if (mTerminalSixel == null) return 0;++ int bitmapNum = getFreeTerminalBitmapNum();+ if (bitmapNum < TERMINAL_BITMAP__NUM_START) {+ Logger.logError(mClient, LOG_TAG, "Cannot create more than " + TERMINAL_BITMAP__NUM_END + " bitmaps");+ return 0;+ }++ TerminalBitmap terminalBitmap = TerminalBitmap.build(this, bitmapNum, mTerminalSixel, x, y, cellW, cellH);+ mTerminalSixel = null;+ if (terminalBitmap == null || terminalBitmap.getBitmap() == null) {+ return 0;+ }+ mTerminalBitmaps.put(bitmapNum, terminalBitmap);++ doTerminalBitmapsGC(30000);+ return terminalBitmap.mScrollLines;+ }++ /** Clears the {@link #mTerminalSixel} by setting it to `null`. */+ public synchronized void sixelClear() {+ mTerminalSixel = null;+ }++ /**+ * Clears the {@link #mTerminalSixel} by setting it to `null` and logs error.+ * Call this on error if further sixel commands/data should be parsed to prevent them from+ * printing on terminal, but sixel rendering should be ignored.+ */+ public synchronized void sixelIgnore() {+ Logger.logError(mClient, LOG_TAG, "Ignoring sixel rendering");+ mTerminalSixel = null;+ }++ public synchronized boolean sixelReadData(int codePoint, int repeat) {+ // If an error occurred during processing (like OOM), then remaining sixel command is+ // completely read, but is ignored.+ if (mTerminalSixel != null) {+ if (!mTerminalSixel.readData(codePoint, repeat)) {+ sixelIgnore();+ return false;+ }+ }+ return true;+ }++ public synchronized boolean sixelResize(int sixelWidth, int sixelHeight) {+ // If an error occurred during processing (like OOM), then remaining sixel command is+ // completely read, but is ignored.+ if (mTerminalSixel != null) {+ if (!mTerminalSixel.resize(sixelWidth, sixelHeight)) {+ sixelIgnore();+ return false;+ }+ }+ return true;+ }++ public synchronized void sixelSetColor(int color) {+ if (mTerminalSixel != null)+ mTerminalSixel.setColor(color);+ }++ public synchronized void sixelSetRGBColor(int color, int r, int g, int b) {+ if (mTerminalSixel != null)+ mTerminalSixel.setRGBColor(color, r, g, b);+ }++++ private synchronized int getFreeTerminalBitmapNum() {+ int bitmapNum = TERMINAL_BITMAP__NUM_START;+ while (mTerminalBitmaps.containsKey(bitmapNum)) {+ bitmapNum++;+ if (bitmapNum == TERMINAL_BITMAP__NUM_END) {+ return -1;+ }+ }+ return bitmapNum;+ }+++ public synchronized int[] addTerminalBitmapForImage(byte[] image, int x, int y, int cellW, int cellH, int width, int height, boolean shouldPreserveAspectRatio) {+ int bitmapNum = getFreeTerminalBitmapNum();+ if (bitmapNum < TERMINAL_BITMAP__NUM_START) {+ Logger.logError(mClient, LOG_TAG, "Cannot create more than " + TERMINAL_BITMAP__NUM_END + " bitmaps");+ return new int[] {0, 0};+ }++ TerminalBitmap terminalBitmap = TerminalBitmap.build(this, bitmapNum, image, x, y,+ cellW, cellH, width, height, shouldPreserveAspectRatio);+ if (terminalBitmap == null || terminalBitmap.getBitmap() == null) {+ return new int[] {0, 0};+ }+ mTerminalBitmaps.put(bitmapNum, terminalBitmap);++ doTerminalBitmapsGC(30000);+ return terminalBitmap.mCursorDelta;+ }+++ /** Remove bitmaps that are completely scrolled out. */+ public synchronized void removeScrolledOutTerminalBitmaps(int row) {+ Set<Integer> bitmapsToRemove = new HashSet<>();++ for (int column = 0; column < mColumns; column++) {+ long columnStyle = mLines[row].getStyle(column);+ int bitmapNum = TextStyle.getTerminalBitmapNum(columnStyle);+ if (bitmapNum >= TERMINAL_BITMAP__NUM_START) {+ bitmapsToRemove.add(bitmapNum);+ }+ }++ if (row + 1 < mTotalRows) {+ TerminalRow nextLine = mLines[row + 1];+ if (nextLine.mHasTerminalBitmap) {+ for (int column = 0; column < mColumns; column++) {+ long columnStyle = nextLine.getStyle(column);+ int bitmapNum = TextStyle.getTerminalBitmapNum(columnStyle);+ if (bitmapNum >= TERMINAL_BITMAP__NUM_START) {+ bitmapsToRemove.add(bitmapNum);+ }+ }+ }+ }++ for(Integer bitmapStyle : bitmapsToRemove) {+ mTerminalBitmaps.remove(bitmapStyle);+ }+ }++ public synchronized void doTerminalBitmapsGC(int timeDelta) {+ if (mTerminalBitmaps.isEmpty() || mTerminalBitmapsLastGC + timeDelta > SystemClock.uptimeMillis()) {+ return;+ }++ Set<Integer> bitmapsToKeep = new HashSet<>();++ for (int line = 0; line < mLines.length; line++) {+ if(mLines[line] != null && mLines[line].mHasTerminalBitmap) {+ for (int column = 0; column < mColumns; column++) {+ long style = mLines[line].getStyle(column);+ int bitmapNum = TextStyle.getTerminalBitmapNum(style);+ if (bitmapNum >= TERMINAL_BITMAP__NUM_START) {+ bitmapsToKeep.add(bitmapNum);+ }+ }+ }+ }++ Set<Integer> bitmapNums = new HashSet<>(mTerminalBitmaps.keySet());+ for (Integer bitmapNum: bitmapNums) {+ if (!bitmapsToKeep.contains(bitmapNum)) {+ mTerminalBitmaps.remove(bitmapNum);+ }+ }++ mTerminalBitmapsLastGC = SystemClock.uptimeMillis();+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalColorScheme.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalColorScheme.javanew file mode 100644index 0000000..4088781--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalColorScheme.java@@ -0,0 +1,126 @@+package com.termux.terminal;++import java.util.Map;+import java.util.Properties;++/**+ * Color scheme for a terminal with default colors, which may be overridden (and then reset) from the shell using+ * Operating System Control (OSC) sequences.+ *+ * @see TerminalColors+ */+public final class TerminalColorScheme {++ /** http://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg, but with blue color brighter. */+ private static final int[] DEFAULT_COLORSCHEME = {+ // 16 original colors. First 8 are dim.+ 0xff000000, // black+ 0xffcd0000, // dim red+ 0xff00cd00, // dim green+ 0xffcdcd00, // dim yellow+ 0xff6495ed, // dim blue+ 0xffcd00cd, // dim magenta+ 0xff00cdcd, // dim cyan+ 0xffe5e5e5, // dim white+ // Second 8 are bright:+ 0xff7f7f7f, // medium grey+ 0xffff0000, // bright red+ 0xff00ff00, // bright green+ 0xffffff00, // bright yellow+ 0xff5c5cff, // light blue+ 0xffff00ff, // bright magenta+ 0xff00ffff, // bright cyan+ 0xffffffff, // bright white++ // 216 color cube, six shades of each color:+ 0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff,+ 0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,+ 0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7, 0xff00ffff,+ 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff,+ 0xff5f8700, 0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff,+ 0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff,+ 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff,+ 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff,+ 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7, 0xff87ffff,+ 0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff,+ 0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff,+ 0xffafd700, 0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff,+ 0xffd70000, 0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff,+ 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff,+ 0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff,+ 0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf, 0xffff5fd7, 0xffff5fff,+ 0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff,+ 0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,++ // 24 grey scale ramp:+ 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676,+ 0xff808080, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee,++ // COLOR_INDEX_DEFAULT_FOREGROUND, COLOR_INDEX_DEFAULT_BACKGROUND and COLOR_INDEX_DEFAULT_CURSOR:+ 0xffffffff, 0xff000000, 0xffffffff};++ public final int[] mDefaultColors = new int[TextStyle.NUM_INDEXED_COLORS];++ public TerminalColorScheme() {+ reset();+ }++ private void reset() {+ System.arraycopy(DEFAULT_COLORSCHEME, 0, mDefaultColors, 0, TextStyle.NUM_INDEXED_COLORS);+ }++ public void updateWith(Properties props) {+ reset();+ boolean cursorPropExists = false;+ for (Map.Entry<Object, Object> entries : props.entrySet()) {+ String key = (String) entries.getKey();+ String value = (String) entries.getValue();+ int colorIndex;++ if (key.equals("foreground")) {+ colorIndex = TextStyle.COLOR_INDEX_FOREGROUND;+ } else if (key.equals("background")) {+ colorIndex = TextStyle.COLOR_INDEX_BACKGROUND;+ } else if (key.equals("cursor")) {+ colorIndex = TextStyle.COLOR_INDEX_CURSOR;+ cursorPropExists = true;+ } else if (key.startsWith("color")) {+ try {+ colorIndex = Integer.parseInt(key.substring(5));+ } catch (NumberFormatException e) {+ throw new IllegalArgumentException("Invalid property: '" + key + "'");+ }+ } else {+ throw new IllegalArgumentException("Invalid property: '" + key + "'");+ }++ int colorValue = TerminalColors.parse(value);+ if (colorValue == 0)+ throw new IllegalArgumentException("Property '" + key + "' has invalid color: '" + value + "'");++ mDefaultColors[colorIndex] = colorValue;+ }++ if (!cursorPropExists)+ setCursorColorForBackground();+ }++ /**+ * If the "cursor" color is not set by user, we need to decide on the appropriate color that will+ * be visible on the current terminal background. White will not be visible on light backgrounds+ * and black won't be visible on dark backgrounds. So we find the perceived brightness of the+ * background color and if its below the threshold (too dark), we use white cursor and if its+ * above (too bright), we use black cursor.+ */+ public void setCursorColorForBackground() {+ int backgroundColor = mDefaultColors[TextStyle.COLOR_INDEX_BACKGROUND];+ int brightness = TerminalColors.getPerceivedBrightnessOfColor(backgroundColor);+ if (brightness > 0) {+ if (brightness < 130)+ mDefaultColors[TextStyle.COLOR_INDEX_CURSOR] = 0xffffffff;+ else+ mDefaultColors[TextStyle.COLOR_INDEX_CURSOR] = 0xff000000;+ }+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalColors.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalColors.javanew file mode 100644index 0000000..25135a2--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalColors.java@@ -0,0 +1,96 @@+package com.termux.terminal;++import android.graphics.Color;++/** Current terminal colors (if different from default). */+public final class TerminalColors {++ /** Static data - a bit ugly but ok for now. */+ public static final TerminalColorScheme COLOR_SCHEME = new TerminalColorScheme();++ /**+ * The current terminal colors, which are normally set from the color theme, but may be set dynamically with the OSC+ * 4 control sequence.+ */+ public final int[] mCurrentColors = new int[TextStyle.NUM_INDEXED_COLORS];++ /** Create a new instance with default colors from the theme. */+ public TerminalColors() {+ reset();+ }++ /** Reset a particular indexed color with the default color from the color theme. */+ public void reset(int index) {+ mCurrentColors[index] = COLOR_SCHEME.mDefaultColors[index];+ }++ /** Reset all indexed colors with the default color from the color theme. */+ public void reset() {+ System.arraycopy(COLOR_SCHEME.mDefaultColors, 0, mCurrentColors, 0, TextStyle.NUM_INDEXED_COLORS);+ }++ /**+ * Parse color according to http://manpages.ubuntu.com/manpages/intrepid/man3/XQueryColor.3.html+ * <p/>+ * Highest bit is set if successful, so return value is 0xFF${R}${G}${B}. Return 0 if failed.+ */+ static int parse(String c) {+ try {+ int skipInitial, skipBetween;+ if (c.charAt(0) == '#') {+ // #RGB, #RRGGBB, #RRRGGGBBB or #RRRRGGGGBBBB. Most significant bits.+ skipInitial = 1;+ skipBetween = 0;+ } else if (c.startsWith("rgb:")) {+ // rgb:<red>/<green>/<blue> where <red>, <green>, <blue> := h | hh | hhh | hhhh. Scaled.+ skipInitial = 4;+ skipBetween = 1;+ } else {+ return 0;+ }+ int charsForColors = c.length() - skipInitial - 2 * skipBetween;+ if (charsForColors % 3 != 0) return 0; // Unequal lengths.+ int componentLength = charsForColors / 3;+ double mult = 255 / (Math.pow(2, componentLength * 4) - 1);++ int currentPosition = skipInitial;+ String rString = c.substring(currentPosition, currentPosition + componentLength);+ currentPosition += componentLength + skipBetween;+ String gString = c.substring(currentPosition, currentPosition + componentLength);+ currentPosition += componentLength + skipBetween;+ String bString = c.substring(currentPosition, currentPosition + componentLength);++ int r = (int) (Integer.parseInt(rString, 16) * mult);+ int g = (int) (Integer.parseInt(gString, 16) * mult);+ int b = (int) (Integer.parseInt(bString, 16) * mult);+ return 0xFF << 24 | r << 16 | g << 8 | b;+ } catch (NumberFormatException | IndexOutOfBoundsException e) {+ return 0;+ }+ }++ /** Try parse a color from a text parameter and into a specified index. */+ public void tryParseColor(int intoIndex, String textParameter) {+ int c = parse(textParameter);+ if (c != 0) mCurrentColors[intoIndex] = c;+ }++ /**+ * Get the perceived brightness of the color based on its RGB components.+ *+ * https://www.nbdtech.com/Blog/archive/2008/04/27/Calculating-the-Perceived-Brightness-of-a-Color.aspx+ * http://alienryderflex.com/hsp.html+ *+ * @param color The color code int.+ * @return Returns value between 0-255.+ */+ public static int getPerceivedBrightnessOfColor(int color) {+ return (int)+ Math.floor(Math.sqrt(+ Math.pow(Color.red(color), 2) * 0.241 ++ Math.pow(Color.green(color), 2) * 0.691 ++ Math.pow(Color.blue(color), 2) * 0.068+ ));+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalEmulator.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalEmulator.javanew file mode 100644index 0000000..5ff1899--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalEmulator.java@@ -0,0 +1,3704 @@+package com.termux.terminal;++import android.util.Base64;++import java.nio.charset.StandardCharsets;+import java.util.Arrays;+import java.util.Locale;+import java.util.Objects;+import java.util.Stack;++/**+ * Renders text into a screen. Contains all the terminal-specific knowledge and state. Emulates a subset of the X Window+ * System xterm terminal, which in turn is an emulator for a subset of the Digital Equipment Corporation vt100 terminal.+ * <p>+ * See also 7-bit Code Table defined at https://vt100.net/docs/vt220-rm/chapter2.html#S2.3.1+ * <p>+ * References:+ * <ul>+ * <li>http://invisible-island.net/xterm/ctlseqs/ctlseqs.html</li>+ * <li>http://en.wikipedia.org/wiki/ANSI_escape_code</li>+ * <li>http://man.he.net/man4/console_codes</li>+ * <li>http://bazaar.launchpad.net/~leonerd/libvterm/trunk/view/head:/src/state.c</li>+ * <li>http://www.columbia.edu/~kermit/k95manual/iso2022.html</li>+ * <li>http://www.vt100.net/docs/vt510-rm/chapter4</li>+ * <li>http://en.wikipedia.org/wiki/ISO/IEC_2022 - for 7-bit and 8-bit GL GR explanation</li>+ * <li>http://bjh21.me.uk/all-escapes/all-escapes.txt - extensive!</li>+ * <li>http://woldlab.caltech.edu/~diane/kde4.10/workingdir/kubuntu/konsole/doc/developer/old-documents/VT100/techref.+ * html - document for konsole - accessible!</li>+ * </ul>+ */+public final class TerminalEmulator {++ /** Log unknown or unimplemented escape sequences received from the shell process. */+ private static final boolean LOG_ESCAPE_SEQUENCES = false;++ public static final int MOUSE_LEFT_BUTTON = 0;++ /** Mouse moving while having left mouse button pressed. */+ public static final int MOUSE_LEFT_BUTTON_MOVED = 32;+ public static final int MOUSE_WHEELUP_BUTTON = 64;+ public static final int MOUSE_WHEELDOWN_BUTTON = 65;++ /** Used for invalid data - http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */+ public static final int UNICODE_REPLACEMENT_CHAR = 0xFFFD;++ /*+ * Escape sequences starting with an ESC character.+ *+ * - https://vt100.net/docs/vt220-rm/chapter2.html#S2.5.1+ * - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Controls-beginning-with-ESC+ * - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-C1-lparen-8-Bit-rparen-Control-Characters+ * - https://en.wikipedia.org/wiki/C0_and_C1_control_codes+ */++ /** Escape processing: Not currently in an escape sequence. */+ private static final int ESC_NONE = 0;+ /** Escape processing: Have seen an ESC character - proceed to {@link #doEsc(int)} */+ private static final int ESC = 1;+ /** Escape processing: Have seen ESC POUND */+ private static final int ESC_POUND = 2;+ /** Escape processing: Have seen ESC and a character-set-select ( char */+ private static final int ESC_SELECT_LEFT_PAREN = 3;+ /** Escape processing: Have seen ESC and a character-set-select ) char */+ private static final int ESC_SELECT_RIGHT_PAREN = 4;+ /** Escape processing: "ESC [" or CSI (Control Sequence Introducer). */+ private static final int ESC_CSI = 6;+ /** Escape processing: ESC [ ? */+ private static final int ESC_CSI_QUESTIONMARK = 7;+ /** Escape processing: ESC [ $ */+ private static final int ESC_CSI_DOLLAR = 8;+ /** Escape processing: ESC % */+ private static final int ESC_PERCENT = 9;+ /**+ * Escape processing: `ESC ]` for Operating System Command (OSC)+ * <p>+ * `OSC` commands may be in one of the following formats:+ * - `OSC Ps ; Pt BEL` where `BEL` is the bell control passed as `\a`.+ * - `OSC Ps ; Pt ST` where `ST` is the string terminator passed as `ESC \`.+ * `ST` is the preferred standard for modern terminals.+ * <p>+ * If an `OSC` escape sequence is received, then {@link #mEscapeState} is set to {@link #ESC_OSC}+ * and {@link #receiveOsc(int)} is called by {@link #processCodePoint(int)}.+ * - By default it will add bytes received after `OSC` escape sequence to {@link #mTerminalControlArgs}.+ * - If a `BEL` is received, then {@link #doOsc(String)} is called to process+ * the OSC command.+ * - If an `ESC` is received, then {@link #mEscapeState} is set to {@link #ESC_OSC__ESC} and+ * {@link #receiveOscEsc(int)} is called for the next code point.+ * - If the next code point is a `\` for `ST`, then {@link #doOsc(String)} is+ * called to process the OSC command.+ * - If the next code point is not a `\`, then {@link #mEscapeState} is set back to+ * {@link #ESC_OSC} as `ESC` may be part of command data as so it is added to+ * {@link #mTerminalControlArgs}, and for later code points {@link #receiveOsc(int)} is called+ * instead.+ * <p>+ * While an `OSC` is being received, {@link #mOscType} may be set to the command type when it+ * has been fully received by {@link #setOscTypeVariables()}.+ * <p>+ * See also {@link #mIsFastPathOsc} for enabling fast path for specific `OSC` commands if required+ * via {@link #setOscTypeVariables()}.+ * <p>+ * See also {@link #mIgnoreCrLfForOsc} to prevent printing of CR/LF characters for specific+ * `OSC` commands if required via {@link #setOscTypeVariables()}.+ * <p>+ * - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands+ */+ private static final int ESC_OSC = 10;+ /** Escape processing: `ESC` received while receiving a {@link #ESC_OSC} command. */+ private static final int ESC_OSC__ESC = 11;+ /** Escape processing: ESC [ > */+ private static final int ESC_CSI_BIGGERTHAN = 12;+ /**+ * Escape procession: `ESC P` for Device Control String (DCS)+ * <p>+ * `DCS` commands are in the format `DCS data ST` where `ST` is the string terminator passed as `ESC \`.+ * `data` is application defined raw data without any specific standards.+ * <p>+ * If an `DCS` escape sequence is received, then {@link #mEscapeState} is set to {@link #ESC_DCS}+ * and {@link #doDcs(int)} is called by {@link #processCodePoint(int)}.+ * - By default it will add bytes received after `DCS` escape sequence to {@link #mTerminalControlArgs}.+ * - If an `ESC` is received by {@link #processCodePoint(int)}, then {@link #ESC_DCS__ESC} set+ * to `true`.+ * - If the next code point is a `\` for `ST`, then {@link #doDcs(int)} processes the DCS command.+ * - If the next code point is not a `\`, then {@link #ESC_DCS__ESC} is set back to `false` as+ * `ESC` may be part of command data as so it is added to {@link #mTerminalControlArgs}.+ * - For certain commands like sixel commands, {@link #doDcs(int)} alters the default behaviour.+ * <p>+ * See also {@link #mIsFastPathDcs} for enabling fast path for specific `DCS` commands if required.+ * <p>+ * <p>+ * - https://vt100.net/docs/vt220-rm/chapter2.html#S2.5.3+ */+ private static final int ESC_DCS = 13;+ /** Escape processing: CSI > */+ private static final int ESC_CSI_QUESTIONMARK_ARG_DOLLAR = 14;+ /** Escape processing: CSI $ARGS ' ' */+ private static final int ESC_CSI_ARGS_SPACE = 15;+ /** Escape processing: CSI $ARGS '*' */+ private static final int ESC_CSI_ARGS_ASTERIX = 16;+ /** Escape processing: CSI " */+ private static final int ESC_CSI_DOUBLE_QUOTE = 17;+ /** Escape processing: CSI ' */+ private static final int ESC_CSI_SINGLE_QUOTE = 18;+ /** Escape processing: CSI ! */+ private static final int ESC_CSI_EXCLAMATION = 19;+ /**+ * Escape processing: `ESC _` for Application Program Command (APC).+ * <p>+ * `APC` commands are in the format `APC data ST` where `ST` is the string terminator passed as `ESC \`.+ * `data` is application defined raw data without any specific standards.+ * <p>+ * If an `APC` escape sequence is received, then {@link #mEscapeState} is set to {@link #ESC_APC}+ * and {@link #receiveApc(int)} is called by {@link #processCodePoint(int)}.+ * - By default it will add bytes received after `APC` escape sequence to {@link #mTerminalControlArgs}.+ * - If an `ESC` is received, then {@link #mEscapeState} is set to {@link #ESC_APC__ESC} and+ * {@link #receiveApcEsc(int)} is called for the next code point.+ * - If the next code point is a `\` for `ST`, then {@link #doApc()} is called to+ * process the APC command.+ * - If the next code point is not a `\`, then {@link #mEscapeState} is set back to+ * {@link #ESC_APC} as `ESC` may be part of command data as so it is added to+ * {@link #mTerminalControlArgs}, and for later code points {@link #receiveApc(int)} is called+ * instead.+ * <p>+ * Currently, APC commands are only parsed, but ignored as none are supported.+ * <p>+ * - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Application-Program-Command-functions+ */+ private static final int ESC_APC = 20;+ /** Escape processing: `ESC` received while receiving a {@link #ESC_APC} command. */+ private static final int ESC_APC__ESC = 21;+ /** Escape processing: ESC [ <parameter bytes> */+ private static final int ESC_CSI_UNSUPPORTED_PARAMETER_BYTE = 22;+ /** Escape processing: ESC [ <parameter bytes> <intermediate bytes> */+ private static final int ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE = 23;++ /** The number of parameter arguments including colon separated sub-parameters. */+ private static final int MAX_ESCAPE_PARAMETERS = 32;++ /** DECSET 1 - application cursor keys. */+ private static final int DECSET_BIT_APPLICATION_CURSOR_KEYS = 1;+ private static final int DECSET_BIT_REVERSE_VIDEO = 1 << 1;+ /**+ * http://www.vt100.net/docs/vt510-rm/DECOM: "When DECOM is set, the home cursor position is at the upper-left+ * corner of the screen, within the margins. The starting point for line numbers depends on the current top margin+ * setting. The cursor cannot move outside of the margins. When DECOM is reset, the home cursor position is at the+ * upper-left corner of the screen. The starting point for line numbers is independent of the margins. The cursor+ * can move outside of the margins."+ */+ private static final int DECSET_BIT_ORIGIN_MODE = 1 << 2;+ /**+ * http://www.vt100.net/docs/vt510-rm/DECAWM: "If the DECAWM function is set, then graphic characters received when+ * the cursor is at the right border of the page appear at the beginning of the next line. Any text on the page+ * scrolls up if the cursor is at the end of the scrolling region. If the DECAWM function is reset, then graphic+ * characters received when the cursor is at the right border of the page replace characters already on the page."+ */+ private static final int DECSET_BIT_AUTOWRAP = 1 << 3;+ /** DECSET 25 - if the cursor should be enabled, {@link #isCursorEnabled()}. */+ private static final int DECSET_BIT_CURSOR_ENABLED = 1 << 4;+ private static final int DECSET_BIT_APPLICATION_KEYPAD = 1 << 5;+ /** DECSET 1000 - if to report mouse press&release events. */+ private static final int DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE = 1 << 6;+ /** DECSET 1002 - like 1000, but report moving mouse while pressed. */+ private static final int DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT = 1 << 7;+ /** DECSET 1004 - NOT implemented. */+ private static final int DECSET_BIT_SEND_FOCUS_EVENTS = 1 << 8;+ /** DECSET 1006 - SGR-like mouse protocol (the modern sane choice). */+ private static final int DECSET_BIT_MOUSE_PROTOCOL_SGR = 1 << 9;+ /** DECSET 2004 - see {@link #paste(String)} */+ private static final int DECSET_BIT_BRACKETED_PASTE_MODE = 1 << 10;+ /** Toggled with DECLRMM - http://www.vt100.net/docs/vt510-rm/DECLRMM */+ private static final int DECSET_BIT_LEFTRIGHT_MARGIN_MODE = 1 << 11;+ /** Not really DECSET bit... - http://www.vt100.net/docs/vt510-rm/DECSACE */+ private static final int DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE = 1 << 12;+ /**+ * DECSET 2026 — Synchronized Output (a.k.a. "atomic frame" / "sync update mode").+ * https://gitlab.com/gnachman/iterm2/-/wikis/synchronized-updates-spec+ *+ * When the application brackets a frame in `\e[?2026h ... \e[?2026l`, the+ * terminal must defer rendering until the close bracket arrives, so the+ * user never sees a partially-updated screen. Used by btop, nvim, fzf,+ * lazygit — eliminates flicker on TUIs that redraw frequently.+ */+ private static final int DECSET_BIT_SYNCHRONIZED_OUTPUT = 1 << 13;+++ private String mTitle;+ private final Stack<String> mTitleStack = new Stack<>();++ /** The cursor position. Between (0,0) and (mRows-1, mColumns-1). */+ private int mCursorRow, mCursorCol;++ /** The number of character rows and columns in the terminal screen. */+ public int mRows, mColumns;++ /** Size of a terminal cell in pixels. */+ private int mCellWidthPixels, mCellHeightPixels;++ /** The number of terminal transcript rows that can be scrolled back to. */+ public static final int TERMINAL_TRANSCRIPT_ROWS_MIN = 100;+ public static final int TERMINAL_TRANSCRIPT_ROWS_MAX = 50000;+ public static final int DEFAULT_TERMINAL_TRANSCRIPT_ROWS = 2000;+++ /* The supported terminal cursor styles. */++ public static final int TERMINAL_CURSOR_STYLE_BLOCK = 0;+ public static final int TERMINAL_CURSOR_STYLE_UNDERLINE = 1;+ public static final int TERMINAL_CURSOR_STYLE_BAR = 2;+ public static final int DEFAULT_TERMINAL_CURSOR_STYLE = TERMINAL_CURSOR_STYLE_BLOCK;+ public static final Integer[] TERMINAL_CURSOR_STYLES_LIST = new Integer[]{TERMINAL_CURSOR_STYLE_BLOCK, TERMINAL_CURSOR_STYLE_UNDERLINE, TERMINAL_CURSOR_STYLE_BAR};++ /** The terminal cursor styles. */+ private int mCursorStyle = DEFAULT_TERMINAL_CURSOR_STYLE;+++ /** The normal screen buffer. Stores the characters that appear on the screen of the emulated terminal. */+ private final TerminalBuffer mMainBuffer;+ /**+ * The alternate screen buffer, exactly as large as the display and contains no additional saved lines (so that when+ * the alternate screen buffer is active, you cannot scroll back to view saved lines).+ * <p>+ * See http://www.xfree86.org/current/ctlseqs.html#The%20Alternate%20Screen%20Buffer+ */+ final TerminalBuffer mAltBuffer;+ /** The current screen buffer, pointing at either {@link #mMainBuffer} or {@link #mAltBuffer}. */+ private TerminalBuffer mScreen;++ /** The terminal session this emulator is bound to. */+ private final TerminalOutput mSession;++ TerminalSessionClient mClient;++ /** Keeps track of the current argument of the current escape sequence. Ranges from 0 to MAX_ESCAPE_PARAMETERS-1. */+ private int mArgIndex;+ /** Holds the arguments of the current escape sequence. */+ private final int[] mArgs = new int[MAX_ESCAPE_PARAMETERS];+ /** Holds the bit flags which arguments are sub parameters (after a colon) - bit N is set if <code>mArgs[N]</code> is a sub parameter. */+ private int mArgsSubParamsBitSet = 0;++++ /**+ * The initial capacity for {@link #mTerminalControlArgs}.+ */+ private static final int TERMINAL_CONTROL_ARGS__INITIAL_CAPACITY = 16;++ /**+ * The default max length for {@link #mTerminalControlArgs}.+ * Needs to be large enough to contain reasonable OSC 52 pastes, sixel and iterm images data.+ */+ private static final int TERMINAL_CONTROL_ARGS__DEFAULT_MAX_LENGTH = 16384;++ /**+ * The max length for {@link #mTerminalControlArgs} used by {@link #collectTerminalControlArgs(int)}.+ */+ private int mTerminalControlArgsMaxLength = TERMINAL_CONTROL_ARGS__DEFAULT_MAX_LENGTH;++ /** The terminal control arguments string buffer, like for OSC, DCS, APC commands. */+ private StringBuilder mTerminalControlArgs = new StringBuilder(TERMINAL_CONTROL_ARGS__INITIAL_CAPACITY);++++ /**+ * The integer Operating System Command `type` received as `ESC ] type ;`.+ * This will be set as soon as `type` followed by `;` is received, and before any further+ * optional parameters are received.+ */+ private int mOscType = -1;++ /**+ * If `true`, then `processCodePoint()` will directly call `receiveOsc()` as a fast path+ * without additional checks.+ *+ * Can be enabled for OSC commands via {@link #setOscTypeVariables()}.+ */+ private boolean mIsFastPathOsc = false;++ /**+ * If `true`, then `processCodePoint()` will not print any CR/LF characters received.+ * This is ignored if `mIsFastPathOsc` is already `true` for a command.+ *+ * Can be enabled for OSC commands via {@link #setOscTypeVariables()}.+ */+ private boolean mIgnoreCrLfForOsc = false;+++ /**+ * If `true`, then `processCodePoint()` will directly call `doDcs()` as a fast path+ * without additional checks.+ *+ * Can be enabled for DCS commands via {@link #doDcs(int)}.+ */+ private boolean mIsFastPathDcs = false;++ /** Whether processing an `ESC` for a DCS command. */+ private boolean ESC_DCS__ESC = false;+++ /** Whether processing a sixel `DCS q s..s ST` or `DCS P1; P2; P3; q s..s ST` command to create a {@link TerminalSixel}. */+ private boolean ESC_DCS__SIXEL = false;++ /** Whether to check if sixel command is being received when processing a DCS command. */+ private boolean ESC_DCS__CHECK_IF_SIXEL = true;++ /** The command part number in case a long sixel command was broken into parts for processing. */+ private int mSixelCommandPartNum;++ /**+ * The capacity to set for {@link #mTerminalControlArgs} used to store sixel commands before processing.+ *+ * See also {@link #ensureTerminalControlArgsCapacity(int)}.+ */+ private Integer mSixelArgsCapacity;++ /**+ * The initial capacity for sixel args stored in {@link #mTerminalControlArgs}.+ */+ private static final int SIXEL_ARGS__INITIAL_CAPACITY = 256;++++ /** The {@link ITermImage} if an iTerm image command is being processed. */+ private ITermImage mITermImage;++ /**+ * Kitty graphics protocol — multi-chunk base64 PNG accumulator.+ * https://sw.kovidgoyal.net/kitty/graphics-protocol/+ *+ * Minimum viable: `\e_Ga=T,f=100,t=d,m=0/1; <base64 PNG chunk> \e\`+ * Used by: kitty +kitten icat, lazygit thumbnails, lf preview, fzf preview,+ * yazi, ranger, hyperfine plot output.+ *+ * The first chunk carries all parameters; continuation chunks (m=1/m=0)+ * carry only `m=`, so action/format/transport must persist.+ */+ private StringBuilder mKittyB64Accumulator;+ private char mKittyAction;+ private int mKittyFormat;+ private char mKittyTransport;+ /** Display columns (`c=`) and rows (`r=`); 0 = natural size scaled to a sensible cap. */+ private int mKittyCols;+ private int mKittyRows;++++ /**+ * True if the current escape sequence should continue, false if the current escape sequence should be terminated.+ * Used when parsing a single character.+ */+ private boolean mContinueSequence;++ /** The current state of the escape sequence state machine. One of the ESC_* constants. */+ private int mEscapeState;++ private final SavedScreenState mSavedStateMain = new SavedScreenState();+ private final SavedScreenState mSavedStateAlt = new SavedScreenState();++ /** http://www.vt100.net/docs/vt102-ug/table5-15.html */+ private boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;++ /**+ * @see TerminalEmulator#mapDecSetBitToInternalBit(int)+ */+ private int mCurrentDecSetFlags, mSavedDecSetFlags;++ /**+ * If insert mode (as opposed to replace mode) is active. In insert mode new characters are inserted, pushing+ * existing text to the right. Characters moved past the right margin are lost.+ */+ private boolean mInsertMode;++ /** An array of tab stops. mTabStop[i] is true if there is a tab stop set for column i. */+ private boolean[] mTabStop;++ /**+ * Top margin of screen for scrolling ranges from 0 to mRows-2. Bottom margin ranges from mTopMargin + 2 to mRows+ * (Defines the first row after the scrolling region). Left/right margin in [0, mColumns].+ */+ private int mTopMargin, mBottomMargin, mLeftMargin, mRightMargin;++ /**+ * If the next character to be emitted will be automatically wrapped to the next line. Used to disambiguate the case+ * where the cursor is positioned on the last column (mColumns-1). When standing there, a written character will be+ * output in the last column, the cursor not moving but this flag will be set. When outputting another character+ * this will move to the next line.+ */+ private boolean mAboutToAutoWrap;++ /**+ * If the cursor blinking is enabled. It requires cursor itself to be enabled, which is controlled+ * byt whether {@link #DECSET_BIT_CURSOR_ENABLED} bit is set or not.+ */+ private boolean mCursorBlinkingEnabled;++ /**+ * If currently cursor should be in a visible state or not if {@link #mCursorBlinkingEnabled}+ * is {@code true}.+ */+ private boolean mCursorBlinkState;++ /**+ * Current foreground, background and underline colors. Can either be a color index in [0,259] or a truecolor (24-bit) value.+ * For a 24-bit value the top byte (0xff000000) is set.+ *+ * <p>Note that the underline color is currently parsed but not yet used during rendering.+ *+ * @see TextStyle+ */+ int mForeColor, mBackColor, mUnderlineColor;++ /** Current {@link TextStyle} effect. */+ int mEffect;++ /**+ * The number of scrolled lines since last calling {@link #clearScrollCounter()}. Used for moving selection up along+ * with the scrolling text.+ */+ private int mScrollCounter = 0;++ /** If automatic scrolling of terminal is disabled */+ private boolean mAutoScrollDisabled;++ private byte mUtf8ToFollow, mUtf8Index;+ private final byte[] mUtf8InputBuffer = new byte[4];+ private int mLastEmittedCodePoint = -1;++ public final TerminalColors mColors = new TerminalColors();++ private static final String LOG_TAG = "TerminalEmulator";++ private boolean isDecsetInternalBitSet(int bit) {+ return (mCurrentDecSetFlags & bit) != 0;+ }++ private void setDecsetinternalBit(int internalBit, boolean set) {+ if (set) {+ // The mouse modes are mutually exclusive.+ if (internalBit == DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) {+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT, false);+ } else if (internalBit == DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT) {+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE, false);+ }+ }+ if (set) {+ mCurrentDecSetFlags |= internalBit;+ } else {+ mCurrentDecSetFlags &= ~internalBit;+ }+ }++ static int mapDecSetBitToInternalBit(int decsetBit) {+ switch (decsetBit) {+ case 1:+ return DECSET_BIT_APPLICATION_CURSOR_KEYS;+ case 5:+ return DECSET_BIT_REVERSE_VIDEO;+ case 6:+ return DECSET_BIT_ORIGIN_MODE;+ case 7:+ return DECSET_BIT_AUTOWRAP;+ case 25:+ return DECSET_BIT_CURSOR_ENABLED;+ case 66:+ return DECSET_BIT_APPLICATION_KEYPAD;+ case 69:+ return DECSET_BIT_LEFTRIGHT_MARGIN_MODE;+ case 1000:+ return DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE;+ case 1002:+ return DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT;+ case 1004:+ return DECSET_BIT_SEND_FOCUS_EVENTS;+ case 1006:+ return DECSET_BIT_MOUSE_PROTOCOL_SGR;+ case 2004:+ return DECSET_BIT_BRACKETED_PASTE_MODE;+ case 2026:+ return DECSET_BIT_SYNCHRONIZED_OUTPUT;+ default:+ return -1;+ // throw new IllegalArgumentException("Unsupported decset: " + decsetBit);+ }+ }++ public TerminalEmulator(TerminalOutput session, int columns, int rows, int cellWidthPixels, int cellHeightPixels, Integer transcriptRows, TerminalSessionClient client) {+ mSession = session;+ mScreen = mMainBuffer = new TerminalBuffer(client, columns, getTerminalTranscriptRows(transcriptRows), rows);+ mAltBuffer = new TerminalBuffer(client, columns, rows, rows);+ mClient = client;+ mRows = rows;+ mColumns = columns;+ mCellWidthPixels = cellWidthPixels;+ mCellHeightPixels = cellHeightPixels;+ mTabStop = new boolean[mColumns];+ reset();+ }++ public void updateTerminalSessionClient(TerminalSessionClient client) {+ mClient = client;+ setCursorStyle();+ setCursorBlinkState(true);+ }++++ public TerminalBuffer getScreen() {+ return mScreen;+ }++ public int getRows() {+ return mRows;+ }++ public int getColumns() {+ return mColumns;+ }++ public int getCellWidthPixels() {+ return mCellWidthPixels;+ }++ public int getCellHeightPixels() {+ return mCellHeightPixels;+ }++ public boolean isAlternateBufferActive() {+ return mScreen == mAltBuffer;+ }++ private int getTerminalTranscriptRows(Integer transcriptRows) {+ if (transcriptRows == null || transcriptRows < TERMINAL_TRANSCRIPT_ROWS_MIN || transcriptRows > TERMINAL_TRANSCRIPT_ROWS_MAX)+ return DEFAULT_TERMINAL_TRANSCRIPT_ROWS;+ else+ return transcriptRows;+ }++++ /**+ * @param mouseButton one of the MOUSE_* constants of this class.+ */+ public void sendMouseEvent(int mouseButton, int column, int row, boolean pressed) {+ if (column < 1) column = 1;+ if (column > mColumns) column = mColumns;+ if (row < 1) row = 1;+ if (row > mRows) row = mRows;++ if (mouseButton == MOUSE_LEFT_BUTTON_MOVED && !isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT)) {+ // Do not send tracking.+ } else if (isDecsetInternalBitSet(DECSET_BIT_MOUSE_PROTOCOL_SGR)) {+ mSession.write(String.format("\033[<%d;%d;%d" + (pressed ? 'M' : 'm'), mouseButton, column, row));+ } else {+ mouseButton = pressed ? mouseButton : 3; // 3 for release of all buttons.+ // Clip to screen, and clip to the limits of 8-bit data.+ boolean out_of_bounds = column > 255 - 32 || row > 255 - 32;+ if (!out_of_bounds) {+ byte[] data = {'\033', '[', 'M', (byte) (32 + mouseButton), (byte) (32 + column), (byte) (32 + row)};+ mSession.write(data, 0, data.length);+ }+ }+ }++ public void resize(int columns, int rows, int cellWidthPixels, int cellHeightPixels) {+ this.mCellWidthPixels = cellWidthPixels;+ this.mCellHeightPixels = cellHeightPixels;++ if (mRows == rows && mColumns == columns) {+ return;+ } else if (columns < 2 || rows < 2) {+ throw new IllegalArgumentException("rows=" + rows + ", columns=" + columns);+ }++ if (mRows != rows) {+ mRows = rows;+ mTopMargin = 0;+ mBottomMargin = mRows;+ }+ if (mColumns != columns) {+ int oldColumns = mColumns;+ mColumns = columns;+ boolean[] oldTabStop = mTabStop;+ mTabStop = new boolean[mColumns];+ setDefaultTabStops();+ int toTransfer = Math.min(oldColumns, columns);+ System.arraycopy(oldTabStop, 0, mTabStop, 0, toTransfer);+ mLeftMargin = 0;+ mRightMargin = mColumns;+ }++ resizeScreen();+ }++ private void resizeScreen() {+ final int[] cursor = {mCursorCol, mCursorRow};+ int newTotalRows = (mScreen == mAltBuffer) ? mRows : mMainBuffer.mTotalRows;+ mScreen.resize(mColumns, mRows, newTotalRows, cursor, getStyle(), isAlternateBufferActive());+ mCursorCol = cursor[0];+ mCursorRow = cursor[1];+ }++ public int getCursorRow() {+ return mCursorRow;+ }++ public int getCursorCol() {+ return mCursorCol;+ }++ /** Get the terminal cursor style. It will be one of {@link #TERMINAL_CURSOR_STYLES_LIST} */+ public int getCursorStyle() {+ return mCursorStyle;+ }++ /** Set the terminal cursor style. */+ public void setCursorStyle() {+ Integer cursorStyle = null;++ if (mClient != null)+ cursorStyle = mClient.getTerminalCursorStyle();++ if (cursorStyle == null || !Arrays.asList(TERMINAL_CURSOR_STYLES_LIST).contains(cursorStyle))+ mCursorStyle = DEFAULT_TERMINAL_CURSOR_STYLE;+ else+ mCursorStyle = cursorStyle;+ }++ public boolean isReverseVideo() {+ return isDecsetInternalBitSet(DECSET_BIT_REVERSE_VIDEO);+ }++ /**+ * True while the application is between `\e[?2026h` and `\e[?2026l`.+ * Callers (TerminalSession) skip view invalidation while this is true so+ * the user never sees a half-redrawn frame.+ */+ public boolean isSynchronizedOutputActive() {+ return isDecsetInternalBitSet(DECSET_BIT_SYNCHRONIZED_OUTPUT);+ }++++ public boolean isCursorEnabled() {+ return isDecsetInternalBitSet(DECSET_BIT_CURSOR_ENABLED);+ }+ public boolean shouldCursorBeVisible() {+ if (!isCursorEnabled())+ return false;+ else+ return mCursorBlinkingEnabled ? mCursorBlinkState : true;+ }++ public void setCursorBlinkingEnabled(boolean cursorBlinkingEnabled) {+ this.mCursorBlinkingEnabled = cursorBlinkingEnabled;+ }++ public void setCursorBlinkState(boolean cursorBlinkState) {+ this.mCursorBlinkState = cursorBlinkState;+ }++++ public boolean isKeypadApplicationMode() {+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD);+ }++ public boolean isCursorKeysApplicationMode() {+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS);+ }++ /** If mouse events are being sent as escape codes to the terminal. */+ public boolean isMouseTrackingActive() {+ return isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) || isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT);+ }++ private void setDefaultTabStops() {+ for (int i = 0; i < mColumns; i++)+ mTabStop[i] = (i & 7) == 0 && i != 0;+ }++ /**+ * Accept bytes (typically from the pseudo-teletype) and process them.+ *+ * @param buffer a byte array containing the bytes to be processed+ * @param length the number of bytes in the array to process+ */+ public void append(byte[] buffer, int length) {+ for (int i = 0; i < length; i++)+ processByte(buffer[i]);+ }++ private void processByte(byte byteToProcess) {+ if (mUtf8ToFollow > 0) {+ if ((byteToProcess & 0b11000000) == 0b10000000) {+ // 10xxxxxx, a continuation byte.+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;+ if (--mUtf8ToFollow == 0) {+ byte firstByteMask = (byte) (mUtf8Index == 2 ? 0b00011111 : (mUtf8Index == 3 ? 0b00001111 : 0b00000111));+ int codePoint = (mUtf8InputBuffer[0] & firstByteMask);+ for (int i = 1; i < mUtf8Index; i++)+ codePoint = ((codePoint << 6) | (mUtf8InputBuffer[i] & 0b00111111));+ if (((codePoint <= 0b1111111) && mUtf8Index > 1) || (codePoint < 0b11111111111 && mUtf8Index > 2)+ || (codePoint < 0b1111111111111111 && mUtf8Index > 3)) {+ // Overlong encoding.+ codePoint = UNICODE_REPLACEMENT_CHAR;+ }++ mUtf8Index = mUtf8ToFollow = 0;++ if (codePoint >= 0x80 && codePoint <= 0x9F) {+ // Sequence decoded to a C1 control character which we ignore. They are+ // not used nowadays and increases the risk of messing up the terminal state+ // on binary input. XTerm does not allow them in utf-8:+ // "It is not possible to use a C1 control obtained from decoding the+ // UTF-8 text" - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html+ } else {+ switch (Character.getType(codePoint)) {+ case Character.UNASSIGNED:+ case Character.SURROGATE:+ codePoint = UNICODE_REPLACEMENT_CHAR;+ }+ processCodePoint(codePoint);+ }+ }+ } else {+ // Not a UTF-8 continuation byte so replace the entire sequence up to now with the replacement char:+ mUtf8Index = mUtf8ToFollow = 0;+ emitCodePoint(UNICODE_REPLACEMENT_CHAR);+ // The Unicode Standard Version 6.2 – Core Specification+ // (http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf):+ // "If the converter encounters an ill-formed UTF-8 code unit sequence which starts with a valid first+ // byte, but which does not continue with valid successor bytes (see Table 3-7), it must not consume the+ // successor bytes as part of the ill-formed subsequence+ // whenever those successor bytes themselves constitute part of a well-formed UTF-8 code unit+ // subsequence."+ processByte(byteToProcess);+ }+ } else {+ if ((byteToProcess & 0b10000000) == 0) { // The leading bit is not set so it is a 7-bit ASCII character.+ processCodePoint(byteToProcess);+ return;+ } else if ((byteToProcess & 0b11100000) == 0b11000000) { // 110xxxxx, a two-byte sequence.+ mUtf8ToFollow = 1;+ } else if ((byteToProcess & 0b11110000) == 0b11100000) { // 1110xxxx, a three-byte sequence.+ mUtf8ToFollow = 2;+ } else if ((byteToProcess & 0b11111000) == 0b11110000) { // 11110xxx, a four-byte sequence.+ mUtf8ToFollow = 3;+ } else {+ // Not a valid UTF-8 sequence start, signal invalid data:+ processCodePoint(UNICODE_REPLACEMENT_CHAR);+ return;+ }+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;+ }+ }++ public void processCodePoint(int b) {+ mScreen.doTerminalBitmapsGC(300000);++ if (mEscapeState == ESC_OSC && mIsFastPathOsc) {+ mContinueSequence = false;+ receiveOsc(b);+ if (!mContinueSequence) mEscapeState = ESC_NONE;+ return;+ }++ if (mEscapeState == ESC_DCS && mIsFastPathDcs) {+ if (b == 27) { // ESC+ ESC_DCS__ESC = true;+ return;+ }+ mContinueSequence = false;+ doDcs(b);+ if (!mContinueSequence) mEscapeState = ESC_NONE;+ return;+ }++ // The Application Program-Control (APC) string might be arbitrary non-printable characters, so handle that early.+ if (mEscapeState == ESC_APC) {+ mContinueSequence = false;+ receiveApc(b);+ if (!mContinueSequence) mEscapeState = ESC_NONE;+ return;+ } else if (mEscapeState == ESC_APC__ESC) {+ mContinueSequence = false;+ receiveApcEsc(b);+ if (!mContinueSequence) mEscapeState = ESC_NONE;+ return;+ }++ switch (b) {+ case 0: // Null character (NUL, ^@). Do nothing.+ break;+ case 7: // Bell (BEL, ^G, \a). If in an OSC sequence, BEL may terminate a string; otherwise signal bell.+ if (mEscapeState == ESC_OSC)+ receiveOsc(b);+ else+ mSession.onBell();+ break;+ case 8: // Backspace (BS, ^H).+ if (mLeftMargin == mCursorCol) {+ // Jump to previous line if it was auto-wrapped.+ int previousRow = mCursorRow - 1;+ if (previousRow >= 0 && mScreen.getLineWrap(previousRow)) {+ mScreen.clearLineWrap(previousRow);+ setCursorRowCol(previousRow, mRightMargin - 1);+ }+ } else {+ setCursorCol(mCursorCol - 1);+ }+ break;+ case 9: // Horizontal tab (HT, \t) - move to next tab stop, but not past edge of screen+ // XXX: Should perhaps use color if writing to new cells. Try with+ // printf "\033[41m\tXX\033[0m\n"+ // The OSX Terminal.app colors the spaces from the tab red, but xterm does not.+ // Note that Terminal.app only colors on new cells, in e.g.+ // printf "\033[41m\t\r\033[42m\tXX\033[0m\n"+ // the first cells are created with a red background, but when tabbing over+ // them again with a green background they are not overwritten.+ mCursorCol = nextTabStop(1);+ break;+ case 10: // Line feed (LF, \n).+ case 11: // Vertical tab (VT, \v).+ case 12: // Form feed (FF, \f).+ // Ignore CR/LF inside DCS by default (including sixel) or OSC if requested (like for iTerm).+ if (!+ (mEscapeState == ESC_DCS ||+ ((mEscapeState == ESC_OSC || mEscapeState == ESC_OSC__ESC) && mIgnoreCrLfForOsc))) {+ doLinefeed();+ }+ break;+ case 13: // Carriage return (CR, \r).+ if (!+ (mEscapeState == ESC_DCS ||+ ((mEscapeState == ESC_OSC || mEscapeState == ESC_OSC__ESC) && mIgnoreCrLfForOsc))) {+ setCursorCol(mLeftMargin);+ }+ break;+ case 14: // Shift Out (Ctrl-N, SO) → Switch to Alternate Character Set. This invokes the G1 character set.+ mUseLineDrawingUsesG0 = false;+ break;+ case 15: // Shift In (Ctrl-O, SI) → Switch to Standard Character Set. This invokes the G0 character set.+ mUseLineDrawingUsesG0 = true;+ break;+ case 24: // CAN.+ case 26: // SUB.+ if (mEscapeState != ESC_NONE) {+ // FIXME: What is this??+ mEscapeState = ESC_NONE;+ emitCodePoint(127);+ }+ break;+ case 27: // ESC+ // Starts an escape sequence unless we're parsing a string+ if (mEscapeState == ESC_DCS) {+ // XXX: Ignore escape when reading device control sequence, since it may be part of string terminator.+ ESC_DCS__ESC = true;+ return;+ } else if (mEscapeState != ESC_OSC) {+ startEscapeSequence();+ } else {+ receiveOsc(b);+ }+ break;+ default:+ mContinueSequence = false;+ switch (mEscapeState) {+ case ESC_NONE:+ if (b >= 32) emitCodePoint(b);+ break;+ case ESC:+ doEsc(b);+ break;+ case ESC_POUND:+ doEscPound(b);+ break;+ case ESC_SELECT_LEFT_PAREN: // Designate G0 Character Set (ISO 2022, VT100).+ mUseLineDrawingG0 = (b == '0');+ break;+ case ESC_SELECT_RIGHT_PAREN: // Designate G1 Character Set (ISO 2022, VT100).+ mUseLineDrawingG1 = (b == '0');+ break;+ case ESC_CSI:+ doCsi(b);+ break;+ case ESC_CSI_UNSUPPORTED_PARAMETER_BYTE:+ case ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE:+ doCsiUnsupportedParameterOrIntermediateByte(b);+ break;+ case ESC_CSI_EXCLAMATION:+ if (b == 'p') { // Soft terminal reset (DECSTR, http://vt100.net/docs/vt510-rm/DECSTR).+ reset();+ } else {+ unknownSequence(b);+ }+ break;+ case ESC_CSI_QUESTIONMARK:+ doCsiQuestionMark(b);+ break;+ case ESC_CSI_BIGGERTHAN:+ doCsiBiggerThan(b);+ break;+ case ESC_CSI_DOLLAR:+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);+ int effectiveTopMargin = originMode ? mTopMargin : 0;+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;+ switch (b) {+ case 'v': // ${CSI}${SRC_TOP}${SRC_LEFT}${SRC_BOTTOM}${SRC_RIGHT}${SRC_PAGE}${DST_TOP}${DST_LEFT}${DST_PAGE}$v"+ // Copy rectangular area (DECCRA - http://vt100.net/docs/vt510-rm/DECCRA):+ // "If Pbs is greater than Pts, or Pls is greater than Prs, the terminal ignores DECCRA.+ // The coordinates of the rectangular area are affected by the setting of origin mode (DECOM).+ // DECCRA is not affected by the page margins.+ // The copied text takes on the line attributes of the destination area.+ // If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, then the value+ // is treated as the width or height of that page.+ // If the destination area is partially off the page, then DECCRA clips the off-page data.+ // DECCRA does not change the active cursor position."+ int topSource = Math.min(getArg(0, 1, true) - 1 + effectiveTopMargin, mRows);+ int leftSource = Math.min(getArg(1, 1, true) - 1 + effectiveLeftMargin, mColumns);+ // Inclusive, so do not subtract one:+ int bottomSource = Math.min(Math.max(getArg(2, mRows, true) + effectiveTopMargin, topSource), mRows);+ int rightSource = Math.min(Math.max(getArg(3, mColumns, true) + effectiveLeftMargin, leftSource), mColumns);+ // int sourcePage = getArg(4, 1, true);+ int destionationTop = Math.min(getArg(5, 1, true) - 1 + effectiveTopMargin, mRows);+ int destinationLeft = Math.min(getArg(6, 1, true) - 1 + effectiveLeftMargin, mColumns);+ // int destinationPage = getArg(7, 1, true);+ int heightToCopy = Math.min(mRows - destionationTop, bottomSource - topSource);+ int widthToCopy = Math.min(mColumns - destinationLeft, rightSource - leftSource);+ mScreen.blockCopy(leftSource, topSource, widthToCopy, heightToCopy, destinationLeft, destionationTop);+ break;+ case '{': // ${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${"+ // Selective erase rectangular area (DECSERA - http://www.vt100.net/docs/vt510-rm/DECSERA).+ case 'x': // ${CSI}${CHAR};${TOP}${LEFT}${BOTTOM}${RIGHT}$x"+ // Fill rectangular area (DECFRA - http://www.vt100.net/docs/vt510-rm/DECFRA).+ case 'z': // ${CSI}$${TOP}${LEFT}${BOTTOM}${RIGHT}$z"+ // Erase rectangular area (DECERA - http://www.vt100.net/docs/vt510-rm/DECERA).+ boolean erase = b != 'x';+ boolean selective = b == '{';+ // Only DECSERA keeps visual attributes, DECERA does not:+ boolean keepVisualAttributes = erase && selective;+ int argIndex = 0;+ int fillChar = erase ? ' ' : getArg(argIndex++, -1, true);+ // "Pch can be any value from 32 to 126 or from 160 to 255. If Pch is not in this range, then the+ // terminal ignores the DECFRA command":+ if ((fillChar >= 32 && fillChar <= 126) || (fillChar >= 160 && fillChar <= 255)) {+ // "If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, the value+ // is treated as the width or height of that page."+ int top = Math.min(getArg(argIndex++, 1, true) + effectiveTopMargin, effectiveBottomMargin + 1);+ int left = Math.min(getArg(argIndex++, 1, true) + effectiveLeftMargin, effectiveRightMargin + 1);+ int bottom = Math.min(getArg(argIndex++, mRows, true) + effectiveTopMargin, effectiveBottomMargin);+ int right = Math.min(getArg(argIndex, mColumns, true) + effectiveLeftMargin, effectiveRightMargin);+ long style = getStyle();+ for (int row = top - 1; row < bottom; row++)+ for (int col = left - 1; col < right; col++)+ if (!selective || (TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)+ mScreen.setChar(col, row, fillChar, keepVisualAttributes ? mScreen.getStyleAt(row, col) : style);+ }+ break;+ case 'r': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$r"+ // Change attributes in rectangular area (DECCARA - http://vt100.net/docs/vt510-rm/DECCARA).+ case 't': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$t"+ // Reverse attributes in rectangular area (DECRARA - http://www.vt100.net/docs/vt510-rm/DECRARA).+ boolean reverse = b == 't';+ // FIXME: "coordinates of the rectangular area are affected by the setting of origin mode (DECOM)".+ int top = Math.min(getArg(0, 1, true) - 1, effectiveBottomMargin) + effectiveTopMargin;+ int left = Math.min(getArg(1, 1, true) - 1, effectiveRightMargin) + effectiveLeftMargin;+ int bottom = Math.min(getArg(2, mRows, true) + 1, effectiveBottomMargin - 1) + effectiveTopMargin;+ int right = Math.min(getArg(3, mColumns, true) + 1, effectiveRightMargin - 1) + effectiveLeftMargin;+ if (mArgIndex >= 4) {+ if (mArgIndex >= mArgs.length) mArgIndex = mArgs.length - 1;+ for (int i = 4; i <= mArgIndex; i++) {+ int bits = 0;+ boolean setOrClear = true; // True if setting, false if clearing.+ switch (getArg(i, 0, false)) {+ case 0: // Attributes off (no bold, no underline, no blink, positive image).+ bits = (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE | TextStyle.CHARACTER_ATTRIBUTE_BLINK+ | TextStyle.CHARACTER_ATTRIBUTE_INVERSE);+ if (!reverse) setOrClear = false;+ break;+ case 1: // Bold.+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;+ break;+ case 4: // Underline.+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ break;+ case 5: // Blink.+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;+ break;+ case 7: // Negative image.+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;+ break;+ case 22: // No bold.+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;+ setOrClear = false;+ break;+ case 24: // No underline.+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ setOrClear = false;+ break;+ case 25: // No blink.+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;+ setOrClear = false;+ break;+ case 27: // Positive image.+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;+ setOrClear = false;+ break;+ }+ if (reverse && !setOrClear) {+ // Reverse attributes in rectangular area ignores non-(1,4,5,7) bits.+ } else {+ mScreen.setOrClearEffect(bits, setOrClear, reverse, isDecsetInternalBitSet(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE),+ effectiveLeftMargin, effectiveRightMargin, top, left, bottom, right);+ }+ }+ } else {+ // Do nothing.+ }+ break;+ default:+ unknownSequence(b);+ }+ break;+ case ESC_CSI_DOUBLE_QUOTE:+ if (b == 'q') {+ // http://www.vt100.net/docs/vt510-rm/DECSCA+ int arg = getArg0(0);+ if (arg == 0 || arg == 2) {+ // DECSED and DECSEL can erase characters.+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;+ } else if (arg == 1) {+ // DECSED and DECSEL cannot erase characters.+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;+ } else {+ unknownSequence(b);+ }+ } else {+ unknownSequence(b);+ }+ break;+ case ESC_CSI_SINGLE_QUOTE:+ if (b == '}') { // Insert Ps Column(s) (default = 1) (DECIC), VT420 and up.+ int columnsAfterCursor = mRightMargin - mCursorCol;+ int columnsToInsert = Math.min(getArg0(1), columnsAfterCursor);+ int columnsToMove = columnsAfterCursor - columnsToInsert;+ mScreen.blockCopy(mCursorCol, 0, columnsToMove, mRows, mCursorCol + columnsToInsert, 0);+ blockClear(mCursorCol, 0, columnsToInsert, mRows);+ } else if (b == '~') { // Delete Ps Column(s) (default = 1) (DECDC), VT420 and up.+ int columnsAfterCursor = mRightMargin - mCursorCol;+ int columnsToDelete = Math.min(getArg0(1), columnsAfterCursor);+ int columnsToMove = columnsAfterCursor - columnsToDelete;+ mScreen.blockCopy(mCursorCol + columnsToDelete, 0, columnsToMove, mRows, mCursorCol, 0);+ } else {+ unknownSequence(b);+ }+ break;+ case ESC_PERCENT:+ break;+ case ESC_OSC:+ receiveOsc(b);+ break;+ case ESC_OSC__ESC:+ receiveOscEsc(b);+ break;+ case ESC_DCS:+ doDcs(b);+ break;+ case ESC_CSI_QUESTIONMARK_ARG_DOLLAR:+ if (b == 'p') {+ // Request DEC private mode (DECRQM).+ int mode = getArg0(0);+ int value;+ if (mode == 47 || mode == 1047 || mode == 1049) {+ // This state is carried by mScreen pointer.+ value = (mScreen == mAltBuffer) ? 1 : 2;+ } else {+ int internalBit = mapDecSetBitToInternalBit(mode);+ if (internalBit != -1) {+ value = isDecsetInternalBitSet(internalBit) ? 1 : 2; // 1=set, 2=reset.+ } else {+ Logger.logError(mClient, LOG_TAG, "Got DECRQM for unrecognized private DEC mode=" + mode);+ value = 0; // 0=not recognized, 3=permanently set, 4=permanently reset+ }+ }+ mSession.write(String.format(Locale.US, "\033[?%d;%d$y", mode, value));+ } else {+ unknownSequence(b);+ }+ break;+ case ESC_CSI_ARGS_SPACE:+ int arg = getArg0(0);+ switch (b) {+ case 'q': // "${CSI}${STYLE} q" - set cursor style (http://www.vt100.net/docs/vt510-rm/DECSCUSR).+ switch (arg) {+ case 0: // Blinking block.+ case 1: // Blinking block.+ case 2: // Steady block.+ mCursorStyle = TERMINAL_CURSOR_STYLE_BLOCK;+ break;+ case 3: // Blinking underline.+ case 4: // Steady underline.+ mCursorStyle = TERMINAL_CURSOR_STYLE_UNDERLINE;+ break;+ case 5: // Blinking bar (xterm addition).+ case 6: // Steady bar (xterm addition).+ mCursorStyle = TERMINAL_CURSOR_STYLE_BAR;+ break;+ }+ break;+ case 't':+ case 'u':+ // Set margin-bell volume - ignore.+ break;+ default:+ unknownSequence(b);+ }+ break;+ case ESC_CSI_ARGS_ASTERIX:+ int attributeChangeExtent = getArg0(0);+ if (b == 'x' && (attributeChangeExtent >= 0 && attributeChangeExtent <= 2)) {+ // Select attribute change extent (DECSACE - http://www.vt100.net/docs/vt510-rm/DECSACE).+ setDecsetinternalBit(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE, attributeChangeExtent == 2);+ } else {+ unknownSequence(b);+ }+ break;+ default:+ unknownSequence(b);+ break;+ }+ if (!mContinueSequence) mEscapeState = ESC_NONE;+ break;+ }+ }++++ /**+ * Do {@link #ESC_DCS}. Check its docs for more info.+ */+ private void doDcs(final int b) {+ if (+ // End of DCS if string terminator ST `ESC \` received.+ (ESC_DCS__ESC && b == '\\')+ // If sixel continuation after sixel start and a+ // Color Introducer `#`, Graphics Repeat Introducer `!` or Raster Attributes `"`+ // command is received, then process any previous commands, or if end of input+ // with a ST received.+ // If `b` is a Color Introducer `#`, Graphics Repeat Introducer `!` or Raster Attributes `"`+ // command, then it is added to buffer in code below and more input is waited for as+ // further arguments need to be received for its command before it can be processed,+ // which is not until the next command is received.+ // We wait till at least `TERMINAL_CONTROL_ARGS__MAX_LENGTH / 2` commands string has+ // been received. The divide by 2 is done since if near the max length, a new command+ // starts and it does not end before the max length, then `Terminal control args overflow+ // error would occur.+ // If the first command has been fully received, then we run it immediately in case+ // it is the Raster Attributes command containing the "rough" horizontal and vertical+ // size of image, which is used to set the capacity of the `mTerminalControlArgs` buffer+ // and also resize the bitmap, so that memory allocations are avoided if possible.+ // `mTerminalControlArgs.length() > 1` is done so that loop does not engage on first+ // character after `q` and only after first command has been fully received.+ // Podroid: also flush on `$` (sixel CR) and `-` (sixel LF). The upstream sixel4+ // fork only triggers on `#`/`!`/`"`, but in pixel-data runs those are infrequent+ // (color is typically set once per row) while `$` and `-` end every sub-row. With+ // chafa's high-color output the buffer would otherwise overflow at 16 KB before+ // any flush-eligible byte arrived — see Podroid CLAUDE.md.+ || (ESC_DCS__SIXEL && ((b == '#' || b == '!' || b == '"' || b == '$' || b == '-') &&+ ((mTerminalControlArgs.length() >= (TERMINAL_CONTROL_ARGS__DEFAULT_MAX_LENGTH / 2)) || (mTerminalControlArgs.length() > 1 && mSixelCommandPartNum == 1))))+ ) {+ String dcs = mTerminalControlArgs.toString();++ // Request Selection or Setting (DECRQSS) `DCS $ q P t ST`.+ // - https://vt100.net/docs/vt510-rm/DECRQSS.html+ if (dcs.startsWith("$q")) {+ if (dcs.equals("$q\"p")) {+ // DECSCL, conformance level, http://www.vt100.net/docs/vt510-rm/DECSCL:+ String csiString = "64;1\"p";+ mSession.write("\033P1$r" + csiString + "\033\\");+ } else {+ finishSequenceAndLogError("Unrecognized DECRQSS string: '" + dcs + "'");+ }+ } else if (dcs.startsWith("+q")) {+ // Request Termcap/Terminfo String. The string following the "q" is a list of names encoded in+ // hexadecimal (2 digits per character) separated by ; which correspond to termcap or terminfo key+ // names.+ // Two special features are also recognized, which are not key names: Co for termcap colors (or colors+ // for terminfo colors), and TN for termcap name (or name for terminfo name).+ // xterm responds with DCS 1 + r P t ST for valid requests, adding to P t an = , and the value of the+ // corresponding string that xterm would send, or DCS 0 + r P t ST for invalid requests. The strings are+ // encoded in hexadecimal (2 digits per character).+ // Example:+ // :kr=\EOC: ks=\E[?1h\E=: ku=\EOA: le=^H:mb=\E[5m:md=\E[1m:\+ // where+ // kd=down-arrow key+ // kl=left-arrow key+ // kr=right-arrow key+ // ku=up-arrow key+ // #2=key_shome, "shifted home"+ // #4=key_sleft, "shift arrow left"+ // %i=key_sright, "shift arrow right"+ // *7=key_send, "shifted end"+ // k1=F1 function key++ // Example: Request for ku is "ESC P + q 6 b 7 5 ESC \", where 6b7d=ku in hexadecimal.+ // Xterm response in normal cursor mode:+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x5B 0x41 = 27 91 65 = ESC [ A+ // Xterm response in application cursor mode:+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x4F 0x41 = 27 91 65 = ESC 0 A++ // #4 is "shift arrow left":+ // *** Device Control (DCS) for '#4'- 'ESC P + q 23 34 ESC \'+ // Response: <27> P 1 + r 2 3 3 4 = 1 B 5 B 3 1 3 B 3 2 4 4 <27> \+ // where 0x1B 0x5B 0x31 0x3B 0x32 0x44 = ESC [ 1 ; 2 D+ // which we find in: TermKeyListener.java: KEY_MAP.put(KEYMOD_SHIFT | KEYCODE_DPAD_LEFT, "\033[1;2D");++ // See http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V40G_HTML/MAN/MAN4/0178____.HTM for what to+ // respond, as well as http://www.freebsd.org/cgi/man.cgi?query=termcap&sektion=5#CAPABILITIES for+ // the meaning of e.g. "ku", "kd", "kr", "kl"++ for (String part : dcs.substring(2).split(";")) {+ if (part.length() % 2 == 0) {+ StringBuilder transBuffer = new StringBuilder();+ char c;+ for (int i = 0; i < part.length(); i += 2) {+ try {+ c = (char) Long.decode("0x" + part.charAt(i) + "" + part.charAt(i + 1)).longValue();+ } catch (NumberFormatException e) {+ Logger.logStackTraceWithMessage(mClient, LOG_TAG, "Invalid device termcap/terminfo encoded name \"" + part + "\"", e);+ continue;+ }+ transBuffer.append(c);+ }++ String trans = transBuffer.toString();+ String responseValue;+ switch (trans) {+ case "Co":+ case "colors":+ responseValue = "256"; // Number of colors.+ break;+ case "TN":+ case "name":+ responseValue = "xterm";+ break;+ default:+ responseValue = KeyHandler.getCodeFromTermcap(trans, isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS),+ isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD));+ break;+ }+ if (responseValue == null) {+ switch (trans) {+ case "%1": // Help key - ignore+ case "&8": // Undo key - ignore.+ break;+ default:+ Logger.logWarn(mClient, LOG_TAG, "Unhandled termcap/terminfo name: '" + trans + "'");+ }+ // Respond with invalid request:+ mSession.write("\033P0+r" + part + "\033\\");+ } else {+ StringBuilder hexEncoded = new StringBuilder();+ for (int j = 0; j < responseValue.length(); j++) {+ hexEncoded.append(String.format("%02X", (int) responseValue.charAt(j)));+ }+ mSession.write("\033P1+r" + part + "=" + hexEncoded + "\033\\");+ }+ } else {+ Logger.logError(mClient, LOG_TAG, "Invalid device termcap/terminfo name of odd length: " + part);+ }+ }+ }+ // If `s..s` or `ST` received from Sixel Device Control String `DCS q s..s ST` or `DCS P1; P2; P3; q s..s ST` command.+ else if (ESC_DCS__SIXEL) {+ mSixelCommandPartNum++;++ boolean isValidDcs = processSixelDcs(dcs);++ if (!isValidDcs) {+ clearTerminalControlArgs();+ clearDcsTypeVariables();+ finishSequence();+ return;+ }++ if (ESC_DCS__ESC && b == '\\') {+ int n = mScreen.sixelEnd(mCursorCol, mCursorRow, mCellWidthPixels, mCellHeightPixels);+ for(; n > 0; n--) {+ doLinefeed();+ }++ // Clear DCS args buffer and variables and finish sequence.+ } else {+ ESC_DCS__ESC = false;++ // Clear DCS args buffer to receive further new input in empty buffer.+ clearTerminalControlArgs();++ // Increase capacity to expected capacity if `Raster Attributes` command+ // was sent with image width and height, or to default+ // `SIXEL_ARGS__INITIAL_CAPACITY` set by `startIfSixelDcs()`.+ if (mSixelArgsCapacity != null) {+ ensureTerminalControlArgsCapacity(mSixelArgsCapacity);+ }++ // If `b` is a Color Introducer `#`, Graphics Repeat Introducer `!` or Raster Attributes `"`+ // command, then add to buffer and wait for more input as further arguments+ // need to be received for its command before it can be processed, which is+ // not until the next command is received.+ if (!collectTerminalControlArgs(b)) return;++ return;+ }+ } else {+ if (LOG_ESCAPE_SEQUENCES)+ Logger.logError(mClient, LOG_TAG, "Unrecognized device control string: " + dcs);+ }++ // Clear DCS args buffer and variables and finish sequence.+ clearTerminalControlArgs();+ clearDcsTypeVariables();+ finishSequence();+ } else {+ ESC_DCS__ESC = false;++ if (!collectTerminalControlArgs(b)) return;++ if (ESC_DCS__CHECK_IF_SIXEL && !ESC_DCS__SIXEL) {+ // Check if `DCS q` or `DCS P1; P2; P3; q` received from Sixel+ // Device Control String `DCS q s..s ST` or `DCS P1; P2; P3; q s..s ST` command.+ // If received, then wait for more input after `q`.+ char ch = mTerminalControlArgs.charAt(0);+ if (ch == 'q' || (ch >= '0' && ch <= '9')) {+ startIfSixelDcs();+ } else {+ ESC_DCS__CHECK_IF_SIXEL = false;+ }+ }+ }+ }++ public void clearDcsTypeVariables() {+ ESC_DCS__ESC = false;+ mIsFastPathDcs = false;++ ESC_DCS__SIXEL = false;+ ESC_DCS__CHECK_IF_SIXEL = true;+ mSixelCommandPartNum = 0;+ mSixelArgsCapacity = null;+ mScreen.sixelClear();+ }++++ private void startIfSixelDcs() {+ int[] sixelDcsSetupArgs = getSixelDcsSetupArgs(mTerminalControlArgs.toString(), 0);+ if (sixelDcsSetupArgs != null) {++ mIsFastPathDcs = true;+ ESC_DCS__SIXEL = true;+ ESC_DCS__CHECK_IF_SIXEL = false;+ mSixelCommandPartNum = 1;++ // Do not actually increase capacity yet, as it will be increased by `doDcs()` after+ // first command has been received, which is checked to see if its a `Raster Attributes`+ // command with image width and height to calculate expected capacity.+ mSixelArgsCapacity = SIXEL_ARGS__INITIAL_CAPACITY;++ // The `P1; P2; P3;` arguements in `sixelDcsSetupArgs` are ignored as they are not supported currently (if ever).+ mScreen.sixelStart(100, 100);+ clearTerminalControlArgs();+ }+ }++ private int[] getSixelDcsSetupArgs(String dcs, int index) {+ int[] args = {/* `P1=0`/`2:1` */ 0, /* `P2=0` */ 0, /* `P3=0` */ 0};++ if (dcs.charAt(index) == 'q') return args;++ char ch;++ int arg = 0; boolean incArg = false;+ while (index < dcs.length()) {+ ch = dcs.charAt(index);+ if (ch >= '0' && ch <= '9') {+ if (incArg) { arg++; incArg = false; }+ args[arg] = args[arg] * 10 + ch - '0';+ if (args[arg] < 0) { // Overflow.+ break;+ }+ index++;+ } else if (ch == ';') {+ index++;++ if (arg == 2) {+ if (index < dcs.length()) {+ if (dcs.charAt(index) == 'q') {+ return args;+ } else {+ // Must be some other command, so no need to check again.+ ESC_DCS__CHECK_IF_SIXEL = false;+ }+ }+ break;+ }++ incArg = true;+ } else if (ch == 'q') {+ // Podroid: also accept `Pa;Pb;Pcq` form (no trailing `;` before `q`).+ // chafa emits `\eP0;1;0q` for Sixel; the upstream sixel4 fork only handled+ // the `Pa;Pb;Pc;q` form (with trailing `;`), so chafa output never entered+ // Sixel mode and bytes accumulated as DCS args until overflow at 16 KB.+ return args;+ } else {+ break;+ }+ }++ return null;+ }++ private boolean processSixelDcs(String dcs) {+ int index = 0;++ char ch;+ int repeat = 1;+ int color;+ boolean isValidDcs = true;++ // FIXME: Use `StringUtils.truncateLogStringWithSnippet()` when its added for logging `dcs` input+ // in errors as it may be truncated from end before index if error length is greater than+ // `Logger.LOGGER_ENTRY_MAX_SAFE_PAYLOAD`.+ while (index < dcs.length()) {+ ch = dcs.charAt(index);++ if (+ // Sixel data characters in the range of `?` (0x3F) to `~` (0x7E).+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.2.1+ (ch >= '?' && ch <= '~')+ // Graphics Carriage Return `$`.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.4+ || ch == '$'+ // Graphics New Line `-`.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.5+ || ch == '-'+ ) {+ mScreen.sixelReadData(ch, repeat);+ index++;+ repeat = 1;+ }+ // Color Introducer `#`+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.3+ else if (ch == '#') {+ index++; // Consume '#'.++ color = 0;+ while (index < dcs.length()) {+ ch = dcs.charAt(index);+ if (ch >= '0' && ch <= '9') {+ color = color * 10 + ch - '0';+ if (color < 0) { // Overflow.+ Logger.logError(mClient, LOG_TAG, "The sixel color command Pc value overflow at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ index++;+ } else {+ break;+ }+ }++ if (color > 255) {+ Logger.logError(mClient, LOG_TAG, "The sixel color command Pc value " + color + " is not between 0-255 at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }++ if (!isValidDcs) {+ break;+ }++ // Basic Colors `# Pc`+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.3.1+ if (index == dcs.length() || dcs.charAt(index) != ';') {+ mScreen.sixelSetColor(color);+ }+ // HLS or RGB Colors `# Pc; Pu; Px; Py; Pz`+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.3.2+ else if (dcs.charAt(index) == ';') {+ index++; // Consume ';'.++ int[] args = {0, 0, 0, 0};+ int arg = 0; boolean incArg = false;+ while (index < dcs.length()) {+ ch = dcs.charAt(index);+ if (ch >= '0' && ch <= '9') {+ if (incArg) { arg++; incArg = false; }+ args[arg] = args[arg] * 10 + ch - '0';+ if (args[arg] < 0) { // Overflow.+ String argName = "";+ switch (arg) { case 0: argName = "Pu"; break; case 1: argName = "pX"; break; case 2: argName = "pY"; break; case 3: argName = "pZ"; break; }+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command " + argName + " value overflow at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ } else if (ch == ';') {+ if (arg == 3) { // Pz must not end with a ';'.+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command Pz value " + args[3] + " must not end with a semicolon ';' at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }++ incArg = true;+ } else {+ break;+ }+ index++;+ }++ if (!isValidDcs) {+ break;+ }++ for (int i = 0; i < args.length; i++) {+ if (i == 0) { // Pu must equal 1 or 2.+ if ((args[i] != 1 && args[i] != 2)) {+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command Pu value " + args[i] + " is not 1 or 2 at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ } else {+ int limit = 100;+ if (args[0] == 1 && i == 1) limit = 360;+ if (args[i] < 0 || args[i] > limit) {+ String argName = "";+ switch (i) { case 1: argName = "pX"; break; case 2: argName = "pY"; break; case 3: argName = "pZ"; break; }+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command " + argName + " value " + args[i] + " is not between 0-" + limit + " at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ }+ }++ if (isValidDcs && arg == 3) { // If complete spec is received and is valid.+ if (args[0] == 2) { // Only RGB is supported.+ mScreen.sixelSetRGBColor(color, args[1], args[2], args[3]);+ } else if (args[0] == 1) { // HLS is not supported.+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command Pu value " + args[0] + " is not supported at index " + index + " of sixel input: " + dcs);+ mScreen.sixelIgnore();+ break;+ }+ } else {+ if (isValidDcs)+ Logger.logError(mClient, LOG_TAG, "The sixel non-basic color command expected 4 arguments at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ }+ }+ // Graphics Repeat Introducer `! Pn character`.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.1+ else if (ch == '!') {+ index++; // Consume '!'.++ repeat = 0;+ while (index < dcs.length()) {+ ch = dcs.charAt(index);+ if (ch >= '0' && ch <= '9') {+ repeat = repeat * 10 + ch - '0';+ if (repeat < 0) { // Overflow.+ Logger.logError(mClient, LOG_TAG, "The sixel repeat command Pn value overflow at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ index++;+ } else {+ break;+ }+ }++ if (repeat > TerminalSixel.SIXEL__MAX_REPEAT) {+ Logger.logError(mClient, LOG_TAG, "The sixel repeat command Pn value " + repeat + " is greater than max repeat value " ++ TerminalSixel.SIXEL__MAX_REPEAT + " at index " + index + " of sixel input: " + dcs);+ mScreen.sixelIgnore();+ break;+ }++ if (!isValidDcs) {+ break;+ }+ }+ // Raster Attributes `" Pan; Pad; Ph; Pv`+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.2+ else if (ch == '"') {+ index++; // Consume '"'.++ int[] args = {0, 0, 0, 0};+ int arg = 0; boolean incArg = false;+ while (index < dcs.length()) {+ ch = dcs.charAt(index);+ if (ch >= '0' && ch <= '9') {+ if (incArg) { arg++; incArg = false; }+ args[arg] = args[arg] * 10 + ch - '0';+ if (args[arg] < 0) { // Overflow.+ String argName = "";+ switch (arg) { case 0: argName = "Pan"; break; case 1: argName = "Pad"; break; case 2: argName = "pH"; break; case 3: argName = "pV"; break; }+ Logger.logError(mClient, LOG_TAG, "The sixel raster command " + argName + " value overflow at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ } else if (ch == ';') {+ if (arg == 3) { // Pv must not end with a ';'.+ Logger.logError(mClient, LOG_TAG, "The sixel raster command Pv value " + args[3] + " must not end with a semicolon ';' at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ incArg = true;+ } else {+ break;+ }+ index++;+ }++ if (isValidDcs && arg == 3) { // If complete spec is received and is valid.+ // Raster pixel aspect ratio is not supported currently.+ // Raster "rough" horizontal and vertical size of image may be sent at start of+ // sixel data string, like done by `img2sixel`, so increase sixel commands args+ // buffer capacity (`mTerminalControlArgs`) and resize sixel bitmap in+ // `TerminalSixel` at start, instead of having to keep resizing buffer/bitmap+ // as more sixel data is received, which has a performance hit due to+ // memory reallocations and copying.+ int sixelWidth = args[2]; // `Ph`+ int sixelHeight = args[3]; // `Pv`+ if (sixelWidth > 0 && sixelHeight > 0) {+ // 2% extra for sixel commands/parameters in addition to image data.+ int sixelArgsExpectedLength = (int) (sixelWidth * sixelHeight * 1.02);+ // If sixel commands are too long, they are divided into parts, and if a+ // new command starts near `TERMINAL_CONTROL_ARGS__MAX_LENGTH / 2`, it could+ // contain image data for 1 pixel line of image width, so add that.+ int sixelArgsPartsExpectedLength = (int) ((((double) TERMINAL_CONTROL_ARGS__DEFAULT_MAX_LENGTH / 2) + sixelWidth) * 1.02);+ int sixelArgsExpectedCapacity = Math.min(sixelArgsPartsExpectedLength, sixelArgsExpectedLength);+ if (sixelArgsExpectedCapacity > SIXEL_ARGS__INITIAL_CAPACITY) {+ mSixelArgsCapacity = sixelArgsExpectedCapacity;+ }++ mScreen.sixelResize(sixelWidth, sixelHeight);+ }+ } else {+ if (isValidDcs)+ Logger.logError(mClient, LOG_TAG, "The sixel raster command expected 4 arguments at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ }+ else if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f' || ch == '\r') {+ index++;+ } else {+ // Invalid character.+ Logger.logError(mClient, LOG_TAG, "Invalid character '" + ch + "' (" + (byte) ch + ") at index " + index + " of sixel input: " + dcs);+ isValidDcs = false;+ break;+ }+ }++ return isValidDcs;+ }++++ private int nextTabStop(int numTabs) {+ for (int i = mCursorCol + 1; i < mColumns; i++)+ if (mTabStop[i] && --numTabs == 0) return Math.min(i, mRightMargin);+ return mRightMargin - 1;+ }++ /**+ * Process byte while in the {@link #ESC_CSI_UNSUPPORTED_PARAMETER_BYTE} or+ * {@link #ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE} escape state.+ *+ * Parse unsupported parameter, intermediate and final bytes but ignore them.+ *+ * > For Control Sequence Introducer, ... the ESC [ is followed by+ * > - any number (including none) of "parameter bytes" in the range 0x30–0x3F (ASCII 0–9:;<=>?),+ * > - then by any number of "intermediate bytes" in the range 0x20–0x2F (ASCII space and !"#$%&'()*+,-./),+ * > - then finally by a single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).+ *+ * - https://en.wikipedia.org/wiki/ANSI_escape_code#Control_Sequence_Introducer_commands+ * - https://invisible-island.net/xterm/ecma-48-parameter-format.html#section5.4+ */+ private void doCsiUnsupportedParameterOrIntermediateByte(int b) {+ if (mEscapeState == ESC_CSI_UNSUPPORTED_PARAMETER_BYTE && b >= 0x30 && b <= 0x3F) {+ // Supported `0–9:;>?` or unsupported `<=` parameter byte after an+ // initial unsupported parameter byte in `doCsi()`, or a sequential parameter byte.+ continueSequence(ESC_CSI_UNSUPPORTED_PARAMETER_BYTE);+ } else if (b >= 0x20 && b <= 0x2F) {+ // Optional intermediate byte `!"#$%&'()*+,-./` after parameter or intermediate byte.+ continueSequence(ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE);+ } else if (b >= 0x40 && b <= 0x7E) {+ // Final byte `@A–Z[\]^_`a–z{|}~` after parameter or intermediate byte.+ // Calling `unknownSequence()` would log an error with only a final byte, so ignore it for now.+ finishSequence();+ } else {+ unknownSequence(b);+ }+ }++ /** Process byte while in the {@link #ESC_CSI_QUESTIONMARK} escape state. */+ private void doCsiQuestionMark(int b) {+ switch (b) {+ case 'J': // Selective erase in display (DECSED) - http://www.vt100.net/docs/vt510-rm/DECSED.+ case 'K': // Selective erase in line (DECSEL) - http://vt100.net/docs/vt510-rm/DECSEL.+ mAboutToAutoWrap = false;+ int fillChar = ' ';+ int startCol = -1;+ int startRow = -1;+ int endCol = -1;+ int endRow = -1;+ boolean justRow = (b == 'K');+ switch (getArg0(0)) {+ case 0: // Erase from the active position to the end, inclusive (default).+ startCol = mCursorCol;+ startRow = mCursorRow;+ endCol = mColumns;+ endRow = justRow ? (mCursorRow + 1) : mRows;+ break;+ case 1: // Erase from start to the active position, inclusive.+ startCol = 0;+ startRow = justRow ? mCursorRow : 0;+ endCol = mCursorCol + 1;+ endRow = mCursorRow + 1;+ break;+ case 2: // Erase all of the display/line.+ startCol = 0;+ startRow = justRow ? mCursorRow : 0;+ endCol = mColumns;+ endRow = justRow ? (mCursorRow + 1) : mRows;+ break;+ default:+ unknownSequence(b);+ break;+ }+ long style = getStyle();+ for (int row = startRow; row < endRow; row++) {+ for (int col = startCol; col < endCol; col++) {+ if ((TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)+ mScreen.setChar(col, row, fillChar, style);+ }+ }+ break;+ case 'h':+ case 'l':+ if (mArgIndex >= mArgs.length) mArgIndex = mArgs.length - 1;+ for (int i = 0; i <= mArgIndex; i++)+ doDecSetOrReset(b == 'h', mArgs[i]);+ break;+ case 'n': // Device Status Report (DSR, DEC-specific).+ switch (getArg0(-1)) {+ case 6:+ // Extended Cursor Position (DECXCPR - http://www.vt100.net/docs/vt510-rm/DECXCPR). Page=1.+ mSession.write(String.format(Locale.US, "\033[?%d;%d;1R", mCursorRow + 1, mCursorCol + 1));+ break;+ default:+ finishSequence();+ return;+ }+ break;+ case 'r':+ case 's':+ if (mArgIndex >= mArgs.length) mArgIndex = mArgs.length - 1;+ for (int i = 0; i <= mArgIndex; i++) {+ int externalBit = mArgs[i];+ int internalBit = mapDecSetBitToInternalBit(externalBit);+ if (internalBit == -1) {+ Logger.logWarn(mClient, LOG_TAG, "Ignoring request to save/recall decset bit=" + externalBit);+ } else {+ if (b == 's') {+ mSavedDecSetFlags |= internalBit;+ } else {+ doDecSetOrReset((mSavedDecSetFlags & internalBit) != 0, externalBit);+ }+ }+ }+ break;+ case '$':+ continueSequence(ESC_CSI_QUESTIONMARK_ARG_DOLLAR);+ return;+ default:+ parseArg(b);+ }+ }++ public void doDecSetOrReset(boolean setting, int externalBit) {+ int internalBit = mapDecSetBitToInternalBit(externalBit);+ if (internalBit != -1) {+ setDecsetinternalBit(internalBit, setting);+ }+ switch (externalBit) {+ case 1: // Application Cursor Keys (DECCKM).+ break;+ case 3: // Set: 132 column mode (. Reset: 80 column mode. ANSI name: DECCOLM.+ // We don't actually set/reset 132 cols, but we do want the side effects+ // (FIXME: Should only do this if the 95 DECSET bit (DECNCSM) is set, and if changing value?):+ // Sets the left, right, top and bottom scrolling margins to their default positions, which is important for+ // the "reset" utility to really reset the terminal:+ mLeftMargin = mTopMargin = 0;+ mBottomMargin = mRows;+ mRightMargin = mColumns;+ // "DECCOLM resets vertical split screen mode (DECLRMM) to unavailable":+ setDecsetinternalBit(DECSET_BIT_LEFTRIGHT_MARGIN_MODE, false);+ // "Erases all data in page memory":+ blockClear(0, 0, mColumns, mRows);+ setCursorRowCol(0, 0);+ break;+ case 4: // DECSCLM-Scrolling Mode. Ignore.+ break;+ case 5: // Reverse video. No action.+ break;+ case 6: // Set: Origin Mode. Reset: Normal Cursor Mode. Ansi name: DECOM.+ if (setting) setCursorPosition(0, 0);+ break;+ case 7: // Wrap-around bit, not specific action.+ case 8: // Auto-repeat Keys (DECARM). Do not implement.+ case 9: // X10 mouse reporting - outdated. Do not implement.+ case 12: // Control cursor blinking - ignore.+ case 25: // Hide/show cursor - no action needed, renderer will check with shouldCursorBeVisible().+ if (mClient != null)+ mClient.onTerminalCursorStateChange(setting);+ break;+ case 40: // Allow 80 => 132 Mode, ignore.+ case 45: // TODO: Reverse wrap-around. Implement???+ case 66: // Application keypad (DECNKM).+ break;+ case 69: // Left and right margin mode (DECLRMM).+ if (!setting) {+ mLeftMargin = 0;+ mRightMargin = mColumns;+ }+ break;+ case 1000:+ case 1001:+ case 1002:+ case 1003:+ case 1004:+ case 1005: // UTF-8 mouse mode, ignore.+ case 1006: // SGR Mouse Mode+ case 1015:+ case 1034: // Interpret "meta" key, sets eighth bit.+ break;+ case 1048: // Set: Save cursor as in DECSC. Reset: Restore cursor as in DECRC.+ if (setting)+ saveCursor();+ else+ restoreCursor();+ break;+ case 47:+ case 1047:+ case 1049: {+ // Set: Save cursor as in DECSC and use Alternate Screen Buffer, clearing it first.+ // Reset: Use Normal Screen Buffer and restore cursor as in DECRC.+ TerminalBuffer newScreen = setting ? mAltBuffer : mMainBuffer;+ if (newScreen != mScreen) {+ boolean resized = !(newScreen.mColumns == mColumns && newScreen.mScreenRows == mRows);+ if (setting) saveCursor();+ mScreen = newScreen;+ if (!setting) {+ int col = mSavedStateMain.mSavedCursorCol;+ int row = mSavedStateMain.mSavedCursorRow;+ restoreCursor();+ if (resized) {+ // Restore cursor position _not_ clipped to current screen (let resizeScreen() handle that):+ mCursorCol = col;+ mCursorRow = row;+ }+ }+ // Check if buffer size needs to be updated:+ if (resized) resizeScreen();+ // Clear new screen if alt buffer:+ if (newScreen == mAltBuffer)+ newScreen.blockSet(0, 0, mColumns, mRows, ' ', getStyle());+ }+ break;+ }+ case 2004:+ // Bracketed paste mode - setting bit is enough.+ break;+ default:+ unknownParameter(externalBit);+ break;+ }+ }++ private void doCsiBiggerThan(int b) {+ switch (b) {+ case 'c': // "${CSI}>c" or "${CSI}>c". Secondary Device Attributes (DA2).+ // Originally this was used for the terminal to respond with "identification code, firmware version level,+ // and hardware options" (http://vt100.net/docs/vt510-rm/DA2), with the first "41" meaning the VT420+ // terminal type. This is not used anymore, but the second version level field has been changed by xterm+ // to mean it's release number ("patch numbers" listed at http://invisible-island.net/xterm/xterm.log.html),+ // and some applications use it as a feature check:+ // * tmux used to have a "xterm won't reach version 500 for a while so set that as the upper limit" check,+ // and then check "xterm_version > 270" if rectangular area operations such as DECCRA could be used.+ // * vim checks xterm version number >140 for "Request termcap/terminfo string" functionality >276 for SGR+ // mouse report.+ // The third number is a keyboard identifier not used nowadays.+ mSession.write("\033[>41;320;0c");+ break;+ case 'q':+ // XTVERSION (`CSI > 0 q`) — report terminal name + version.+ // Format: `DCS > | NAME ST` per xterm spec.+ // Modern apps (Neovim ≥0.10, kitty-aware tools) use this to detect+ // capabilities (truecolor, sync output, etc.) without trial-and-error.+ if (getArg0(0) == 0) {+ String version = mClient != null ? mClient.getTerminalVersionString() : null;+ if (version == null || version.isEmpty()) version = "Podroid";+ mSession.write("\033P>|" + version + "\033\\");+ }+ break;+ case 'm':+ // https://bugs.launchpad.net/gnome-terminal/+bug/96676/comments/25+ // Depending on the first number parameter, this can set one of the xterm resources+ // modifyKeyboard, modifyCursorKeys, modifyFunctionKeys and modifyOtherKeys.+ // http://invisible-island.net/xterm/manpage/xterm.html#RESOURCES++ // * modifyKeyboard (parameter=1):+ // Normally xterm makes a special case regarding modifiers (shift, control, etc.) to handle special keyboard+ // layouts (legacy and vt220). This is done to provide compatible keyboards for DEC VT220 and related+ // terminals that implement user-defined keys (UDK).+ // The bits of the resource value selectively enable modification of the given category when these keyboards+ // are selected. The default is "0":+ // (0) The legacy/vt220 keyboards interpret only the Control-modifier when constructing numbered+ // function-keys. Other special keys are not modified.+ // (1) allows modification of the numeric keypad+ // (2) allows modification of the editing keypad+ // (4) allows modification of function-keys, overrides use of Shift-modifier for UDK.+ // (8) allows modification of other special keys++ // * modifyCursorKeys (parameter=2):+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a+ // parameter to the escape sequence returned by a cursor-key. The default is "2".+ // - Set it to -1 to disable it.+ // - Set it to 0 to use the old/obsolete behavior.+ // - Set it to 1 to prefix modified sequences with CSI.+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.++ // * modifyFunctionKeys (parameter=3):+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a+ // parameter to the escape sequence returned by a (numbered) function-+ // key. The default is "2". The resource values are similar to modifyCursorKeys:+ // Set it to -1 to permit the user to use shift- and control-modifiers to construct function-key strings+ // using the normal encoding scheme.+ // - Set it to 0 to use the old/obsolete behavior.+ // - Set it to 1 to prefix modified sequences with CSI.+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.+ // If modifyFunctionKeys is zero, xterm uses Control- and Shift-modifiers to allow the user to construct+ // numbered function-keys beyond the set provided by the keyboard:+ // (Control) adds the value given by the ctrlFKeys resource.+ // (Shift) adds twice the value given by the ctrlFKeys resource.+ // (Control/Shift) adds three times the value given by the ctrlFKeys resource.+ //+ // As a special case, legacy (when oldFunctionKeys is true) or vt220 (when sunKeyboard is true)+ // keyboards interpret only the Control-modifier when constructing numbered function-keys.+ // This is done to provide compatible keyboards for DEC VT220 and related terminals that+ // implement user-defined keys (UDK).++ // * modifyOtherKeys (parameter=4):+ // Like modifyCursorKeys, tells xterm to construct an escape sequence for other keys (such as "2") when+ // modified by Control-, Alt- or Meta-modifiers. This feature does not apply to function keys and+ // well-defined keys such as ESC or the control keys. The default is "0".+ // (0) disables this feature.+ // (1) enables this feature for keys except for those with well-known behavior, e.g., Tab, Backarrow and+ // some special control character cases, e.g., Control-Space to make a NUL.+ // (2) enables this feature for keys including the exceptions listed.+ Logger.logError(mClient, LOG_TAG, "(ignored) CSI > MODIFY RESOURCE: " + getArg0(-1) + " to " + getArg1(-1));+ break;+ default:+ parseArg(b);+ break;+ }+ }++ private void startEscapeSequence() {+ mEscapeState = ESC;+ mArgIndex = 0;+ Arrays.fill(mArgs, -1);+ mArgsSubParamsBitSet = 0;+ }++ private void doLinefeed() {+ boolean belowScrollingRegion = mCursorRow >= mBottomMargin;+ int newCursorRow = mCursorRow + 1;+ if (belowScrollingRegion) {+ // Move down (but not scroll) as long as we are above the last row.+ if (mCursorRow != mRows - 1) {+ setCursorRow(newCursorRow);+ }+ } else {+ if (newCursorRow == mBottomMargin) {+ scrollDownOneLine();+ newCursorRow = mBottomMargin - 1;+ }+ setCursorRow(newCursorRow);+ }+ }++ private void continueSequence(int state) {+ mEscapeState = state;+ mContinueSequence = true;+ }++ private void doEscPound(int b) {+ switch (b) {+ case '8': // Esc # 8 - DEC screen alignment test - fill screen with E's.+ mScreen.blockSet(0, 0, mColumns, mRows, 'E', getStyle());+ break;+ default:+ unknownSequence(b);+ break;+ }+ }++ /** Encountering a character in the {@link #ESC} state. */+ private void doEsc(int b) {+ switch (b) {+ case '#':+ continueSequence(ESC_POUND);+ break;+ case '(':+ continueSequence(ESC_SELECT_LEFT_PAREN);+ break;+ case ')':+ continueSequence(ESC_SELECT_RIGHT_PAREN);+ break;+ case '6': // Back index (http://www.vt100.net/docs/vt510-rm/DECBI). Move left, insert blank column if start.+ if (mCursorCol > mLeftMargin) {+ mCursorCol--;+ } else {+ int rows = mBottomMargin - mTopMargin;+ mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin + 1, mTopMargin);+ mScreen.blockSet(mLeftMargin, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));+ }+ break;+ case '7': // DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC+ saveCursor();+ break;+ case '8': // DECRC restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC+ restoreCursor();+ break;+ case '9': // Forward Index (http://www.vt100.net/docs/vt510-rm/DECFI). Move right, insert blank column if end.+ if (mCursorCol < mRightMargin - 1) {+ mCursorCol++;+ } else {+ int rows = mBottomMargin - mTopMargin;+ mScreen.blockCopy(mLeftMargin + 1, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin, mTopMargin);+ mScreen.blockSet(mRightMargin - 1, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));+ }+ break;+ case 'c': // RIS - Reset to Initial State (http://vt100.net/docs/vt510-rm/RIS).+ reset();+ mMainBuffer.clearTranscript();+ blockClear(0, 0, mColumns, mRows);+ setCursorPosition(0, 0);+ break;+ case 'D': // INDEX+ doLinefeed();+ break;+ case 'E': // Next line (http://www.vt100.net/docs/vt510-rm/NEL).+ setCursorCol(isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) ? mLeftMargin : 0);+ doLinefeed();+ break;+ case 'F': // Cursor to lower-left corner of screen+ setCursorRowCol(0, mBottomMargin - 1);+ break;+ case 'H': // Tab set+ mTabStop[mCursorCol] = true;+ break;+ case 'M': // "${ESC}M" - reverse index (RI).+ // http://www.vt100.net/docs/vt100-ug/chapter3.html: "Move the active position to the same horizontal+ // position on the preceding line. If the active position is at the top margin, a scroll down is performed".+ if (mCursorRow <= mTopMargin) {+ mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, mBottomMargin - (mTopMargin + 1), mLeftMargin, mTopMargin + 1);+ blockClear(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin);+ } else {+ mCursorRow--;+ }+ break;+ case 'N': // SS2, ignore.+ case '0': // SS3, ignore.+ break;+ case 'P': // Device control string+ clearTerminalControlArgs();+ clearDcsTypeVariables();+ continueSequence(ESC_DCS);+ break;+ case '[':+ continueSequence(ESC_CSI);+ break;+ case '=': // DECKPAM+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, true);+ break;+ case ']': // OSC+ clearTerminalControlArgs();+ clearOscTypeVariables();+ continueSequence(ESC_OSC);+ break;+ case '>': // DECKPNM+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, false);+ break;+ case '_': // APC - Application Program Command.+ clearTerminalControlArgs();+ continueSequence(ESC_APC);+ break;+ default:+ unknownSequence(b);+ break;+ }+ }++ /** DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC . See {@link #restoreCursor()}. */+ private void saveCursor() {+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;+ state.mSavedCursorRow = mCursorRow;+ state.mSavedCursorCol = mCursorCol;+ state.mSavedEffect = mEffect;+ state.mSavedForeColor = mForeColor;+ state.mSavedBackColor = mBackColor;+ state.mSavedDecFlags = mCurrentDecSetFlags;+ state.mUseLineDrawingG0 = mUseLineDrawingG0;+ state.mUseLineDrawingG1 = mUseLineDrawingG1;+ state.mUseLineDrawingUsesG0 = mUseLineDrawingUsesG0;+ }++ /** DECRS restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC. See {@link #saveCursor()}. */+ private void restoreCursor() {+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;+ setCursorRowCol(state.mSavedCursorRow, state.mSavedCursorCol);+ mEffect = state.mSavedEffect;+ mForeColor = state.mSavedForeColor;+ mBackColor = state.mSavedBackColor;+ int mask = (DECSET_BIT_AUTOWRAP | DECSET_BIT_ORIGIN_MODE);+ mCurrentDecSetFlags = (mCurrentDecSetFlags & ~mask) | (state.mSavedDecFlags & mask);+ mUseLineDrawingG0 = state.mUseLineDrawingG0;+ mUseLineDrawingG1 = state.mUseLineDrawingG1;+ mUseLineDrawingUsesG0 = state.mUseLineDrawingUsesG0;+ }++ /** Following a CSI - Control Sequence Introducer, "\033[". {@link #ESC_CSI}. */+ private void doCsi(int b) {+ switch (b) {+ case '!':+ continueSequence(ESC_CSI_EXCLAMATION);+ break;+ case '"':+ continueSequence(ESC_CSI_DOUBLE_QUOTE);+ break;+ case '\'':+ continueSequence(ESC_CSI_SINGLE_QUOTE);+ break;+ case '$':+ continueSequence(ESC_CSI_DOLLAR);+ break;+ case '*':+ continueSequence(ESC_CSI_ARGS_ASTERIX);+ break;+ case '@': {+ // "CSI{n}@" - Insert ${n} space characters (ICH) - http://www.vt100.net/docs/vt510-rm/ICH.+ mAboutToAutoWrap = false;+ int columnsAfterCursor = mColumns - mCursorCol;+ int spacesToInsert = Math.min(getArg0(1), columnsAfterCursor);+ int charsToMove = columnsAfterCursor - spacesToInsert;+ mScreen.blockCopy(mCursorCol, mCursorRow, charsToMove, 1, mCursorCol + spacesToInsert, mCursorRow);+ blockClear(mCursorCol, mCursorRow, spacesToInsert);+ }+ break;+ case 'A': // "CSI${n}A" - Cursor up (CUU) ${n} rows.+ setCursorRow(Math.max(0, mCursorRow - getArg0(1)));+ break;+ case 'B': // "CSI${n}B" - Cursor down (CUD) ${n} rows.+ setCursorRow(Math.min(mRows - 1, mCursorRow + getArg0(1)));+ break;+ case 'C': // "CSI${n}C" - Cursor forward (CUF).+ case 'a': // "CSI${n}a" - Horizontal position relative (HPR). From ISO-6428/ECMA-48.+ setCursorCol(Math.min(mRightMargin - 1, mCursorCol + getArg0(1)));+ break;+ case 'D': // "CSI${n}D" - Cursor backward (CUB) ${n} columns.+ setCursorCol(Math.max(mLeftMargin, mCursorCol - getArg0(1)));+ break;+ case 'E': // "CSI{n}E - Cursor Next Line (CNL). From ISO-6428/ECMA-48.+ setCursorPosition(0, mCursorRow + getArg0(1));+ break;+ case 'F': // "CSI{n}F - Cursor Previous Line (CPL). From ISO-6428/ECMA-48.+ setCursorPosition(0, mCursorRow - getArg0(1));+ break;+ case 'G': // "CSI${n}G" - Cursor horizontal absolute (CHA) to column ${n}.+ setCursorCol(Math.min(Math.max(1, getArg0(1)), mColumns) - 1);+ break;+ case 'H': // "${CSI}${ROW};${COLUMN}H" - Cursor position (CUP).+ case 'f': // "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP).+ setCursorPosition(getArg1(1) - 1, getArg0(1) - 1);+ break;+ case 'I': // Cursor Horizontal Forward Tabulation (CHT). Move the active position n tabs forward.+ setCursorCol(nextTabStop(getArg0(1)));+ break;+ case 'J': // "${CSI}${0,1,2,3}J" - Erase in Display (ED)+ // ED ignores the scrolling margins.+ switch (getArg0(0)) {+ case 0: // Erase from the active position to the end of the screen, inclusive (default).+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);+ blockClear(0, mCursorRow + 1, mColumns, mRows - (mCursorRow + 1));+ break;+ case 1: // Erase from start of the screen to the active position, inclusive.+ blockClear(0, 0, mColumns, mCursorRow);+ blockClear(0, mCursorRow, mCursorCol + 1);+ break;+ case 2: // Erase all of the display - all lines are erased, changed to single-width, and the cursor does not+ // move..+ blockClear(0, 0, mColumns, mRows);+ break;+ case 3: // Delete all lines saved in the scrollback buffer (xterm etc)+ mMainBuffer.clearTranscript();+ break;+ default:+ unknownSequence(b);+ return;+ }+ mAboutToAutoWrap = false;+ break;+ case 'K': // "CSI{n}K" - Erase in line (EL).+ switch (getArg0(0)) {+ case 0: // Erase from the cursor to the end of the line, inclusive (default)+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);+ break;+ case 1: // Erase from the start of the screen to the cursor, inclusive.+ blockClear(0, mCursorRow, mCursorCol + 1);+ break;+ case 2: // Erase all of the line.+ blockClear(0, mCursorRow, mColumns);+ break;+ default:+ unknownSequence(b);+ return;+ }+ mAboutToAutoWrap = false;+ break;+ case 'L': // "${CSI}{N}L" - insert ${N} lines (IL).+ {+ int linesAfterCursor = mBottomMargin - mCursorRow;+ int linesToInsert = Math.min(getArg0(1), linesAfterCursor);+ int linesToMove = linesAfterCursor - linesToInsert;+ mScreen.blockCopy(0, mCursorRow, mColumns, linesToMove, 0, mCursorRow + linesToInsert);+ blockClear(0, mCursorRow, mColumns, linesToInsert);+ }+ break;+ case 'M': // "${CSI}${N}M" - delete N lines (DL).+ {+ mAboutToAutoWrap = false;+ int linesAfterCursor = mBottomMargin - mCursorRow;+ int linesToDelete = Math.min(getArg0(1), linesAfterCursor);+ int linesToMove = linesAfterCursor - linesToDelete;+ mScreen.blockCopy(0, mCursorRow + linesToDelete, mColumns, linesToMove, 0, mCursorRow);+ blockClear(0, mCursorRow + linesToMove, mColumns, linesToDelete);+ }+ break;+ case 'P': // "${CSI}{N}P" - delete ${N} characters (DCH).+ {+ // http://www.vt100.net/docs/vt510-rm/DCH: "If ${N} is greater than the number of characters between the+ // cursor and the right margin, then DCH only deletes the remaining characters.+ // As characters are deleted, the remaining characters between the cursor and right margin move to the left.+ // Character attributes move with the characters. The terminal adds blank spaces with no visual character+ // attributes at the right margin. DCH has no effect outside the scrolling margins."+ mAboutToAutoWrap = false;+ int cellsAfterCursor = mColumns - mCursorCol;+ int cellsToDelete = Math.min(getArg0(1), cellsAfterCursor);+ int cellsToMove = cellsAfterCursor - cellsToDelete;+ mScreen.blockCopy(mCursorCol + cellsToDelete, mCursorRow, cellsToMove, 1, mCursorCol, mCursorRow);+ blockClear(mCursorCol + cellsToMove, mCursorRow, cellsToDelete);+ }+ break;+ case 'S': { // "${CSI}${N}S" - scroll up ${N} lines (default = 1) (SU).+ final int linesToScroll = getArg0(1);+ for (int i = 0; i < linesToScroll; i++)+ scrollDownOneLine();+ break;+ }+ case 'T':+ if (mArgIndex == 0) {+ // "${CSI}${N}T" - Scroll down N lines (default = 1) (SD).+ // http://vt100.net/docs/vt510-rm/SD: "N is the number of lines to move the user window up in page+ // memory. N new lines appear at the top of the display. N old lines disappear at the bottom of the+ // display. You cannot pan past the top margin of the current page".+ final int linesToScrollArg = getArg0(1);+ final int linesBetweenTopAndBottomMargins = mBottomMargin - mTopMargin;+ final int linesToScroll = Math.min(linesBetweenTopAndBottomMargins, linesToScrollArg);+ mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, linesBetweenTopAndBottomMargins - linesToScroll, mLeftMargin, mTopMargin + linesToScroll);+ blockClear(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, linesToScroll);+ } else {+ // "${CSI}${func};${startx};${starty};${firstrow};${lastrow}T" - initiate highlight mouse tracking.+ unimplementedSequence(b);+ }+ break;+ case 'X': // "${CSI}${N}X" - Erase ${N:=1} character(s) (ECH). FIXME: Clears character attributes?+ mAboutToAutoWrap = false;+ mScreen.blockSet(mCursorCol, mCursorRow, Math.min(getArg0(1), mColumns - mCursorCol), 1, ' ', getStyle());+ break;+ case 'Z': // Cursor Backward Tabulation (CBT). Move the active position n tabs backward.+ int numberOfTabs = getArg0(1);+ int newCol = mLeftMargin;+ for (int i = mCursorCol - 1; i >= 0; i--)+ if (mTabStop[i]) {+ if (--numberOfTabs == 0) {+ newCol = Math.max(i, mLeftMargin);+ break;+ }+ }+ mCursorCol = newCol;+ break;+ case '?': // Esc [ ? -- start of a private parameter byte+ continueSequence(ESC_CSI_QUESTIONMARK);+ break;+ case '>': // "Esc [ >" -- start of a private parameter byte+ continueSequence(ESC_CSI_BIGGERTHAN);+ break;+ case '<': // "Esc [ <" -- start of a private parameter byte+ case '=': // "Esc [ =" -- start of a private parameter byte+ continueSequence(ESC_CSI_UNSUPPORTED_PARAMETER_BYTE);+ break;+ case '`': // Horizontal position absolute (HPA - http://www.vt100.net/docs/vt510-rm/HPA).+ setCursorColRespectingOriginMode(getArg0(1) - 1);+ break;+ case 'b': // Repeat the preceding graphic character Ps times (REP).+ if (mLastEmittedCodePoint == -1) break;+ final int numRepeat = getArg0(1);+ for (int i = 0; i < numRepeat; i++) emitCodePoint(mLastEmittedCodePoint);+ break;+ case 'c': // Primary Device Attributes (http://www.vt100.net/docs/vt510-rm/DA1) if argument is missing or zero.+ // The important part that may still be used by some (tmux stores this value but does not currently use it)+ // is the first response parameter identifying the terminal service class, where we send 64 for "vt420".+ // This is followed by a list of attributes which is probably unused by applications. Send like xterm.+ if (getArg0(0) == 0) mSession.write("\033[?64;1;2;4;6;9;15;18;21;22c");+ break;+ case 'd': // ESC [ Pn d - Vert Position Absolute+ setCursorRow(Math.min(Math.max(1, getArg0(1)), mRows) - 1);+ break;+ case 'e': // Vertical Position Relative (VPR). From ISO-6429 (ECMA-48).+ setCursorPosition(mCursorCol, mCursorRow + getArg0(1));+ break;+ // case 'f': "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP). Grouped with case 'H'.+ case 'g': // Clear tab stop+ switch (getArg0(0)) {+ case 0:+ mTabStop[mCursorCol] = false;+ break;+ case 3:+ for (int i = 0; i < mColumns; i++) {+ mTabStop[i] = false;+ }+ break;+ default:+ // Specified to have no effect.+ break;+ }+ break;+ case 'h': // Set Mode+ doSetMode(true);+ break;+ case 'l': // Reset Mode+ doSetMode(false);+ break;+ case 'm': // Esc [ Pn m - character attributes. (can have up to 16 numerical arguments)+ selectGraphicRendition();+ break;+ case 'n': // Esc [ Pn n - ECMA-48 Status Report Commands+ // sendDeviceAttributes()+ switch (getArg0(0)) {+ case 5: // Device status report (DSR):+ // Answer is ESC [ 0 n (Terminal OK).+ byte[] dsr = {(byte) 27, (byte) '[', (byte) '0', (byte) 'n'};+ mSession.write(dsr, 0, dsr.length);+ break;+ case 6: // Cursor position report (CPR):+ // Answer is ESC [ y ; x R, where x,y is+ // the cursor location.+ mSession.write(String.format(Locale.US, "\033[%d;%dR", mCursorRow + 1, mCursorCol + 1));+ break;+ default:+ break;+ }+ break;+ case 'r': // "CSI${top};${bottom}r" - set top and bottom Margins (DECSTBM).+ {+ // https://vt100.net/docs/vt510-rm/DECSTBM.html+ // The top margin defaults to 1, the bottom margin defaults to mRows.+ // The escape sequence numbers top 1..23, but we number top 0..22.+ // The escape sequence numbers bottom 2..24, and so do we (because we use a zero based numbering+ // scheme, but we store the first line below the bottom-most scrolling line.+ // As a result, we adjust the top line by -1, but we leave the bottom line alone.+ // Also require that top + 2 <= bottom.+ mTopMargin = Math.max(0, Math.min(getArg0(1) - 1, mRows - 2));+ mBottomMargin = Math.max(mTopMargin + 2, Math.min(getArg1(mRows), mRows));++ // DECSTBM moves the cursor to column 1, line 1 of the page respecting origin mode.+ setCursorPosition(0, 0);+ }+ break;+ case 's':+ if (isDecsetInternalBitSet(DECSET_BIT_LEFTRIGHT_MARGIN_MODE)) {+ // Set left and right margins (DECSLRM - http://www.vt100.net/docs/vt510-rm/DECSLRM).+ mLeftMargin = Math.min(getArg0(1) - 1, mColumns - 2);+ mRightMargin = Math.max(mLeftMargin + 1, Math.min(getArg1(mColumns), mColumns));+ // DECSLRM moves the cursor to column 1, line 1 of the page.+ setCursorPosition(0, 0);+ } else {+ // Save cursor (ANSI.SYS), available only when DECLRMM is disabled.+ saveCursor();+ }+ break;+ case 't': // Window manipulation (from dtterm, as well as extensions)+ switch (getArg0(0)) {+ case 11: // Report xterm window state. If the xterm window is open (non-iconified), it returns CSI 1 t .+ mSession.write("\033[1t");+ break;+ case 13: // Report xterm window position. Result is CSI 3 ; x ; y t+ mSession.write("\033[3;0;0t");+ break;+ case 14: // Report xterm window in pixels. Result is CSI 4 ; height ; width t+ mSession.write(String.format(Locale.US, "\033[4;%d;%dt", mRows * mCellHeightPixels, mColumns * mCellWidthPixels));+ break;+ case 16: // Report xterm character cell size in pixels. Result is CSI 6 ; height ; width t+ mSession.write(String.format(Locale.US, "\033[6;%d;%dt", mCellHeightPixels, mCellWidthPixels));+ break;+ case 18: // Report the size of the text area in characters. Result is CSI 8 ; height ; width t+ mSession.write(String.format(Locale.US, "\033[8;%d;%dt", mRows, mColumns));+ break;+ case 19: // Report the size of the screen in characters. Result is CSI 9 ; height ; width t+ // We report the same size as the view, since it's the view really isn't resizable from the shell.+ mSession.write(String.format(Locale.US, "\033[9;%d;%dt", mRows, mColumns));+ break;+ case 20: // Report xterm windows icon label. Result is OSC L label ST. Disabled due to security concerns:+ mSession.write("\033]LIconLabel\033\\");+ break;+ case 21: // Report xterm windows title. Result is OSC l label ST. Disabled due to security concerns:+ mSession.write("\033]l\033\\");+ break;+ case 22:+ // 22;0 -> Save xterm icon and window title on stack.+ // 22;1 -> Save xterm icon title on stack.+ // 22;2 -> Save xterm window title on stack.+ mTitleStack.push(mTitle);+ if (mTitleStack.size() > 20) {+ // Limit size+ mTitleStack.remove(0);+ }+ break;+ case 23: // Like 22 above but restore from stack.+ if (!mTitleStack.isEmpty()) setTitle(mTitleStack.pop());+ break;+ default:+ // Ignore window manipulation.+ break;+ }+ break;+ case 'u': // Restore cursor (ANSI.SYS).+ restoreCursor();+ break;+ case ' ':+ continueSequence(ESC_CSI_ARGS_SPACE);+ break;+ default:+ parseArg(b);+ break;+ }+ }++ /** Select Graphic Rendition (SGR) - see http://en.wikipedia.org/wiki/ANSI_escape_code#graphics. */+ private void selectGraphicRendition() {+ if (mArgIndex >= mArgs.length) mArgIndex = mArgs.length - 1;+ for (int i = 0; i <= mArgIndex; i++) {+ // Skip leading sub parameters:+ if ((mArgsSubParamsBitSet & (1 << i)) != 0) {+ continue;+ }++ int code = getArg(i, 0, false);+ if (code < 0) {+ if (mArgIndex > 0) {+ continue;+ } else {+ code = 0;+ }+ }+ if (code == 0) { // reset+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;+ mEffect = 0;+ } else if (code == 1) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BOLD;+ } else if (code == 2) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_DIM;+ } else if (code == 3) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_ITALIC;+ } else if (code == 4) {+ if (i + 1 <= mArgIndex && ((mArgsSubParamsBitSet & (1 << (i + 1))) != 0)) {+ // Sub parameter, see https://sw.kovidgoyal.net/kitty/underlines/+ i++;+ if (mArgs[i] == 0) {+ // No underline.+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ } else {+ // Different variations of underlines: https://sw.kovidgoyal.net/kitty/underlines/+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ }+ } else {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ }+ } else if (code == 5) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BLINK;+ } else if (code == 7) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVERSE;+ } else if (code == 8) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;+ } else if (code == 9) {+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;+ } else if (code == 10) {+ // Exit alt charset (TERM=linux) - ignore.+ } else if (code == 11) {+ // Enter alt charset (TERM=linux) - ignore.+ } else if (code == 22) { // Normal color or intensity, neither bright, bold nor faint.+ mEffect &= ~(TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_DIM);+ } else if (code == 23) { // not italic, but rarely used as such; clears standout with TERM=screen+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_ITALIC;+ } else if (code == 24) { // underline: none+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ } else if (code == 25) { // blink: none+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_BLINK;+ } else if (code == 27) { // image: positive+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVERSE;+ } else if (code == 28) {+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;+ } else if (code == 29) {+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;+ } else if (code >= 30 && code <= 37) {+ mForeColor = code - 30;+ } else if (code == 38 || code == 48 || code == 58) {+ // Extended set foreground(38)/background(48)/underline(58) color.+ // This is followed by either "2;$R;$G;$B" to set a 24-bit color or+ // "5;$INDEX" to set an indexed color.+ if (i + 2 > mArgIndex) continue;+ int firstArg = mArgs[i + 1];+ if (firstArg == 2) {+ if (i + 4 > mArgIndex) {+ Logger.logWarn(mClient, LOG_TAG, "Too few CSI" + code + ";2 RGB arguments");+ } else {+ int red = getArg(i + 2, 0, false);+ int green = getArg(i + 3, 0, false);+ int blue = getArg(i + 4, 0, false);++ if (red < 0 || green < 0 || blue < 0 || red > 255 || green > 255 || blue > 255) {+ finishSequenceAndLogError("Invalid RGB: " + red + "," + green + "," + blue);+ } else {+ int argbColor = 0xff_00_00_00 | (red << 16) | (green << 8) | blue;+ switch (code) {+ case 38: mForeColor = argbColor; break;+ case 48: mBackColor = argbColor; break;+ case 58: mUnderlineColor = argbColor; break;+ }+ }+ i += 4; // "2;P_r;P_g;P_r"+ }+ } else if (firstArg == 5) {+ int color = getArg(i + 2, 0, false);+ i += 2; // "5;P_s"+ if (color >= 0 && color < TextStyle.NUM_INDEXED_COLORS) {+ switch (code) {+ case 38: mForeColor = color; break;+ case 48: mBackColor = color; break;+ case 58: mUnderlineColor = color; break;+ }+ } else {+ if (LOG_ESCAPE_SEQUENCES) Logger.logWarn(mClient, LOG_TAG, "Invalid color index: " + color);+ }+ } else {+ finishSequenceAndLogError("Invalid ISO-8613-3 SGR first argument: " + firstArg);+ }+ } else if (code == 39) { // Set default foreground color.+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;+ } else if (code >= 40 && code <= 47) { // Set background color.+ mBackColor = code - 40;+ } else if (code == 49) { // Set default background color.+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;+ } else if (code == 59) { // Set default underline color.+ mUnderlineColor = TextStyle.COLOR_INDEX_FOREGROUND;+ } else if (code >= 90 && code <= 97) { // Bright foreground colors (aixterm codes).+ mForeColor = code - 90 + 8;+ } else if (code >= 100 && code <= 107) { // Bright background color (aixterm codes).+ mBackColor = code - 100 + 8;+ } else {+ if (LOG_ESCAPE_SEQUENCES)+ Logger.logWarn(mClient, LOG_TAG, String.format("SGR unknown code %d", code));+ }+ }+ }++++ /**+ * Receive {@link #ESC_APC}. Check its docs for more info.+ */+ private void receiveApc(final int b) {+ switch (b) {+ case 27: // Escape.+ continueSequence(ESC_APC__ESC);+ break;+ default:+ // Kitty graphics chunks can be 4–64 KB each; raise the cap as soon as we+ // detect `\e_G…`. 1 MB ceiling keeps a malicious or runaway payload from+ // exhausting memory.+ if (mTerminalControlArgs.length() == 0 && b == 'G') {+ setTerminalControlArgsMaxLength(1024 * 1024);+ }+ if (!collectTerminalControlArgs(b)) return;+ }+ }++ /**+ * Receive {@link #ESC_APC__ESC}. Check its docs for more info.+ */+ private void receiveApcEsc(final int b) {+ switch (b) {+ case '\\':+ doApc();+ clearTerminalControlArgs();+ finishSequence();+ break;+ default:+ // The ESC character was not followed by a \, so insert the ESC and+ // the current character in arg buffer.+ if (!collectTerminalControlArgs(27)) return;+ if (!collectTerminalControlArgs(b)) return;+ continueSequence(ESC_APC);+ break;+ }+ }++ /**+ * APC dispatcher. Currently only Kitty graphics (`G…`) is recognized.+ * Format: `\e_G<key>=<value>,<key>=<value>,...; <base64-payload> \e\`+ * Multi-chunk: `m=1` more coming, `m=0` (or absent) last chunk.+ */+ private void doApc() {+ String args = mTerminalControlArgs.toString();+ if (args.isEmpty() || args.charAt(0) != 'G') return;++ int sep = args.indexOf(';');+ String header = sep >= 0 ? args.substring(1, sep) : args.substring(1);+ String payload = sep >= 0 ? args.substring(sep + 1) : "";++ // First chunk seeds defaults; continuation chunks (m=1/m=0) only carry `m=`,+ // so any key not present preserves its prior value.+ boolean firstChunk = (mKittyB64Accumulator == null);+ if (firstChunk) {+ mKittyAction = 'T'; // spec default+ mKittyFormat = 32; // spec default (RGBA) — we only handle 100 (PNG)+ mKittyTransport = 'd'; // spec default+ mKittyCols = 0;+ mKittyRows = 0;+ }+ boolean moreChunks = false;+ for (String pair : header.split(",")) {+ int eq = pair.indexOf('=');+ if (eq <= 0) continue;+ String key = pair.substring(0, eq);+ String val = pair.substring(eq + 1);+ switch (key) {+ case "a": if (!val.isEmpty()) mKittyAction = val.charAt(0); break;+ case "f": try { mKittyFormat = Integer.parseInt(val); } catch (Exception e) {} break;+ case "t": if (!val.isEmpty()) mKittyTransport = val.charAt(0); break;+ case "c": try { mKittyCols = Integer.parseInt(val); } catch (Exception e) {} break;+ case "r": try { mKittyRows = Integer.parseInt(val); } catch (Exception e) {} break;+ case "m": moreChunks = "1".equals(val); break;+ default: break;+ }+ }++ // Only "transmit and display" with PNG via base64-direct is supported.+ if (mKittyAction != 'T' || mKittyFormat != 100 || mKittyTransport != 'd') {+ mKittyB64Accumulator = null;+ return;+ }++ if (mKittyB64Accumulator == null) mKittyB64Accumulator = new StringBuilder();+ mKittyB64Accumulator.append(payload);++ if (moreChunks) return; // wait for more++ // Final chunk: decode + place via the existing iTerm/byte-array path.+ try {+ byte[] png = android.util.Base64.decode(mKittyB64Accumulator.toString(),+ android.util.Base64.DEFAULT);+ // Convert cell-count display dims to pixel dims if specified.+ int displayW = mKittyCols > 0 ? mKittyCols * mCellWidthPixels : 0;+ int displayH = mKittyRows > 0 ? mKittyRows * mCellHeightPixels : 0;+ int[] cursorDelta = mScreen.addTerminalBitmapForImage(+ png, mCursorCol, mCursorRow,+ mCellWidthPixels, mCellHeightPixels,+ displayW, displayH, /* preserveAspectRatio */ true);+ // cursorDelta[0]=column delta, cursorDelta[1]=row delta — emit linefeeds for vertical advance.+ for (int i = 0; i < cursorDelta[1]; i++) doLinefeed();+ if (cursorDelta[0] != 0) {+ mCursorCol = Math.min(mCursorCol + cursorDelta[0], mColumns - 1);+ }+ } catch (Throwable t) {+ Logger.logError(mClient, LOG_TAG, "Kitty graphics decode failed: " + t.getMessage());+ } finally {+ mKittyB64Accumulator = null;+ }+ }++ /**+ * Clear {@link #ESC_APC} type variables.+ */+ public void clearApcTypeVariables() {}++ // Real doApc() implementation lives at line ~2670 (Kitty graphics handler).+++++ /**+ * Receive {@link #ESC_OSC}. Check its docs for more info.+ */+ private void receiveOsc(final int b) {+ switch (b) {+ case 7: // Bell.+ doOsc("\007");+ clearOscTypeVariables();+ break;+ case 27: // Escape.+ continueSequence(ESC_OSC__ESC);+ break;+ default:+ if (!collectTerminalControlArgs(b)) return;+ if (mOscType == -1) {+ setOscTypeVariables();+ }+ break;+ }+ }++ /**+ * Receive {@link #ESC_OSC__ESC}. Check its docs for more info.+ */+ private void receiveOscEsc(final int b) {+ switch (b) {+ case '\\':+ doOsc("\033\\");+ clearOscTypeVariables();+ break;+ default:+ // The ESC character was not followed by a \, so insert the ESC and+ // the current character in arg buffer.+ if (!collectTerminalControlArgs(27)) return;+ if (!collectTerminalControlArgs(b)) return;+ continueSequence(ESC_OSC);+ break;+ }+ }++ /**+ * Set {@link #ESC_OSC} type variables.+ */+ void setOscTypeVariables() {+ if (mOscType >= 0) return;+ if (mTerminalControlArgs.indexOf(":") < 0) return;++ int value = -1;+ int argsLength = mTerminalControlArgs.length();++ // Extract initial $value from initial "$value;..." string.+ for (int i = 0; i < argsLength; i++) {+ char b = mTerminalControlArgs.charAt(i);+ if (b == ';') {+ mOscType = value;+ break;+ } else if (b >= '0' && b <= '9') {+ value = ((value < 0) ? 0 : value * 10) + (b - '0');+ } else {+ mOscType = -2; // Unknown sequence.+ return;+ }+ }++ if (mOscType >= 0) {+ Integer terminalControlArgsCapacity = null;+ Integer terminalControlArgsMaxLength = null;+ switch (mOscType) {+ case 52:+ // Android has a `~100KB` limit for sharing/sending `UTF-16` encoded `String`+ // with binder tranasactions, including clipboard, otherwise can result in a+ // `TransactionTooLargeException`.+ // - https://www.reddit.com/r/tasker/comments/prro8t/autoshare_crashed_when_i_pasted_the_file_path/+ terminalControlArgsMaxLength = (100 * 1024) ++ /* `52;Pc;` */ 10;+ break;+ case 1337: // iTerm image command sends the base64 encoded image, do not run complex logic for each byte.+ mIsFastPathOsc = true;+ mIgnoreCrLfForOsc = true;+ // Expect large amount of data for image bytes.+ // `imgcat` utility splits image bytes into 200-byte chunks when sending with `FilePart=` commands.+ // - https://github.com/gnachman/iTerm2-shell-integration/blob/d1d4012068c3c6761d5676c28ed73e0e2df2b715/utilities/imgcat#L89+ // > Older versions of tmux have a limit of 256 bytes for the entire sequence.+ // - https://iterm2.com/documentation-images.html+ terminalControlArgsCapacity = 256;+ terminalControlArgsMaxLength = TerminalBitmap.MAX_BITMAP_SIZE ++ /* `1337;File=inline=1;size=209715200;name=xxxxxxxxxxxxxxxxxxxxxxxx;width=8192px;height=8192px;preserveAspectRatio=1:` */ 150;+ break;+ }++ if (terminalControlArgsCapacity != null) {+ ensureTerminalControlArgsCapacity(terminalControlArgsCapacity);+ }++ if (terminalControlArgsMaxLength != null) {+ setTerminalControlArgsMaxLength(terminalControlArgsMaxLength);+ }+ }+ }++ /**+ * Clear {@link #ESC_OSC} type variables.+ */+ public void clearOscTypeVariables() {+ mOscType = -1;+ mIsFastPathOsc = false;+ mIgnoreCrLfForOsc = false;+ }++ /**+ * Do {@link #ESC_OSC}. Check its docs for more info.+ *+ * This handles Set Text Parameters commands.+ *+ * The `bellOrStringTerminator` defines whether `OSC` command terminated with a `BEL` or `ST`.+ */+ private void doOsc(String bellOrStringTerminator) {+ int value = -1;+ String textParameter = "";+ int argsLength = mTerminalControlArgs.length();++ // Extract initial $value from initial "$value;..." string.+ for (int i = 0; i < argsLength; i++) {+ char b = mTerminalControlArgs.charAt(i);+ if (b == ';') {+ // Do not make a copy of `mTerminalControlArgs` for lengthy commands.+ if (value != 1337) {+ textParameter = mTerminalControlArgs.substring(i + 1);+ }+ break;+ } else if (b >= '0' && b <= '9') {+ value = ((value < 0) ? 0 : value * 10) + (b - '0');+ } else {+ unknownSequence(b);+ return;+ }+ }++ switch (value) {+ case 0: // Change icon name and window title to T.+ case 1: // Change icon name to T.+ case 2: // Change window title to T.+ setTitle(textParameter);+ break;+ case 4:+ // P s = 4 ; c ; spec → Change Color Number c to the color specified by spec. This can be a name or RGB+ // specification as per XParseColor. Any number of c name pairs may be given. The color numbers correspond+ // to the ANSI colors 0-7, their bright versions 8-15, and if supported, the remainder of the 88-color or+ // 256-color table.+ // If a "?" is given rather than a name or RGB specification, xterm replies with a control sequence of the+ // same form which can be used to set the corresponding color. Because more than one pair of color number+ // and specification can be given in one control sequence, xterm can make more than one reply.+ int colorIndex = -1;+ int parsingPairStart = -1;+ for (int i = 0; ; i++) {+ boolean endOfInput = i == textParameter.length();+ char b = endOfInput ? ';' : textParameter.charAt(i);+ if (b == ';') {+ if (parsingPairStart < 0) {+ parsingPairStart = i + 1;+ } else {+ if (colorIndex < 0 || colorIndex > 255) {+ unknownSequence(b);+ return;+ } else {+ mColors.tryParseColor(colorIndex, textParameter.substring(parsingPairStart, i));+ mSession.onColorsChanged();+ colorIndex = -1;+ parsingPairStart = -1;+ }+ }+ } else if (parsingPairStart >= 0) {+ // We have passed a color index and are now going through color spec.+ } else if (parsingPairStart < 0 && (b >= '0' && b <= '9')) {+ colorIndex = ((colorIndex < 0) ? 0 : colorIndex * 10) + (b - '0');+ } else {+ unknownSequence(b);+ return;+ }+ if (endOfInput) break;+ }+ break;+ case 10: // Set foreground color.+ case 11: // Set background color.+ case 12: // Set cursor color.+ int specialIndex = TextStyle.COLOR_INDEX_FOREGROUND + (value - 10);+ int lastSemiIndex = 0;+ for (int charIndex = 0; ; charIndex++) {+ boolean endOfInput = charIndex == textParameter.length();+ if (endOfInput || textParameter.charAt(charIndex) == ';') {+ try {+ String colorSpec = textParameter.substring(lastSemiIndex, charIndex);+ if ("?".equals(colorSpec)) {+ // Report current color in the same format xterm and gnome-terminal does.+ int rgb = mColors.mCurrentColors[specialIndex];+ int r = (65535 * ((rgb & 0x00FF0000) >> 16)) / 255;+ int g = (65535 * ((rgb & 0x0000FF00) >> 8)) / 255;+ int b = (65535 * ((rgb & 0x000000FF))) / 255;+ mSession.write("\033]" + value + ";rgb:" + String.format(Locale.US, "%04x", r) + "/" + String.format(Locale.US, "%04x", g) + "/"+ + String.format(Locale.US, "%04x", b) + bellOrStringTerminator);+ } else {+ mColors.tryParseColor(specialIndex, colorSpec);+ mSession.onColorsChanged();+ }+ specialIndex++;+ if (endOfInput || (specialIndex > TextStyle.COLOR_INDEX_CURSOR) || ++charIndex >= textParameter.length())+ break;+ lastSemiIndex = charIndex;+ } catch (NumberFormatException e) {+ // Ignore.+ }+ }+ }+ break;+ case 8: {+ // OSC 8 hyperlink — `\e]8;<params>;<url>\e\` opens, `\e]8;;\e\` closes.+ // textParameter holds `<params>;<url>` (or empty `;` to close).+ int sep = textParameter.indexOf(';');+ String url = sep >= 0 ? textParameter.substring(sep + 1) : "";+ if (url.isEmpty()) {+ mScreen.endHyperlink(mCursorRow, mCursorCol);+ } else {+ mScreen.beginHyperlink(url, mCursorRow, mCursorCol);+ }+ break;+ }+ case 52: // Manipulate Selection Data. Skip the optional first selection parameter(s).+ int startIndex = textParameter.indexOf(";") + 1;+ try {+ String clipboardText = new String(Base64.decode(textParameter.substring(startIndex), Base64.DEFAULT), StandardCharsets.UTF_8);+ mSession.onCopyTextToClipboard(clipboardText);+ } catch (Exception e) {+ Logger.logError(mClient, LOG_TAG, "OSC Manipulate selection, invalid string '" + textParameter + "'");+ }+ break;+ case 104:+ // "104;$c" → Reset Color Number $c. It is reset to the color specified by the corresponding X+ // resource. Any number of c parameters may be given. These parameters correspond to the ANSI colors 0-7,+ // their bright versions 8-15, and if supported, the remainder of the 88-color or 256-color table. If no+ // parameters are given, the entire table will be reset.+ if (textParameter.isEmpty()) {+ mColors.reset();+ mSession.onColorsChanged();+ } else {+ int lastIndex = 0;+ for (int charIndex = 0; ; charIndex++) {+ boolean endOfInput = charIndex == textParameter.length();+ if (endOfInput || textParameter.charAt(charIndex) == ';') {+ try {+ int colorToReset = Integer.parseInt(textParameter.substring(lastIndex, charIndex));+ mColors.reset(colorToReset);+ mSession.onColorsChanged();+ if (endOfInput) break;+ charIndex++;+ lastIndex = charIndex;+ } catch (NumberFormatException e) {+ // Ignore.+ }+ }+ }+ }+ break;+ case 110: // Reset foreground color.+ case 111: // Reset background color.+ case 112: // Reset cursor color.+ mColors.reset(TextStyle.COLOR_INDEX_FOREGROUND + (value - 110));+ mSession.onColorsChanged();+ break;+ case 119: // Reset highlight color.+ break;+ case 1337: // iTerm image+ // - https://iterm2.com/documentation-images.html+ // - https://iterm2.com/documentation-escape-codes.html+ String controlCommandPrefix = mTerminalControlArgs.substring(5, Math.min(19, argsLength));++ if (controlCommandPrefix.startsWith("File=") ||+ controlCommandPrefix.startsWith("MultipartFile=") ||+ controlCommandPrefix.startsWith("FilePart=") ||+ controlCommandPrefix.equals("FileEnd")) {++ ITermImage iTermImage = null;+ boolean oscArgsCleared = false;+ int index;+ // `File = [optional arguments] : base-64 encoded file contents ^G`+ if (controlCommandPrefix.startsWith("File=")) {+ if (mITermImage != null) {+ Logger.logWarn(mClient, LOG_TAG, "A new iTerm 'File' command received while already processing a 'MultipartFile' command");+ mITermImage = null; // Unset old image.+ }++ iTermImage = new ITermImage(mClient, /* multiPart */ false);+ if ((index = iTermImage.readArguments(this, mTerminalControlArgs, /* `1337;File=` */ 10)) < 10 ||+ !iTermImage.readImage(mTerminalControlArgs, index)) {+ iTermImage = null;+ } else {+ // Free image data from memory held in osc command arguments as it is no longer needed.+ clearTerminalControlArgs();+ oscArgsCleared = true;+ if (!iTermImage.decodeImage()) {+ iTermImage = null;+ }+ }+ }+ // `MultipartFile = [optional arguments] ^G`+ else if (controlCommandPrefix.startsWith("MultipartFile=")) {+ if (mITermImage != null) {+ Logger.logWarn(mClient, LOG_TAG, "A new iTerm 'MultipartFile' command received while already processing a 'MultipartFile' command");+ mITermImage = null; // Unset old image.+ }++ iTermImage = new ITermImage(mClient, /* multiPart */ true);+ if (iTermImage.readArguments(this, mTerminalControlArgs, /* `1337;MultipartFile=` */ 19) < 19) {+ iTermImage = null;+ } else {+ mITermImage = iTermImage;+ }+ }+ // `FilePart = base64 encoded file contents ^G`+ else if (controlCommandPrefix.startsWith("FilePart=")) {+ if (mITermImage == null) {+ Logger.logError(mClient, LOG_TAG, "An iTerm 'FilePart' command received without a 'MultipartFile' command preceding it");+ return;+ }++ if (!mITermImage.readImage(mTerminalControlArgs, /* `1337;FilePart=` */ 14)) {+ mITermImage = null;+ }+ }+ // `FileEnd ^G`+ else if (controlCommandPrefix.equals("FileEnd")) {+ if (mITermImage == null) {+ Logger.logError(mClient, LOG_TAG, "An iTerm 'FileEnd' command received without a 'MultipartFile' command preceding it");+ return;+ }++ iTermImage = mITermImage;+ mITermImage = null; // Free global reference so that memory is freed at end function.+ if (+ !iTermImage.setMultiPartImageRead() ||+ !iTermImage.decodeImage()) {+ iTermImage = null;+ }+ }++ // Free image data from memory held in osc command arguments as it is no longer needed.+ if (!oscArgsCleared)+ clearTerminalControlArgs();++ if (iTermImage != null && iTermImage.isImageDecoded()) {+ // Display image as inline in Terminal.+ if (iTermImage.isInline()) {+ int[] cursorDelta = mScreen.addTerminalBitmapForImage(iTermImage.getDecodedImage(),+ mCursorCol, mCursorRow, mCellWidthPixels, mCellHeightPixels,+ iTermImage.getWidth(), iTermImage.getHeight(),+ iTermImage.shouldPreserveAspectRatio());++ int col = cursorDelta[1] + mCursorCol;+ if (col < mColumns - 1) {+ cursorDelta[0] -= 1;+ } else {+ col = 0;+ }+ for (; cursorDelta[0] > 0; cursorDelta[0]--) {+ doLinefeed();+ }+ mCursorCol = col;+ }+ // Saving files in downloads folder is not supported currently.+ else {}+ }+ break;+ } else if (controlCommandPrefix.startsWith("ReportCellSize")) {+ mSession.write(String.format(Locale.ENGLISH, "\0331337;ReportCellSize=%d;%d\007", mCellHeightPixels, mCellWidthPixels));+ }++ // Free image from memory for any non `MultipartFile=` related commands.+ mITermImage = null;+ default:+ unknownParameter(value);+ break;+ }++ // Free image from memory if an incomplete `MultipartFile` command was received without a `FileEnd`.+ // The `mITermImage` cannot set to `null` in `clearOscTypeVariables()` as sequential+ // OSC commands will be received for `MultipartFile` commands, and the variable is required+ // to be set until the final `FileEnd` command is received.+ if (mITermImage != null && value != 1337) {+ mITermImage = null;+ }++ finishSequence();+ }++ private void blockClear(int sx, int sy, int w) {+ blockClear(sx, sy, w, 1);+ }++ private void blockClear(int sx, int sy, int w, int h) {+ mScreen.blockSet(sx, sy, w, h, ' ', getStyle());+ }++ private long getStyle() {+ return TextStyle.encode(mForeColor, mBackColor, mEffect);+ }++ /** "CSI P_m h" for set or "CSI P_m l" for reset ANSI mode. */+ private void doSetMode(boolean newValue) {+ int modeBit = getArg0(0);+ switch (modeBit) {+ case 4: // Set="Insert Mode". Reset="Replace Mode". (IRM).+ mInsertMode = newValue;+ break;+ case 20: // Normal Linefeed (LNM).+ unknownParameter(modeBit);+ // http://www.vt100.net/docs/vt510-rm/LNM+ break;+ case 34:+ // Normal cursor visibility - when using TERM=screen, see+ // http://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html+ break;+ default:+ unknownParameter(modeBit);+ break;+ }+ }++ /**+ * NOTE: The parameters of this function respect the {@link #DECSET_BIT_ORIGIN_MODE}. Use+ * {@link #setCursorRowCol(int, int)} for absolute pos.+ */+ private void setCursorPosition(int x, int y) {+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);+ int effectiveTopMargin = originMode ? mTopMargin : 0;+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;+ int newRow = Math.max(effectiveTopMargin, Math.min(effectiveTopMargin + y, effectiveBottomMargin - 1));+ int newCol = Math.max(effectiveLeftMargin, Math.min(effectiveLeftMargin + x, effectiveRightMargin - 1));+ setCursorRowCol(newRow, newCol);+ }++ private void scrollDownOneLine() {+ mScrollCounter++;+ long currentStyle = getStyle();+ if (mLeftMargin != 0 || mRightMargin != mColumns) {+ // Horizontal margin: Do not put anything into scroll history, just non-margin part of screen up.+ mScreen.blockCopy(mLeftMargin, mTopMargin + 1, mRightMargin - mLeftMargin, mBottomMargin - mTopMargin - 1, mLeftMargin, mTopMargin);+ // .. and blank bottom row between margins:+ mScreen.blockSet(mLeftMargin, mBottomMargin - 1, mRightMargin - mLeftMargin, 1, ' ', currentStyle);+ } else {+ mScreen.scrollDownOneLine(mTopMargin, mBottomMargin, currentStyle);+ }+ }++ /**+ * Process the next ASCII character of a parameter.+ *+ * <p>You must use the ; character to separate parameters and : to separate sub-parameters.+ *+ * <p>Parameter characters modify the action or interpretation of the sequence. Originally+ * you can use up to 16 parameters per sequence, but following at least xterm and alacritty+ * we use a common space for parameters and sub-parameters, allowing 32 in total.+ *+ * <p>All parameters are unsigned, positive decimal integers, with the most significant+ * digit sent first. Any parameter greater than 9999 (decimal) is set to 9999+ * (decimal). If you do not specify a value, a 0 value is assumed. A 0 value+ * or omitted parameter indicates a default value for the sequence. For most+ * sequences, the default value is 1.+ *+ * <p>References:+ * <a href="https://vt100.net/docs/vt510-rm/chapter4.html#S4.3.3">VT510 Video Terminal Programmer Information: Control Sequences</a>+ * <a href="https://github.com/alacritty/vte/issues/22">alacritty/vte: Implement colon separated CSI parameters</a>+ * */+ private void parseArg(int b) {+ if (b >= '0' && b <= '9') {+ if (mArgIndex < mArgs.length) {+ int oldValue = mArgs[mArgIndex];+ int thisDigit = b - '0';+ int value;+ if (oldValue >= 0) {+ value = oldValue * 10 + thisDigit;+ } else {+ value = thisDigit;+ }+ if (value > 9999)+ value = 9999;+ mArgs[mArgIndex] = value;+ }+ continueSequence(mEscapeState);+ } else if (b == ';' || b == ':') {+ if (mArgIndex + 1 < mArgs.length) {+ mArgIndex++;+ if (b == ':') {+ mArgsSubParamsBitSet |= 1 << mArgIndex;+ }+ } else {+ logError("Too many parameters when in state: " + mEscapeState);+ }+ continueSequence(mEscapeState);+ } else {+ unknownSequence(b);+ }+ }++ private int getArg0(int defaultValue) {+ return getArg(0, defaultValue, true);+ }++ private int getArg1(int defaultValue) {+ return getArg(1, defaultValue, true);+ }++ private int getArg(int index, int defaultValue, boolean treatZeroAsDefault) {+ int result = mArgs[index];+ if (result < 0 || (result == 0 && treatZeroAsDefault)) {+ result = defaultValue;+ }+ return result;+ }++++ /** Collect code point in {@link #mTerminalControlArgs}. */+ private boolean collectTerminalControlArgs(int b) {+ // FIXME: Use `Logger.logErrorDebug()` and elsewhere in terminal code when support is added+ // to prevent logging potentially private data to logcat unless user has increased log level.+ if (mTerminalControlArgs.length() < mTerminalControlArgsMaxLength) {+ try {+ // Appending can cause an increase in capacity and cause an OOM.+ mTerminalControlArgs.appendCodePoint(b);+ continueSequence(mEscapeState);+ return true;+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(mClient, LOG_TAG, "Terminal control args collect failed for" ++ " char '" + (char) b + "' (numeric value=" + b + ") and" ++ " args string '" + mTerminalControlArgs.substring(0, Math.min(100, mTerminalControlArgs.length())) + "...' with length " + mTerminalControlArgs.length() ++ ": " + t.getMessage());+ }+ } else {+ Logger.logError(mClient, LOG_TAG, "Terminal control args input will" ++ " overflow max args length " + mTerminalControlArgsMaxLength + " for" ++ " char '" + (char) b + "' (numeric value=" + b + ") and" ++ " args string '" + mTerminalControlArgs.substring(0, Math.min(100, mTerminalControlArgs.length())) + "...' with length " + mTerminalControlArgs.length());+ }++ clearTerminalControlArgs();+ finishSequence();+ return false;+ }++ /** Clear {@link #mTerminalControlArgs}. */+ private void clearTerminalControlArgs() {+ mTerminalControlArgsMaxLength = TERMINAL_CONTROL_ARGS__DEFAULT_MAX_LENGTH;++ if (mTerminalControlArgs.capacity() <= TERMINAL_CONTROL_ARGS__INITIAL_CAPACITY) {+ // Mark existing buffer as empty and reuse old array already allocated in+ // `StringBuffer` for future commands if required.+ mTerminalControlArgs.setLength(0);+ } else {+ // `setLength()` will only update internal length marker and not reduce internal array+ // capacity, and to deallocate extra memory `trimToSize()` needs to be called, which+ // creates another smaller array.+ // So just allocate a new object with an array with required initial capacity directly+ // instead of setting length to 0, then trimming to create a smaller array, then+ // increasing capacity again by creating a new array with required initial capacity by+ // calling `ensureCapacity()`.+ mTerminalControlArgs = new StringBuilder(TERMINAL_CONTROL_ARGS__INITIAL_CAPACITY);+ }+ }++ /**+ * Ensure enough capacity for {@link #mTerminalControlArgs} to prevent repeated reallocation of+ * memory and copying as more data is received and appended, like with `append(char)`.+ *+ * The default capacity for {@link #mTerminalControlArgs} is defined by+ * {@link #TERMINAL_CONTROL_ARGS__INITIAL_CAPACITY}.+ *+ * By default, if `StringBuilder` reaches capacity, it sets new capacity to `(oldCapacity * 2) + 2`.+ * So if initial capacity is `16`, and data to be received is 1024 bytes, then 6 reallocations+ * will be done, so command processors should+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:libcore/ojluni/src/main/java/java/lang/AbstractStringBuilder.java;l=758+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:libcore/ojluni/src/main/java/java/lang/AbstractStringBuilder.java;l=183+ * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:libcore/ojluni/src/main/java/java/lang/AbstractStringBuilder.java;l=210+ *+ * See also {@link StringBuilder#ensureCapacity(int)}.+ *+ * @param capacity The new capacity.+ */+ private void ensureTerminalControlArgsCapacity(int capacity) {+ mTerminalControlArgs.ensureCapacity(capacity);+ }++ /**+ * Set {@link #mTerminalControlArgsMaxLength} in case a command expects a larger input.+ *+ * @param length The new max length.+ */+ private void setTerminalControlArgsMaxLength(int length) {+ if (length > 0) {+ mTerminalControlArgsMaxLength = length;+ }+ }++++++ private void unimplementedSequence(int b) {+ logError("Unimplemented sequence char '" + (char) b + "' (U+" + String.format("%04x", b) + ")");+ finishSequence();+ }++ private void unknownSequence(int b) {+ logError("Unknown sequence char '" + (char) b + "' (numeric value=" + b + ")");+ finishSequence();+ }++ private void unknownParameter(int parameter) {+ logError("Unknown parameter: " + parameter);+ finishSequence();+ }++ private void logError(String errorType) {+ if (LOG_ESCAPE_SEQUENCES) {+ StringBuilder buf = new StringBuilder();+ buf.append(errorType);+ buf.append(", escapeState=");+ buf.append(mEscapeState);+ boolean firstArg = true;+ if (mArgIndex >= mArgs.length) mArgIndex = mArgs.length - 1;+ for (int i = 0; i <= mArgIndex; i++) {+ int value = mArgs[i];+ if (value >= 0) {+ if (firstArg) {+ firstArg = false;+ buf.append(", args={");+ } else {+ buf.append(',');+ }+ buf.append(value);+ }+ }+ if (!firstArg) buf.append('}');+ finishSequenceAndLogError(buf.toString());+ }+ }++ private void finishSequenceAndLogError(String error) {+ if (LOG_ESCAPE_SEQUENCES) Logger.logWarn(mClient, LOG_TAG, error);+ finishSequence();+ }++ private void finishSequence() {+ mEscapeState = ESC_NONE;+ }++ /**+ * Send a Unicode code point to the screen.+ *+ * @param codePoint The code point of the character to display+ */+ private void emitCodePoint(int codePoint) {+ mLastEmittedCodePoint = codePoint;+ if (mUseLineDrawingUsesG0 ? mUseLineDrawingG0 : mUseLineDrawingG1) {+ // http://www.vt100.net/docs/vt102-ug/table5-15.html.+ switch (codePoint) {+ case '_':+ codePoint = ' '; // Blank.+ break;+ case '`':+ codePoint = '◆'; // Diamond.+ break;+ case '0':+ codePoint = '█'; // Solid block;+ break;+ case 'a':+ codePoint = '▒'; // Checker board.+ break;+ case 'b':+ codePoint = '␉'; // Horizontal tab.+ break;+ case 'c':+ codePoint = '␌'; // Form feed.+ break;+ case 'd':+ codePoint = '\r'; // Carriage return.+ break;+ case 'e':+ codePoint = '␊'; // Linefeed.+ break;+ case 'f':+ codePoint = '°'; // Degree.+ break;+ case 'g':+ codePoint = '±'; // Plus-minus.+ break;+ case 'h':+ codePoint = '\n'; // Newline.+ break;+ case 'i':+ codePoint = '␋'; // Vertical tab.+ break;+ case 'j':+ codePoint = '┘'; // Lower right corner.+ break;+ case 'k':+ codePoint = '┐'; // Upper right corner.+ break;+ case 'l':+ codePoint = '┌'; // Upper left corner.+ break;+ case 'm':+ codePoint = '└'; // Left left corner.+ break;+ case 'n':+ codePoint = '┼'; // Crossing lines.+ break;+ case 'o':+ codePoint = '⎺'; // Horizontal line - scan 1.+ break;+ case 'p':+ codePoint = '⎻'; // Horizontal line - scan 3.+ break;+ case 'q':+ codePoint = '─'; // Horizontal line - scan 5.+ break;+ case 'r':+ codePoint = '⎼'; // Horizontal line - scan 7.+ break;+ case 's':+ codePoint = '⎽'; // Horizontal line - scan 9.+ break;+ case 't':+ codePoint = '├'; // T facing rightwards.+ break;+ case 'u':+ codePoint = '┤'; // T facing leftwards.+ break;+ case 'v':+ codePoint = '┴'; // T facing upwards.+ break;+ case 'w':+ codePoint = '┬'; // T facing downwards.+ break;+ case 'x':+ codePoint = '│'; // Vertical line.+ break;+ case 'y':+ codePoint = '≤'; // Less than or equal to.+ break;+ case 'z':+ codePoint = '≥'; // Greater than or equal to.+ break;+ case '{':+ codePoint = 'π'; // Pi.+ break;+ case '|':+ codePoint = '≠'; // Not equal to.+ break;+ case '}':+ codePoint = '£'; // UK pound.+ break;+ case '~':+ codePoint = '·'; // Centered dot.+ break;+ }+ }++ final boolean autoWrap = isDecsetInternalBitSet(DECSET_BIT_AUTOWRAP);+ final int displayWidth = WcWidth.width(codePoint);+ final boolean cursorInLastColumn = mCursorCol == mRightMargin - 1;++ if (autoWrap) {+ if (cursorInLastColumn && ((mAboutToAutoWrap && displayWidth == 1) || displayWidth == 2)) {+ mScreen.setLineWrap(mCursorRow);+ mCursorCol = mLeftMargin;+ if (mCursorRow + 1 < mBottomMargin) {+ mCursorRow++;+ } else {+ scrollDownOneLine();+ }+ }+ } else if (cursorInLastColumn && displayWidth == 2) {+ // The behaviour when a wide character is output with cursor in the last column when+ // autowrap is disabled is not obvious - it's ignored here.+ return;+ }++ if (mInsertMode && displayWidth > 0) {+ // Move character to right one space.+ int destCol = mCursorCol + displayWidth;+ if (destCol < mRightMargin)+ mScreen.blockCopy(mCursorCol, mCursorRow, mRightMargin - destCol, 1, destCol, mCursorRow);+ }++ int offsetDueToCombiningChar = ((displayWidth <= 0 && mCursorCol > 0 && !mAboutToAutoWrap) ? 1 : 0);+ int column = mCursorCol - offsetDueToCombiningChar;++ // Fix TerminalRow.setChar() ArrayIndexOutOfBoundsException index=-1 exception reported+ // The offsetDueToCombiningChar would never be 1 if mCursorCol was 0 to get column/index=-1,+ // so was mCursorCol changed after the offsetDueToCombiningChar conditional by another thread?+ // TODO: Check if there are thread synchronization issues with mCursorCol and mCursorRow, possibly causing others bugs too.+ if (column < 0) column = 0;+ mScreen.setChar(column, mCursorRow, codePoint, getStyle());++ if (autoWrap && displayWidth > 0)+ mAboutToAutoWrap = (mCursorCol == mRightMargin - displayWidth);++ mCursorCol = Math.min(mCursorCol + displayWidth, mRightMargin - 1);+ }++ private void setCursorRow(int row) {+ mCursorRow = row;+ mAboutToAutoWrap = false;+ }++ private void setCursorCol(int col) {+ mCursorCol = col;+ mAboutToAutoWrap = false;+ }++ /** Set the cursor mode, but limit it to margins if {@link #DECSET_BIT_ORIGIN_MODE} is enabled. */+ private void setCursorColRespectingOriginMode(int col) {+ setCursorPosition(col, mCursorRow);+ }++ /** TODO: Better name, distinguished from {@link #setCursorPosition(int, int)} by not regarding origin mode. */+ private void setCursorRowCol(int row, int col) {+ mCursorRow = Math.max(0, Math.min(row, mRows - 1));+ mCursorCol = Math.max(0, Math.min(col, mColumns - 1));+ mAboutToAutoWrap = false;+ }++ public int getScrollCounter() {+ return mScrollCounter;+ }++ public void clearScrollCounter() {+ mScrollCounter = 0;+ }++ public boolean isAutoScrollDisabled() {+ return mAutoScrollDisabled;+ }++ public void toggleAutoScrollDisabled() {+ mAutoScrollDisabled = !mAutoScrollDisabled;+ }+++ /** Reset terminal state so user can interact with it regardless of present state. */+ public void reset() {+ setCursorStyle();+ mArgIndex = 0;+ mContinueSequence = false;+ mEscapeState = ESC_NONE;+ mInsertMode = false;+ mTopMargin = mLeftMargin = 0;+ mBottomMargin = mRows;+ mRightMargin = mColumns;+ mAboutToAutoWrap = false;+ mForeColor = mSavedStateMain.mSavedForeColor = mSavedStateAlt.mSavedForeColor = TextStyle.COLOR_INDEX_FOREGROUND;+ mBackColor = mSavedStateMain.mSavedBackColor = mSavedStateAlt.mSavedBackColor = TextStyle.COLOR_INDEX_BACKGROUND;+ setDefaultTabStops();++ mUseLineDrawingG0 = mUseLineDrawingG1 = false;+ mUseLineDrawingUsesG0 = true;++ mSavedStateMain.mSavedCursorRow = mSavedStateMain.mSavedCursorCol = mSavedStateMain.mSavedEffect = mSavedStateMain.mSavedDecFlags = 0;+ mSavedStateAlt.mSavedCursorRow = mSavedStateAlt.mSavedCursorCol = mSavedStateAlt.mSavedEffect = mSavedStateAlt.mSavedDecFlags = 0;+ mCurrentDecSetFlags = 0;+ // Initial wrap-around is not accurate but makes terminal more useful, especially on a small screen:+ setDecsetinternalBit(DECSET_BIT_AUTOWRAP, true);+ setDecsetinternalBit(DECSET_BIT_CURSOR_ENABLED, true);+ mSavedDecSetFlags = mSavedStateMain.mSavedDecFlags = mSavedStateAlt.mSavedDecFlags = mCurrentDecSetFlags;++ // XXX: Should we set terminal driver back to IUTF8 with termios?+ mUtf8Index = mUtf8ToFollow = 0;++ mColors.reset();+ mSession.onColorsChanged();++ clearTerminalControlArgs();+ clearOscTypeVariables();+ mITermImage = null;+ }++ public String getSelectedText(int x1, int y1, int x2, int y2) {+ return mScreen.getSelectedText(x1, y1, x2, y2);+ }++ /** Get the terminal session's title (null if not set). */+ public String getTitle() {+ return mTitle;+ }++ /** Change the terminal session's title. */+ private void setTitle(String newTitle) {+ String oldTitle = mTitle;+ mTitle = newTitle;+ if (!Objects.equals(oldTitle, newTitle)) {+ mSession.titleChanged(oldTitle, newTitle);+ }+ }++ /** If DECSET 2004 is set, prefix paste with "\033[200~" and suffix with "\033[201~". */+ public void paste(String text) {+ // First: Always remove escape key and C1 control characters [0x80,0x9F]:+ text = text.replaceAll("(\u001B|[\u0080-\u009F])", "");+ // Second: Replace all newlines (\n) or CRLF (\r\n) with carriage returns (\r).+ text = text.replaceAll("\r?\n", "\r");++ // Then: Implement bracketed paste mode if enabled:+ boolean bracketed = isDecsetInternalBitSet(DECSET_BIT_BRACKETED_PASTE_MODE);+ if (bracketed) mSession.write("\033[200~");+ mSession.write(text);+ if (bracketed) mSession.write("\033[201~");+ }++ /** http://www.vt100.net/docs/vt510-rm/DECSC */+ static final class SavedScreenState {+ /** Saved state of the cursor position, Used to implement the save/restore cursor position escape sequences. */+ int mSavedCursorRow, mSavedCursorCol;+ int mSavedEffect, mSavedForeColor, mSavedBackColor;+ int mSavedDecFlags;+ boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;+ }++ @Override+ public String toString() {+ return "TerminalEmulator[size=" + mScreen.mColumns + "x" + mScreen.mScreenRows + ", margins={" + mTopMargin + "," + mRightMargin + "," + mBottomMargin+ + "," + mLeftMargin + "}]";+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalOutput.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalOutput.javanew file mode 100644index 0000000..305082a--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalOutput.java@@ -0,0 +1,32 @@+package com.termux.terminal;++import java.nio.charset.StandardCharsets;++/** A client which receives callbacks from events triggered by feeding input to a {@link TerminalEmulator}. */+public abstract class TerminalOutput {++ /** Write a string using the UTF-8 encoding to the terminal client. */+ public final void write(String data) {+ if (data == null) return;+ byte[] bytes = data.getBytes(StandardCharsets.UTF_8);+ write(bytes, 0, bytes.length);+ }++ /** Write bytes to the terminal client. */+ public abstract void write(byte[] data, int offset, int count);++ /** Notify the terminal client that the terminal title has changed. */+ public abstract void titleChanged(String oldTitle, String newTitle);++ /** Notify the terminal client that text should be copied to clipboard. */+ public abstract void onCopyTextToClipboard(String text);++ /** Notify the terminal client that text should be pasted from clipboard. */+ public abstract void onPasteTextFromClipboard();++ /** Notify the terminal client that a bell character (ASCII 7, bell, BEL, \a, ^G)) has been received. */+ public abstract void onBell();++ public abstract void onColorsChanged();++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalRow.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalRow.javanew file mode 100644index 0000000..14de528--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalRow.java@@ -0,0 +1,290 @@+package com.termux.terminal;++import java.util.Arrays;++/**+ * A row in a terminal, composed of a fixed number of cells.+ * <p>+ * The text in the row is stored in a char[] array, {@link #mText}, for quick access during rendering.+ */+public final class TerminalRow {++ private static final float SPARE_CAPACITY_FACTOR = 1.5f;++ /**+ * Max combining characters that can exist in a column, that are separate from the base character+ * itself. Any additional combining characters will be ignored and not added to the column.+ *+ * There does not seem to be limit in unicode standard for max number of combination characters+ * that can be combined but such characters are primarily under 10.+ *+ * "Section 3.6 Combination" of unicode standard contains combining characters info.+ * - https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf+ * - https://en.wikipedia.org/wiki/Combining_character#Unicode_ranges+ * - https://stackoverflow.com/questions/71237212/what-is-the-maximum-number-of-unicode-combined-characters-that-may-be-needed-to+ *+ * UAX15-D3 Stream-Safe Text Format limits to max 30 combining characters.+ * > The value of 30 is chosen to be significantly beyond what is required for any linguistic or technical usage.+ * > While it would have been feasible to chose a smaller number, this value provides a very wide margin,+ * > yet is well within the buffer size limits of practical implementations.+ * - https://unicode.org/reports/tr15/#Stream_Safe_Text_Format+ * - https://stackoverflow.com/a/11983435/14686958+ *+ * We choose the value 15 because it should be enough for terminal based applications and keep+ * the memory usage low for a terminal row, won't affect performance or cause terminal to+ * lag or hang, and will keep malicious applications from causing harm. The value can be+ * increased if ever needed for legitimate applications.+ */+ private static final int MAX_COMBINING_CHARACTERS_PER_COLUMN = 15;++ /** The number of columns in this terminal row. */+ private final int mColumns;+ /** The text filling this terminal row. */+ public char[] mText;+ /** The number of java chars used in {@link #mText}. */+ private int mSpaceUsed;+ /** If this row has been line wrapped due to text output at the end of line. */+ boolean mLineWrap;+ /** The style bits of each cell in the row. See {@link TextStyle}. */+ final long[] mStyle;+ /** If this row might contain chars with width != 1, used for deactivating fast path */+ boolean mHasNonOneWidthOrSurrogateChars;+ /** If this row has a {@link TerminalBitmap}. Used for performance only. */+ public boolean mHasTerminalBitmap;++ /** Construct a blank row (containing only whitespace, ' ') with a specified style. */+ public TerminalRow(int columns, long style) {+ mColumns = columns;+ mText = new char[(int) (SPARE_CAPACITY_FACTOR * columns)];+ mStyle = new long[columns];+ clear(style);+ }++ /** NOTE: The sourceX2 is exclusive. */+ public void copyInterval(TerminalRow line, int sourceX1, int sourceX2, int destinationX) {+ mHasNonOneWidthOrSurrogateChars |= line.mHasNonOneWidthOrSurrogateChars;+ final int x1 = line.findStartOfColumn(sourceX1);+ final int x2 = line.findStartOfColumn(sourceX2);+ boolean startingFromSecondHalfOfWideChar = (sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1));+ final char[] sourceChars = (this == line) ? Arrays.copyOf(line.mText, line.mText.length) : line.mText;+ int latestNonCombiningWidth = 0;+ for (int i = x1; i < x2; i++) {+ char sourceChar = sourceChars[i];+ int codePoint = Character.isHighSurrogate(sourceChar) ? Character.toCodePoint(sourceChar, sourceChars[++i]) : sourceChar;+ if (startingFromSecondHalfOfWideChar) {+ // Just treat copying second half of wide char as copying whitespace.+ codePoint = ' ';+ startingFromSecondHalfOfWideChar = false;+ }+ int w = WcWidth.width(codePoint);+ if (w > 0) {+ destinationX += latestNonCombiningWidth;+ sourceX1 += latestNonCombiningWidth;+ latestNonCombiningWidth = w;+ }+ setChar(destinationX, codePoint, line.getStyle(sourceX1));+ }+ }++ public int getSpaceUsed() {+ return mSpaceUsed;+ }++ /** Note that the column may end of second half of wide character. */+ public int findStartOfColumn(int column) {+ if (column == mColumns) return getSpaceUsed();++ int currentColumn = 0;+ int currentCharIndex = 0;+ while (true) { // 0<2 1 < 2+ int newCharIndex = currentCharIndex;+ char c = mText[newCharIndex++]; // cci=1, cci=2+ boolean isHigh = Character.isHighSurrogate(c);+ int codePoint = isHigh ? Character.toCodePoint(c, mText[newCharIndex++]) : c;+ int wcwidth = WcWidth.width(codePoint); // 1, 2+ if (wcwidth > 0) {+ currentColumn += wcwidth;+ if (currentColumn == column) {+ while (newCharIndex < mSpaceUsed) {+ // Skip combining chars.+ if (Character.isHighSurrogate(mText[newCharIndex])) {+ if (WcWidth.width(Character.toCodePoint(mText[newCharIndex], mText[newCharIndex + 1])) <= 0) {+ newCharIndex += 2;+ } else {+ break;+ }+ } else if (WcWidth.width(mText[newCharIndex]) <= 0) {+ newCharIndex++;+ } else {+ break;+ }+ }+ return newCharIndex;+ } else if (currentColumn > column) {+ // Wide column going past end.+ return currentCharIndex;+ }+ }+ currentCharIndex = newCharIndex;+ }+ }++ private boolean wideDisplayCharacterStartingAt(int column) {+ for (int currentCharIndex = 0, currentColumn = 0; currentCharIndex < mSpaceUsed; ) {+ char c = mText[currentCharIndex++];+ int codePoint = Character.isHighSurrogate(c) ? Character.toCodePoint(c, mText[currentCharIndex++]) : c;+ int wcwidth = WcWidth.width(codePoint);+ if (wcwidth > 0) {+ if (currentColumn == column && wcwidth == 2) return true;+ currentColumn += wcwidth;+ if (currentColumn > column) return false;+ }+ }+ return false;+ }++ public void clear(long style) {+ Arrays.fill(mText, ' ');+ Arrays.fill(mStyle, style);+ mSpaceUsed = mColumns;+ mHasNonOneWidthOrSurrogateChars = false;+ mHasTerminalBitmap = false;+ }++ // https://github.com/steven676/Android-Terminal-Emulator/commit/9a47042620bec87617f0b4f5d50568535668fe26+ public void setChar(int columnToSet, int codePoint, long style) {+ if (columnToSet < 0 || columnToSet >= mStyle.length)+ throw new IllegalArgumentException("TerminalRow.setChar(): columnToSet=" + columnToSet + ", codePoint=" + codePoint + ", style=" + style);++ mStyle[columnToSet] = style;++ if (!mHasTerminalBitmap && TextStyle.isTerminalBitmap(style)) {+ mHasTerminalBitmap = true;+ }++ final int newCodePointDisplayWidth = WcWidth.width(codePoint);++ // Fast path when we don't have any chars with width != 1+ if (!mHasNonOneWidthOrSurrogateChars) {+ if (codePoint >= Character.MIN_SUPPLEMENTARY_CODE_POINT || newCodePointDisplayWidth != 1) {+ mHasNonOneWidthOrSurrogateChars = true;+ } else {+ mText[columnToSet] = (char) codePoint;+ return;+ }+ }++ final boolean newIsCombining = newCodePointDisplayWidth <= 0;++ boolean wasExtraColForWideChar = (columnToSet > 0) && wideDisplayCharacterStartingAt(columnToSet - 1);++ if (newIsCombining) {+ // When standing at second half of wide character and inserting combining:+ if (wasExtraColForWideChar) columnToSet--;+ } else {+ // Check if we are overwriting the second half of a wide character starting at the previous column:+ if (wasExtraColForWideChar) setChar(columnToSet - 1, ' ', style);+ // Check if we are overwriting the first half of a wide character starting at the next column:+ boolean overwritingWideCharInNextColumn = newCodePointDisplayWidth == 2 && wideDisplayCharacterStartingAt(columnToSet + 1);+ if (overwritingWideCharInNextColumn) setChar(columnToSet + 1, ' ', style);+ }++ char[] text = mText;+ final int oldStartOfColumnIndex = findStartOfColumn(columnToSet);+ final int oldCodePointDisplayWidth = WcWidth.width(text, oldStartOfColumnIndex);++ // Get the number of elements in the mText array this column uses now+ int oldCharactersUsedForColumn;+ if (columnToSet + oldCodePointDisplayWidth < mColumns) {+ int oldEndOfColumnIndex = findStartOfColumn(columnToSet + oldCodePointDisplayWidth);+ oldCharactersUsedForColumn = oldEndOfColumnIndex - oldStartOfColumnIndex;+ } else {+ // Last character.+ oldCharactersUsedForColumn = mSpaceUsed - oldStartOfColumnIndex;+ }++ // If MAX_COMBINING_CHARACTERS_PER_COLUMN already exist in column, then ignore adding additional combining characters.+ if (newIsCombining) {+ int combiningCharsCount = WcWidth.zeroWidthCharsCount(mText, oldStartOfColumnIndex, oldStartOfColumnIndex + oldCharactersUsedForColumn);+ if (combiningCharsCount >= MAX_COMBINING_CHARACTERS_PER_COLUMN)+ return;+ }++ // Find how many chars this column will need+ int newCharactersUsedForColumn = Character.charCount(codePoint);+ if (newIsCombining) {+ // Combining characters are added to the contents of the column instead of overwriting them, so that they+ // modify the existing contents.+ // FIXME: Unassigned characters also get width=0.+ newCharactersUsedForColumn += oldCharactersUsedForColumn;+ }++ int oldNextColumnIndex = oldStartOfColumnIndex + oldCharactersUsedForColumn;+ int newNextColumnIndex = oldStartOfColumnIndex + newCharactersUsedForColumn;++ final int javaCharDifference = newCharactersUsedForColumn - oldCharactersUsedForColumn;+ if (javaCharDifference > 0) {+ // Shift the rest of the line right.+ int oldCharactersAfterColumn = mSpaceUsed - oldNextColumnIndex;+ if (mSpaceUsed + javaCharDifference > text.length) {+ // We need to grow the array+ char[] newText = new char[text.length + mColumns];+ System.arraycopy(text, 0, newText, 0, oldNextColumnIndex);+ System.arraycopy(text, oldNextColumnIndex, newText, newNextColumnIndex, oldCharactersAfterColumn);+ mText = text = newText;+ } else {+ System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, oldCharactersAfterColumn);+ }+ } else if (javaCharDifference < 0) {+ // Shift the rest of the line left.+ System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - oldNextColumnIndex);+ }+ mSpaceUsed += javaCharDifference;++ // Store char. A combining character is stored at the end of the existing contents so that it modifies them:+ //noinspection ResultOfMethodCallIgnored - since we already now how many java chars is used.+ Character.toChars(codePoint, text, oldStartOfColumnIndex + (newIsCombining ? oldCharactersUsedForColumn : 0));++ if (oldCodePointDisplayWidth == 2 && newCodePointDisplayWidth == 1) {+ // Replace second half of wide char with a space. Which mean that we actually add a ' ' java character.+ if (mSpaceUsed + 1 > text.length) {+ char[] newText = new char[text.length + mColumns];+ System.arraycopy(text, 0, newText, 0, newNextColumnIndex);+ System.arraycopy(text, newNextColumnIndex, newText, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);+ mText = text = newText;+ } else {+ System.arraycopy(text, newNextColumnIndex, text, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);+ }+ text[newNextColumnIndex] = ' ';++ ++mSpaceUsed;+ } else if (oldCodePointDisplayWidth == 1 && newCodePointDisplayWidth == 2) {+ if (columnToSet == mColumns - 1) {+ throw new IllegalArgumentException("Cannot put wide character in last column");+ } else if (columnToSet == mColumns - 2) {+ // Truncate the line to the second part of this wide char:+ mSpaceUsed = newNextColumnIndex;+ } else {+ // Overwrite the contents of the next column, which mean we actually remove java characters. Due to the+ // check at the beginning of this method we know that we are not overwriting a wide char.+ int newNextNextColumnIndex = newNextColumnIndex + (Character.isHighSurrogate(mText[newNextColumnIndex]) ? 2 : 1);+ int nextLen = newNextNextColumnIndex - newNextColumnIndex;++ // Shift the array leftwards.+ System.arraycopy(text, newNextNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - newNextNextColumnIndex);+ mSpaceUsed -= nextLen;+ }+ }+ }++ boolean isBlank() {+ for (int charIndex = 0, charLen = getSpaceUsed(); charIndex < charLen; charIndex++)+ if (mText[charIndex] != ' ') return false;+ return true;+ }++ public final long getStyle(int column) {+ return mStyle[column];+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalSession.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSession.javanew file mode 100644index 0000000..31a48a6--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSession.java@@ -0,0 +1,387 @@+package com.termux.terminal;++import android.annotation.SuppressLint;+import android.os.Handler;+import android.os.Message;+import android.system.ErrnoException;+import android.system.Os;+import android.system.OsConstants;++import java.io.File;+import java.io.FileDescriptor;+import java.io.FileInputStream;+import java.io.FileOutputStream;+import java.io.IOException;+import java.io.InputStream;+import java.lang.reflect.Field;+import java.nio.charset.StandardCharsets;+import java.util.UUID;++/**+ * A terminal session, consisting of a process coupled to a terminal interface.+ * <p>+ * The subprocess will be executed by the constructor, and when the size is made known by a call to+ * {@link #updateSize(int, int, int, int)} terminal emulation will begin and threads will be spawned to handle the subprocess I/O.+ * All terminal emulation and callback methods will be performed on the main thread.+ * <p>+ * The child process may be exited forcefully by using the {@link #finishIfRunning()} method.+ * <p>+ * NOTE: The terminal session may outlive the EmulatorView, so be careful with callbacks!+ */+public final class TerminalSession extends TerminalOutput {++ private static final int MSG_NEW_INPUT = 1;+ private static final int MSG_PROCESS_EXITED = 4;++ public final String mHandle = UUID.randomUUID().toString();++ TerminalEmulator mEmulator;++ /**+ * A queue written to from a separate thread when the process outputs, and read by main thread to process by+ * terminal emulator.+ */+ final ByteQueue mProcessToTerminalIOQueue = new ByteQueue(64 * 1024);+ /**+ * A queue written to from the main thread due to user interaction, and read by another thread which forwards by+ * writing to the {@link #mTerminalFileDescriptor}.+ */+ final ByteQueue mTerminalToProcessIOQueue = new ByteQueue(4096);+ /** Buffer to write translate code points into utf8 before writing to mTerminalToProcessIOQueue */+ private final byte[] mUtf8InputBuffer = new byte[5];++ /** Callback which gets notified when a session finishes or changes title. */+ TerminalSessionClient mClient;++ /** The pid of the shell process. 0 if not started and -1 if finished running. */+ int mShellPid;++ /** The exit status of the shell process. Only valid if ${@link #mShellPid} is -1. */+ int mShellExitStatus;++ /**+ * The file descriptor referencing the master half of a pseudo-terminal pair, resulting from calling+ * {@link JNI#createSubprocess(String, String, String[], String[], int[], int, int, int, int)}.+ */+ private int mTerminalFileDescriptor;++ /** Set by the application for user identification of session, not by terminal. */+ public String mSessionName;++ final Handler mMainThreadHandler = new MainThreadHandler();++ private final String mShellPath;+ private final String mCwd;+ private final String[] mArgs;+ private final String[] mEnv;+ private final Integer mTranscriptRows;+++ private static final String LOG_TAG = "TerminalSession";++ public TerminalSession(String shellPath, String cwd, String[] args, String[] env, Integer transcriptRows, TerminalSessionClient client) {+ this.mShellPath = shellPath;+ this.mCwd = cwd;+ this.mArgs = args;+ this.mEnv = env;+ this.mTranscriptRows = transcriptRows;+ this.mClient = client;+ }++ /**+ * @param client The {@link TerminalSessionClient} interface implementation to allow+ * for communication between {@link TerminalSession} and its client.+ */+ public void updateTerminalSessionClient(TerminalSessionClient client) {+ mClient = client;++ if (mEmulator != null)+ mEmulator.updateTerminalSessionClient(client);+ }++ /** Inform the attached pty of the new size and reflow or initialize the emulator. */+ public void updateSize(int columns, int rows, int cellWidthPixels, int cellHeightPixels) {+ if (mEmulator == null) {+ initializeEmulator(columns, rows, cellWidthPixels, cellHeightPixels);+ } else {+ JNI.setPtyWindowSize(mTerminalFileDescriptor, rows, columns, cellWidthPixels, cellHeightPixels);+ mEmulator.resize(columns, rows, cellWidthPixels, cellHeightPixels);+ }+ }++ /** The terminal title as set through escape sequences or null if none set. */+ public String getTitle() {+ return (mEmulator == null) ? null : mEmulator.getTitle();+ }++ /**+ * Set the terminal emulator's window size and start terminal emulation.+ *+ * @param columns The number of columns in the terminal window.+ * @param rows The number of rows in the terminal window.+ */+ public void initializeEmulator(int columns, int rows, int cellWidthPixels, int cellHeightPixels) {+ mEmulator = new TerminalEmulator(this, columns, rows, cellWidthPixels, cellHeightPixels, mTranscriptRows, mClient);++ int[] processId = new int[1];+ mTerminalFileDescriptor = JNI.createSubprocess(mShellPath, mCwd, mArgs, mEnv, processId, rows, columns, cellWidthPixels, cellHeightPixels);+ mShellPid = processId[0];+ mClient.setTerminalShellPid(this, mShellPid);++ final FileDescriptor terminalFileDescriptorWrapped = wrapFileDescriptor(mTerminalFileDescriptor, mClient);++ new Thread("TermSessionInputReader[pid=" + mShellPid + "]") {+ @Override+ public void run() {+ try (InputStream termIn = new FileInputStream(terminalFileDescriptorWrapped)) {+ // Podroid: 64 KB drain buffer (was 4 KB upstream). Pairs with the+ // 64 KB main-thread receive buffer below — bursts drain the PTY in+ // a single read instead of splintering across 16 wakeups.+ final byte[] buffer = new byte[64 * 1024];+ while (true) {+ int read = termIn.read(buffer);+ if (read == -1) return;+ if (!mProcessToTerminalIOQueue.write(buffer, 0, read)) return;+ // Podroid: dedupe — main thread reads up to 64 KB at a time, so+ // queueing N messages just to discover an empty queue N-1 times+ // is pure overhead. One pending message is enough.+ if (!mMainThreadHandler.hasMessages(MSG_NEW_INPUT)) {+ mMainThreadHandler.sendEmptyMessage(MSG_NEW_INPUT);+ }+ }+ } catch (Exception e) {+ // Ignore, just shutting down.+ }+ }+ }.start();++ new Thread("TermSessionOutputWriter[pid=" + mShellPid + "]") {+ @Override+ public void run() {+ final byte[] buffer = new byte[4096];+ try (FileOutputStream termOut = new FileOutputStream(terminalFileDescriptorWrapped)) {+ while (true) {+ int bytesToWrite = mTerminalToProcessIOQueue.read(buffer, true);+ if (bytesToWrite == -1) return;+ termOut.write(buffer, 0, bytesToWrite);+ }+ } catch (IOException e) {+ // Ignore.+ }+ }+ }.start();++ new Thread("TermSessionWaiter[pid=" + mShellPid + "]") {+ @Override+ public void run() {+ int processExitCode = JNI.waitFor(mShellPid);+ mMainThreadHandler.sendMessage(mMainThreadHandler.obtainMessage(MSG_PROCESS_EXITED, processExitCode));+ }+ }.start();++ }++ /** Write data to the shell process. */+ @Override+ public void write(byte[] data, int offset, int count) {+ if (mShellPid > 0) mTerminalToProcessIOQueue.write(data, offset, count);+ }++ /** Write the Unicode code point to the terminal encoded in UTF-8. */+ public void writeCodePoint(boolean prependEscape, int codePoint) {+ if (codePoint > 1114111 || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {+ // 1114111 (= 2**16 + 1024**2 - 1) is the highest code point, [0xD800,0xDFFF] is the surrogate range.+ throw new IllegalArgumentException("Invalid code point: " + codePoint);+ }++ int bufferPosition = 0;+ if (prependEscape) mUtf8InputBuffer[bufferPosition++] = 27;++ if (codePoint <= /* 7 bits */0b1111111) {+ mUtf8InputBuffer[bufferPosition++] = (byte) codePoint;+ } else if (codePoint <= /* 11 bits */0b11111111111) {+ /* 110xxxxx leading byte with leading 5 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11000000 | (codePoint >> 6));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));+ } else if (codePoint <= /* 16 bits */0b1111111111111111) {+ /* 1110xxxx leading byte with leading 4 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11100000 | (codePoint >> 12));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));+ } else { /* We have checked codePoint <= 1114111 above, so we have max 21 bits = 0b111111111111111111111 */+ /* 11110xxx leading byte with leading 3 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11110000 | (codePoint >> 18));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 12) & 0b111111));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));+ /* 10xxxxxx continuation byte with following 6 bits */+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));+ }+ write(mUtf8InputBuffer, 0, bufferPosition);+ }++ public TerminalEmulator getEmulator() {+ return mEmulator;+ }++ /** Notify the {@link #mClient} that the screen has changed. */+ protected void notifyScreenUpdate() {+ mClient.onTextChanged(this);+ }++ /** Reset state for terminal emulator state. */+ public void reset() {+ mEmulator.reset();+ notifyScreenUpdate();+ }++ /** Finish this terminal session by sending SIGKILL to the shell. */+ public void finishIfRunning() {+ if (isRunning()) {+ try {+ Os.kill(mShellPid, OsConstants.SIGKILL);+ } catch (ErrnoException e) {+ Logger.logWarn(mClient, LOG_TAG, "Failed sending SIGKILL: " + e.getMessage());+ }+ }+ }++ /** Cleanup resources when the process exits. */+ void cleanupResources(int exitStatus) {+ synchronized (this) {+ mShellPid = -1;+ mShellExitStatus = exitStatus;+ }++ // Stop the reader and writer threads, and close the I/O streams+ mTerminalToProcessIOQueue.close();+ mProcessToTerminalIOQueue.close();+ JNI.close(mTerminalFileDescriptor);+ }++ @Override+ public void titleChanged(String oldTitle, String newTitle) {+ mClient.onTitleChanged(this);+ }++ public synchronized boolean isRunning() {+ return mShellPid != -1;+ }++ /** Only valid if not {@link #isRunning()}. */+ public synchronized int getExitStatus() {+ return mShellExitStatus;+ }++ @Override+ public void onCopyTextToClipboard(String text) {+ mClient.onCopyTextToClipboard(this, text);+ }++ @Override+ public void onPasteTextFromClipboard() {+ mClient.onPasteTextFromClipboard(this);+ }++ @Override+ public void onBell() {+ mClient.onBell(this);+ }++ @Override+ public void onColorsChanged() {+ mClient.onColorsChanged(this);+ }++ public int getPid() {+ return mShellPid;+ }++ /** Returns the shell's working directory or null if it was unavailable. */+ public String getCwd() {+ if (mShellPid < 1) {+ return null;+ }+ try {+ final String cwdSymlink = String.format("/proc/%s/cwd/", mShellPid);+ String outputPath = new File(cwdSymlink).getCanonicalPath();+ String outputPathWithTrailingSlash = outputPath;+ if (!outputPath.endsWith("/")) {+ outputPathWithTrailingSlash += '/';+ }+ if (!cwdSymlink.equals(outputPathWithTrailingSlash)) {+ return outputPath;+ }+ } catch (IOException | SecurityException e) {+ Logger.logStackTraceWithMessage(mClient, LOG_TAG, "Error getting current directory", e);+ }+ return null;+ }++ private static FileDescriptor wrapFileDescriptor(int fileDescriptor, TerminalSessionClient client) {+ FileDescriptor result = new FileDescriptor();+ try {+ Field descriptorField;+ try {+ descriptorField = FileDescriptor.class.getDeclaredField("descriptor");+ } catch (NoSuchFieldException e) {+ // For desktop java:+ descriptorField = FileDescriptor.class.getDeclaredField("fd");+ }+ descriptorField.setAccessible(true);+ descriptorField.set(result, fileDescriptor);+ } catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {+ Logger.logStackTraceWithMessage(client, LOG_TAG, "Error accessing FileDescriptor#descriptor private field", e);+ System.exit(1);+ }+ return result;+ }++ @SuppressLint("HandlerLeak")+ class MainThreadHandler extends Handler {++ final byte[] mReceiveBuffer = new byte[64 * 1024];++ @Override+ public void handleMessage(Message msg) {+ int bytesRead = mProcessToTerminalIOQueue.read(mReceiveBuffer, false);+ if (bytesRead > 0) {+ mEmulator.append(mReceiveBuffer, bytesRead);+ // Podroid: DECSET 2026 — if the app is mid-frame (e.g. btop's atomic+ // update), skip the invalidate. Cells are still mutated in the buffer;+ // the close bracket arriving in a later batch will clear the flag and+ // the next handleMessage will paint the completed frame in one shot.+ if (!mEmulator.isSynchronizedOutputActive()) {+ notifyScreenUpdate();+ }+ }++ if (msg.what == MSG_PROCESS_EXITED) {+ int exitCode = (Integer) msg.obj;+ cleanupResources(exitCode);++ String exitDescription = "\r\n[Process completed";+ if (exitCode > 0) {+ // Non-zero process exit.+ exitDescription += " (code " + exitCode + ")";+ } else if (exitCode < 0) {+ // Negated signal.+ exitDescription += " (signal " + (-exitCode) + ")";+ }+ exitDescription += " - press Enter]";++ byte[] bytesToWrite = exitDescription.getBytes(StandardCharsets.UTF_8);+ mEmulator.append(bytesToWrite, bytesToWrite.length);+ notifyScreenUpdate();++ mClient.onSessionFinished(TerminalSession.this);+ }+ }++ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalSessionClient.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSessionClient.javanew file mode 100644index 0000000..db6d5ab--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSessionClient.java@@ -0,0 +1,61 @@+package com.termux.terminal;++import androidx.annotation.NonNull;+import androidx.annotation.Nullable;++/**+ * The interface for communication between {@link TerminalSession} and its client. It is used to+ * send callbacks to the client when {@link TerminalSession} changes or for sending other+ * back data to the client like logs.+ */+public interface TerminalSessionClient {++ void onTextChanged(@NonNull TerminalSession changedSession);++ void onTitleChanged(@NonNull TerminalSession changedSession);++ void onSessionFinished(@NonNull TerminalSession finishedSession);++ void onCopyTextToClipboard(@NonNull TerminalSession session, String text);++ void onPasteTextFromClipboard(@Nullable TerminalSession session);++ void onBell(@NonNull TerminalSession session);++ void onColorsChanged(@NonNull TerminalSession session);++ void onTerminalCursorStateChange(boolean state);++ void setTerminalShellPid(@NonNull TerminalSession session, int pid);++++ Integer getTerminalCursorStyle();++ /**+ * Identifier reported by the emulator in response to XTVERSION (`CSI > 0 q`).+ * Format: `<name> <version>`, e.g. `"Podroid 1.1.7-debug"`. Apps like Neovim+ * use this to detect terminal capabilities. Default returns null → emulator+ * falls back to a bare name without version.+ */+ default String getTerminalVersionString() {+ return null;+ }++++ void logError(String tag, String message);++ void logWarn(String tag, String message);++ void logInfo(String tag, String message);++ void logDebug(String tag, String message);++ void logVerbose(String tag, String message);++ void logStackTraceWithMessage(String tag, String message, Exception e);++ void logStackTrace(String tag, Exception e);++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TerminalSixel.java b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSixel.javanew file mode 100644index 0000000..fa1340b--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TerminalSixel.java@@ -0,0 +1,271 @@+package com.termux.terminal;++import android.graphics.Bitmap;++/**+ * A terminal sixel received via `DCS q s..s ST` or `DCS P1; P2; P3; q s..s ST`.+ *+ * **See Also:**+ * - `TerminalEmulator.ESC_DCS__SIXEL`+ * - https://vt100.net/docs/vt3xx-gp/chapter14.html+ * - https://en.wikipedia.org/wiki/Sixel+ * - https://www.digiater.nl/openvms/decus/vax90b1/krypton-nasa/all-about-sixels.text+ */+public class TerminalSixel {++ public static final String LOG_TAG = "TerminalSixel";++++ public static final int[] SIXEL__INITIAL_COLOR_MAP = {+ 0xFF000000, 0xFF3333CC, 0xFFCC2323, 0xFF33CC33, 0xFFCC33CC, 0xFF33CCCC, 0xFFCCCC33, 0xFF777777,+ 0xFF444444, 0xFF565699, 0xFF994444, 0xFF569956, 0xFF995699, 0xFF569999, 0xFF999956, 0xFFCCCCCC+ };++ /**+ * A sixel is a group of six pixels in a vertical column.+ */+ public static final int SIXEL__LINE_LEN = 6;++ /**+ * The amount of extra dimension added when resizing a sixel when receiving more image data.+ */+ public static final int SIXEL__BITMAP_RESIZE_EXTRA_DIMENSION = 100;++ /**+ * The max value for the sixel Graphics Repeat Introducer.+ *+ * The value `8192` can support 8K images, see also {@link TerminalBitmap#MAX_BITMAP_SIZE}.+ *+ * Each repeat creates a new sixel line of `1x6` pixels, where `6` is the {@link #SIXEL__LINE_LEN}.+ *+ * - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.1+ */+ public static final int SIXEL__MAX_REPEAT = 8192;++++ protected final TerminalSessionClient mClient;++ protected Bitmap mBitmap;++ protected int mWidth;+ protected int mHeight;++ protected int mCurX;+ protected int mCurY;++ protected final int[] mColorMap;+ protected int mColor;++++ protected TerminalSixel(TerminalSessionClient client, Bitmap bitmap) {+ mClient = client;++ mBitmap = bitmap;++ mWidth = 0;+ mHeight = 0;++ mCurX = 0;+ mCurY = 0;++ mColorMap = new int[256];+ System.arraycopy(SIXEL__INITIAL_COLOR_MAP, 0, mColorMap, 0, 16);+ mColor = mColorMap[0];+ }++++ public static TerminalSixel build(TerminalSessionClient client, int bitmapWidth, int bitmapHeight) {+ try {++ Bitmap bitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888);+ bitmap.eraseColor(0);++ return new TerminalSixel(client, bitmap);+ } catch (Throwable t) {+ if (t instanceof OutOfMemoryError) System.gc();+ Logger.logError(client, LOG_TAG, "Create sixel bitmap for" ++ " width " + bitmapWidth + " with height " + bitmapHeight + " failed: " + t.getMessage());+ return null;+ }+ }++++ public TerminalSessionClient getClient() {+ return mClient;+ }+++ public Bitmap getBitmap() {+ return mBitmap;+ }+++ public int getWidth() {+ return mWidth;+ }++ public int getHeight() {+ return mHeight;+ }+++ public int getCurX() {+ return mCurX;+ }++ public int getCurY() {+ return mCurY;+ }+++ public int[] getColorMap() {+ return mColorMap;+ }++ public int getColor() {+ return mColor;+ }++++ public boolean readData(int codePoint, int repeat) {+ if (mBitmap == null) {+ return false;+ }++ if (repeat > TerminalSixel.SIXEL__MAX_REPEAT) {+ Logger.logError(mClient, LOG_TAG, "The sixel repeat value " + repeat + " is greater than max repeat value " + TerminalSixel.SIXEL__MAX_REPEAT);+ return false;+ }++ // Graphics Carriage Return `$`.+ // > The $ (2/4) character indicates the end of the sixel line. The active position returns+ // > to the left page border of the same sixel line. You can use this character to overprint lines.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.4+ if (codePoint == '$') {+ mCurX = 0;+ return true;+ }++ // Graphics New Line `-`.+ // > The - (2/13) character indicates the end of a sixel line. The active position moves to+ // > the left margin of the next sixel line.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.3.5+ if (codePoint == '-') {+ mCurX = 0;+ mCurY += SIXEL__LINE_LEN;+ return true;+ }++ if (mBitmap.getWidth() < mCurX + repeat) {+ int newBitmapWidth = mCurX + repeat + SIXEL__BITMAP_RESIZE_EXTRA_DIMENSION;++ if (newBitmapWidth < 0) {+ Logger.logError(mClient, LOG_TAG, "The new sixel bitmap width overflowed: " ++ mCurX + " (cursor x) + " + repeat + " (repeat) + " + SIXEL__BITMAP_RESIZE_EXTRA_DIMENSION);+ return false;+ }++ mBitmap = TerminalBitmap.resizeBitmap(LOG_TAG, "sixel", mClient, mBitmap, newBitmapWidth, mBitmap.getHeight());+ if (mBitmap == null) {+ return false;+ }+ }++ if (mBitmap.getHeight() < mCurY + SIXEL__LINE_LEN) {+ // Very unlikely to resize both at the same time.+ int newBitmapHeight = mCurY + SIXEL__BITMAP_RESIZE_EXTRA_DIMENSION;++ if (newBitmapHeight < 0) {+ Logger.logError(mClient, LOG_TAG, "The new sixel bitmap height overflowed: " ++ mCurY + " (cursor y) + " + SIXEL__BITMAP_RESIZE_EXTRA_DIMENSION);+ return false;+ }++ mBitmap = TerminalBitmap.resizeBitmap(LOG_TAG, "sixel", mClient, mBitmap, mBitmap.getWidth(), newBitmapHeight);+ if (mBitmap == null) {+ return false;+ }+ }++ if (mCurX + repeat > mBitmap.getWidth()) {+ repeat = mBitmap.getWidth() - mCurX;+ }++ if (mCurY + SIXEL__LINE_LEN > mBitmap.getHeight()) {+ Logger.logError(mClient, LOG_TAG, "The sixel curson y position " ++ mCurY + SIXEL__LINE_LEN + " is greater than bitmap height " + mBitmap.getHeight());+ return false;+ }++ // Sixel data characters are in the range of `?` (0x3F) to `~` (0x7E).+ // > Each sixel data character represents six vertical pixels of data. Each sixel data character+ // > represents a binary value equal to the character code value minus hex 3F.+ // - https://vt100.net/docs/vt3xx-gp/chapter14.html#S14.2.1+ if (repeat > 0 && codePoint >= '?' && codePoint <= '~') {+ int b = codePoint - '?';+ if (mCurY + SIXEL__LINE_LEN > mHeight) {+ mHeight = mCurY + SIXEL__LINE_LEN;+ }++ while (repeat-- > 0) {+ for (int i = 0; i < SIXEL__LINE_LEN; i++) {+ if ((b & (1 << i)) != 0) {+ mBitmap.setPixel(mCurX, mCurY + i, mColor);+ }+ }++ mCurX += 1;+ if (mCurX > mWidth) {+ mWidth = mCurX;+ }+ }+ }++ return true;+ }++ public boolean resize(int sixelWidth, int sixelHeight) {+ if (mBitmap == null) {+ return false;+ }++ if (sixelWidth < 1 || sixelHeight < 1)+ return false;++ int bitmapWidth = mBitmap.getWidth();+ int newBitmapWidth = Math.max(sixelWidth, bitmapWidth);++ int bitmapHeight = mBitmap.getHeight();+ int newBitmapHeight = Math.max(sixelHeight, bitmapHeight);++ if (bitmapWidth < newBitmapWidth || bitmapHeight < newBitmapHeight) {+ mBitmap = TerminalBitmap.resizeBitmap(LOG_TAG, "sixel", mClient, mBitmap, newBitmapWidth, newBitmapHeight);+ return mBitmap != null;+ }++ return true;+ }++ public void setColor(int color) {+ if (color >= 0 && color < mColorMap.length) {+ mColor = mColorMap[color];+ }+ }++ public void setRGBColor(int color, int r, int g, int b) {+ if (color >= 0 && color < mColorMap.length) {+ int red = Math.min(255, r * 255/100);+ int green = Math.min(255, g * 255/100);+ int blue = Math.min(255, b * 255/100);+ mColor = 0xff000000 + (red << 16) + (green << 8) + blue;+ mColorMap[color] = mColor;+ }+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/TextStyle.java b/terminal-emulator/src/main/java/com/termux/terminal/TextStyle.javanew file mode 100644index 0000000..008d1e7--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/TextStyle.java@@ -0,0 +1,116 @@+package com.termux.terminal;++/**+ * <p>+ * Encodes effects, foreground and background colors into a 64 bit long, which are stored for each cell in a terminal+ * row in {@link TerminalRow#mStyle}.+ * </p>+ * <p>+ * The bit layout is:+ * </p>+ * - 16 flags (11 currently used).+ * - 24 for foreground color (only 9 first bits if a color index).+ * - 24 for background color (only 9 first bits if a color index).+ */+public final class TextStyle {++ public final static int CHARACTER_ATTRIBUTE_BOLD = 1;+ public final static int CHARACTER_ATTRIBUTE_ITALIC = 1 << 1;+ public final static int CHARACTER_ATTRIBUTE_UNDERLINE = 1 << 2;+ public final static int CHARACTER_ATTRIBUTE_BLINK = 1 << 3;+ public final static int CHARACTER_ATTRIBUTE_INVERSE = 1 << 4;+ public final static int CHARACTER_ATTRIBUTE_INVISIBLE = 1 << 5;+ public final static int CHARACTER_ATTRIBUTE_STRIKETHROUGH = 1 << 6;+ /**+ * The selective erase control functions (DECSED and DECSEL) can only erase characters defined as erasable.+ * <p>+ * This bit is set if DECSCA (Select Character Protection Attribute) has been used to define the characters that+ * come after it as erasable from the screen.+ * </p>+ */+ public final static int CHARACTER_ATTRIBUTE_PROTECTED = 1 << 7;+ /** Dim colors. Also known as faint or half intensity. */+ public final static int CHARACTER_ATTRIBUTE_DIM = 1 << 8;+ /** If true (24-bit) color is used for the cell for foreground. */+ private final static int CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND = 1 << 9;+ /** If true (24-bit) color is used for the cell for foreground. */+ private final static int CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND= 1 << 10;+ /** If true, character represents a {@link TerminalBitmap} slice, not text. */+ public final static int TERMINAL_BITMAP = 1 << 15;++ public final static int COLOR_INDEX_FOREGROUND = 256;+ public final static int COLOR_INDEX_BACKGROUND = 257;+ public final static int COLOR_INDEX_CURSOR = 258;++ /** The 256 standard color entries and the three special (foreground, background and cursor) ones. */+ public final static int NUM_INDEXED_COLORS = 259;++ /** Normal foreground and background colors and no effects. */+ final static long NORMAL = encode(COLOR_INDEX_FOREGROUND, COLOR_INDEX_BACKGROUND, 0);++ static long encode(int foreColor, int backColor, int effect) {+ long result = effect & 0b111111111;+ if ((0xff000000 & foreColor) == 0xff000000) {+ // 24-bit color.+ result |= CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND | ((foreColor & 0x00ffffffL) << 40L);+ } else {+ // Indexed color.+ result |= (foreColor & 0b111111111L) << 40;+ }+ if ((0xff000000 & backColor) == 0xff000000) {+ // 24-bit color.+ result |= CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND | ((backColor & 0x00ffffffL) << 16L);+ } else {+ // Indexed color.+ result |= (backColor & 0b111111111L) << 16L;+ }++ return result;+ }++ public static int decodeForeColor(long style) {+ if ((style & CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND) == 0) {+ return (int) ((style >>> 40) & 0b111111111L);+ } else {+ return 0xff000000 | (int) ((style >>> 40) & 0x00ffffffL);+ }++ }++ public static int decodeBackColor(long style) {+ if ((style & CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND) == 0) {+ return (int) ((style >>> 16) & 0b111111111L);+ } else {+ return 0xff000000 | (int) ((style >>> 16) & 0x00ffffffL);+ }+ }++ public static int decodeEffect(long style) {+ return (int) (style & 0b11111111111);+ }++++ public static long encodeTerminalBitmap(int num, int x, int y) {+ return ((long) x << 48) | ((long) y << 32) | ((long) num << 16) | TERMINAL_BITMAP;+ }++ public static boolean isTerminalBitmap(long style) {+ return (style & TERMINAL_BITMAP) != 0;+ }++ /* The bitmap num, x or y could have value `0`, so only return value (especially `0`) if bitmap bit is set. */++ public static int getTerminalBitmapNum(long style) {+ return (style & TERMINAL_BITMAP) != 0 ? (int) (style & 0xffff0000L) >> 16 : -1;+ }++ public static int getTerminalBitmapX(long style) {+ return (style & TERMINAL_BITMAP) != 0 ? (int) ((style >> 48) & 0xfff) : -1;+ }++ public static int getTerminalBitmapY(long style) {+ return (style & TERMINAL_BITMAP) != 0 ? (int) ((style >> 32) & 0xfff) : -1;+ }++}diff --git a/terminal-emulator/src/main/java/com/termux/terminal/WcWidth.java b/terminal-emulator/src/main/java/com/termux/terminal/WcWidth.javanew file mode 100644index 0000000..d71cc27--- /dev/null+++ b/terminal-emulator/src/main/java/com/termux/terminal/WcWidth.java@@ -0,0 +1,566 @@+package com.termux.terminal;++/**+ * Implementation of wcwidth(3) for Unicode 15.+ *+ * Implementation from https://github.com/jquast/wcwidth but we return 0 for unprintable characters.+ *+ * IMPORTANT:+ * Must be kept in sync with the following:+ * https://github.com/termux/wcwidth+ * https://github.com/termux/libandroid-support+ * https://github.com/termux/termux-packages/tree/master/packages/libandroid-support+ */+public final class WcWidth {++ // From https://github.com/jquast/wcwidth/blob/master/wcwidth/table_zero.py+ // from https://github.com/jquast/wcwidth/pull/64+ // at commit 1b9b6585b0080ea5cb88dc9815796505724793fe (2022-12-16):+ private static final int[][] ZERO_WIDTH = {+ {0x00300, 0x0036f}, // Combining Grave Accent ..Combining Latin Small Le+ {0x00483, 0x00489}, // Combining Cyrillic Titlo..Combining Cyrillic Milli+ {0x00591, 0x005bd}, // Hebrew Accent Etnahta ..Hebrew Point Meteg+ {0x005bf, 0x005bf}, // Hebrew Point Rafe ..Hebrew Point Rafe+ {0x005c1, 0x005c2}, // Hebrew Point Shin Dot ..Hebrew Point Sin Dot+ {0x005c4, 0x005c5}, // Hebrew Mark Upper Dot ..Hebrew Mark Lower Dot+ {0x005c7, 0x005c7}, // Hebrew Point Qamats Qata..Hebrew Point Qamats Qata+ {0x00610, 0x0061a}, // Arabic Sign Sallallahou ..Arabic Small Kasra+ {0x0064b, 0x0065f}, // Arabic Fathatan ..Arabic Wavy Hamza Below+ {0x00670, 0x00670}, // Arabic Letter Superscrip..Arabic Letter Superscrip+ {0x006d6, 0x006dc}, // Arabic Small High Ligatu..Arabic Small High Seen+ {0x006df, 0x006e4}, // Arabic Small High Rounde..Arabic Small High Madda+ {0x006e7, 0x006e8}, // Arabic Small High Yeh ..Arabic Small High Noon+ {0x006ea, 0x006ed}, // Arabic Empty Centre Low ..Arabic Small Low Meem+ {0x00711, 0x00711}, // Syriac Letter Superscrip..Syriac Letter Superscrip+ {0x00730, 0x0074a}, // Syriac Pthaha Above ..Syriac Barrekh+ {0x007a6, 0x007b0}, // Thaana Abafili ..Thaana Sukun+ {0x007eb, 0x007f3}, // Nko Combining Short High..Nko Combining Double Dot+ {0x007fd, 0x007fd}, // Nko Dantayalan ..Nko Dantayalan+ {0x00816, 0x00819}, // Samaritan Mark In ..Samaritan Mark Dagesh+ {0x0081b, 0x00823}, // Samaritan Mark Epentheti..Samaritan Vowel Sign A+ {0x00825, 0x00827}, // Samaritan Vowel Sign Sho..Samaritan Vowel Sign U+ {0x00829, 0x0082d}, // Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa+ {0x00859, 0x0085b}, // Mandaic Affrication Mark..Mandaic Gemination Mark+ {0x00898, 0x0089f}, // Arabic Small High Word A..Arabic Half Madda Over M+ {0x008ca, 0x008e1}, // Arabic Small High Farsi ..Arabic Small High Sign S+ {0x008e3, 0x00902}, // Arabic Turned Damma Belo..Devanagari Sign Anusvara+ {0x0093a, 0x0093a}, // Devanagari Vowel Sign Oe..Devanagari Vowel Sign Oe+ {0x0093c, 0x0093c}, // Devanagari Sign Nukta ..Devanagari Sign Nukta+ {0x00941, 0x00948}, // Devanagari Vowel Sign U ..Devanagari Vowel Sign Ai+ {0x0094d, 0x0094d}, // Devanagari Sign Virama ..Devanagari Sign Virama+ {0x00951, 0x00957}, // Devanagari Stress Sign U..Devanagari Vowel Sign Uu+ {0x00962, 0x00963}, // Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo+ {0x00981, 0x00981}, // Bengali Sign Candrabindu..Bengali Sign Candrabindu+ {0x009bc, 0x009bc}, // Bengali Sign Nukta ..Bengali Sign Nukta+ {0x009c1, 0x009c4}, // Bengali Vowel Sign U ..Bengali Vowel Sign Vocal+ {0x009cd, 0x009cd}, // Bengali Sign Virama ..Bengali Sign Virama+ {0x009e2, 0x009e3}, // Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal+ {0x009fe, 0x009fe}, // Bengali Sandhi Mark ..Bengali Sandhi Mark+ {0x00a01, 0x00a02}, // Gurmukhi Sign Adak Bindi..Gurmukhi Sign Bindi+ {0x00a3c, 0x00a3c}, // Gurmukhi Sign Nukta ..Gurmukhi Sign Nukta+ {0x00a41, 0x00a42}, // Gurmukhi Vowel Sign U ..Gurmukhi Vowel Sign Uu+ {0x00a47, 0x00a48}, // Gurmukhi Vowel Sign Ee ..Gurmukhi Vowel Sign Ai+ {0x00a4b, 0x00a4d}, // Gurmukhi Vowel Sign Oo ..Gurmukhi Sign Virama+ {0x00a51, 0x00a51}, // Gurmukhi Sign Udaat ..Gurmukhi Sign Udaat+ {0x00a70, 0x00a71}, // Gurmukhi Tippi ..Gurmukhi Addak+ {0x00a75, 0x00a75}, // Gurmukhi Sign Yakash ..Gurmukhi Sign Yakash+ {0x00a81, 0x00a82}, // Gujarati Sign Candrabind..Gujarati Sign Anusvara+ {0x00abc, 0x00abc}, // Gujarati Sign Nukta ..Gujarati Sign Nukta+ {0x00ac1, 0x00ac5}, // Gujarati Vowel Sign U ..Gujarati Vowel Sign Cand+ {0x00ac7, 0x00ac8}, // Gujarati Vowel Sign E ..Gujarati Vowel Sign Ai+ {0x00acd, 0x00acd}, // Gujarati Sign Virama ..Gujarati Sign Virama+ {0x00ae2, 0x00ae3}, // Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca+ {0x00afa, 0x00aff}, // Gujarati Sign Sukun ..Gujarati Sign Two-circle+ {0x00b01, 0x00b01}, // Oriya Sign Candrabindu ..Oriya Sign Candrabindu+ {0x00b3c, 0x00b3c}, // Oriya Sign Nukta ..Oriya Sign Nukta+ {0x00b3f, 0x00b3f}, // Oriya Vowel Sign I ..Oriya Vowel Sign I+ {0x00b41, 0x00b44}, // Oriya Vowel Sign U ..Oriya Vowel Sign Vocalic+ {0x00b4d, 0x00b4d}, // Oriya Sign Virama ..Oriya Sign Virama+ {0x00b55, 0x00b56}, // Oriya Sign Overline ..Oriya Ai Length Mark+ {0x00b62, 0x00b63}, // Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic+ {0x00b82, 0x00b82}, // Tamil Sign Anusvara ..Tamil Sign Anusvara+ {0x00bc0, 0x00bc0}, // Tamil Vowel Sign Ii ..Tamil Vowel Sign Ii+ {0x00bcd, 0x00bcd}, // Tamil Sign Virama ..Tamil Sign Virama+ {0x00c00, 0x00c00}, // Telugu Sign Combining Ca..Telugu Sign Combining Ca+ {0x00c04, 0x00c04}, // Telugu Sign Combining An..Telugu Sign Combining An+ {0x00c3c, 0x00c3c}, // Telugu Sign Nukta ..Telugu Sign Nukta+ {0x00c3e, 0x00c40}, // Telugu Vowel Sign Aa ..Telugu Vowel Sign Ii+ {0x00c46, 0x00c48}, // Telugu Vowel Sign E ..Telugu Vowel Sign Ai+ {0x00c4a, 0x00c4d}, // Telugu Vowel Sign O ..Telugu Sign Virama+ {0x00c55, 0x00c56}, // Telugu Length Mark ..Telugu Ai Length Mark+ {0x00c62, 0x00c63}, // Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali+ {0x00c81, 0x00c81}, // Kannada Sign Candrabindu..Kannada Sign Candrabindu+ {0x00cbc, 0x00cbc}, // Kannada Sign Nukta ..Kannada Sign Nukta+ {0x00cbf, 0x00cbf}, // Kannada Vowel Sign I ..Kannada Vowel Sign I+ {0x00cc6, 0x00cc6}, // Kannada Vowel Sign E ..Kannada Vowel Sign E+ {0x00ccc, 0x00ccd}, // Kannada Vowel Sign Au ..Kannada Sign Virama+ {0x00ce2, 0x00ce3}, // Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal+ {0x00d00, 0x00d01}, // Malayalam Sign Combining..Malayalam Sign Candrabin+ {0x00d3b, 0x00d3c}, // Malayalam Sign Vertical ..Malayalam Sign Circular+ {0x00d41, 0x00d44}, // Malayalam Vowel Sign U ..Malayalam Vowel Sign Voc+ {0x00d4d, 0x00d4d}, // Malayalam Sign Virama ..Malayalam Sign Virama+ {0x00d62, 0x00d63}, // Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc+ {0x00d81, 0x00d81}, // Sinhala Sign Candrabindu..Sinhala Sign Candrabindu+ {0x00dca, 0x00dca}, // Sinhala Sign Al-lakuna ..Sinhala Sign Al-lakuna+ {0x00dd2, 0x00dd4}, // Sinhala Vowel Sign Ketti..Sinhala Vowel Sign Ketti+ {0x00dd6, 0x00dd6}, // Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga+ {0x00e31, 0x00e31}, // Thai Character Mai Han-a..Thai Character Mai Han-a+ {0x00e34, 0x00e3a}, // Thai Character Sara I ..Thai Character Phinthu+ {0x00e47, 0x00e4e}, // Thai Character Maitaikhu..Thai Character Yamakkan+ {0x00eb1, 0x00eb1}, // Lao Vowel Sign Mai Kan ..Lao Vowel Sign Mai Kan+ {0x00eb4, 0x00ebc}, // Lao Vowel Sign I ..Lao Semivowel Sign Lo+ {0x00ec8, 0x00ece}, // Lao Tone Mai Ek ..(nil)+ {0x00f18, 0x00f19}, // Tibetan Astrological Sig..Tibetan Astrological Sig+ {0x00f35, 0x00f35}, // Tibetan Mark Ngas Bzung ..Tibetan Mark Ngas Bzung+ {0x00f37, 0x00f37}, // Tibetan Mark Ngas Bzung ..Tibetan Mark Ngas Bzung+ {0x00f39, 0x00f39}, // Tibetan Mark Tsa -phru ..Tibetan Mark Tsa -phru+ {0x00f71, 0x00f7e}, // Tibetan Vowel Sign Aa ..Tibetan Sign Rjes Su Nga+ {0x00f80, 0x00f84}, // Tibetan Vowel Sign Rever..Tibetan Mark Halanta+ {0x00f86, 0x00f87}, // Tibetan Sign Lci Rtags ..Tibetan Sign Yang Rtags+ {0x00f8d, 0x00f97}, // Tibetan Subjoined Sign L..Tibetan Subjoined Letter+ {0x00f99, 0x00fbc}, // Tibetan Subjoined Letter..Tibetan Subjoined Letter+ {0x00fc6, 0x00fc6}, // Tibetan Symbol Padma Gda..Tibetan Symbol Padma Gda+ {0x0102d, 0x01030}, // Myanmar Vowel Sign I ..Myanmar Vowel Sign Uu+ {0x01032, 0x01037}, // Myanmar Vowel Sign Ai ..Myanmar Sign Dot Below+ {0x01039, 0x0103a}, // Myanmar Sign Virama ..Myanmar Sign Asat+ {0x0103d, 0x0103e}, // Myanmar Consonant Sign M..Myanmar Consonant Sign M+ {0x01058, 0x01059}, // Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal+ {0x0105e, 0x01060}, // Myanmar Consonant Sign M..Myanmar Consonant Sign M+ {0x01071, 0x01074}, // Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah+ {0x01082, 0x01082}, // Myanmar Consonant Sign S..Myanmar Consonant Sign S+ {0x01085, 0x01086}, // Myanmar Vowel Sign Shan ..Myanmar Vowel Sign Shan+ {0x0108d, 0x0108d}, // Myanmar Sign Shan Counci..Myanmar Sign Shan Counci+ {0x0109d, 0x0109d}, // Myanmar Vowel Sign Aiton..Myanmar Vowel Sign Aiton+ {0x0135d, 0x0135f}, // Ethiopic Combining Gemin..Ethiopic Combining Gemin+ {0x01712, 0x01714}, // Tagalog Vowel Sign I ..Tagalog Sign Virama+ {0x01732, 0x01733}, // Hanunoo Vowel Sign I ..Hanunoo Vowel Sign U+ {0x01752, 0x01753}, // Buhid Vowel Sign I ..Buhid Vowel Sign U+ {0x01772, 0x01773}, // Tagbanwa Vowel Sign I ..Tagbanwa Vowel Sign U+ {0x017b4, 0x017b5}, // Khmer Vowel Inherent Aq ..Khmer Vowel Inherent Aa+ {0x017b7, 0x017bd}, // Khmer Vowel Sign I ..Khmer Vowel Sign Ua+ {0x017c6, 0x017c6}, // Khmer Sign Nikahit ..Khmer Sign Nikahit+ {0x017c9, 0x017d3}, // Khmer Sign Muusikatoan ..Khmer Sign Bathamasat+ {0x017dd, 0x017dd}, // Khmer Sign Atthacan ..Khmer Sign Atthacan+ {0x0180b, 0x0180d}, // Mongolian Free Variation..Mongolian Free Variation+ {0x0180f, 0x0180f}, // Mongolian Free Variation..Mongolian Free Variation+ {0x01885, 0x01886}, // Mongolian Letter Ali Gal..Mongolian Letter Ali Gal+ {0x018a9, 0x018a9}, // Mongolian Letter Ali Gal..Mongolian Letter Ali Gal+ {0x01920, 0x01922}, // Limbu Vowel Sign A ..Limbu Vowel Sign U+ {0x01927, 0x01928}, // Limbu Vowel Sign E ..Limbu Vowel Sign O+ {0x01932, 0x01932}, // Limbu Small Letter Anusv..Limbu Small Letter Anusv+ {0x01939, 0x0193b}, // Limbu Sign Mukphreng ..Limbu Sign Sa-i+ {0x01a17, 0x01a18}, // Buginese Vowel Sign I ..Buginese Vowel Sign U+ {0x01a1b, 0x01a1b}, // Buginese Vowel Sign Ae ..Buginese Vowel Sign Ae+ {0x01a56, 0x01a56}, // Tai Tham Consonant Sign ..Tai Tham Consonant Sign+ {0x01a58, 0x01a5e}, // Tai Tham Sign Mai Kang L..Tai Tham Consonant Sign+ {0x01a60, 0x01a60}, // Tai Tham Sign Sakot ..Tai Tham Sign Sakot+ {0x01a62, 0x01a62}, // Tai Tham Vowel Sign Mai ..Tai Tham Vowel Sign Mai+ {0x01a65, 0x01a6c}, // Tai Tham Vowel Sign I ..Tai Tham Vowel Sign Oa B+ {0x01a73, 0x01a7c}, // Tai Tham Vowel Sign Oa A..Tai Tham Sign Khuen-lue+ {0x01a7f, 0x01a7f}, // Tai Tham Combining Crypt..Tai Tham Combining Crypt+ {0x01ab0, 0x01ace}, // Combining Doubled Circum..Combining Latin Small Le+ {0x01b00, 0x01b03}, // Balinese Sign Ulu Ricem ..Balinese Sign Surang+ {0x01b34, 0x01b34}, // Balinese Sign Rerekan ..Balinese Sign Rerekan+ {0x01b36, 0x01b3a}, // Balinese Vowel Sign Ulu ..Balinese Vowel Sign Ra R+ {0x01b3c, 0x01b3c}, // Balinese Vowel Sign La L..Balinese Vowel Sign La L+ {0x01b42, 0x01b42}, // Balinese Vowel Sign Pepe..Balinese Vowel Sign Pepe+ {0x01b6b, 0x01b73}, // Balinese Musical Symbol ..Balinese Musical Symbol+ {0x01b80, 0x01b81}, // Sundanese Sign Panyecek ..Sundanese Sign Panglayar+ {0x01ba2, 0x01ba5}, // Sundanese Consonant Sign..Sundanese Vowel Sign Pan+ {0x01ba8, 0x01ba9}, // Sundanese Vowel Sign Pam..Sundanese Vowel Sign Pan+ {0x01bab, 0x01bad}, // Sundanese Sign Virama ..Sundanese Consonant Sign+ {0x01be6, 0x01be6}, // Batak Sign Tompi ..Batak Sign Tompi+ {0x01be8, 0x01be9}, // Batak Vowel Sign Pakpak ..Batak Vowel Sign Ee+ {0x01bed, 0x01bed}, // Batak Vowel Sign Karo O ..Batak Vowel Sign Karo O+ {0x01bef, 0x01bf1}, // Batak Vowel Sign U For S..Batak Consonant Sign H+ {0x01c2c, 0x01c33}, // Lepcha Vowel Sign E ..Lepcha Consonant Sign T+ {0x01c36, 0x01c37}, // Lepcha Sign Ran ..Lepcha Sign Nukta+ {0x01cd0, 0x01cd2}, // Vedic Tone Karshana ..Vedic Tone Prenkha+ {0x01cd4, 0x01ce0}, // Vedic Sign Yajurvedic Mi..Vedic Tone Rigvedic Kash+ {0x01ce2, 0x01ce8}, // Vedic Sign Visarga Svari..Vedic Sign Visarga Anuda+ {0x01ced, 0x01ced}, // Vedic Sign Tiryak ..Vedic Sign Tiryak+ {0x01cf4, 0x01cf4}, // Vedic Tone Candra Above ..Vedic Tone Candra Above+ {0x01cf8, 0x01cf9}, // Vedic Tone Ring Above ..Vedic Tone Double Ring A+ {0x01dc0, 0x01dff}, // Combining Dotted Grave A..Combining Right Arrowhea+ {0x020d0, 0x020f0}, // Combining Left Harpoon A..Combining Asterisk Above+ {0x02cef, 0x02cf1}, // Coptic Combining Ni Abov..Coptic Combining Spiritu+ {0x02d7f, 0x02d7f}, // Tifinagh Consonant Joine..Tifinagh Consonant Joine+ {0x02de0, 0x02dff}, // Combining Cyrillic Lette..Combining Cyrillic Lette+ {0x0302a, 0x0302d}, // Ideographic Level Tone M..Ideographic Entering Ton+ {0x03099, 0x0309a}, // Combining Katakana-hirag..Combining Katakana-hirag+ {0x0a66f, 0x0a672}, // Combining Cyrillic Vzmet..Combining Cyrillic Thous+ {0x0a674, 0x0a67d}, // Combining Cyrillic Lette..Combining Cyrillic Payer+ {0x0a69e, 0x0a69f}, // Combining Cyrillic Lette..Combining Cyrillic Lette+ {0x0a6f0, 0x0a6f1}, // Bamum Combining Mark Koq..Bamum Combining Mark Tuk+ {0x0a802, 0x0a802}, // Syloti Nagri Sign Dvisva..Syloti Nagri Sign Dvisva+ {0x0a806, 0x0a806}, // Syloti Nagri Sign Hasant..Syloti Nagri Sign Hasant+ {0x0a80b, 0x0a80b}, // Syloti Nagri Sign Anusva..Syloti Nagri Sign Anusva+ {0x0a825, 0x0a826}, // Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign+ {0x0a82c, 0x0a82c}, // Syloti Nagri Sign Altern..Syloti Nagri Sign Altern+ {0x0a8c4, 0x0a8c5}, // Saurashtra Sign Virama ..Saurashtra Sign Candrabi+ {0x0a8e0, 0x0a8f1}, // Combining Devanagari Dig..Combining Devanagari Sig+ {0x0a8ff, 0x0a8ff}, // Devanagari Vowel Sign Ay..Devanagari Vowel Sign Ay+ {0x0a926, 0x0a92d}, // Kayah Li Vowel Ue ..Kayah Li Tone Calya Plop+ {0x0a947, 0x0a951}, // Rejang Vowel Sign I ..Rejang Consonant Sign R+ {0x0a980, 0x0a982}, // Javanese Sign Panyangga ..Javanese Sign Layar+ {0x0a9b3, 0x0a9b3}, // Javanese Sign Cecak Telu..Javanese Sign Cecak Telu+ {0x0a9b6, 0x0a9b9}, // Javanese Vowel Sign Wulu..Javanese Vowel Sign Suku+ {0x0a9bc, 0x0a9bd}, // Javanese Vowel Sign Pepe..Javanese Consonant Sign+ {0x0a9e5, 0x0a9e5}, // Myanmar Sign Shan Saw ..Myanmar Sign Shan Saw+ {0x0aa29, 0x0aa2e}, // Cham Vowel Sign Aa ..Cham Vowel Sign Oe+ {0x0aa31, 0x0aa32}, // Cham Vowel Sign Au ..Cham Vowel Sign Ue+ {0x0aa35, 0x0aa36}, // Cham Consonant Sign La ..Cham Consonant Sign Wa+ {0x0aa43, 0x0aa43}, // Cham Consonant Sign Fina..Cham Consonant Sign Fina+ {0x0aa4c, 0x0aa4c}, // Cham Consonant Sign Fina..Cham Consonant Sign Fina+ {0x0aa7c, 0x0aa7c}, // Myanmar Sign Tai Laing T..Myanmar Sign Tai Laing T+ {0x0aab0, 0x0aab0}, // Tai Viet Mai Kang ..Tai Viet Mai Kang+ {0x0aab2, 0x0aab4}, // Tai Viet Vowel I ..Tai Viet Vowel U+ {0x0aab7, 0x0aab8}, // Tai Viet Mai Khit ..Tai Viet Vowel Ia+ {0x0aabe, 0x0aabf}, // Tai Viet Vowel Am ..Tai Viet Tone Mai Ek+ {0x0aac1, 0x0aac1}, // Tai Viet Tone Mai Tho ..Tai Viet Tone Mai Tho+ {0x0aaec, 0x0aaed}, // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign+ {0x0aaf6, 0x0aaf6}, // Meetei Mayek Virama ..Meetei Mayek Virama+ {0x0abe5, 0x0abe5}, // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign+ {0x0abe8, 0x0abe8}, // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign+ {0x0abed, 0x0abed}, // Meetei Mayek Apun Iyek ..Meetei Mayek Apun Iyek+ {0x0fb1e, 0x0fb1e}, // Hebrew Point Judeo-spani..Hebrew Point Judeo-spani+ {0x0fe00, 0x0fe0f}, // Variation Selector-1 ..Variation Selector-16+ {0x0fe20, 0x0fe2f}, // Combining Ligature Left ..Combining Cyrillic Titlo+ {0x101fd, 0x101fd}, // Phaistos Disc Sign Combi..Phaistos Disc Sign Combi+ {0x102e0, 0x102e0}, // Coptic Epact Thousands M..Coptic Epact Thousands M+ {0x10376, 0x1037a}, // Combining Old Permic Let..Combining Old Permic Let+ {0x10a01, 0x10a03}, // Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo+ {0x10a05, 0x10a06}, // Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O+ {0x10a0c, 0x10a0f}, // Kharoshthi Vowel Length ..Kharoshthi Sign Visarga+ {0x10a38, 0x10a3a}, // Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo+ {0x10a3f, 0x10a3f}, // Kharoshthi Virama ..Kharoshthi Virama+ {0x10ae5, 0x10ae6}, // Manichaean Abbreviation ..Manichaean Abbreviation+ {0x10d24, 0x10d27}, // Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas+ {0x10eab, 0x10eac}, // Yezidi Combining Hamza M..Yezidi Combining Madda M+ {0x10efd, 0x10eff}, // (nil) ..(nil)+ {0x10f46, 0x10f50}, // Sogdian Combining Dot Be..Sogdian Combining Stroke+ {0x10f82, 0x10f85}, // Old Uyghur Combining Dot..Old Uyghur Combining Two+ {0x11001, 0x11001}, // Brahmi Sign Anusvara ..Brahmi Sign Anusvara+ {0x11038, 0x11046}, // Brahmi Vowel Sign Aa ..Brahmi Virama+ {0x11070, 0x11070}, // Brahmi Sign Old Tamil Vi..Brahmi Sign Old Tamil Vi+ {0x11073, 0x11074}, // Brahmi Vowel Sign Old Ta..Brahmi Vowel Sign Old Ta+ {0x1107f, 0x11081}, // Brahmi Number Joiner ..Kaithi Sign Anusvara+ {0x110b3, 0x110b6}, // Kaithi Vowel Sign U ..Kaithi Vowel Sign Ai+ {0x110b9, 0x110ba}, // Kaithi Sign Virama ..Kaithi Sign Nukta+ {0x110c2, 0x110c2}, // Kaithi Vowel Sign Vocali..Kaithi Vowel Sign Vocali+ {0x11100, 0x11102}, // Chakma Sign Candrabindu ..Chakma Sign Visarga+ {0x11127, 0x1112b}, // Chakma Vowel Sign A ..Chakma Vowel Sign Uu+ {0x1112d, 0x11134}, // Chakma Vowel Sign Ai ..Chakma Maayyaa+ {0x11173, 0x11173}, // Mahajani Sign Nukta ..Mahajani Sign Nukta+ {0x11180, 0x11181}, // Sharada Sign Candrabindu..Sharada Sign Anusvara+ {0x111b6, 0x111be}, // Sharada Vowel Sign U ..Sharada Vowel Sign O+ {0x111c9, 0x111cc}, // Sharada Sandhi Mark ..Sharada Extra Short Vowe+ {0x111cf, 0x111cf}, // Sharada Sign Inverted Ca..Sharada Sign Inverted Ca+ {0x1122f, 0x11231}, // Khojki Vowel Sign U ..Khojki Vowel Sign Ai+ {0x11234, 0x11234}, // Khojki Sign Anusvara ..Khojki Sign Anusvara+ {0x11236, 0x11237}, // Khojki Sign Nukta ..Khojki Sign Shadda+ {0x1123e, 0x1123e}, // Khojki Sign Sukun ..Khojki Sign Sukun+ {0x11241, 0x11241}, // (nil) ..(nil)+ {0x112df, 0x112df}, // Khudawadi Sign Anusvara ..Khudawadi Sign Anusvara+ {0x112e3, 0x112ea}, // Khudawadi Vowel Sign U ..Khudawadi Sign Virama+ {0x11300, 0x11301}, // Grantha Sign Combining A..Grantha Sign Candrabindu+ {0x1133b, 0x1133c}, // Combining Bindu Below ..Grantha Sign Nukta+ {0x11340, 0x11340}, // Grantha Vowel Sign Ii ..Grantha Vowel Sign Ii+ {0x11366, 0x1136c}, // Combining Grantha Digit ..Combining Grantha Digit+ {0x11370, 0x11374}, // Combining Grantha Letter..Combining Grantha Letter+ {0x11438, 0x1143f}, // Newa Vowel Sign U ..Newa Vowel Sign Ai+ {0x11442, 0x11444}, // Newa Sign Virama ..Newa Sign Anusvara+ {0x11446, 0x11446}, // Newa Sign Nukta ..Newa Sign Nukta+ {0x1145e, 0x1145e}, // Newa Sandhi Mark ..Newa Sandhi Mark+ {0x114b3, 0x114b8}, // Tirhuta Vowel Sign U ..Tirhuta Vowel Sign Vocal+ {0x114ba, 0x114ba}, // Tirhuta Vowel Sign Short..Tirhuta Vowel Sign Short+ {0x114bf, 0x114c0}, // Tirhuta Sign Candrabindu..Tirhuta Sign Anusvara+ {0x114c2, 0x114c3}, // Tirhuta Sign Virama ..Tirhuta Sign Nukta+ {0x115b2, 0x115b5}, // Siddham Vowel Sign U ..Siddham Vowel Sign Vocal+ {0x115bc, 0x115bd}, // Siddham Sign Candrabindu..Siddham Sign Anusvara+ {0x115bf, 0x115c0}, // Siddham Sign Virama ..Siddham Sign Nukta+ {0x115dc, 0x115dd}, // Siddham Vowel Sign Alter..Siddham Vowel Sign Alter+ {0x11633, 0x1163a}, // Modi Vowel Sign U ..Modi Vowel Sign Ai+ {0x1163d, 0x1163d}, // Modi Sign Anusvara ..Modi Sign Anusvara+ {0x1163f, 0x11640}, // Modi Sign Virama ..Modi Sign Ardhacandra+ {0x116ab, 0x116ab}, // Takri Sign Anusvara ..Takri Sign Anusvara+ {0x116ad, 0x116ad}, // Takri Vowel Sign Aa ..Takri Vowel Sign Aa+ {0x116b0, 0x116b5}, // Takri Vowel Sign U ..Takri Vowel Sign Au+ {0x116b7, 0x116b7}, // Takri Sign Nukta ..Takri Sign Nukta+ {0x1171d, 0x1171f}, // Ahom Consonant Sign Medi..Ahom Consonant Sign Medi+ {0x11722, 0x11725}, // Ahom Vowel Sign I ..Ahom Vowel Sign Uu+ {0x11727, 0x1172b}, // Ahom Vowel Sign Aw ..Ahom Sign Killer+ {0x1182f, 0x11837}, // Dogra Vowel Sign U ..Dogra Sign Anusvara+ {0x11839, 0x1183a}, // Dogra Sign Virama ..Dogra Sign Nukta+ {0x1193b, 0x1193c}, // Dives Akuru Sign Anusvar..Dives Akuru Sign Candrab+ {0x1193e, 0x1193e}, // Dives Akuru Virama ..Dives Akuru Virama+ {0x11943, 0x11943}, // Dives Akuru Sign Nukta ..Dives Akuru Sign Nukta+ {0x119d4, 0x119d7}, // Nandinagari Vowel Sign U..Nandinagari Vowel Sign V+ {0x119da, 0x119db}, // Nandinagari Vowel Sign E..Nandinagari Vowel Sign A+ {0x119e0, 0x119e0}, // Nandinagari Sign Virama ..Nandinagari Sign Virama+ {0x11a01, 0x11a0a}, // Zanabazar Square Vowel S..Zanabazar Square Vowel L+ {0x11a33, 0x11a38}, // Zanabazar Square Final C..Zanabazar Square Sign An+ {0x11a3b, 0x11a3e}, // Zanabazar Square Cluster..Zanabazar Square Cluster+ {0x11a47, 0x11a47}, // Zanabazar Square Subjoin..Zanabazar Square Subjoin+ {0x11a51, 0x11a56}, // Soyombo Vowel Sign I ..Soyombo Vowel Sign Oe+ {0x11a59, 0x11a5b}, // Soyombo Vowel Sign Vocal..Soyombo Vowel Length Mar+ {0x11a8a, 0x11a96}, // Soyombo Final Consonant ..Soyombo Sign Anusvara+ {0x11a98, 0x11a99}, // Soyombo Gemination Mark ..Soyombo Subjoiner+ {0x11c30, 0x11c36}, // Bhaiksuki Vowel Sign I ..Bhaiksuki Vowel Sign Voc+ {0x11c38, 0x11c3d}, // Bhaiksuki Vowel Sign E ..Bhaiksuki Sign Anusvara+ {0x11c3f, 0x11c3f}, // Bhaiksuki Sign Virama ..Bhaiksuki Sign Virama+ {0x11c92, 0x11ca7}, // Marchen Subjoined Letter..Marchen Subjoined Letter+ {0x11caa, 0x11cb0}, // Marchen Subjoined Letter..Marchen Vowel Sign Aa+ {0x11cb2, 0x11cb3}, // Marchen Vowel Sign U ..Marchen Vowel Sign E+ {0x11cb5, 0x11cb6}, // Marchen Sign Anusvara ..Marchen Sign Candrabindu+ {0x11d31, 0x11d36}, // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign+ {0x11d3a, 0x11d3a}, // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign+ {0x11d3c, 0x11d3d}, // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign+ {0x11d3f, 0x11d45}, // Masaram Gondi Vowel Sign..Masaram Gondi Virama+ {0x11d47, 0x11d47}, // Masaram Gondi Ra-kara ..Masaram Gondi Ra-kara+ {0x11d90, 0x11d91}, // Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign+ {0x11d95, 0x11d95}, // Gunjala Gondi Sign Anusv..Gunjala Gondi Sign Anusv+ {0x11d97, 0x11d97}, // Gunjala Gondi Virama ..Gunjala Gondi Virama+ {0x11ef3, 0x11ef4}, // Makasar Vowel Sign I ..Makasar Vowel Sign U+ {0x11f00, 0x11f01}, // (nil) ..(nil)+ {0x11f36, 0x11f3a}, // (nil) ..(nil)+ {0x11f40, 0x11f40}, // (nil) ..(nil)+ {0x11f42, 0x11f42}, // (nil) ..(nil)+ {0x13440, 0x13440}, // (nil) ..(nil)+ {0x13447, 0x13455}, // (nil) ..(nil)+ {0x16af0, 0x16af4}, // Bassa Vah Combining High..Bassa Vah Combining High+ {0x16b30, 0x16b36}, // Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta+ {0x16f4f, 0x16f4f}, // Miao Sign Consonant Modi..Miao Sign Consonant Modi+ {0x16f8f, 0x16f92}, // Miao Tone Right ..Miao Tone Below+ {0x16fe4, 0x16fe4}, // Khitan Small Script Fill..Khitan Small Script Fill+ {0x1bc9d, 0x1bc9e}, // Duployan Thick Letter Se..Duployan Double Mark+ {0x1cf00, 0x1cf2d}, // Znamenny Combining Mark ..Znamenny Combining Mark+ {0x1cf30, 0x1cf46}, // Znamenny Combining Tonal..Znamenny Priznak Modifie+ {0x1d167, 0x1d169}, // Musical Symbol Combining..Musical Symbol Combining+ {0x1d17b, 0x1d182}, // Musical Symbol Combining..Musical Symbol Combining+ {0x1d185, 0x1d18b}, // Musical Symbol Combining..Musical Symbol Combining+ {0x1d1aa, 0x1d1ad}, // Musical Symbol Combining..Musical Symbol Combining+ {0x1d242, 0x1d244}, // Combining Greek Musical ..Combining Greek Musical+ {0x1da00, 0x1da36}, // Signwriting Head Rim ..Signwriting Air Sucking+ {0x1da3b, 0x1da6c}, // Signwriting Mouth Closed..Signwriting Excitement+ {0x1da75, 0x1da75}, // Signwriting Upper Body T..Signwriting Upper Body T+ {0x1da84, 0x1da84}, // Signwriting Location Hea..Signwriting Location Hea+ {0x1da9b, 0x1da9f}, // Signwriting Fill Modifie..Signwriting Fill Modifie+ {0x1daa1, 0x1daaf}, // Signwriting Rotation Mod..Signwriting Rotation Mod+ {0x1e000, 0x1e006}, // Combining Glagolitic Let..Combining Glagolitic Let+ {0x1e008, 0x1e018}, // Combining Glagolitic Let..Combining Glagolitic Let+ {0x1e01b, 0x1e021}, // Combining Glagolitic Let..Combining Glagolitic Let+ {0x1e023, 0x1e024}, // Combining Glagolitic Let..Combining Glagolitic Let+ {0x1e026, 0x1e02a}, // Combining Glagolitic Let..Combining Glagolitic Let+ {0x1e08f, 0x1e08f}, // (nil) ..(nil)+ {0x1e130, 0x1e136}, // Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T+ {0x1e2ae, 0x1e2ae}, // Toto Sign Rising Tone ..Toto Sign Rising Tone+ {0x1e2ec, 0x1e2ef}, // Wancho Tone Tup ..Wancho Tone Koini+ {0x1e4ec, 0x1e4ef}, // (nil) ..(nil)+ {0x1e8d0, 0x1e8d6}, // Mende Kikakui Combining ..Mende Kikakui Combining+ {0x1e944, 0x1e94a}, // Adlam Alif Lengthener ..Adlam Nukta+ {0xe0100, 0xe01ef}, // Variation Selector-17 ..Variation Selector-256+ };++ // https://github.com/jquast/wcwidth/blob/master/wcwidth/table_wide.py+ // from https://github.com/jquast/wcwidth/pull/64+ // at commit 1b9b6585b0080ea5cb88dc9815796505724793fe (2022-12-16):+ private static final int[][] WIDE_EASTASIAN = {+ {0x01100, 0x0115f}, // Hangul Choseong Kiyeok ..Hangul Choseong Filler+ {0x0231a, 0x0231b}, // Watch ..Hourglass+ {0x02329, 0x0232a}, // Left-pointing Angle Brac..Right-pointing Angle Bra+ {0x023e9, 0x023ec}, // Black Right-pointing Dou..Black Down-pointing Doub+ {0x023f0, 0x023f0}, // Alarm Clock ..Alarm Clock+ {0x023f3, 0x023f3}, // Hourglass With Flowing S..Hourglass With Flowing S+ {0x025fd, 0x025fe}, // White Medium Small Squar..Black Medium Small Squar+ {0x02614, 0x02615}, // Umbrella With Rain Drops..Hot Beverage+ {0x02648, 0x02653}, // Aries ..Pisces+ {0x0267f, 0x0267f}, // Wheelchair Symbol ..Wheelchair Symbol+ {0x02693, 0x02693}, // Anchor ..Anchor+ {0x026a1, 0x026a1}, // High Voltage Sign ..High Voltage Sign+ {0x026aa, 0x026ab}, // Medium White Circle ..Medium Black Circle+ {0x026bd, 0x026be}, // Soccer Ball ..Baseball+ {0x026c4, 0x026c5}, // Snowman Without Snow ..Sun Behind Cloud+ {0x026ce, 0x026ce}, // Ophiuchus ..Ophiuchus+ {0x026d4, 0x026d4}, // No Entry ..No Entry+ {0x026ea, 0x026ea}, // Church ..Church+ {0x026f2, 0x026f3}, // Fountain ..Flag In Hole+ {0x026f5, 0x026f5}, // Sailboat ..Sailboat+ {0x026fa, 0x026fa}, // Tent ..Tent+ {0x026fd, 0x026fd}, // Fuel Pump ..Fuel Pump+ {0x02705, 0x02705}, // White Heavy Check Mark ..White Heavy Check Mark+ {0x0270a, 0x0270b}, // Raised Fist ..Raised Hand+ {0x02728, 0x02728}, // Sparkles ..Sparkles+ {0x0274c, 0x0274c}, // Cross Mark ..Cross Mark+ {0x0274e, 0x0274e}, // Negative Squared Cross M..Negative Squared Cross M+ {0x02753, 0x02755}, // Black Question Mark Orna..White Exclamation Mark O+ {0x02757, 0x02757}, // Heavy Exclamation Mark S..Heavy Exclamation Mark S+ {0x02795, 0x02797}, // Heavy Plus Sign ..Heavy Division Sign+ {0x027b0, 0x027b0}, // Curly Loop ..Curly Loop+ {0x027bf, 0x027bf}, // Double Curly Loop ..Double Curly Loop+ {0x02b1b, 0x02b1c}, // Black Large Square ..White Large Square+ {0x02b50, 0x02b50}, // White Medium Star ..White Medium Star+ {0x02b55, 0x02b55}, // Heavy Large Circle ..Heavy Large Circle+ {0x02e80, 0x02e99}, // Cjk Radical Repeat ..Cjk Radical Rap+ {0x02e9b, 0x02ef3}, // Cjk Radical Choke ..Cjk Radical C-simplified+ {0x02f00, 0x02fd5}, // Kangxi Radical One ..Kangxi Radical Flute+ {0x02ff0, 0x02ffb}, // Ideographic Description ..Ideographic Description+ {0x03000, 0x0303e}, // Ideographic Space ..Ideographic Variation In+ {0x03041, 0x03096}, // Hiragana Letter Small A ..Hiragana Letter Small Ke+ {0x03099, 0x030ff}, // Combining Katakana-hirag..Katakana Digraph Koto+ {0x03105, 0x0312f}, // Bopomofo Letter B ..Bopomofo Letter Nn+ {0x03131, 0x0318e}, // Hangul Letter Kiyeok ..Hangul Letter Araeae+ {0x03190, 0x031e3}, // Ideographic Annotation L..Cjk Stroke Q+ {0x031f0, 0x0321e}, // Katakana Letter Small Ku..Parenthesized Korean Cha+ {0x03220, 0x03247}, // Parenthesized Ideograph ..Circled Ideograph Koto+ {0x03250, 0x04dbf}, // Partnership Sign ..Cjk Unified Ideograph-4d+ {0x04e00, 0x0a48c}, // Cjk Unified Ideograph-4e..Yi Syllable Yyr+ {0x0a490, 0x0a4c6}, // Yi Radical Qot ..Yi Radical Ke+ {0x0a960, 0x0a97c}, // Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo+ {0x0ac00, 0x0d7a3}, // Hangul Syllable Ga ..Hangul Syllable Hih+ {0x0f900, 0x0faff}, // Cjk Compatibility Ideogr..(nil)+ {0x0fe10, 0x0fe19}, // Presentation Form For Ve..Presentation Form For Ve+ {0x0fe30, 0x0fe52}, // Presentation Form For Ve..Small Full Stop+ {0x0fe54, 0x0fe66}, // Small Semicolon ..Small Equals Sign+ {0x0fe68, 0x0fe6b}, // Small Reverse Solidus ..Small Commercial At+ {0x0ff01, 0x0ff60}, // Fullwidth Exclamation Ma..Fullwidth Right White Pa+ {0x0ffe0, 0x0ffe6}, // Fullwidth Cent Sign ..Fullwidth Won Sign+ {0x16fe0, 0x16fe4}, // Tangut Iteration Mark ..Khitan Small Script Fill+ {0x16ff0, 0x16ff1}, // Vietnamese Alternate Rea..Vietnamese Alternate Rea+ {0x17000, 0x187f7}, // (nil) ..(nil)+ {0x18800, 0x18cd5}, // Tangut Component-001 ..Khitan Small Script Char+ {0x18d00, 0x18d08}, // (nil) ..(nil)+ {0x1aff0, 0x1aff3}, // Katakana Letter Minnan T..Katakana Letter Minnan T+ {0x1aff5, 0x1affb}, // Katakana Letter Minnan T..Katakana Letter Minnan N+ {0x1affd, 0x1affe}, // Katakana Letter Minnan N..Katakana Letter Minnan N+ {0x1b000, 0x1b122}, // Katakana Letter Archaic ..Katakana Letter Archaic+ {0x1b132, 0x1b132}, // (nil) ..(nil)+ {0x1b150, 0x1b152}, // Hiragana Letter Small Wi..Hiragana Letter Small Wo+ {0x1b155, 0x1b155}, // (nil) ..(nil)+ {0x1b164, 0x1b167}, // Katakana Letter Small Wi..Katakana Letter Small N+ {0x1b170, 0x1b2fb}, // Nushu Character-1b170 ..Nushu Character-1b2fb+ {0x1f004, 0x1f004}, // Mahjong Tile Red Dragon ..Mahjong Tile Red Dragon+ {0x1f0cf, 0x1f0cf}, // Playing Card Black Joker..Playing Card Black Joker+ {0x1f18e, 0x1f18e}, // Negative Squared Ab ..Negative Squared Ab+ {0x1f191, 0x1f19a}, // Squared Cl ..Squared Vs+ {0x1f200, 0x1f202}, // Square Hiragana Hoka ..Squared Katakana Sa+ {0x1f210, 0x1f23b}, // Squared Cjk Unified Ideo..Squared Cjk Unified Ideo+ {0x1f240, 0x1f248}, // Tortoise Shell Bracketed..Tortoise Shell Bracketed+ {0x1f250, 0x1f251}, // Circled Ideograph Advant..Circled Ideograph Accept+ {0x1f260, 0x1f265}, // Rounded Symbol For Fu ..Rounded Symbol For Cai+ {0x1f300, 0x1f320}, // Cyclone ..Shooting Star+ {0x1f32d, 0x1f335}, // Hot Dog ..Cactus+ {0x1f337, 0x1f37c}, // Tulip ..Baby Bottle+ {0x1f37e, 0x1f393}, // Bottle With Popping Cork..Graduation Cap+ {0x1f3a0, 0x1f3ca}, // Carousel Horse ..Swimmer+ {0x1f3cf, 0x1f3d3}, // Cricket Bat And Ball ..Table Tennis Paddle And+ {0x1f3e0, 0x1f3f0}, // House Building ..European Castle+ {0x1f3f4, 0x1f3f4}, // Waving Black Flag ..Waving Black Flag+ {0x1f3f8, 0x1f43e}, // Badminton Racquet And Sh..Paw Prints+ {0x1f440, 0x1f440}, // Eyes ..Eyes+ {0x1f442, 0x1f4fc}, // Ear ..Videocassette+ {0x1f4ff, 0x1f53d}, // Prayer Beads ..Down-pointing Small Red+ {0x1f54b, 0x1f54e}, // Kaaba ..Menorah With Nine Branch+ {0x1f550, 0x1f567}, // Clock Face One Oclock ..Clock Face Twelve-thirty+ {0x1f57a, 0x1f57a}, // Man Dancing ..Man Dancing+ {0x1f595, 0x1f596}, // Reversed Hand With Middl..Raised Hand With Part Be+ {0x1f5a4, 0x1f5a4}, // Black Heart ..Black Heart+ {0x1f5fb, 0x1f64f}, // Mount Fuji ..Person With Folded Hands+ {0x1f680, 0x1f6c5}, // Rocket ..Left Luggage+ {0x1f6cc, 0x1f6cc}, // Sleeping Accommodation ..Sleeping Accommodation+ {0x1f6d0, 0x1f6d2}, // Place Of Worship ..Shopping Trolley+ {0x1f6d5, 0x1f6d7}, // Hindu Temple ..Elevator+ {0x1f6dc, 0x1f6df}, // (nil) ..Ring Buoy+ {0x1f6eb, 0x1f6ec}, // Airplane Departure ..Airplane Arriving+ {0x1f6f4, 0x1f6fc}, // Scooter ..Roller Skate+ {0x1f7e0, 0x1f7eb}, // Large Orange Circle ..Large Brown Square+ {0x1f7f0, 0x1f7f0}, // Heavy Equals Sign ..Heavy Equals Sign+ {0x1f90c, 0x1f93a}, // Pinched Fingers ..Fencer+ {0x1f93c, 0x1f945}, // Wrestlers ..Goal Net+ {0x1f947, 0x1f9ff}, // First Place Medal ..Nazar Amulet+ {0x1fa70, 0x1fa7c}, // Ballet Shoes ..Crutch+ {0x1fa80, 0x1fa88}, // Yo-yo ..(nil)+ {0x1fa90, 0x1fabd}, // Ringed Planet ..(nil)+ {0x1fabf, 0x1fac5}, // (nil) ..Person With Crown+ {0x1face, 0x1fadb}, // (nil) ..(nil)+ {0x1fae0, 0x1fae8}, // Melting Face ..(nil)+ {0x1faf0, 0x1faf8}, // Hand With Index Finger A..(nil)+ {0x20000, 0x2fffd}, // Cjk Unified Ideograph-20..(nil)+ {0x30000, 0x3fffd}, // Cjk Unified Ideograph-30..(nil)+ };+++ private static boolean intable(int[][] table, int c) {+ // First quick check f|| Latin1 etc. characters.+ if (c < table[0][0]) return false;++ // Binary search in table.+ int bot = 0;+ int top = table.length - 1; // (int)(size / sizeof(struct interval) - 1);+ while (top >= bot) {+ int mid = (bot + top) / 2;+ if (table[mid][1] < c) {+ bot = mid + 1;+ } else if (table[mid][0] > c) {+ top = mid - 1;+ } else {+ return true;+ }+ }+ return false;+ }++ /** Return the terminal display width of a code point: 0, 1 || 2. */+ public static int width(int ucs) {+ if (ucs == 0 ||+ ucs == 0x034F ||+ (0x200B <= ucs && ucs <= 0x200F) ||+ ucs == 0x2028 ||+ ucs == 0x2029 ||+ (0x202A <= ucs && ucs <= 0x202E) ||+ (0x2060 <= ucs && ucs <= 0x2063)) {+ return 0;+ }++ // C0/C1 control characters+ // Termux change: Return 0 instead of -1.+ if (ucs < 32 || (0x07F <= ucs && ucs < 0x0A0)) return 0;++ // combining characters with zero width+ if (intable(ZERO_WIDTH, ucs)) return 0;++ return intable(WIDE_EASTASIAN, ucs) ? 2 : 1;+ }++ /** The width at an index position in a java char array. */+ public static int width(char[] chars, int index) {+ char c = chars[index];+ return Character.isHighSurrogate(c) ? width(Character.toCodePoint(c, chars[index + 1])) : width(c);+ }++ /**+ * The zero width characters count like combining characters in the `chars` array from start+ * index to end index (exclusive).+ */+ public static int zeroWidthCharsCount(char[] chars, int start, int end) {+ if (start < 0 || start >= chars.length)+ return 0;++ int count = 0;+ for (int i = start; i < end && i < chars.length;) {+ if (Character.isHighSurrogate(chars[i])) {+ if (width(Character.toCodePoint(chars[i], chars[i + 1])) <= 0) {+ count++;+ }+ i += 2;+ } else {+ if (width(chars[i]) <= 0) {+ count++;+ }+ i++;+ }+ }+ return count;+ }++}diff --git a/terminal-emulator/src/main/jni/Android.mk b/terminal-emulator/src/main/jni/Android.mknew file mode 100644index 0000000..745691a--- /dev/null+++ b/terminal-emulator/src/main/jni/Android.mk@@ -0,0 +1,7 @@+LOCAL_PATH:= $(call my-dir)+include $(CLEAR_VARS)+LOCAL_MODULE:= libtermux+LOCAL_SRC_FILES:= termux.c+# 16 KB page alignment is mandatory on Android 13+ (CLAUDE.md).+LOCAL_LDFLAGS += -Wl,-z,max-page-size=16384 -Wl,--gc-sections+include $(BUILD_SHARED_LIBRARY)diff --git a/terminal-emulator/src/main/jni/termux.c b/terminal-emulator/src/main/jni/termux.cnew file mode 100644index 0000000..8cd5e78--- /dev/null+++ b/terminal-emulator/src/main/jni/termux.c@@ -0,0 +1,218 @@+#include <dirent.h>+#include <fcntl.h>+#include <jni.h>+#include <signal.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <sys/ioctl.h>+#include <sys/wait.h>+#include <termios.h>+#include <unistd.h>++#define TERMUX_UNUSED(x) x __attribute__((__unused__))+#ifdef __APPLE__+# define LACKS_PTSNAME_R+#endif++static int throw_runtime_exception(JNIEnv* env, char const* message)+{+ jclass exClass = (*env)->FindClass(env, "java/lang/RuntimeException");+ (*env)->ThrowNew(env, exClass, message);+ return -1;+}++static int create_subprocess(JNIEnv* env,+ char const* cmd,+ char const* cwd,+ char* const argv[],+ char** envp,+ int* pProcessId,+ jint rows,+ jint columns,+ jint cell_width,+ jint cell_height)+{+ int ptm = open("/dev/ptmx", O_RDWR | O_CLOEXEC);+ if (ptm < 0) return throw_runtime_exception(env, "Cannot open /dev/ptmx");++#ifdef LACKS_PTSNAME_R+ char* devname;+#else+ char devname[64];+#endif+ if (grantpt(ptm) || unlockpt(ptm) ||+#ifdef LACKS_PTSNAME_R+ (devname = ptsname(ptm)) == NULL+#else+ ptsname_r(ptm, devname, sizeof(devname))+#endif+ ) {+ return throw_runtime_exception(env, "Cannot grantpt()/unlockpt()/ptsname_r() on /dev/ptmx");+ }++ // Enable UTF-8 mode and disable flow control to prevent Ctrl+S from locking up the display.+ struct termios tios;+ tcgetattr(ptm, &tios);+ tios.c_iflag |= IUTF8;+ tios.c_iflag &= ~(IXON | IXOFF);+ tcsetattr(ptm, TCSANOW, &tios);++ /** Set initial winsize. */+ struct winsize sz = { .ws_row = (unsigned short) rows, .ws_col = (unsigned short) columns, .ws_xpixel = (unsigned short) (columns * cell_width), .ws_ypixel = (unsigned short) (rows * cell_height)};+ ioctl(ptm, TIOCSWINSZ, &sz);++ pid_t pid = fork();+ if (pid < 0) {+ return throw_runtime_exception(env, "Fork failed");+ } else if (pid > 0) {+ *pProcessId = (int) pid;+ return ptm;+ } else {+ // Clear signals which the Android java process may have blocked:+ sigset_t signals_to_unblock;+ sigfillset(&signals_to_unblock);+ sigprocmask(SIG_UNBLOCK, &signals_to_unblock, 0);++ close(ptm);+ setsid();++ int pts = open(devname, O_RDWR);+ if (pts < 0) exit(-1);++ dup2(pts, 0);+ dup2(pts, 1);+ dup2(pts, 2);++ DIR* self_dir = opendir("/proc/self/fd");+ if (self_dir != NULL) {+ int self_dir_fd = dirfd(self_dir);+ struct dirent* entry;+ while ((entry = readdir(self_dir)) != NULL) {+ int fd = atoi(entry->d_name);+ if (fd > 2 && fd != self_dir_fd) close(fd);+ }+ closedir(self_dir);+ }++ clearenv();+ if (envp) for (; *envp; ++envp) putenv(*envp);++ if (chdir(cwd) != 0) {+ char* error_message;+ // No need to free asprintf()-allocated memory since doing execvp() or exit() below.+ if (asprintf(&error_message, "chdir(\"%s\")", cwd) == -1) error_message = "chdir()";+ perror(error_message);+ fflush(stderr);+ }+ execvp(cmd, argv);+ // Show terminal output about failing exec() call:+ char* error_message;+ if (asprintf(&error_message, "exec(\"%s\")", cmd) == -1) error_message = "exec()";+ perror(error_message);+ _exit(1);+ }+}++JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_createSubprocess(+ JNIEnv* env,+ jclass TERMUX_UNUSED(clazz),+ jstring cmd,+ jstring cwd,+ jobjectArray args,+ jobjectArray envVars,+ jintArray processIdArray,+ jint rows,+ jint columns,+ jint cell_width,+ jint cell_height)+{+ jsize size = args ? (*env)->GetArrayLength(env, args) : 0;+ char** argv = NULL;+ if (size > 0) {+ argv = (char**) malloc((size + 1) * sizeof(char*));+ if (!argv) return throw_runtime_exception(env, "Couldn't allocate argv array");+ for (int i = 0; i < size; ++i) {+ jstring arg_java_string = (jstring) (*env)->GetObjectArrayElement(env, args, i);+ char const* arg_utf8 = (*env)->GetStringUTFChars(env, arg_java_string, NULL);+ if (!arg_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for argv");+ argv[i] = strdup(arg_utf8);+ (*env)->ReleaseStringUTFChars(env, arg_java_string, arg_utf8);+ }+ argv[size] = NULL;+ }++ size = envVars ? (*env)->GetArrayLength(env, envVars) : 0;+ char** envp = NULL;+ if (size > 0) {+ envp = (char**) malloc((size + 1) * sizeof(char *));+ if (!envp) return throw_runtime_exception(env, "malloc() for envp array failed");+ for (int i = 0; i < size; ++i) {+ jstring env_java_string = (jstring) (*env)->GetObjectArrayElement(env, envVars, i);+ char const* env_utf8 = (*env)->GetStringUTFChars(env, env_java_string, 0);+ if (!env_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for env");+ envp[i] = strdup(env_utf8);+ (*env)->ReleaseStringUTFChars(env, env_java_string, env_utf8);+ }+ envp[size] = NULL;+ }++ int procId = 0;+ char const* cmd_cwd = (*env)->GetStringUTFChars(env, cwd, NULL);+ char const* cmd_utf8 = (*env)->GetStringUTFChars(env, cmd, NULL);+ int ptm = create_subprocess(env, cmd_utf8, cmd_cwd, argv, envp, &procId, rows, columns, cell_width, cell_height);+ (*env)->ReleaseStringUTFChars(env, cmd, cmd_utf8);+ (*env)->ReleaseStringUTFChars(env, cmd, cmd_cwd);++ if (argv) {+ for (char** tmp = argv; *tmp; ++tmp) free(*tmp);+ free(argv);+ }+ if (envp) {+ for (char** tmp = envp; *tmp; ++tmp) free(*tmp);+ free(envp);+ }++ int* pProcId = (int*) (*env)->GetPrimitiveArrayCritical(env, processIdArray, NULL);+ if (!pProcId) return throw_runtime_exception(env, "JNI call GetPrimitiveArrayCritical(processIdArray, &isCopy) failed");++ *pProcId = procId;+ (*env)->ReleasePrimitiveArrayCritical(env, processIdArray, pProcId, 0);++ return ptm;+}++JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_setPtyWindowSize(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fd, jint rows, jint cols, jint cell_width, jint cell_height)+{+ struct winsize sz = { .ws_row = (unsigned short) rows, .ws_col = (unsigned short) cols, .ws_xpixel = (unsigned short) (cols * cell_width), .ws_ypixel = (unsigned short) (rows * cell_height) };+ ioctl(fd, TIOCSWINSZ, &sz);+}++JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_setPtyUTF8Mode(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fd)+{+ struct termios tios;+ tcgetattr(fd, &tios);+ if ((tios.c_iflag & IUTF8) == 0) {+ tios.c_iflag |= IUTF8;+ tcsetattr(fd, TCSANOW, &tios);+ }+}++JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_waitFor(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint pid)+{+ int status;+ waitpid(pid, &status, 0);+ if (WIFEXITED(status)) {+ return WEXITSTATUS(status);+ } else if (WIFSIGNALED(status)) {+ return -WTERMSIG(status);+ } else {+ // Should never happen - waitpid(2) says "One of the first three macros will evaluate to a non-zero (true) value".+ return 0;+ }+}++JNIEXPORT void JNICALL Java_com_termux_terminal_JNI_close(JNIEnv* TERMUX_UNUSED(env), jclass TERMUX_UNUSED(clazz), jint fileDescriptor)+{+ close(fileDescriptor);+}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ApcTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ApcTest.javanew file mode 100644index 0000000..4f6292a--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ApcTest.java@@ -0,0 +1,21 @@+package com.termux.terminal;++public class ApcTest extends TerminalTestCase {++ public void testApcConsumed() {+ // At time of writing this is part of what yazi sends for probing for kitty graphics protocol support:+ // https://github.com/sxyazi/yazi/blob/0cdaff98d0b3723caff63eebf1974e7907a43a2c/yazi-adapter/src/emulator.rs#L129+ // This should not result in anything being written to the screen: If kitty graphics protocol support+ // is implemented it should instead result in an error code on stdin, and if not it should be consumed+ // silently just as xterm does. See https://sw.kovidgoyal.net/kitty/graphics-protocol/.+ withTerminalSized(2, 2)+ .enterString("\033_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\033\\")+ .assertLinesAre(" ", " ");++ // It is ok for the APC content to be non printable characters:+ withTerminalSized(12, 2)+ .enterString("hello \033_some\023\033_\\apc#end\033\\ world")+ .assertLinesAre("hello world", " ");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ByteQueueTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ByteQueueTest.javanew file mode 100644index 0000000..44a605b--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ByteQueueTest.java@@ -0,0 +1,54 @@+package com.termux.terminal;++import junit.framework.TestCase;++public class ByteQueueTest extends TestCase {++ private static void assertArrayEquals(byte[] expected, byte[] actual) {+ if (expected.length != actual.length) {+ fail("Difference array length");+ }+ for (int i = 0; i < expected.length; i++) {+ if (expected[i] != actual[i]) {+ fail("Inequals at index=" + i + ", expected=" + (int) expected[i] + ", actual=" + (int) actual[i]);+ }+ }+ }++ public void testCompleteWrites() throws Exception {+ ByteQueue q = new ByteQueue(10);+ assertTrue(q.write(new byte[]{1, 2, 3}, 0, 3));++ byte[] arr = new byte[10];+ assertEquals(3, q.read(arr, true));+ assertArrayEquals(new byte[]{1, 2, 3}, new byte[]{arr[0], arr[1], arr[2]});++ assertTrue(q.write(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 0, 10));+ assertEquals(10, q.read(arr, true));+ assertArrayEquals(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, arr);+ }++ public void testQueueWraparound() throws Exception {+ ByteQueue q = new ByteQueue(10);++ byte[] origArray = new byte[]{1, 2, 3, 4, 5, 6};+ byte[] readArray = new byte[origArray.length];+ for (int i = 0; i < 20; i++) {+ q.write(origArray, 0, origArray.length);+ assertEquals(origArray.length, q.read(readArray, true));+ assertArrayEquals(origArray, readArray);+ }+ }++ public void testWriteNotesClosing() throws Exception {+ ByteQueue q = new ByteQueue(10);+ q.close();+ assertFalse(q.write(new byte[]{1, 2, 3}, 0, 3));+ }++ public void testReadNonBlocking() throws Exception {+ ByteQueue q = new ByteQueue(10);+ assertEquals(0, q.read(new byte[128], false));+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.javanew file mode 100644index 0000000..9f123bc--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ControlSequenceIntroducerTest.java@@ -0,0 +1,131 @@+package com.termux.terminal;++import java.util.List;++/** "\033[" is the Control Sequence Introducer char sequence (CSI). */+public class ControlSequenceIntroducerTest extends TerminalTestCase {++ /** CSI Ps P Scroll down Ps lines (default = 1) (SD). */+ public void testCsiT() {+ withTerminalSized(4, 6).enterString("1\r\n2\r\n3\r\nhi\033[2Tyo\r\nA\r\nB").assertLinesAre(" ", " ", "1 ", "2 yo", "A ",+ "Bi ");+ // Default value (1):+ withTerminalSized(4, 6).enterString("1\r\n2\r\n3\r\nhi\033[Tyo\r\nA\r\nB").assertLinesAre(" ", "1 ", "2 ", "3 yo", "Ai ",+ "B ");+ }++ /** CSI Ps S Scroll up Ps lines (default = 1) (SU). */+ public void testCsiS() {+ // The behaviour here is a bit inconsistent between terminals - this is how the OS X Terminal.app does it:+ withTerminalSized(3, 4).enterString("1\r\n2\r\n3\r\nhi\033[2Sy").assertLinesAre("3 ", "hi ", " ", " y");+ // Default value (1):+ withTerminalSized(3, 4).enterString("1\r\n2\r\n3\r\nhi\033[Sy").assertLinesAre("2 ", "3 ", "hi ", " y");+ }++ /** CSI Ps X Erase Ps Character(s) (default = 1) (ECH). */+ public void testCsiX() {+ // See https://code.google.com/p/chromium/issues/detail?id=212712 where test was extraced from.+ withTerminalSized(13, 2).enterString("abcdefghijkl\b\b\b\b\b\033[X").assertLinesAre("abcdefg ijkl ", " ");+ withTerminalSized(13, 2).enterString("abcdefghijkl\b\b\b\b\b\033[1X").assertLinesAre("abcdefg ijkl ", " ");+ withTerminalSized(13, 2).enterString("abcdefghijkl\b\b\b\b\b\033[2X").assertLinesAre("abcdefg jkl ", " ");+ withTerminalSized(13, 2).enterString("abcdefghijkl\b\b\b\b\b\033[20X").assertLinesAre("abcdefg ", " ");+ }++ /** CSI Pm m Set SGR parameter(s) from semicolon-separated list Pm. */+ public void testCsiSGRParameters() {+ // Set more parameters (19) than supported (16). Additional parameters should be silently consumed.+ withTerminalSized(3, 2).enterString("\033[0;38;2;255;255;255;48;2;0;0;0;1;2;3;4;5;7;8;9mabc").assertLinesAre("abc", " ");+ }++ /** CSI Ps b Repeat the preceding graphic character Ps times (REP). */+ public void testRepeat() {+ withTerminalSized(3, 2).enterString("a\033[b").assertLinesAre("aa ", " ");+ withTerminalSized(3, 2).enterString("a\033[2b").assertLinesAre("aaa", " ");+ // When no char has been output we ignore REP:+ withTerminalSized(3, 2).enterString("\033[b").assertLinesAre(" ", " ");+ // This shows that REP outputs the last emitted code point and not the one relative to the+ // current cursor position:+ withTerminalSized(5, 2).enterString("abcde\033[2G\033[2b\n").assertLinesAre("aeede", " ");+ }++ /** CSI 3 J Clear scrollback (xterm, libvte; non-standard). */+ public void testCsi3J() {+ withTerminalSized(3, 2).enterString("a\r\nb\r\nc\r\nd");+ assertEquals("a\nb\nc\nd", mTerminal.getScreen().getTranscriptText());+ enterString("\033[3J");+ assertEquals("c\nd", mTerminal.getScreen().getTranscriptText());++ withTerminalSized(3, 2).enterString("Lorem_ipsum");+ assertEquals("Lorem_ipsum", mTerminal.getScreen().getTranscriptText());+ enterString("\033[3J");+ assertEquals("ipsum", mTerminal.getScreen().getTranscriptText());++ withTerminalSized(3, 2).enterString("w\r\nx\r\ny\r\nz\033[?1049h\033[3J\033[?1049l");+ assertEquals("y\nz", mTerminal.getScreen().getTranscriptText());+ }++ public void testReportPixelSize() {+ int columns = 3;+ int rows = 3;+ withTerminalSized(columns, rows);+ int cellWidth = TerminalTest.INITIAL_CELL_WIDTH_PIXELS;+ int cellHeight = TerminalTest.INITIAL_CELL_HEIGHT_PIXELS;+ assertEnteringStringGivesResponse("\033[14t", "\033[4;" + (rows*cellHeight) + ";" + (columns*cellWidth) + "t");+ assertEnteringStringGivesResponse("\033[16t", "\033[6;" + cellHeight + ";" + cellWidth + "t");+ columns = 23;+ rows = 33;+ resize(columns, rows);+ assertEnteringStringGivesResponse("\033[14t", "\033[4;" + (rows*cellHeight) + ";" + (columns*cellWidth) + "t");+ assertEnteringStringGivesResponse("\033[16t", "\033[6;" + cellHeight + ";" + cellWidth + "t");+ cellWidth = 8;+ cellHeight = 18;+ mTerminal.resize(columns, rows, cellWidth, cellHeight);+ assertEnteringStringGivesResponse("\033[14t", "\033[4;" + (rows*cellHeight) + ";" + (columns*cellWidth) + "t");+ assertEnteringStringGivesResponse("\033[16t", "\033[6;" + cellHeight + ";" + cellWidth + "t");+ }++ /**+ * See <a href="https://sw.kovidgoyal.net/kitty/underlines/">Colored and styled underlines</a>:+ *+ * <pre>+ * <ESC>[4:0m # no underline+ * <ESC>[4:1m # straight underline+ * <ESC>[4:2m # double underline+ * <ESC>[4:3m # curly underline+ * <ESC>[4:4m # dotted underline+ * <ESC>[4:5m # dashed underline+ * <ESC>[4m # straight underline (for backwards compat)+ * <ESC>[24m # no underline (for backwards compat)+ * </pre>+ * <p>+ * We currently parse the variants, but map them to normal/no underlines as appropriate+ */+ public void testUnderlineVariants() {+ for (String suffix : List.of("", ":1", ":2", ":3", ":4", ":5")) {+ for (String stop : List.of("24", "4:0")) {+ withTerminalSized(3, 3);+ enterString("\033[4" + suffix + "m").assertLinesAre(" ", " ", " ");+ assertEquals(TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, mTerminal.mEffect);+ enterString("\033[4;1m").assertLinesAre(" ", " ", " ");+ assertEquals(TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, mTerminal.mEffect);+ enterString("\033[" + stop + "m").assertLinesAre(" ", " ", " ");+ assertEquals(TextStyle.CHARACTER_ATTRIBUTE_BOLD, mTerminal.mEffect);+ }+ }+ }++ public void testManyParameters() {+ StringBuilder b = new StringBuilder("\033[");+ for (int i = 0; i < 30; i++) {+ b.append("0;");+ }+ b.append("4:2");+ // This clearing of underline should be ignored as the parameters pass the threshold for too many parameters:+ b.append("4:0m");+ withTerminalSized(3, 3)+ .enterString(b.toString())+ .assertLinesAre(" ", " ", " ");+ assertEquals(TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, mTerminal.mEffect);+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/CursorAndScreenTest.java b/terminal-emulator/src/test/java/com/termux/terminal/CursorAndScreenTest.javanew file mode 100644index 0000000..8a65e66--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/CursorAndScreenTest.java@@ -0,0 +1,266 @@+package com.termux.terminal;++import org.junit.Assert;++public class CursorAndScreenTest extends TerminalTestCase {++ public void testDeleteLinesKeepsStyles() {+ int cols = 5, rows = 5;+ withTerminalSized(cols, rows);+ for (int row = 0; row < 5; row++) {+ for (int col = 0; col < 5; col++) {+ // Foreground color to col, background to row:+ enterString("\033[38;5;" + col + "m");+ enterString("\033[48;5;" + row + "m");+ enterString(Character.toString((char) ('A' + col + row * 5)));+ }+ }+ assertLinesAre("ABCDE", "FGHIJ", "KLMNO", "PQRST", "UVWXY");+ for (int row = 0; row < 5; row++) {+ for (int col = 0; col < 5; col++) {+ long s = getStyleAt(row, col);+ Assert.assertEquals(col, TextStyle.decodeForeColor(s));+ Assert.assertEquals(row, TextStyle.decodeBackColor(s));+ }+ }+ // "${CSI}H" - place cursor at 1,1, then "${CSI}2M" to delete two lines.+ enterString("\033[H\033[2M");+ assertLinesAre("KLMNO", "PQRST", "UVWXY", " ", " ");+ for (int row = 0; row < 3; row++) {+ for (int col = 0; col < 5; col++) {+ long s = getStyleAt(row, col);+ Assert.assertEquals(col, TextStyle.decodeForeColor(s));+ Assert.assertEquals(row + 2, TextStyle.decodeBackColor(s));+ }+ }+ // Set default fg and background for the new blank lines:+ enterString("\033[38;5;98m");+ enterString("\033[48;5;99m");+ // "${CSI}B" to go down one line, then "${CSI}2L" to insert two lines:+ enterString("\033[B\033[2L");+ assertLinesAre("KLMNO", " ", " ", "PQRST", "UVWXY");+ for (int row = 0; row < 5; row++) {+ for (int col = 0; col < 5; col++) {+ int wantedForeground = (row == 1 || row == 2) ? 98 : col;+ int wantedBackground = (row == 1 || row == 2) ? 99 : (row == 0 ? 2 : row);+ long s = getStyleAt(row, col);+ Assert.assertEquals(wantedForeground, TextStyle.decodeForeColor(s));+ Assert.assertEquals(wantedBackground, TextStyle.decodeBackColor(s));+ }+ }+ }++ public void testDeleteCharacters() {+ withTerminalSized(5, 2).enterString("枝ce").assertLinesAre("枝ce ", " ");+ withTerminalSized(5, 2).enterString("a枝ce").assertLinesAre("a枝ce", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[P").assertLinesAre("ice ", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[2P").assertLinesAre("ne ", " ");+ // "${CSI}${n}P, the delete characters (DCH) sequence should cap characters to delete.+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[99P").assertLinesAre(" ", " ");+ // With combining char U+0302.+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[P").assertLinesAre("ice ", " ");+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[2G\033[2P").assertLinesAre("n\u0302e ", " ");+ // With wide 枝 char, checking that putting char at part replaces other with whitespace:+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[Ga").assertLinesAre("a ce ", " ");+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2Ga").assertLinesAre(" ace ", " ");+ // With wide 枝 char, deleting either part replaces other with whitespace:+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[G\033[P").assertLinesAre(" ce ", " ");+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2G\033[P").assertLinesAre(" ce ", " ");+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[2G\033[2P").assertLinesAre(" e ", " ");+ withTerminalSized(5, 2).enterString("枝ce").enterString("\033[G\033[2P").assertLinesAre("ce ", " ");+ withTerminalSized(5, 2).enterString("a枝ce").enterString("\033[G\033[P").assertLinesAre("枝ce ", " ");+ }++ public void testInsertMode() {+ // "${CSI}4h" enables insert mode.+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4hA").assertLinesAre("Anice", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[4hA").assertLinesAre("nAice", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4hABC").assertLinesAre("ABCni", " ");+ // With combining char U+0302.+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[4hA").assertLinesAre("An\u0302ice", " ");+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[G\033[4hAB").assertLinesAre("ABn\u0302ic", " ");+ withTerminalSized(5, 2).enterString("n\u0302ic\u0302e").enterString("\033[2G\033[4hA").assertLinesAre("n\u0302Aic\u0302e", " ");+ // ... but without insert mode, combining char should be overwritten:+ withTerminalSized(5, 2).enterString("n\u0302ice").enterString("\033[GA").assertLinesAre("Aice ", " ");+ // ... also with two combining:+ withTerminalSized(5, 2).enterString("n\u0302\u0302i\u0302ce").enterString("\033[GA").assertLinesAre("Ai\u0302ce ", " ");+ // ... and in last column:+ withTerminalSized(5, 2).enterString("n\u0302\u0302ice!\u0302").enterString("\033[5GA").assertLinesAre("n\u0302\u0302iceA", " ");+ withTerminalSized(5, 2).enterString("nic\u0302e!\u0302").enterString("\033[4G枝").assertLinesAre("nic\u0302枝", " ");+ withTerminalSized(5, 2).enterString("nic枝\u0302").enterString("\033[3GA").assertLinesAre("niA枝\u0302", " ");+ withTerminalSized(5, 2).enterString("nic枝\u0302").enterString("\033[3GA").assertLinesAre("niA枝\u0302", " ");+ // With wide 枝 char.+ withTerminalSized(5, 2).enterString("nice").enterString("\033[G\033[4h枝").assertLinesAre("枝nic", " ");+ withTerminalSized(5, 2).enterString("nice").enterString("\033[2G\033[4h枝").assertLinesAre("n枝ic", " ");+ withTerminalSized(5, 2).enterString("n枝ce").enterString("\033[G\033[4ha").assertLinesAre("an枝c", " ");+ }++ /** HPA—Horizontal Position Absolute (http://www.vt100.net/docs/vt510-rm/HPA) */+ public void testCursorHorizontalPositionAbsolute() {+ withTerminalSized(4, 4).enterString("ABC\033[`").assertCursorAt(0, 0);+ enterString("\033[1`").assertCursorAt(0, 0).enterString("\033[2`").assertCursorAt(0, 1);+ enterString("\r\n\033[3`").assertCursorAt(1, 2).enterString("\033[22`").assertCursorAt(1, 3);+ // Enable and configure right and left margins, first without origin mode:+ enterString("\033[?69h\033[2;3s\033[`").assertCursorAt(0, 0).enterString("\033[22`").assertCursorAt(0, 3);+ // .. now with origin mode:+ enterString("\033[?6h\033[`").assertCursorAt(0, 1).enterString("\033[22`").assertCursorAt(0, 2);+ }++ public void testCursorForward() {+ // "${CSI}${N:=1}C" moves cursor forward N columns:+ withTerminalSized(6, 2).enterString("A\033[CB\033[2CC").assertLinesAre("A B C", " ");+ // If an attempt is made to move the cursor to the right of the right margin, the cursor stops at the right margin:+ withTerminalSized(6, 2).enterString("A\033[44CB").assertLinesAre("A B", " ");+ // Enable right margin and verify that CUF ends at the set right margin:+ withTerminalSized(6, 2).enterString("\033[?69h\033[1;3s\033[44CAB").assertLinesAre(" A ", "B ");+ }++ public void testCursorBack() {+ // "${CSI}${N:=1}D" moves cursor back N columns:+ withTerminalSized(3, 2).enterString("A\033[DB").assertLinesAre("B ", " ");+ withTerminalSized(3, 2).enterString("AB\033[2DC").assertLinesAre("CB ", " ");+ // If an attempt is made to move the cursor to the left of the left margin, the cursor stops at the left margin:+ withTerminalSized(3, 2).enterString("AB\033[44DC").assertLinesAre("CB ", " ");+ // Enable left margin and verify that CUB ends at the set left margin:+ withTerminalSized(6, 2).enterString("ABCD\033[?69h\033[2;6s\033[44DE").assertLinesAre("AECD ", " ");+ }++ public void testCursorUp() {+ // "${CSI}${N:=1}A" moves cursor up N rows:+ withTerminalSized(3, 3).enterString("ABCDEFG\033[AH").assertLinesAre("ABC", "DHF", "G ");+ withTerminalSized(3, 3).enterString("ABCDEFG\033[2AH").assertLinesAre("AHC", "DEF", "G ");+ // If an attempt is made to move the cursor above the top margin, the cursor stops at the top margin:+ withTerminalSized(3, 3).enterString("ABCDEFG\033[44AH").assertLinesAre("AHC", "DEF", "G ");+ }++ public void testCursorDown() {+ // "${CSI}${N:=1}B" moves cursor down N rows:+ withTerminalSized(3, 3).enterString("AB\033[BC").assertLinesAre("AB ", " C", " ");+ withTerminalSized(3, 3).enterString("AB\033[2BC").assertLinesAre("AB ", " ", " C");+ // If an attempt is made to move the cursor below the bottom margin, the cursor stops at the bottom margin:+ withTerminalSized(3, 3).enterString("AB\033[44BC").assertLinesAre("AB ", " ", " C");+ }++ public void testReportCursorPosition() {+ withTerminalSized(10, 10);+ for (int i = 0; i < 10; i++) {+ for (int j = 0; j < 10; j++) {+ enterString("\033[" + (i + 1) + ";" + (j + 1) + "H"); // CUP cursor position.+ assertCursorAt(i, j);+ // Device Status Report (DSR):+ assertEnteringStringGivesResponse("\033[6n", "\033[" + (i + 1) + ";" + (j + 1) + "R");+ // DECXCPR — Extended Cursor Position. Note that http://www.vt100.net/docs/vt510-rm/DECXCPR says+ // the response is "${CSI}${LINE};${COLUMN};${PAGE}R" while xterm (http://invisible-island.net/xterm/ctlseqs/ctlseqs.html)+ // drops the question mark. Expect xterm behaviour here.+ assertEnteringStringGivesResponse("\033[?6n", "\033[?" + (i + 1) + ";" + (j + 1) + ";1R");+ }+ }+ }++ /**+ * See comments on horizontal tab handling in TerminalEmulator.java.+ * <p/>+ * We do not want to color already written cells when tabbing over them.+ */+ public void DISABLED_testHorizontalTabColorsBackground() {+ withTerminalSized(10, 3).enterString("\033[48;5;15m").enterString("\t");+ assertCursorAt(0, 8);+ for (int i = 0; i < 10; i++) {+ int expectedColor = i < 8 ? 15 : TextStyle.COLOR_INDEX_BACKGROUND;+ assertEquals(expectedColor, TextStyle.decodeBackColor(getStyleAt(0, i)));+ }+ }++ /**+ * Test interactions between the cursor overflow bit and various escape sequences.+ * <p/>+ * Adapted from hterm:+ * https://chromium.googlesource.com/chromiumos/platform/assets/+/2337afa5c063127d5ce40ec7fec9b602d096df86%5E%21/#F2+ */+ public void testClearingOfAutowrap() {+ // Fill a row with the last hyphen wrong, then run a command that+ // modifies the screen, then add a hyphen. The wrap bit should be+ // cleared, so the extra hyphen can fix the row.+ withTerminalSized(15, 6);++ enterString("----- 1 ----X");+ enterString("\033[K-"); // EL++ enterString("----- 2 ----X");+ enterString("\033[J-"); // ED++ enterString("----- 3 ----X");+ enterString("\033[@-"); // ICH++ enterString("----- 4 ----X");+ enterString("\033[P-"); // DCH++ enterString("----- 5 ----X");+ enterString("\033[X-"); // ECH++ // DL will delete the entire line but clear the wrap bit, so we+ // expect a hyphen at the end and nothing else.+ enterString("XXXXXXXXXXXXXXX");+ enterString("\033[M-"); // DL++ assertLinesAre(+ "----- 1 -----",+ "----- 2 -----",+ "----- 3 -----",+ "----- 4 -----",+ "----- 5 -----",+ " -");+ }++ public void testBackspaceAcrossWrappedLines() {+ // Backspace should not go to previous line if not auto-wrapped:+ withTerminalSized(3, 3).enterString("hi\r\n\b\byou").assertLinesAre("hi ", "you", " ");+ // Backspace should go to previous line if auto-wrapped:+ withTerminalSized(3, 3).enterString("hi y").assertLinesAre("hi ", "y ", " ").enterString("\b\b#").assertLinesAre("hi#", "y ", " ");+ // Initial backspace should do nothing:+ withTerminalSized(3, 3).enterString("\b\b\b\bhi").assertLinesAre("hi ", " ", " ");+ }++ public void testCursorSaveRestoreLocation() {+ // DEC save/restore+ withTerminalSized(4, 2).enterString("t\0337est\r\nme\0338ry ").assertLinesAre("try ", "me ");+ // ANSI.SYS save/restore+ withTerminalSized(4, 2).enterString("t\033[sest\r\nme\033[ury ").assertLinesAre("try ", "me ");+ // Alternate screen enter/exit+ withTerminalSized(4, 2).enterString("t\033[?1049h\033[Hest\r\nme").assertLinesAre("est ", "me ").enterString("\033[?1049lry").assertLinesAre("try ", " ");+ }++ public void testCursorSaveRestoreTextStyle() {+ long s;++ // DEC save/restore+ withTerminalSized(4, 2).enterString("\033[31;42;4m..\0337\033[36;47;24m\0338..");+ s = getStyleAt(0, 3);+ Assert.assertEquals(1, TextStyle.decodeForeColor(s));+ Assert.assertEquals(2, TextStyle.decodeBackColor(s));+ Assert.assertEquals(TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, TextStyle.decodeEffect(s));++ // ANSI.SYS save/restore+ withTerminalSized(4, 2).enterString("\033[31;42;4m..\033[s\033[36;47;24m\033[u..");+ s = getStyleAt(0, 3);+ Assert.assertEquals(1, TextStyle.decodeForeColor(s));+ Assert.assertEquals(2, TextStyle.decodeBackColor(s));+ Assert.assertEquals(TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, TextStyle.decodeEffect(s));++ // Alternate screen enter/exit+ withTerminalSized(4, 2);+ enterString("\033[31;42;4m..\033[?1049h\033[H\033[36;47;24m.");+ s = getStyleAt(0, 0);+ Assert.assertEquals(6, TextStyle.decodeForeColor(s));+ Assert.assertEquals(7, TextStyle.decodeBackColor(s));+ Assert.assertEquals(0, TextStyle.decodeEffect(s));+ enterString("\033[?1049l..");+ s = getStyleAt(0, 3);+ Assert.assertEquals(1, TextStyle.decodeForeColor(s));+ Assert.assertEquals(2, TextStyle.decodeBackColor(s));+ Assert.assertEquals(TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, TextStyle.decodeEffect(s));+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/DecSetTest.java b/terminal-emulator/src/test/java/com/termux/terminal/DecSetTest.javanew file mode 100644index 0000000..f31f1fb--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/DecSetTest.java@@ -0,0 +1,78 @@+package com.termux.terminal;++/**+ * <pre>+ * "CSI ? Pm h", DEC Private Mode Set (DECSET)+ * </pre>+ * <p/>+ * and+ * <p/>+ * <pre>+ * "CSI ? Pm l", DEC Private Mode Reset (DECRST)+ * </pre>+ * <p/>+ * controls various aspects of the terminal+ */+public class DecSetTest extends TerminalTestCase {++ /** DECSET 25, DECTCEM, controls visibility of the cursor. */+ public void testEnableDisableCursor() {+ withTerminalSized(3, 3);+ assertTrue("Initially the cursor should be enabled", mTerminal.isCursorEnabled());+ enterString("\033[?25l"); // Disable Cursor (DECTCEM).+ assertFalse(mTerminal.isCursorEnabled());+ enterString("\033[?25h"); // Enable Cursor (DECTCEM).+ assertTrue(mTerminal.isCursorEnabled());++ enterString("\033[?25l"); // Disable Cursor (DECTCEM), again.+ assertFalse(mTerminal.isCursorEnabled());+ mTerminal.reset();+ assertTrue("Resetting the terminal should enable the cursor", mTerminal.isCursorEnabled());++ enterString("\033[?25l");+ assertFalse(mTerminal.isCursorEnabled());+ enterString("\033c"); // RIS resetting should enabled cursor.+ assertTrue(mTerminal.isCursorEnabled());+ }++ /** DECSET 2004, controls bracketed paste mode. */+ public void testBracketedPasteMode() {+ withTerminalSized(3, 3);++ mTerminal.paste("a");+ assertEquals("Pasting 'a' should output 'a' when bracketed paste mode is disabled", "a", mOutput.getOutputAndClear());++ enterString("\033[?2004h"); // Enable bracketed paste mode.+ mTerminal.paste("a");+ assertEquals("Pasting when in bracketed paste mode should be bracketed", "\033[200~a\033[201~", mOutput.getOutputAndClear());++ enterString("\033[?2004l"); // Disable bracketed paste mode.+ mTerminal.paste("a");+ assertEquals("Pasting 'a' should output 'a' when bracketed paste mode is disabled", "a", mOutput.getOutputAndClear());++ enterString("\033[?2004h"); // Enable bracketed paste mode, again.+ mTerminal.paste("a");+ assertEquals("Pasting when in bracketed paste mode again should be bracketed", "\033[200~a\033[201~", mOutput.getOutputAndClear());++ mTerminal.paste("\033ab\033cd\033");+ assertEquals("Pasting an escape character should not input it", "\033[200~abcd\033[201~", mOutput.getOutputAndClear());+ mTerminal.paste("\u0081ab\u0081cd\u009F");+ assertEquals("Pasting C1 control codes should not input it", "\033[200~abcd\033[201~", mOutput.getOutputAndClear());++ mTerminal.reset();+ mTerminal.paste("a");+ assertEquals("Terminal reset() should disable bracketed paste mode", "a", mOutput.getOutputAndClear());+ }++ /** DECSET 7, DECAWM, controls wraparound mode. */+ public void testWrapAroundMode() {+ // Default with wraparound:+ withTerminalSized(3, 3).enterString("abcd").assertLinesAre("abc", "d ", " ");+ // With wraparound disabled:+ withTerminalSized(3, 3).enterString("\033[?7labcd").assertLinesAre("abd", " ", " ");+ enterString("efg").assertLinesAre("abg", " ", " ");+ // Re-enabling wraparound:+ enterString("\033[?7hhij").assertLinesAre("abh", "ij ", " ");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/DeviceControlStringTest.java b/terminal-emulator/src/test/java/com/termux/terminal/DeviceControlStringTest.javanew file mode 100644index 0000000..f889935--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/DeviceControlStringTest.java@@ -0,0 +1,53 @@+package com.termux.terminal;++/**+ * "\033P" is a device control string.+ */+public class DeviceControlStringTest extends TerminalTestCase {++ private static String hexEncode(String s) {+ StringBuilder result = new StringBuilder();+ for (int i = 0; i < s.length(); i++)+ result.append(String.format("%02X", (int) s.charAt(i)));+ return result.toString();+ }++ private void assertCapabilityResponse(String cap, String expectedResponse) {+ String input = "\033P+q" + hexEncode(cap) + "\033\\";+ assertEnteringStringGivesResponse(input, "\033P1+r" + hexEncode(cap) + "=" + hexEncode(expectedResponse) + "\033\\");+ }++ public void testReportColorsAndName() {+ // Request Termcap/Terminfo String. The string following the "q" is a list of names encoded in+ // hexadecimal (2 digits per character) separated by ; which correspond to termcap or terminfo key+ // names.+ // Two special features are also recognized, which are not key names: Co for termcap colors (or colors+ // for terminfo colors), and TN for termcap name (or name for terminfo name).+ // xterm responds with DCS 1 + r P t ST for valid requests, adding to P t an = , and the value of the+ // corresponding string that xterm would send, or DCS 0 + r P t ST for invalid requests. The strings are+ // encoded in hexadecimal (2 digits per character).+ withTerminalSized(3, 3).enterString("A");+ assertCapabilityResponse("Co", "256");+ assertCapabilityResponse("colors", "256");+ assertCapabilityResponse("TN", "xterm");+ assertCapabilityResponse("name", "xterm");+ enterString("B").assertLinesAre("AB ", " ", " ");+ }++ public void testReportKeys() {+ withTerminalSized(3, 3);+ assertCapabilityResponse("kB", "\033[Z");+ }++ public void testReallyLongDeviceControlString() {+ withTerminalSized(3, 3).enterString("\033P");+ for (int i = 0; i < 10000; i++) {+ enterString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");+ }+ // The terminal should ignore the overlong DCS sequence and continue printing "aaa." and fill at least the first two lines with+ // them:+ assertLineIs(0, "aaa");+ assertLineIs(1, "aaa");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/HistoryTest.java b/terminal-emulator/src/test/java/com/termux/terminal/HistoryTest.javanew file mode 100644index 0000000..17f8111--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/HistoryTest.java@@ -0,0 +1,33 @@+package com.termux.terminal;+++public class HistoryTest extends TerminalTestCase {++ public void testHistory() {+ final int rows = 3;+ final int cols = 3;+ withTerminalSized(cols, rows).enterString("111222333444555666777888999");+ assertCursorAt(2, 2);+ assertLinesAre("777", "888", "999");+ assertHistoryStartsWith("666", "555");++ resize(cols, 2);+ assertHistoryStartsWith("777", "666", "555");++ resize(cols, 3);+ assertHistoryStartsWith("666", "555");+ }++ public void testHistoryWithScrollRegion() {+ // "CSI P_s ; P_s r" - set Scrolling Region [top;bottom] (default = full size of window) (DECSTBM).+ withTerminalSized(3, 4).enterString("111222333444");+ assertLinesAre("111", "222", "333", "444");+ enterString("\033[2;3r");+ // NOTE: "DECSTBM moves the cursor to column 1, line 1 of the page."+ assertCursorAt(0, 0);+ enterString("\nCDEFGH").assertLinesAre("111", "CDE", "FGH", "444");+ enterString("IJK").assertLinesAre("111", "FGH", "IJK", "444").assertHistoryStartsWith("CDE");+ enterString("LMN").assertLinesAre("111", "IJK", "LMN", "444").assertHistoryStartsWith("FGH", "CDE");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/KeyHandlerTest.java b/terminal-emulator/src/test/java/com/termux/terminal/KeyHandlerTest.javanew file mode 100644index 0000000..15b2376--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/KeyHandlerTest.java@@ -0,0 +1,203 @@+package com.termux.terminal;++import android.view.KeyEvent;++import junit.framework.TestCase;++public class KeyHandlerTest extends TestCase {++ private static String stringToHex(String s) {+ if (s == null) return null;+ StringBuilder buffer = new StringBuilder();+ for (int i = 0; i < s.length(); i++) {+ if (buffer.length() > 0) {+ buffer.append(" ");+ }+ buffer.append("0x");+ buffer.append(Integer.toHexString(s.charAt(i)));+ }+ return buffer.toString();+ }++ private static void assertKeysEquals(String expected, String actual) {+ if (!expected.equals(actual)) {+ assertEquals(stringToHex(expected), stringToHex(actual));+ }+ }++ /** See http://pubs.opengroup.org/onlinepubs/7990989799/xcurses/terminfo.html */+ public void testTermCaps() {+ // Backspace.+ assertKeysEquals("\u007f", KeyHandler.getCodeFromTermcap("kb", false, false));++ // Back tab.+ assertKeysEquals("\033[Z", KeyHandler.getCodeFromTermcap("kB", false, false));++ // Arrow keys (up/down/right/left):+ assertKeysEquals("\033[A", KeyHandler.getCodeFromTermcap("ku", false, false));+ assertKeysEquals("\033[B", KeyHandler.getCodeFromTermcap("kd", false, false));+ assertKeysEquals("\033[C", KeyHandler.getCodeFromTermcap("kr", false, false));+ assertKeysEquals("\033[D", KeyHandler.getCodeFromTermcap("kl", false, false));+ // .. shifted:+ assertKeysEquals("\033[1;2A", KeyHandler.getCodeFromTermcap("kUP", false, false));+ assertKeysEquals("\033[1;2B", KeyHandler.getCodeFromTermcap("kDN", false, false));+ assertKeysEquals("\033[1;2C", KeyHandler.getCodeFromTermcap("%i", false, false));+ assertKeysEquals("\033[1;2D", KeyHandler.getCodeFromTermcap("#4", false, false));++ // Home/end keys:+ assertKeysEquals("\033[H", KeyHandler.getCodeFromTermcap("kh", false, false));+ assertKeysEquals("\033[F", KeyHandler.getCodeFromTermcap("@7", false, false));+ // ... shifted:+ assertKeysEquals("\033[1;2H", KeyHandler.getCodeFromTermcap("#2", false, false));+ assertKeysEquals("\033[1;2F", KeyHandler.getCodeFromTermcap("*7", false, false));++ // The traditional keyboard keypad:+ // [Insert] [Home] [Page Up ]+ // [Delete] [End] [Page Down]+ //+ // Termcap names (with xterm response in parenthesis):+ // K1=Upper left of keypad (xterm sends same "<ESC>[H" = Home).+ // K2=Center of keypad (xterm sends invalid response).+ // K3=Upper right of keypad (xterm sends "<ESC>[5~" = Page Up).+ // K4=Lower left of keypad (xterm sends "<ESC>[F" = End key).+ // K5=Lower right of keypad (xterm sends "<ESC>[6~" = Page Down).+ //+ // vim/neovim (runtime/doc/term.txt):+ // t_K1 <kHome> keypad home key+ // t_K3 <kPageUp> keypad page-up key+ // t_K4 <kEnd> keypad end key+ // t_K5 <kPageDown> keypad page-down key+ //+ assertKeysEquals("\033[H", KeyHandler.getCodeFromTermcap("K1", false, false));+ assertKeysEquals("\033OH", KeyHandler.getCodeFromTermcap("K1", true, false));+ assertKeysEquals("\033[5~", KeyHandler.getCodeFromTermcap("K3", false, false));+ assertKeysEquals("\033[F", KeyHandler.getCodeFromTermcap("K4", false, false));+ assertKeysEquals("\033OF", KeyHandler.getCodeFromTermcap("K4", true, false));+ assertKeysEquals("\033[6~", KeyHandler.getCodeFromTermcap("K5", false, false));++ // Function keys F1-F12:+ assertKeysEquals("\033OP", KeyHandler.getCodeFromTermcap("k1", false, false));+ assertKeysEquals("\033OQ", KeyHandler.getCodeFromTermcap("k2", false, false));+ assertKeysEquals("\033OR", KeyHandler.getCodeFromTermcap("k3", false, false));+ assertKeysEquals("\033OS", KeyHandler.getCodeFromTermcap("k4", false, false));+ assertKeysEquals("\033[15~", KeyHandler.getCodeFromTermcap("k5", false, false));+ assertKeysEquals("\033[17~", KeyHandler.getCodeFromTermcap("k6", false, false));+ assertKeysEquals("\033[18~", KeyHandler.getCodeFromTermcap("k7", false, false));+ assertKeysEquals("\033[19~", KeyHandler.getCodeFromTermcap("k8", false, false));+ assertKeysEquals("\033[20~", KeyHandler.getCodeFromTermcap("k9", false, false));+ assertKeysEquals("\033[21~", KeyHandler.getCodeFromTermcap("k;", false, false));+ assertKeysEquals("\033[23~", KeyHandler.getCodeFromTermcap("F1", false, false));+ assertKeysEquals("\033[24~", KeyHandler.getCodeFromTermcap("F2", false, false));+ // Function keys F13-F24 (same as shifted F1-F12):+ assertKeysEquals("\033[1;2P", KeyHandler.getCodeFromTermcap("F3", false, false));+ assertKeysEquals("\033[1;2Q", KeyHandler.getCodeFromTermcap("F4", false, false));+ assertKeysEquals("\033[1;2R", KeyHandler.getCodeFromTermcap("F5", false, false));+ assertKeysEquals("\033[1;2S", KeyHandler.getCodeFromTermcap("F6", false, false));+ assertKeysEquals("\033[15;2~", KeyHandler.getCodeFromTermcap("F7", false, false));+ assertKeysEquals("\033[17;2~", KeyHandler.getCodeFromTermcap("F8", false, false));+ assertKeysEquals("\033[18;2~", KeyHandler.getCodeFromTermcap("F9", false, false));+ assertKeysEquals("\033[19;2~", KeyHandler.getCodeFromTermcap("FA", false, false));+ assertKeysEquals("\033[20;2~", KeyHandler.getCodeFromTermcap("FB", false, false));+ assertKeysEquals("\033[21;2~", KeyHandler.getCodeFromTermcap("FC", false, false));+ assertKeysEquals("\033[23;2~", KeyHandler.getCodeFromTermcap("FD", false, false));+ assertKeysEquals("\033[24;2~", KeyHandler.getCodeFromTermcap("FE", false, false));+ }++ public void testKeyCodes() {+ // Return sends carriage return (\r), which normally gets translated by the device driver to newline (\n) unless the ICRNL termios+ // flag has been set.+ assertKeysEquals("\r", KeyHandler.getCode(KeyEvent.KEYCODE_ENTER, 0, false, false));++ // Backspace.+ assertKeysEquals("\u007f", KeyHandler.getCode(KeyEvent.KEYCODE_DEL, 0, false, false));++ // Space.+ assertNull(KeyHandler.getCode(KeyEvent.KEYCODE_SPACE, 0, false, false));+ assertKeysEquals("\u0000", KeyHandler.getCode(KeyEvent.KEYCODE_SPACE, KeyHandler.KEYMOD_CTRL, false, false));++ // Back tab.+ assertKeysEquals("\033[Z", KeyHandler.getCode(KeyEvent.KEYCODE_TAB, KeyHandler.KEYMOD_SHIFT, false, false));++ // Arrow keys (up/down/right/left):+ assertKeysEquals("\033[A", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_UP, 0, false, false));+ assertKeysEquals("\033[B", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_DOWN, 0, false, false));+ assertKeysEquals("\033[C", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_RIGHT, 0, false, false));+ assertKeysEquals("\033[D", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_LEFT, 0, false, false));+ // .. shifted:+ assertKeysEquals("\033[1;2A", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_UP, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2B", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_DOWN, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2C", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_RIGHT, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2D", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_LEFT, KeyHandler.KEYMOD_SHIFT, false, false));+ // .. ctrl:ed:+ assertKeysEquals("\033[1;5A", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_UP, KeyHandler.KEYMOD_CTRL, false, false));+ assertKeysEquals("\033[1;5B", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_DOWN, KeyHandler.KEYMOD_CTRL, false, false));+ assertKeysEquals("\033[1;5C", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_RIGHT, KeyHandler.KEYMOD_CTRL, false, false));+ assertKeysEquals("\033[1;5D", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_LEFT, KeyHandler.KEYMOD_CTRL, false, false));+ // .. ctrl:ed and shifted:+ int mod = KeyHandler.KEYMOD_CTRL | KeyHandler.KEYMOD_SHIFT;+ assertKeysEquals("\033[1;6A", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_UP, mod, false, false));+ assertKeysEquals("\033[1;6B", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_DOWN, mod, false, false));+ assertKeysEquals("\033[1;6C", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_RIGHT, mod, false, false));+ assertKeysEquals("\033[1;6D", KeyHandler.getCode(KeyEvent.KEYCODE_DPAD_LEFT, mod, false, false));++ // Home/end keys:+ assertKeysEquals("\033[H", KeyHandler.getCode(KeyEvent.KEYCODE_MOVE_HOME, 0, false, false));+ assertKeysEquals("\033[F", KeyHandler.getCode(KeyEvent.KEYCODE_MOVE_END, 0, false, false));+ // ... shifted:+ assertKeysEquals("\033[1;2H", KeyHandler.getCode(KeyEvent.KEYCODE_MOVE_HOME, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2F", KeyHandler.getCode(KeyEvent.KEYCODE_MOVE_END, KeyHandler.KEYMOD_SHIFT, false, false));++ // Function keys F1-F12:+ assertKeysEquals("\033OP", KeyHandler.getCode(KeyEvent.KEYCODE_F1, 0, false, false));+ assertKeysEquals("\033OQ", KeyHandler.getCode(KeyEvent.KEYCODE_F2, 0, false, false));+ assertKeysEquals("\033OR", KeyHandler.getCode(KeyEvent.KEYCODE_F3, 0, false, false));+ assertKeysEquals("\033OS", KeyHandler.getCode(KeyEvent.KEYCODE_F4, 0, false, false));+ assertKeysEquals("\033[15~", KeyHandler.getCode(KeyEvent.KEYCODE_F5, 0, false, false));+ assertKeysEquals("\033[17~", KeyHandler.getCode(KeyEvent.KEYCODE_F6, 0, false, false));+ assertKeysEquals("\033[18~", KeyHandler.getCode(KeyEvent.KEYCODE_F7, 0, false, false));+ assertKeysEquals("\033[19~", KeyHandler.getCode(KeyEvent.KEYCODE_F8, 0, false, false));+ assertKeysEquals("\033[20~", KeyHandler.getCode(KeyEvent.KEYCODE_F9, 0, false, false));+ assertKeysEquals("\033[21~", KeyHandler.getCode(KeyEvent.KEYCODE_F10, 0, false, false));+ assertKeysEquals("\033[23~", KeyHandler.getCode(KeyEvent.KEYCODE_F11, 0, false, false));+ assertKeysEquals("\033[24~", KeyHandler.getCode(KeyEvent.KEYCODE_F12, 0, false, false));+ // Function keys F13-F24 (same as shifted F1-F12):+ assertKeysEquals("\033[1;2P", KeyHandler.getCode(KeyEvent.KEYCODE_F1, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2Q", KeyHandler.getCode(KeyEvent.KEYCODE_F2, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2R", KeyHandler.getCode(KeyEvent.KEYCODE_F3, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[1;2S", KeyHandler.getCode(KeyEvent.KEYCODE_F4, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[15;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F5, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[17;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F6, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[18;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F7, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[19;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F8, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[20;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F9, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[21;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F10, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[23;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F11, KeyHandler.KEYMOD_SHIFT, false, false));+ assertKeysEquals("\033[24;2~", KeyHandler.getCode(KeyEvent.KEYCODE_F12, KeyHandler.KEYMOD_SHIFT, false, false));++ assertKeysEquals("0", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_0, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("1", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_1, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("2", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_2, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("3", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_3, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("4", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_4, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("5", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_5, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("6", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_6, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("7", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_7, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("8", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_8, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals("9", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_9, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals(",", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_COMMA, KeyHandler.KEYMOD_NUM_LOCK, false, false));+ assertKeysEquals(".", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_DOT, KeyHandler.KEYMOD_NUM_LOCK, false, false));++ assertKeysEquals("\033[2~", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_0, 0, false, false));+ assertKeysEquals("\033[F", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_1, 0, false, false));+ assertKeysEquals("\033[B", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_2, 0, false, false));+ assertKeysEquals("\033[6~", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_3, 0, false, false));+ assertKeysEquals("\033[D", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_4, 0, false, false));+ assertKeysEquals("5", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_5, 0, false, false));+ assertKeysEquals("\033[C", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_6, 0, false, false));+ assertKeysEquals("\033[H", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_7, 0, false, false));+ assertKeysEquals("\033[A", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_8, 0, false, false));+ assertKeysEquals("\033[5~", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_9, 0, false, false));+ assertKeysEquals("\033[3~", KeyHandler.getCode(KeyEvent.KEYCODE_NUMPAD_DOT, 0, false, false));+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/OperatingSystemControlTest.java b/terminal-emulator/src/test/java/com/termux/terminal/OperatingSystemControlTest.javanew file mode 100644index 0000000..13377c0--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/OperatingSystemControlTest.java@@ -0,0 +1,196 @@+package com.termux.terminal;++import android.util.Base64;++import java.util.ArrayList;+import java.util.List;+import java.util.Random;++/** "ESC ]" is the Operating System Command. */+public class OperatingSystemControlTest extends TerminalTestCase {++ public void testSetTitle() throws Exception {+ List<ChangedTitle> expectedTitleChanges = new ArrayList<>();++ withTerminalSized(10, 10);+ enterString("\033]0;Hello, world\007");+ assertEquals("Hello, world", mTerminal.getTitle());+ expectedTitleChanges.add(new ChangedTitle(null, "Hello, world"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033]0;Goodbye, world\007");+ assertEquals("Goodbye, world", mTerminal.getTitle());+ expectedTitleChanges.add(new ChangedTitle("Hello, world", "Goodbye, world"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033]0;Goodbye, \u00F1 world\007");+ assertEquals("Goodbye, \uu00F1 world", mTerminal.getTitle());+ expectedTitleChanges.add(new ChangedTitle("Goodbye, world", "Goodbye, \uu00F1 world"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ // 2 should work as well (0 sets both title and icon).+ enterString("\033]2;Updated\007");+ assertEquals("Updated", mTerminal.getTitle());+ expectedTitleChanges.add(new ChangedTitle("Goodbye, \uu00F1 world", "Updated"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033[22;0t");+ enterString("\033]0;FIRST\007");+ expectedTitleChanges.add(new ChangedTitle("Updated", "FIRST"));+ assertEquals("FIRST", mTerminal.getTitle());+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033[22;0t");+ enterString("\033]0;SECOND\007");+ assertEquals("SECOND", mTerminal.getTitle());++ expectedTitleChanges.add(new ChangedTitle("FIRST", "SECOND"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033[23;0t");+ assertEquals("FIRST", mTerminal.getTitle());++ expectedTitleChanges.add(new ChangedTitle("SECOND", "FIRST"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033[23;0t");+ expectedTitleChanges.add(new ChangedTitle("FIRST", "Updated"));+ assertEquals(expectedTitleChanges, mOutput.titleChanges);++ enterString("\033[22;0t");+ enterString("\033[22;0t");+ enterString("\033[22;0t");+ // Popping to same title should not cause changes.+ enterString("\033[23;0t");+ enterString("\033[23;0t");+ enterString("\033[23;0t");+ assertEquals(expectedTitleChanges, mOutput.titleChanges);+ }++ public void testTitleStack() throws Exception {+ // echo -ne '\e]0;BEFORE\007' # set title+ // echo -ne '\e[22t' # push to stack+ // echo -ne '\e]0;AFTER\007' # set new title+ // echo -ne '\e[23t' # retrieve from stack++ withTerminalSized(10, 10);+ enterString("\033]0;InitialTitle\007");+ assertEquals("InitialTitle", mTerminal.getTitle());+ enterString("\033[22t");+ assertEquals("InitialTitle", mTerminal.getTitle());+ enterString("\033]0;UpdatedTitle\007");+ assertEquals("UpdatedTitle", mTerminal.getTitle());+ enterString("\033[23t");+ assertEquals("InitialTitle", mTerminal.getTitle());+ enterString("\033[23t\033[23t\033[23t");+ assertEquals("InitialTitle", mTerminal.getTitle());+ }++ public void testSetColor() throws Exception {+ // "OSC 4; $INDEX; $COLORSPEC BEL" => Change color $INDEX to the color specified by $COLORSPEC.+ withTerminalSized(4, 4).enterString("\033]4;5;#00FF00\007");+ assertEquals(Integer.toHexString(0xFF00FF00), Integer.toHexString(mTerminal.mColors.mCurrentColors[5]));+ enterString("\033]4;5;#00FFAB\007");+ assertEquals(mTerminal.mColors.mCurrentColors[5], 0xFF00FFAB);+ enterString("\033]4;255;#ABFFAB\007");+ assertEquals(mTerminal.mColors.mCurrentColors[255], 0xFFABFFAB);+ // Two indexed colors at once:+ enterString("\033]4;7;#00FF00;8;#0000FF\007");+ assertEquals(mTerminal.mColors.mCurrentColors[7], 0xFF00FF00);+ assertEquals(mTerminal.mColors.mCurrentColors[8], 0xFF0000FF);+ }++ void assertIndexColorsMatch(int[] expected) {+ for (int i = 0; i < 255; i++)+ assertEquals("index=" + i, expected[i], mTerminal.mColors.mCurrentColors[i]);+ }++ public void testResetColor() throws Exception {+ withTerminalSized(4, 4);+ int[] initialColors = new int[TextStyle.NUM_INDEXED_COLORS];+ System.arraycopy(mTerminal.mColors.mCurrentColors, 0, initialColors, 0, initialColors.length);+ int[] expectedColors = new int[initialColors.length];+ System.arraycopy(mTerminal.mColors.mCurrentColors, 0, expectedColors, 0, expectedColors.length);+ Random rand = new Random();+ for (int endType = 0; endType < 3; endType++) {+ // Both BEL (7) and ST (ESC \) can end an OSC sequence.+ String ender = (endType == 0) ? "\007" : "\033\\";+ for (int i = 0; i < 255; i++) {+ expectedColors[i] = 0xFF000000 + (rand.nextInt() & 0xFFFFFF);+ int r = (expectedColors[i] >> 16) & 0xFF;+ int g = (expectedColors[i] >> 8) & 0xFF;+ int b = expectedColors[i] & 0xFF;+ String rgbHex = String.format("%02x", r) + String.format("%02x", g) + String.format("%02x", b);+ enterString("\033]4;" + i + ";#" + rgbHex + ender);+ assertEquals(expectedColors[i], mTerminal.mColors.mCurrentColors[i]);+ }+ }++ enterString("\033]104;0\007");+ expectedColors[0] = TerminalColors.COLOR_SCHEME.mDefaultColors[0];+ assertIndexColorsMatch(expectedColors);+ enterString("\033]104;1;2\007");+ expectedColors[1] = TerminalColors.COLOR_SCHEME.mDefaultColors[1];+ expectedColors[2] = TerminalColors.COLOR_SCHEME.mDefaultColors[2];+ assertIndexColorsMatch(expectedColors);+ enterString("\033]104\007"); // Reset all colors.+ assertIndexColorsMatch(TerminalColors.COLOR_SCHEME.mDefaultColors);+ }++ public void disabledTestSetClipboard() {+ // Cannot run this as a unit test since Base64 is a android.util class.+ enterString("\033]52;c;" + Base64.encodeToString("Hello, world".getBytes(), 0) + "\007");+ }++ public void testResettingTerminalResetsColor() throws Exception {+ // "OSC 4; $INDEX; $COLORSPEC BEL" => Change color $INDEX to the color specified by $COLORSPEC.+ withTerminalSized(4, 4).enterString("\033]4;5;#00FF00\007");+ enterString("\033]4;5;#00FFAB\007").assertColor(5, 0xFF00FFAB);+ enterString("\033]4;255;#ABFFAB\007").assertColor(255, 0xFFABFFAB);+ mTerminal.reset();+ assertIndexColorsMatch(TerminalColors.COLOR_SCHEME.mDefaultColors);+ }++ public void testSettingDynamicColors() {+ // "${OSC}${DYNAMIC};${COLORSPEC}${BEL_OR_STRINGTERMINATOR}" => Change ${DYNAMIC} color to the color specified by $COLORSPEC where:+ // DYNAMIC=10: Text foreground color.+ // DYNAMIC=11: Text background color.+ // DYNAMIC=12: Text cursor color.+ withTerminalSized(3, 3).enterString("\033]10;#ABCD00\007").assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFFABCD00);+ enterString("\033]11;#0ABCD0\007").assertColor(TextStyle.COLOR_INDEX_BACKGROUND, 0xFF0ABCD0);+ enterString("\033]12;#00ABCD\007").assertColor(TextStyle.COLOR_INDEX_CURSOR, 0xFF00ABCD);+ // Two special colors at once+ // ("Each successive parameter changes the next color in the list. The value of P s tells the starting point in the list"):+ enterString("\033]10;#FF0000;#00FF00\007").assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFFFF0000);+ assertColor(TextStyle.COLOR_INDEX_BACKGROUND, 0xFF00FF00);+ // Three at once:+ enterString("\033]10;#0000FF;#00FF00;#FF0000\007").assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFF0000FF);+ assertColor(TextStyle.COLOR_INDEX_BACKGROUND, 0xFF00FF00).assertColor(TextStyle.COLOR_INDEX_CURSOR, 0xFFFF0000);++ // Without ending semicolon:+ enterString("\033]10;#FF0000\007").assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFFFF0000);+ // For background and cursor:+ enterString("\033]11;#FFFF00;\007").assertColor(TextStyle.COLOR_INDEX_BACKGROUND, 0xFFFFFF00);+ enterString("\033]12;#00FFFF;\007").assertColor(TextStyle.COLOR_INDEX_CURSOR, 0xFF00FFFF);++ // Using string terminator:+ String stringTerminator = "\033\\";+ enterString("\033]10;#FF0000" + stringTerminator).assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFFFF0000);+ // For background and cursor:+ enterString("\033]11;#FFFF00;" + stringTerminator).assertColor(TextStyle.COLOR_INDEX_BACKGROUND, 0xFFFFFF00);+ enterString("\033]12;#00FFFF;" + stringTerminator).assertColor(TextStyle.COLOR_INDEX_CURSOR, 0xFF00FFFF);+ }++ public void testReportSpecialColors() {+ // "${OSC}${DYNAMIC};?${BEL}" => Terminal responds with the control sequence which would set the current color.+ // Both xterm and libvte (gnome-terminal and others) use the longest color representation, which means that+ // the response is "${OSC}rgb:RRRR/GGGG/BBBB"+ withTerminalSized(3, 3).enterString("\033]10;#ABCD00\007").assertColor(TextStyle.COLOR_INDEX_FOREGROUND, 0xFFABCD00);+ assertEnteringStringGivesResponse("\033]10;?\007", "\033]10;rgb:abab/cdcd/0000\007");+ // Same as above but with string terminator. xterm uses the same string terminator in the response, which+ // e.g. script posted at http://superuser.com/questions/157563/programmatic-access-to-current-xterm-background-color+ // relies on:+ assertEnteringStringGivesResponse("\033]10;?\033\\", "\033]10;rgb:abab/cdcd/0000\033\\");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/RectangularAreasTest.java b/terminal-emulator/src/test/java/com/termux/terminal/RectangularAreasTest.javanew file mode 100644index 0000000..8709c2c--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/RectangularAreasTest.java@@ -0,0 +1,117 @@+package com.termux.terminal;++public class RectangularAreasTest extends TerminalTestCase {++ /** http://www.vt100.net/docs/vt510-rm/DECFRA */+ public void testFillRectangularArea() {+ withTerminalSized(3, 3).enterString("\033[88$x").assertLinesAre("XXX", "XXX", "XXX");+ withTerminalSized(3, 3).enterString("\033[88;1;1;2;10$x").assertLinesAre("XXX", "XXX", " ");+ withTerminalSized(3, 3).enterString("\033[88;2;1;3;10$x").assertLinesAre(" ", "XXX", "XXX");+ withTerminalSized(3, 3).enterString("\033[88;1;1;100;1$x").assertLinesAre("X ", "X ", "X ");+ withTerminalSized(3, 3).enterString("\033[88;1;1;100;2$x").assertLinesAre("XX ", "XX ", "XX ");+ withTerminalSized(3, 3).enterString("\033[88;100;1;100;2$x").assertLinesAre(" ", " ", " ");+ }++ /** http://www.vt100.net/docs/vt510-rm/DECERA */+ public void testEraseRectangularArea() {+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[$z").assertLinesAre(" ", " ", " ");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;2;10$z").assertLinesAre(" ", " ", "GHI");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[2;1;3;10$z").assertLinesAre("ABC", " ", " ");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;100;1$z").assertLinesAre(" BC", " EF", " HI");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;100;2$z").assertLinesAre(" C", " F", " I");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[100;1;100;2$z").assertLinesAre("ABC", "DEF", "GHI");++ withTerminalSized(3, 3).enterString("A\033[$zBC").assertLinesAre(" BC", " ", " ");+ }++ /** http://www.vt100.net/docs/vt510-rm/DECSED */+ public void testSelectiveEraseInDisplay() {+ // ${CSI}1"q enables protection, ${CSI}0"q disables it.+ // ${CSI}?${0,1,2}J" erases (0=cursor to end, 1=start to cursor, 2=complete display).+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[?2J").assertLinesAre(" ", " ", " ");+ withTerminalSized(3, 3).enterString("ABC\033[1\"qDE\033[0\"qFGHI\033[?2J").assertLinesAre(" ", "DE ", " ");+ withTerminalSized(3, 3).enterString("\033[1\"qABCDE\033[0\"qFGHI\033[?2J").assertLinesAre("ABC", "DE ", " ");+ }++ /** http://vt100.net/docs/vt510-rm/DECSEL */+ public void testSelectiveEraseInLine() {+ // ${CSI}1"q enables protection, ${CSI}0"q disables it.+ // ${CSI}?${0,1,2}K" erases (0=cursor to end, 1=start to cursor, 2=complete line).+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[?2K").assertLinesAre("ABC", "DEF", " ");+ withTerminalSized(3, 3).enterString("ABCDE\033[?0KFGHI").assertLinesAre("ABC", "DEF", "GHI");+ withTerminalSized(3, 3).enterString("ABCDE\033[?1KFGHI").assertLinesAre("ABC", " F", "GHI");+ withTerminalSized(3, 3).enterString("ABCDE\033[?2KFGHI").assertLinesAre("ABC", " F", "GHI");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[2;2H\033[?0K").assertLinesAre("ABC", "D ", "GHI");+ withTerminalSized(3, 3).enterString("ABC\033[1\"qD\033[0\"qE\033[?2KFGHI").assertLinesAre("ABC", "D F", "GHI");+ }++ /** http://www.vt100.net/docs/vt510-rm/DECSERA */+ public void testSelectiveEraseInRectangle() {+ // ${CSI}1"q enables protection, ${CSI}0"q disables it.+ // ${CSI}?${TOP};${LEFT};${BOTTOM};${RIGHT}${" erases.+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[${").assertLinesAre(" ", " ", " ");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;2;10${").assertLinesAre(" ", " ", "GHI");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[2;1;3;10${").assertLinesAre("ABC", " ", " ");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;100;1${").assertLinesAre(" BC", " EF", " HI");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;100;2${").assertLinesAre(" C", " F", " I");+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[100;1;100;2${").assertLinesAre("ABC", "DEF", "GHI");++ withTerminalSized(3, 3).enterString("ABCD\033[1\"qE\033[0\"qFGHI\033[${").assertLinesAre(" ", " E ", " ");+ withTerminalSized(3, 3).enterString("ABCD\033[1\"qE\033[0\"qFGHI\033[1;1;2;10${").assertLinesAre(" ", " E ", "GHI");+ }++ /** http://vt100.net/docs/vt510-rm/DECCRA */+ public void testRectangularCopy() {+ // "${CSI}${SRC_TOP};${SRC_LEFT};${SRC_BOTTOM};${SRC_RIGHT};${SRC_PAGE};${DST_TOP};${DST_LEFT};${DST_PAGE}\$v"+ withTerminalSized(7, 3).enterString("ABC\r\nDEF\r\nGHI\033[1;1;2;2;1;2;5;1$v").assertLinesAre("ABC ", "DEF AB ", "GHI DE ");+ withTerminalSized(7, 3).enterString("ABC\r\nDEF\r\nGHI\033[1;1;3;3;1;1;4;1$v").assertLinesAre("ABCABC ", "DEFDEF ", "GHIGHI ");+ withTerminalSized(7, 3).enterString("ABC\r\nDEF\r\nGHI\033[1;1;3;3;1;1;3;1$v").assertLinesAre("ABABC ", "DEDEF ", "GHGHI ");+ withTerminalSized(7, 3).enterString(" ABC\r\n DEF\r\n GHI\033[1;4;3;6;1;1;1;1$v").assertLinesAre("ABCABC ", "DEFDEF ",+ "GHIGHI ");+ withTerminalSized(7, 3).enterString(" ABC\r\n DEF\r\n GHI\033[1;4;3;6;1;1;2;1$v").assertLinesAre(" ABCBC ", " DEFEF ",+ " GHIHI ");+ withTerminalSized(3, 3).enterString("ABC\r\nDEF\r\nGHI\033[1;1;2;2;1;2;2;1$v").assertLinesAre("ABC", "DAB", "GDE");++ // Enable ${CSI}?6h origin mode (DECOM) and ${CSI}?69h for left/right margin (DECLRMM) enabling, ${CSI}${LEFTMARGIN};${RIGHTMARGIN}s+ // for DECSLRM margin setting.+ withTerminalSized(5, 5).enterString("\033[?6h\033[?69h\033[2;4s");+ enterString("ABCDEFGHIJK").assertLinesAre(" ABC ", " DEF ", " GHI ", " JK ", " ");+ enterString("\033[1;1;2;2;1;2;2;1$v").assertLinesAre(" ABC ", " DAB ", " GDE ", " JK ", " ");+ }++ /** http://vt100.net/docs/vt510-rm/DECCARA */+ public void testChangeAttributesInRectangularArea() {+ final int b = TextStyle.CHARACTER_ATTRIBUTE_BOLD;+ // "${CSI}${TOP};${LEFT};${BOTTOM};${RIGHT};${ATTRIBUTES}\$r"+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;2;2;1$r").assertLinesAre("ABC", "DEF", "GHI");+ assertEffectAttributesSet(effectLine(b, b, b), effectLine(b, b, 0), effectLine(0, 0, 0));++ // Now with http://www.vt100.net/docs/vt510-rm/DECSACE ("${CSI}2*x") specifying rectangle:+ withTerminalSized(3, 3).enterString("\033[2*xABCDEFGHI\033[1;1;2;2;1$r").assertLinesAre("ABC", "DEF", "GHI");+ assertEffectAttributesSet(effectLine(b, b, 0), effectLine(b, b, 0), effectLine(0, 0, 0));+ }++ /** http://vt100.net/docs/vt510-rm/DECCARA */+ public void testReverseAttributesInRectangularArea() {+ final int b = TextStyle.CHARACTER_ATTRIBUTE_BOLD;+ final int u = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ final int bu = TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;+ // "${CSI}${TOP};${LEFT};${BOTTOM};${RIGHT};${ATTRIBUTES}\$t"+ withTerminalSized(3, 3).enterString("ABCDEFGHI\033[1;1;2;2;1$t").assertLinesAre("ABC", "DEF", "GHI");+ assertEffectAttributesSet(effectLine(b, b, b), effectLine(b, b, 0), effectLine(0, 0, 0));++ // Now with http://www.vt100.net/docs/vt510-rm/DECSACE ("${CSI}2*x") specifying rectangle:+ withTerminalSized(3, 3).enterString("\033[2*xABCDEFGHI\033[1;1;2;2;1$t").assertLinesAre("ABC", "DEF", "GHI");+ assertEffectAttributesSet(effectLine(b, b, 0), effectLine(b, b, 0), effectLine(0, 0, 0));++ // Check reversal by initially bolding the B:+ withTerminalSized(3, 3).enterString("\033[2*xA\033[1mB\033[0mCDEFGHI\033[1;1;2;2;1$t").assertLinesAre("ABC", "DEF", "GHI");+ assertEffectAttributesSet(effectLine(b, 0, 0), effectLine(b, b, 0), effectLine(0, 0, 0));++ // Check reversal by initially underlining A, bolding B, then reversing both bold and underline:+ withTerminalSized(3, 3).enterString("\033[2*x\033[4mA\033[0m\033[1mB\033[0mCDEFGHI\033[1;1;2;2;1;4$t").assertLinesAre("ABC", "DEF",+ "GHI");+ assertEffectAttributesSet(effectLine(b, u, 0), effectLine(bu, bu, 0), effectLine(0, 0, 0));+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ResizeTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ResizeTest.javanew file mode 100644index 0000000..6c32d66--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ResizeTest.java@@ -0,0 +1,212 @@+package com.termux.terminal;++public class ResizeTest extends TerminalTestCase {++ public void testResizeWhenHasHistory() {+ final int cols = 3;+ withTerminalSized(cols, 3).enterString("111222333444555666777888999").assertCursorAt(2, 2).assertLinesAre("777", "888", "999");+ resize(cols, 5).assertCursorAt(4, 2).assertLinesAre("555", "666", "777", "888", "999");+ resize(cols, 3).assertCursorAt(2, 2).assertLinesAre("777", "888", "999");+ }++ public void testResizeWhenInAltBuffer() {+ final int rows = 3, cols = 3;+ withTerminalSized(cols, rows).enterString("a\r\ndef$").assertLinesAre("a ", "def", "$ ").assertCursorAt(2, 1);++ // Resize and back again while in main buffer:+ resize(cols, 5).assertLinesAre("a ", "def", "$ ", " ", " ").assertCursorAt(2, 1);+ resize(cols, rows).assertLinesAre("a ", "def", "$ ").assertCursorAt(2, 1);++ // Switch to alt buffer:+ enterString("\033[?1049h").assertLinesAre(" ", " ", " ").assertCursorAt(2, 1);+ enterString("h").assertLinesAre(" ", " ", " h ").assertCursorAt(2, 2);++ resize(cols, 5).resize(cols, rows);++ // Switch from alt buffer:+ enterString("\033[?1049l").assertLinesAre("a ", "def", "$ ").assertCursorAt(2, 1);+ }++ public void testShrinkingInAltBuffer() {+ final int rows = 5;+ final int cols = 3;+ withTerminalSized(cols, rows).enterString("A\r\nB\r\nC\r\nD\r\nE").assertLinesAre("A ", "B ", "C ", "D ", "E ");+ enterString("\033[?1049h").assertLinesAre(" ", " ", " ", " ", " ");+ resize(3, 3).enterString("\033[?1049lF").assertLinesAre("C ", "D ", "EF ");+ }++ public void testResizeAfterNewlineWhenInAltBuffer() {+ final int rows = 3;+ final int cols = 3;+ withTerminalSized(cols, rows);+ enterString("a\r\nb\r\nc\r\nd\r\ne\r\nf\r\n").assertLinesAre("e ", "f ", " ").assertCursorAt(2, 0);+ assertLineWraps(false, false, false);++ // Switch to alt buffer:+ enterString("\033[?1049h").assertLinesAre(" ", " ", " ").assertCursorAt(2, 0);+ enterString("h").assertLinesAre(" ", " ", "h ").assertCursorAt(2, 1);++ // Grow by two rows:+ resize(cols, 5).assertLinesAre(" ", " ", "h ", " ", " ").assertCursorAt(2, 1);+ resize(cols, rows).assertLinesAre(" ", " ", "h ").assertCursorAt(2, 1);++ // Switch from alt buffer:+ enterString("\033[?1049l").assertLinesAre("e ", "f ", " ").assertCursorAt(2, 0);+ }++ public void testResizeAfterHistoryWraparound() {+ final int rows = 3;+ final int cols = 10;+ withTerminalSized(cols, rows);+ StringBuilder buffer = new StringBuilder();+ for (int i = 0; i < 1000; i++) {+ String s = Integer.toString(i);+ enterString(s);+ buffer.setLength(0);+ buffer.append(s);+ while (buffer.length() < cols)+ buffer.append(' ');+ if (i > rows) {+ assertLineIs(rows - 1, buffer.toString());+ }+ enterString("\r\n");+ }+ assertLinesAre("998 ", "999 ", " ");+ resize(cols, 2);+ assertLinesAre("999 ", " ");+ resize(cols, 5);+ assertLinesAre("996 ", "997 ", "998 ", "999 ", " ");+ resize(cols, rows);+ assertLinesAre("998 ", "999 ", " ");+ }++ public void testVerticalResize() {+ final int rows = 5;+ final int cols = 3;++ withTerminalSized(cols, rows);+ // Foreground color to 119:+ enterString("\033[38;5;119m");+ // Background color to 129:+ enterString("\033[48;5;129m");+ // Clear with ED, Erase in Display:+ enterString("\033[2J");+ for (int r = 0; r < rows; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals(119, TextStyle.decodeForeColor(style));+ assertEquals(129, TextStyle.decodeBackColor(style));+ }+ }+ enterString("11\r\n22");+ assertLinesAre("11 ", "22 ", " ", " ", " ").assertLineWraps(false, false, false, false, false);+ resize(cols, rows - 2).assertLinesAre("11 ", "22 ", " ");++ // After resize, screen should still be same color:+ for (int r = 0; r < rows - 2; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals(119, TextStyle.decodeForeColor(style));+ assertEquals(129, TextStyle.decodeBackColor(style));+ }+ }++ // Background color to 200 and grow back size (which should be cleared to the new background color):+ enterString("\033[48;5;200m");+ resize(cols, rows);+ for (int r = 0; r < rows; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals(119, TextStyle.decodeForeColor(style));+ assertEquals("wrong at row=" + r, r >= 3 ? 200 : 129, TextStyle.decodeBackColor(style));+ }+ }+ }++ public void testHorizontalResize() {+ final int rows = 5;+ final int cols = 5;++ withTerminalSized(cols, rows);+ // Background color to 129:+ // enterString("\033[48;5;129m").assertLinesAre(" ", " ", " ", " ", " ");+ enterString("1111\r\n2222\r\n3333\r\n4444\r\n5555").assertCursorAt(4, 4);+ // assertEquals(129, TextStyle.decodeBackColor(getStyleAt(2, 2)));+ assertLinesAre("1111 ", "2222 ", "3333 ", "4444 ", "5555 ").assertLineWraps(false, false, false, false, false);+ resize(cols + 2, rows).assertLinesAre("1111 ", "2222 ", "3333 ", "4444 ", "5555 ").assertCursorAt(4, 4);+ assertLineWraps(false, false, false, false, false);+ resize(cols, rows).assertLinesAre("1111 ", "2222 ", "3333 ", "4444 ", "5555 ").assertCursorAt(4, 4);+ assertLineWraps(false, false, false, false, false);+ resize(cols - 1, rows).assertLinesAre("2222", "3333", "4444", "5555", " ").assertCursorAt(4, 0);+ assertLineWraps(false, false, false, true, false);+ resize(cols - 2, rows).assertLinesAre("3 ", "444", "4 ", "555", "5 ").assertCursorAt(4, 1);+ assertLineWraps(false, true, false, true, false);+ // Back to original size:+ resize(cols, rows).assertLinesAre("1111 ", "2222 ", "3333 ", "4444 ", "5555 ").assertCursorAt(4, 4);+ assertLineWraps(false, false, false, false, false);+ }++ public void testLineWrap() {+ final int rows = 3, cols = 5;+ withTerminalSized(cols, rows).enterString("111111").assertLinesAre("11111", "1 ", " ");+ assertCursorAt(1, 1).assertLineWraps(true, false, false);++ resize(7, rows).assertCursorAt(0, 6).assertLinesAre("111111 ", " ", " ").assertLineWraps(false, false, false);+ resize(cols, rows).assertCursorAt(1, 1).assertLinesAre("11111", "1 ", " ").assertLineWraps(true, false, false);++ enterString("2").assertLinesAre("11111", "12 ", " ").assertLineWraps(true, false, false);+ enterString("123").assertLinesAre("11111", "12123", " ").assertLineWraps(true, false, false);+ enterString("W").assertLinesAre("11111", "12123", "W ").assertLineWraps(true, true, false);++ withTerminalSized(cols, rows).enterString("1234512345");+ assertLinesAre("12345", "12345", " ").assertLineWraps(true, false, false);+ enterString("W").assertLinesAre("12345", "12345", "W ").assertLineWraps(true, true, false);+ }++ public void testCursorPositionWhenShrinking() {+ final int rows = 5, cols = 3;+ withTerminalSized(cols, rows).enterString("$ ").assertLinesAre("$ ", " ", " ", " ", " ").assertCursorAt(0, 2);+ resize(3, 3).assertLinesAre("$ ", " ", " ").assertCursorAt(0, 2);+ resize(cols, rows).assertLinesAre("$ ", " ", " ", " ", " ").assertCursorAt(0, 2);+ }++ public void testResizeWithCombiningCharInLastColumn() {+ withTerminalSized(3, 3).enterString("ABC\u0302DEF").assertLinesAre("ABC\u0302", "DEF", " ");+ resize(4, 3).assertLinesAre("ABC\u0302D", "EF ", " ");++ // Same as above but with colors:+ withTerminalSized(3, 3).enterString("\033[37mA\033[35mB\033[33mC\u0302\033[32mD\033[31mE\033[34mF").assertLinesAre("ABC\u0302",+ "DEF", " ");+ resize(4, 3).assertLinesAre("ABC\u0302D", "EF ", " ");+ assertForegroundIndices(effectLine(7, 5, 3, 2), effectLine(1, 4, 4, 4), effectLine(4, 4, 4, 4));+ }++ public void testResizeWithLineWrappingContinuing() {+ withTerminalSized(5, 3).enterString("\r\nAB DE").assertLinesAre(" ", "AB DE", " ");+ resize(4, 3).assertLinesAre("AB D", "E ", " ");+ resize(3, 3).assertLinesAre("AB ", "DE ", " ");+ resize(5, 3).assertLinesAre(" ", "AB DE", " ");+ }++ public void testResizeWithWideChars() {+ final int rows = 3, cols = 4;+ String twoCharsWidthOne = new String(Character.toChars(TerminalRowTest.TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1));+ withTerminalSized(cols, rows).enterString(twoCharsWidthOne).enterString("\r\n");+ enterString(twoCharsWidthOne).assertLinesAre(twoCharsWidthOne + " ", twoCharsWidthOne + " ", " ");+ resize(3, 3).assertLinesAre(twoCharsWidthOne + " ", twoCharsWidthOne + " ", " ");+ enterString(twoCharsWidthOne).assertLinesAre(twoCharsWidthOne + " ", twoCharsWidthOne + twoCharsWidthOne + " ", " ");+ }++ public void testResizeWithMoreWideChars() {+ final int rows = 4, cols = 5;++ withTerminalSized(cols, rows).enterString("qqrr").assertLinesAre("qqrr ", " ", " ", " ");+ resize(2, rows).assertLinesAre("qq", "rr", " ", " ");+ resize(5, rows).assertLinesAre("qqrr ", " ", " ", " ");++ withTerminalSized(cols, rows).enterString("QR").assertLinesAre("QR ", " ", " ", " ");+ resize(2, rows).assertLinesAre("Q", "R", " ", " ");+ resize(5, rows).assertLinesAre("QR ", " ", " ", " ");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ScreenBufferTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ScreenBufferTest.javanew file mode 100644index 0000000..9a8f115--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ScreenBufferTest.java@@ -0,0 +1,65 @@+package com.termux.terminal;++public class ScreenBufferTest extends TerminalTestCase {++ public void testBasics() {+ TerminalBuffer screen = new TerminalBuffer(5, 3, 3);+ assertEquals("", screen.getTranscriptText());+ screen.setChar(0, 0, 'a', 0);+ assertEquals("a", screen.getTranscriptText());+ screen.setChar(0, 0, 'b', 0);+ assertEquals("b", screen.getTranscriptText());+ screen.setChar(2, 0, 'c', 0);+ assertEquals("b c", screen.getTranscriptText());+ screen.setChar(2, 2, 'f', 0);+ assertEquals("b c\n\n f", screen.getTranscriptText());+ screen.blockSet(0, 0, 2, 2, 'X', 0);+ }++ public void testBlockSet() {+ TerminalBuffer screen = new TerminalBuffer(5, 3, 3);+ screen.blockSet(0, 0, 2, 2, 'X', 0);+ assertEquals("XX\nXX", screen.getTranscriptText());+ screen.blockSet(1, 1, 2, 2, 'Y', 0);+ assertEquals("XX\nXYY\n YY", screen.getTranscriptText());+ }++ public void testGetSelectedText() {+ withTerminalSized(5, 3).enterString("ABCDEFGHIJ").assertLinesAre("ABCDE", "FGHIJ", " ");+ assertEquals("AB", mTerminal.getSelectedText(0, 0, 1, 0));+ assertEquals("BC", mTerminal.getSelectedText(1, 0, 2, 0));+ assertEquals("CDE", mTerminal.getSelectedText(2, 0, 4, 0));+ assertEquals("FG", mTerminal.getSelectedText(0, 1, 1, 1));+ assertEquals("GH", mTerminal.getSelectedText(1, 1, 2, 1));+ assertEquals("HIJ", mTerminal.getSelectedText(2, 1, 4, 1));++ assertEquals("ABCDEFG", mTerminal.getSelectedText(0, 0, 1, 1));+ withTerminalSized(5, 3).enterString("ABCDE\r\nFGHIJ").assertLinesAre("ABCDE", "FGHIJ", " ");+ assertEquals("ABCDE\nFG", mTerminal.getSelectedText(0, 0, 1, 1));+ }++ public void testGetSelectedTextJoinFullLines() {+ withTerminalSized(5, 3).enterString("ABCDE\r\nFG");+ assertEquals("ABCDEFG", mTerminal.getScreen().getSelectedText(0, 0, 1, 1, true, true));++ withTerminalSized(5, 3).enterString("ABC\r\nFG");+ assertEquals("ABC\nFG", mTerminal.getScreen().getSelectedText(0, 0, 1, 1, true, true));+ }++ public void testGetWordAtLocation() {+ withTerminalSized(5, 3).enterString("ABCDEFGHIJ\r\nKLMNO");+ assertEquals("ABCDEFGHIJKLMNO", mTerminal.getScreen().getWordAtLocation(0, 0));+ assertEquals("ABCDEFGHIJKLMNO", mTerminal.getScreen().getWordAtLocation(4, 1));+ assertEquals("ABCDEFGHIJKLMNO", mTerminal.getScreen().getWordAtLocation(4, 2));++ withTerminalSized(5, 3).enterString("ABC DEF GHI ");+ assertEquals("ABC", mTerminal.getScreen().getWordAtLocation(0, 0));+ assertEquals("", mTerminal.getScreen().getWordAtLocation(3, 0));+ assertEquals("DEF", mTerminal.getScreen().getWordAtLocation(4, 0));+ assertEquals("DEF", mTerminal.getScreen().getWordAtLocation(0, 1));+ assertEquals("DEF", mTerminal.getScreen().getWordAtLocation(1, 1));+ assertEquals("GHI", mTerminal.getScreen().getWordAtLocation(0, 2));+ assertEquals("", mTerminal.getScreen().getWordAtLocation(1, 2));+ assertEquals("", mTerminal.getScreen().getWordAtLocation(2, 2));+ }+}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/ScrollRegionTest.java b/terminal-emulator/src/test/java/com/termux/terminal/ScrollRegionTest.javanew file mode 100644index 0000000..039605a--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/ScrollRegionTest.java@@ -0,0 +1,167 @@+package com.termux.terminal;++/**+ * ${CSI}${top};${bottom}r" - set Scrolling Region [top;bottom] (default = full size of window) (DECSTBM).+ * <p/>+ * "DECSTBM moves the cursor to column 1, line 1 of the page" (http://www.vt100.net/docs/vt510-rm/DECSTBM).+ */+public class ScrollRegionTest extends TerminalTestCase {++ public void testScrollRegionTop() {+ withTerminalSized(3, 4).enterString("111222333444").assertLinesAre("111", "222", "333", "444");+ enterString("\033[2r").assertCursorAt(0, 0);+ enterString("\r\n\r\n\r\n\r\nCDEFGH").assertLinesAre("111", "444", "CDE", "FGH").assertHistoryStartsWith("333");+ enterString("IJK").assertLinesAre("111", "CDE", "FGH", "IJK").assertHistoryStartsWith("444");+ // Reset scroll region and enter line:+ enterString("\033[r").enterString("\r\n\r\n\r\n").enterString("LMNOPQ").assertLinesAre("CDE", "FGH", "LMN", "OPQ");+ }++ public void testScrollRegionBottom() {+ withTerminalSized(3, 4).enterString("111222333444");+ assertLinesAre("111", "222", "333", "444");+ enterString("\033[1;3r").assertCursorAt(0, 0);+ enterString("\r\n\r\nCDEFGH").assertLinesAre("222", "CDE", "FGH", "444").assertHistoryStartsWith("111");+ // Reset scroll region and enter line:+ enterString("\033[r").enterString("\r\n\r\n\r\n").enterString("IJKLMN").assertLinesAre("CDE", "FGH", "IJK", "LMN");+ }++ public void testScrollRegionResetWithOriginMode() {+ withTerminalSized(3, 4).enterString("111222333444");+ assertLinesAre("111", "222", "333", "444");+ // "\033[?6h" sets origin mode, so that the later DECSTBM resets cursor to below margin:+ enterString("\033[?6h\033[2r").assertCursorAt(1, 0);+ }++ public void testScrollRegionLeft() {+ // ${CSI}?69h for DECLRMM enabling, ${CSI}${LEFTMARGIN};${RIGHTMARGIN}s for DECSLRM margin setting.+ withTerminalSized(3, 3).enterString("\033[?69h\033[2sABCDEFG").assertLinesAre("ABC", " DE", " FG");+ enterString("HI").assertLinesAre("ADE", " FG", " HI").enterString("JK").assertLinesAre("AFG", " HI", " JK");+ enterString("\n").assertLinesAre("AHI", " JK", " ");+ }++ public void testScrollRegionRight() {+ // ${CSI}?69h for DECLRMM enabling, ${CSI}${LEFTMARGIN};${RIGHTMARGIN}s for DECSLRM margin setting.+ withTerminalSized(3, 3).enterString("YYY\033[?69h\033[1;2sABCDEF").assertLinesAre("ABY", "CD ", "EF ");+ enterString("GH").assertLinesAre("CDY", "EF ", "GH ").enterString("IJ").assertLinesAre("EFY", "GH ", "IJ ");+ enterString("\n").assertLinesAre("GHY", "IJ ", " ");+ }++ public void testScrollRegionOnAllSides() {+ // ${CSI}?69h for DECLRMM enabling, ${CSI}${LEFTMARGIN};${RIGHTMARGIN}s for DECSLRM margin setting.+ withTerminalSized(4, 4).enterString("ABCDEFGHIJKLMNOP").assertLinesAre("ABCD", "EFGH", "IJKL", "MNOP");+ // http://www.vt100.net/docs/vt510-rm/DECOM+ enterString("\033[?6h\033[2;3r").assertCursorAt(1, 0);+ enterString("\033[?69h\033[2;3s").assertCursorAt(1, 1);+ enterString("QRST").assertLinesAre("ABCD", "EQRH", "ISTL", "MNOP");+ enterString("UV").assertLinesAre("ABCD", "ESTH", "IUVL", "MNOP");+ }++ public void testDECCOLMResetsScrollMargin() {+ // DECCOLM — Select 80 or 132 Columns per Page (http://www.vt100.net/docs/vt510-rm/DECCOLM) has the important+ // side effect to clear scroll margins, which is useful for e.g. the "reset" utility to clear scroll margins.+ withTerminalSized(3, 4).enterString("111222333444").assertLinesAre("111", "222", "333", "444");+ enterString("\033[2r\033[?3h\r\nABCDEFGHIJKL").assertLinesAre("ABC", "DEF", "GHI", "JKL");+ }++ public void testScrollOutsideVerticalRegion() {+ withTerminalSized(3, 4).enterString("\033[0;2rhi\033[4;0Hyou").assertLinesAre("hi ", " ", " ", "you");+ //enterString("see").assertLinesAre("hi ", " ", " ", "see");+ }++ public void testNELRespectsLeftMargin() {+ // vttest "Menu 11.3.2: VT420 Cursor-Movement Test", select "10. Test other movement (CR/HT/LF/FF) within margins".+ // The NEL (ESC E) sequence moves cursor to first position on next line, where first position depends on origin mode and margin.+ withTerminalSized(3, 3).enterString("\033[?69h\033[2sABC\033ED").assertLinesAre("ABC", "D ", " ");+ withTerminalSized(3, 3).enterString("\033[?69h\033[2sABC\033[?6h\033ED").assertLinesAre("ABC", " D ", " ");+ }++ public void testRiRespectsLeftMargin() {+ // Reverse Index (RI), ${ESC}M, should respect horizontal margins:+ withTerminalSized(4, 3).enterString("ABCD\033[?69h\033[2;3s\033[?6h\033M").assertLinesAre("A D", " BC ", " ");+ }++ public void testSdRespectsLeftMargin() {+ // Scroll Down (SD), ${CSI}${N}T, should respect horizontal margins:+ withTerminalSized(4, 3).enterString("ABCD\033[?69h\033[2;3s\033[?6h\033[2T").assertLinesAre("A D", " ", " BC ");+ }++ public void testBackwardIndex() {+ // vttest "Menu 11.3.2: VT420 Cursor-Movement Test", test 7.+ // Without margins:+ withTerminalSized(3, 3).enterString("ABCDEF\0336H").assertLinesAre("ABC", "DHF", " ");+ enterString("\0336\0336I").assertLinesAre("ABC", "IHF", " ");+ enterString("\0336\0336").assertLinesAre(" AB", " IH", " ");+ // With left margin:+ withTerminalSized(3, 3).enterString("\033[?69h\033[2sABCDEF\0336\0336").assertLinesAre("A B", " D", " F");+ }++ public void testForwardIndex() {+ // vttest "Menu 11.3.2: VT420 Cursor-Movement Test", test 8.+ // Without margins:+ withTerminalSized(3, 3).enterString("ABCD\0339E").assertLinesAre("ABC", "D E", " ");+ enterString("\0339").assertLinesAre("BC ", " E ", " ");+ // With right margin:+ withTerminalSized(3, 3).enterString("\033[?69h\033[0;2sABCD\0339").assertLinesAre("B ", "D ", " ");+ }++ public void testScrollDownWithScrollRegion() {+ withTerminalSized(2, 5).enterString("1\r\n2\r\n3\r\n4\r\n5").assertLinesAre("1 ", "2 ", "3 ", "4 ", "5 ");+ enterString("\033[3r").enterString("\033[2T").assertLinesAre("1 ", "2 ", " ", " ", "3 ");+ }++ public void testScrollDownBelowScrollRegion() {+ withTerminalSized(2, 5).enterString("1\r\n2\r\n3\r\n4\r\n5").assertLinesAre("1 ", "2 ", "3 ", "4 ", "5 ");+ enterString("\033[1;3r"); // DECSTBM margins.+ enterString("\033[4;1H"); // Place cursor just below bottom margin.+ enterString("QQ\r\nRR\r\n\r\n\r\nYY");+ assertLinesAre("1 ", "2 ", "3 ", "QQ", "YY");+ }++ /** See https://github.com/termux/termux-app/issues/1340 */+ public void testScrollRegionDoesNotLimitCursorMovement() {+ withTerminalSized(6, 4)+ .enterString("\033[4;7r\033[3;1Haaa\033[Axxx")+ .assertLinesAre(+ " ",+ " xxx",+ "aaa ",+ " "+ );++ withTerminalSized(6, 4)+ .enterString("\033[1;3r\033[3;1Haaa\033[Bxxx")+ .assertLinesAre(+ " ",+ " ",+ "aaa ",+ " xxx"+ );+ }++ /**+ * See <a href="https://github.com/termux/termux-packages/issues/12556">reported issue</a>.+ */+ public void testClearingWhenScrollingWithMargins() {+ int newForeground = 2;+ int newBackground = 3;+ int size = 3;+ TerminalTestCase terminal = withTerminalSized(size, size)+ // Enable horizontal margin and set left margin to 1:+ .enterString("\033[?69h\033[2s")+ // Set foreground and background color:+ .enterString("\033[" + (30 + newForeground) + ";" + (40 + newBackground) + "m")+ // Enter newlines to scroll down:+ .enterString("\r\n\r\n\r\n\r\n\r\n");+ for (int row = 0; row < size; row++) {+ for (int col = 0; col < size; col++) {+ // The first column (outside of the scrolling area, due to us setting a left scroll+ // margin of 1) should be unmodified, the others should use the current style:+ int expectedForeground = col == 0 ? TextStyle.COLOR_INDEX_FOREGROUND : newForeground;+ int expectedBackground = col == 0 ? TextStyle.COLOR_INDEX_BACKGROUND : newBackground;+ terminal.assertForegroundColorAt(row, col, expectedForeground);+ terminal.assertBackgroundColorAt(row, col, expectedBackground);+ }+ }+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/TerminalRowTest.java b/terminal-emulator/src/test/java/com/termux/terminal/TerminalRowTest.javanew file mode 100644index 0000000..043d608--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/TerminalRowTest.java@@ -0,0 +1,432 @@+package com.termux.terminal;++import junit.framework.TestCase;++import java.util.Arrays;+import java.util.Random;++public class TerminalRowTest extends TestCase {++ /** The properties of these code points are validated in {@link #testStaticConstants()}. */+ private static final int ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1 = 0x679C;+ private static final int ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2 = 0x679D;+ private static final int TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1 = 0x2070E;+ private static final int TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2 = 0x20731;++ /** Unicode Character 'MUSICAL SYMBOL G CLEF' (U+1D11E). Two java chars required for this. */+ static final int TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1 = 0x1D11E;+ /** Unicode Character 'MUSICAL SYMBOL G CLEF OTTAVA ALTA' (U+1D11F). Two java chars required for this. */+ private static final int TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_2 = 0x1D11F;++ private final int COLUMNS = 80;++ /** A combining character. */+ private static final int DIARESIS_CODEPOINT = 0x0308;++ private TerminalRow row;++ @Override+ protected void setUp() throws Exception {+ super.setUp();+ row = new TerminalRow(COLUMNS, TextStyle.NORMAL);+ }++ private void assertLineStartsWith(int... codePoints) {+ char[] chars = row.mText;+ int charIndex = 0;+ for (int i = 0; i < codePoints.length; i++) {+ int lineCodePoint = chars[charIndex++];+ if (Character.isHighSurrogate((char) lineCodePoint)) {+ lineCodePoint = Character.toCodePoint((char) lineCodePoint, chars[charIndex++]);+ }+ assertEquals("Differing a code point index=" + i, codePoints[i], lineCodePoint);+ }+ }++ private void assertColumnCharIndicesStartsWith(int... indices) {+ for (int i = 0; i < indices.length; i++) {+ int expected = indices[i];+ int actual = row.findStartOfColumn(i);+ assertEquals("At index=" + i, expected, actual);+ }+ }++ public void testSimpleDiaresis() {+ row.setChar(0, DIARESIS_CODEPOINT, 0);+ assertEquals(81, row.getSpaceUsed());+ row.setChar(0, DIARESIS_CODEPOINT, 0);+ assertEquals(82, row.getSpaceUsed());+ assertLineStartsWith(' ', DIARESIS_CODEPOINT, DIARESIS_CODEPOINT, ' ');+ }++ public void testStaticConstants() {+ assertEquals(1, Character.charCount(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1));+ assertEquals(1, Character.charCount(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2));+ assertEquals(2, WcWidth.width(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1));+ assertEquals(2, WcWidth.width(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2));++ assertEquals(2, Character.charCount(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1));+ assertEquals(2, Character.charCount(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_2));+ assertEquals(1, WcWidth.width(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1));+ assertEquals(1, WcWidth.width(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_2));++ assertEquals(2, Character.charCount(TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1));+ assertEquals(2, Character.charCount(TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2));+ assertEquals(2, WcWidth.width(TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1));+ assertEquals(2, WcWidth.width(TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2));++ assertEquals(1, Character.charCount(DIARESIS_CODEPOINT));+ assertEquals(0, WcWidth.width(DIARESIS_CODEPOINT));+ }++ public void testOneColumn() {+ assertEquals(0, row.findStartOfColumn(0));+ row.setChar(0, 'a', 0);+ assertEquals(0, row.findStartOfColumn(0));+ }++ public void testAscii() {+ assertEquals(0, row.findStartOfColumn(0));+ row.setChar(0, 'a', 0);+ assertLineStartsWith('a', ' ', ' ');+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(80, row.getSpaceUsed());+ row.setChar(0, 'b', 0);+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(2, row.findStartOfColumn(2));+ assertEquals(80, row.getSpaceUsed());+ assertColumnCharIndicesStartsWith(0, 1, 2, 3);++ char[] someChars = new char[]{'a', 'c', 'e', '4', '5', '6', '7', '8'};++ char[] rawLine = new char[80];+ Arrays.fill(rawLine, ' ');+ Random random = new Random();+ for (int i = 0; i < 1000; i++) {+ int lineIndex = random.nextInt(rawLine.length);+ int charIndex = random.nextInt(someChars.length);+ rawLine[lineIndex] = someChars[charIndex];+ row.setChar(lineIndex, someChars[charIndex], 0);+ }+ char[] lineChars = row.mText;+ for (int i = 0; i < rawLine.length; i++) {+ assertEquals(rawLine[i], lineChars[i]);+ }+ }++ public void testUnicode() {+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(80, row.getSpaceUsed());++ row.setChar(0, TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, 0);+ assertEquals(81, row.getSpaceUsed());+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(2, row.findStartOfColumn(1));+ assertLineStartsWith(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, ' ', ' ');+ assertColumnCharIndicesStartsWith(0, 2, 3, 4);++ row.setChar(0, 'a', 0);+ assertEquals(80, row.getSpaceUsed());+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertLineStartsWith('a', ' ', ' ');+ assertColumnCharIndicesStartsWith(0, 1, 2, 3);++ row.setChar(0, TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, 0);+ row.setChar(1, 'a', 0);+ assertLineStartsWith(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, 'a', ' ');++ row.setChar(0, TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, 0);+ row.setChar(1, TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_2, 0);+ assertLineStartsWith(TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_1, TWO_JAVA_CHARS_DISPLAY_WIDTH_ONE_2, ' ');+ assertColumnCharIndicesStartsWith(0, 2, 4, 5);+ assertEquals(82, row.getSpaceUsed());+ }++ public void testDoubleWidth() {+ row.setChar(0, 'a', 0);+ row.setChar(1, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, 0);+ assertLineStartsWith('a', ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, ' ');+ assertColumnCharIndicesStartsWith(0, 1, 1, 2);+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertLineStartsWith(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, ' ', ' ');+ assertColumnCharIndicesStartsWith(0, 0, 1, 2);++ row.setChar(0, ' ', 0);+ assertLineStartsWith(' ', ' ', ' ', ' ');+ assertColumnCharIndicesStartsWith(0, 1, 2, 3, 4);+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ row.setChar(2, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, 0);+ assertLineStartsWith(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2);+ assertColumnCharIndicesStartsWith(0, 0, 1, 1, 2);+ row.setChar(0, 'a', 0);+ assertLineStartsWith('a', ' ', ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, ' ');+ }++ /** Just as {@link #testDoubleWidth()} but requires a surrogate pair. */+ public void testDoubleWidthSurrogage() {+ row.setChar(0, 'a', 0);+ assertColumnCharIndicesStartsWith(0, 1, 2, 3, 4);++ row.setChar(1, TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2, 0);+ assertColumnCharIndicesStartsWith(0, 1, 1, 3, 4);+ assertLineStartsWith('a', TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2, ' ');+ row.setChar(0, TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1, 0);+ assertColumnCharIndicesStartsWith(0, 0, 2, 3, 4);+ assertLineStartsWith(TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1, ' ', ' ', ' ');++ row.setChar(0, ' ', 0);+ assertLineStartsWith(' ', ' ', ' ', ' ');+ row.setChar(0, TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_1, 0);+ row.setChar(1, TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2, 0);+ assertLineStartsWith(' ', TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2, ' ');+ row.setChar(0, 'a', 0);+ assertLineStartsWith('a', TWO_JAVA_CHARS_DISPLAY_WIDTH_TWO_2, ' ');+ }++ public void testReplacementChar() {+ row.setChar(0, TerminalEmulator.UNICODE_REPLACEMENT_CHAR, 0);+ row.setChar(1, 'Y', 0);+ assertLineStartsWith(TerminalEmulator.UNICODE_REPLACEMENT_CHAR, 'Y', ' ', ' ');+ }++ public void testSurrogateCharsWithNormalDisplayWidth() {+ // These requires a UTF-16 surrogate pair, and has a display width of one.+ int first = 0x1D306;+ int second = 0x1D307;+ // Assert the above statement:+ assertEquals(2, Character.toChars(first).length);+ assertEquals(2, Character.toChars(second).length);++ row.setChar(0, second, 0);+ assertEquals(second, Character.toCodePoint(row.mText[0], row.mText[1]));+ assertEquals(' ', row.mText[2]);+ assertEquals(2, row.findStartOfColumn(1));++ row.setChar(0, first, 0);+ assertEquals(first, Character.toCodePoint(row.mText[0], row.mText[1]));+ assertEquals(' ', row.mText[2]);+ assertEquals(2, row.findStartOfColumn(1));++ row.setChar(1, second, 0);+ row.setChar(2, 'a', 0);+ assertEquals(first, Character.toCodePoint(row.mText[0], row.mText[1]));+ assertEquals(second, Character.toCodePoint(row.mText[2], row.mText[3]));+ assertEquals('a', row.mText[4]);+ assertEquals(' ', row.mText[5]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(2, row.findStartOfColumn(1));+ assertEquals(4, row.findStartOfColumn(2));+ assertEquals(5, row.findStartOfColumn(3));+ assertEquals(6, row.findStartOfColumn(4));++ row.setChar(0, ' ', 0);+ assertEquals(' ', row.mText[0]);+ assertEquals(second, Character.toCodePoint(row.mText[1], row.mText[2]));+ assertEquals('a', row.mText[3]);+ assertEquals(' ', row.mText[4]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(3, row.findStartOfColumn(2));+ assertEquals(4, row.findStartOfColumn(3));+ assertEquals(5, row.findStartOfColumn(4));++ for (int i = 0; i < 80; i++) {+ row.setChar(i, i % 2 == 0 ? first : second, 0);+ }+ for (int i = 0; i < 80; i++) {+ int idx = row.findStartOfColumn(i);+ assertEquals(i % 2 == 0 ? first : second, Character.toCodePoint(row.mText[idx], row.mText[idx + 1]));+ }+ for (int i = 0; i < 80; i++) {+ row.setChar(i, i % 2 == 0 ? 'a' : 'b', 0);+ }+ for (int i = 0; i < 80; i++) {+ int idx = row.findStartOfColumn(i);+ assertEquals(i, idx);+ assertEquals(i % 2 == 0 ? 'a' : 'b', row.mText[i]);+ }+ }++ public void testOverwritingDoubleDisplayWidthWithNormalDisplayWidth() {+ // Initial "OO "+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(0, row.findStartOfColumn(1));+ assertEquals(1, row.findStartOfColumn(2));++ // Setting first column to a clears second: "a "+ row.setChar(0, 'a', 0);+ assertEquals('a', row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(2, row.findStartOfColumn(2));++ // Back to initial "OO "+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(0, row.findStartOfColumn(1));+ assertEquals(1, row.findStartOfColumn(2));++ // Setting first column to a clears first: " a "+ row.setChar(1, 'a', 0);+ assertEquals(' ', row.mText[0]);+ assertEquals('a', row.mText[1]);+ assertEquals(' ', row.mText[2]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(2, row.findStartOfColumn(2));+ }++ public void testOverwritingDoubleDisplayWidthWithSelf() {+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(0, row.findStartOfColumn(1));+ assertEquals(1, row.findStartOfColumn(2));+ }++ public void testNormalCharsWithDoubleDisplayWidth() {+ // These fit in one java char, and has a display width of two.+ assertTrue(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1 != ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2);+ assertEquals(1, Character.charCount(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1));+ assertEquals(1, Character.charCount(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2));+ assertEquals(2, WcWidth.width(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1));+ assertEquals(2, WcWidth.width(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2));++ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals(0, row.findStartOfColumn(1));+ assertEquals(' ', row.mText[1]);++ row.setChar(0, 'a', 0);+ assertEquals('a', row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals(1, row.findStartOfColumn(1));++ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ // The first character fills both first columns.+ assertEquals(0, row.findStartOfColumn(1));+ row.setChar(2, 'a', 0);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals('a', row.mText[1]);+ assertEquals(1, row.findStartOfColumn(2));++ row.setChar(0, 'c', 0);+ assertEquals('c', row.mText[0]);+ assertEquals(' ', row.mText[1]);+ assertEquals('a', row.mText[2]);+ assertEquals(' ', row.mText[3]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(2, row.findStartOfColumn(2));+ }++ public void testNormalCharsWithDoubleDisplayWidthOverlapping() {+ // These fit in one java char, and has a display width of two.+ row.setChar(0, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, 0);+ row.setChar(2, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, 0);+ row.setChar(4, 'a', 0);+ // O = ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO+ // A = ANOTHER_JAVA_CHAR_DISPLAY_WIDTH_TWO+ // "OOAAa "+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(0, row.findStartOfColumn(1));+ assertEquals(1, row.findStartOfColumn(2));+ assertEquals(1, row.findStartOfColumn(3));+ assertEquals(2, row.findStartOfColumn(4));+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1, row.mText[0]);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, row.mText[1]);+ assertEquals('a', row.mText[2]);+ assertEquals(' ', row.mText[3]);++ row.setChar(1, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, 0);+ // " AA a "+ assertEquals(' ', row.mText[0]);+ assertEquals(ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_2, row.mText[1]);+ assertEquals(' ', row.mText[2]);+ assertEquals('a', row.mText[3]);+ assertEquals(' ', row.mText[4]);+ assertEquals(0, row.findStartOfColumn(0));+ assertEquals(1, row.findStartOfColumn(1));+ assertEquals(1, row.findStartOfColumn(2));+ assertEquals(2, row.findStartOfColumn(3));+ assertEquals(3, row.findStartOfColumn(4));+ }++ // https://github.com/jackpal/Android-Terminal-Emulator/issues/145+ public void testCrashATE145() {+ // 0xC2541 is unassigned, use display width 1 for UNICODE_REPLACEMENT_CHAR.+ // assertEquals(1, WcWidth.width(0xC2541));+ assertEquals(2, Character.charCount(0xC2541));++ assertEquals(2, WcWidth.width(0x73EE));+ assertEquals(1, Character.charCount(0x73EE));++ assertEquals(0, WcWidth.width(0x009F));+ assertEquals(1, Character.charCount(0x009F));++ int[] points = new int[]{0xC2541, 'a', '8', 0x73EE, 0x009F, 0x881F, 0x8324, 0xD4C9, 0xFFFD, 'B', 0x009B, 0x61C9, 'Z'};+ // int[] expected = new int[] { TerminalEmulator.UNICODE_REPLACEMENT_CHAR, 'a', '8', 0x73EE, 0x009F, 0x881F, 0x8324, 0xD4C9, 0xFFFD,+ // 'B', 0x009B, 0x61C9, 'Z' };+ int currentColumn = 0;+ for (int point : points) {+ row.setChar(currentColumn, point, 0);+ currentColumn += WcWidth.width(point);+ }+ // assertLineStartsWith(points);+ // assertEquals(Character.highSurrogate(0xC2541), line.mText[0]);+ // assertEquals(Character.lowSurrogate(0xC2541), line.mText[1]);+ // assertEquals('a', line.mText[2]);+ // assertEquals('8', line.mText[3]);+ // assertEquals(Character.highSurrogate(0x73EE), line.mText[4]);+ // assertEquals(Character.lowSurrogate(0x73EE), line.mText[5]);+ //+ // char[] chars = line.mText;+ // int charIndex = 0;+ // for (int i = 0; i < points.length; i++) {+ // char c = chars[charIndex];+ // charIndex++;+ // int thisPoint = (int) c;+ // if (Character.isHighSurrogate(c)) {+ // thisPoint = Character.toCodePoint(c, chars[charIndex]);+ // charIndex++;+ // }+ // assertEquals("At index=" + i + ", charIndex=" + charIndex + ", char=" + (char) thisPoint, points[i], thisPoint);+ // }+ }++ public void testNormalization() {+ // int lowerCaseN = 0x006E;+ // int combiningTilde = 0x0303;+ // int combined = 0x00F1;+ row.setChar(0, 0x006E, 0);+ assertEquals(80, row.getSpaceUsed());+ row.setChar(0, 0x0303, 0);+ assertEquals(81, row.getSpaceUsed());+ // assertEquals("\u00F1 ", new String(term.getScreen().getLine(0)));+ assertLineStartsWith(0x006E, 0x0303, ' ');+ }++ public void testInsertWideAtLastColumn() {+ row.setChar(COLUMNS - 2, 'Z', 0);+ row.setChar(COLUMNS - 1, 'a', 0);+ assertEquals('Z', row.mText[row.findStartOfColumn(COLUMNS - 2)]);+ assertEquals('a', row.mText[row.findStartOfColumn(COLUMNS - 1)]);+ row.setChar(COLUMNS - 1, 'ö', 0);+ assertEquals('Z', row.mText[row.findStartOfColumn(COLUMNS - 2)]);+ assertEquals('ö', row.mText[row.findStartOfColumn(COLUMNS - 1)]);+ // line.setChar(COLUMNS - 1, ONE_JAVA_CHAR_DISPLAY_WIDTH_TWO_1);+ // assertEquals('Z', line.mText[line.findStartOfColumn(COLUMNS - 2)]);+ // assertEquals(' ', line.mText[line.findStartOfColumn(COLUMNS - 1)]);+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/TerminalTest.java b/terminal-emulator/src/test/java/com/termux/terminal/TerminalTest.javanew file mode 100644index 0000000..3e1f824--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/TerminalTest.java@@ -0,0 +1,350 @@+package com.termux.terminal;++import java.io.UnsupportedEncodingException;++public class TerminalTest extends TerminalTestCase {++ public void testCursorPositioning() throws Exception {+ withTerminalSized(10, 10).placeCursorAndAssert(1, 2).placeCursorAndAssert(3, 5).placeCursorAndAssert(2, 2).enterString("A")+ .assertCursorAt(2, 3);+ }++ public void testScreen() throws UnsupportedEncodingException {+ withTerminalSized(3, 3);+ assertLinesAre(" ", " ", " ");++ assertEquals("", mTerminal.getScreen().getTranscriptText());+ enterString("hi").assertLinesAre("hi ", " ", " ");+ assertEquals("hi", mTerminal.getScreen().getTranscriptText());+ enterString("\r\nu");+ assertEquals("hi\nu", mTerminal.getScreen().getTranscriptText());+ mTerminal.reset();+ assertEquals("hi\nu", mTerminal.getScreen().getTranscriptText());++ withTerminalSized(3, 3).enterString("hello");+ assertEquals("hello", mTerminal.getScreen().getTranscriptText());+ enterString("\r\nworld");+ assertEquals("hello\nworld", mTerminal.getScreen().getTranscriptText());+ }++ public void testScrollDownInAltBuffer() {+ withTerminalSized(3, 3).enterString("\033[?1049h");+ enterString("\033[38;5;111m1\r\n");+ enterString("\033[38;5;112m2\r\n");+ enterString("\033[38;5;113m3\r\n");+ enterString("\033[38;5;114m4\r\n");+ enterString("\033[38;5;115m5");+ assertLinesAre("3 ", "4 ", "5 ");+ assertForegroundColorAt(0, 0, 113);+ assertForegroundColorAt(1, 0, 114);+ assertForegroundColorAt(2, 0, 115);+ }++ public void testMouseClick() throws Exception {+ withTerminalSized(10, 10);+ assertFalse(mTerminal.isMouseTrackingActive());+ enterString("\033[?1000h");+ assertTrue(mTerminal.isMouseTrackingActive());+ enterString("\033[?1000l");+ assertFalse(mTerminal.isMouseTrackingActive());+ enterString("\033[?1000h");+ assertTrue(mTerminal.isMouseTrackingActive());++ enterString("\033[?1006h");+ mTerminal.sendMouseEvent(TerminalEmulator.MOUSE_LEFT_BUTTON, 3, 4, true);+ assertEquals("\033[<0;3;4M", mOutput.getOutputAndClear());+ mTerminal.sendMouseEvent(TerminalEmulator.MOUSE_LEFT_BUTTON, 3, 4, false);+ assertEquals("\033[<0;3;4m", mOutput.getOutputAndClear());++ // When the client says that a click is outside (which could happen when pixels are outside+ // the terminal area, see https://github.com/termux/termux-app/issues/501) the terminal+ // sends a click at the edge.+ mTerminal.sendMouseEvent(TerminalEmulator.MOUSE_LEFT_BUTTON, 0, 0, true);+ assertEquals("\033[<0;1;1M", mOutput.getOutputAndClear());+ mTerminal.sendMouseEvent(TerminalEmulator.MOUSE_LEFT_BUTTON, 11, 11, false);+ assertEquals("\033[<0;10;10m", mOutput.getOutputAndClear());+ }++ public void testNormalization() throws UnsupportedEncodingException {+ // int lowerCaseN = 0x006E;+ // int combiningTilde = 0x0303;+ // int combined = 0x00F1;+ withTerminalSized(3, 3).assertLinesAre(" ", " ", " ");+ enterString("\u006E\u0303");+ assertEquals(1, WcWidth.width("\u006E\u0303".toCharArray(), 0));+ // assertEquals("\u00F1 ", new String(mTerminal.getScreen().getLine(0)));+ assertLinesAre("\u006E\u0303 ", " ", " ");+ }++ /** On "\e[18t" xterm replies with "\e[8;${HEIGHT};${WIDTH}t" */+ public void testReportTerminalSize() throws Exception {+ withTerminalSized(5, 5);+ assertEnteringStringGivesResponse("\033[18t", "\033[8;5;5t");+ for (int width = 3; width < 12; width++) {+ for (int height = 3; height < 12; height++) {+ resize(width, height);+ assertEnteringStringGivesResponse("\033[18t", "\033[8;" + height + ";" + width + "t");+ }+ }+ }++ /** Device Status Report (DSR) and Report Cursor Position (CPR). */+ public void testDeviceStatusReport() throws Exception {+ withTerminalSized(5, 5);+ assertEnteringStringGivesResponse("\033[5n", "\033[0n");++ assertEnteringStringGivesResponse("\033[6n", "\033[1;1R");+ enterString("AB");+ assertEnteringStringGivesResponse("\033[6n", "\033[1;3R");+ enterString("\r\n");+ assertEnteringStringGivesResponse("\033[6n", "\033[2;1R");+ }++ /** Test the cursor shape changes using DECSCUSR. */+ public void testSetCursorStyle() throws Exception {+ withTerminalSized(5, 5);+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK, mTerminal.getCursorStyle());+ enterString("\033[3 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_UNDERLINE, mTerminal.getCursorStyle());+ enterString("\033[5 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BAR, mTerminal.getCursorStyle());+ enterString("\033[0 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK, mTerminal.getCursorStyle());+ enterString("\033[6 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BAR, mTerminal.getCursorStyle());+ enterString("\033[4 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_UNDERLINE, mTerminal.getCursorStyle());+ enterString("\033[1 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK, mTerminal.getCursorStyle());+ enterString("\033[4 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_UNDERLINE, mTerminal.getCursorStyle());+ enterString("\033[2 q");+ assertEquals(TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK, mTerminal.getCursorStyle());+ }++ public void testPaste() {+ withTerminalSized(5, 5);+ mTerminal.paste("hi");+ assertEquals("hi", mOutput.getOutputAndClear());++ enterString("\033[?2004h");+ mTerminal.paste("hi");+ assertEquals("\033[200~" + "hi" + "\033[201~", mOutput.getOutputAndClear());++ enterString("\033[?2004l");+ mTerminal.paste("hi");+ assertEquals("hi", mOutput.getOutputAndClear());+ }++ public void testSelectGraphics() {+ selectGraphicsTestRun(';');+ selectGraphicsTestRun(':');+ }++ public void selectGraphicsTestRun(char separator) {+ withTerminalSized(5, 5);+ enterString("\033[31m");+ assertEquals(mTerminal.mForeColor, 1);+ enterString("\033[32m");+ assertEquals(mTerminal.mForeColor, 2);+ enterString("\033[43m");+ assertEquals(2, mTerminal.mForeColor);+ assertEquals(3, mTerminal.mBackColor);++ // SGR 0 should reset both foreground and background color.+ enterString("\033[0m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);++ // Test CSI resetting to default if sequence starts with ; or has sequential ;;+ // Check TerminalEmulator.parseArg()+ enterString("\033[31m\033[m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31m\033[;m".replace(';', separator));+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31m\033[0m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31m\033[0;m".replace(';', separator));+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31;;m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31::m");+ assertEquals(1, mTerminal.mForeColor);+ enterString("\033[31;m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ enterString("\033[31:m");+ assertEquals(1, mTerminal.mForeColor);+ enterString("\033[31;;41m");+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ assertEquals(1, mTerminal.mBackColor);+ enterString("\033[0m");+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);++ // 256 colors:+ enterString("\033[38;5;119m".replace(';', separator));+ assertEquals(119, mTerminal.mForeColor);+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);+ enterString("\033[48;5;129m".replace(';', separator));+ assertEquals(119, mTerminal.mForeColor);+ assertEquals(129, mTerminal.mBackColor);++ // Invalid parameter:+ enterString("\033[48;8;129m".replace(';', separator));+ assertEquals(119, mTerminal.mForeColor);+ assertEquals(129, mTerminal.mBackColor);++ // Multiple parameters at once:+ enterString("\033[38;5;178".replace(';', separator) + ";" + "48;5;179m".replace(';', separator));+ assertEquals(178, mTerminal.mForeColor);+ assertEquals(179, mTerminal.mBackColor);++ // Omitted parameter means zero:+ enterString("\033[38;5;m".replace(';', separator));+ assertEquals(0, mTerminal.mForeColor);+ assertEquals(179, mTerminal.mBackColor);+ enterString("\033[48;5;m".replace(';', separator));+ assertEquals(0, mTerminal.mForeColor);+ assertEquals(0, mTerminal.mBackColor);++ // 24 bit colors:+ enterString(("\033[0m")); // Reset fg and bg colors.+ enterString("\033[38;2;255;127;2m".replace(';', separator));+ int expectedForeground = 0xff000000 | (255 << 16) | (127 << 8) | 2;+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);+ enterString("\033[48;2;1;2;254m".replace(';', separator));+ int expectedBackground = 0xff000000 | (1 << 16) | (2 << 8) | 254;+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(expectedBackground, mTerminal.mBackColor);++ // 24 bit colors, set fg and bg at once:+ enterString(("\033[0m")); // Reset fg and bg colors.+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, mTerminal.mForeColor);+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);+ enterString("\033[38;2;255;127;2".replace(';', separator) + ";" + "48;2;1;2;254m".replace(';', separator));+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(expectedBackground, mTerminal.mBackColor);++ // 24 bit colors, invalid input:+ enterString("\033[38;2;300;127;2;48;2;1;300;254m".replace(';', separator));+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(expectedBackground, mTerminal.mBackColor);++ // 24 bit colors, omitted parameter means zero:+ enterString("\033[38;2;255;127;m".replace(';', separator));+ expectedForeground = 0xff000000 | (255 << 16) | (127 << 8);+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(expectedBackground, mTerminal.mBackColor);+ enterString("\033[38;2;123;;77m".replace(';', separator));+ expectedForeground = 0xff000000 | (123 << 16) | 77;+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(expectedBackground, mTerminal.mBackColor);++ // 24 bit colors, extra sub-parameters are skipped:+ expectedForeground = 0xff000000 | (255 << 16) | (127 << 8) | 2;+ enterString("\033[0;38:2:255:127:2:48:2:1:2:254m");+ assertEquals(expectedForeground, mTerminal.mForeColor);+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, mTerminal.mBackColor);+ }++ public void testBackgroundColorErase() {+ final int rows = 3;+ final int cols = 3;+ withTerminalSized(cols, rows);+ for (int r = 0; r < rows; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals(TextStyle.COLOR_INDEX_FOREGROUND, TextStyle.decodeForeColor(style));+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, TextStyle.decodeBackColor(style));+ }+ }+ // Foreground color to 119:+ enterString("\033[38;5;119m");+ // Background color to 129:+ enterString("\033[48;5;129m");+ // Clear with ED, Erase in Display:+ enterString("\033[2J");+ for (int r = 0; r < rows; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals(119, TextStyle.decodeForeColor(style));+ assertEquals(129, TextStyle.decodeBackColor(style));+ }+ }+ // Background color to 139:+ enterString("\033[48;5;139m");+ // Insert two blank lines.+ enterString("\033[2L");+ for (int r = 0; r < rows; r++) {+ for (int c = 0; c < cols; c++) {+ long style = getStyleAt(r, c);+ assertEquals((r == 0 || r == 1) ? 139 : 129, TextStyle.decodeBackColor(style));+ }+ }++ withTerminalSized(cols, rows);+ // Background color to 129:+ enterString("\033[48;5;129m");+ // Erase two characters, filling them with background color:+ enterString("\033[2X");+ assertEquals(129, TextStyle.decodeBackColor(getStyleAt(0, 0)));+ assertEquals(129, TextStyle.decodeBackColor(getStyleAt(0, 1)));+ assertEquals(TextStyle.COLOR_INDEX_BACKGROUND, TextStyle.decodeBackColor(getStyleAt(0, 2)));+ }++ public void testParseColor() {+ assertEquals(0xFF0000FA, TerminalColors.parse("#0000FA"));+ assertEquals(0xFF000000, TerminalColors.parse("#000000"));+ assertEquals(0xFF000000, TerminalColors.parse("#000"));+ assertEquals(0xFF000000, TerminalColors.parse("#000000000"));+ assertEquals(0xFF53186f, TerminalColors.parse("#53186f"));++ assertEquals(0xFFFF00FF, TerminalColors.parse("rgb:F/0/F"));+ assertEquals(0xFF0000FA, TerminalColors.parse("rgb:00/00/FA"));+ assertEquals(0xFF53186f, TerminalColors.parse("rgb:53/18/6f"));++ assertEquals(0, TerminalColors.parse("invalid_0000FA"));+ assertEquals(0, TerminalColors.parse("#3456"));+ }++ /** The ncurses library still uses this. */+ public void testLineDrawing() {+ // 016 - shift out / G1. 017 - shift in / G0. "ESC ) 0" - use line drawing for G1+ withTerminalSized(4, 2).enterString("q\033)0q\016q\017q").assertLinesAre("qq─q", " ");+ // "\0337", saving cursor should save G0, G1 and invoked charset and "ESC 8" should restore.+ withTerminalSized(4, 2).enterString("\033)0\016qqq\0337\017\0338q").assertLinesAre("────", " ");+ }++ public void testSoftTerminalReset() {+ // See http://vt100.net/docs/vt510-rm/DECSTR and https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=650304+ // "\033[?7l" is DECRST to disable wrap-around, and DECSTR ("\033[!p") should reset it.+ withTerminalSized(3, 3).enterString("\033[?7lABCD").assertLinesAre("ABD", " ", " ");+ enterString("\033[!pEF").assertLinesAre("ABE", "F ", " ");+ }++ public void testBel() {+ withTerminalSized(3, 3);+ assertEquals(0, mOutput.bellsRung);+ enterString("\07");+ assertEquals(1, mOutput.bellsRung);+ enterString("hello\07");+ assertEquals(2, mOutput.bellsRung);+ enterString("\07hello");+ assertEquals(3, mOutput.bellsRung);+ enterString("hello\07world");+ assertEquals(4, mOutput.bellsRung);+ }++ public void testAutomargins() throws UnsupportedEncodingException {+ withTerminalSized(3, 3).enterString("abc").assertLinesAre("abc", " ", " ").assertCursorAt(0, 2);+ enterString("d").assertLinesAre("abc", "d ", " ").assertCursorAt(1, 1);++ withTerminalSized(3, 3).enterString("abc\r ").assertLinesAre(" bc", " ", " ").assertCursorAt(0, 1);+ }++ public void testTab() {+ withTerminalSized(11, 2).enterString("01234567890\r\tXX").assertLinesAre("01234567XX0", " ");+ withTerminalSized(11, 2).enterString("01234567890\033[44m\r\tXX").assertLinesAre("01234567XX0", " ");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/TerminalTestCase.java b/terminal-emulator/src/test/java/com/termux/terminal/TerminalTestCase.javanew file mode 100644index 0000000..4490207--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/TerminalTestCase.java@@ -0,0 +1,319 @@+package com.termux.terminal;++import junit.framework.AssertionFailedError;+import junit.framework.TestCase;++import java.io.ByteArrayOutputStream;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.HashSet;+import java.util.List;+import java.util.Objects;+import java.util.Set;++public abstract class TerminalTestCase extends TestCase {++ public static final int INITIAL_CELL_WIDTH_PIXELS = 13;+ public static final int INITIAL_CELL_HEIGHT_PIXELS = 15;++ public static class MockTerminalOutput extends TerminalOutput {+ final ByteArrayOutputStream baos = new ByteArrayOutputStream();+ public final List<ChangedTitle> titleChanges = new ArrayList<>();+ public final List<String> clipboardPuts = new ArrayList<>();+ public int bellsRung = 0;+ public int colorsChanged = 0;++ @Override+ public void write(byte[] data, int offset, int count) {+ baos.write(data, offset, count);+ }++ public String getOutputAndClear() {+ String result = new String(baos.toByteArray(), StandardCharsets.UTF_8);+ baos.reset();+ return result;+ }++ @Override+ public void titleChanged(String oldTitle, String newTitle) {+ titleChanges.add(new ChangedTitle(oldTitle, newTitle));+ }++ @Override+ public void onCopyTextToClipboard(String text) {+ clipboardPuts.add(text);+ }++ @Override+ public void onPasteTextFromClipboard() {+ }++ @Override+ public void onBell() {+ bellsRung++;+ }++ @Override+ public void onColorsChanged() {+ colorsChanged++;+ }+ }++ public TerminalEmulator mTerminal;+ public MockTerminalOutput mOutput;++ public static final class ChangedTitle {+ final String oldTitle;+ final String newTitle;++ public ChangedTitle(String oldTitle, String newTitle) {+ this.oldTitle = oldTitle;+ this.newTitle = newTitle;+ }++ @Override+ public boolean equals(Object o) {+ if (!(o instanceof ChangedTitle)) return false;+ ChangedTitle other = (ChangedTitle) o;+ return Objects.equals(oldTitle, other.oldTitle) && Objects.equals(newTitle, other.newTitle);+ }++ @Override+ public int hashCode() {+ return Objects.hash(oldTitle, newTitle);+ }++ @Override+ public String toString() {+ return "ChangedTitle[oldTitle=" + oldTitle + ", newTitle=" + newTitle + "]";+ }++ }++ public TerminalTestCase enterString(String s) {+ byte[] bytes = s.getBytes(StandardCharsets.UTF_8);+ mTerminal.append(bytes, bytes.length);+ assertInvariants();+ return this;+ }++ public void assertEnteringStringGivesResponse(String input, String expectedResponse) {+ enterString(input);+ String response = mOutput.getOutputAndClear();+ assertEquals(expectedResponse, response);+ }++ @Override+ protected void setUp() throws Exception {+ super.setUp();+ mOutput = new MockTerminalOutput();+ }++ protected TerminalTestCase withTerminalSized(int columns, int rows) {+ // The tests aren't currently using the client, so a null client will suffice, a dummy client should be implemented if needed+ mTerminal = new TerminalEmulator(mOutput, columns, rows, INITIAL_CELL_WIDTH_PIXELS, INITIAL_CELL_HEIGHT_PIXELS, rows * 2, null);+ return this;+ }++ public void assertHistoryStartsWith(String... rows) {+ assertTrue("About to check " + rows.length + " lines, but only " + mTerminal.getScreen().getActiveTranscriptRows() + " in history",+ mTerminal.getScreen().getActiveTranscriptRows() >= rows.length);+ for (int i = 0; i < rows.length; i++) {+ assertLineIs(-i - 1, rows[i]);+ }+ }++ private static final class LineWrapper {+ final TerminalRow mLine;++ public LineWrapper(TerminalRow line) {+ mLine = line;+ }++ @Override+ public int hashCode() {+ return System.identityHashCode(mLine);+ }++ @Override+ public boolean equals(Object o) {+ return o instanceof LineWrapper && ((LineWrapper) o).mLine == mLine;+ }+ }++ protected TerminalTestCase assertInvariants() {+ TerminalBuffer screen = mTerminal.getScreen();+ TerminalRow[] lines = screen.mLines;++ Set<LineWrapper> linesSet = new HashSet<>();+ for (int i = 0; i < lines.length; i++) {+ if (lines[i] == null) continue;+ assertTrue("Line exists at multiple places: " + i, linesSet.add(new LineWrapper(lines[i])));+ char[] text = lines[i].mText;+ int usedChars = lines[i].getSpaceUsed();+ int currentColumn = 0;+ for (int j = 0; j < usedChars; j++) {+ char c = text[j];+ int codePoint;+ if (Character.isHighSurrogate(c)) {+ char lowSurrogate = text[++j];+ assertTrue("High surrogate without following low surrogate", Character.isLowSurrogate(lowSurrogate));+ codePoint = Character.toCodePoint(c, lowSurrogate);+ } else {+ assertFalse("Low surrogate without preceding high surrogate", Character.isLowSurrogate(c));+ codePoint = c;+ }+ assertFalse("Screen should never contain unassigned characters", Character.getType(codePoint) == Character.UNASSIGNED);+ int width = WcWidth.width(codePoint);+ assertFalse("The first column should not start with combining character", currentColumn == 0 && width < 0);+ if (width > 0) currentColumn += width;+ }+ assertEquals("Line whose width does not match screens. line=" + new String(lines[i].mText, 0, lines[i].getSpaceUsed()),+ screen.mColumns, currentColumn);+ }++ assertEquals("The alt buffer should have have no history", mTerminal.mAltBuffer.mTotalRows, mTerminal.mAltBuffer.mScreenRows);+ if (mTerminal.isAlternateBufferActive()) {+ assertEquals("The alt buffer should be the same size as the screen", mTerminal.mRows, mTerminal.mAltBuffer.mTotalRows);+ }++ return this;+ }++ protected void assertLineIs(int line, String expected) {+ TerminalRow l = mTerminal.getScreen().allocateFullLineIfNecessary(mTerminal.getScreen().externalToInternalRow(line));+ char[] chars = l.mText;+ int textLen = l.getSpaceUsed();+ if (textLen != expected.length()) fail("Expected '" + expected + "' (len=" + expected.length() + "), was='"+ + new String(chars, 0, textLen) + "' (len=" + textLen + ")");+ for (int i = 0; i < textLen; i++) {+ if (expected.charAt(i) != chars[i])+ fail("Expected '" + expected + "', was='" + new String(chars, 0, textLen) + "' - first different at index=" + i);+ }+ }++ public TerminalTestCase assertLinesAre(String... lines) {+ assertEquals(lines.length, mTerminal.getScreen().mScreenRows);+ for (int i = 0; i < lines.length; i++)+ try {+ assertLineIs(i, lines[i]);+ } catch (AssertionFailedError e) {+ throw new AssertionFailedError("Line: " + i + " - " + e.getMessage());+ }+ return this;+ }++ public TerminalTestCase resize(int cols, int rows) {+ mTerminal.resize(cols, rows, INITIAL_CELL_WIDTH_PIXELS, INITIAL_CELL_HEIGHT_PIXELS);+ assertInvariants();+ return this;+ }++ public TerminalTestCase assertLineWraps(boolean... lines) {+ for (int i = 0; i < lines.length; i++)+ assertEquals("line=" + i, lines[i], mTerminal.getScreen().mLines[mTerminal.getScreen().externalToInternalRow(i)].mLineWrap);+ return this;+ }++ protected TerminalTestCase assertLineStartsWith(int line, int... codePoints) {+ char[] chars = mTerminal.getScreen().mLines[mTerminal.getScreen().externalToInternalRow(line)].mText;+ int charIndex = 0;+ for (int i = 0; i < codePoints.length; i++) {+ int lineCodePoint = chars[charIndex++];+ if (Character.isHighSurrogate((char) lineCodePoint)) {+ lineCodePoint = Character.toCodePoint((char) lineCodePoint, chars[charIndex++]);+ }+ assertEquals("Differing a code point index=" + i, codePoints[i], lineCodePoint);+ }+ return this;+ }++ protected TerminalTestCase placeCursorAndAssert(int row, int col) {+ // +1 due to escape sequence being one based.+ enterString("\033[" + (row + 1) + ";" + (col + 1) + "H");+ assertCursorAt(row, col);+ return this;+ }++ public TerminalTestCase assertCursorAt(int row, int col) {+ int actualRow = mTerminal.getCursorRow();+ int actualCol = mTerminal.getCursorCol();+ if (!(row == actualRow && col == actualCol))+ fail("Expected cursor at (row,col)=(" + row + ", " + col + ") but was (" + actualRow + ", " + actualCol + ")");+ return this;+ }++ /** For testing only. Encoded style according to {@link TextStyle}. */+ public long getStyleAt(int externalRow, int column) {+ return mTerminal.getScreen().getStyleAt(externalRow, column);+ }++ public static class EffectLine {+ final int[] styles;++ public EffectLine(int[] styles) {+ this.styles = styles;+ }+ }++ protected EffectLine effectLine(int... bits) {+ return new EffectLine(bits);+ }++ public TerminalTestCase assertEffectAttributesSet(EffectLine... lines) {+ assertEquals(lines.length, mTerminal.getScreen().mScreenRows);+ for (int i = 0; i < lines.length; i++) {+ int[] line = lines[i].styles;+ for (int j = 0; j < line.length; j++) {+ int effectsAtCell = TextStyle.decodeEffect(getStyleAt(i, j));+ int attributes = line[j];+ if ((effectsAtCell & attributes) != attributes) fail("Line=" + i + ", column=" + j + ", expected "+ + describeStyle(attributes) + " set, was " + describeStyle(effectsAtCell));+ }+ }+ return this;+ }++ public TerminalTestCase assertForegroundIndices(EffectLine... lines) {+ assertEquals(lines.length, mTerminal.getScreen().mScreenRows);+ for (int i = 0; i < lines.length; i++) {+ int[] line = lines[i].styles;+ for (int j = 0; j < line.length; j++) {+ int actualColor = TextStyle.decodeForeColor(getStyleAt(i, j));+ int expectedColor = line[j];+ if (actualColor != expectedColor) fail("Line=" + i + ", column=" + j + ", expected color "+ + Integer.toHexString(expectedColor) + " set, was " + Integer.toHexString(actualColor));+ }+ }+ return this;+ }++ private static String describeStyle(int styleBits) {+ return "'" + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_BLINK) != 0 ? ":BLINK:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_BOLD) != 0 ? ":BOLD:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_INVERSE) != 0 ? ":INVERSE:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) != 0 ? ":INVISIBLE:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0 ? ":ITALIC:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) != 0 ? ":PROTECTED:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0 ? ":STRIKETHROUGH:" : "")+ + ((styleBits & TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0 ? ":UNDERLINE:" : "") + "'";+ }++ public void assertForegroundColorAt(int externalRow, int column, int color) {+ long style = mTerminal.getScreen().mLines[mTerminal.getScreen().externalToInternalRow(externalRow)].getStyle(column);+ assertEquals(color, TextStyle.decodeForeColor(style));+ }++ public void assertBackgroundColorAt(int externalRow, int column, int color) {+ long style = mTerminal.getScreen().mLines[mTerminal.getScreen().externalToInternalRow(externalRow)].getStyle(column);+ assertEquals(color, TextStyle.decodeBackColor(style));+ }++ public TerminalTestCase assertColor(int colorIndex, int expected) {+ int actual = mTerminal.mColors.mCurrentColors[colorIndex];+ if (expected != actual) {+ fail("Color index=" + colorIndex + ", expected=" + Integer.toHexString(expected) + ", was=" + Integer.toHexString(actual));+ }+ return this;+ }+}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/TextStyleTest.java b/terminal-emulator/src/test/java/com/termux/terminal/TextStyleTest.javanew file mode 100644index 0000000..6ec7a34--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/TextStyleTest.java@@ -0,0 +1,65 @@+package com.termux.terminal;++import junit.framework.TestCase;++public class TextStyleTest extends TestCase {++ private static final int[] ALL_EFFECTS = new int[]{0, TextStyle.CHARACTER_ATTRIBUTE_BOLD, TextStyle.CHARACTER_ATTRIBUTE_ITALIC,+ TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE, TextStyle.CHARACTER_ATTRIBUTE_BLINK, TextStyle.CHARACTER_ATTRIBUTE_INVERSE,+ TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE, TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH, TextStyle.CHARACTER_ATTRIBUTE_PROTECTED,+ TextStyle.CHARACTER_ATTRIBUTE_DIM};++ public void testEncodingSingle() {+ for (int fx : ALL_EFFECTS) {+ for (int fg = 0; fg < TextStyle.NUM_INDEXED_COLORS; fg++) {+ for (int bg = 0; bg < TextStyle.NUM_INDEXED_COLORS; bg++) {+ long encoded = TextStyle.encode(fg, bg, fx);+ assertEquals(fg, TextStyle.decodeForeColor(encoded));+ assertEquals(bg, TextStyle.decodeBackColor(encoded));+ assertEquals(fx, TextStyle.decodeEffect(encoded));+ }+ }+ }+ }++ public void testEncoding24Bit() {+ int[] values = {255, 240, 127, 1, 0};+ for (int red : values) {+ for (int green : values) {+ for (int blue : values) {+ int argb = 0xFF000000 | (red << 16) | (green << 8) | blue;+ long encoded = TextStyle.encode(argb, 0, 0);+ assertEquals(argb, TextStyle.decodeForeColor(encoded));+ encoded = TextStyle.encode(0, argb, 0);+ assertEquals(argb, TextStyle.decodeBackColor(encoded));+ }+ }+ }+ }+++ public void testEncodingCombinations() {+ for (int f1 : ALL_EFFECTS) {+ for (int f2 : ALL_EFFECTS) {+ int combined = f1 | f2;+ assertEquals(combined, TextStyle.decodeEffect(TextStyle.encode(0, 0, combined)));+ }+ }+ }++ public void testEncodingStrikeThrough() {+ long encoded = TextStyle.encode(TextStyle.COLOR_INDEX_FOREGROUND, TextStyle.COLOR_INDEX_BACKGROUND,+ TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH);+ assertTrue((TextStyle.decodeEffect(encoded) & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0);+ }++ public void testEncodingProtected() {+ long encoded = TextStyle.encode(TextStyle.COLOR_INDEX_FOREGROUND, TextStyle.COLOR_INDEX_BACKGROUND,+ TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH);+ assertEquals(0, (TextStyle.decodeEffect(encoded) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED));+ encoded = TextStyle.encode(TextStyle.COLOR_INDEX_FOREGROUND, TextStyle.COLOR_INDEX_BACKGROUND,+ TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH | TextStyle.CHARACTER_ATTRIBUTE_PROTECTED);+ assertTrue((TextStyle.decodeEffect(encoded) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) != 0);+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/UnicodeInputTest.java b/terminal-emulator/src/test/java/com/termux/terminal/UnicodeInputTest.javanew file mode 100644index 0000000..2733190--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/UnicodeInputTest.java@@ -0,0 +1,136 @@+package com.termux.terminal;++import java.io.UnsupportedEncodingException;++public class UnicodeInputTest extends TerminalTestCase {++ public void testIllFormedUtf8SuccessorByteNotConsumed() throws Exception {+ // The Unicode Standard Version 6.2 – Core Specification (http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf):+ // "If the converter encounters an ill-formed UTF-8 code unit sequence which starts with a valid first byte, but which does not+ // continue with valid successor bytes (see Table 3-7), it must not consume the successor bytes as part of the ill-formed+ // subsequence whenever those successor bytes themselves constitute part of a well-formed UTF-8 code unit subsequence."+ withTerminalSized(5, 5);+ mTerminal.append(new byte[]{(byte) 0b11101111, (byte) 'a'}, 2);+ assertLineIs(0, ((char) TerminalEmulator.UNICODE_REPLACEMENT_CHAR) + "a ");++ // https://code.google.com/p/chromium/issues/detail?id=212704+ byte[] input = new byte[]{+ (byte) 0x61, (byte) 0xF1,+ (byte) 0x80, (byte) 0x80,+ (byte) 0xe1, (byte) 0x80,+ (byte) 0xc2, (byte) 0x62,+ (byte) 0x80, (byte) 0x63,+ (byte) 0x80, (byte) 0xbf,+ (byte) 0x64+ };+ withTerminalSized(10, 2);+ mTerminal.append(input, input.length);+ assertLinesAre("a\uFFFD\uFFFD\uFFFDb\uFFFDc\uFFFD\uFFFDd", " ");++ // Surrogate pairs.+ withTerminalSized(5, 2);+ input = new byte[]{+ (byte) 0xed, (byte) 0xa0,+ (byte) 0x80, (byte) 0xed,+ (byte) 0xad, (byte) 0xbf,+ (byte) 0xed, (byte) 0xae,+ (byte) 0x80, (byte) 0xed,+ (byte) 0xbf, (byte) 0xbf+ };+ mTerminal.append(input, input.length);+ assertLinesAre("\uFFFD\uFFFD\uFFFD\uFFFD ", " ");++ // https://bugzilla.mozilla.org/show_bug.cgi?id=746900: "with this patch 0xe0 0x80 is decoded as two U+FFFDs,+ // but 0xe0 0xa0 is decoded as a single U+FFFD, and this is correct according to the "Best Practices", but IE+ // and Chrome (Version 22.0.1229.94) decode both of them as two U+FFFDs. Opera 12.11 decodes both of them as+ // one U+FFFD".+ withTerminalSized(5, 2);+ input = new byte[]{(byte) 0xe0, (byte) 0xa0, ' '};+ mTerminal.append(input, input.length);+ assertLinesAre("\uFFFD ", " ");++ // withTerminalSized(5, 2);+ // input = new byte[]{(byte) 0xe0, (byte) 0x80, 'a'};+ // mTerminal.append(input, input.length);+ // assertLinesAre("\uFFFD\uFFFDa ", " ");+ }++ public void testUnassignedCodePoint() throws UnsupportedEncodingException {+ withTerminalSized(3, 3);+ // UTF-8 for U+C2541, an unassigned code point:+ byte[] b = new byte[]{(byte) 0xf3, (byte) 0x82, (byte) 0x95, (byte) 0x81};+ mTerminal.append(b, b.length);+ enterString("Y");+ assertEquals(1, Character.charCount(TerminalEmulator.UNICODE_REPLACEMENT_CHAR));+ assertLineStartsWith(0, TerminalEmulator.UNICODE_REPLACEMENT_CHAR, (int) 'Y', ' ');+ }++ public void testStuff() {+ withTerminalSized(80, 24);+ byte[] b = new byte[]{(byte) 0xf3, (byte) 0x82, (byte) 0x95, (byte) 0x81, (byte) 0x61, (byte) 0x38, (byte) 0xe7, (byte) 0x8f,+ (byte) 0xae, (byte) 0xc2, (byte) 0x9f, (byte) 0xe8, (byte) 0xa0, (byte) 0x9f, (byte) 0xe8, (byte) 0x8c, (byte) 0xa4,+ (byte) 0xed, (byte) 0x93, (byte) 0x89, (byte) 0xef, (byte) 0xbf, (byte) 0xbd, (byte) 0x42, (byte) 0xc2, (byte) 0x9b,+ (byte) 0xe6, (byte) 0x87, (byte) 0x89, (byte) 0x5a};+ mTerminal.append(b, b.length);+ }++ public void testSimpleCombining() throws Exception {+ withTerminalSized(3, 2).enterString(" a\u0302 ").assertLinesAre(" a\u0302 ", " ");+ }++ public void testCombiningCharacterInFirstColumn() throws Exception {+ withTerminalSized(5, 3).enterString("test\r\nhi\r\n").assertLinesAre("test ", "hi ", " ");++ // U+0302 is COMBINING CIRCUMFLEX ACCENT. Test case from mosh (http://mosh.mit.edu/).+ withTerminalSized(5, 5).enterString("test\r\nabc\r\n\u0302\r\ndef\r\n");+ assertLinesAre("test ", "abc ", " \u0302 ", "def ", " ");+ }++ public void testCombiningCharacterInLastColumn() throws Exception {+ withTerminalSized(3, 2).enterString(" a\u0302").assertLinesAre(" a\u0302", " ");+ withTerminalSized(3, 2).enterString(" à̲").assertLinesAre(" à̲", " ");+ withTerminalSized(3, 2).enterString("Aà̲F").assertLinesAre("Aà̲F", " ");+ }++ public void testWideCharacterInLastColumn() throws Exception {+ withTerminalSized(3, 2).enterString(" 枝\u0302").assertLinesAre(" ", "枝\u0302 ");++ withTerminalSized(3, 2).enterString(" 枝").assertLinesAre(" 枝", " ").assertCursorAt(0, 2);+ enterString("a").assertLinesAre(" 枝", "a ");+ }++ public void testWideCharacterDeletion() throws Exception {+ // CSI Ps D Cursor Backward Ps Times+ withTerminalSized(3, 2).enterString("枝\033[Da").assertLinesAre(" a ", " ");+ withTerminalSized(3, 2).enterString("枝\033[2Da").assertLinesAre("a ", " ");+ withTerminalSized(3, 2).enterString("枝\033[2D枝").assertLinesAre("枝 ", " ");+ withTerminalSized(3, 2).enterString("枝\033[1D枝").assertLinesAre(" 枝", " ");+ withTerminalSized(5, 2).enterString(" 枝 \033[Da").assertLinesAre(" 枝a ", " ");+ withTerminalSized(5, 2).enterString("a \033[D\u0302").assertLinesAre("a\u0302 ", " ");+ withTerminalSized(5, 2).enterString("枝 \033[D\u0302").assertLinesAre("枝\u0302 ", " ");+ enterString("Z").assertLinesAre("枝\u0302Z ", " ");+ enterString("\033[D ").assertLinesAre("枝\u0302 ", " ");+ // Go back two columns, standing at the second half of the wide character:+ enterString("\033[2DU").assertLinesAre(" U ", " ");+ }++ public void testWideCharOverwriting() {+ withTerminalSized(3, 2).enterString("abc\033[3D枝").assertLinesAre("枝c", " ");+ }++ public void testOverlongUtf8Encoding() throws Exception {+ // U+0020 should be encoded as 0x20, 0xc0 0xa0 is an overlong encoding+ // so should be replaced with the replacement char U+FFFD.+ withTerminalSized(5, 5).mTerminal.append(new byte[]{(byte) 0xc0, (byte) 0xa0, 'Y'}, 3);+ assertLineIs(0, "\uFFFDY ");+ }++ public void testWideCharacterWithoutWrapping() throws Exception {+ // With wraparound disabled. The behaviour when a wide character is output with cursor in+ // the last column when autowrap is disabled is not obvious, but we expect the wide+ // character to be ignored here.+ withTerminalSized(3, 3).enterString("\033[?7l").enterString("枝枝枝").assertLinesAre("枝 ", " ", " ");+ enterString("a枝").assertLinesAre("枝a", " ", " ");+ }++}diff --git a/terminal-emulator/src/test/java/com/termux/terminal/WcWidthTest.java b/terminal-emulator/src/test/java/com/termux/terminal/WcWidthTest.javanew file mode 100644index 0000000..c0d9a0b--- /dev/null+++ b/terminal-emulator/src/test/java/com/termux/terminal/WcWidthTest.java@@ -0,0 +1,81 @@+package com.termux.terminal;++import junit.framework.TestCase;++public class WcWidthTest extends TestCase {++ private static void assertWidthIs(int expectedWidth, int codePoint) {+ int wcWidth = WcWidth.width(codePoint);+ assertEquals(expectedWidth, wcWidth);+ }++ public void testPrintableAscii() {+ for (int i = 0x20; i <= 0x7E; i++) {+ assertWidthIs(1, i);+ }+ }++ public void testSomeWidthOne() {+ assertWidthIs(1, 'å');+ assertWidthIs(1, 'ä');+ assertWidthIs(1, 'ö');+ assertWidthIs(1, 0x23F2);+ }++ public void testSomeWide() {+ assertWidthIs(2, 'A');+ assertWidthIs(2, 'B');+ assertWidthIs(2, 'C');+ assertWidthIs(2, '中');+ assertWidthIs(2, '文');++ assertWidthIs(2, 0x679C);+ assertWidthIs(2, 0x679D);++ assertWidthIs(2, 0x2070E);+ assertWidthIs(2, 0x20731);++ assertWidthIs(1, 0x1F781);+ }++ public void testSomeNonWide() {+ assertWidthIs(1, 0x1D11E);+ assertWidthIs(1, 0x1D11F);+ }++ public void testCombining() {+ assertWidthIs(0, 0x0302);+ assertWidthIs(0, 0x0308);+ assertWidthIs(0, 0xFE0F);+ }++ public void testWordJoiner() {+ // https://en.wikipedia.org/wiki/Word_joiner+ // The word joiner (WJ) is a code point in Unicode used to separate words when using scripts+ // that do not use explicit spacing. It is encoded since Unicode version 3.2+ // (released in 2002) as U+2060 WORD JOINER (HTML ⁠).+ // The word joiner does not produce any space, and prohibits a line break at its position.+ assertWidthIs(0, 0x2060);+ }++ public void testSofthyphen() {+ // http://osdir.com/ml/internationalization.linux/2003-05/msg00006.html:+ // "Existing implementation practice in terminals is that the SOFT HYPHEN is+ // a spacing graphical character, and the purpose of my wcwidth() was to+ // predict the advancement of the cursor position after a string is sent to+ // a terminal. Hence, I have no choice but to keep wcwidth(SOFT HYPHEN) = 1.+ // VT100-style terminals do not hyphenate."+ assertWidthIs(1, 0x00AD);+ }++ public void testHangul() {+ assertWidthIs(1, 0x11A3);+ }++ public void testEmojis() {+ assertWidthIs(2, 0x1F428); // KOALA.+ assertWidthIs(2, 0x231a); // WATCH.+ assertWidthIs(2, 0x1F643); // UPSIDE-DOWN FACE (Unicode 8).+ }++}diff --git a/terminal-view/build.gradle.kts b/terminal-view/build.gradle.ktsnew file mode 100644index 0000000..559929b--- /dev/null+++ b/terminal-view/build.gradle.kts@@ -0,0 +1,22 @@+plugins {+ alias(libs.plugins.android.library)+}++android {+ namespace = "com.termux.view"+ compileSdk = 36++ defaultConfig {+ minSdk = 28+ }++ compileOptions {+ sourceCompatibility = JavaVersion.VERSION_17+ targetCompatibility = JavaVersion.VERSION_17+ }+}++dependencies {+ api(project(":terminal-emulator"))+ implementation("androidx.annotation:annotation:1.9.0")+}diff --git a/terminal-view/proguard-rules.pro b/terminal-view/proguard-rules.pronew file mode 100644index 0000000..2e56e60--- /dev/null+++ b/terminal-view/proguard-rules.pro@@ -0,0 +1,25 @@+# Add project specific ProGuard rules here.+# By default, the flags in this file are appended to flags specified+# in /Users/fornwall/lib/android-sdk/tools/proguard/proguard-android.txt+# You can edit the include path and order by changing the proguardFiles+# directive in build.gradle.+#+# For more details, see+# http://developer.android.com/guide/developing/tools/proguard.html++# Add any project specific keep options here:++# If your project uses WebView with JS, uncomment the following+# and specify the fully qualified class name to the JavaScript interface+# class:+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {+# public *;+#}++# Uncomment this to preserve the line number information for+# debugging stack traces.+#-keepattributes SourceFile,LineNumberTable++# If you keep the line number information, uncomment this to+# hide the original source file name.+#-renamesourcefileattribute SourceFilediff --git a/terminal-view/src/main/AndroidManifest.xml b/terminal-view/src/main/AndroidManifest.xmlnew file mode 100644index 0000000..bdae66c--- /dev/null+++ b/terminal-view/src/main/AndroidManifest.xml@@ -0,0 +1,2 @@+<manifest>+</manifest>diff --git a/terminal-view/src/main/java/com/termux/view/GestureAndScaleRecognizer.java b/terminal-view/src/main/java/com/termux/view/GestureAndScaleRecognizer.javanew file mode 100644index 0000000..f7fc9d2--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/GestureAndScaleRecognizer.java@@ -0,0 +1,112 @@+package com.termux.view;++import android.content.Context;+import android.view.GestureDetector;+import android.view.MotionEvent;+import android.view.ScaleGestureDetector;++/** A combination of {@link GestureDetector} and {@link ScaleGestureDetector}. */+final class GestureAndScaleRecognizer {++ public interface Listener {+ boolean onSingleTapUp(MotionEvent e);++ boolean onDoubleTap(MotionEvent e);++ boolean onScroll(MotionEvent e2, float dx, float dy);++ boolean onFling(MotionEvent e, float velocityX, float velocityY);++ boolean onScale(float focusX, float focusY, float scale);++ boolean onDown(float x, float y);++ boolean onUp(MotionEvent e);++ void onLongPress(MotionEvent e);+ }++ private final GestureDetector mGestureDetector;+ private final ScaleGestureDetector mScaleDetector;+ final Listener mListener;+ boolean isAfterLongPress;++ public GestureAndScaleRecognizer(Context context, Listener listener) {+ mListener = listener;++ mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {+ @Override+ public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx, float dy) {+ return mListener.onScroll(e2, dx, dy);+ }++ @Override+ public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {+ return mListener.onFling(e2, velocityX, velocityY);+ }++ @Override+ public boolean onDown(MotionEvent e) {+ return mListener.onDown(e.getX(), e.getY());+ }++ @Override+ public void onLongPress(MotionEvent e) {+ mListener.onLongPress(e);+ isAfterLongPress = true;+ }+ }, null, true /* ignoreMultitouch */);++ mGestureDetector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {+ @Override+ public boolean onSingleTapConfirmed(MotionEvent e) {+ return mListener.onSingleTapUp(e);+ }++ @Override+ public boolean onDoubleTap(MotionEvent e) {+ return mListener.onDoubleTap(e);+ }++ @Override+ public boolean onDoubleTapEvent(MotionEvent e) {+ return true;+ }+ });++ mScaleDetector = new ScaleGestureDetector(context, new ScaleGestureDetector.SimpleOnScaleGestureListener() {+ @Override+ public boolean onScaleBegin(ScaleGestureDetector detector) {+ return true;+ }++ @Override+ public boolean onScale(ScaleGestureDetector detector) {+ return mListener.onScale(detector.getFocusX(), detector.getFocusY(), detector.getScaleFactor());+ }+ });+ mScaleDetector.setQuickScaleEnabled(false);+ }++ public void onTouchEvent(MotionEvent event) {+ mGestureDetector.onTouchEvent(event);+ mScaleDetector.onTouchEvent(event);+ switch (event.getAction()) {+ case MotionEvent.ACTION_DOWN:+ isAfterLongPress = false;+ break;+ case MotionEvent.ACTION_UP:+ if (!isAfterLongPress) {+ // This behaviour is desired when in e.g. vim with mouse events, where we do not+ // want to move the cursor when lifting finger after a long press.+ mListener.onUp(event);+ }+ break;+ }+ }++ public boolean isInProgress() {+ return mScaleDetector.isInProgress();+ }++}diff --git a/terminal-view/src/main/java/com/termux/view/TerminalRenderer.java b/terminal-view/src/main/java/com/termux/view/TerminalRenderer.javanew file mode 100644index 0000000..f499d1c--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/TerminalRenderer.java@@ -0,0 +1,288 @@+package com.termux.view;++import android.graphics.Bitmap;+import android.graphics.Canvas;+import android.graphics.Paint;+import android.graphics.PorterDuff;+import android.graphics.Rect;+import android.graphics.RectF;+import android.graphics.Typeface;+import android.os.Build;++import com.termux.terminal.TerminalBuffer;+import com.termux.terminal.TerminalEmulator;+import com.termux.terminal.TerminalRow;+import com.termux.terminal.TextStyle;+import com.termux.terminal.WcWidth;++/**+ * Renderer of a {@link TerminalEmulator} into a {@link Canvas}.+ * <p/>+ * Saves font metrics, so needs to be recreated each time the typeface or font size changes.+ */+public final class TerminalRenderer {++ final int mTextSize;+ final Typeface mTypeface;+ private final Paint mTextPaint = new Paint();++ /** The width of a single mono spaced character obtained by {@link Paint#measureText(String)} on a single 'X'. */+ final float mFontWidth;+ /** The {@link Paint#getFontSpacing()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */+ final int mFontLineSpacing;+ /** The {@link Paint#ascent()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */+ private final int mFontAscent;+ /** The {@link #mFontLineSpacing} + {@link #mFontAscent}. */+ final int mFontLineSpacingAndAscent;++ private final float[] asciiMeasures = new float[127];++ // Podroid: hoisted out of the per-cell hot path. Image-heavy frames (chafa,+ // gnuplot) draw one Sixel bitmap per cell — allocating a fresh RectF each+ // time was straight-up GC pressure with no benefit since we just mutate it.+ private final RectF mBitmapDestRect = new RectF();++ public TerminalRenderer(int textSize, Typeface typeface) {+ mTextSize = textSize;+ mTypeface = typeface;++ mTextPaint.setTypeface(typeface);+ mTextPaint.setAntiAlias(true);+ mTextPaint.setTextSize(textSize);+ // Programming-font ligatures (FiraCode, JetBrains Mono, Cascadia Code).+ // `liga` = standard ligatures, `calt` = contextual alternates — most+ // programming fonts ship their `=>`, `===`, `!=`, etc. under `calt`.+ // Android's text engine handles the shaping inside drawTextRun; the+ // run-coalescing logic above already groups same-style cells, so the+ // ligature glyph paints naturally over its source cells.+ mTextPaint.setFontFeatureSettings("'liga' on, 'calt' on");++ mFontLineSpacing = (int) Math.ceil(mTextPaint.getFontSpacing());+ mFontAscent = (int) Math.ceil(mTextPaint.ascent());+ mFontLineSpacingAndAscent = mFontLineSpacing + mFontAscent;+ mFontWidth = mTextPaint.measureText("X");++ StringBuilder sb = new StringBuilder(" ");+ for (int i = 0; i < asciiMeasures.length; i++) {+ sb.setCharAt(0, (char) i);+ asciiMeasures[i] = mTextPaint.measureText(sb, 0, 1);+ }+ }++ /** Render the terminal to a canvas with at a specified row scroll, and an optional rectangular selection. */+ public final void render(TerminalEmulator mEmulator, Canvas canvas, int topRow,+ int selectionY1, int selectionY2, int selectionX1, int selectionX2) {+ final boolean reverseVideo = mEmulator.isReverseVideo();+ final int endRow = topRow + mEmulator.mRows;+ final int columns = mEmulator.mColumns;+ final int cursorCol = mEmulator.getCursorCol();+ final int cursorRow = mEmulator.getCursorRow();+ final boolean cursorVisible = mEmulator.shouldCursorBeVisible();+ final TerminalBuffer screen = mEmulator.getScreen();+ final int[] palette = mEmulator.mColors.mCurrentColors;+ final int cursorShape = mEmulator.getCursorStyle();++ if (reverseVideo)+ canvas.drawColor(palette[TextStyle.COLOR_INDEX_FOREGROUND], PorterDuff.Mode.SRC);++ float heightOffset = mFontLineSpacingAndAscent;+ for (int row = topRow; row < endRow; row++) {+ heightOffset += mFontLineSpacing;++ final int cursorX = (row == cursorRow && cursorVisible) ? cursorCol : -1;+ int selx1 = -1, selx2 = -1;+ if (row >= selectionY1 && row <= selectionY2) {+ if (row == selectionY1) selx1 = selectionX1;+ selx2 = (row == selectionY2) ? selectionX2 : mEmulator.mColumns;+ }++ TerminalRow lineObject = screen.allocateFullLineIfNecessary(screen.externalToInternalRow(row));+ final char[] line = lineObject.mText;+ final int charsUsedInLine = lineObject.getSpaceUsed();++ long lastRunStyle = 0;+ boolean lastRunInsideCursor = false;+ boolean lastRunInsideSelection = false;+ int lastRunStartColumn = -1;+ int lastRunStartIndex = 0;+ boolean lastRunFontWidthMismatch = false;+ int currentCharIndex = 0;+ float measuredWidthForRun = 0.f;++ for (int column = 0; column < columns; ) {+ final char charAtIndex = line[currentCharIndex];+ final boolean charIsHighsurrogate = Character.isHighSurrogate(charAtIndex);+ final int charsForCodePoint = charIsHighsurrogate ? 2 : 1;+ final int codePoint = charIsHighsurrogate ? Character.toCodePoint(charAtIndex, line[currentCharIndex + 1]) : charAtIndex;+ final long style = lineObject.getStyle(column);+ if (TextStyle.isTerminalBitmap(style)) {+ Bitmap bitmap = mEmulator.getScreen().getSixelBitmap(style);+ if (bitmap != null) {+ float left = column * mFontWidth;+ float top = heightOffset - mFontLineSpacing;+ Rect bitmapSrcRect = mEmulator.getScreen().getSixelRect(style);+ mBitmapDestRect.set(left, top, left + mFontWidth, top + mFontLineSpacing);+ canvas.drawBitmap(bitmap, bitmapSrcRect, mBitmapDestRect, null);+ }+ column += 1;+ measuredWidthForRun = 0.f;+ lastRunStyle = 0;+ lastRunInsideCursor = false;+ lastRunStartColumn = column + 1;+ lastRunStartIndex = currentCharIndex;+ lastRunFontWidthMismatch = false;+ currentCharIndex += charsForCodePoint;+ continue;+ }+ final int codePointWcWidth = WcWidth.width(codePoint);+ final boolean insideCursor = (cursorX == column || (codePointWcWidth == 2 && cursorX == column + 1));+ final boolean insideSelection = column >= selx1 && column <= selx2;++ // Check if the measured text width for this code point is not the same as that expected by wcwidth().+ // This could happen for some fonts which are not truly monospace, or for more exotic characters such as+ // smileys which android font renders as wide.+ // If this is detected, we draw this code point scaled to match what wcwidth() expects.+ final float measuredCodePointWidth = (codePoint < asciiMeasures.length) ? asciiMeasures[codePoint] : mTextPaint.measureText(line,+ currentCharIndex, charsForCodePoint);+ final boolean fontWidthMismatch = Math.abs(measuredCodePointWidth / mFontWidth - codePointWcWidth) > 0.01;++ if (style != lastRunStyle || insideCursor != lastRunInsideCursor || insideSelection != lastRunInsideSelection || fontWidthMismatch || lastRunFontWidthMismatch) {+ if (column == 0 || column == lastRunStartColumn) {+ // Skip first column as there is nothing to draw, just record the current style.+ } else {+ final int columnWidthSinceLastRun = column - lastRunStartColumn;+ final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;+ int cursorColor = lastRunInsideCursor ? mEmulator.mColors.mCurrentColors[TextStyle.COLOR_INDEX_CURSOR] : 0;+ boolean invertCursorTextColor = false;+ if (lastRunInsideCursor && cursorShape == TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK) {+ invertCursorTextColor = true;+ }+ drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun,+ lastRunStartIndex, charsSinceLastRun, measuredWidthForRun,+ cursorColor, cursorShape, lastRunStyle, reverseVideo || invertCursorTextColor || lastRunInsideSelection);+ }+ measuredWidthForRun = 0.f;+ lastRunStyle = style;+ lastRunInsideCursor = insideCursor;+ lastRunInsideSelection = insideSelection;+ lastRunStartColumn = column;+ lastRunStartIndex = currentCharIndex;+ lastRunFontWidthMismatch = fontWidthMismatch;+ }+ measuredWidthForRun += measuredCodePointWidth;+ column += codePointWcWidth;+ currentCharIndex += charsForCodePoint;+ while (currentCharIndex < charsUsedInLine && WcWidth.width(line, currentCharIndex) <= 0) {+ // Eat combining chars so that they are treated as part of the last non-combining code point,+ // instead of e.g. being considered inside the cursor in the next run.+ currentCharIndex += Character.isHighSurrogate(line[currentCharIndex]) ? 2 : 1;+ }+ }++ final int columnWidthSinceLastRun = columns - lastRunStartColumn;+ final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;+ int cursorColor = lastRunInsideCursor ? mEmulator.mColors.mCurrentColors[TextStyle.COLOR_INDEX_CURSOR] : 0;+ boolean invertCursorTextColor = false;+ if (lastRunInsideCursor && cursorShape == TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK) {+ invertCursorTextColor = true;+ }+ drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,+ measuredWidthForRun, cursorColor, cursorShape, lastRunStyle, reverseVideo || invertCursorTextColor || lastRunInsideSelection);+ }+ }++ private void drawTextRun(Canvas canvas, char[] text, int[] palette, float y, int startColumn, int runWidthColumns,+ int startCharIndex, int runWidthChars, float mes, int cursor, int cursorStyle,+ long textStyle, boolean reverseVideo) {+ int foreColor = TextStyle.decodeForeColor(textStyle);+ final int effect = TextStyle.decodeEffect(textStyle);+ int backColor = TextStyle.decodeBackColor(textStyle);+ final boolean bold = (effect & (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_BLINK)) != 0;+ final boolean underline = (effect & TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0;+ final boolean italic = (effect & TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0;+ final boolean strikeThrough = (effect & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0;+ final boolean dim = (effect & TextStyle.CHARACTER_ATTRIBUTE_DIM) != 0;++ if ((foreColor & 0xff000000) != 0xff000000) {+ // Let bold have bright colors if applicable (one of the first 8):+ if (bold && foreColor >= 0 && foreColor < 8) foreColor += 8;+ foreColor = palette[foreColor];+ }++ if ((backColor & 0xff000000) != 0xff000000) {+ backColor = palette[backColor];+ }++ // Reverse video here if _one and only one_ of the reverse flags are set:+ final boolean reverseVideoHere = reverseVideo ^ (effect & (TextStyle.CHARACTER_ATTRIBUTE_INVERSE)) != 0;+ if (reverseVideoHere) {+ int tmp = foreColor;+ foreColor = backColor;+ backColor = tmp;+ }++ float left = startColumn * mFontWidth;+ float right = left + runWidthColumns * mFontWidth;++ mes = mes / mFontWidth;+ boolean savedMatrix = false;+ if (Math.abs(mes - runWidthColumns) > 0.01) {+ canvas.save();+ canvas.scale(runWidthColumns / mes, 1.f);+ left *= mes / runWidthColumns;+ right *= mes / runWidthColumns;+ savedMatrix = true;+ }++ if (backColor != palette[TextStyle.COLOR_INDEX_BACKGROUND]) {+ // Only draw non-default background.+ mTextPaint.setColor(backColor);+ canvas.drawRect(left, y - mFontLineSpacingAndAscent + mFontAscent, right, y, mTextPaint);+ }++ if (cursor != 0) {+ mTextPaint.setColor(cursor);+ float cursorHeight = mFontLineSpacingAndAscent - mFontAscent;+ if (cursorStyle == TerminalEmulator.TERMINAL_CURSOR_STYLE_UNDERLINE) cursorHeight /= 4.f;+ else if (cursorStyle == TerminalEmulator.TERMINAL_CURSOR_STYLE_BAR) right -= (((right - left) * 3) / 4.f);+ canvas.drawRect(left, y - cursorHeight, right, y, mTextPaint);+ }++ if ((effect & TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) == 0) {+ if (dim) {+ int red = (0xFF & (foreColor >> 16));+ int green = (0xFF & (foreColor >> 8));+ int blue = (0xFF & foreColor);+ // Dim color handling used by libvte which in turn took it from xterm+ // (https://bug735245.bugzilla-attachments.gnome.org/attachment.cgi?id=284267):+ red = red * 2 / 3;+ green = green * 2 / 3;+ blue = blue * 2 / 3;+ foreColor = 0xFF000000 + (red << 16) + (green << 8) + blue;+ }++ mTextPaint.setFakeBoldText(bold);+ mTextPaint.setUnderlineText(underline);+ mTextPaint.setTextSkewX(italic ? -0.35f : 0.f);+ mTextPaint.setStrikeThruText(strikeThrough);+ mTextPaint.setColor(foreColor);++ // The text alignment is the default Paint.Align.LEFT.+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {+ canvas.drawTextRun(text, startCharIndex, runWidthChars, startCharIndex, runWidthChars, left, y - mFontLineSpacingAndAscent, false, mTextPaint);+ } else {+ canvas.drawText(text, startCharIndex, runWidthChars, left, y - mFontLineSpacingAndAscent, mTextPaint);+ }+ }++ if (savedMatrix) canvas.restore();+ }++ public float getFontWidth() {+ return mFontWidth;+ }++ public int getFontLineSpacing() {+ return mFontLineSpacing;+ }+}diff --git a/terminal-view/src/main/java/com/termux/view/TerminalView.java b/terminal-view/src/main/java/com/termux/view/TerminalView.javanew file mode 100644index 0000000..49e03ca--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/TerminalView.java@@ -0,0 +1,1512 @@+package com.termux.view;++import android.annotation.SuppressLint;+import android.annotation.TargetApi;+import android.app.Activity;+import android.content.ClipData;+import android.content.ClipboardManager;+import android.content.Context;+import android.graphics.Canvas;+import android.graphics.Typeface;+import android.os.Build;+import android.os.Handler;+import android.os.Looper;+import android.os.SystemClock;+import android.text.Editable;+import android.text.InputType;+import android.text.TextUtils;+import android.util.AttributeSet;+import android.view.ActionMode;+import android.view.HapticFeedbackConstants;+import android.view.InputDevice;+import android.view.KeyCharacterMap;+import android.view.KeyEvent;+import android.view.Menu;+import android.view.MotionEvent;+import android.view.View;+import android.view.ViewConfiguration;+import android.view.ViewTreeObserver;+import android.view.accessibility.AccessibilityManager;+import android.view.autofill.AutofillManager;+import android.view.autofill.AutofillValue;+import android.view.inputmethod.BaseInputConnection;+import android.view.inputmethod.EditorInfo;+import android.view.inputmethod.InputConnection;+import android.widget.Scroller;++import androidx.annotation.Nullable;+import androidx.annotation.RequiresApi;++import com.termux.terminal.KeyHandler;+import com.termux.terminal.TerminalEmulator;+import com.termux.terminal.TerminalSession;+import com.termux.view.textselection.TextSelectionCursorController;++/** View displaying and interacting with a {@link TerminalSession}. */+public final class TerminalView extends View {++ /** Log terminal view key and IME events. */+ private static boolean TERMINAL_VIEW_KEY_LOGGING_ENABLED = false;++ /** The currently displayed terminal session, whose emulator is {@link #mEmulator}. */+ public TerminalSession mTermSession;+ /** Our terminal emulator whose session is {@link #mTermSession}. */+ public TerminalEmulator mEmulator;++ public TerminalRenderer mRenderer;++ public TerminalViewClient mClient;++ private TextSelectionCursorController mTextSelectionCursorController;++ private Handler mTerminalCursorBlinkerHandler;+ private TerminalCursorBlinkerRunnable mTerminalCursorBlinkerRunnable;+ private int mTerminalCursorBlinkerRate;+ private boolean mCursorInvisibleIgnoreOnce;+ public static final int TERMINAL_CURSOR_BLINK_RATE_MIN = 100;+ public static final int TERMINAL_CURSOR_BLINK_RATE_MAX = 2000;++ /** The top row of text to display. Ranges from -activeTranscriptRows to 0. */+ int mTopRow;+ int[] mDefaultSelectors = new int[]{-1,-1,-1,-1};++ float mScaleFactor = 1.f;+ final GestureAndScaleRecognizer mGestureRecognizer;++ /** Keep track of where mouse touch event started which we report as mouse scroll. */+ private int mMouseScrollStartX = -1, mMouseScrollStartY = -1;+ /** Keep track of the time when a touch event leading to sending mouse scroll events started. */+ private long mMouseStartDownTime = -1;++ final Scroller mScroller;++ /** What was left in from scrolling movement. */+ float mScrollRemainder;++ /** If non-zero, this is the last unicode code point received if that was a combining character. */+ int mCombiningAccent;++ /**+ * The current AutoFill type returned for {@link View#getAutofillType()} by {@link #getAutofillType()}.+ *+ * The default is {@link #AUTOFILL_TYPE_NONE} so that AutoFill UI, like toolbar above keyboard+ * is not shown automatically, like on Activity starts/View create. This value should be updated+ * to required value, like {@link #AUTOFILL_TYPE_TEXT} before calling+ * {@link AutofillManager#requestAutofill(View)} so that AutoFill UI shows. The updated value+ * set will automatically be restored to {@link #AUTOFILL_TYPE_NONE} in+ * {@link #autofill(AutofillValue)} so that AutoFill UI isn't shown anymore by calling+ * {@link #resetAutoFill()}.+ */+ @RequiresApi(api = Build.VERSION_CODES.O)+ private int mAutoFillType = AUTOFILL_TYPE_NONE;++ /**+ * The current AutoFill type returned for {@link View#getImportantForAutofill()} by+ * {@link #getImportantForAutofill()}.+ *+ * The default is {@link #IMPORTANT_FOR_AUTOFILL_NO} so that view is not considered important+ * for AutoFill. This value should be updated to required value, like+ * {@link #IMPORTANT_FOR_AUTOFILL_YES} before calling {@link AutofillManager#requestAutofill(View)}+ * so that Android and apps consider the view as important for AutoFill to process the request.+ * The updated value set will automatically be restored to {@link #IMPORTANT_FOR_AUTOFILL_NO} in+ * {@link #autofill(AutofillValue)} by calling {@link #resetAutoFill()}.+ */+ @RequiresApi(api = Build.VERSION_CODES.O)+ private int mAutoFillImportance = IMPORTANT_FOR_AUTOFILL_NO;++ /**+ * The current AutoFill hints returned for {@link View#getAutofillHints()} ()} by {@link #getAutofillHints()} ()}.+ *+ * The default is an empty `string[]`. This value should be updated to required value. The+ * updated value set will automatically be restored an empty `string[]` in+ * {@link #autofill(AutofillValue)} by calling {@link #resetAutoFill()}.+ */+ private String[] mAutoFillHints = new String[0];++ private final boolean mAccessibilityEnabled;++ /** The {@link KeyEvent} is generated from a virtual keyboard, like manually with the {@link KeyEvent#KeyEvent(int, int)} constructor. */+ public final static int KEY_EVENT_SOURCE_VIRTUAL_KEYBOARD = KeyCharacterMap.VIRTUAL_KEYBOARD; // -1++ /** The {@link KeyEvent} is generated from a non-physical device, like if 0 value is returned by {@link KeyEvent#getDeviceId()}. */+ public final static int KEY_EVENT_SOURCE_SOFT_KEYBOARD = 0;++ private static final String LOG_TAG = "TerminalView";++ public TerminalView(Context context, AttributeSet attributes) { // NO_UCD (unused code)+ super(context, attributes);+ mGestureRecognizer = new GestureAndScaleRecognizer(context, new GestureAndScaleRecognizer.Listener() {++ boolean scrolledWithFinger;++ @Override+ public boolean onUp(MotionEvent event) {+ mScrollRemainder = 0.0f;+ if (mEmulator != null && mEmulator.isMouseTrackingActive() && !event.isFromSource(InputDevice.SOURCE_MOUSE) && !isSelectingText() && !scrolledWithFinger) {+ // Quick event processing when mouse tracking is active - do not wait for check of double tapping+ // for zooming.+ sendMouseEventCode(event, TerminalEmulator.MOUSE_LEFT_BUTTON, true);+ sendMouseEventCode(event, TerminalEmulator.MOUSE_LEFT_BUTTON, false);+ return true;+ }+ scrolledWithFinger = false;+ return false;+ }++ @Override+ public boolean onSingleTapUp(MotionEvent event) {+ if (mEmulator == null) return true;++ if (isSelectingText()) {+ stopTextSelectionMode();+ return true;+ }+ requestFocus();+ mClient.onSingleTapUp(event);+ return true;+ }++ @Override+ public boolean onScroll(MotionEvent e, float distanceX, float distanceY) {+ if (mEmulator == null) return true;+ if (mEmulator.isMouseTrackingActive() && e.isFromSource(InputDevice.SOURCE_MOUSE)) {+ // If moving with mouse pointer while pressing button, report that instead of scroll.+ // This means that we never report moving with button press-events for touch input,+ // since we cannot just start sending these events without a starting press event,+ // which we do not do for touch input, only mouse in onTouchEvent().+ sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);+ } else {+ scrolledWithFinger = true;+ distanceY += mScrollRemainder;+ int deltaRows = (int) (distanceY / mRenderer.mFontLineSpacing);+ mScrollRemainder = distanceY - deltaRows * mRenderer.mFontLineSpacing;+ doScroll(e, deltaRows);+ }+ return true;+ }++ @Override+ public boolean onScale(float focusX, float focusY, float scale) {+ if (mEmulator == null || isSelectingText()) return true;+ mScaleFactor *= scale;+ mScaleFactor = mClient.onScale(mScaleFactor);+ return true;+ }++ @Override+ public boolean onFling(final MotionEvent e2, float velocityX, float velocityY) {+ if (mEmulator == null) return true;+ // Do not start scrolling until last fling has been taken care of:+ if (!mScroller.isFinished()) return true;++ final boolean mouseTrackingAtStartOfFling = mEmulator.isMouseTrackingActive();+ float SCALE = 0.25f;+ if (mouseTrackingAtStartOfFling) {+ mScroller.fling(0, 0, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.mRows / 2, mEmulator.mRows / 2);+ } else {+ mScroller.fling(0, mTopRow, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.getScreen().getActiveTranscriptRows(), 0);+ }++ post(new Runnable() {+ private int mLastY = 0;++ @Override+ public void run() {+ if (mouseTrackingAtStartOfFling != mEmulator.isMouseTrackingActive()) {+ mScroller.abortAnimation();+ return;+ }+ if (mScroller.isFinished()) return;+ boolean more = mScroller.computeScrollOffset();+ int newY = mScroller.getCurrY();+ int diff = mouseTrackingAtStartOfFling ? (newY - mLastY) : (newY - mTopRow);+ doScroll(e2, diff);+ mLastY = newY;+ if (more) post(this);+ }+ });++ return true;+ }++ @Override+ public boolean onDown(float x, float y) {+ // Why is true not returned here?+ // https://developer.android.com/training/gestures/detector.html#detect-a-subset-of-supported-gestures+ // Although setting this to true still does not solve the following errors when long pressing in terminal view text area+ // ViewDragHelper: Ignoring pointerId=0 because ACTION_DOWN was not received for this pointer before ACTION_MOVE+ // Commenting out the call to mGestureDetector.onTouchEvent(event) in GestureAndScaleRecognizer#onTouchEvent() removes+ // the error logging, so issue is related to GestureDetector+ return false;+ }++ @Override+ public boolean onDoubleTap(MotionEvent event) {+ // Do not treat is as a single confirmed tap - it may be followed by zoom.+ return false;+ }++ @Override+ public void onLongPress(MotionEvent event) {+ if (mGestureRecognizer.isInProgress()) return;+ if (mClient.onLongPress(event)) return;+ if (!isSelectingText()) {+ performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);+ startTextSelectionMode(event);+ }+ }+ });+ mScroller = new Scroller(context);+ AccessibilityManager am = (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);+ mAccessibilityEnabled = am.isEnabled();+ }++++ /**+ * @param client The {@link TerminalViewClient} interface implementation to allow+ * for communication between {@link TerminalView} and its client.+ */+ public void setTerminalViewClient(TerminalViewClient client) {+ this.mClient = client;+ }++ /**+ * Sets whether terminal view key logging is enabled or not.+ *+ * @param value The boolean value that defines the state.+ */+ public void setIsTerminalViewKeyLoggingEnabled(boolean value) {+ TERMINAL_VIEW_KEY_LOGGING_ENABLED = value;+ }++++ /**+ * Attach a {@link TerminalSession} to this view.+ *+ * @param session The {@link TerminalSession} this view will be displaying.+ */+ public boolean attachSession(TerminalSession session) {+ if (session == mTermSession) return false;+ mTopRow = 0;++ mTermSession = session;+ mEmulator = null;+ mCombiningAccent = 0;++ updateSize();++ // Wait with enabling the scrollbar until we have a terminal to get scroll position from.+ setVerticalScrollBarEnabled(true);++ return true;+ }++ @Override+ public InputConnection onCreateInputConnection(EditorInfo outAttrs) {+ // Ensure that inputType is only set if TerminalView is selected view with the keyboard and+ // an alternate view is not selected, like an EditText. This is necessary if an activity is+ // initially started with the alternate view or if activity is returned to from another app+ // and the alternate view was the one selected the last time.+ if (mClient.isTerminalViewSelected()) {+ if (mClient.shouldEnforceCharBasedInput()) {+ // Some keyboards seems do not reset the internal state on TYPE_NULL.+ // Affects mostly Samsung stock keyboards.+ // https://github.com/termux/termux-app/issues/686+ // However, this is not a valid value as per AOSP since `InputType.TYPE_CLASS_*` is+ // not set and it logs a warning:+ // W/InputAttributes: Unexpected input class: inputType=0x00080090 imeOptions=0x02000000+ // https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:packages/inputmethods/LatinIME/java/src/com/android/inputmethod/latin/InputAttributes.java;l=79+ outAttrs.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS;+ } else {+ // Using InputType.NULL is the most correct input type and avoids issues with other hacks.+ //+ // Previous keyboard issues:+ // https://github.com/termux/termux-packages/issues/25+ // https://github.com/termux/termux-app/issues/87.+ // https://github.com/termux/termux-app/issues/126.+ // https://github.com/termux/termux-app/issues/137 (japanese chars and TYPE_NULL).+ outAttrs.inputType = InputType.TYPE_NULL;+ }+ } else {+ // Corresponds to android:inputType="text"+ outAttrs.inputType = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_NORMAL;+ }++ // Note that IME_ACTION_NONE cannot be used as that makes it impossible to input newlines using the on-screen+ // keyboard on Android TV (see https://github.com/termux/termux-app/issues/221).+ outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;++ return new BaseInputConnection(this, true) {++ @Override+ public boolean finishComposingText() {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED) mClient.logInfo(LOG_TAG, "IME: finishComposingText()");+ super.finishComposingText();++ sendTextToTerminal(getEditable());+ getEditable().clear();+ return true;+ }++ @Override+ public boolean commitText(CharSequence text, int newCursorPosition) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED) {+ mClient.logInfo(LOG_TAG, "IME: commitText(\"" + text + "\", " + newCursorPosition + ")");+ }+ super.commitText(text, newCursorPosition);++ if (mEmulator == null) return true;++ Editable content = getEditable();+ sendTextToTerminal(content);+ content.clear();+ return true;+ }++ @Override+ public boolean deleteSurroundingText(int leftLength, int rightLength) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED) {+ mClient.logInfo(LOG_TAG, "IME: deleteSurroundingText(" + leftLength + ", " + rightLength + ")");+ }+ // The stock Samsung keyboard with 'Auto check spelling' enabled sends leftLength > 1.+ KeyEvent deleteKey = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL);+ for (int i = 0; i < leftLength; i++) sendKeyEvent(deleteKey);+ return super.deleteSurroundingText(leftLength, rightLength);+ }++ void sendTextToTerminal(CharSequence text) {+ stopTextSelectionMode();+ final int textLengthInChars = text.length();+ for (int i = 0; i < textLengthInChars; i++) {+ char firstChar = text.charAt(i);+ int codePoint;+ if (Character.isHighSurrogate(firstChar)) {+ if (++i < textLengthInChars) {+ codePoint = Character.toCodePoint(firstChar, text.charAt(i));+ } else {+ // At end of string, with no low surrogate following the high:+ codePoint = TerminalEmulator.UNICODE_REPLACEMENT_CHAR;+ }+ } else {+ codePoint = firstChar;+ }++ // Check onKeyDown() for details.+ if (mClient.readShiftKey())+ codePoint = Character.toUpperCase(codePoint);++ boolean ctrlHeld = false;+ if (codePoint <= 31 && codePoint != 27) {+ if (codePoint == '\n') {+ // The AOSP keyboard and descendants seems to send \n as text when the enter key is pressed,+ // instead of a key event like most other keyboard apps. A terminal expects \r for the enter+ // key (although when icrnl is enabled this doesn't make a difference - run 'stty -icrnl' to+ // check the behaviour).+ codePoint = '\r';+ }++ // E.g. penti keyboard for ctrl input.+ ctrlHeld = true;+ switch (codePoint) {+ case 31:+ codePoint = '_';+ break;+ case 30:+ codePoint = '^';+ break;+ case 29:+ codePoint = ']';+ break;+ case 28:+ codePoint = '\\';+ break;+ default:+ codePoint += 96;+ break;+ }+ }++ inputCodePoint(KEY_EVENT_SOURCE_SOFT_KEYBOARD, codePoint, ctrlHeld, false);+ }+ }++ };+ }++ @Override+ protected int computeVerticalScrollRange() {+ return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows();+ }++ @Override+ protected int computeVerticalScrollExtent() {+ return mEmulator == null ? 1 : mEmulator.mRows;+ }++ @Override+ protected int computeVerticalScrollOffset() {+ return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows() + mTopRow - mEmulator.mRows;+ }++ public void onScreenUpdated() {+ onScreenUpdated(false);+ }++ public void onScreenUpdated(boolean skipScrolling) {+ if (mEmulator == null) return;++ int rowsInHistory = mEmulator.getScreen().getActiveTranscriptRows();+ if (mTopRow < -rowsInHistory) mTopRow = -rowsInHistory;++ if (isSelectingText() || mEmulator.isAutoScrollDisabled()) {++ // Do not scroll when selecting text.+ int rowShift = mEmulator.getScrollCounter();+ if (-mTopRow + rowShift > rowsInHistory) {+ // .. unless we're hitting the end of history transcript, in which+ // case we abort text selection and scroll to end.+ if (isSelectingText())+ stopTextSelectionMode();++ if (mEmulator.isAutoScrollDisabled()) {+ mTopRow = -rowsInHistory;+ skipScrolling = true;+ }+ } else {+ skipScrolling = true;+ mTopRow -= rowShift;+ decrementYTextSelectionCursors(rowShift);+ }+ }++ if (!skipScrolling && mTopRow != 0) {+ // Scroll down if not already there.+ if (mTopRow < -3) {+ // Awaken scroll bars only if scrolling a noticeable amount+ // - we do not want visible scroll bars during normal typing+ // of one row at a time.+ awakenScrollBars();+ }+ mTopRow = 0;+ }++ mEmulator.clearScrollCounter();++ invalidate();+ if (mAccessibilityEnabled) setContentDescription(getText());+ }++ /** This must be called by the hosting activity in {@link Activity#onContextMenuClosed(Menu)}+ * when context menu for the {@link TerminalView} is started by+ * {@link TextSelectionCursorController#ACTION_MORE} is closed. */+ public void onContextMenuClosed(Menu menu) {+ // Unset the stored text since it shouldn't be used anymore and should be cleared from memory+ unsetStoredSelectedText();+ }++ /**+ * Sets the text size, which in turn sets the number of rows and columns.+ *+ * @param textSize the new font size, in density-independent pixels.+ */+ public void setTextSize(int textSize) {+ mRenderer = new TerminalRenderer(textSize, mRenderer == null ? Typeface.MONOSPACE : mRenderer.mTypeface);+ updateSize();+ }++ public void setTypeface(Typeface newTypeface) {+ mRenderer = new TerminalRenderer(mRenderer.mTextSize, newTypeface);+ updateSize();+ invalidate();+ }++ @Override+ public boolean onCheckIsTextEditor() {+ return true;+ }++ @Override+ public boolean isOpaque() {+ return true;+ }++ /**+ * Get the zero indexed column and row of the terminal view for the+ * position of the event.+ *+ * @param event The event with the position to get the column and row for.+ * @param relativeToScroll If true the column number will take the scroll+ * position into account. E.g. if scrolled 3 lines up and the event+ * position is in the top left, column will be -3 if relativeToScroll is+ * true and 0 if relativeToScroll is false.+ * @return Array with the column and row.+ */+ public int[] getColumnAndRow(MotionEvent event, boolean relativeToScroll) {+ int column = (int) (event.getX() / mRenderer.mFontWidth);+ int row = (int) ((event.getY() - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing);+ if (relativeToScroll) {+ row += mTopRow;+ }+ return new int[] { column, row };+ }++ /** Send a single mouse event code to the terminal. */+ void sendMouseEventCode(MotionEvent e, int button, boolean pressed) {+ int[] columnAndRow = getColumnAndRow(e, false);+ int x = columnAndRow[0] + 1;+ int y = columnAndRow[1] + 1;+ if (pressed && (button == TerminalEmulator.MOUSE_WHEELDOWN_BUTTON || button == TerminalEmulator.MOUSE_WHEELUP_BUTTON)) {+ if (mMouseStartDownTime == e.getDownTime()) {+ x = mMouseScrollStartX;+ y = mMouseScrollStartY;+ } else {+ mMouseStartDownTime = e.getDownTime();+ mMouseScrollStartX = x;+ mMouseScrollStartY = y;+ }+ }+ mEmulator.sendMouseEvent(button, x, y, pressed);+ }++ /** Perform a scroll, either from dragging the screen or by scrolling a mouse wheel. */+ void doScroll(MotionEvent event, int rowsDown) {+ boolean up = rowsDown < 0;+ int amount = Math.abs(rowsDown);+ for (int i = 0; i < amount; i++) {+ if (mEmulator.isMouseTrackingActive()) {+ sendMouseEventCode(event, up ? TerminalEmulator.MOUSE_WHEELUP_BUTTON : TerminalEmulator.MOUSE_WHEELDOWN_BUTTON, true);+ } else if (mEmulator.isAlternateBufferActive()) {+ // Send up and down key events for scrolling, which is what some terminals do to make scroll work in+ // e.g. less, which shifts to the alt screen without mouse handling.+ handleKeyCode(up ? KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN, 0);+ } else {+ mTopRow = Math.min(0, Math.max(-(mEmulator.getScreen().getActiveTranscriptRows()), mTopRow + (up ? -1 : 1)));+ if (!awakenScrollBars()) invalidate();+ }+ }+ }++ /** Overriding {@link View#onGenericMotionEvent(MotionEvent)}. */+ @Override+ public boolean onGenericMotionEvent(MotionEvent event) {+ if (mEmulator != null && event.isFromSource(InputDevice.SOURCE_MOUSE) && event.getAction() == MotionEvent.ACTION_SCROLL) {+ // Handle mouse wheel scrolling.+ boolean up = event.getAxisValue(MotionEvent.AXIS_VSCROLL) > 0.0f;+ doScroll(event, up ? -3 : 3);+ return true;+ }+ return false;+ }++ @SuppressLint("ClickableViewAccessibility")+ @Override+ @TargetApi(23)+ public boolean onTouchEvent(MotionEvent event) {+ if (mEmulator == null) return true;+ final int action = event.getAction();++ if (isSelectingText()) {+ updateFloatingToolbarVisibility(event);+ mGestureRecognizer.onTouchEvent(event);+ return true;+ } else if (event.isFromSource(InputDevice.SOURCE_MOUSE)) {+ if (event.isButtonPressed(MotionEvent.BUTTON_SECONDARY)) {+ if (action == MotionEvent.ACTION_DOWN) showContextMenu();+ return true;+ } else if (event.isButtonPressed(MotionEvent.BUTTON_TERTIARY)) {+ ClipboardManager clipboardManager = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);+ ClipData clipData = clipboardManager.getPrimaryClip();+ if (clipData != null) {+ ClipData.Item clipItem = clipData.getItemAt(0);+ if (clipItem != null) {+ CharSequence text = clipItem.coerceToText(getContext());+ if (!TextUtils.isEmpty(text)) mEmulator.paste(text.toString());+ }+ }+ } else if (mEmulator.isMouseTrackingActive()) { // BUTTON_PRIMARY.+ switch (event.getAction()) {+ case MotionEvent.ACTION_DOWN:+ case MotionEvent.ACTION_UP:+ sendMouseEventCode(event, TerminalEmulator.MOUSE_LEFT_BUTTON, event.getAction() == MotionEvent.ACTION_DOWN);+ break;+ case MotionEvent.ACTION_MOVE:+ sendMouseEventCode(event, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);+ break;+ }+ }+ }++ mGestureRecognizer.onTouchEvent(event);+ return true;+ }++ @Override+ public boolean onKeyPreIme(int keyCode, KeyEvent event) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logInfo(LOG_TAG, "onKeyPreIme(keyCode=" + keyCode + ", event=" + event + ")");+ if (keyCode == KeyEvent.KEYCODE_BACK) {+ cancelRequestAutoFill();+ if (isSelectingText()) {+ stopTextSelectionMode();+ return true;+ } else if (mClient.shouldBackButtonBeMappedToEscape()) {+ // Intercept back button to treat it as escape:+ switch (event.getAction()) {+ case KeyEvent.ACTION_DOWN:+ return onKeyDown(keyCode, event);+ case KeyEvent.ACTION_UP:+ return onKeyUp(keyCode, event);+ }+ }+ } else if (mClient.shouldUseCtrlSpaceWorkaround() &&+ keyCode == KeyEvent.KEYCODE_SPACE && event.isCtrlPressed()) {+ /* ctrl+space does not work on some ROMs without this workaround.+ However, this breaks it on devices where it works out of the box. */+ return onKeyDown(keyCode, event);+ }+ return super.onKeyPreIme(keyCode, event);+ }++ /**+ * Key presses in software keyboards will generally NOT trigger this listener, although some+ * may elect to do so in some situations. Do not rely on this to catch software key presses.+ * Gboard calls this when shouldEnforceCharBasedInput() is disabled (InputType.TYPE_NULL) instead+ * of calling commitText(), with deviceId=-1. However, Hacker's Keyboard, OpenBoard, LG Keyboard+ * call commitText().+ *+ * This function may also be called directly without android calling it, like by+ * `TerminalExtraKeys` which generates a KeyEvent manually which uses {@link KeyCharacterMap#VIRTUAL_KEYBOARD}+ * as the device (deviceId=-1), as does Gboard. That would normally use mappings defined in+ * `/system/usr/keychars/Virtual.kcm`. You can run `dumpsys input` to find the `KeyCharacterMapFile`+ * used by virtual keyboard or hardware keyboard. Note that virtual keyboard device is not the+ * same as software keyboard, like Gboard, etc. Its a fake device used for generating events and+ * for testing.+ *+ * We handle shift key in `commitText()` to convert codepoint to uppercase case there with a+ * call to {@link Character#toUpperCase(int)}, but here we instead rely on getUnicodeChar() for+ * conversion of keyCode, for both hardware keyboard shift key (via effectiveMetaState) and+ * `mClient.readShiftKey()`, based on value in kcm files.+ * This may result in different behaviour depending on keyboard and android kcm files set for the+ * InputDevice for the event passed to this function. This will likely be an issue for non-english+ * languages since `Virtual.kcm` in english only by default or at least in AOSP. For both hardware+ * shift key (via effectiveMetaState) and `mClient.readShiftKey()`, `getUnicodeChar()` is used+ * for shift specific behaviour which usually is to uppercase.+ *+ * For fn key on hardware keyboard, android checks kcm files for hardware keyboards, which is+ * `Generic.kcm` by default, unless a vendor specific one is defined. The event passed will have+ * {@link KeyEvent#META_FUNCTION_ON} set. If the kcm file only defines a single character or unicode+ * code point `\\uxxxx`, then only one event is passed with that value. However, if kcm defines+ * a `fallback` key for fn or others, like `key DPAD_UP { ... fn: fallback PAGE_UP }`, then+ * android will first pass an event with original key `DPAD_UP` and {@link KeyEvent#META_FUNCTION_ON}+ * set. But this function will not consume it and android will pass another event with `PAGE_UP`+ * and {@link KeyEvent#META_FUNCTION_ON} not set, which will be consumed.+ *+ * Now there are some other issues as well, firstly ctrl and alt flags are not passed to+ * `getUnicodeChar()`, so modified key values in kcm are not used. Secondly, if the kcm file+ * for other modifiers like shift or fn define a non-alphabet, like { fn: '\u0015' } to act as+ * DPAD_LEFT, the `getUnicodeChar()` will correctly return `21` as the code point but action will+ * not happen because the `handleKeyCode()` function that transforms DPAD_LEFT to `\033[D`+ * escape sequence for the terminal to perform the left action would not be called since its+ * called before `getUnicodeChar()` and terminal will instead get `21 0x15 Negative Acknowledgement`.+ * The solution to such issues is calling `getUnicodeChar()` before the call to `handleKeyCode()`+ * if user has defined a custom kcm file, like done in POC mentioned in #2237. Note that+ * Hacker's Keyboard calls `commitText()` so don't test fn/shift with it for this function.+ * https://github.com/termux/termux-app/pull/2237+ * https://github.com/agnostic-apollo/termux-app/blob/terminal-code-point-custom-mapping/terminal-view/src/main/java/com/termux/view/TerminalView.java+ *+ * Key Character Map (kcm) and Key Layout (kl) files info:+ * https://source.android.com/devices/input/key-character-map-files+ * https://source.android.com/devices/input/key-layout-files+ * https://source.android.com/devices/input/keyboard-devices+ * AOSP kcm and kl files:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/data/keyboards+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/packages/InputDevices/res/raw+ *+ * KeyCodes:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/core/java/android/view/KeyEvent.java+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/native/include/android/keycodes.h+ *+ * `dumpsys input`:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/services/inputflinger/reader/EventHub.cpp;l=1917+ *+ * Loading of keymap:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/services/inputflinger/reader/EventHub.cpp;l=1644+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/Keyboard.cpp;l=41+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/InputDevice.cpp+ * OVERLAY keymaps for hardware keyboards may be combined as well:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/KeyCharacterMap.cpp;l=165+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/KeyCharacterMap.cpp;l=831+ *+ * Parse kcm file:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/KeyCharacterMap.cpp;l=727+ * Parse key value:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/KeyCharacterMap.cpp;l=981+ *+ * `KeyEvent.getUnicodeChar()`+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/core/java/android/view/KeyEvent.java;l=2716+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/view/KeyCharacterMap.java;l=368+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/core/jni/android_view_KeyCharacterMap.cpp;l=117+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/native/libs/input/KeyCharacterMap.cpp;l=231+ *+ * Keyboard layouts advertised by applications, like for hardware keyboards via #ACTION_QUERY_KEYBOARD_LAYOUTS+ * Config is stored in `/data/system/input-manager-state.xml`+ * https://github.com/ris58h/custom-keyboard-layout+ * Loading from apps:+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/input/InputManagerService.java;l=1221+ * Set:+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/core/java/android/hardware/input/InputManager.java;l=89+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/core/java/android/hardware/input/InputManager.java;l=543+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:packages/apps/Settings/src/com/android/settings/inputmethod/KeyboardLayoutDialogFragment.java;l=167+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/input/InputManagerService.java;l=1385+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/input/PersistentDataStore.java+ * Get overlay keyboard layout+ * https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/input/InputManagerService.java;l=2158+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r40:frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp;l=616+ */+ @Override+ public boolean onKeyDown(int keyCode, KeyEvent event) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logInfo(LOG_TAG, "onKeyDown(keyCode=" + keyCode + ", isSystem()=" + event.isSystem() + ", event=" + event + ")");+ if (mEmulator == null) return true;+ if (isSelectingText()) {+ stopTextSelectionMode();+ }++ if (mClient.onKeyDown(keyCode, event, mTermSession)) {+ invalidate();+ return true;+ } else if (event.isSystem() && (!mClient.shouldBackButtonBeMappedToEscape() || keyCode != KeyEvent.KEYCODE_BACK)) {+ return super.onKeyDown(keyCode, event);+ } else if (event.getAction() == KeyEvent.ACTION_MULTIPLE && keyCode == KeyEvent.KEYCODE_UNKNOWN) {+ mTermSession.write(event.getCharacters());+ return true;+ } else if (keyCode == KeyEvent.KEYCODE_LANGUAGE_SWITCH) {+ return super.onKeyDown(keyCode, event);+ }++ final int metaState = event.getMetaState();+ final boolean controlDown = event.isCtrlPressed() || mClient.readControlKey();+ final boolean leftAltDown = (metaState & KeyEvent.META_ALT_LEFT_ON) != 0 || mClient.readAltKey();+ final boolean shiftDown = event.isShiftPressed() || mClient.readShiftKey();+ final boolean rightAltDownFromEvent = (metaState & KeyEvent.META_ALT_RIGHT_ON) != 0;++ int keyMod = 0;+ if (controlDown) keyMod |= KeyHandler.KEYMOD_CTRL;+ if (event.isAltPressed() || leftAltDown) keyMod |= KeyHandler.KEYMOD_ALT;+ if (shiftDown) keyMod |= KeyHandler.KEYMOD_SHIFT;+ if (event.isNumLockOn()) keyMod |= KeyHandler.KEYMOD_NUM_LOCK;+ // https://github.com/termux/termux-app/issues/731+ if (!event.isFunctionPressed() && handleKeyCode(keyCode, keyMod)) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED) mClient.logInfo(LOG_TAG, "handleKeyCode() took key event");+ return true;+ }++ // Clear Ctrl since we handle that ourselves:+ int bitsToClear = KeyEvent.META_CTRL_MASK;+ if (rightAltDownFromEvent) {+ // Let right Alt/Alt Gr be used to compose characters.+ } else {+ // Use left alt to send to terminal (e.g. Left Alt+B to jump back a word), so remove:+ bitsToClear |= KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON;+ }+ int effectiveMetaState = event.getMetaState() & ~bitsToClear;++ if (shiftDown) effectiveMetaState |= KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON;+ if (mClient.readFnKey()) effectiveMetaState |= KeyEvent.META_FUNCTION_ON;++ int result = event.getUnicodeChar(effectiveMetaState);+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logInfo(LOG_TAG, "KeyEvent#getUnicodeChar(" + effectiveMetaState + ") returned: " + result);+ if (result == 0) {+ return false;+ }++ int oldCombiningAccent = mCombiningAccent;+ if ((result & KeyCharacterMap.COMBINING_ACCENT) != 0) {+ // If entered combining accent previously, write it out:+ if (mCombiningAccent != 0)+ inputCodePoint(event.getDeviceId(), mCombiningAccent, controlDown, leftAltDown);+ mCombiningAccent = result & KeyCharacterMap.COMBINING_ACCENT_MASK;+ } else {+ if (mCombiningAccent != 0) {+ int combinedChar = KeyCharacterMap.getDeadChar(mCombiningAccent, result);+ if (combinedChar > 0) result = combinedChar;+ mCombiningAccent = 0;+ }+ inputCodePoint(event.getDeviceId(), result, controlDown, leftAltDown);+ }++ if (mCombiningAccent != oldCombiningAccent) invalidate();++ return true;+ }++ public void inputCodePoint(int eventSource, int codePoint, boolean controlDownFromEvent, boolean leftAltDownFromEvent) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED) {+ mClient.logInfo(LOG_TAG, "inputCodePoint(eventSource=" + eventSource + ", codePoint=" + codePoint + ", controlDownFromEvent=" + controlDownFromEvent + ", leftAltDownFromEvent="+ + leftAltDownFromEvent + ")");+ }++ if (mTermSession == null) return;++ // Ensure cursor is shown when a key is pressed down like long hold on (arrow) keys+ if (mEmulator != null)+ mEmulator.setCursorBlinkState(true);++ final boolean controlDown = controlDownFromEvent || mClient.readControlKey();+ final boolean altDown = leftAltDownFromEvent || mClient.readAltKey();++ if (mClient.onCodePoint(codePoint, controlDown, mTermSession)) return;++ if (controlDown) {+ if (codePoint >= 'a' && codePoint <= 'z') {+ codePoint = codePoint - 'a' + 1;+ } else if (codePoint >= 'A' && codePoint <= 'Z') {+ codePoint = codePoint - 'A' + 1;+ } else if (codePoint == ' ' || codePoint == '2') {+ codePoint = 0;+ } else if (codePoint == '[' || codePoint == '3') {+ codePoint = 27; // ^[ (Esc)+ } else if (codePoint == '\\' || codePoint == '4') {+ codePoint = 28;+ } else if (codePoint == ']' || codePoint == '5') {+ codePoint = 29;+ } else if (codePoint == '^' || codePoint == '6') {+ codePoint = 30; // control-^+ } else if (codePoint == '_' || codePoint == '7' || codePoint == '/') {+ // "Ctrl-/ sends 0x1f which is equivalent of Ctrl-_ since the days of VT102"+ // - http://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal+ codePoint = 31;+ } else if (codePoint == '8') {+ codePoint = 127; // DEL+ }+ }++ if (codePoint > -1) {+ // If not virtual or soft keyboard.+ if (eventSource > KEY_EVENT_SOURCE_SOFT_KEYBOARD) {+ // Work around bluetooth keyboards sending funny unicode characters instead+ // of the more normal ones from ASCII that terminal programs expect - the+ // desire to input the original characters should be low.+ switch (codePoint) {+ case 0x02DC: // SMALL TILDE.+ codePoint = 0x007E; // TILDE (~).+ break;+ case 0x02CB: // MODIFIER LETTER GRAVE ACCENT.+ codePoint = 0x0060; // GRAVE ACCENT (`).+ break;+ case 0x02C6: // MODIFIER LETTER CIRCUMFLEX ACCENT.+ codePoint = 0x005E; // CIRCUMFLEX ACCENT (^).+ break;+ }+ }++ // If left alt, send escape before the code point to make e.g. Alt+B and Alt+F work in readline:+ mTermSession.writeCodePoint(altDown, codePoint);+ }+ }++ /** Input the specified keyCode if applicable and return if the input was consumed. */+ public boolean handleKeyCode(int keyCode, int keyMod) {+ // Ensure cursor is shown when a key is pressed down like long hold on (arrow) keys+ if (mEmulator != null)+ mEmulator.setCursorBlinkState(true);++ if (handleKeyCodeAction(keyCode, keyMod))+ return true;++ TerminalEmulator term = mTermSession.getEmulator();+ String code = KeyHandler.getCode(keyCode, keyMod, term.isCursorKeysApplicationMode(), term.isKeypadApplicationMode());+ if (code == null) return false;+ mTermSession.write(code);+ return true;+ }++ public boolean handleKeyCodeAction(int keyCode, int keyMod) {+ boolean shiftDown = (keyMod & KeyHandler.KEYMOD_SHIFT) != 0;++ switch (keyCode) {+ case KeyEvent.KEYCODE_PAGE_UP:+ case KeyEvent.KEYCODE_PAGE_DOWN:+ // shift+page_up and shift+page_down should scroll scrollback history instead of+ // scrolling command history or changing pages+ if (shiftDown) {+ long time = SystemClock.uptimeMillis();+ MotionEvent motionEvent = MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN, 0, 0, 0);+ doScroll(motionEvent, keyCode == KeyEvent.KEYCODE_PAGE_UP ? -mEmulator.mRows : mEmulator.mRows);+ motionEvent.recycle();+ return true;+ }+ }++ return false;+ }++ /**+ * Called when a key is released in the view.+ *+ * @param keyCode The keycode of the key which was released.+ * @param event A {@link KeyEvent} describing the event.+ * @return Whether the event was handled.+ */+ @Override+ public boolean onKeyUp(int keyCode, KeyEvent event) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logInfo(LOG_TAG, "onKeyUp(keyCode=" + keyCode + ", event=" + event + ")");++ // Do not return for KEYCODE_BACK and send it to the client since user may be trying+ // to exit the activity.+ if (mEmulator == null && keyCode != KeyEvent.KEYCODE_BACK) return true;++ if (mClient.onKeyUp(keyCode, event)) {+ invalidate();+ return true;+ } else if (event.isSystem()) {+ // Let system key events through.+ return super.onKeyUp(keyCode, event);+ }++ return true;+ }++ /**+ * This is called during layout when the size of this view has changed. If you were just added to the view+ * hierarchy, you're called with the old values of 0.+ */+ @Override+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {+ updateSize();+ }++ /** Check if the terminal size in rows and columns should be updated. */+ public void updateSize() {+ int viewWidth = getWidth();+ int viewHeight = getHeight();+ if (viewWidth == 0 || viewHeight == 0 || mTermSession == null) return;++ // Set to 80 and 24 if you want to enable vttest.+ int newColumns = Math.max(4, (int) (viewWidth / mRenderer.mFontWidth));+ int newRows = Math.max(4, (viewHeight - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing);++ if (mEmulator == null || (newColumns != mEmulator.mColumns || newRows != mEmulator.mRows)) {+ mTermSession.updateSize(newColumns, newRows, (int) mRenderer.getFontWidth(), mRenderer.getFontLineSpacing());+ mEmulator = mTermSession.getEmulator();+ mClient.onEmulatorSet();++ // Update mTerminalCursorBlinkerRunnable inner class mEmulator on session change+ if (mTerminalCursorBlinkerRunnable != null)+ mTerminalCursorBlinkerRunnable.setEmulator(mEmulator);++ mTopRow = 0;+ scrollTo(0, 0);+ invalidate();+ }+ }++ @Override+ protected void onDraw(Canvas canvas) {+ if (mEmulator == null) {+ canvas.drawColor(0XFF000000);+ } else {+ // render the terminal view and highlight any selected text+ int[] sel = mDefaultSelectors;+ if (mTextSelectionCursorController != null) {+ mTextSelectionCursorController.getSelectors(sel);+ }++ mRenderer.render(mEmulator, canvas, mTopRow, sel[0], sel[1], sel[2], sel[3]);++ // render the text selection handles+ renderTextSelection();+ }+ }++ public TerminalSession getCurrentSession() {+ return mTermSession;+ }++ /**+ * Look up an OSC 8 hyperlink URL at the given screen-pixel coordinates.+ * Returns null if no hyperlink is registered at that cell.+ */+ public String getHyperlinkAt(float x, float y) {+ if (mEmulator == null || mRenderer == null) return null;+ int col = (int) (x / mRenderer.mFontWidth);+ int row = (int) ((y - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing) + mTopRow;+ if (col < 0 || col >= mEmulator.mColumns || row < 0 || row >= mEmulator.mRows) return null;+ return mEmulator.getScreen().getHyperlinkAt(row, col);+ }++ private CharSequence getText() {+ return mEmulator.getScreen().getSelectedText(0, mTopRow, mEmulator.mColumns, mTopRow + mEmulator.mRows);+ }++ public int getCursorX(float x) {+ return (int) (x / mRenderer.mFontWidth);+ }++ public int getCursorY(float y) {+ return (int) (((y - 40) / mRenderer.mFontLineSpacing) + mTopRow);+ }++ public int getPointX(int cx) {+ if (cx > mEmulator.mColumns) {+ cx = mEmulator.mColumns;+ }+ return Math.round(cx * mRenderer.mFontWidth);+ }++ public int getPointY(int cy) {+ return Math.round((cy - mTopRow) * mRenderer.mFontLineSpacing);+ }++ public int getTopRow() {+ return mTopRow;+ }++ public void setTopRow(int mTopRow) {+ this.mTopRow = mTopRow;+ }++++ /**+ * Define functions required for AutoFill API+ */+ @RequiresApi(api = Build.VERSION_CODES.O)+ @Override+ public void autofill(AutofillValue value) {+ if (value.isText()) {+ mTermSession.write(value.getTextValue().toString());+ }++ resetAutoFill();+ }++ @RequiresApi(api = Build.VERSION_CODES.O)+ @Override+ public int getAutofillType() {+ return mAutoFillType;+ }++ @RequiresApi(api = Build.VERSION_CODES.O)+ @Override+ public String[] getAutofillHints() {+ return mAutoFillHints;+ }++ @RequiresApi(api = Build.VERSION_CODES.O)+ @Override+ public AutofillValue getAutofillValue() {+ return AutofillValue.forText("");+ }++ @RequiresApi(api = Build.VERSION_CODES.O)+ @Override+ public int getImportantForAutofill() {+ return mAutoFillImportance;+ }++ @RequiresApi(api = Build.VERSION_CODES.O)+ private synchronized void resetAutoFill() {+ // Restore none type so that AutoFill UI isn't shown anymore.+ mAutoFillType = AUTOFILL_TYPE_NONE;+ mAutoFillImportance = IMPORTANT_FOR_AUTOFILL_NO;+ mAutoFillHints = new String[0];+ }++ public AutofillManager getAutoFillManagerService() {+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return null;++ try {+ Context context = getContext();+ if (context == null) return null;+ return context.getSystemService(AutofillManager.class);+ } catch (Exception e) {+ mClient.logStackTraceWithMessage(LOG_TAG, "Failed to get AutofillManager service", e);+ return null;+ }+ }++ public boolean isAutoFillEnabled() {+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;++ try {+ AutofillManager autofillManager = getAutoFillManagerService();+ return autofillManager != null && autofillManager.isEnabled();+ } catch (Exception e) {+ mClient.logStackTraceWithMessage(LOG_TAG, "Failed to check if Autofill is enabled", e);+ return false;+ }+ }++ public synchronized void requestAutoFillUsername() {+ requestAutoFill(+ Build.VERSION.SDK_INT >= Build.VERSION_CODES.O ? new String[]{View.AUTOFILL_HINT_USERNAME} :+ null);+ }++ public synchronized void requestAutoFillPassword() {+ requestAutoFill(+ Build.VERSION.SDK_INT >= Build.VERSION_CODES.O ? new String[]{View.AUTOFILL_HINT_PASSWORD} :+ null);+ }++ public synchronized void requestAutoFill(String[] autoFillHints) {+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return;+ if (autoFillHints == null || autoFillHints.length < 1) return;++ try {+ AutofillManager autofillManager = getAutoFillManagerService();+ if (autofillManager != null && autofillManager.isEnabled()) {+ // Update type that will be returned by `getAutofillType()` so that AutoFill UI is shown.+ mAutoFillType = AUTOFILL_TYPE_TEXT;+ // Update importance that will be returned by `getImportantForAutofill()` so that+ // AutoFill considers the view as important.+ mAutoFillImportance = IMPORTANT_FOR_AUTOFILL_YES;+ // Update hints that will be returned by `getAutofillHints()` for which to show AutoFill UI.+ mAutoFillHints = autoFillHints;+ autofillManager.requestAutofill(this);+ }+ } catch (Exception e) {+ mClient.logStackTraceWithMessage(LOG_TAG, "Failed to request Autofill", e);+ }+ }++ public synchronized void cancelRequestAutoFill() {+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return;+ if (mAutoFillType == AUTOFILL_TYPE_NONE) return;++ try {+ AutofillManager autofillManager = getAutoFillManagerService();+ if (autofillManager != null && autofillManager.isEnabled()) {+ resetAutoFill();+ autofillManager.cancel();+ }+ } catch (Exception e) {+ mClient.logStackTraceWithMessage(LOG_TAG, "Failed to cancel Autofill request", e);+ }+ }++++++ /**+ * Set terminal cursor blinker rate. It must be between {@link #TERMINAL_CURSOR_BLINK_RATE_MIN}+ * and {@link #TERMINAL_CURSOR_BLINK_RATE_MAX}, otherwise it will be disabled.+ *+ * The {@link #setTerminalCursorBlinkerState(boolean, boolean)} must be called after this+ * for changes to take effect if not disabling.+ *+ * @param blinkRate The value to set.+ * @return Returns {@code true} if setting blinker rate was successfully set, otherwise [@code false}.+ */+ public synchronized boolean setTerminalCursorBlinkerRate(int blinkRate) {+ boolean result;++ // If cursor blinking rate is not valid+ if (blinkRate != 0 && (blinkRate < TERMINAL_CURSOR_BLINK_RATE_MIN || blinkRate > TERMINAL_CURSOR_BLINK_RATE_MAX)) {+ mClient.logError(LOG_TAG, "The cursor blink rate must be in between " + TERMINAL_CURSOR_BLINK_RATE_MIN + "-" + TERMINAL_CURSOR_BLINK_RATE_MAX + ": " + blinkRate);+ mTerminalCursorBlinkerRate = 0;+ result = false;+ } else {+ mClient.logVerbose(LOG_TAG, "Setting cursor blinker rate to " + blinkRate);+ mTerminalCursorBlinkerRate = blinkRate;+ result = true;+ }++ if (mTerminalCursorBlinkerRate == 0) {+ mClient.logVerbose(LOG_TAG, "Cursor blinker disabled");+ stopTerminalCursorBlinker();+ }++ return result;+ }++ /**+ * Sets whether cursor blinker should be started or stopped. Cursor blinker will only be+ * started if {@link #mTerminalCursorBlinkerRate} does not equal 0 and is between+ * {@link #TERMINAL_CURSOR_BLINK_RATE_MIN} and {@link #TERMINAL_CURSOR_BLINK_RATE_MAX}.+ *+ * This should be called when the view holding this activity is resumed or stopped so that+ * cursor blinker does not run when activity is not visible. If you call this on onResume()+ * to start cursor blinking, then ensure that {@link #mEmulator} is set, otherwise wait for the+ * {@link TerminalViewClient#onEmulatorSet()} event after calling {@link #attachSession(TerminalSession)}+ * for the first session added in the activity since blinking will not start if {@link #mEmulator}+ * is not set, like if activity is started again after exiting it with double back press. Do not+ * call this directly after {@link #attachSession(TerminalSession)} since {@link #updateSize()}+ * may return without setting {@link #mEmulator} since width/height may be 0. Its called again in+ * {@link #onSizeChanged(int, int, int, int)}. Calling on onResume() if emulator is already set+ * is necessary, since onEmulatorSet() may not be called after activity is started after device+ * display timeout with double tap and not power button.+ *+ * It should also be called on the+ * {@link com.termux.terminal.TerminalSessionClient#onTerminalCursorStateChange(boolean)}+ * callback when cursor is enabled or disabled so that blinker is disabled if cursor is not+ * to be shown. It should also be checked if activity is visible if blinker is to be started+ * before calling this.+ *+ * It should also be called after terminal is reset with {@link TerminalSession#reset()} in case+ * cursor blinker was disabled before reset due to call to+ * {@link com.termux.terminal.TerminalSessionClient#onTerminalCursorStateChange(boolean)}.+ *+ * How cursor blinker starting works is by registering a {@link Runnable} with the looper of+ * the main thread of the app which when run, toggles the cursor blinking state and re-registers+ * itself to be called with the delay set by {@link #mTerminalCursorBlinkerRate}. When cursor+ * blinking needs to be disabled, we just cancel any callbacks registered. We don't run our own+ * "thread" and let the thread for the main looper do the work for us, whose usage is also+ * required to update the UI, since it also handles other calls to update the UI as well based+ * on a queue.+ *+ * Note that when moving cursor in text editors like nano, the cursor state is quickly+ * toggled `-> off -> on`, which would call this very quickly sequentially. So that if cursor+ * is moved 2 or more times quickly, like long hold on arrow keys, it would trigger+ * `-> off -> on -> off -> on -> ...`, and the "on" callback at index 2 is automatically+ * cancelled by next "off" callback at index 3 before getting a chance to be run. For this case+ * we log only if {@link #TERMINAL_VIEW_KEY_LOGGING_ENABLED} is enabled, otherwise would clutter+ * the log. We don't start the blinking with a delay to immediately show cursor in case it was+ * previously not visible.+ *+ * @param start If cursor blinker should be started or stopped.+ * @param startOnlyIfCursorEnabled If set to {@code true}, then it will also be checked if the+ * cursor is even enabled by {@link TerminalEmulator} before+ * starting the cursor blinker.+ */+ public synchronized void setTerminalCursorBlinkerState(boolean start, boolean startOnlyIfCursorEnabled) {+ // Stop any existing cursor blinker callbacks+ stopTerminalCursorBlinker();++ if (mEmulator == null) return;++ mEmulator.setCursorBlinkingEnabled(false);++ if (start) {+ // If cursor blinker is not enabled or is not valid+ if (mTerminalCursorBlinkerRate < TERMINAL_CURSOR_BLINK_RATE_MIN || mTerminalCursorBlinkerRate > TERMINAL_CURSOR_BLINK_RATE_MAX)+ return;+ // If cursor blinder is to be started only if cursor is enabled+ else if (startOnlyIfCursorEnabled && ! mEmulator.isCursorEnabled()) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logVerbose(LOG_TAG, "Ignoring call to start cursor blinker since cursor is not enabled");+ return;+ }++ // Start cursor blinker runnable+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logVerbose(LOG_TAG, "Starting cursor blinker with the blink rate " + mTerminalCursorBlinkerRate);+ if (mTerminalCursorBlinkerHandler == null)+ mTerminalCursorBlinkerHandler = new Handler(Looper.getMainLooper());+ mTerminalCursorBlinkerRunnable = new TerminalCursorBlinkerRunnable(mEmulator, mTerminalCursorBlinkerRate);+ mEmulator.setCursorBlinkingEnabled(true);+ mTerminalCursorBlinkerRunnable.run();+ }+ }++ /**+ * Cancel the terminal cursor blinker callbacks+ */+ private void stopTerminalCursorBlinker() {+ if (mTerminalCursorBlinkerHandler != null && mTerminalCursorBlinkerRunnable != null) {+ if (TERMINAL_VIEW_KEY_LOGGING_ENABLED)+ mClient.logVerbose(LOG_TAG, "Stopping cursor blinker");+ mTerminalCursorBlinkerHandler.removeCallbacks(mTerminalCursorBlinkerRunnable);+ }+ }++ private class TerminalCursorBlinkerRunnable implements Runnable {++ private TerminalEmulator mEmulator;+ private final int mBlinkRate;++ // Initialize with false so that initial blink state is visible after toggling+ boolean mCursorVisible = false;++ public TerminalCursorBlinkerRunnable(TerminalEmulator emulator, int blinkRate) {+ mEmulator = emulator;+ mBlinkRate = blinkRate;+ }++ public void setEmulator(TerminalEmulator emulator) {+ mEmulator = emulator;+ }++ public void run() {+ try {+ if (mEmulator != null) {+ // Toggle the blink state and then invalidate() the view so+ // that onDraw() is called, which then calls TerminalRenderer.render()+ // which checks with TerminalEmulator.shouldCursorBeVisible() to decide whether+ // to draw the cursor or not+ mCursorVisible = !mCursorVisible;+ //mClient.logVerbose(LOG_TAG, "Toggling cursor blink state to " + mCursorVisible);+ mEmulator.setCursorBlinkState(mCursorVisible);+ invalidate();+ }+ } finally {+ // Recall the Runnable after mBlinkRate milliseconds to toggle the blink state+ mTerminalCursorBlinkerHandler.postDelayed(this, mBlinkRate);+ }+ }+ }++++ /**+ * Define functions required for text selection and its handles.+ */+ TextSelectionCursorController getTextSelectionCursorController() {+ if (mTextSelectionCursorController == null) {+ mTextSelectionCursorController = new TextSelectionCursorController(this);++ final ViewTreeObserver observer = getViewTreeObserver();+ if (observer != null) {+ observer.addOnTouchModeChangeListener(mTextSelectionCursorController);+ }+ }++ return mTextSelectionCursorController;+ }++ private void showTextSelectionCursors(MotionEvent event) {+ getTextSelectionCursorController().show(event);+ }++ private boolean hideTextSelectionCursors() {+ return getTextSelectionCursorController().hide();+ }++ private void renderTextSelection() {+ if (mTextSelectionCursorController != null)+ mTextSelectionCursorController.render();+ }++ public boolean isSelectingText() {+ if (mTextSelectionCursorController != null) {+ return mTextSelectionCursorController.isActive();+ } else {+ return false;+ }+ }++ /** Get the currently selected text if selecting. */+ public String getSelectedText() {+ if (isSelectingText() && mTextSelectionCursorController != null)+ return mTextSelectionCursorController.getSelectedText();+ else+ return null;+ }++ /** Get the selected text stored before "MORE" button was pressed on the context menu. */+ @Nullable+ public String getStoredSelectedText() {+ return mTextSelectionCursorController != null ? mTextSelectionCursorController.getStoredSelectedText() : null;+ }++ /** Unset the selected text stored before "MORE" button was pressed on the context menu. */+ public void unsetStoredSelectedText() {+ if (mTextSelectionCursorController != null) mTextSelectionCursorController.unsetStoredSelectedText();+ }++ private ActionMode getTextSelectionActionMode() {+ if (mTextSelectionCursorController != null) {+ return mTextSelectionCursorController.getActionMode();+ } else {+ return null;+ }+ }++ public void startTextSelectionMode(MotionEvent event) {+ if (!requestFocus()) {+ return;+ }++ showTextSelectionCursors(event);+ mClient.copyModeChanged(isSelectingText());++ invalidate();+ }++ public void stopTextSelectionMode() {+ if (hideTextSelectionCursors()) {+ mClient.copyModeChanged(isSelectingText());+ invalidate();+ }+ }++ private void decrementYTextSelectionCursors(int decrement) {+ if (mTextSelectionCursorController != null) {+ mTextSelectionCursorController.decrementYTextSelectionCursors(decrement);+ }+ }++ @Override+ protected void onAttachedToWindow() {+ super.onAttachedToWindow();++ if (mTextSelectionCursorController != null) {+ getViewTreeObserver().addOnTouchModeChangeListener(mTextSelectionCursorController);+ }+ }++ @Override+ protected void onDetachedFromWindow() {+ super.onDetachedFromWindow();++ if (mTextSelectionCursorController != null) {+ // Might solve the following exception+ // android.view.WindowLeaked: Activity com.termux.app.TermuxActivity has leaked window android.widget.PopupWindow+ stopTextSelectionMode();++ getViewTreeObserver().removeOnTouchModeChangeListener(mTextSelectionCursorController);+ mTextSelectionCursorController.onDetached();+ }+ }++++ /**+ * Define functions required for long hold toolbar.+ */+ private final Runnable mShowFloatingToolbar = new Runnable() {+ @RequiresApi(api = Build.VERSION_CODES.M)+ @Override+ public void run() {+ if (getTextSelectionActionMode() != null) {+ getTextSelectionActionMode().hide(0); // hide off.+ }+ }+ };++ @RequiresApi(api = Build.VERSION_CODES.M)+ private void showFloatingToolbar() {+ if (getTextSelectionActionMode() != null) {+ int delay = ViewConfiguration.getDoubleTapTimeout();+ postDelayed(mShowFloatingToolbar, delay);+ }+ }++ @RequiresApi(api = Build.VERSION_CODES.M)+ void hideFloatingToolbar() {+ if (getTextSelectionActionMode() != null) {+ removeCallbacks(mShowFloatingToolbar);+ getTextSelectionActionMode().hide(-1);+ }+ }++ public void updateFloatingToolbarVisibility(MotionEvent event) {+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && getTextSelectionActionMode() != null) {+ switch (event.getActionMasked()) {+ case MotionEvent.ACTION_MOVE:+ hideFloatingToolbar();+ break;+ case MotionEvent.ACTION_UP: // fall through+ case MotionEvent.ACTION_CANCEL:+ showFloatingToolbar();+ }+ }+ }++}diff --git a/terminal-view/src/main/java/com/termux/view/TerminalViewClient.java b/terminal-view/src/main/java/com/termux/view/TerminalViewClient.javanew file mode 100644index 0000000..d6b49b8--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/TerminalViewClient.java@@ -0,0 +1,83 @@+package com.termux.view;++import android.view.KeyEvent;+import android.view.MotionEvent;+import android.view.ScaleGestureDetector;+import android.view.View;++import com.termux.terminal.TerminalSession;++/**+ * The interface for communication between {@link TerminalView} and its client. It allows for getting+ * various configuration options from the client and for sending back data to the client like logs,+ * key events, both hardware and IME (which makes it different from that available with+ * {@link View#setOnKeyListener(View.OnKeyListener)}, etc. It must be set for the+ * {@link TerminalView} through {@link TerminalView#setTerminalViewClient(TerminalViewClient)}.+ */+public interface TerminalViewClient {++ /**+ * Callback function on scale events according to {@link ScaleGestureDetector#getScaleFactor()}.+ */+ float onScale(float scale);++++ /**+ * On a single tap on the terminal if terminal mouse reporting not enabled.+ */+ void onSingleTapUp(MotionEvent e);++ boolean shouldBackButtonBeMappedToEscape();++ boolean shouldEnforceCharBasedInput();++ boolean shouldUseCtrlSpaceWorkaround();++ boolean isTerminalViewSelected();++++ void copyModeChanged(boolean copyMode);++++ boolean onKeyDown(int keyCode, KeyEvent e, TerminalSession session);++ boolean onKeyUp(int keyCode, KeyEvent e);++ boolean onLongPress(MotionEvent event);++++ boolean readControlKey();++ boolean readAltKey();++ boolean readShiftKey();++ boolean readFnKey();++++ boolean onCodePoint(int codePoint, boolean ctrlDown, TerminalSession session);+++ void onEmulatorSet();+++ void logError(String tag, String message);++ void logWarn(String tag, String message);++ void logInfo(String tag, String message);++ void logDebug(String tag, String message);++ void logVerbose(String tag, String message);++ void logStackTraceWithMessage(String tag, String message, Exception e);++ void logStackTrace(String tag, Exception e);++}diff --git a/terminal-view/src/main/java/com/termux/view/support/PopupWindowCompatGingerbread.java b/terminal-view/src/main/java/com/termux/view/support/PopupWindowCompatGingerbread.javanew file mode 100644index 0000000..24a1797--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/support/PopupWindowCompatGingerbread.java@@ -0,0 +1,75 @@+/*+ * Copyright (C) 2015 The Android Open Source Project+ *+ * 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 com.termux.view.support;++import android.util.Log;+import android.widget.PopupWindow;++import java.lang.reflect.Method;++/**+ * Implementation of PopupWindow compatibility that can call Gingerbread APIs.+ * https://chromium.googlesource.com/android_tools/+/HEAD/sdk/extras/android/support/v4/src/gingerbread/android/support/v4/widget/PopupWindowCompatGingerbread.java+ */+public class PopupWindowCompatGingerbread {++ private static Method sSetWindowLayoutTypeMethod;+ private static boolean sSetWindowLayoutTypeMethodAttempted;+ private static Method sGetWindowLayoutTypeMethod;+ private static boolean sGetWindowLayoutTypeMethodAttempted;++ public static void setWindowLayoutType(PopupWindow popupWindow, int layoutType) {+ if (!sSetWindowLayoutTypeMethodAttempted) {+ try {+ sSetWindowLayoutTypeMethod = PopupWindow.class.getDeclaredMethod(+ "setWindowLayoutType", int.class);+ sSetWindowLayoutTypeMethod.setAccessible(true);+ } catch (Exception e) {+ // Reflection method fetch failed. Oh well.+ }+ sSetWindowLayoutTypeMethodAttempted = true;+ }+ if (sSetWindowLayoutTypeMethod != null) {+ try {+ sSetWindowLayoutTypeMethod.invoke(popupWindow, layoutType);+ } catch (Exception e) {+ // Reflection call failed. Oh well.+ }+ }+ }++ public static int getWindowLayoutType(PopupWindow popupWindow) {+ if (!sGetWindowLayoutTypeMethodAttempted) {+ try {+ sGetWindowLayoutTypeMethod = PopupWindow.class.getDeclaredMethod(+ "getWindowLayoutType");+ sGetWindowLayoutTypeMethod.setAccessible(true);+ } catch (Exception e) {+ // Reflection method fetch failed. Oh well.+ }+ sGetWindowLayoutTypeMethodAttempted = true;+ }+ if (sGetWindowLayoutTypeMethod != null) {+ try {+ return (Integer) sGetWindowLayoutTypeMethod.invoke(popupWindow);+ } catch (Exception e) {+ // Reflection call failed. Oh well.+ }+ }+ return 0;+ }++}diff --git a/terminal-view/src/main/java/com/termux/view/textselection/CursorController.java b/terminal-view/src/main/java/com/termux/view/textselection/CursorController.javanew file mode 100644index 0000000..f0e1cc5--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/textselection/CursorController.java@@ -0,0 +1,55 @@+package com.termux.view.textselection;++import android.view.MotionEvent;+import android.view.ViewTreeObserver;++import com.termux.view.TerminalView;++/**+ * A CursorController instance can be used to control cursors in the text.+ * It is not used outside of {@link TerminalView}.+ */+public interface CursorController extends ViewTreeObserver.OnTouchModeChangeListener {+ /**+ * Show the cursors on screen. Will be drawn by {@link #render()} by a call during onDraw.+ * See also {@link #hide()}.+ */+ void show(MotionEvent event);++ /**+ * Hide the cursors from screen.+ * See also {@link #show(MotionEvent event)}.+ */+ boolean hide();++ /**+ * Render the cursors.+ */+ void render();++ /**+ * Update the cursor positions.+ */+ void updatePosition(TextSelectionHandleView handle, int x, int y);++ /**+ * This method is called by {@link #onTouchEvent(MotionEvent)} and gives the cursors+ * a chance to become active and/or visible.+ *+ * @param event The touch event+ */+ boolean onTouchEvent(MotionEvent event);++ /**+ * Called when the view is detached from window. Perform house keeping task, such as+ * stopping Runnable thread that would otherwise keep a reference on the context, thus+ * preventing the activity to be recycled.+ */+ void onDetached();++ /**+ * @return true if the cursors are currently active.+ */+ boolean isActive();++}diff --git a/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionCursorController.java b/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionCursorController.javanew file mode 100644index 0000000..c2cd7c6--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionCursorController.java@@ -0,0 +1,407 @@+package com.termux.view.textselection;++import android.content.ClipboardManager;+import android.content.Context;+import android.graphics.Rect;+import android.os.Build;+import android.text.TextUtils;+import android.view.ActionMode;+import android.view.Menu;+import android.view.MenuItem;+import android.view.MotionEvent;+import android.view.View;++import androidx.annotation.Nullable;++import com.termux.terminal.TerminalBuffer;+import com.termux.terminal.WcWidth;+import com.termux.view.R;+import com.termux.view.TerminalView;++public class TextSelectionCursorController implements CursorController {++ private final TerminalView terminalView;+ private final TextSelectionHandleView mStartHandle, mEndHandle;+ private String mStoredSelectedText;+ private boolean mIsSelectingText = false;+ private long mShowStartTime = System.currentTimeMillis();++ private final int mHandleHeight;+ private int mSelX1 = -1, mSelX2 = -1, mSelY1 = -1, mSelY2 = -1;++ private ActionMode mActionMode;+ public final int ACTION_COPY = 1;+ public final int ACTION_PASTE = 2;+ public final int ACTION_MORE = 3;++ public TextSelectionCursorController(TerminalView terminalView) {+ this.terminalView = terminalView;+ mStartHandle = new TextSelectionHandleView(terminalView, this, TextSelectionHandleView.LEFT);+ mEndHandle = new TextSelectionHandleView(terminalView, this, TextSelectionHandleView.RIGHT);++ mHandleHeight = Math.max(mStartHandle.getHandleHeight(), mEndHandle.getHandleHeight());+ }++ @Override+ public void show(MotionEvent event) {+ setInitialTextSelectionPosition(event);+ mStartHandle.positionAtCursor(mSelX1, mSelY1, true);+ mEndHandle.positionAtCursor(mSelX2 + 1, mSelY2, true);++ setActionModeCallBacks();+ mShowStartTime = System.currentTimeMillis();+ mIsSelectingText = true;+ }++ @Override+ public boolean hide() {+ if (!isActive()) return false;++ // prevent hide calls right after a show call, like long pressing the down key+ // 300ms seems long enough that it wouldn't cause hide problems if action button+ // is quickly clicked after the show, otherwise decrease it+ if (System.currentTimeMillis() - mShowStartTime < 300) {+ return false;+ }++ mStartHandle.hide();+ mEndHandle.hide();++ if (mActionMode != null) {+ // This will hide the TextSelectionCursorController+ mActionMode.finish();+ }++ mSelX1 = mSelY1 = mSelX2 = mSelY2 = -1;+ mIsSelectingText = false;++ return true;+ }++ @Override+ public void render() {+ if (!isActive()) return;++ mStartHandle.positionAtCursor(mSelX1, mSelY1, false);+ mEndHandle.positionAtCursor(mSelX2 + 1, mSelY2, false);++ if (mActionMode != null) {+ mActionMode.invalidate();+ }+ }++ public void setInitialTextSelectionPosition(MotionEvent event) {+ int[] columnAndRow = terminalView.getColumnAndRow(event, true);+ mSelX1 = mSelX2 = columnAndRow[0];+ mSelY1 = mSelY2 = columnAndRow[1];++ TerminalBuffer screen = terminalView.mEmulator.getScreen();+ if (!" ".equals(screen.getSelectedText(mSelX1, mSelY1, mSelX1, mSelY1))) {+ // Selecting something other than whitespace. Expand to word.+ while (mSelX1 > 0 && !"".equals(screen.getSelectedText(mSelX1 - 1, mSelY1, mSelX1 - 1, mSelY1))) {+ mSelX1--;+ }+ while (mSelX2 < terminalView.mEmulator.mColumns - 1 && !"".equals(screen.getSelectedText(mSelX2 + 1, mSelY1, mSelX2 + 1, mSelY1))) {+ mSelX2++;+ }+ }+ }++ public void setActionModeCallBacks() {+ final ActionMode.Callback callback = new ActionMode.Callback() {+ @Override+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {+ int show = MenuItem.SHOW_AS_ACTION_IF_ROOM | MenuItem.SHOW_AS_ACTION_WITH_TEXT;++ ClipboardManager clipboard = (ClipboardManager) terminalView.getContext().getSystemService(Context.CLIPBOARD_SERVICE);+ menu.add(Menu.NONE, ACTION_COPY, Menu.NONE, R.string.copy_text).setShowAsAction(show);+ menu.add(Menu.NONE, ACTION_PASTE, Menu.NONE, R.string.paste_text).setEnabled(clipboard != null && clipboard.hasPrimaryClip()).setShowAsAction(show);+ menu.add(Menu.NONE, ACTION_MORE, Menu.NONE, R.string.text_selection_more);+ return true;+ }++ @Override+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {+ return false;+ }++ @Override+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {+ if (!isActive()) {+ // Fix issue where the dialog is pressed while being dismissed.+ return true;+ }++ switch (item.getItemId()) {+ case ACTION_COPY:+ String selectedText = getSelectedText();+ terminalView.mTermSession.onCopyTextToClipboard(selectedText);+ terminalView.stopTextSelectionMode();+ break;+ case ACTION_PASTE:+ terminalView.stopTextSelectionMode();+ terminalView.mTermSession.onPasteTextFromClipboard();+ break;+ case ACTION_MORE:+ // We first store the selected text in case TerminalViewClient needs the+ // selected text before MORE button was pressed since we are going to+ // stop selection mode+ mStoredSelectedText = getSelectedText();+ // The text selection needs to be stopped before showing context menu,+ // otherwise handles will show above popup+ terminalView.stopTextSelectionMode();+ terminalView.showContextMenu();+ break;+ }++ return true;+ }++ @Override+ public void onDestroyActionMode(ActionMode mode) {+ }++ };++ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {+ mActionMode = terminalView.startActionMode(callback);+ return;+ }++ //noinspection NewApi+ mActionMode = terminalView.startActionMode(new ActionMode.Callback2() {+ @Override+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {+ return callback.onCreateActionMode(mode, menu);+ }++ @Override+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {+ return false;+ }++ @Override+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {+ return callback.onActionItemClicked(mode, item);+ }++ @Override+ public void onDestroyActionMode(ActionMode mode) {+ // Ignore.+ }++ @Override+ public void onGetContentRect(ActionMode mode, View view, Rect outRect) {+ int x1 = Math.round(mSelX1 * terminalView.mRenderer.getFontWidth());+ int x2 = Math.round(mSelX2 * terminalView.mRenderer.getFontWidth());+ int y1 = Math.round((mSelY1 - 1 - terminalView.getTopRow()) * terminalView.mRenderer.getFontLineSpacing());+ int y2 = Math.round((mSelY2 + 1 - terminalView.getTopRow()) * terminalView.mRenderer.getFontLineSpacing());++ if (x1 > x2) {+ int tmp = x1;+ x1 = x2;+ x2 = tmp;+ }++ int terminalBottom = terminalView.getBottom();+ int top = y1 + mHandleHeight;+ int bottom = y2 + mHandleHeight;+ if (top > terminalBottom) top = terminalBottom;+ if (bottom > terminalBottom) bottom = terminalBottom;++ outRect.set(x1, top, x2, bottom);+ }+ }, ActionMode.TYPE_FLOATING);+ }++ @Override+ public void updatePosition(TextSelectionHandleView handle, int x, int y) {+ TerminalBuffer screen = terminalView.mEmulator.getScreen();+ final int scrollRows = screen.getActiveRows() - terminalView.mEmulator.mRows;+ if (handle == mStartHandle) {+ mSelX1 = terminalView.getCursorX(x);+ mSelY1 = terminalView.getCursorY(y);+ if (mSelX1 < 0) {+ mSelX1 = 0;+ }++ if (mSelY1 < -scrollRows) {+ mSelY1 = -scrollRows;++ } else if (mSelY1 > terminalView.mEmulator.mRows - 1) {+ mSelY1 = terminalView.mEmulator.mRows - 1;++ }++ if (mSelY1 > mSelY2) {+ mSelY1 = mSelY2;+ }+ if (mSelY1 == mSelY2 && mSelX1 > mSelX2) {+ mSelX1 = mSelX2;+ }++ if (!terminalView.mEmulator.isAlternateBufferActive()) {+ int topRow = terminalView.getTopRow();++ if (mSelY1 <= topRow) {+ topRow--;+ if (topRow < -scrollRows) {+ topRow = -scrollRows;+ }+ } else if (mSelY1 >= topRow + terminalView.mEmulator.mRows) {+ topRow++;+ if (topRow > 0) {+ topRow = 0;+ }+ }++ terminalView.setTopRow(topRow);+ }++ mSelX1 = getValidCurX(screen, mSelY1, mSelX1);++ } else {+ mSelX2 = terminalView.getCursorX(x);+ mSelY2 = terminalView.getCursorY(y);+ if (mSelX2 < 0) {+ mSelX2 = 0;+ }++ if (mSelY2 < -scrollRows) {+ mSelY2 = -scrollRows;+ } else if (mSelY2 > terminalView.mEmulator.mRows - 1) {+ mSelY2 = terminalView.mEmulator.mRows - 1;+ }++ if (mSelY1 > mSelY2) {+ mSelY2 = mSelY1;+ }+ if (mSelY1 == mSelY2 && mSelX1 > mSelX2) {+ mSelX2 = mSelX1;+ }++ if (!terminalView.mEmulator.isAlternateBufferActive()) {+ int topRow = terminalView.getTopRow();++ if (mSelY2 <= topRow) {+ topRow--;+ if (topRow < -scrollRows) {+ topRow = -scrollRows;+ }+ } else if (mSelY2 >= topRow + terminalView.mEmulator.mRows) {+ topRow++;+ if (topRow > 0) {+ topRow = 0;+ }+ }++ terminalView.setTopRow(topRow);+ }++ mSelX2 = getValidCurX(screen, mSelY2, mSelX2);+ }++ terminalView.invalidate();+ }++ private int getValidCurX(TerminalBuffer screen, int cy, int cx) {+ String line = screen.getSelectedText(0, cy, cx, cy);+ if (!TextUtils.isEmpty(line)) {+ int col = 0;+ for (int i = 0, len = line.length(); i < len; i++) {+ char ch1 = line.charAt(i);+ if (ch1 == 0) {+ break;+ }++ int wc;+ if (Character.isHighSurrogate(ch1) && i + 1 < len) {+ char ch2 = line.charAt(++i);+ wc = WcWidth.width(Character.toCodePoint(ch1, ch2));+ } else {+ wc = WcWidth.width(ch1);+ }++ final int cend = col + wc;+ if (cx > col && cx < cend) {+ return cend;+ }+ if (cend == col) {+ return col;+ }+ col = cend;+ }+ }+ return cx;+ }++ public void decrementYTextSelectionCursors(int decrement) {+ mSelY1 -= decrement;+ mSelY2 -= decrement;+ }++ public boolean onTouchEvent(MotionEvent event) {+ return false;+ }++ public void onTouchModeChanged(boolean isInTouchMode) {+ if (!isInTouchMode) {+ terminalView.stopTextSelectionMode();+ }+ }++ @Override+ public void onDetached() {+ }++ @Override+ public boolean isActive() {+ return mIsSelectingText;+ }++ public void getSelectors(int[] sel) {+ if (sel == null || sel.length != 4) {+ return;+ }++ sel[0] = mSelY1;+ sel[1] = mSelY2;+ sel[2] = mSelX1;+ sel[3] = mSelX2;+ }++ /** Get the currently selected text. */+ public String getSelectedText() {+ return terminalView.mEmulator.getSelectedText(mSelX1, mSelY1, mSelX2, mSelY2);+ }++ /** Get the selected text stored before "MORE" button was pressed on the context menu. */+ @Nullable+ public String getStoredSelectedText() {+ return mStoredSelectedText;+ }++ /** Unset the selected text stored before "MORE" button was pressed on the context menu. */+ public void unsetStoredSelectedText() {+ mStoredSelectedText = null;+ }++ public ActionMode getActionMode() {+ return mActionMode;+ }++ /**+ * @return true if this controller is currently used to move the start selection.+ */+ public boolean isSelectionStartDragged() {+ return mStartHandle.isDragging();+ }++ /**+ * @return true if this controller is currently used to move the end selection.+ */+ public boolean isSelectionEndDragged() {+ return mEndHandle.isDragging();+ }++}diff --git a/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionHandleView.java b/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionHandleView.javanew file mode 100644index 0000000..b3caca6--- /dev/null+++ b/terminal-view/src/main/java/com/termux/view/textselection/TextSelectionHandleView.java@@ -0,0 +1,352 @@+package com.termux.view.textselection;++import android.annotation.SuppressLint;+import android.graphics.Canvas;+import android.graphics.Rect;+import android.graphics.drawable.Drawable;+import android.os.Build;+import android.os.SystemClock;+import android.view.MotionEvent;+import android.view.View;+import android.view.ViewGroup;+import android.view.ViewParent;+import android.view.WindowManager;+import android.widget.PopupWindow;++import com.termux.view.R;+import com.termux.view.TerminalView;+import com.termux.view.support.PopupWindowCompatGingerbread;++@SuppressLint("ViewConstructor")+public class TextSelectionHandleView extends View {+ private final TerminalView terminalView;+ private PopupWindow mHandle;+ private final CursorController mCursorController;++ private final Drawable mHandleLeftDrawable;+ private final Drawable mHandleRightDrawable;+ private Drawable mHandleDrawable;++ private boolean mIsDragging;++ final int[] mTempCoords = new int[2];+ Rect mTempRect;++ private int mPointX;+ private int mPointY;+ private float mTouchToWindowOffsetX;+ private float mTouchToWindowOffsetY;+ private float mHotspotX;+ private float mHotspotY;+ private float mTouchOffsetY;+ private int mLastParentX;+ private int mLastParentY;++ private int mHandleHeight;+ private int mHandleWidth;++ private final int mInitialOrientation;+ private int mOrientation;++ public static final int LEFT = 0;+ public static final int RIGHT = 2;++ private long mLastTime;++ public TextSelectionHandleView(TerminalView terminalView, CursorController cursorController, int initialOrientation) {+ super(terminalView.getContext());+ this.terminalView = terminalView;+ mCursorController = cursorController;+ mInitialOrientation = initialOrientation;++ mHandleLeftDrawable = getContext().getDrawable(R.drawable.text_select_handle_left_material);+ mHandleRightDrawable = getContext().getDrawable(R.drawable.text_select_handle_right_material);++ setOrientation(mInitialOrientation);+ }++ private void initHandle() {+ mHandle = new PopupWindow(terminalView.getContext(), null,+ android.R.attr.textSelectHandleWindowStyle);+ mHandle.setSplitTouchEnabled(true);+ mHandle.setClippingEnabled(false);+ mHandle.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);+ mHandle.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);+ mHandle.setBackgroundDrawable(null);+ mHandle.setAnimationStyle(0);++ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {+ mHandle.setWindowLayoutType(WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL);+ mHandle.setEnterTransition(null);+ mHandle.setExitTransition(null);+ } else {+ PopupWindowCompatGingerbread.setWindowLayoutType(mHandle, WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL);+ }+ mHandle.setContentView(this);+ }++ public void setOrientation(int orientation) {+ mOrientation = orientation;+ int handleWidth = 0;+ switch (orientation) {+ case LEFT: {+ mHandleDrawable = mHandleLeftDrawable;+ handleWidth = mHandleDrawable.getIntrinsicWidth();+ mHotspotX = (handleWidth * 3) / (float) 4;+ break;+ }++ case RIGHT: {+ mHandleDrawable = mHandleRightDrawable;+ handleWidth = mHandleDrawable.getIntrinsicWidth();+ mHotspotX = handleWidth / (float) 4;+ break;+ }+ }++ mHandleHeight = mHandleDrawable.getIntrinsicHeight();++ mHandleWidth = handleWidth;+ mTouchOffsetY = -mHandleHeight * 0.3f;+ mHotspotY = 0;+ invalidate();+ }++ public void show() {+ if (!isPositionVisible()) {+ hide();+ return;+ }++ // We remove handle from its parent first otherwise the following exception may be thrown+ // java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child's parent first.+ removeFromParent();++ initHandle(); // init the handle+ invalidate(); // invalidate to make sure onDraw is called++ final int[] coords = mTempCoords;+ terminalView.getLocationInWindow(coords);+ coords[0] += mPointX;+ coords[1] += mPointY;++ if (mHandle != null)+ mHandle.showAtLocation(terminalView, 0, coords[0], coords[1]);+ }++ public void hide() {+ mIsDragging = false;++ if (mHandle != null) {+ mHandle.dismiss();++ // We remove handle from its parent, otherwise it may still be shown in some cases even after the dismiss call+ removeFromParent();+ mHandle = null; // garbage collect the handle+ }+ invalidate();+ }++ public void removeFromParent() {+ if (!isParentNull()) {+ ((ViewGroup)this.getParent()).removeView(this);+ }+ }++ public void positionAtCursor(final int cx, final int cy, boolean forceOrientationCheck) {+ int x = terminalView.getPointX(cx);+ int y = terminalView.getPointY(cy + 1);+ moveTo(x, y, forceOrientationCheck);+ }++ private void moveTo(int x, int y, boolean forceOrientationCheck) {+ float oldHotspotX = mHotspotX;+ checkChangedOrientation(x, forceOrientationCheck);+ mPointX = (int) (x - (isShowing() ? oldHotspotX : mHotspotX));+ mPointY = y;++ if (isPositionVisible()) {+ int[] coords = null;++ if (isShowing()) {+ coords = mTempCoords;+ terminalView.getLocationInWindow(coords);+ int x1 = coords[0] + mPointX;+ int y1 = coords[1] + mPointY;+ if (mHandle != null)+ mHandle.update(x1, y1, getWidth(), getHeight());+ } else {+ show();+ }++ if (mIsDragging) {+ if (coords == null) {+ coords = mTempCoords;+ terminalView.getLocationInWindow(coords);+ }+ if (coords[0] != mLastParentX || coords[1] != mLastParentY) {+ mTouchToWindowOffsetX += coords[0] - mLastParentX;+ mTouchToWindowOffsetY += coords[1] - mLastParentY;+ mLastParentX = coords[0];+ mLastParentY = coords[1];+ }+ }+ } else {+ hide();+ }+ }++ public void changeOrientation(int orientation) {+ if (mOrientation != orientation) {+ setOrientation(orientation);+ }+ }++ private void checkChangedOrientation(int posX, boolean force) {+ if (!mIsDragging && !force) {+ return;+ }+ long millis = SystemClock.currentThreadTimeMillis();+ if (millis - mLastTime < 50 && !force) {+ return;+ }+ mLastTime = millis;++ final TerminalView hostView = terminalView;+ final int left = hostView.getLeft();+ final int right = hostView.getWidth();+ final int top = hostView.getTop();+ final int bottom = hostView.getHeight();++ if (mTempRect == null) {+ mTempRect = new Rect();+ }+ final Rect clip = mTempRect;+ clip.left = left + terminalView.getPaddingLeft();+ clip.top = top + terminalView.getPaddingTop();+ clip.right = right - terminalView.getPaddingRight();+ clip.bottom = bottom - terminalView.getPaddingBottom();++ final ViewParent parent = hostView.getParent();+ if (parent == null || !parent.getChildVisibleRect(hostView, clip, null)) {+ return;+ }++ if (posX - mHandleWidth < clip.left) {+ changeOrientation(RIGHT);+ } else if (posX + mHandleWidth > clip.right) {+ changeOrientation(LEFT);+ } else {+ changeOrientation(mInitialOrientation);+ }+ }++ private boolean isPositionVisible() {+ // Always show a dragging handle.+ if (mIsDragging) {+ return true;+ }++ final TerminalView hostView = terminalView;+ final int left = 0;+ final int right = hostView.getWidth();+ final int top = 0;+ final int bottom = hostView.getHeight();++ if (mTempRect == null) {+ mTempRect = new Rect();+ }+ final Rect clip = mTempRect;+ clip.left = left + terminalView.getPaddingLeft();+ clip.top = top + terminalView.getPaddingTop();+ clip.right = right - terminalView.getPaddingRight();+ clip.bottom = bottom - terminalView.getPaddingBottom();++ final ViewParent parent = hostView.getParent();+ if (parent == null || !parent.getChildVisibleRect(hostView, clip, null)) {+ return false;+ }++ final int[] coords = mTempCoords;+ hostView.getLocationInWindow(coords);+ final int posX = coords[0] + mPointX + (int) mHotspotX;+ final int posY = coords[1] + mPointY + (int) mHotspotY;++ return posX >= clip.left && posX <= clip.right &&+ posY >= clip.top && posY <= clip.bottom;+ }++ @Override+ public void onDraw(Canvas c) {+ final int width = mHandleDrawable.getIntrinsicWidth();+ int height = mHandleDrawable.getIntrinsicHeight();+ mHandleDrawable.setBounds(0, 0, width, height);+ mHandleDrawable.draw(c);+ }++ @SuppressLint("ClickableViewAccessibility")+ @Override+ public boolean onTouchEvent(MotionEvent event) {+ terminalView.updateFloatingToolbarVisibility(event);+ switch (event.getActionMasked()) {+ case MotionEvent.ACTION_DOWN: {+ final float rawX = event.getRawX();+ final float rawY = event.getRawY();+ mTouchToWindowOffsetX = rawX - mPointX;+ mTouchToWindowOffsetY = rawY - mPointY;+ final int[] coords = mTempCoords;+ terminalView.getLocationInWindow(coords);+ mLastParentX = coords[0];+ mLastParentY = coords[1];+ mIsDragging = true;+ break;+ }++ case MotionEvent.ACTION_MOVE: {+ final float rawX = event.getRawX();+ final float rawY = event.getRawY();++ final float newPosX = rawX - mTouchToWindowOffsetX + mHotspotX;+ final float newPosY = rawY - mTouchToWindowOffsetY + mHotspotY + mTouchOffsetY;++ mCursorController.updatePosition(this, Math.round(newPosX), Math.round(newPosY));+ break;+ }++ case MotionEvent.ACTION_UP:+ case MotionEvent.ACTION_CANCEL:+ mIsDragging = false;+ }+ return true;+ }++ @Override+ public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {+ setMeasuredDimension(mHandleDrawable.getIntrinsicWidth(),+ mHandleDrawable.getIntrinsicHeight());+ }++ public int getHandleHeight() {+ return mHandleHeight;+ }++ public int getHandleWidth() {+ return mHandleWidth;+ }++ public boolean isShowing() {+ if (mHandle != null)+ return mHandle.isShowing();+ else+ return false;+ }++ public boolean isParentNull() {+ return this.getParent() == null;+ }++ public boolean isDragging() {+ return mIsDragging;+ }++}diff --git a/terminal-view/src/main/res/drawable/text_select_handle_left_material.xml b/terminal-view/src/main/res/drawable/text_select_handle_left_material.xmlnew file mode 100644index 0000000..576ff4a--- /dev/null+++ b/terminal-view/src/main/res/drawable/text_select_handle_left_material.xml@@ -0,0 +1,10 @@+<vector xmlns:android="http://schemas.android.com/apk/res/android"+ android:width="48dp"+ android:height="24dp"+ android:viewportWidth="132"+ android:viewportHeight="66">+ <path+ android:pathData="M52.3,1.6c-5.7,2.1 -12.9,8.6 -16,14.8 -2.2,4.1 -2.8,6.9 -3.1,14.3 -0.6,12.6 1.3,17.8 9.3,25.8 8,8 13.2,9.9 25.8,9.3 11.1,-0.5 17.3,-3.2 23.5,-10.3 6.5,-7.4 7.2,-10.8 7.2,-34.7l0,-20.8 -21.2,0.1c-16.1,-0 -22.3,0.4 -25.5,1.5z"+ android:fillColor="#2196F3"+ android:strokeColor="#00000000"/>+</vector>diff --git a/terminal-view/src/main/res/drawable/text_select_handle_right_material.xml b/terminal-view/src/main/res/drawable/text_select_handle_right_material.xmlnew file mode 100644index 0000000..d049d3a--- /dev/null+++ b/terminal-view/src/main/res/drawable/text_select_handle_right_material.xml@@ -0,0 +1,10 @@+<vector xmlns:android="http://schemas.android.com/apk/res/android"+ android:width="48dp"+ android:height="24dp"+ android:viewportWidth="132"+ android:viewportHeight="66">+ <path+ android:pathData="M33,20.8c0,23.9 0.7,27.3 7.2,34.7 6.2,7.1 12.4,9.8 23.5,10.3 12.6,0.6 17.8,-1.3 25.8,-9.3 8,-8 9.9,-13.2 9.3,-25.8 -0.5,-11.1 -3.2,-17.3 -10.3,-23.5 -7.4,-6.5 -10.8,-7.2 -34.7,-7.2l-20.8,-0 0,20.8z"+ android:fillColor="#2196F3"+ android:strokeColor="#00000000"/>+</vector>diff --git a/terminal-view/src/main/res/values/strings.xml b/terminal-view/src/main/res/values/strings.xmlnew file mode 100644index 0000000..cd03c61--- /dev/null+++ b/terminal-view/src/main/res/values/strings.xml@@ -0,0 +1,5 @@+<resources>+ <string name="paste_text">Paste</string>+ <string name="copy_text">Copy</string>+ <string name="text_selection_more">More…</string>+</resources>