Top align terminal reading mode

.gitea/workflows/android.yaml

@@ -16,13 +16,31 @@ jobs:
         run: |
           set -eu
 
+          install_packages() {
+            if command -v apt-get >/dev/null 2>&1; then
+              apt-get update
+              apt-get install -y "$@"
+            elif command -v apk >/dev/null 2>&1; then
+              apk add --no-cache "$@"
+            elif command -v dnf >/dev/null 2>&1; then
+              dnf install -y "$@"
+            else
+              echo "No supported package manager found." >&2
+              exit 1
+            fi
+          }
+
           if ! command -v git >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1 || ! command -v unzip >/dev/null 2>&1; then
-            apt-get update
-            apt-get install -y git curl unzip
+            install_packages git curl unzip
           fi
           if ! command -v java >/dev/null 2>&1; then
-            apt-get update
-            apt-get install -y openjdk-17-jdk-headless
+            if command -v apk >/dev/null 2>&1; then
+              install_packages openjdk17-jdk
+            elif command -v dnf >/dev/null 2>&1; then
+              install_packages java-17-openjdk-devel
+            else
+              install_packages openjdk-17-jdk-headless
+            fi
           fi
           java -version
 

app/src/main/java/com/neatstudio/tmuxandroid/MainActivity.java

@@ -23,6 +23,7 @@ import android.os.Looper;
 import android.provider.Settings;
 import android.text.TextUtils;
 import android.text.InputType;
+import android.text.method.LinkMovementMethod;
 import android.view.Gravity;
 import android.view.HapticFeedbackConstants;
 import android.view.KeyEvent;
@@ -66,7 +67,7 @@ public final class MainActivity extends Activity {
     private static final int MAX_TERMINAL_COLS = 140;
     private static final int MIN_TERMINAL_ROWS = 8;
     private static final int MAX_TERMINAL_ROWS = 80;
-    private static final int TERMINAL_KEYS_HEIGHT_DP = 54;
+    private static final int TERMINAL_KEYS_HEIGHT_DP = 34;
     private static final int STATUS_NORMAL = 0;
     private static final int STATUS_BUSY = 1;
     private static final int STATUS_SUCCESS = 2;
@@ -124,10 +125,17 @@ public final class MainActivity extends Activity {
     private LinearLayout sessionGroupList;
     private TextView terminalText;
     private TextView terminalMetaText;
+    private TextView terminalConnectionText;
+    private Button terminalReadingButton;
     private ScrollView terminalScroll;
     private EditText inputField;
+    private final Button[] terminalAccessoryTabButtons = new Button[4];
     private View terminalAccessoryBar;
     private View terminalComposerBar;
+    private LinearLayout terminalImagePreviewBar;
+    private ImageView terminalImagePreview;
+    private TextView terminalImagePreviewPath;
+    private String terminalImagePath = "";
     private LinearLayout terminalGroupRow;
     private String activeSessionName;
     private String terminalPathStatus = "";
@@ -139,11 +147,13 @@ public final class MainActivity extends Activity {
     private int lastActiveSessionCount = -1;
     private TerminalScreenBuffer terminalScreen = new TerminalScreenBuffer(DEFAULT_TERMINAL_COLS, DEFAULT_TERMINAL_ROWS);
     private final StringBuilder queuedTerminalInput = new StringBuilder();
+    private final Set<String> terminalExpandedBlocks = new HashSet<>();
     private boolean terminalConnected;
     private boolean terminalConnecting;
     private boolean terminalRenderPending;
     private boolean terminalSelectionEnabled;
     private boolean terminalFollowOutput = true;
+    private boolean terminalReadingMode = true;
     private int terminalKeyPage;
     private int terminalReconnectAttempt;
     private int terminalConnectionGeneration;
@@ -1595,6 +1605,11 @@ public final class MainActivity extends Activity {
         terminalSelectionEnabled = false;
         terminalFollowOutput = true;
         terminalKeyPage = 0;
+        terminalExpandedBlocks.clear();
+        terminalImagePath = "";
+        terminalImagePreviewBar = null;
+        terminalImagePreview = null;
+        terminalImagePreviewPath = null;
         terminalPathStatus = "path loading";
         terminalSocketStatus = "terminal idle";
         terminalEventStatus = "events listening";
@@ -1613,11 +1628,12 @@ public final class MainActivity extends Activity {
         terminalScroll.setBackgroundColor(COLOR_TERMINAL_BG);
         terminalText = new TextView(this);
         terminalText.setTextColor(COLOR_TEXT);
-        terminalText.setTextSize(13);
+        terminalText.setTextSize(11);
         terminalText.setTypeface(Typeface.MONOSPACE);
         terminalText.setIncludeFontPadding(false);
+        terminalText.setHorizontallyScrolling(!terminalReadingMode);
         terminalText.setLineSpacing(0, 1.05f);
-        terminalText.setGravity(Gravity.BOTTOM | Gravity.START);
+        terminalText.setGravity((terminalReadingMode ? Gravity.TOP : Gravity.BOTTOM) | Gravity.START);
         terminalText.setTextIsSelectable(terminalSelectionEnabled);
         terminalText.setPadding(dp(2), dp(8), dp(2), dp(8));
         terminalText.setBackgroundColor(COLOR_TERMINAL_BG);
@@ -1666,6 +1682,10 @@ public final class MainActivity extends Activity {
         titleBlock.setGravity(Gravity.CENTER_VERTICAL);
         titleBlock.setPadding(dp(9), 0, dp(7), 0);
 
+        LinearLayout titleRow = new LinearLayout(this);
+        titleRow.setOrientation(LinearLayout.HORIZONTAL);
+        titleRow.setGravity(Gravity.CENTER_VERTICAL);
+
         TextView title = new TextView(this);
         title.setText(sessionName);
         title.setTextColor(COLOR_TEXT);
@@ -1674,6 +1694,22 @@ public final class MainActivity extends Activity {
         title.setSingleLine(true);
         title.setEllipsize(TextUtils.TruncateAt.END);
         title.setIncludeFontPadding(false);
+        titleRow.addView(title, new LinearLayout.LayoutParams(
+                0,
+                dp(17),
+                1
+        ));
+
+        terminalConnectionText = new TextView(this);
+        terminalConnectionText.setTextSize(9);
+        terminalConnectionText.setTypeface(Typeface.MONOSPACE);
+        terminalConnectionText.setSingleLine(true);
+        terminalConnectionText.setIncludeFontPadding(false);
+        terminalConnectionText.setPadding(dp(7), 0, 0, 0);
+        titleRow.addView(terminalConnectionText, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                dp(17)
+        ));
 
         terminalMetaText = new TextView(this);
         terminalMetaText.setTextColor(COLOR_TEXT_DIM);
@@ -1684,7 +1720,7 @@ public final class MainActivity extends Activity {
         terminalMetaText.setIncludeFontPadding(false);
         updateTerminalMeta();
 
-        titleBlock.addView(title, new LinearLayout.LayoutParams(
+        titleBlock.addView(titleRow, new LinearLayout.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 dp(17)
         ));
@@ -1693,10 +1729,38 @@ public final class MainActivity extends Activity {
                 dp(13)
         ));
         bar.addView(titleBlock, new LinearLayout.LayoutParams(0, dp(32), 1));
+        terminalReadingButton = terminalToolButton("读", view ->
+                setTerminalReadingMode(!terminalReadingMode));
+        terminalReadingButton.setContentDescription("Toggle Chinese reading mode");
+        styleTerminalReadingButton();
+        bar.addView(terminalReadingButton);
         bar.addView(terminalToolButton("☰", view -> showTerminalActions(sessionName)));
         return bar;
     }
 
+    private void setTerminalReadingMode(boolean reading) {
+        terminalReadingMode = reading;
+        if (terminalText != null) {
+            terminalText.setHorizontallyScrolling(!reading);
+            terminalText.setGravity((reading ? Gravity.TOP : Gravity.BOTTOM) | Gravity.START);
+            terminalText.setMovementMethod(reading ? LinkMovementMethod.getInstance() : null);
+        }
+        styleTerminalReadingButton();
+        renderTerminalNow();
+        setStatus(reading ? "Chinese reading mode" : "Full terminal mode");
+    }
+
+    private void styleTerminalReadingButton() {
+        if (terminalReadingButton == null) {
+            return;
+        }
+        terminalReadingButton.setText(terminalReadingMode ? "读" : "终");
+        terminalReadingButton.setTextColor(terminalReadingMode ? Color.rgb(14, 38, 24) : COLOR_TEXT_MUTED);
+        terminalReadingButton.setBackground(terminalReadingMode
+                ? rounded(COLOR_ACCENT, 7, COLOR_ACCENT, 1)
+                : buttonBackground());
+    }
+
     private HorizontalScrollView createTerminalGroupBar() {
         HorizontalScrollView scroller = new HorizontalScrollView(this);
         scroller.setHorizontalScrollBarEnabled(false);
@@ -1736,18 +1800,13 @@ public final class MainActivity extends Activity {
             try {
                 List<SessionSummary> sessions = api.getSessions();
                 String path = "";
-                String command = "";
                 for (SessionSummary session : sessions) {
                     if (sessionName.equals(session.name)) {
                         path = defaultValue(session.currentPath, "");
-                        command = defaultValue(session.currentCommand, "");
                         break;
                     }
                 }
-                String meta = path.isEmpty() ? "path unavailable" : path;
-                if (!command.isEmpty()) {
-                    meta = meta + "  ·  " + command;
-                }
+                String meta = path.isEmpty() ? "path unavailable" : compactTerminalPath(path);
                 String finalMeta = meta;
                 runOnUiThread(() -> {
                     if (sessionName.equals(activeSessionName)) {
@@ -1767,18 +1826,28 @@ public final class MainActivity extends Activity {
     }
 
     private void updateTerminalMeta() {
-        if (terminalMetaText == null) {
+        if (terminalMetaText == null || terminalConnectionText == null) {
             return;
         }
-        StringBuilder meta = new StringBuilder();
-        meta.append(defaultValue(terminalPathStatus, "path loading"));
-        if (!terminalSocketStatus.isEmpty()) {
-            meta.append("  ·  ").append(terminalSocketStatus);
+        terminalMetaText.setText(defaultValue(terminalPathStatus, "path loading"));
+        String socket = terminalSocketStatus.toLowerCase(java.util.Locale.ROOT);
+        if (socket.contains("connected") && !socket.contains("disconnected")) {
+            terminalConnectionText.setText("● connected");
+            terminalConnectionText.setTextColor(COLOR_SUCCESS);
+        } else if (socket.contains("error") || socket.contains("disconnected")) {
+            terminalConnectionText.setText("● disconnected");
+            terminalConnectionText.setTextColor(COLOR_DANGER);
+        } else {
+            terminalConnectionText.setText("● connecting");
+            terminalConnectionText.setTextColor(COLOR_ACCENT_WARM);
         }
-        if (!terminalEventStatus.isEmpty()) {
-            meta.append("  ·  ").append(terminalEventStatus);
-        }
-        terminalMetaText.setText(meta.toString());
+    }
+
+    private String compactTerminalPath(String path) {
+        String compact = path.trim();
+        compact = compact.replaceFirst("^/home/[^/]+(?=/|$)", "~");
+        compact = compact.replaceFirst("^/Users/[^/]+(?=/|$)", "~");
+        return compact;
     }
 
     private void renderTerminalGroupSessions(String sessionName, String text) {
@@ -1991,6 +2060,7 @@ public final class MainActivity extends Activity {
                 "Clear local view and tmux history",
                 "Split horizontal",
                 "Split vertical",
+                "Zoom active pane",
                 "Page up",
                 "Page down",
                 "Session status",
@@ -2022,34 +2092,37 @@ public final class MainActivity extends Activity {
                             runApiAction("Split vertical", () -> api.splitPane(sessionName, "vertical"));
                             break;
                         case 4:
+                            sendTerminalInput("\u0002z");
+                            break;
+                        case 5:
                             if (terminalSocket != null) {
                                 terminalSocket.scroll(-terminalRows);
                             }
                             break;
-                        case 5:
+                        case 6:
                             if (terminalSocket != null) {
                                 terminalSocket.scroll(terminalRows);
                             }
                             break;
-                        case 6:
+                        case 7:
                             showRaw("Session status", () -> api.sessionStatus(sessionName));
                             break;
-                        case 7:
+                        case 8:
                             promptSendCommand(sessionName);
                             break;
-                        case 8:
+                        case 9:
                             sendTerminalInput("\u0002");
                             break;
-                        case 9:
+                        case 10:
                             sendTerminalInput("\u0002d");
                             break;
-                        case 10:
+                        case 11:
                             sendTerminalInput("\u0002c");
                             break;
-                        case 11:
+                        case 12:
                             sendTerminalInput("\u0002n");
                             break;
-                        case 12:
+                        case 13:
                             sendTerminalInput("\u0002p");
                             break;
                         default:
@@ -2065,9 +2138,40 @@ public final class MainActivity extends Activity {
         bar.setPadding(dp(8), dp(5), dp(8), dp(7));
         bar.setBackgroundColor(COLOR_BAR);
 
+        terminalImagePreviewBar = createComposerImagePreviewBar();
+        bar.addView(terminalImagePreviewBar, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                dp(64)
+        ));
+
         LinearLayout row = new LinearLayout(this);
         row.setOrientation(LinearLayout.HORIZONTAL);
-        row.setGravity(Gravity.BOTTOM);
+        row.setGravity(Gravity.CENTER_VERTICAL);
+
+        LinearLayout tabGrid = new LinearLayout(this);
+        tabGrid.setOrientation(LinearLayout.VERTICAL);
+        LinearLayout firstTabRow = terminalKeyRow();
+        LinearLayout secondTabRow = terminalKeyRow();
+        addAccessoryTab(firstTabRow, "Edit", 0);
+        addAccessoryTab(firstTabRow, "Ctrl", 1);
+        addAccessoryTab(secondTabRow, "Nav", 2);
+        addAccessoryTab(secondTabRow, "Sym", 3);
+        tabGrid.addView(firstTabRow, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                0,
+                1
+        ));
+        LinearLayout.LayoutParams secondTabParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                0,
+                1
+        );
+        secondTabParams.topMargin = dp(3);
+        tabGrid.addView(secondTabRow, secondTabParams);
+        row.addView(tabGrid, new LinearLayout.LayoutParams(
+                dp(72),
+                ViewGroup.LayoutParams.MATCH_PARENT
+        ));
 
         inputField = new EditText(this);
         inputField.setTextColor(COLOR_TEXT);
@@ -2100,9 +2204,6 @@ public final class MainActivity extends Activity {
             }
             return false;
         });
-        Button image = composerButton("Img", view -> pickImageForSession(activeSessionName));
-        image.setContentDescription("Upload image");
-        row.addView(image, new LinearLayout.LayoutParams(dp(38), dp(38)));
         LinearLayout.LayoutParams inputParams = new LinearLayout.LayoutParams(
                 0,
                 ViewGroup.LayoutParams.WRAP_CONTENT,
@@ -2111,13 +2212,114 @@ public final class MainActivity extends Activity {
         inputParams.leftMargin = dp(5);
         inputParams.rightMargin = dp(5);
         row.addView(inputField, inputParams);
+
+        LinearLayout actions = new LinearLayout(this);
+        actions.setOrientation(LinearLayout.VERTICAL);
         Button send = composerPrimaryButton("Send", view -> sendLine());
         send.setContentDescription("Send input");
-        row.addView(send, new LinearLayout.LayoutParams(dp(48), dp(38)));
+        actions.addView(send, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                0,
+                1
+        ));
+        Button image = composerButton("Img", view -> pickImageForSession(activeSessionName));
+        image.setContentDescription("Upload image");
+        LinearLayout.LayoutParams imageParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                0,
+                1
+        );
+        imageParams.topMargin = dp(3);
+        actions.addView(image, imageParams);
+        row.addView(actions, new LinearLayout.LayoutParams(
+                dp(48),
+                ViewGroup.LayoutParams.MATCH_PARENT
+        ));
         bar.addView(row, matchWrap());
         return bar;
     }
 
+    private LinearLayout createComposerImagePreviewBar() {
+        LinearLayout previewBar = new LinearLayout(this);
+        previewBar.setOrientation(LinearLayout.HORIZONTAL);
+        previewBar.setGravity(Gravity.CENTER_VERTICAL);
+        previewBar.setPadding(dp(4), dp(3), dp(2), dp(7));
+        previewBar.setVisibility(View.GONE);
+
+        terminalImagePreview = new ImageView(this);
+        terminalImagePreview.setScaleType(ImageView.ScaleType.CENTER_CROP);
+        terminalImagePreview.setAdjustViewBounds(false);
+        terminalImagePreview.setBackground(rounded(COLOR_FIELD, 6, COLOR_BORDER, 1));
+        terminalImagePreview.setContentDescription("Open uploaded image preview");
+        terminalImagePreview.setOnClickListener(view -> {
+            if (!terminalImagePath.isEmpty()) {
+                showImagePreview(terminalImagePath, "");
+            }
+        });
+        previewBar.addView(terminalImagePreview, new LinearLayout.LayoutParams(dp(52), dp(52)));
+
+        terminalImagePreviewPath = bodyText("Loading image preview...");
+        terminalImagePreviewPath.setSingleLine(true);
+        terminalImagePreviewPath.setEllipsize(TextUtils.TruncateAt.MIDDLE);
+        terminalImagePreviewPath.setTextSize(10);
+        LinearLayout.LayoutParams pathParams = new LinearLayout.LayoutParams(0, dp(52), 1);
+        pathParams.leftMargin = dp(9);
+        previewBar.addView(terminalImagePreviewPath, pathParams);
+
+        Button clear = terminalToolButton("×", view -> clearComposerImagePreview());
+        clear.setContentDescription("Clear image preview");
+        previewBar.addView(clear);
+        return previewBar;
+    }
+
+    private void loadComposerImagePreview(String path) {
+        if (terminalImagePreviewBar == null || path == null || path.isEmpty()) {
+            return;
+        }
+        terminalImagePath = path;
+        terminalImagePreview.setImageDrawable(null);
+        terminalImagePreviewPath.setText("Loading  " + path);
+        terminalImagePreviewBar.setVisibility(View.VISIBLE);
+        int generation = terminalConnectionGeneration;
+        ImageView preview = terminalImagePreview;
+        TextView previewPath = terminalImagePreviewPath;
+        executor.execute(() -> {
+            try {
+                byte[] bytes = api.imagePreview(path, "");
+                Bitmap bitmap = decodePreviewBitmap(bytes, 1200);
+                if (bitmap == null) {
+                    throw new IllegalStateException("Preview is not a supported bitmap");
+                }
+                runOnUiThread(() -> {
+                    if (generation == terminalConnectionGeneration
+                            && path.equals(terminalImagePath)
+                            && preview == terminalImagePreview) {
+                        preview.setImageBitmap(bitmap);
+                        previewPath.setText(path);
+                    }
+                });
+            } catch (Exception error) {
+                runOnUiThread(() -> {
+                    if (generation == terminalConnectionGeneration
+                            && path.equals(terminalImagePath)
+                            && previewPath == terminalImagePreviewPath) {
+                        previewPath.setText("Preview unavailable  " + path);
+                    }
+                });
+            }
+        });
+    }
+
+    private void clearComposerImagePreview() {
+        terminalImagePath = "";
+        if (terminalImagePreview != null) {
+            terminalImagePreview.setImageDrawable(null);
+        }
+        if (terminalImagePreviewBar != null) {
+            terminalImagePreviewBar.setVisibility(View.GONE);
+        }
+    }
+
     private void promptRenameSession(String sessionName) {
         promptText("Rename session", sessionName, sessionName, nextName -> {
             if (!nextName.matches("[A-Za-z0-9._-]+")) {
@@ -2546,7 +2748,7 @@ public final class MainActivity extends Activity {
         executor.execute(() -> {
             try {
                 byte[] bytes = api.imagePreview(path, basePath);
-                Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                Bitmap bitmap = decodePreviewBitmap(bytes, 1800);
                 if (bitmap == null) {
                     throw new IllegalStateException("Preview is not a supported bitmap");
                 }
@@ -2571,6 +2773,23 @@ public final class MainActivity extends Activity {
         });
     }
 
+    private Bitmap decodePreviewBitmap(byte[] bytes, int maxDimension) {
+        BitmapFactory.Options bounds = new BitmapFactory.Options();
+        bounds.inJustDecodeBounds = true;
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.length, bounds);
+        if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
+            return null;
+        }
+        int sampleSize = 1;
+        while (bounds.outWidth / sampleSize > maxDimension
+                || bounds.outHeight / sampleSize > maxDimension) {
+            sampleSize *= 2;
+        }
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inSampleSize = sampleSize;
+        return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
+    }
+
     private void promptText(String title, String hint, String value, TextApiAction action) {
         EditText input = new EditText(this);
         input.setSingleLine(true);
@@ -2679,20 +2898,9 @@ public final class MainActivity extends Activity {
     private LinearLayout createAccessoryBar() {
         LinearLayout panel = new LinearLayout(this);
         panel.setOrientation(LinearLayout.VERTICAL);
-        panel.setPadding(dp(6), dp(3), dp(6), dp(3));
+        panel.setPadding(dp(4), dp(3), dp(4), dp(3));
         panel.setBackgroundColor(COLOR_PANEL);
 
-        LinearLayout tabs = terminalKeyRow();
-        tabs.setGravity(Gravity.CENTER_VERTICAL);
-        addAccessoryTab(tabs, "Edit", 0);
-        addAccessoryTab(tabs, "Ctrl", 1);
-        addAccessoryTab(tabs, "Nav", 2);
-        addAccessoryTab(tabs, "Sym", 3);
-        panel.addView(tabs, new LinearLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                dp(18)
-        ));
-
         HorizontalScrollView keyScroller = new HorizontalScrollView(this);
         keyScroller.setHorizontalScrollBarEnabled(false);
         keyScroller.setFillViewport(true);
@@ -2702,13 +2910,10 @@ public final class MainActivity extends Activity {
                 ViewGroup.LayoutParams.WRAP_CONTENT,
                 ViewGroup.LayoutParams.MATCH_PARENT
         ));
-        LinearLayout.LayoutParams keyParams = new LinearLayout.LayoutParams(
+        panel.addView(keyScroller, new LinearLayout.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
-                0,
-                1
-        );
-        keyParams.topMargin = dp(2);
-        panel.addView(keyScroller, keyParams);
+                ViewGroup.LayoutParams.MATCH_PARENT
+        ));
         return panel;
     }
 
@@ -2744,8 +2949,6 @@ public final class MainActivity extends Activity {
                 addSoftKey(row, "End", "\u001b[F");
                 addSoftKey(row, "Pg↑", "\u001b[5~");
                 addSoftKey(row, "Pg↓", "\u001b[6~");
-                addComposerButton(row, "Prev", () -> setTerminalKeyPage(terminalKeyPage - 1));
-                addComposerButton(row, "Next", () -> setTerminalKeyPage(terminalKeyPage + 1));
                 addSoftKey(row, "Clear", "\u000c");
                 addSoftKey(row, "Detach", "\u0002d");
                 break;
@@ -2771,12 +2974,12 @@ public final class MainActivity extends Activity {
                 addSoftKey(row, "↓", "\u001b[B");
                 addSoftKey(row, "Esc", "\u001b");
                 addSoftKey(row, "Tab", "\t");
-                addSoftKey(row, "Enter", TERMINAL_ENTER);
+                addSoftKey(row, "↵", TERMINAL_ENTER);
                 addSoftButton(row, "Paste", view -> pasteClipboard());
                 addComposerButton(row, "⌫", this::backspaceComposerText);
                 addTextKey(row, "NL", "\n");
-                addComposerButton(row, "Bottom", this::scrollTerminalBottom);
-                addComposerButton(row, "Select", () -> {
+                addComposerButton(row, "Bot", this::scrollTerminalBottom);
+                addComposerButton(row, "Sel", () -> {
                     terminalSelectionEnabled = !terminalSelectionEnabled;
                     if (terminalText != null) {
                         terminalText.setTextIsSelectable(terminalSelectionEnabled);
@@ -2879,7 +3082,7 @@ public final class MainActivity extends Activity {
         }
         int horizontalPadding = terminalText.getPaddingLeft() + terminalText.getPaddingRight();
         int verticalPadding = terminalText.getPaddingTop() + terminalText.getPaddingBottom();
-        float charWidth = terminalText.getPaint().measureText("W");
+        float charWidth = terminalText.getPaint().measureText("0000000000") / 10f;
         if (charWidth <= 0f) {
             charWidth = dp(8);
         }
@@ -3053,6 +3256,7 @@ public final class MainActivity extends Activity {
 
     private void setTerminalKeyPage(int page) {
         terminalKeyPage = (page + 4) % 4;
+        updateAccessoryTabs();
         if (activeSessionName != null) {
             renderTerminalControlsOnly();
         }
@@ -3094,7 +3298,19 @@ public final class MainActivity extends Activity {
             return;
         }
         lastTerminalRenderMs = System.currentTimeMillis();
-        terminalText.setText(terminalScreen.render());
+        if (terminalReadingMode) {
+            terminalText.setMovementMethod(LinkMovementMethod.getInstance());
+            terminalText.setHighlightColor(Color.TRANSPARENT);
+            terminalText.setText(terminalScreen.renderFocused(terminalExpandedBlocks, key -> {
+                if (!terminalExpandedBlocks.add(key)) {
+                    terminalExpandedBlocks.remove(key);
+                }
+                renderTerminalNow();
+            }));
+        } else {
+            terminalText.setMovementMethod(null);
+            terminalText.setText(terminalScreen.render());
+        }
         if (terminalFollowOutput) {
             terminalScroll.post(() -> terminalScroll.fullScroll(View.FOCUS_DOWN));
         }
@@ -3222,8 +3438,8 @@ public final class MainActivity extends Activity {
         Button button = toolbarButton(label, listener);
         button.setTextSize(10);
         button.setPadding(dp(5), 0, dp(5), 0);
-        button.setMinWidth(0);
-        button.setMinimumWidth(0);
+        button.setMinWidth(dp(38));
+        button.setMinimumWidth(dp(38));
         button.setMinHeight(0);
         button.setMinimumHeight(0);
         return button;
@@ -3309,9 +3525,9 @@ public final class MainActivity extends Activity {
     private void addSoftButton(LinearLayout row, String label, View.OnClickListener listener) {
         Button button = toolbarButton(label, listener);
         button.setTextSize(isArrowLabel(label) ? 14 : 9);
-        button.setPadding(dp(5), 0, dp(5), 0);
-        button.setMinWidth(0);
-        button.setMinimumWidth(0);
+        button.setPadding(dp(2), 0, dp(2), 0);
+        button.setMinWidth(dp(24));
+        button.setMinimumWidth(dp(24));
         button.setMinHeight(0);
         button.setMinimumHeight(0);
         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
@@ -3319,31 +3535,45 @@ public final class MainActivity extends Activity {
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 0
         );
-        params.leftMargin = dp(1);
         params.rightMargin = dp(1);
         row.addView(button, params);
     }
 
     private void addAccessoryTab(LinearLayout row, String label, int page) {
         Button button = toolbarButton(label, view -> setTerminalKeyPage(page));
-        boolean selected = terminalKeyPage == page;
         button.setTextSize(8);
-        button.setPadding(dp(7), 0, dp(7), 0);
+        button.setPadding(dp(3), 0, dp(3), 0);
         button.setMinWidth(0);
         button.setMinimumWidth(0);
         button.setMinHeight(0);
         button.setMinimumHeight(0);
+        terminalAccessoryTabButtons[page] = button;
+        styleAccessoryTab(button, terminalKeyPage == page);
+        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
+                0,
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                1
+        );
+        if (row.getChildCount() > 0) {
+            params.leftMargin = dp(3);
+        }
+        row.addView(button, params);
+    }
+
+    private void updateAccessoryTabs() {
+        for (int page = 0; page < terminalAccessoryTabButtons.length; page++) {
+            Button button = terminalAccessoryTabButtons[page];
+            if (button != null) {
+                styleAccessoryTab(button, terminalKeyPage == page);
+            }
+        }
+    }
+
+    private void styleAccessoryTab(Button button, boolean selected) {
         button.setTextColor(selected ? Color.rgb(14, 38, 24) : COLOR_TEXT_MUTED);
         button.setBackground(selected
-                ? rounded(COLOR_ACCENT, 7, COLOR_ACCENT, 1)
-                : rounded(COLOR_CARD_ALT, 7, COLOR_BORDER_SOFT, 1));
-        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
-                ViewGroup.LayoutParams.WRAP_CONTENT,
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                0
-        );
-        params.rightMargin = dp(2);
-        row.addView(button, params);
+                ? rounded(COLOR_ACCENT, 6, COLOR_ACCENT, 1)
+                : rounded(COLOR_CARD_ALT, 6, COLOR_BORDER_SOFT, 1));
     }
 
     private boolean isArrowLabel(String label) {
@@ -3653,9 +3883,15 @@ public final class MainActivity extends Activity {
                     throw new IllegalStateException("Cannot open selected image");
                 }
                 String response = api.uploadImage(sessionName, readAllBytes(input));
+                String imagePath = new JSONObject(response).optString("absolutePath", "").trim();
+                if (imagePath.isEmpty()) {
+                    throw new IllegalStateException("Upload response did not include absolutePath");
+                }
                 runOnUiThread(() -> {
                     progressBar.setVisibility(View.GONE);
-                    showTextDialog("Image upload", response);
+                    insertComposerPath(imagePath);
+                    loadComposerImagePreview(imagePath);
+                    setStatus("Image path inserted");
                 });
             } catch (Exception error) {
                 runOnUiThread(() -> {
@@ -3677,6 +3913,21 @@ public final class MainActivity extends Activity {
         return output.toByteArray();
     }
 
+    private void insertComposerPath(String path) {
+        if (inputField == null) {
+            return;
+        }
+        int start = Math.max(0, inputField.getSelectionStart());
+        int end = Math.max(0, inputField.getSelectionEnd());
+        int from = Math.min(start, end);
+        int to = Math.max(start, end);
+        CharSequence current = inputField.getText();
+        String prefix = from > 0 && !Character.isWhitespace(current.charAt(from - 1)) ? " " : "";
+        String suffix = to < current.length() && Character.isWhitespace(current.charAt(to)) ? "" : " ";
+        inputField.getText().replace(from, to, prefix + path + suffix);
+        inputField.requestFocus();
+    }
+
     @Override
     public void onBackPressed() {
         if (activeSessionName != null) {

app/src/main/java/com/neatstudio/tmuxandroid/TerminalScreenBuffer.java

@@ -4,16 +4,22 @@ import android.graphics.Color;
 import android.graphics.Typeface;
 import android.text.SpannableStringBuilder;
 import android.text.Spanned;
+import android.text.TextPaint;
 import android.text.style.BackgroundColorSpan;
+import android.text.style.ClickableSpan;
 import android.text.style.ForegroundColorSpan;
 import android.text.style.StyleSpan;
+import android.view.View;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
+import java.util.Set;
 
 final class TerminalScreenBuffer {
     private static final int DEFAULT_FG = 0xffe6ebf2;
     private static final int DEFAULT_BG = Color.TRANSPARENT;
+    private static final int TERMINAL_BG = 0xff0b0e13;
 
     private int cols;
     private int rows;
@@ -27,6 +33,11 @@ final class TerminalScreenBuffer {
     private int fg = DEFAULT_FG;
     private int bg = DEFAULT_BG;
     private boolean bold;
+    private boolean dim;
+
+    interface FocusToggle {
+        void toggle(String key);
+    }
 
     TerminalScreenBuffer(int cols, int rows) {
         resize(cols, rows);
@@ -35,9 +46,6 @@ final class TerminalScreenBuffer {
     void resize(int nextCols, int nextRows) {
         nextCols = Math.max(1, nextCols);
         nextRows = Math.max(1, nextRows);
-        Cell[][] previous = cells;
-        int previousRows = rows;
-        int previousCols = cols;
         cols = nextCols;
         rows = nextRows;
         cells = new Cell[rows][cols];
@@ -46,21 +54,11 @@ final class TerminalScreenBuffer {
                 cells[row][col] = new Cell();
             }
         }
-        if (previous != null) {
-            int copyRows = Math.min(previousRows, rows);
-            int copyCols = Math.min(previousCols, cols);
-            int previousStart = Math.max(0, previousRows - copyRows);
-            int nextStart = Math.max(0, rows - copyRows);
-            for (int row = 0; row < copyRows; row++) {
-                for (int col = 0; col < copyCols; col++) {
-                    cells[nextStart + row][col].copyFrom(previous[previousStart + row][col]);
-                }
-            }
-        }
-        cursorRow = clamp(cursorRow, 0, rows - 1);
-        cursorCol = clamp(cursorCol, 0, cols - 1);
-        savedRow = clamp(savedRow, 0, rows - 1);
-        savedCol = clamp(savedCol, 0, cols - 1);
+        cursorRow = 0;
+        cursorCol = 0;
+        savedRow = 0;
+        savedCol = 0;
+        wrapPending = false;
     }
 
     void clear() {
@@ -74,6 +72,7 @@ final class TerminalScreenBuffer {
         fg = DEFAULT_FG;
         bg = DEFAULT_BG;
         bold = false;
+        dim = false;
     }
 
     void write(String text) {
@@ -131,6 +130,106 @@ final class TerminalScreenBuffer {
         return output;
     }
 
+    CharSequence renderFocused(Set<String> expandedBlocks, FocusToggle toggle) {
+        SpannableStringBuilder output = new SpannableStringBuilder();
+        List<String> hiddenRows = new ArrayList<>();
+        int hiddenStart = -1;
+        for (int row = 0; row < rows; row++) {
+            String text = rowText(row).trim();
+            if (containsHan(text)) {
+                if (!hiddenRows.isEmpty()) {
+                    appendFocusBlock(output, hiddenRows, hiddenStart, row - 1, expandedBlocks, toggle);
+                    hiddenRows.clear();
+                    hiddenStart = -1;
+                }
+                appendLine(output, text);
+            } else if (!text.isEmpty()) {
+                if (hiddenStart < 0) {
+                    hiddenStart = row;
+                }
+                hiddenRows.add(text);
+            }
+        }
+        if (!hiddenRows.isEmpty()) {
+            appendFocusBlock(output, hiddenRows, hiddenStart, rows - 1, expandedBlocks, toggle);
+        }
+        if (output.length() == 0) {
+            output.append("暂无可读内容");
+        }
+        return output;
+    }
+
+    private void appendFocusBlock(
+            SpannableStringBuilder output,
+            List<String> lines,
+            int startRow,
+            int endRow,
+            Set<String> expandedBlocks,
+            FocusToggle toggle
+    ) {
+        String key = startRow + ":" + endRow;
+        boolean expanded = expandedBlocks.contains(key);
+        String summary = focusSummary(lines);
+        int actionStart = output.length();
+        appendLine(output, (expanded ? "▼ " : "▶ ") + summary);
+        int actionEnd = output.length();
+        output.setSpan(new ClickableSpan() {
+            @Override
+            public void onClick(View widget) {
+                toggle.toggle(key);
+            }
+
+            @Override
+            public void updateDrawState(TextPaint paint) {
+                paint.setColor(0xff67da91);
+                paint.setUnderlineText(false);
+                paint.setFakeBoldText(true);
+            }
+        }, actionStart, actionEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        if (expanded) {
+            for (String line : lines) {
+                appendLine(output, "  " + line);
+            }
+        }
+    }
+
+    private String focusSummary(List<String> lines) {
+        String joined = String.join(" ", lines).toLowerCase(Locale.ROOT);
+        String type;
+        if (joined.contains("error") || joined.contains("failed") || joined.contains("exception")) {
+            type = "错误输出";
+        } else if (joined.contains("working") || joined.contains("running")
+                || joined.contains("waiting") || joined.contains("interrupt")) {
+            type = "运行状态";
+        } else if (joined.contains("test") || joined.contains("build") || joined.contains("compile")
+                || joined.contains("gradle") || joined.contains("webpack") || joined.contains("npm")) {
+            type = "构建/测试";
+        } else if (joined.contains("git ") || joined.contains("commit") || joined.contains("push")) {
+            type = "Git 操作";
+        } else if (lines.get(0).startsWith(">") || lines.get(0).startsWith("$")
+                || lines.get(0).startsWith("!")) {
+            type = "命令与输出";
+        } else {
+            type = "终端细节";
+        }
+        return type + " · " + lines.size() + " 行 · " + compactSummary(lines.get(0), 42);
+    }
+
+    private String compactSummary(String text, int maxChars) {
+        String compact = text.replaceAll("\\s+", " ").trim();
+        if (compact.length() <= maxChars) {
+            return compact;
+        }
+        return compact.substring(0, maxChars - 1) + "…";
+    }
+
+    private void appendLine(SpannableStringBuilder output, String text) {
+        if (output.length() > 0) {
+            output.append('\n');
+        }
+        output.append(text);
+    }
+
     private int handleEscape(String text, int index) {
         if (index + 1 >= text.length()) {
             return -1;
@@ -257,10 +356,14 @@ final class TerminalScreenBuffer {
                 fg = DEFAULT_FG;
                 bg = DEFAULT_BG;
                 bold = false;
+                dim = false;
             } else if (value == 1) {
                 bold = true;
+            } else if (value == 2) {
+                dim = true;
             } else if (value == 22) {
                 bold = false;
+                dim = false;
             } else if (value == 39) {
                 fg = DEFAULT_FG;
             } else if (value == 49) {
@@ -302,14 +405,34 @@ final class TerminalScreenBuffer {
             wrapPending = false;
             newLine();
         }
-        cells[cursorRow][cursorCol].set(value, fg, bg, bold);
-        if (cursorCol == cols - 1) {
+        int width = isWideCharacter(value) ? 2 : 1;
+        if (width == 2 && cursorCol == cols - 1) {
+            newLine();
+        }
+        cells[cursorRow][cursorCol].set(value, fg, bg, bold, dim);
+        if (width == 2) {
+            cells[cursorRow][cursorCol + 1].setContinuation(fg, bg, bold, dim);
+        }
+        if (cursorCol + width >= cols) {
+            cursorCol = cols - 1;
             wrapPending = true;
         } else {
-            cursorCol++;
+            cursorCol += width;
         }
     }
 
+    private boolean isWideCharacter(char value) {
+        return value >= '\u1100' && (value <= '\u115f'
+                || value == '\u2329' || value == '\u232a'
+                || (value >= '\u2e80' && value <= '\ua4cf' && value != '\u303f')
+                || (value >= '\uac00' && value <= '\ud7a3')
+                || (value >= '\uf900' && value <= '\ufaff')
+                || (value >= '\ufe10' && value <= '\ufe19')
+                || (value >= '\ufe30' && value <= '\ufe6f')
+                || (value >= '\uff00' && value <= '\uff60')
+                || (value >= '\uffe0' && value <= '\uffe6'));
+    }
+
     private void newLine() {
         wrapPending = false;
         cursorRow++;
@@ -453,15 +576,21 @@ final class TerminalScreenBuffer {
             int fgColor = first.fg;
             int bgColor = first.bg;
             boolean isBold = first.bold;
+            boolean isDim = first.dim;
             while (col < cols) {
                 Cell cell = cells[row][col];
-                if (cell.fg != fgColor || cell.bg != bgColor || cell.bold != isBold) {
+                if (cell.fg != fgColor || cell.bg != bgColor || cell.bold != isBold || cell.dim != isDim) {
                     break;
                 }
-                output.append(cell.value);
+                if (!cell.continuation) {
+                    output.append(cell.value);
+                }
                 col++;
             }
             int end = output.length();
+            if (isDim) {
+                fgColor = blendColor(fgColor, bgColor == DEFAULT_BG ? TERMINAL_BG : bgColor, 0.55f);
+            }
             output.setSpan(new ForegroundColorSpan(fgColor), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
             if (bgColor != DEFAULT_BG) {
                 output.setSpan(new BackgroundColorSpan(bgColor), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
@@ -472,6 +601,29 @@ final class TerminalScreenBuffer {
         }
     }
 
+    private String rowText(int row) {
+        StringBuilder text = new StringBuilder(cols);
+        for (int col = 0; col < cols; col++) {
+            Cell cell = cells[row][col];
+            if (!cell.continuation) {
+                text.append(cell.value);
+            }
+        }
+        return text.toString();
+    }
+
+    private boolean containsHan(String text) {
+        for (int index = 0; index < text.length(); index++) {
+            Character.UnicodeBlock block = Character.UnicodeBlock.of(text.charAt(index));
+            if (block == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
+                    || block == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
+                    || block == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private void saveCursor() {
         savedRow = cursorRow;
         savedCol = cursorCol;
@@ -613,6 +765,15 @@ final class TerminalScreenBuffer {
         return value == 0 ? 0 : 55 + value * 40;
     }
 
+    private static int blendColor(int foreground, int background, float foregroundRatio) {
+        float backgroundRatio = 1f - foregroundRatio;
+        return Color.rgb(
+                Math.round(Color.red(foreground) * foregroundRatio + Color.red(background) * backgroundRatio),
+                Math.round(Color.green(foreground) * foregroundRatio + Color.green(background) * backgroundRatio),
+                Math.round(Color.blue(foreground) * foregroundRatio + Color.blue(background) * backgroundRatio)
+        );
+    }
+
     private static int clamp(int value, int min, int max) {
         return Math.max(min, Math.min(max, value));
     }
@@ -622,19 +783,34 @@ final class TerminalScreenBuffer {
         int fg = DEFAULT_FG;
         int bg = DEFAULT_BG;
         boolean bold;
+        boolean dim;
+        boolean continuation;
 
         void clear() {
             value = ' ';
             fg = DEFAULT_FG;
             bg = DEFAULT_BG;
             bold = false;
+            dim = false;
+            continuation = false;
         }
 
-        void set(char nextValue, int nextFg, int nextBg, boolean nextBold) {
+        void set(char nextValue, int nextFg, int nextBg, boolean nextBold, boolean nextDim) {
             value = nextValue;
             fg = nextFg;
             bg = nextBg;
             bold = nextBold;
+            dim = nextDim;
+            continuation = false;
+        }
+
+        void setContinuation(int nextFg, int nextBg, boolean nextBold, boolean nextDim) {
+            value = ' ';
+            fg = nextFg;
+            bg = nextBg;
+            bold = nextBold;
+            dim = nextDim;
+            continuation = true;
         }
 
         void copyFrom(Cell other) {
@@ -642,6 +818,8 @@ final class TerminalScreenBuffer {
             fg = other.fg;
             bg = other.bg;
             bold = other.bold;
+            dim = other.dim;
+            continuation = other.continuation;
         }
     }
 }