Repo clean

.gitignore

@@ -1,3 +1,5 @@
+j3270.log.*
+build/*
 *.log
 .DS_Store
 *.jar

README.md

@@ -1,9 +1,9 @@
 # j3270
 
 [![Build & Test](https://git.hugfreevikings.wtf/rudi/j3270/actions/workflows/build.yaml/badge.svg)](https://git.hugfreevikings.wtf/rudi/j3270/actions)
-[![Latest Release](https://git.hugfreevikings.wtf/rudi/j3270/badges/release.svg)](https://git.hugfreevikings.wtf/rudi/j3270/releases)
+[![Releases](https://img.shields.io/badge/Releases-Gitea-blue.svg)](https://git.hugfreevikings.wtf/rudi/j3270/releases)
 [![Java](https://img.shields.io/badge/Java-11%20%7C%2017%20%7C%2021-blue.svg)](https://adoptium.net)
-[![License](https://img.shields.io/badge/License-MIT%20%2F%20BSD-green.svg)](LICENSE)
+[![License](https://img.shields.io/badge/License-Unlicense-blue.svg)](LICENSE)
 
 An **x3270-aligned IBM 3270 mainframe terminal emulator** written in pure Java. Designed for high compatibility with IBM z/OS, z/VM, CMS, and TSO systems over TN3270 and TN3270E.
 
@@ -24,6 +24,19 @@ Requires **Java 11 or higher** (Java 11, 17, 21+):
 # Launch interactive GUI
 java -jar j3270.jar
 
+# Connect to TLS/SSL mainframe with custom port
+java -jar j3270.jar -s mainframe.example.com 992
+# Or using standard x3270 L: prefix
+java -jar j3270.jar L:mainframe.example.com:992
+
+# Connect via Plain TN3270 (Non-E)
+java -jar j3270.jar -P mainframe.example.com 23
+# Or using standard x3270 P: prefix
+java -jar j3270.jar P:mainframe.example.com:23
+
+# Connect with unverified/self-signed certificate verification bypass
+java -jar j3270.jar --tls --insecure mainframe.example.com 992
+
 # Launch with custom configuration file
 java -jar j3270.jar -c config.ini
 
@@ -35,7 +48,11 @@ java -jar j3270.jar -c config.ini
 
 ## ✨ Features
 
-- **TN3270 & TN3270E Protocol Support**: RFC 2355 compliant state machine, negotiation, Device-Type query, and SSL/TLS encryption.
+- **TN3270 & TN3270E Protocol Support**: RFC 2355 compliant state machine, negotiation, Device-Type query, plain TN3270 fallback, and SSL/TLS encryption.
+- **SSL/TLS Security**:
+  - Encrypted TN3270 over TLS connections on standard port `992` or custom ports.
+  - Interactive certificate verification prompt for self-signed or untrusted certificates with fingerprint, subject, issuer, and validity inspection.
+  - Optional unverified/insecure mode for testing and headless scripting.
 - **IND$FILE File Transfer**: Full support for both **CUT** and **DFT (DDM)** high-speed structured field transfers with ASCII/binary translation, CRLF handling, and recfm/lrecl formatting for TSO, VM/CMS, and CICS.
 - **z/VM & Line-Mode Support**: Proper SSCP-LU and unformatted line handling (`CP TERM CONMODE 3270` supported).
 - **APL & Graphic Escape**: Comprehensive box-drawing and math symbol character rendering.
@@ -59,7 +76,7 @@ The project includes self-contained, portable build scripts:
 # Build executable JAR in 2 seconds:
 sh ./build_all.sh
 
-# Run all 25 automated unit tests in ~130ms:
+# Run all 57 automated unit tests in ~500ms:
 sh ./test_all.sh
 ```
 
@@ -73,15 +90,13 @@ The resulting standalone JAR is created at `build/j3270.jar`.
 
 ---
 
-## 🤝 Contributing
-
-Contributions and issue reports are welcome! Please feel free to open a bug report or feature request via the Gitea issue tracker.
-
----
-
 ## 📜 Acknowledgements
 
 - [x3270](https://x3270.miraheze.org/wiki/Main_Page) — Reference C implementation and protocol specifications
-- [Antigravity](https://antigravity.google)
+- [Antigravity](https://antigravity.google/)
 - Claude Opus 4.6
 - Gemini 3.1 Pro
+- Gemini 3.7 Flash
+- Gemma4 12B and 26B
+- GPT-OSS 120B
+- Qwen3 4B and 32B

bugs.txt

@@ -8,3 +8,6 @@
 - IND$FILE CMS and TSO:
   Fixed command formatting options handling (empty parenthesis removal for CMS binary/default modes and option spacing) and added Query Reply filtering for DFT/DDM mode.
 
+- Local keyboard input and cursor updates not rendering in terminal:
+  Fixed in ScreenBuffer, InputProcessor, and TerminalPanel by ensuring display snapshot and cursor address are updated synchronously on user input operations (typing, backspace, delete, cursor movement, erase) so the presentation layer immediately renders user keystrokes.
+

build/MANIFEST.MF

@@ -1,6 +0,0 @@
-Manifest-Version: 1.0
-Main-Class: org.pubvm.j3270.J3270App
-Implementation-Title: j3270
-Implementation-Version: 0.1.0
-Created-By: j3270 build_all.sh
-

j3270/src/main/java/org/pubvm/j3270/J3270App.java

@@ -34,6 +34,7 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
     private int lastPort = 23;
 
     private FileTransfer fileTransfer;
+    private final java.util.concurrent.atomic.AtomicBoolean screenUpdatePending = new java.util.concurrent.atomic.AtomicBoolean(false);
 
     public J3270App() {
         super("j3270 — Java TN3270 Terminal Emulator");
@@ -227,8 +228,12 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
 
     private void showConnectDialog() {
         ConnectDialog dialog = new ConnectDialog(this);
-        dialog.setInitialHost(lastHost);
-        dialog.setInitialPort(lastPort);
+        String initialHost = lastHost != null && !lastHost.isEmpty() ? lastHost : org.pubvm.j3270.config.Settings.getAutoConnectHost();
+        int initialPort = lastPort > 0 ? lastPort : org.pubvm.j3270.config.Settings.getAutoConnectPort();
+        dialog.setInitialHost(initialHost);
+        dialog.setInitialPort(initialPort);
+        dialog.setInitialTls(org.pubvm.j3270.config.Settings.getAutoConnectTls());
+        dialog.setInitialVerifyCert(org.pubvm.j3270.config.Settings.getAutoConnectVerifyCert());
         dialog.setVisible(true);
 
         if (dialog.isConfirmed()) {
@@ -255,10 +260,19 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
         // Save for auto-connect
         org.pubvm.j3270.config.Settings.setAutoConnectHost(config.getHost());
         org.pubvm.j3270.config.Settings.setAutoConnectPort(config.getPort());
+        org.pubvm.j3270.config.Settings.setAutoConnectTls(config.isUseTls());
+        org.pubvm.j3270.config.Settings.setAutoConnectVerifyCert(config.isTlsVerifyCert());
 
         // Disconnect existing connection
         disconnect();
 
+        // Wire interactive certificate verifier if none configured
+        if (config.getCertificateVerifier() == null) {
+            config.setCertificateVerifier((chain, authType, exception) ->
+                org.pubvm.j3270.ui.UntrustedCertificateDialog.showPrompt(this, config.getHost(), config.getPort(), chain, exception)
+            );
+        }
+
         client = new Telnet3270Client(config);
         client.addConnectionListener(this);
         client.addScreenUpdateListener(this);
@@ -266,7 +280,8 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
         terminalPanel.setClient(client);
         statusBar.setClient(client);
 
-        setTitle("j3270 — " + config.getHost() + ":" + config.getPort());
+        String tlsIndicator = config.isUseTls() ? (config.isTlsVerifyCert() ? " [TLS]" : " [TLS/Unverified]") : "";
+        setTitle("j3270 — " + config.getHost() + ":" + config.getPort() + tlsIndicator);
 
         // Resize window to match model
         terminalPanel.guardedPack();
@@ -349,7 +364,9 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
 
     @Override
     public void onScreenUpdated() {
+        if (screenUpdatePending.compareAndSet(false, true)) {
             SwingUtilities.invokeLater(() -> {
+                screenUpdatePending.set(false);
                 // During an active file transfer, let the CUT/DFT handler drive
                 // keyboard state.  In x3270, ft_cut_data() runs before WCC
                 // keyboard-restore is applied — the keyboard stays locked for the
@@ -364,6 +381,7 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
                 statusBar.updateStatus();
             });
         }
+    }
 
     @Override
     public void onSoundAlarm() {
@@ -426,11 +444,29 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
 
     public static void main(String[] args) {
         boolean debug = false;
+        boolean cliTls = false;
+        boolean cliNoVerifyCert = false;
+        Boolean cliTn3270e = null;
+        org.lib3270j.graphics.GraphicsMode cliGraphicsMode = null;
         String configFile = null;
         java.util.List<String> remainingArgs = new java.util.ArrayList<>();
         for (int i = 0; i < args.length; i++) {
             if ("--debug".equals(args[i]) || "-d".equals(args[i])) {
                 debug = true;
+            } else if ("--tls".equals(args[i]) || "--ssl".equals(args[i]) || "-s".equals(args[i])) {
+                cliTls = true;
+            } else if ("--no-verify-cert".equals(args[i]) || "--insecure".equals(args[i]) || "-k".equals(args[i])) {
+                cliNoVerifyCert = true;
+            } else if ("--no-tn3270e".equals(args[i]) || "--plain-tn3270".equals(args[i]) || "--plain".equals(args[i]) || "-P".equals(args[i]) || "-p".equals(args[i]) || "--non-e".equals(args[i])) {
+                cliTn3270e = false;
+            } else if ("--tn3270e".equals(args[i])) {
+                cliTn3270e = true;
+            } else if (args[i].startsWith("--graphics=")) {
+                cliGraphicsMode = org.lib3270j.graphics.GraphicsMode.fromString(args[i].substring(11));
+            } else if (("--graphics".equals(args[i]) || "-g".equals(args[i])) && i + 1 < args.length && !args[i + 1].startsWith("-")) {
+                cliGraphicsMode = org.lib3270j.graphics.GraphicsMode.fromString(args[++i]);
+            } else if ("--no-graphics".equals(args[i])) {
+                cliGraphicsMode = org.lib3270j.graphics.GraphicsMode.NONE;
             } else if (("-c".equals(args[i]) || "--config".equals(args[i])) && i + 1 < args.length) {
                 configFile = args[++i];
             } else {
@@ -439,33 +475,41 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
         }
 
         // Configure logging for application packages
+        Level logLevel = debug ? Level.ALL : Level.INFO;
         Logger globalRoot = Logger.getLogger("");
         for (java.util.logging.Handler h : globalRoot.getHandlers()) {
             globalRoot.removeHandler(h);
         }
-        globalRoot.setLevel(Level.WARNING);
+        globalRoot.setLevel(Level.ALL);
 
-        ConsoleHandler handler = new ConsoleHandler();
-        handler.setLevel(debug ? Level.ALL : Level.INFO);
-        handler.setFormatter(new SimpleFormatter());
+        java.util.logging.Filter appFilter = record -> {
+            String name = record.getLoggerName();
+            return name != null && (name.startsWith("org.lib3270j") || name.startsWith("org.pubvm.j3270"));
+        };
 
-        Logger appLogger = Logger.getLogger("org.pubvm.j3270");
-        appLogger.setLevel(Level.ALL);
-        appLogger.addHandler(handler);
-        appLogger.setUseParentHandlers(false);
+        ConsoleHandler consoleHandler = new ConsoleHandler();
+        consoleHandler.setLevel(logLevel);
+        consoleHandler.setFormatter(new SimpleFormatter());
+        consoleHandler.setFilter(appFilter);
+        globalRoot.addHandler(consoleHandler);
 
-        Logger libLogger = Logger.getLogger("org.lib3270j");
-        libLogger.setLevel(Level.ALL);
-        libLogger.addHandler(handler);
-        libLogger.setUseParentHandlers(false);
+        Logger.getLogger("org.pubvm").setLevel(logLevel);
+        Logger.getLogger("org.pubvm.j3270").setLevel(logLevel);
+        Logger.getLogger("org.lib3270j").setLevel(logLevel);
 
         try {
-            java.util.logging.FileHandler fileHandler = new java.util.logging.FileHandler("j3270.log", 10 * 1024 * 1024, 1, false);
+            java.util.logging.FileHandler fileHandler = new java.util.logging.FileHandler("j3270.log", 10 * 1024 * 1024, 1, false) {
+                @Override
+                public synchronized void publish(java.util.logging.LogRecord record) {
+                    super.publish(record);
+                    flush();
+                }
+            };
             fileHandler.setLevel(Level.ALL);
             fileHandler.setFormatter(new SimpleFormatter());
-            appLogger.addHandler(fileHandler);
-            libLogger.addHandler(fileHandler);
-            log.info("Logging protocol trace to j3270.log");
+            fileHandler.setFilter(appFilter);
+            globalRoot.addHandler(fileHandler);
+            log.info("Logging protocol trace to j3270.log (debug=" + debug + ", level=" + logLevel + ")");
         } catch (Exception e) {
             System.err.println("Could not create j3270.log: " + e.getMessage());
         }
@@ -492,18 +536,23 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
         System.setProperty("apple.laf.useScreenMenuBar", "true");
         System.setProperty("apple.awt.application.name", "j3270");
 
+        final boolean finalTls = cliTls;
+        final boolean finalNoVerify = cliNoVerifyCert;
+        final Boolean finalTn3270e = cliTn3270e;
+        final org.lib3270j.graphics.GraphicsMode finalGraphicsMode = cliGraphicsMode;
+
         SwingUtilities.invokeLater(() -> {
             J3270App app = new J3270App();
             app.setVisible(true);
 
             // If host:port given on command line, connect directly
             if (!remainingArgs.isEmpty()) {
-                String host = remainingArgs.get(0);
-                int port = 23;
+                String hostArg = remainingArgs.get(0);
+                int port = finalTls ? 992 : 23;
                 if (remainingArgs.size() >= 2) {
                     try {
                         port = Integer.parseInt(remainingArgs.get(1));
-                    } catch (NumberFormatException e) {
+                    } catch (NumberFormatException ignored) {
                     }
                 }
                 TerminalModel model = TerminalModel.IBM_3279_4;
@@ -511,10 +560,24 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
                     try {
                         int modelNum = Integer.parseInt(remainingArgs.get(2));
                         model = TerminalModel.forModel(modelNum, true);
-                    } catch (Exception e) {
+                    } catch (Exception ignored) {
                     }
                 }
-                ConnectionConfig config = new ConnectionConfig(host, port, model);
+                ConnectionConfig config = ConnectionConfig.parseHostString(hostArg, port, model);
+                if (finalTls) {
+                    config.setUseTls(true);
+                }
+                if (finalNoVerify) {
+                    config.setTlsVerifyCert(false);
+                }
+                if (finalTn3270e != null) {
+                    config.setTn3270eEnabled(finalTn3270e);
+                }
+                if (finalGraphicsMode != null) {
+                    config.setGraphicsMode(finalGraphicsMode);
+                } else {
+                    config.setGraphicsMode(org.pubvm.j3270.config.Settings.getGraphicsMode());
+                }
                 app.connect(config);
             } else {
                 org.pubvm.j3270.config.Settings.StartupBehavior behavior = org.pubvm.j3270.config.Settings
@@ -526,8 +589,19 @@ public class J3270App extends JFrame implements ConnectionListener, ScreenUpdate
                     case AUTO_CONNECT:
                         String host = org.pubvm.j3270.config.Settings.getAutoConnectHost();
                         int port = org.pubvm.j3270.config.Settings.getAutoConnectPort();
+                        boolean tls = org.pubvm.j3270.config.Settings.getAutoConnectTls();
+                        boolean verify = org.pubvm.j3270.config.Settings.getAutoConnectVerifyCert();
+                        boolean tn3270e = org.pubvm.j3270.config.Settings.getAutoConnectTn3270e();
                         if (host != null && !host.isEmpty()) {
-                            app.connect(new ConnectionConfig(host, port, TerminalModel.IBM_3279_4));
+                            ConnectionConfig config = new ConnectionConfig(host, port, TerminalModel.IBM_3279_4, tls);
+                            config.setTlsVerifyCert(verify);
+                            config.setTn3270eEnabled(finalTn3270e != null ? finalTn3270e : tn3270e);
+                            if (finalGraphicsMode != null) {
+                                config.setGraphicsMode(finalGraphicsMode);
+                            } else {
+                                config.setGraphicsMode(org.pubvm.j3270.config.Settings.getGraphicsMode());
+                            }
+                            app.connect(config);
                         } else {
                             SwingUtilities.invokeLater(app::showConnectDialog);
                         }

j3270/src/main/java/org/pubvm/j3270/config/Settings.java

@@ -62,6 +62,39 @@ public class Settings {
         prefs.putInt("autoConnectPort", port);
     }
 
+    public static boolean getAutoConnectTls() {
+        return prefs.getBoolean("autoConnectTls", false);
+    }
+
+    public static void setAutoConnectTls(boolean tls) {
+        prefs.putBoolean("autoConnectTls", tls);
+    }
+
+    public static boolean getAutoConnectVerifyCert() {
+        return prefs.getBoolean("autoConnectVerifyCert", true);
+    }
+
+    public static void setAutoConnectVerifyCert(boolean verify) {
+        prefs.putBoolean("autoConnectVerifyCert", verify);
+    }
+
+    public static boolean getAutoConnectTn3270e() {
+        return prefs.getBoolean("autoConnectTn3270e", true);
+    }
+
+    public static void setAutoConnectTn3270e(boolean tn3270e) {
+        prefs.putBoolean("autoConnectTn3270e", tn3270e);
+    }
+
+    public static org.lib3270j.graphics.GraphicsMode getGraphicsMode() {
+        String modeStr = prefs.get("graphicsMode", org.lib3270j.graphics.GraphicsMode.BOTH.name());
+        return org.lib3270j.graphics.GraphicsMode.fromString(modeStr);
+    }
+
+    public static void setGraphicsMode(org.lib3270j.graphics.GraphicsMode mode) {
+        prefs.put("graphicsMode", (mode != null ? mode : org.lib3270j.graphics.GraphicsMode.BOTH).name());
+    }
+
     public static Color getColorOverride(int index, Color defaultColor) {
         String hex = prefs.get("color_" + index, null);
         try {
@@ -194,15 +227,38 @@ public class Settings {
                 break;
 
             case "behavior":
+            case "connection":
                 switch (key) {
                     case "startupBehavior":
                         setStartupBehavior(StartupBehavior.valueOf(value.toUpperCase()));
                         break;
-                    case "autoConnectHost": setAutoConnectHost(value); break;
-                    case "autoConnectPort": setAutoConnectPort(Integer.parseInt(value)); break;
+                    case "autoConnectHost":
+                    case "host":
+                        setAutoConnectHost(value);
+                        break;
+                    case "autoConnectPort":
+                    case "port":
+                        setAutoConnectPort(Integer.parseInt(value));
+                        break;
+                    case "autoConnectTls":
+                    case "tls":
+                    case "ssl":
+                    case "useTls":
+                        setAutoConnectTls(Boolean.parseBoolean(value));
+                        break;
+                    case "autoConnectVerifyCert":
+                    case "verifyCert":
+                    case "tlsVerifyCert":
+                        setAutoConnectVerifyCert(Boolean.parseBoolean(value));
+                        break;
+                    case "autoConnectTn3270e":
+                    case "tn3270e":
+                    case "enableTn3270e":
+                        setAutoConnectTn3270e(Boolean.parseBoolean(value));
+                        break;
                     case "blockSelectMode": setBlockSelectMode(Boolean.parseBoolean(value)); break;
                     default:
-                        log.warning("Unknown behavior key: " + key);
+                        log.warning("Unknown behavior/connection key: " + key);
                 }
                 break;
 
@@ -222,6 +278,14 @@ public class Settings {
                 setKeyBinding(key, value);
                 break;
 
+            case "graphics":
+                if ("graphicsMode".equalsIgnoreCase(key) || "mode".equalsIgnoreCase(key)) {
+                    setGraphicsMode(org.lib3270j.graphics.GraphicsMode.fromString(value));
+                } else {
+                    log.warning("Unknown graphics key: " + key);
+                }
+                break;
+
             default:
                 // Allow bare keys outside any section — treat as raw prefs
                 log.fine("Setting raw preference: " + key + " = " + value);
@@ -256,10 +320,18 @@ public class Settings {
             if (acHost != null && !acHost.isEmpty()) {
                 w.println("autoConnectHost = " + acHost);
                 w.println("autoConnectPort = " + getAutoConnectPort());
+                w.println("autoConnectTls = " + getAutoConnectTls());
+                w.println("autoConnectVerifyCert = " + getAutoConnectVerifyCert());
+                w.println("autoConnectTn3270e = " + getAutoConnectTn3270e());
             }
             w.println("blockSelectMode = " + getBlockSelectMode());
             w.println();
 
+            // [graphics]
+            w.println("[graphics]");
+            w.println("graphicsMode = " + getGraphicsMode().name());
+            w.println();
+
             // [colors]
             w.println("[colors]");
             // Host colors 0-15

j3270/src/main/java/org/pubvm/j3270/ui/ConnectDialog.java

@@ -14,7 +14,11 @@ public class ConnectDialog extends JDialog {
     private JTextField hostField;
     private JTextField portField;
     private JComboBox<TerminalModel> modelCombo;
+    private JComboBox<org.lib3270j.graphics.GraphicsMode> graphicsCombo;
     private JTextField luField;
+    private JCheckBox tlsCheckBox;
+    private JCheckBox verifyCertCheckBox;
+    private JCheckBox tn3270eCheckBox;
     private boolean confirmed;
     private ConnectionConfig result;
 
@@ -93,6 +97,67 @@ public class ConnectDialog extends JDialog {
         luField = createDarkField(12);
         mainPanel.add(luField, gbc);
 
+        // Graphics Mode
+        gbc.gridx = 0;
+        gbc.gridy = 4;
+        gbc.weightx = 0;
+        JLabel graphicsLabel = new JLabel("Graphics:");
+        graphicsLabel.setForeground(fg);
+        graphicsLabel.setFont(labelFont);
+        mainPanel.add(graphicsLabel, gbc);
+        gbc.gridx = 1;
+        gbc.weightx = 1.0;
+        graphicsCombo = new JComboBox<>(org.lib3270j.graphics.GraphicsMode.values());
+        graphicsCombo.setSelectedItem(org.pubvm.j3270.config.Settings.getGraphicsMode());
+        graphicsCombo.setBackground(new Color(45, 45, 45));
+        graphicsCombo.setForeground(fg);
+        graphicsCombo.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 13));
+        mainPanel.add(graphicsCombo, gbc);
+
+        // TLS / SSL Checkbox
+        gbc.gridx = 1;
+        gbc.gridy = 5;
+        gbc.weightx = 1.0;
+        tlsCheckBox = new JCheckBox("Enable TLS/SSL");
+        tlsCheckBox.setBackground(new Color(30, 30, 30));
+        tlsCheckBox.setForeground(fg);
+        tlsCheckBox.setFont(labelFont);
+        tlsCheckBox.setFocusPainted(false);
+        tlsCheckBox.addActionListener(e -> {
+            boolean isTls = tlsCheckBox.isSelected();
+            verifyCertCheckBox.setEnabled(isTls);
+            String currentPort = portField.getText().trim();
+            if (isTls && "23".equals(currentPort)) {
+                portField.setText("992");
+            } else if (!isTls && "992".equals(currentPort)) {
+                portField.setText("23");
+            }
+        });
+        mainPanel.add(tlsCheckBox, gbc);
+
+        // Verify Certificate Checkbox
+        gbc.gridx = 1;
+        gbc.gridy = 6;
+        verifyCertCheckBox = new JCheckBox("Verify Server Certificate");
+        verifyCertCheckBox.setBackground(new Color(30, 30, 30));
+        verifyCertCheckBox.setForeground(new Color(160, 160, 160));
+        verifyCertCheckBox.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 13));
+        verifyCertCheckBox.setSelected(true);
+        verifyCertCheckBox.setEnabled(false);
+        verifyCertCheckBox.setFocusPainted(false);
+        mainPanel.add(verifyCertCheckBox, gbc);
+
+        // TN3270E Checkbox
+        gbc.gridx = 1;
+        gbc.gridy = 7;
+        tn3270eCheckBox = new JCheckBox("Enable TN3270E (Extended 3270)");
+        tn3270eCheckBox.setBackground(new Color(30, 30, 30));
+        tn3270eCheckBox.setForeground(fg);
+        tn3270eCheckBox.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 13));
+        tn3270eCheckBox.setSelected(org.pubvm.j3270.config.Settings.getAutoConnectTn3270e());
+        tn3270eCheckBox.setFocusPainted(false);
+        mainPanel.add(tn3270eCheckBox, gbc);
+
         // Buttons
         JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
         buttonPanel.setBackground(new Color(30, 30, 30));
@@ -116,7 +181,7 @@ public class ConnectDialog extends JDialog {
         buttonPanel.add(connectBtn);
 
         gbc.gridx = 0;
-        gbc.gridy = 4;
+        gbc.gridy = 8;
         gbc.gridwidth = 2;
         mainPanel.add(buttonPanel, gbc);
 
@@ -158,6 +223,10 @@ public class ConnectDialog extends JDialog {
         if (!lu.isEmpty()) {
             result.setLuName(lu);
         }
+        result.setGraphicsMode((org.lib3270j.graphics.GraphicsMode) graphicsCombo.getSelectedItem());
+        result.setUseTls(tlsCheckBox.isSelected());
+        result.setTlsVerifyCert(verifyCertCheckBox.isSelected());
+        result.setTn3270eEnabled(tn3270eCheckBox.isSelected());
         confirmed = true;
         dispose();
     }
@@ -178,4 +247,17 @@ public class ConnectDialog extends JDialog {
     public void setInitialPort(int port) {
         portField.setText(String.valueOf(port));
     }
+
+    public void setInitialTls(boolean tls) {
+        tlsCheckBox.setSelected(tls);
+        verifyCertCheckBox.setEnabled(tls);
+    }
+
+    public void setInitialVerifyCert(boolean verify) {
+        verifyCertCheckBox.setSelected(verify);
+    }
+
+    public void setInitialTn3270e(boolean tn3270e) {
+        tn3270eCheckBox.setSelected(tn3270e);
+    }
 }

j3270/src/main/java/org/pubvm/j3270/ui/SettingsDialog.java

@@ -31,6 +31,7 @@ public class SettingsDialog extends JDialog {
     // Appearance tab
     private JComboBox<String> fontBox;
     private JSpinner fontSizeSpinner;
+    private JComboBox<org.lib3270j.graphics.GraphicsMode> graphicsModeBox;
 
     // Behavior tab
     private JComboBox<Settings.StartupBehavior> startupBehaviorBox;
@@ -264,8 +265,21 @@ public class SettingsDialog extends JDialog {
         gbc.fill = GridBagConstraints.HORIZONTAL;
         panel.add(fontSizeSpinner, gbc);
 
-        // Fill remaining space
+        // Graphics Mode
+        gbc.gridx = 0;
         gbc.gridy = 2;
+        gbc.fill = GridBagConstraints.NONE;
+        JLabel graphicsLabel = new JLabel("Graphics Mode:");
+        panel.add(graphicsLabel, gbc);
+
+        graphicsModeBox = new JComboBox<>(org.lib3270j.graphics.GraphicsMode.values());
+        graphicsModeBox.setSelectedItem(Settings.getGraphicsMode());
+        gbc.gridx = 1;
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+        panel.add(graphicsModeBox, gbc);
+
+        // Fill remaining space
+        gbc.gridy = 3;
         gbc.weighty = 1.0;
         panel.add(Box.createGlue(), gbc);
 
@@ -611,6 +625,9 @@ public class SettingsDialog extends JDialog {
                 Settings.setFontFamily(fontFam);
             }
             Settings.setFontSize((Integer) fontSizeSpinner.getValue());
+            if (graphicsModeBox.getSelectedItem() != null) {
+                Settings.setGraphicsMode((org.lib3270j.graphics.GraphicsMode) graphicsModeBox.getSelectedItem());
+            }
 
             // Apply Behavior
             Settings.StartupBehavior behavior = (Settings.StartupBehavior) startupBehaviorBox.getSelectedItem();

j3270/src/main/java/org/pubvm/j3270/ui/StatusBar.java

@@ -15,6 +15,7 @@ import java.awt.*;
 public class StatusBar extends JPanel {
 
     private final JLabel connectionStatus;
+    private final JLabel tlsStatus;
     private final JLabel cursorPosition;
     private final JLabel luName;
     private final JLabel lockStatus;
@@ -37,6 +38,7 @@ public class StatusBar extends JPanel {
         Font oiaFont = new Font(Font.MONOSPACED, Font.PLAIN, 12);
 
         connectionStatus = createLabel("Not Connected", oiaFont, OIA_DIM);
+        tlsStatus = createLabel("", oiaFont, OIA_FG);
         luName = createLabel("", oiaFont, OIA_FG);
         lockStatus = createLabel("", oiaFont, OIA_ALERT);
         modelInfo = createLabel("", oiaFont, OIA_DIM);
@@ -44,6 +46,8 @@ public class StatusBar extends JPanel {
 
         add(Box.createHorizontalStrut(6));
         add(connectionStatus);
+        add(Box.createHorizontalStrut(10));
+        add(tlsStatus);
         add(Box.createHorizontalStrut(12));
         add(luName);
         add(Box.createHorizontalStrut(12));
@@ -110,6 +114,26 @@ public class StatusBar extends JPanel {
                 break;
         }
 
+        // TLS Status
+        if (state.isConnected() && client.getConfig().isUseTls()) {
+            boolean verified = client.getConfig().isTlsVerifyCert();
+            javax.net.ssl.SSLSession session = client.getSslSession();
+            String cipher = session != null ? session.getCipherSuite() : "TLS";
+            String protocol = session != null ? session.getProtocol() : "TLS";
+            if (verified) {
+                tlsStatus.setText("🔒 TLS");
+                tlsStatus.setForeground(OIA_FG);
+                tlsStatus.setToolTipText(protocol + " / " + cipher + " (Verified)");
+            } else {
+                tlsStatus.setText("🔓 TLS (Unverified)");
+                tlsStatus.setForeground(new Color(255, 180, 80));
+                tlsStatus.setToolTipText(protocol + " / " + cipher + " (Verification Bypassed)");
+            }
+        } else {
+            tlsStatus.setText("");
+            tlsStatus.setToolTipText(null);
+        }
+
         // LU name
         String lu = "";
         if (client.getConnectionState().isTn3270e()) {

j3270/src/main/java/org/pubvm/j3270/ui/TerminalPanel.java

@@ -22,6 +22,7 @@ public class TerminalPanel extends JPanel {
 
     // Font and cell dimensions
     private Font terminalFont;
+    private Font boldTerminalFont;
     private int cellWidth;
     private int cellHeight;
     private int fontAscent;
@@ -47,6 +48,14 @@ public class TerminalPanel extends JPanel {
 
     // ========== Selection / Copy-Paste state ==========
     private boolean blockSelectMode = false;
+
+    private static final String[] CHAR_STRINGS = new String[128];
+    static {
+        for (int i = 0; i < 128; i++) {
+            CHAR_STRINGS[i] = String.valueOf((char) i);
+        }
+    }
+    private static final Color CURSOR_COLOR = new Color(255, 255, 255, 180);
     private int selectionStartRow = -1, selectionStartCol = -1;
     private int selectionEndRow = -1, selectionEndCol = -1;
     private boolean isDragging = false;
@@ -181,6 +190,8 @@ public class TerminalPanel extends JPanel {
                             ScreenBuffer sb = client.getScreenBuffer();
                             sb.setCursorAddress(selectionStartRow * sb.getCols() + selectionStartCol);
                             clearSelection();
+                            refreshScreen();
+                            return;
                         }
                     }
                     repaint();
@@ -714,6 +725,9 @@ public class TerminalPanel extends JPanel {
     }
 
     private void refreshScreen() {
+        if (client != null) {
+            client.getScreenBuffer().updateDisplaySnapshot();
+        }
         repaint();
         // Notify parent to update status bar too
         Container parent = getParent();
@@ -779,6 +793,7 @@ public class TerminalPanel extends JPanel {
         cellHeight = fm.getHeight();
         fontAscent = fm.getAscent();
         fontDescent = fm.getDescent();
+        boldTerminalFont = terminalFont.deriveFont(Font.BOLD);
     }
 
     private void setupCursorBlink() {
@@ -818,6 +833,8 @@ public class TerminalPanel extends JPanel {
         Graphics2D g2 = (Graphics2D) g;
         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
         g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
+        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+        g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
 
         // Clear entire panel with background color
         g2.setColor(bgColor);
@@ -828,8 +845,8 @@ public class TerminalPanel extends JPanel {
         int oy = getRenderOffsetY();
 
         ScreenBuffer sb = client.getScreenBuffer();
-        int rows = sb.getRows();
-        int cols = sb.getCols();
+        int rows = sb.getDisplayRows();
+        int cols = sb.getDisplayCols();
         boolean isColorModel = client.getConfig().getModel().isColor();
 
         // Track current field attribute for monochrome color decisions
@@ -839,7 +856,7 @@ public class TerminalPanel extends JPanel {
         for (int row = 0; row < rows; row++) {
             for (int col = 0; col < cols; col++) {
                 int baddr = row * cols + col;
-                ExtendedAttribute ea = sb.getCell(baddr);
+                ExtendedAttribute ea = sb.getDisplayCell(baddr);
 
                 int x = ox + col * cellWidth;
                 int y = oy + row * cellHeight;
@@ -854,10 +871,7 @@ public class TerminalPanel extends JPanel {
                 if (ea.isFieldAttribute()) {
                     currentFA = ea.fa;
                     currentFieldEa = ea;
-                    // Field attributes display as blanks
-                    g2.setColor(this.bgColor);
-                    g2.fillRect(x, y, cellWidth, cellHeight);
-                    // Selection highlight on field attribute cells too
+                    // Selection highlight on field attribute cells
                     if (isCellSelected(row, col)) {
                         g2.setColor(SELECTION_COLOR);
                         g2.fillRect(x, y, cellWidth, cellHeight);
@@ -892,12 +906,9 @@ public class TerminalPanel extends JPanel {
                 // Handle invisible fields (zero intensity / password fields)
                 // Modern UX: render '*' for typed characters so user sees length/digit count
                 if (faIsZero(currentFA & 0xFF)) {
-                    g2.setColor(this.bgColor);
-                    g2.fillRect(x, y, cellWidth, cellHeight);
-
                     char ch = ea.ucs4;
                     if (ch > 0x20 && ch != 0xFF) {
-                        Font f = bold ? terminalFont.deriveFont(Font.BOLD) : terminalFont;
+                        Font f = bold ? boldTerminalFont : terminalFont;
                         g2.setFont(f);
                         g2.setColor(fgColor);
                         g2.drawString("*", x, y + fontAscent);
@@ -917,18 +928,39 @@ public class TerminalPanel extends JPanel {
                     bgColor = tmp;
                 }
 
-                // Draw background
+                // Draw background only if different from default panel bgColor or if inverted
+                if (!bgColor.equals(this.bgColor) || reverse) {
                     g2.setColor(bgColor);
                     g2.fillRect(x, y, cellWidth, cellHeight);
+                }
 
-                // Draw character
+                // Draw character or Programmed Symbol
+                int cs = (ea.cs != 0) ? (ea.cs & 0xFF) : (currentFieldEa != null ? (currentFieldEa.cs & 0xFF) : 0);
+                boolean drawnAsPs = false;
+                if (cs >= 0x40 && client.getProgramSymbolManager() != null) {
+                    org.lib3270j.graphics.ProgramSymbolSet.SymbolSlot slot = client.getProgramSymbolManager().getSymbol(cs, ea.ec & 0xFF);
+                    if (slot != null) {
+                        java.awt.image.BufferedImage img = slot.getScaledImage(cellWidth, cellHeight, fgColor.getRGB(), bgColor.getRGB());
+                        if (img != null) {
+                            g2.drawImage(img, x, y, null);
+                            drawnAsPs = true;
+                        }
+                    }
+                }
+
+                if (!drawnAsPs) {
                     char ch = ea.ucs4;
                     if (ch > 0x20 && ch != 0xFF) {
-                    Font f = bold ? terminalFont.deriveFont(Font.BOLD) : terminalFont;
+                        Font f = bold ? boldTerminalFont : terminalFont;
                         g2.setFont(f);
                         g2.setColor(fgColor);
+                        if (ch < 128) {
+                            g2.drawString(CHAR_STRINGS[ch], x, y + fontAscent);
+                        } else {
                             g2.drawString(String.valueOf(ch), x, y + fontAscent);
                         }
+                    }
+                }
 
                 // Draw underline
                 if (underline) {
@@ -945,15 +977,28 @@ public class TerminalPanel extends JPanel {
             }
         }
 
+        // Draw Vector Graphics Plane overlay if present
+        if (client.getGraphicsPlane() != null && client.getGraphicsPlane().hasContent()) {
+            int gridW = cols * cellWidth;
+            int gridH = rows * cellHeight;
+            client.getGraphicsPlane().resize(gridW, gridH);
+            int[] rgb = client.getGraphicsPlane().getRgbBuffer();
+            if (rgb != null) {
+                java.awt.image.BufferedImage img = new java.awt.image.BufferedImage(gridW, gridH, java.awt.image.BufferedImage.TYPE_INT_ARGB);
+                img.setRGB(0, 0, gridW, gridH, rgb, 0, gridW);
+                g2.drawImage(img, ox, oy, gridW, gridH, null);
+            }
+        }
+
         // Draw cursor
         if (cursorVisible && client.getConnectionState().isFullSession()) {
-            int curAddr = sb.getCursorAddress();
+            int curAddr = sb.getDisplayCursorAddress();
             int curRow = curAddr / cols;
             int curCol = curAddr % cols;
             int cx = ox + curCol * cellWidth;
             int cy = oy + curRow * cellHeight;
 
-            g2.setColor(new Color(255, 255, 255, 180));
+            g2.setColor(CURSOR_COLOR);
             g2.setXORMode(bgColor);
             g2.fillRect(cx, cy, cellWidth, cellHeight);
             g2.setPaintMode();

j3270/src/main/java/org/pubvm/j3270/ui/UntrustedCertificateDialog.java

@@ -0,0 +1,153 @@
+package org.pubvm.j3270.ui;
+
+import javax.swing.*;
+import java.awt.*;
+import java.security.MessageDigest;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.text.SimpleDateFormat;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Modal dialog for inspecting and confirming untrusted TLS/SSL server certificates.
+ */
+public class UntrustedCertificateDialog extends JDialog {
+
+    private boolean accepted = false;
+
+    public UntrustedCertificateDialog(Frame parent, String host, int port, X509Certificate[] chain, CertificateException exception) {
+        super(parent, "Untrusted SSL/TLS Certificate", true);
+        buildUI(host, port, chain, exception);
+        pack();
+        setLocationRelativeTo(parent);
+        setResizable(false);
+    }
+
+    private void buildUI(String host, int port, X509Certificate[] chain, CertificateException exception) {
+        JPanel mainPanel = new JPanel(new BorderLayout(12, 12));
+        mainPanel.setBorder(BorderFactory.createEmptyBorder(16, 16, 16, 16));
+        mainPanel.setBackground(new Color(30, 30, 30));
+
+        // Header
+        JPanel headerPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 0));
+        headerPanel.setBackground(new Color(30, 30, 30));
+        JLabel iconLabel = new JLabel("⚠️");
+        iconLabel.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 28));
+        headerPanel.add(iconLabel);
+
+        JPanel titleBox = new JPanel(new GridLayout(2, 1, 0, 2));
+        titleBox.setBackground(new Color(30, 30, 30));
+        JLabel titleLabel = new JLabel("Untrusted SSL Certificate");
+        titleLabel.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 16));
+        titleLabel.setForeground(new Color(255, 180, 80));
+        titleBox.add(titleLabel);
+
+        JLabel subtitleLabel = new JLabel("The server certificate for " + host + ":" + port + " could not be verified.");
+        subtitleLabel.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 12));
+        subtitleLabel.setForeground(new Color(180, 180, 180));
+        titleBox.add(subtitleLabel);
+        headerPanel.add(titleBox);
+        mainPanel.add(headerPanel, BorderLayout.NORTH);
+
+        // Certificate Details Area
+        X509Certificate cert = (chain != null && chain.length > 0) ? chain[0] : null;
+        StringBuilder sb = new StringBuilder();
+        if (exception != null) {
+            sb.append("Validation Error:\n  ").append(exception.getMessage() != null ? exception.getMessage() : exception.toString()).append("\n\n");
+        }
+        if (cert != null) {
+            sb.append("Subject:\n  ").append(cert.getSubjectX500Principal().getName()).append("\n\n");
+            sb.append("Issuer:\n  ").append(cert.getIssuerX500Principal().getName()).append("\n\n");
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
+            sb.append("Validity:\n  From: ").append(sdf.format(cert.getNotBefore()))
+              .append("\n  To:   ").append(sdf.format(cert.getNotAfter())).append("\n\n");
+            sb.append("Serial Number:\n  ").append(cert.getSerialNumber().toString(16).toUpperCase()).append("\n\n");
+            sb.append("SHA-256 Fingerprint:\n  ").append(computeFingerprint(cert, "SHA-256")).append("\n\n");
+            sb.append("SHA-1 Fingerprint:\n  ").append(computeFingerprint(cert, "SHA-1"));
+        } else {
+            sb.append("No peer certificate information available.");
+        }
+
+        JTextArea detailsArea = new JTextArea(sb.toString());
+        detailsArea.setEditable(false);
+        detailsArea.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 12));
+        detailsArea.setBackground(new Color(20, 20, 20));
+        detailsArea.setForeground(new Color(210, 210, 210));
+        detailsArea.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+
+        JScrollPane scrollPane = new JScrollPane(detailsArea);
+        scrollPane.setPreferredSize(new Dimension(520, 260));
+        scrollPane.setBorder(BorderFactory.createLineBorder(new Color(60, 60, 60)));
+        mainPanel.add(scrollPane, BorderLayout.CENTER);
+
+        // Buttons
+        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 10, 0));
+        buttonPanel.setBackground(new Color(30, 30, 30));
+
+        JButton cancelBtn = new JButton("Cancel Connection");
+        cancelBtn.setBackground(new Color(60, 60, 60));
+        cancelBtn.setForeground(new Color(220, 220, 220));
+        cancelBtn.addActionListener(e -> {
+            accepted = false;
+            dispose();
+        });
+
+        JButton trustBtn = new JButton("Connect Anyway");
+        trustBtn.setBackground(new Color(180, 100, 40));
+        trustBtn.setForeground(Color.WHITE);
+        trustBtn.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 13));
+        trustBtn.addActionListener(e -> {
+            accepted = true;
+            dispose();
+        });
+
+        buttonPanel.add(cancelBtn);
+        buttonPanel.add(trustBtn);
+        mainPanel.add(buttonPanel, BorderLayout.SOUTH);
+
+        setContentPane(mainPanel);
+        getRootPane().setDefaultButton(trustBtn);
+    }
+
+    public boolean isAccepted() {
+        return accepted;
+    }
+
+    private static String computeFingerprint(X509Certificate cert, String algorithm) {
+        try {
+            MessageDigest md = MessageDigest.getInstance(algorithm);
+            byte[] digest = md.digest(cert.getEncoded());
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < digest.length; i++) {
+                if (i > 0) sb.append(':');
+                sb.append(String.format("%02X", digest[i]));
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            return "Unable to compute fingerprint: " + e.getMessage();
+        }
+    }
+
+    /**
+     * Show the prompt modal dialog on the Swing EDT and return user choice.
+     */
+    public static boolean showPrompt(Frame parent, String host, int port, X509Certificate[] chain, CertificateException exception) {
+        if (SwingUtilities.isEventDispatchThread()) {
+            UntrustedCertificateDialog dialog = new UntrustedCertificateDialog(parent, host, port, chain, exception);
+            dialog.setVisible(true);
+            return dialog.isAccepted();
+        } else {
+            AtomicBoolean result = new AtomicBoolean(false);
+            try {
+                SwingUtilities.invokeAndWait(() -> {
+                    UntrustedCertificateDialog dialog = new UntrustedCertificateDialog(parent, host, port, chain, exception);
+                    dialog.setVisible(true);
+                    result.set(dialog.isAccepted());
+                });
+            } catch (Exception e) {
+                return false;
+            }
+            return result.get();
+        }
+    }
+}

lib3270j/build.gradle

@@ -3,6 +3,12 @@ plugins {
 }
 
 dependencies {
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+}
+
+test {
+    useJUnitPlatform()
 }
 
 jar {

lib3270j/src/main/java/org/lib3270j/ConnectionConfig.java

@@ -11,9 +11,14 @@ public class ConnectionConfig {
     private String luName = null;
     private boolean extendedDataStream = true;
     private boolean useTls = false;
+    private boolean tlsVerifyCert = true;
+    private org.lib3270j.tls.TlsCertificateVerifier certificateVerifier = null;
+    private String sslProtocol = "TLS";
     private int connectTimeoutMs = 15000;
     private int nopIntervalSeconds = 0;
     private String terminalName = null; // override terminal type string
+    private boolean tn3270eEnabled = true;
+    private org.lib3270j.graphics.GraphicsMode graphicsMode = org.lib3270j.graphics.GraphicsMode.BOTH;
 
     public ConnectionConfig() {}
 
@@ -22,12 +27,25 @@ public class ConnectionConfig {
         this.port = port;
     }
 
+    public ConnectionConfig(String host, int port, boolean useTls) {
+        this.host = host;
+        this.port = port;
+        this.useTls = useTls;
+    }
+
     public ConnectionConfig(String host, int port, TerminalModel model) {
         this.host = host;
         this.port = port;
         this.model = model;
     }
 
+    public ConnectionConfig(String host, int port, TerminalModel model, boolean useTls) {
+        this.host = host;
+        this.port = port;
+        this.model = model;
+        this.useTls = useTls;
+    }
+
     public String getHost()                   { return host; }
     public void setHost(String host)          { this.host = host; }
 
@@ -46,15 +64,101 @@ public class ConnectionConfig {
     public boolean isUseTls()                 { return useTls; }
     public void setUseTls(boolean useTls)     { this.useTls = useTls; }
 
+    public boolean isTlsVerifyCert()          { return tlsVerifyCert; }
+    public void setTlsVerifyCert(boolean verify) { this.tlsVerifyCert = verify; }
+
+    public boolean isTn3270eEnabled()         { return tn3270eEnabled; }
+    public void setTn3270eEnabled(boolean enabled) { this.tn3270eEnabled = enabled; }
+
+    public org.lib3270j.tls.TlsCertificateVerifier getCertificateVerifier() { return certificateVerifier; }
+    public void setCertificateVerifier(org.lib3270j.tls.TlsCertificateVerifier verifier) { this.certificateVerifier = verifier; }
+
+    public String getSslProtocol()            { return sslProtocol; }
+    public void setSslProtocol(String protocol) { this.sslProtocol = protocol; }
+
     public int getConnectTimeoutMs()          { return connectTimeoutMs; }
     public void setConnectTimeoutMs(int ms)   { this.connectTimeoutMs = ms; }
 
     public int getNopIntervalSeconds()        { return nopIntervalSeconds; }
     public void setNopIntervalSeconds(int s)  { this.nopIntervalSeconds = s; }
 
+    public org.lib3270j.graphics.GraphicsMode getGraphicsMode() { return graphicsMode; }
+    public void setGraphicsMode(org.lib3270j.graphics.GraphicsMode mode) {
+        this.graphicsMode = (mode != null) ? mode : org.lib3270j.graphics.GraphicsMode.NONE;
+    }
+
     public String getTerminalName()           { return terminalName; }
     public void setTerminalName(String name)  { this.terminalName = name; }
 
+    /**
+     * Parse a host connection string which may include prefixes for TLS (e.g. "L:host:port", "ssl:host:port", "y:host:port"),
+     * plain TN3270 (e.g. "P:host:port", "plain:host:port", "non-e:host:port"), or standard "host:port" formats.
+     */
+    public static ConnectionConfig parseHostString(String hostStr, int defaultPort, TerminalModel defaultModel) {
+        if (hostStr == null || hostStr.trim().isEmpty()) {
+            return new ConnectionConfig("localhost", defaultPort, defaultModel);
+        }
+        String s = hostStr.trim();
+        boolean tls = false;
+        boolean tn3270e = true;
+
+        // Parse chained x3270-style prefixes (e.g. "L:P:host:port" or "P:host:port")
+        boolean prefixFound = true;
+        while (prefixFound) {
+            prefixFound = false;
+            if (s.startsWith("L:") || s.startsWith("l:") || s.startsWith("Y:") || s.startsWith("y:")) {
+                tls = true;
+                s = s.substring(2);
+                prefixFound = true;
+            } else if (s.toLowerCase().startsWith("ssl:") || s.toLowerCase().startsWith("tls:")) {
+                tls = true;
+                s = s.substring(4);
+                prefixFound = true;
+            } else if (s.startsWith("N:") || s.startsWith("n:") || s.toLowerCase().startsWith("notls:") || s.toLowerCase().startsWith("nossl:")) {
+                tls = false;
+                int colon = s.indexOf(':');
+                s = s.substring(colon + 1);
+                prefixFound = true;
+            } else if (s.startsWith("P:") || s.startsWith("p:")) {
+                tn3270e = false;
+                s = s.substring(2);
+                prefixFound = true;
+            } else if (s.toLowerCase().startsWith("plain:") || s.toLowerCase().startsWith("non-e:")) {
+                tn3270e = false;
+                int colon = s.indexOf(':');
+                s = s.substring(colon + 1);
+                prefixFound = true;
+            }
+        }
+
+        String host = s;
+        int port = (defaultPort > 0) ? defaultPort : (tls ? 992 : 23);
+
+        // Check for host:port (handle IPv6 [::1]:port)
+        if (s.startsWith("[") && s.contains("]")) {
+            int closeBracket = s.indexOf(']');
+            host = s.substring(1, closeBracket);
+            if (s.length() > closeBracket + 1 && s.charAt(closeBracket + 1) == ':') {
+                try {
+                    port = Integer.parseInt(s.substring(closeBracket + 2));
+                } catch (NumberFormatException ignored) {}
+            }
+        } else {
+            int colon = s.lastIndexOf(':');
+            if (colon > 0 && colon < s.length() - 1) {
+                try {
+                    port = Integer.parseInt(s.substring(colon + 1));
+                    host = s.substring(0, colon);
+                } catch (NumberFormatException ignored) {}
+            }
+        }
+
+        ConnectionConfig config = new ConnectionConfig(host, port, defaultModel != null ? defaultModel : TerminalModel.IBM_3279_4);
+        config.setUseTls(tls);
+        config.setTn3270eEnabled(tn3270e);
+        return config;
+    }
+
     /**
      * Get the effective terminal type string to send during negotiation.
      */

lib3270j/src/main/java/org/lib3270j/Telnet3270Client.java

@@ -46,12 +46,14 @@ public class Telnet3270Client {
         this.translator = new EbcdicTranslator();
         this.screenBuffer = new ScreenBuffer(config.getModel(), translator);
         this.dsProcessor = new DataStreamProcessor(screenBuffer, translator);
+        this.dsProcessor.getQueryReplyBuilder().setGraphicsMode(config.getGraphicsMode());
         this.fsm = new TelnetFSM(config, screenBuffer, dsProcessor);
         this.inputProcessor = new InputProcessor(screenBuffer, translator, fsm);
 
         // Wire up the output sender: DSProcessor -> FSM -> TelnetConnection
         dsProcessor.setOutputSender(fsm::send3270Data);
         dsProcessor.setInputProcessor(inputProcessor);
+        inputProcessor.setGraphicsPlane(dsProcessor.getGraphicsPlane());
     }
 
     /**
@@ -122,6 +124,16 @@ public class Telnet3270Client {
     /** Get the connection config. */
     public ConnectionConfig getConfig() { return config; }
 
+    /** Set a custom or interactive TLS certificate verifier callback. */
+    public void setTlsCertificateVerifier(org.lib3270j.tls.TlsCertificateVerifier verifier) {
+        config.setCertificateVerifier(verifier);
+    }
+
+    /** Get the active SSLSession if connected over TLS, or null. */
+    public javax.net.ssl.SSLSession getSslSession() {
+        return connection.getSslSession();
+    }
+
     // ========== Convenience input methods ==========
 
     /** Type a character at the cursor position. */
@@ -210,4 +222,16 @@ public class Telnet3270Client {
     public void sysReq()      { inputProcessor.sysReq(); }
     /** Reset (unlock keyboard). */  
     public void reset()       { inputProcessor.reset(); }
+
+    public org.lib3270j.graphics.ProgramSymbolManager getProgramSymbolManager() {
+        return dsProcessor.getProgramSymbolManager();
+    }
+
+    public org.lib3270j.graphics.GraphicsPlane getGraphicsPlane() {
+        return dsProcessor.getGraphicsPlane();
+    }
+
+    public org.lib3270j.graphics.GocaDecoder getGocaDecoder() {
+        return dsProcessor.getGocaDecoder();
+    }
 }

lib3270j/src/main/java/org/lib3270j/charset/EbcdicTranslator.java

@@ -85,6 +85,20 @@ public class EbcdicTranslator {
         return (char) CP037_TO_UNICODE[ebc & 0xFF];
     }
 
+    /**
+     * Static helper to translate EBCDIC byte to Unicode character.
+     */
+    public static char toUnicode(int ebc) {
+        return (char) CP037_TO_UNICODE[ebc & 0xFF];
+    }
+
+    /**
+     * Static helper to translate EBCDIC byte to ASCII character.
+     */
+    public static char ebcdicToAscii(int ebc) {
+        return toUnicode(ebc);
+    }
+
     /**
      * Translate Unicode character to EBCDIC byte.
      * Returns -1 if the character cannot be mapped.

lib3270j/src/main/java/org/lib3270j/datastream/DataStreamProcessor.java

@@ -9,6 +9,7 @@ import static org.lib3270j.protocol.DS3270Constants.*;
 import java.io.ByteArrayOutputStream;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
@@ -38,6 +39,13 @@ public class DataStreamProcessor {
     // Input processor reference to manage keyboard locking state
     private org.lib3270j.input.InputProcessor inputProcessor;
 
+    // Graphics & Programmed Symbols
+    private final org.lib3270j.graphics.ProgramSymbolManager programSymbolManager = new org.lib3270j.graphics.ProgramSymbolManager();
+    private final org.lib3270j.graphics.GraphicsPlane graphicsPlane = new org.lib3270j.graphics.GraphicsPlane(800, 600);
+    private final org.lib3270j.graphics.GocaDecoder gocaDecoder = new org.lib3270j.graphics.GocaDecoder(graphicsPlane);
+    private final java.io.ByteArrayOutputStream gocaAccumulator = new java.io.ByteArrayOutputStream();
+    private int currentGocaSubtype = 0;
+
     /** Functional interface for sending output back through the telnet stack. */
     @FunctionalInterface
     public interface OutputSender {
@@ -50,6 +58,23 @@ public class DataStreamProcessor {
         this.qrBuilder = new QueryReplyBuilder(screen);
         this.outputBuffer = new byte[32768];
         this.outputPos = 0;
+        this.gocaDecoder.setProgramSymbolManager(programSymbolManager);
+    }
+
+    public QueryReplyBuilder getQueryReplyBuilder() {
+        return qrBuilder;
+    }
+
+    public org.lib3270j.graphics.ProgramSymbolManager getProgramSymbolManager() {
+        return programSymbolManager;
+    }
+
+    public org.lib3270j.graphics.GraphicsPlane getGraphicsPlane() {
+        return graphicsPlane;
+    }
+
+    public org.lib3270j.graphics.GocaDecoder getGocaDecoder() {
+        return gocaDecoder;
     }
 
     public void setOutputSender(OutputSender sender) {
@@ -81,19 +106,28 @@ public class DataStreamProcessor {
             return;
 
         int cmd = data[offset] & 0xFF;
-        log.info(">>> CMD: " + commandName(cmd) + " (0x" + String.format("%02x", cmd) + ") " + length + " bytes");
+        synchronized (screen.getRenderLock()) {
+            if (log.isLoggable(Level.FINE)) {
+                log.fine(">>> CMD: " + commandName(cmd) + " (0x" + String.format("%02x", cmd) + ") " + length + " bytes");
+            }
 
             switch (cmd) {
                 case CMD_W:
                 case SNA_CMD_W:
+                    programSymbolManager.commitStagedSymbols();
                     processWrite(data, offset, length, false);
                     break;
                 case CMD_EW:
                 case SNA_CMD_EW:
-                log.info(">>> ERASE/WRITE: clearing screen (default size)"); {
+                    programSymbolManager.commitStagedSymbols();
+                    if (log.isLoggable(Level.FINE)) {
+                        log.fine(">>> ERASE/WRITE: clearing screen (default size)");
+                    }
+                    {
                         int oldRows = screen.getRows();
                         int oldCols = screen.getCols();
                         screen.erase(false);
+                        graphicsPlane.clear();
                         processWrite(data, offset, length, true);
                         if (oldRows != screen.getRows() || oldCols != screen.getCols()) {
                             notifyScreenSizeChanged();
@@ -102,10 +136,15 @@ public class DataStreamProcessor {
                     break;
                 case CMD_EWA:
                 case SNA_CMD_EWA:
-                log.info(">>> ERASE/WRITE ALTERNATE: clearing screen (alt size)"); {
+                    programSymbolManager.commitStagedSymbols();
+                    if (log.isLoggable(Level.FINE)) {
+                        log.fine(">>> ERASE/WRITE ALTERNATE: clearing screen (alt size)");
+                    }
+                    {
                         int oldRows = screen.getRows();
                         int oldCols = screen.getCols();
                         screen.erase(true);
+                        graphicsPlane.clear();
                         processWrite(data, offset, length, true);
                         if (oldRows != screen.getRows() || oldCols != screen.getCols()) {
                             notifyScreenSizeChanged();
@@ -114,18 +153,22 @@ public class DataStreamProcessor {
                     break;
                 case CMD_RB:
                 case SNA_CMD_RB:
+                    programSymbolManager.commitStagedSymbols();
                     processReadBuffer();
                     break;
                 case CMD_RM:
                 case SNA_CMD_RM:
+                    programSymbolManager.commitStagedSymbols();
                     processReadModified(false);
                     break;
                 case CMD_RMA:
                 case SNA_CMD_RMA:
+                    programSymbolManager.commitStagedSymbols();
                     processReadModified(true);
                     break;
                 case CMD_EAU:
                 case SNA_CMD_EAU:
+                    programSymbolManager.commitStagedSymbols();
                     log.info(">>> EAU: erasing all unprotected fields");
                     screen.eraseAllUnprotected();
                     break;
@@ -144,9 +187,11 @@ public class DataStreamProcessor {
             // Translate EBCDIC to Unicode for display
             screen.translateToUnicode();
             screen.markAllChanged();
+            screen.updateDisplaySnapshot();
+        }
 
         // Debug: dump non-empty screen lines
-        if (cmd == SNA_CMD_EWA || cmd == CMD_EWA || cmd == SNA_CMD_EW || cmd == CMD_EW) {
+        if (log.isLoggable(Level.FINE) && (cmd == SNA_CMD_EWA || cmd == CMD_EWA || cmd == SNA_CMD_EW || cmd == CMD_EW)) {
             int r = screen.getRows();
             int c = screen.getCols();
             StringBuilder dump = new StringBuilder();
@@ -179,7 +224,7 @@ public class DataStreamProcessor {
                 }
             }
             if (dump.length() > 0) {
-                log.info("Screen content after " + commandName(cmd) + ":\n" + dump.toString());
+                log.fine("Screen content after " + commandName(cmd) + ":\n" + dump.toString());
             }
         }
     }
@@ -741,6 +786,7 @@ public class DataStreamProcessor {
                     if (fieldLen >= 4) {
                         boolean alt = (data[pos + 3] & 0xFF) == SF_ER_ALT;
                         screen.erase(alt);
+                        graphicsPlane.clear();
                         notifyScreenSizeChanged();
                     }
                     break;
@@ -751,6 +797,7 @@ public class DataStreamProcessor {
                     break;
                 case SF_CREATE_PART:
                     // Acknowledged — we use implicit partition
+                    graphicsPlane.clear();
                     break;
                 case SF_OUTBOUND_DS:
                     if (fieldLen > 5) {
@@ -765,6 +812,81 @@ public class DataStreamProcessor {
                         log.fine("SF_TRANSFER_DATA received but ftDft is null");
                     }
                     break;
+                case org.lib3270j.graphics.GocaConstants.SF_LOADPS_DIRECT: // 0x06: Load Programmed Symbols direct
+                    if (fieldLen > 3) {
+                        byte[] psData = new byte[fieldLen - 3];
+                        System.arraycopy(data, pos + 3, psData, 0, psData.length);
+                        programSymbolManager.loadps(psData);
+                    }
+                    break;
+                case org.lib3270j.graphics.GocaConstants.SF_LOADPS: { // 0x0F: 2-byte Structured Field prefix
+                    if (fieldLen >= 4) {
+                        int sfSubId = data[pos + 3] & 0xFF;
+                        switch (sfSubId) {
+                            case org.lib3270j.graphics.GocaConstants.SF_LOADPS_SUB: // 0x06: Load Programmed Symbols
+                                if (fieldLen > 4) {
+                                    byte[] psData = new byte[fieldLen - 4];
+                                    System.arraycopy(data, pos + 4, psData, 0, psData.length);
+                                    programSymbolManager.loadps(psData);
+                                }
+                                break;
+                            case org.lib3270j.graphics.GocaConstants.SF_OBJCNTL_SUB: // 0x11: Object Control (Procedure orders)
+                            case org.lib3270j.graphics.GocaConstants.SF_OBJPICT_SUB: // 0x10: Object Picture (Picture segments)
+                            case org.lib3270j.graphics.GocaConstants.SF_OBJDATA_SUB: { // 0x0F: Object Data (GOCA draw orders)
+                                int flags = (fieldLen >= 6) ? (data[pos + 5] & 0xC0) : 0xC0;
+                                int orderOffset = (fieldLen >= 7) ? (pos + 7) : (pos + 4);
+                                int orderLen = Math.max(0, fieldLen - (orderOffset - pos));
+
+                                graphicsPlane.setScreenDimensions(screen.getCols(), screen.getRows());
+
+                                if (flags == 0x80) { // SPAN_FIRST
+                                    gocaAccumulator.reset();
+                                    currentGocaSubtype = sfSubId;
+                                    if (orderLen > 0) {
+                                        gocaAccumulator.write(data, orderOffset, orderLen);
+                                    }
+                                } else if (flags == 0x00) { // SPAN_MIDDLE
+                                    if (orderLen > 0) {
+                                        gocaAccumulator.write(data, orderOffset, orderLen);
+                                    }
+                                } else if (flags == 0x40) { // SPAN_LAST
+                                    if (orderLen > 0) {
+                                        gocaAccumulator.write(data, orderOffset, orderLen);
+                                    }
+                                    byte[] fullStream = gocaAccumulator.toByteArray();
+                                    gocaAccumulator.reset();
+                                    if (currentGocaSubtype == org.lib3270j.graphics.GocaConstants.SF_OBJCNTL_SUB) {
+                                        gocaDecoder.processProcedureOrders(fullStream, 0, fullStream.length);
+                                    } else {
+                                        gocaDecoder.decodeStream(fullStream, 0, fullStream.length);
+                                    }
+                                    notifyScreenUpdated();
+                                } else { // SPAN_ONLY (0xC0)
+                                    gocaAccumulator.reset();
+                                    if (sfSubId == org.lib3270j.graphics.GocaConstants.SF_OBJCNTL_SUB) {
+                                        gocaDecoder.processProcedureOrders(data, orderOffset, orderLen);
+                                    } else {
+                                        gocaDecoder.decodeStream(data, orderOffset, orderLen);
+                                    }
+                                    notifyScreenUpdated();
+                                }
+                                break;
+                            }
+                            default:
+                                log.fine("Unknown SF 0x0F subtype: " + String.format("0x%02x", sfSubId));
+                                break;
+                        }
+                    }
+                    break;
+                }
+                case org.lib3270j.graphics.GocaConstants.SF_OBJDATA: // 0x85: Graphics Object Data / GOCA
+                case org.lib3270j.graphics.GocaConstants.SF_3270_G:  // 0x20: 3270 Graphics
+                    if (fieldLen > 3) {
+                        graphicsPlane.setScreenDimensions(screen.getCols(), screen.getRows());
+                        gocaDecoder.decodeStream(data, pos + 3, fieldLen - 3);
+                        notifyScreenUpdated();
+                    }
+                    break;
                 default:
                     log.fine("Unknown SF id: " + String.format("0x%02x", sfId));
                     break;
@@ -841,7 +963,7 @@ public class DataStreamProcessor {
             if ((i + 1) % 32 == 0)
                 sb.append("\n  ");
         }
-        log.info("Query reply (" + qr.length + " bytes):\n  " + sb.toString().trim());
+        log.warning(">>> SENDING Query Reply (" + qr.length + " bytes):\n  " + sb.toString().trim());
         if (outputSender != null) {
             outputSender.send3270Data(qr);
         }
@@ -856,7 +978,7 @@ public class DataStreamProcessor {
             if ((i + 1) % 32 == 0)
                 sb.append("\n  ");
         }
-        log.info("Requested query reply (" + qr.length + " bytes):\n  " + sb.toString().trim());
+        log.warning(">>> SENDING Requested Query Reply (" + qr.length + " bytes):\n  " + sb.toString().trim());
         if (outputSender != null) {
             outputSender.send3270Data(qr);
         }
@@ -887,4 +1009,10 @@ public class DataStreamProcessor {
             l.onScreenSizeChanged(screen.getRows(), screen.getCols());
         }
     }
+
+    private void notifyScreenUpdated() {
+        for (ScreenUpdateListener l : screenListeners) {
+            l.onScreenUpdated();
+        }
+    }
 }

lib3270j/src/main/java/org/lib3270j/datastream/QueryReplyBuilder.java

@@ -3,12 +3,13 @@ package org.lib3270j.datastream;
 import java.io.ByteArrayOutputStream;
 import java.util.logging.Logger;
 
+import org.lib3270j.graphics.GraphicsMode;
 import org.lib3270j.screen.ScreenBuffer;
 import static org.lib3270j.protocol.DS3270Constants.*;
 
 /**
  * Builds Query Reply structured fields in response to host Read Partition queries.
- * Equivalent to the do_qr_* functions in sf.c.
+ * Matches IBM 3270 Architecture (GA23-0059) and x3270 sf.c exact binary layout.
  */
 public class QueryReplyBuilder {
 
@@ -21,9 +22,10 @@ public class QueryReplyBuilder {
     private static final int Yr_3279_2 = 0x0002006f;
 
     private final ScreenBuffer screen;
+    private GraphicsMode graphicsMode = GraphicsMode.BOTH;
 
-    // Supported query reply codes (must match what we send in summary)
-    private static final int[] SUPPORTED_QR = {
+    // Base query reply codes (text mode)
+    private static final int[] SUPPORTED_QR_BASE = {
         QR_SUMMARY,      // 0x80 — summary must list itself
         QR_USABLE_AREA,  // 0x81
         QR_ALPHA_PART,   // 0x84
@@ -35,10 +37,45 @@ public class QueryReplyBuilder {
         QR_IMP_PART,     // 0xa6
     };
 
+    // Vector graphics query reply codes matching HOD DS3270.java line 1723
+    private static final int[] SUPPORTED_QR_VECTOR = {
+        QR_SUMMARY,      // 0x80
+        QR_USABLE_AREA,  // 0x81
+        QR_ALPHA_PART,   // 0x84
+        QR_CHARSETS,     // 0x85
+        QR_COLOR,        // 0x86
+        QR_HIGHLIGHTING, // 0x87
+        QR_REPLY_MODES,  // 0x88
+        QR_SAVE_RESTORE, // 0x8c
+        QR_DDM,          // 0x95
+        QR_TRANSPARENCY, // 0x99
+        QR_IMP_PART,     // 0xa6
+        QR_RPQ_NAMES,    // 0xa8
+        QR_GRAPHICS,     // 0xb0
+        QR_GIMAGE,       // 0xb1
+        QR_AUX_DEV,      // 0xb2
+        QR_OEM_FMT,      // 0xb3
+        QR_GCOLOR,       // 0xb4
+        QR_GSYMBOLS,     // 0xb6
+    };
+
     public QueryReplyBuilder(ScreenBuffer screen) {
         this.screen = screen;
     }
 
+    public QueryReplyBuilder(ScreenBuffer screen, GraphicsMode graphicsMode) {
+        this.screen = screen;
+        this.graphicsMode = (graphicsMode != null) ? graphicsMode : GraphicsMode.NONE;
+    }
+
+    public GraphicsMode getGraphicsMode() {
+        return graphicsMode;
+    }
+
+    public void setGraphicsMode(GraphicsMode graphicsMode) {
+        this.graphicsMode = (graphicsMode != null) ? graphicsMode : GraphicsMode.NONE;
+    }
+
     /**
      * Build all query replies as a single AID_SF + structured field response.
      */
@@ -66,16 +103,37 @@ public class QueryReplyBuilder {
         // Highlighting
         appendQueryReply(out, QR_HIGHLIGHTING, buildHighlighting());
 
-        // Reply Modes
+        // Reply Modes (0x88)
         appendQueryReply(out, QR_REPLY_MODES, buildReplyModes());
 
-        // Distributed Data Management (DFT File Transfer)
+        if (graphicsMode.isVectorGraphicsEnabled()) {
+            // Save/Restore (0x8C)
+            appendQueryReply(out, QR_SAVE_RESTORE, buildSaveRestore());
+        }
+
+        // Distributed Data Management (0x95)
         appendQueryReply(out, QR_DDM, buildDdm(4096));
 
-        // Implicit Partition
+        if (graphicsMode.isVectorGraphicsEnabled()) {
+            // Transparency (0x99)
+            appendQueryReply(out, QR_TRANSPARENCY, buildTransparency());
+        }
+
+        // Implicit Partition (0xA6)
         appendQueryReply(out, QR_IMP_PART, buildImplicitPartition(maxCols, maxRows));
 
-        log.info("Built " + out.size() + " bytes of all query replies");
+        // Vector Graphics QRs if enabled
+        if (graphicsMode.isVectorGraphicsEnabled()) {
+            appendQueryReply(out, QR_RPQ_NAMES, buildRpqNames()); // 0xA8
+            appendQueryReply(out, QR_GRAPHICS, buildGraphics());   // 0xB0
+            appendQueryReply(out, QR_GIMAGE, buildGImage());       // 0xB1
+            appendQueryReply(out, QR_AUX_DEV, buildAuxDev());       // 0xB2
+            appendOemFmt(out);                                     // 0xB3
+            appendQueryReply(out, QR_GCOLOR, buildGColor());       // 0xB4
+            appendQueryReply(out, QR_GSYMBOLS, buildGSymbols());   // 0xB6
+        }
+
+        log.info("Built " + out.size() + " bytes of all query replies (graphicsMode=" + graphicsMode + ")");
         return out.toByteArray();
     }
 
@@ -116,14 +174,75 @@ public class QueryReplyBuilder {
                 case QR_REPLY_MODES:
                     appendQueryReply(out, QR_REPLY_MODES, buildReplyModes());
                     break;
+                case QR_SAVE_RESTORE:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_SAVE_RESTORE, buildSaveRestore());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
                 case QR_DDM:
                     appendQueryReply(out, QR_DDM, buildDdm(4096));
                     break;
+                case QR_TRANSPARENCY:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_TRANSPARENCY, buildTransparency());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
                 case QR_IMP_PART:
                     appendQueryReply(out, QR_IMP_PART, buildImplicitPartition(maxCols, maxRows));
                     break;
+                case QR_RPQ_NAMES:
                 case QR_RPQNAMES:
-                    appendQueryReply(out, QR_RPQNAMES, new byte[0]);
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_RPQ_NAMES, buildRpqNames());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_GRAPHICS:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_GRAPHICS, buildGraphics());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_GIMAGE:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_GIMAGE, buildGImage());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_AUX_DEV:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_AUX_DEV, buildAuxDev());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_OEM_FMT:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendOemFmt(out);
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_GCOLOR:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_GCOLOR, buildGColor());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
+                    break;
+                case QR_GSYMBOLS:
+                    if (graphicsMode.isVectorGraphicsEnabled()) {
+                        appendQueryReply(out, QR_GSYMBOLS, buildGSymbols());
+                    } else {
+                        appendQueryReply(out, QR_NULL, new byte[0]);
+                    }
                     break;
                 default:
                     // Unsupported query reply code — emit QR_NULL
@@ -148,7 +267,8 @@ public class QueryReplyBuilder {
 
     private byte[] buildSummary() {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
-        for (int code : SUPPORTED_QR) {
+        int[] codes = graphicsMode.isVectorGraphicsEnabled() ? SUPPORTED_QR_VECTOR : SUPPORTED_QR_BASE;
+        for (int code : codes) {
             out.write(code);
         }
         return out.toByteArray();
@@ -184,66 +304,81 @@ public class QueryReplyBuilder {
     private byte[] buildAlphaPartitions(int maxRows) {
         int bufSize = screen.getMaxCols() * screen.getMaxRows();
         ByteArrayOutputStream out = new ByteArrayOutputStream(4);
-        out.write(0x00);                     // max partitions (1 partition)
+        out.write(0x00);                     // max partitions (1 byte: 0x00 = 1 partition)
         out.write((bufSize >> 8) & 0xFF);    // total partition storage high
         out.write(bufSize & 0xFF);           // total partition storage low
-        out.write(0x00);                     // no special features
+        out.write(0x00);                     // flags
         return out.toByteArray();
     }
 
     private byte[] buildCharsets() {
-        ByteArrayOutputStream out = new ByteArrayOutputStream(32);
-        out.write(0x82); // flags: GE, CGCSGID present
+        if (graphicsMode.isProgrammedSymbolsEnabled()) {
+            // Programmed Symbols mode (3279 PS with LoadPS 0x0A, flags1 = 0xA2 for GE + PS + CGCSGID)
+            ByteArrayOutputStream out = new ByteArrayOutputStream(65);
+            out.write(0xa2); // flags: GE (0x80), PS/Loadable Charsets (0x20), CGCSGID present (0x02)
             out.write(0x00); // more flags
-        out.write(SW_3279_2); // SDW - default char width
-        out.write(SH_3279_2); // SDH - default char height
-        out.write(0x00); // Load PS format types supported: none
+            out.write(SW_3279_2); // SDW (9)
+            out.write(SH_3279_2); // SDH (12)
+            out.write(0x0a); // Load PS format types supported: Format 1 and Format 3
             out.write(0x00); // Load PS device type (high)
             out.write(0x00); // Load PS device type (low)
             out.write(0x00); // reserved
-        out.write(0x07); // DL = 7 bytes per descriptor (non-DBCS)
-        // Descriptor 1 (SET 0): default character set
-        out.write(0x00); // SET 0
-        out.write(0x10); // FLAGS: non-loadable, single-plane, single-byte, no compare
-        out.write(0x00); // LCID 0
-        out.write(0x02); // CGCSGID (4 bytes) = 0x02b90025 (CGEN|CSET)
-        out.write(0xb9);
-        out.write(0x00);
-        out.write(0x25);
+            out.write(0x07); // DL = 7 bytes per descriptor
+            // Descriptor 1 (SET 0): default character set (non-loadable, single plane, CP037)
+            out.write(0x00); out.write(0x10); out.write(0x00); out.write(0x02); out.write(0xb9); out.write(0x00); out.write(0x25);
             // Descriptor 2 (SET 1): APL/GE character set
-        out.write(0x01); // SET 1
-        out.write(0x00); // FLAGS: non-loadable, single-plane, single-byte, no compare
-        out.write(0xf1); // LCID 0xf1
-        out.write(0x03); // CGCSGID: 3179-style APL2 = 0x03c30136
-        out.write(0xc3);
-        out.write(0x01);
-        out.write(0x36);
+            out.write(0x01); out.write(0x00); out.write(0xf1); out.write(0x03); out.write(0xc3); out.write(0x01); out.write(0x36);
+            // Loadable Single-Plane PS Sets (PSA, PSB: Slots 2, 3) - Flags = 0x80 (Loadable, single plane)
+            out.write(0x02); out.write(0x80); out.write(0x40); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            out.write(0x03); out.write(0x80); out.write(0x41); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            // Loadable Triple-Plane PS Sets (PSC, PSD, PSE, PSF: Slots 4, 5, 6, 7) - Flags = 0xC0 (0x80 Loadable | 0x40 Triple-plane)
+            out.write(0x04); out.write(0xc0); out.write(0x42); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            out.write(0x05); out.write(0xc0); out.write(0x43); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            out.write(0x06); out.write(0xc0); out.write(0x44); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            out.write(0x07); out.write(0xc0); out.write(0x45); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+            return out.toByteArray();
+        }
+
+        // Standard 3179G / Base character sets (matches sf.c / HOD)
+        ByteArrayOutputStream out = new ByteArrayOutputStream(23);
+        out.write(0x82); // flags: GE, CGCSGID present
+        out.write(0x00); // more flags
+        out.write(SW_3279_2); // SDW - default char width (9)
+        out.write(SH_3279_2); // SDH - default char height (12)
+        out.write(0x00); // LoadPS format (0x00)
+        out.write(0x00);
+        out.write(0x00);
+        out.write(0x00);
+        out.write(0x07); // DL = 7
+        // Set 0 (Base EBCDIC - Non-loadable, single plane, CP037)
+        out.write(0x00); out.write(0x10); out.write(0x00); out.write(0x02); out.write(0xb9); out.write(0x00); out.write(0x25);
+        // Set 1 (APL/Text)
+        out.write(0x01); out.write(0x00); out.write(0xf1); out.write(0x03); out.write(0xc3); out.write(0x01); out.write(0x36);
         return out.toByteArray();
     }
 
     private byte[] buildColor() {
-        ByteArrayOutputStream out = new ByteArrayOutputStream(36);
-        int colorMax = 16;
-        out.write(0x00);                     // no options
-        out.write(colorMax);                 // number of colors
-        out.write(0x00);                     // default color pair: attribute
-        out.write(0xf0 + HOST_COLOR_GREEN);  // default color: green
-        for (int i = 0xf1; i < 0xf1 + colorMax - 1; i++) {
-            out.write(i);                    // color attribute value
-            out.write(i);                    // maps to itself (color mode)
-        }
-        return out.toByteArray();
+        // Alphanumeric Color (matches HOD: 8 pairs, F1..F7 + default F4 green, 18 bytes payload / 22 bytes total)
+        return new byte[] {
+            0x00, 0x08, 0x00, (byte) 0xF4,
+            (byte) 0xF1, (byte) 0xF1, // Blue
+            (byte) 0xF2, (byte) 0xF2, // Red
+            (byte) 0xF3, (byte) 0xF3, // Pink
+            (byte) 0xF4, (byte) 0xF4, // Green
+            (byte) 0xF5, (byte) 0xF5, // Turquoise
+            (byte) 0xF6, (byte) 0xF6, // Yellow
+            (byte) 0xF7, (byte) 0xF7  // Neutral/White
+        };
     }
 
     private byte[] buildHighlighting() {
-        ByteArrayOutputStream out = new ByteArrayOutputStream(11);
-        out.write(5);               // 5 pairs
-        out.write(XAH_DEFAULT);     out.write(XAH_NORMAL);
-        out.write(XAH_BLINK);       out.write(XAH_BLINK);
-        out.write(XAH_REVERSE);     out.write(XAH_REVERSE);
-        out.write(XAH_UNDERSCORE);  out.write(XAH_UNDERSCORE);
-        out.write(XAH_INTENSIFY);   out.write(XAH_INTENSIFY);
-        return out.toByteArray();
+        // Highlighting (matches HOD: 4 pairs: default F0, Blink F1, Reverse F2, Underscore F4, 9 bytes payload / 13 bytes total)
+        return new byte[] {
+            0x04, 0x00, (byte) 0xF0,
+            (byte) 0xF1, (byte) 0xF1,
+            (byte) 0xF2, (byte) 0xF2,
+            (byte) 0xF4, (byte) 0xF4
+        };
     }
 
     private byte[] buildReplyModes() {
@@ -265,21 +400,20 @@ public class QueryReplyBuilder {
 
     private byte[] buildImplicitPartition(int maxCols, int maxRows) {
         ByteArrayOutputStream out = new ByteArrayOutputStream(22);
-        // Implicit partition sizes SDP (Self-Defining Parameter)
+        // Implicit partition sizes, 2 self-defining parameters
 
+        // SDP 1: Default screen size (Model 2: 80x24)
         out.write(0x00); // flags
         out.write(0x00); // reserved
-        // SDP 1: Implicit partition sizes
-        out.write(0x00); // SDP length high byte
-        out.write(0x0b); // SDP length low byte (11 bytes: 2 len + 1 type + 1 res + 8 dims)
+        out.write(0x0b); // SDP length (11 bytes)
         out.write(0x01); // SDP type: implicit partition sizes
         out.write(0x00); // reserved
-        // Default dimensions (Model 2: 80x24)
+        // Default size
         out.write((MODEL_2_COLS >> 8) & 0xFF);
         out.write(MODEL_2_COLS & 0xFF);
         out.write((MODEL_2_ROWS >> 8) & 0xFF);
         out.write(MODEL_2_ROWS & 0xFF);
-        // Alternate dimensions
+        // Alternate size (Model 4: 80x43, Model 5: 132x27, etc.)
         out.write((maxCols >> 8) & 0xFF);
         out.write(maxCols & 0xFF);
         out.write((maxRows >> 8) & 0xFF);
@@ -287,4 +421,83 @@ public class QueryReplyBuilder {
 
         return out.toByteArray();
     }
+
+    private byte[] buildGraphics() {
+        return new byte[]{ (byte) 0x80, 0x02, 0x00, 0x00, 0x00, (byte) 0xFC, 0x00 };
+    }
+
+    private byte[] buildGImage() {
+        return new byte[]{
+            0x00, 0x01, 0x00, 0x00, 0x00, (byte) 0xFC, 0x00,
+            0x06, 0x40, 0x06, 0x40, 0x06, 0x01,
+            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xF0
+        };
+    }
+
+    private byte[] buildAuxDev() {
+        return new byte[]{
+            0x00, 0x09, 0x00, 0x07,
+            0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04,
+            0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08
+        };
+    }
+
+    private byte[] buildSaveRestore() {
+        // HOD DS3270.java line 1768: 6 bytes payload
+        return new byte[]{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    }
+
+    private byte[] buildTransparency() {
+        // HOD DS3270.java line 1782: 2 bytes payload
+        return new byte[]{ 0x00, 0x00 };
+    }
+
+    private byte[] buildRpqNames() {
+        // HOD DS3270.java line 1798: 5 bytes payload
+        return new byte[]{ 0x02, 0x00, (byte) 0xF0, (byte) 0xFF, (byte) 0xFF };
+    }
+
+    private void appendOemFmt(ByteArrayOutputStream out) {
+        // HOD DS3270.java line 1814: 4 distinct OEM format sub-fields
+        appendQueryReply(out, QR_OEM_FMT, new byte[]{
+            0x00, 0x03, 0x02, (byte) 0x90, 0x09, 0x01, 0x00, 0x03, 0x02, (byte) 0x80, 0x00, 0x7F, (byte) 0xFF
+        });
+        appendQueryReply(out, QR_OEM_FMT, new byte[]{
+            0x00, 0x04, 0x08, 0x40, 0x07, 0x03, 0x00, 0x03, (byte) 0x80, 0x00, 0x02
+        });
+        appendQueryReply(out, QR_OEM_FMT, new byte[]{
+            0x00, 0x05, 0x02, (byte) 0x80, 0x09, 0x01, 0x00, 0x01, 0x02, (byte) 0x80, 0x00, 0x7F, (byte) 0xFF
+        });
+        appendQueryReply(out, QR_OEM_FMT, new byte[]{
+            0x00, 0x07, 0x08, 0x40, 0x07, 0x03, 0x00, 0x01, 0x00, 0x00, 0x1C
+        });
+    }
+
+    private byte[] buildGColor() {
+        ByteArrayOutputStream out = new ByteArrayOutputStream(110);
+        out.write(0x00); out.write(0x04); out.write(0x00); out.write(0xFF); out.write(0xFF);
+        out.write(0x00); out.write(0x10); out.write(0x00); out.write(0x10);
+
+        for (int i = 0; i < 16; i++) {
+            out.write(0x00);
+            out.write(i);
+            int argb = org.lib3270j.graphics.GocaConstants.GOCA_COLORS[i];
+            int r = (argb >> 16) & 0xFF;
+            int g = (argb >> 8) & 0xFF;
+            int b = argb & 0xFF;
+            out.write(r);
+            out.write(g);
+            out.write(b);
+            out.write(0x00); // 6th byte in HOD color table
+        }
+        return out.toByteArray();
+    }
+
+    private byte[] buildGSymbols() {
+        return new byte[]{
+            0x00, 0x00, 0x0C, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x12,
+            0x01, 0x00, 0x00, (byte) 0xF0, (byte) 0xC1, (byte) 0xC1, 0x00, 0x00,
+            0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+        };
+    }
 }

lib3270j/src/main/java/org/lib3270j/graphics/GocaConstants.java

@@ -0,0 +1,184 @@
+package org.lib3270j.graphics;
+
+/**
+ * Constants for IBM 3179G / 3270-PC GOCA (Graphics Object Content Architecture)
+ * vector graphics and Programmed Symbols (PS).
+ */
+public final class GocaConstants {
+
+    private GocaConstants() {}
+
+    // Structured Field IDs
+    public static final int SF_LOADPS   = 0x0F; // 2-byte Structured Field prefix (or 0x06 for direct Load PS)
+    public static final int SF_LOADPS_DIRECT = 0x06; // Load Programmed Symbols direct SFID
+    public static final int SF_OBJCNTL  = 0x24; // Object Control
+    public static final int SF_OBJDATA  = 0x85; // Graphics Object Data
+    public static final int SF_3270_G   = 0x20; // 3270 Graphics / Picture
+
+    // Structured Field Sub-IDs (for SF 0x0F)
+    public static final int SF_LOADPS_SUB  = 0x06; // Load Programmed Symbols
+    public static final int SF_LOADLT_SUB  = 0x07; // Load Line Type / Symbol Set
+    public static final int SF_OBJDATA_SUB = 0x0F; // Graphics Object Data (GOCA draw orders)
+    public static final int SF_OBJPICT_SUB = 0x10; // Graphics Object Picture (Segment draw orders)
+    public static final int SF_OBJCNTL_SUB = 0x11; // Graphics Object Control (Procedure orders)
+
+    // Procedure Orders (for SF_OBJCNTL_SUB 0x11)
+    public static final int P_NOP1      = 0x00; // Procedure NOOP
+    public static final int P_COMT      = 0x01; // Procedure Comment
+    public static final int P_ATTCUR    = 0x08; // Attach Graphic Cursor
+    public static final int P_DETCUR    = 0x09; // Detach Graphic Cursor
+    public static final int P_ERASE     = 0x0A; // Erase Graphics Presentation Space
+    public static final int P_STOPDR    = 0x0F; // Stop Draw
+    public static final int P_SCUDEF    = 0x21; // Set Current Defaults
+    public static final int P_BEGPROC   = 0x30; // Begin Procedure
+    public static final int P_SETCUR    = 0x31; // Set Graphic Cursor Position
+
+    // Coordinate space
+    public static final int VIRTUAL_COORD_MAX = 4096;
+
+    // GOCA Drawing / Segment Orders
+    public static final int G_NOP1      = 0x00; // NOOP 1-byte
+    public static final int G_COMT      = 0x01; // Comment
+    public static final int G_GSMC      = 0x07; // Set Marker Color
+    public static final int G_GSPS      = 0x08; // Set Pattern Set
+    public static final int G_GSCOL     = 0x0A; // Set Color
+    public static final int G_GSMX      = 0x0C; // Set Foreground Mix
+    public static final int G_GSBMX     = 0x0D; // Set Background Mix
+    public static final int G_GSFLW     = 0x11; // Set Fractional Line Width
+    public static final int G_GSLT      = 0x18; // Set Line Type
+    public static final int G_GSLW      = 0x19; // Set Line Width
+    public static final int G_GSMS      = 0x1B; // Set Marker Size
+    public static final int G_GSCP      = 0x21; // Set Current Position
+    public static final int G_GSAP      = 0x22; // Arc Parameters
+    public static final int G_GSECOL    = 0x26; // Set Extended Color
+    public static final int G_GSVW      = 0x27; // Set Viewing Window
+    public static final int G_GSPT      = 0x28; // Set Pattern Symbol
+    public static final int G_GSMT      = 0x29; // Set Marker Symbol / Type
+    public static final int G_GSCH      = 0x33; // Set Character Cell
+    public static final int G_GSCA      = 0x34; // Set Character Angle
+    public static final int G_GSCR      = 0x35; // Set Character Shear
+    public static final int G_GSMCEL    = 0x37; // Set Marker Cell
+    public static final int G_GSCS      = 0x38; // Set Character Set
+    public static final int G_GSMP      = 0x39; // Set Marker Precision
+    public static final int G_GSCD      = 0x3A; // Set Character Direction
+    public static final int G_GSCC      = 0x3B; // Set Character Precision
+    public static final int G_GSMS_SET  = 0x3C; // Set Marker Set
+    public static final int G_ENDPROLOGUE = 0x3E; // End Prologue
+    public static final int G_GPOP      = 0x3F; // Pop Attribute
+    public static final int G_GEAR      = 0x60; // End Area
+    public static final int G_GBAR      = 0x68; // Begin Area
+    public static final int G_BEGSEGM   = 0x70; // Begin Segment
+    public static final int G_ENDSEGM   = 0x71; // End Segment
+    public static final int G_GERASE    = 0x7E; // Erase Graphics Plane
+    public static final int G_GCLINE    = 0x81; // Line at Current Position
+    public static final int G_GCMRK     = 0x82; // Marker at Current Position
+    public static final int G_GCCHST    = 0x83; // Character String at Current Position
+    public static final int G_GCFLT     = 0x85; // Fillet at Current Position
+    public static final int G_GCARC     = 0x86; // Partial Arc at Current Position
+    public static final int G_GCFARC    = 0x87; // Full Arc at Current Position
+    public static final int G_GEIMG     = 0x91; // End Image
+    public static final int G_GIMD      = 0x92; // Image Data
+    public static final int G_GCRLIN    = 0xA1; // Relative Line at Current Position
+    public static final int G_GLINE     = 0xC1; // Line (Absolute)
+    public static final int G_GMRK      = 0xC2; // Marker (Absolute)
+    public static final int G_GCHST     = 0xC3; // Character String (Absolute)
+    public static final int G_GFLT      = 0xC5; // Fillet (Absolute)
+    public static final int G_GARC      = 0xC6; // Partial Arc (Absolute)
+    public static final int G_GFARC     = 0xC7; // Full Arc (Absolute)
+    public static final int G_GBIMG     = 0xD1; // Begin Image
+    public static final int G_GRLINE    = 0xE1; // Relative Line (Absolute Start)
+
+    // Line Types (GSLT)
+    public static final int LT_DEFAULT  = 0;
+    public static final int LT_DOT      = 1;
+    public static final int LT_SHORTDASH= 2;
+    public static final int LT_DASHDOT  = 3;
+    public static final int LT_DOUBLEDOT= 4;
+    public static final int LT_LONGDASH = 5;
+    public static final int LT_DASHDOUBLEDOT = 6;
+    public static final int LT_SOLID    = 7;
+
+    // Line Widths (GSLW)
+    public static final int LW_DEFAULT  = 0;
+    public static final int LW_NORMAL   = 1;
+    public static final int LW_THICK    = 2;
+
+    // Fill Patterns (GSPT)
+    public static final int PT_DEFAULT  = 0;
+    public static final int PT_D1       = 1;
+    public static final int PT_D2       = 2;
+    public static final int PT_D3       = 3;
+    public static final int PT_D4       = 4;
+    public static final int PT_D5       = 5;
+    public static final int PT_D6       = 6;
+    public static final int PT_D7       = 7;
+    public static final int PT_D8       = 8;
+    public static final int PT_VERT_LINE   = 9;
+    public static final int PT_HORIZ_LINE  = 10;
+    public static final int PT_DIAG_BLTR   = 11;
+    public static final int PT_DIAG_BLTR2  = 12;
+    public static final int PT_DIAG_TLBR   = 13;
+    public static final int PT_DIAG_TLBR2  = 14;
+    public static final int PT_EMPTY    = 15;
+    public static final int PT_SOLID    = 16;
+
+    // Marker Symbols (GSMT)
+    public static final int MK_DEFAULT  = 0;
+    public static final int MK_CROSS    = 1; // x
+    public static final int MK_PLUS     = 2; // +
+    public static final int MK_DIAMOND  = 3; // <>
+    public static final int MK_SQUARE   = 4; // []
+    public static final int MK_6STAR    = 5; // * 6-point
+    public static final int MK_8STAR    = 6; // * 8-point
+    public static final int MK_SDIAMOND = 7; // solid diamond
+    public static final int MK_SSQUARE  = 8; // solid square
+    public static final int MK_DOT      = 9; // .
+    public static final int MK_CIRCLE   = 10;// o
+
+    // Character Direction (GSCD)
+    public static final int CD_DEFAULT  = 0;
+    public static final int CD_LR       = 1; // Left to Right
+    public static final int CD_TB       = 2; // Top to Bottom
+    public static final int CD_RL       = 3; // Right to Left
+    public static final int CD_BT       = 4; // Bottom to Top
+
+    // Foreground / Background Mix Modes (GSMX / GSBMX)
+    public static final int MIX_DEFAULT = 0;
+    public static final int MIX_OR      = 1;
+    public static final int MIX_OVER    = 2;
+    public static final int MIX_LEAVE   = 3;
+    public static final int MIX_XOR     = 4;
+    public static final int MIX_UNDER   = 5;
+
+    // Graphic Colors (IBM 3179G / HOD 16-color table in 32-bit ARGB)
+    public static final int[] GOCA_COLORS = new int[] {
+        0xFF00FF00,       // 0: Default (Green)
+        0xFF7890F0,       // 1: Blue (120, 144, 240)
+        0xFFFF0000,       // 2: Red (255, 0, 0)
+        0xFFFF00FF,       // 3: Pink / Magenta (255, 0, 255)
+        0xFF00FF00,       // 4: Green (0, 255, 0)
+        0xFF00FFFF,       // 5: Turquoise / Cyan (0, 255, 255)
+        0xFFFFFF00,       // 6: Yellow (255, 255, 0)
+        0xFFFFFFFF,       // 7: Neutral White (255, 255, 255)
+        0xFF000000,       // 8: Black (0, 0, 0)
+        0xFF000080,       // 9: Deep Blue (0, 0, 128)
+        0xFF800000,       // 10: Orange / Dark Red (128, 0, 0)
+        0xFF800080,       // 11: Purple (128, 0, 128)
+        0xFF008000,       // 12: Pale Green (0, 128, 0)
+        0xFF008080,       // 13: Pale Cyan (0, 128, 128)
+        0xFFD79700,       // 14: Mustard (215, 151, 0)
+        0xFFC0C0C0,       // 15: Grey / Light White (192, 192, 192)
+        0xFF492400        // 16: Brown (73, 36, 0)
+    };
+
+    /**
+     * Retrieves the 32-bit ARGB color value for a given GOCA color index (0-16).
+     * Returns Green (0xFF00FF00) if the index is out of range.
+     */
+    public static int getGocaColorArgb(int colorIndex) {
+        if (colorIndex >= 0 && colorIndex < GOCA_COLORS.length) {
+            return GOCA_COLORS[colorIndex];
+        }
+        return GOCA_COLORS[0];
+    }
+}

lib3270j/src/main/java/org/lib3270j/graphics/GocaDecoder.java

@@ -0,0 +1,827 @@
+package org.lib3270j.graphics;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.lib3270j.charset.EbcdicTranslator;
+
+/**
+ * Interprets GOCA (Graphics Object Content Architecture) drawing orders
+ * and updates the GraphicsPlane.
+ */
+public class GocaDecoder {
+
+    private static final Logger logger = Logger.getLogger(GocaDecoder.class.getName());
+
+    private final GraphicsPlane plane;
+
+    // Drawing state
+    private int curX = 0;
+    private int curY = 0;
+    private int curColor = GocaConstants.GOCA_COLORS[0];
+    private int lineType = GocaConstants.LT_SOLID;
+    private int lineWidth = GocaConstants.LW_NORMAL;
+    private int markerType = GocaConstants.MK_PLUS;
+    private int markerSize = 5;
+    private int markerColor = GocaConstants.GOCA_COLORS[0];
+    private int pattern = GocaConstants.PT_SOLID;
+    private int fillColor = GocaConstants.GOCA_COLORS[0];
+    private int charDir = GocaConstants.CD_LR;
+    private double charAngle = 0.0;
+    private int charWidth = 9;
+    private int charHeight = 16;
+    private int charSet = 0;
+    private int arcParamP = 1;
+    private int arcParamQ = 1;
+    private int arcParamR = 0;
+    private int arcParamS = 0;
+
+    private ProgramSymbolManager programSymbolManager;
+
+    // Area accumulation
+    private boolean inArea = false;
+    private boolean areaDrawBoundary = true;
+    private final List<Integer> areaPointsX = new ArrayList<>();
+    private final List<Integer> areaPointsY = new ArrayList<>();
+
+    // Image accumulation
+    private boolean inImage = false;
+    private int imgX = 0;
+    private int imgY = 0;
+    private int imgWidth = 0;
+    private int imgHeight = 0;
+    private final List<Byte> imgBuffer = new ArrayList<>();
+
+    public GocaDecoder(GraphicsPlane plane) {
+        this.plane = plane;
+    }
+
+    public void setProgramSymbolManager(ProgramSymbolManager psm) {
+        this.programSymbolManager = psm;
+    }
+
+    public GraphicsPlane getGraphicsPlane() {
+        return plane;
+    }
+
+    public int getCurX() {
+        return curX;
+    }
+
+    public int getCurY() {
+        return curY;
+    }
+
+    public synchronized void resetDefaults() {
+        curX = 0;
+        curY = 0;
+        resetAttributes();
+    }
+
+    public synchronized void resetAttributes() {
+        curColor = getColor(0);
+        lineType = GocaConstants.LT_SOLID;
+        lineWidth = GocaConstants.LW_NORMAL;
+        markerType = GocaConstants.MK_PLUS;
+        markerSize = 5;
+        markerColor = curColor;
+        pattern = GocaConstants.PT_SOLID;
+        fillColor = curColor;
+        charDir = GocaConstants.CD_LR;
+        charAngle = 0.0;
+        charSet = 0;
+        inArea = false;
+        areaPointsX.clear();
+        areaPointsY.clear();
+        inImage = false;
+        imgBuffer.clear();
+    }
+
+    private byte[] partialOrderBuffer = new byte[0];
+
+    private int getOrderLength(byte[] data, int idx, int end) {
+        int order = data[idx] & 0xFF;
+        if (order == GocaConstants.G_NOP1 || order == 0xFF) {
+            return 1;
+        }
+        if (order == GocaConstants.G_GEAR ||
+            order == GocaConstants.G_ENDSEGM || order == GocaConstants.G_ENDPROLOGUE ||
+            order == GocaConstants.G_GEIMG || order == GocaConstants.G_GPOP) {
+            return (idx + 1 < end && data[idx + 1] == 0x00) ? 2 : 1;
+        }
+        if (order == 0x04 || order == GocaConstants.G_GSMC || order == GocaConstants.G_GSPS ||
+            order == GocaConstants.G_GSCOL || order == GocaConstants.G_GSMX ||
+            order == GocaConstants.G_GSBMX || order == GocaConstants.G_GSFLW ||
+            order == GocaConstants.G_GSLT || order == GocaConstants.G_GSLW ||
+            order == GocaConstants.G_GSMS || order == GocaConstants.G_GSPT ||
+            order == GocaConstants.G_GSMT || order == GocaConstants.G_GSCS ||
+            order == GocaConstants.G_GSMP || order == GocaConstants.G_GSCD ||
+            order == GocaConstants.G_GSCC || order == GocaConstants.G_GSMS_SET ||
+            order == GocaConstants.G_GBAR) {
+            return 2;
+        }
+        if (order == GocaConstants.G_GSAP || order == GocaConstants.G_GBIMG || order == 0x91) {
+            return 10;
+        }
+        if (idx + 1 >= end) {
+            return -1;
+        }
+        return (data[idx + 1] & 0xFF) + 2;
+    }
+
+    /**
+     * Decodes a stream of GOCA drawing orders.
+     */
+    public synchronized void decodeStream(byte[] data, int offset, int length) {
+        if (data == null || length <= 0 || offset < 0 || offset + length > data.length) {
+            return;
+        }
+
+        byte[] inputData;
+        int idx;
+        int end;
+
+        if (partialOrderBuffer.length > 0) {
+            inputData = new byte[partialOrderBuffer.length + length];
+            System.arraycopy(partialOrderBuffer, 0, inputData, 0, partialOrderBuffer.length);
+            System.arraycopy(data, offset, inputData, partialOrderBuffer.length, length);
+            idx = 0;
+            end = inputData.length;
+            partialOrderBuffer = new byte[0];
+        } else {
+            inputData = data;
+            idx = offset;
+            end = offset + length;
+        }
+
+        while (idx < end) {
+            int order = inputData[idx] & 0xFF;
+            int orderLen = getOrderLength(inputData, idx, end);
+
+            if (orderLen == -1 || idx + orderLen > end) {
+                int remaining = end - idx;
+                partialOrderBuffer = new byte[remaining];
+                System.arraycopy(inputData, idx, partialOrderBuffer, 0, remaining);
+                break;
+            }
+
+            int payloadLen = (orderLen >= 2) ? (inputData[idx + 1] & 0xFF) : 0;
+
+            switch (order) {
+                case GocaConstants.G_NOP1:
+                case 0xFF: {
+                    idx++;
+                    break;
+                }
+                case GocaConstants.G_GEAR: {
+                    endArea();
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GEIMG: {
+                    endImage();
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_BEGSEGM: { // Begin Segment (0x70)
+                    if (idx + 7 < end && (inputData[idx + 7] & 0x06) == 0) {
+                        resetAttributes();
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_ENDSEGM: { // End Segment (0x71)
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_ENDPROLOGUE: { // End Prologue (0x3E)
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_COMT: { // Comment (0x01)
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCP: { // Set Current Position (0x21)
+                    if (payloadLen >= 4 && idx + 5 < end) {
+                        curX = readCoord(inputData, idx + 2);
+                        curY = readCoord(inputData, idx + 4);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSAP: { // Arc Parameters (0x22)
+                    if (idx + 9 < end) {
+                        arcParamP = readCoord(inputData, idx + 2);
+                        arcParamQ = readCoord(inputData, idx + 4);
+                        arcParamR = readCoord(inputData, idx + 6);
+                        arcParamS = readCoord(inputData, idx + 8);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSVW: { // Set Viewing Window (0x27)
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCA: { // Set Character Angle (0x34)
+                    if (payloadLen >= 4 && idx + 5 < end) {
+                        int ax = readCoord(inputData, idx + 2);
+                        int ay = readCoord(inputData, idx + 4);
+                        if (ax != 0 || ay != 0) {
+                            charAngle = Math.toDegrees(Math.atan2(ay, ax));
+                        }
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCH: { // Set Character Cell (0x33)
+                    if (payloadLen >= 4 && idx + 5 < end) {
+                        charWidth = readCoord(inputData, idx + 2);
+                        charHeight = readCoord(inputData, idx + 4);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCR: { // Set Character Shear (0x35)
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCOL: { // Set Color (0x0A)
+                    int colIdx = inputData[idx + 1] & 0xFF;
+                    curColor = getColor(colIdx);
+                    fillColor = curColor;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSECOL: { // Set Extended Color (0x26)
+                    if (payloadLen >= 2 && idx + 3 < end) {
+                        int colIdx = inputData[idx + 3] & 0xFF;
+                        curColor = getColor(colIdx);
+                        fillColor = curColor;
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSLT: { // Set Line Type (0x18)
+                    lineType = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSLW: { // Set Line Width (0x19)
+                    lineWidth = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSMC: { // Set Marker Color (0x07)
+                    int colIdx = inputData[idx + 1] & 0xFF;
+                    markerColor = getColor(colIdx);
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSMS: { // Set Marker Size (0x1B)
+                    markerSize = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSMT: { // Set Marker Type (0x29)
+                    markerType = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSPS: { // Set Pattern Set (0x08)
+                    pattern = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSPT: { // Set Pattern Symbol (0x28)
+                    pattern = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCD: { // Set Character Direction (0x3A)
+                    charDir = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GSCS: { // Set Character Set (0x38)
+                    charSet = inputData[idx + 1] & 0xFF;
+                    idx += orderLen;
+                    break;
+                }
+                case 0x04:
+                case GocaConstants.G_GSMX:
+                case GocaConstants.G_GSBMX:
+                case GocaConstants.G_GSFLW:
+                case GocaConstants.G_GSMP:
+                case GocaConstants.G_GSCC:
+                case GocaConstants.G_GSMS_SET:
+                case GocaConstants.G_GPOP: {
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GBAR: { // Begin Area (0x68)
+                    int flags = inputData[idx + 1] & 0xFF;
+                    beginArea((flags & 0x40) != 0);
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GLINE: { // Line Absolute (0xC1)
+                    if (payloadLen >= 4) {
+                        processLine(inputData, idx + 2, payloadLen, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCLINE: { // Line Current Position (0x81)
+                    if (payloadLen >= 4) {
+                        processLine(inputData, idx + 2, payloadLen, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GRLINE: { // Relative Line Absolute Start (0xE1)
+                    if (payloadLen >= 4) {
+                        processRelativeLine(inputData, idx + 2, payloadLen, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCRLIN: { // Relative Line Current Position (0xA1)
+                    if (payloadLen >= 2) {
+                        processRelativeLine(inputData, idx + 2, payloadLen, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GFARC: { // Full Arc Absolute (0xC7)
+                    if (payloadLen >= 4) {
+                        processArc(inputData, idx + 2, payloadLen, false, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCFARC: { // Full Arc Current Position (0x87)
+                    if (payloadLen >= 2) {
+                        processArc(inputData, idx + 2, payloadLen, true, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GARC: { // Partial Arc Absolute (0xC6)
+                    if (payloadLen >= 8) {
+                        processArc(inputData, idx + 2, payloadLen, false, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCARC: { // Partial Arc Current Position (0x86)
+                    if (payloadLen >= 4) {
+                        processArc(inputData, idx + 2, payloadLen, true, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GFLT: { // Fillet Absolute (0xC5)
+                    if (payloadLen >= 4) {
+                        processFillet(inputData, idx + 2, payloadLen, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCFLT: { // Fillet Current Position (0x85)
+                    if (payloadLen >= 4) {
+                        processFillet(inputData, idx + 2, payloadLen, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GMRK: { // Marker Absolute (0xC2)
+                    if (payloadLen >= 4) {
+                        processMarker(inputData, idx + 2, payloadLen, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCMRK: { // Marker Current Position (0x82)
+                    if (payloadLen >= 4) {
+                        processMarker(inputData, idx + 2, payloadLen, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCHST: { // Character String Absolute (0xC3)
+                    if (payloadLen >= 4) {
+                        processText(inputData, idx + 2, payloadLen, false);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GCCHST: { // Character String Current Position (0x83)
+                    if (payloadLen >= 0) {
+                        processText(inputData, idx + 2, payloadLen, true);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GBIMG: { // Begin Image (0xD1)
+                    if (idx + 9 < end) {
+                        int x = readCoord(inputData, idx + 2);
+                        int y = readCoord(inputData, idx + 4);
+                        int w = readCoord(inputData, idx + 6);
+                        int h = readCoord(inputData, idx + 8);
+                        beginImage(x, y, w, h);
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                case GocaConstants.G_GIMD: { // Image Data (0x92)
+                    if (inImage) {
+                        for (int k = 0; k < payloadLen; k++) {
+                            imgBuffer.add(inputData[idx + 2 + k]);
+                        }
+                    }
+                    idx += orderLen;
+                    break;
+                }
+                default: {
+                    idx += orderLen;
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Decodes a stream of Object Control Procedure Orders (subtype 0x11).
+     */
+    public synchronized void processProcedureOrders(byte[] data, int offset, int length) {
+        if (data == null || length <= 0 || offset < 0 || offset + length > data.length) {
+            return;
+        }
+
+        int idx = offset;
+        int end = offset + length;
+
+        while (idx < end) {
+            int order = data[idx] & 0xFF;
+
+            switch (order) {
+                case GocaConstants.P_NOP1:
+                case GocaConstants.P_ATTCUR:
+                case GocaConstants.P_DETCUR:
+                case GocaConstants.P_STOPDR: {
+                    idx++;
+                    break;
+                }
+                case GocaConstants.P_ERASE: { // 0x0A: Erase Graphics Presentation Space
+                    plane.clear();
+                    resetDefaults();
+                    idx++;
+                    break;
+                }
+                case GocaConstants.P_BEGPROC: { // 0x30: Begin Procedure (length 12)
+                    int len = 12;
+                    if (idx + 1 < end && data[idx + 1] != 0) {
+                        len = (data[idx + 1] & 0xFF) + 2;
+                    }
+                    idx += len;
+                    break;
+                }
+                case GocaConstants.P_SCUDEF: { // 0x21: Set Current Defaults
+                    if (idx + 1 < end) {
+                        int len = data[idx + 1] & 0xFF;
+                        if (idx + 2 + len <= end) {
+                            decodeStream(data, idx + 2, len);
+                        }
+                        idx += 2 + len;
+                    } else {
+                        idx++;
+                    }
+                    break;
+                }
+                case GocaConstants.P_COMT:
+                case GocaConstants.P_SETCUR: {
+                    if (idx + 1 < end) {
+                        int len = data[idx + 1] & 0xFF;
+                        idx += 2 + len;
+                    } else {
+                        idx++;
+                    }
+                    break;
+                }
+                default: {
+                    if (idx + 1 < end) {
+                        int len = data[idx + 1] & 0xFF;
+                        idx += 2 + len;
+                    } else {
+                        idx++;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    private void beginArea(boolean drawBoundary) {
+        this.inArea = true;
+        this.areaDrawBoundary = drawBoundary;
+        this.fillColor = this.curColor;
+        this.areaPointsX.clear();
+        this.areaPointsY.clear();
+    }
+
+    private void endArea() {
+        if (!inArea || areaPointsX.size() < 3) {
+            inArea = false;
+            areaPointsX.clear();
+            areaPointsY.clear();
+            return;
+        }
+        int n = areaPointsX.size();
+        int[] px = new int[n];
+        int[] py = new int[n];
+        for (int i = 0; i < n; i++) {
+            px[i] = plane.mapX(areaPointsX.get(i));
+            py[i] = plane.mapY(areaPointsY.get(i));
+        }
+
+        plane.fillArea(px, py, n, fillColor, pattern, areaDrawBoundary, curColor, lineType, lineWidth);
+        inArea = false;
+        areaPointsX.clear();
+        areaPointsY.clear();
+    }
+
+    private void addAreaPoint(int x, int y) {
+        if (inArea) {
+            areaPointsX.add(x);
+            areaPointsY.add(y);
+        }
+    }
+
+    private void beginImage(int x, int y, int w, int h) {
+        this.inImage = true;
+        this.imgX = x;
+        this.imgY = y;
+        this.imgWidth = w;
+        this.imgHeight = h;
+        this.imgBuffer.clear();
+    }
+
+    private void endImage() {
+        if (!inImage || imgWidth <= 0 || imgHeight <= 0 || imgBuffer.isEmpty()) {
+            inImage = false;
+            return;
+        }
+        byte[] bytes = new byte[imgBuffer.size()];
+        for (int i = 0; i < bytes.length; i++) {
+            bytes[i] = imgBuffer.get(i);
+        }
+
+        int px = plane.mapX(imgX);
+        int py = plane.mapY(imgY);
+        plane.drawImage(px, py, imgWidth, imgHeight, bytes, curColor);
+        inImage = false;
+        imgBuffer.clear();
+    }
+
+    private void processLine(byte[] data, int off, int len, boolean fromCurPos) {
+        int pos = off;
+        int end = off + len;
+
+        int startX = curX;
+        int startY = curY;
+
+        if (!fromCurPos && pos + 4 <= end) {
+            startX = readCoord(data, pos);
+            startY = readCoord(data, pos + 2);
+            pos += 4;
+        }
+
+        if (inArea) {
+            addAreaPoint(startX, startY);
+        }
+
+        while (pos + 4 <= end) {
+            int nextX = readCoord(data, pos);
+            int nextY = readCoord(data, pos + 2);
+            pos += 4;
+
+            if (inArea) {
+                addAreaPoint(nextX, nextY);
+            } else {
+                plane.drawLine(plane.mapX(startX), plane.mapY(startY),
+                               plane.mapX(nextX), plane.mapY(nextY),
+                               curColor, lineType, lineWidth);
+            }
+
+            startX = nextX;
+            startY = nextY;
+        }
+
+        curX = startX;
+        curY = startY;
+    }
+
+    private void processRelativeLine(byte[] data, int off, int len, boolean fromCurPos) {
+        int pos = off;
+        int end = off + len;
+
+        int startX = curX;
+        int startY = curY;
+
+        if (!fromCurPos && pos + 4 <= end) {
+            startX = readCoord(data, pos);
+            startY = readCoord(data, pos + 2);
+            pos += 4;
+        }
+
+        if (inArea) {
+            addAreaPoint(startX, startY);
+        }
+
+        while (pos + 2 <= end) {
+            int dx = (byte) data[pos];
+            int dy = (byte) data[pos + 1];
+            pos += 2;
+
+            int nextX = startX + dx;
+            int nextY = startY + dy;
+
+            if (inArea) {
+                addAreaPoint(nextX, nextY);
+            } else {
+                plane.drawLine(plane.mapX(startX), plane.mapY(startY),
+                               plane.mapX(nextX), plane.mapY(nextY),
+                               curColor, lineType, lineWidth);
+            }
+
+            startX = nextX;
+            startY = nextY;
+        }
+
+        curX = startX;
+        curY = startY;
+    }
+
+    private void processArc(byte[] data, int off, int len, boolean fromCurPos, boolean isFull) {
+        int pos = off;
+        int startX = curX;
+        int startY = curY;
+
+        if (!fromCurPos && pos + 4 <= off + len) {
+            startX = readCoord(data, pos);
+            startY = readCoord(data, pos + 2);
+            pos += 4;
+        }
+
+        double multiplier = 1.0;
+        if (pos + 2 <= off + len) {
+            multiplier = (data[pos] & 0xFF) + ((data[pos + 1] & 0xFF) / 255.0);
+            if (multiplier == 0.0) multiplier = 1.0;
+        }
+
+        int dxP = Math.abs(arcParamP - arcParamR);
+        int dyQ = Math.abs(arcParamQ - arcParamS);
+        if (dxP == 0) dxP = 10;
+        if (dyQ == 0) dyQ = 10;
+
+        int rxVirtual = (int) (dxP * multiplier);
+        int ryVirtual = (int) (dyQ * multiplier);
+
+        int rx = Math.abs(plane.mapX(rxVirtual) - plane.mapX(0));
+        int ry = Math.abs(plane.mapY(ryVirtual) - plane.mapY(0));
+        if (rx <= 0) rx = 10;
+        if (ry <= 0) ry = 10;
+
+        plane.drawArc(plane.mapX(startX), plane.mapY(startY), rx, ry, 0.0, 360.0,
+                      curColor, lineType, lineWidth, isFull);
+
+        curX = startX;
+        curY = startY;
+    }
+
+    private void processFillet(byte[] data, int off, int len, boolean fromCurPos) {
+        int pos = off;
+        int end = off + len;
+
+        List<Integer> ptsX = new ArrayList<>();
+        List<Integer> ptsY = new ArrayList<>();
+
+        if (fromCurPos) {
+            ptsX.add(plane.mapX(curX));
+            ptsY.add(plane.mapY(curY));
+        }
+
+        while (pos + 4 <= end) {
+            int x = readCoord(data, pos);
+            int y = readCoord(data, pos + 2);
+            ptsX.add(plane.mapX(x));
+            ptsY.add(plane.mapY(y));
+            curX = x;
+            curY = y;
+            pos += 4;
+        }
+
+        if (ptsX.size() >= 2) {
+            int n = ptsX.size();
+            int[] px = new int[n];
+            int[] py = new int[n];
+            for (int i = 0; i < n; i++) {
+                px[i] = ptsX.get(i);
+                py[i] = ptsY.get(i);
+            }
+            plane.drawFillet(px, py, n, curColor, lineType, lineWidth);
+        }
+    }
+
+    private void processMarker(byte[] data, int off, int len, boolean fromCurPos) {
+        int pos = off;
+        int end = off + len;
+
+        if (fromCurPos) {
+            plane.drawMarker(plane.mapX(curX), plane.mapY(curY), markerType, markerSize, markerColor);
+        }
+
+        while (pos + 4 <= end) {
+            int x = readCoord(data, pos);
+            int y = readCoord(data, pos + 2);
+            plane.drawMarker(plane.mapX(x), plane.mapY(y), markerType, markerSize, markerColor);
+            curX = x;
+            curY = y;
+            pos += 4;
+        }
+    }
+
+    private void processText(byte[] data, int off, int len, boolean fromCurPos) {
+        int pos = off;
+        int end = off + len;
+
+        int startX = curX;
+        int startY = curY;
+
+        if (!fromCurPos && pos + 4 <= end) {
+            startX = readCoord(data, pos);
+            startY = readCoord(data, pos + 2);
+            pos += 4;
+        }
+
+        int textLen = end - pos;
+        if (textLen <= 0) return;
+
+        int cw = charWidth > 0 ? (int) Math.round((double) charWidth * plane.getCanvasWidth() / (plane.getScreenCols() * 9.0)) : 12;
+        int ch = charHeight > 0 ? (int) Math.round((double) charHeight * plane.getCanvasHeight() / (plane.getScreenRows() * 16.0)) : 20;
+
+        if (charSet != 0 && programSymbolManager != null) {
+            for (int i = 0; i < textLen; i++) {
+                int code = data[pos + i] & 0xFF;
+                int px = plane.mapX(startX);
+                int py = plane.mapY(startY) - ch;
+                ProgramSymbolSet.SymbolSlot slot = programSymbolManager.getSymbol(charSet, code);
+                if (slot != null) {
+                    int[] rgb = slot.getRgbPixels(curColor, 0);
+                    int symW = slot.getWidth();
+                    int symH = slot.getHeight();
+                    for (int dy = 0; dy < ch; dy++) {
+                        int sy = (dy * symH) / ch;
+                        for (int dx = 0; dx < cw; dx++) {
+                            int sx = (dx * symW) / cw;
+                            int pixelArgb = rgb[sy * symW + sx];
+                            if ((pixelArgb >>> 24) != 0) {
+                                plane.setPixel(px + dx, py + dy, pixelArgb);
+                            }
+                        }
+                    }
+                } else {
+                    char c = EbcdicTranslator.ebcdicToAscii(data[pos + i]);
+                    plane.drawVectorText(px, py, String.valueOf(c), curColor, cw, ch, charDir, charAngle);
+                }
+                startX += (charWidth > 0 ? charWidth : 9);
+            }
+            curX = startX;
+            curY = startY;
+            return;
+        }
+
+        char[] chars = new char[textLen];
+        for (int i = 0; i < textLen; i++) {
+            chars[i] = EbcdicTranslator.ebcdicToAscii(data[pos + i]);
+        }
+        String text = new String(chars);
+
+        plane.drawVectorText(plane.mapX(startX), plane.mapY(startY) - ch, text,
+                             curColor, cw, ch, charDir, charAngle);
+
+        curX = startX + (textLen * (charWidth > 0 ? charWidth : 9));
+        curY = startY;
+    }
+
+    private int readCoord(byte[] data, int off) {
+        return (short) (((data[off] & 0xFF) << 8) | (data[off + 1] & 0xFF));
+    }
+
+    private int getColor(int colorIndex) {
+        return GocaConstants.getGocaColorArgb(colorIndex);
+    }
+}

lib3270j/src/main/java/org/lib3270j/graphics/GraphicsMode.java

@@ -0,0 +1,70 @@
+package org.lib3270j.graphics;
+
+/**
+ * Graphics modes supported by j3270 / lib3270j.
+ */
+public enum GraphicsMode {
+    /** Text only (no graphics query replies, classic 3279-4 terminal behavior). */
+    NONE("None (Text Only)"),
+
+    /** Programmed Symbols only (custom character matrices and APL, single & triple plane). */
+    PROGRAMMED_SYMBOLS("Programmed Symbols Only"),
+
+    /** Vector graphics only (GOCA / 3179G drawing orders). */
+    VECTOR_GRAPHICS("Vector Graphics Only"),
+
+    /** Full graphics support (both Programmed Symbols and Vector Graphics). */
+    BOTH("Both (Programmed Symbols & Vector Graphics)");
+
+    private final String description;
+
+    GraphicsMode(String description) {
+        this.description = description;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public boolean isProgrammedSymbolsEnabled() {
+        return this == PROGRAMMED_SYMBOLS || this == BOTH;
+    }
+
+    public boolean isVectorGraphicsEnabled() {
+        return this == VECTOR_GRAPHICS || this == BOTH;
+    }
+
+    public static GraphicsMode fromString(String str) {
+        if (str == null || str.trim().isEmpty()) {
+            return NONE;
+        }
+        String s = str.trim().toUpperCase();
+        switch (s) {
+            case "BOTH":
+            case "ALL":
+            case "FULL":
+            case "ON":
+            case "TRUE":
+                return BOTH;
+            case "PS":
+            case "PROGRAMMED_SYMBOLS":
+            case "PROGRAMMEDSYMBOLS":
+            case "SYMBOLS":
+            case "APL":
+                return PROGRAMMED_SYMBOLS;
+            case "VECTOR":
+            case "VECTOR_GRAPHICS":
+            case "VECTORGRAPHICS":
+            case "GOCA":
+            case "GDDM":
+                return VECTOR_GRAPHICS;
+            case "NONE":
+            case "OFF":
+            case "FALSE":
+            case "DISABLED":
+            case "TEXT":
+            default:
+                return NONE;
+        }
+    }
+}

lib3270j/src/main/java/org/lib3270j/graphics/GraphicsPlane.java

@@ -0,0 +1,524 @@
+package org.lib3270j.graphics;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+
+/**
+ * Offscreen rendering surface for GOCA vector graphics.
+ * Maintained as an ARGB 32-bit integer pixel buffer that overlays the 3270 character cell matrix.
+ * Pure Java software rasterizer compatible with standard Java SE (Swing) and Android (Bitmap).
+ */
+public class GraphicsPlane {
+
+    private static final Logger logger = Logger.getLogger(GraphicsPlane.class.getName());
+
+    // 17 Standard GOCA 8x8 Fill Patterns
+    public static final byte[][] PATTERN_DATA = new byte[][]{
+        {-1, -1, -1, -1, -1, -1, -1, -1},                     // 0: Solid (all 1s)
+        {-1, -1, -1, -18, -1, -1, -1, -18},                   // 1: D1
+        {-1, -69, -1, -18, -1, -69, -1, -18},                 // 2: D2
+        {119, -35, -69, -18, 119, -35, -69, -18},             // 3: D3
+        {-69, -52, 51, -18, -69, -52, 51, -18},               // 4: D4
+        {85, -86, 85, -86, 85, -86, 85, -86},                 // 5: D5 (50% checker)
+        {68, 51, -52, 17, 68, 51, -52, 17},                   // 6: D6
+        {-120, 34, 68, 17, -120, 34, 68, 17},                 // 7: D7
+        {0, 68, 0, 17, 0, 68, 0, 17},                         // 8: D8 (sparse dots)
+        {-128, -128, -128, -128, -128, -128, -128, -128},     // 9: Vertical line
+        {-1, 0, 0, 0, 0, 0, 0, 0},                             // 10: Horizontal line
+        {1, 2, 4, 8, 16, 32, 64, -128},                       // 11: Diagonal bottom-left to top-right
+        {3, 12, 48, -64, 3, 12, 48, -64},                     // 12: Diagonal BL-TR dense
+        {-128, 64, 32, 16, 8, 4, 2, 1},                       // 13: Diagonal top-left to bottom-right
+        {-64, 48, 12, 3, -64, 48, 12, 3},                     // 14: Diagonal TL-BR dense
+        {0, 0, 0, 0, 0, 0, 0, 0},                             // 15: Empty (transparent)
+        {-1, -1, -1, -1, -1, -1, -1, -1}                      // 16: Solid
+    };
+
+    private int canvasWidth = 800;
+    private int canvasHeight = 600;
+    private int[] rgbBuffer;
+    private boolean hasContent = false;
+
+    private int screenCols = 80;
+    private int screenRows = 24;
+
+    public GraphicsPlane(int width, int height) {
+        this.canvasWidth = Math.max(1, width);
+        this.canvasHeight = Math.max(1, height);
+        this.rgbBuffer = new int[canvasWidth * canvasHeight];
+    }
+
+    public synchronized void resize(int width, int height) {
+        int w = Math.max(1, width);
+        int h = Math.max(1, height);
+        if (w == canvasWidth && h == canvasHeight && rgbBuffer != null) {
+            return;
+        }
+
+        int[] newBuffer = new int[w * h];
+        if (rgbBuffer != null && hasContent) {
+            // Scale existing content to new dimensions using nearest-neighbor
+            for (int dy = 0; dy < h; dy++) {
+                int sy = (dy * canvasHeight) / h;
+                for (int dx = 0; dx < w; dx++) {
+                    int sx = (dx * canvasWidth) / w;
+                    newBuffer[dy * w + dx] = rgbBuffer[sy * canvasWidth + sx];
+                }
+            }
+        }
+
+        this.canvasWidth = w;
+        this.canvasHeight = h;
+        this.rgbBuffer = newBuffer;
+    }
+
+    public synchronized void clear() {
+        if (rgbBuffer != null) {
+            Arrays.fill(rgbBuffer, 0);
+        }
+        hasContent = false;
+    }
+
+    public synchronized boolean hasContent() {
+        return hasContent;
+    }
+
+    public synchronized int[] getRgbBuffer() {
+        return rgbBuffer;
+    }
+
+    public int getCanvasWidth() {
+        return canvasWidth;
+    }
+
+    public int getCanvasHeight() {
+        return canvasHeight;
+    }
+
+    public void setScreenDimensions(int cols, int rows) {
+        this.screenCols = cols > 0 ? cols : 80;
+        this.screenRows = rows > 0 ? rows : 24;
+    }
+
+    public int getScreenCols() {
+        return screenCols;
+    }
+
+    public int getScreenRows() {
+        return screenRows;
+    }
+
+    /**
+     * Maps a 3179G / GOCA signed coordinate (centered at screen midpoint) to canvas pixel X.
+     */
+    public int mapX(int gocaX) {
+        int nominalWidth = screenCols * 9;
+        int xMax = (nominalWidth - 1) / 2 + ((nominalWidth - 1) % 2 != 0 ? 1 : 0);
+        int nx = gocaX + xMax;
+        return (int) Math.round((double) nx * canvasWidth / nominalWidth);
+    }
+
+    /**
+     * Maps a 3179G / GOCA signed coordinate (centered at screen midpoint, bottom-up) to canvas pixel Y (top-down).
+     */
+    public int mapY(int gocaY) {
+        int nominalHeight = screenRows * 16;
+        int yMax = (nominalHeight - 1) / 2;
+        int ny = yMax - gocaY;
+        return (int) Math.round((double) ny * canvasHeight / nominalHeight);
+    }
+
+    /**
+     * Safely plots a pixel at (x, y).
+     */
+    public synchronized void setPixel(int x, int y, int colorArgb) {
+        if (x >= 0 && x < canvasWidth && y >= 0 && y < canvasHeight) {
+            rgbBuffer[y * canvasWidth + x] = colorArgb;
+            hasContent = true;
+        }
+    }
+
+    /**
+     * Draws an absolute or relative line using Bresenham's algorithm with line styles and widths.
+     */
+    public synchronized void drawLine(int x1, int y1, int x2, int y2, int colorArgb, int lineType, int lineWidth) {
+        int color = (colorArgb != 0) ? colorArgb : 0xFFFFFFFF;
+        int thickness = (lineWidth == GocaConstants.LW_THICK) ? 2 : 1;
+
+        int dx = Math.abs(x2 - x1);
+        int dy = Math.abs(y2 - y1);
+        int sx = x1 < x2 ? 1 : -1;
+        int sy = y1 < y2 ? 1 : -1;
+        int err = dx - dy;
+
+        int curX = x1;
+        int curY = y1;
+        int stepIndex = 0;
+
+        while (true) {
+            if (shouldPlotLinePixel(stepIndex, lineType)) {
+                drawPixelWithThickness(curX, curY, color, thickness);
+            }
+            stepIndex++;
+
+            if (curX == x2 && curY == y2) {
+                break;
+            }
+
+            int e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                curX += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                curY += sy;
+            }
+        }
+        hasContent = true;
+    }
+
+    private boolean shouldPlotLinePixel(int step, int lineType) {
+        switch (lineType) {
+            case GocaConstants.LT_DOT:
+                return (step % 4) < 2;
+            case GocaConstants.LT_SHORTDASH:
+                return (step % 6) < 4;
+            case GocaConstants.LT_DASHDOT:
+                int m12 = step % 12;
+                return m12 < 6 || (m12 >= 8 && m12 < 10);
+            case GocaConstants.LT_DOUBLEDOT:
+                int m10 = step % 10;
+                return m10 < 2 || (m10 >= 4 && m10 < 6);
+            case GocaConstants.LT_LONGDASH:
+                return (step % 11) < 8;
+            case GocaConstants.LT_DASHDOUBLEDOT:
+                int m18 = step % 18;
+                return m18 < 8 || (m18 >= 10 && m18 < 12) || (m18 >= 14 && m18 < 16);
+            case GocaConstants.LT_SOLID:
+            case GocaConstants.LT_DEFAULT:
+            default:
+                return true;
+        }
+    }
+
+    private void drawPixelWithThickness(int x, int y, int color, int thickness) {
+        if (thickness <= 1) {
+            setPixel(x, y, color);
+        } else {
+            for (int dy = -(thickness - 1); dy <= (thickness - 1); dy++) {
+                for (int dx = -(thickness - 1); dx <= (thickness - 1); dx++) {
+                    setPixel(x + dx, y + dy, color);
+                }
+            }
+        }
+    }
+
+    /**
+     * Draws a full or partial arc / ellipse.
+     */
+    public synchronized void drawArc(int cx, int cy, int rx, int ry, double startAngleDeg, double sweepAngleDeg,
+                                     int colorArgb, int lineType, int lineWidth, boolean isFull) {
+        if (rx <= 0) rx = 1;
+        if (ry <= 0) ry = 1;
+
+        int numSteps = Math.max(24, Math.max(rx, ry) * 4);
+        double startRad = Math.toRadians(startAngleDeg);
+        double sweepRad = isFull ? (2.0 * Math.PI) : Math.toRadians(sweepAngleDeg);
+        double stepRad = sweepRad / numSteps;
+
+        int prevX = (int) Math.round(cx + rx * Math.cos(startRad));
+        int prevY = (int) Math.round(cy - ry * Math.sin(startRad));
+
+        for (int i = 1; i <= numSteps; i++) {
+            double angle = startRad + i * stepRad;
+            int nextX = (int) Math.round(cx + rx * Math.cos(angle));
+            int nextY = (int) Math.round(cy - ry * Math.sin(angle));
+            drawLine(prevX, prevY, nextX, nextY, colorArgb, lineType, lineWidth);
+            prevX = nextX;
+            prevY = nextY;
+        }
+        hasContent = true;
+    }
+
+    /**
+     * Draws a Fillet (spline / curve approximation across control points).
+     */
+    public synchronized void drawFillet(int[] px, int[] py, int numPoints, int colorArgb, int lineType, int lineWidth) {
+        if (px == null || py == null || numPoints < 2) return;
+
+        if (numPoints == 2) {
+            drawLine(px[0], py[0], px[1], py[1], colorArgb, lineType, lineWidth);
+            return;
+        }
+
+        int prevX = px[0];
+        int prevY = py[0];
+
+        for (int i = 0; i < numPoints - 1; i++) {
+            double p0x = (i == 0) ? px[0] : (px[i - 1] + px[i]) / 2.0;
+            double p0y = (i == 0) ? py[0] : (py[i - 1] + py[i]) / 2.0;
+            double p1x = px[i];
+            double p1y = py[i];
+            double p2x = (i == numPoints - 2) ? px[numPoints - 1] : (px[i] + px[i + 1]) / 2.0;
+            double p2y = (i == numPoints - 2) ? py[numPoints - 1] : (py[i] + py[i + 1]) / 2.0;
+
+            int steps = 20;
+            for (int s = 1; s <= steps; s++) {
+                double t = (double) s / steps;
+                double oneMinusT = 1.0 - t;
+                double bx = oneMinusT * oneMinusT * p0x + 2.0 * oneMinusT * t * p1x + t * t * p2x;
+                double by = oneMinusT * oneMinusT * p0y + 2.0 * oneMinusT * t * p1y + t * t * p2y;
+                int nextX = (int) Math.round(bx);
+                int nextY = (int) Math.round(by);
+                drawLine(prevX, prevY, nextX, nextY, colorArgb, lineType, lineWidth);
+                prevX = nextX;
+                prevY = nextY;
+            }
+        }
+        hasContent = true;
+    }
+
+    /**
+     * Fills a closed polygon area with a solid color or hatching pattern.
+     */
+    public synchronized void fillArea(int[] px, int[] py, int numPoints, int fillColorArgb, int pattern,
+                                      boolean drawBoundary, int boundaryColorArgb, int lineType, int lineWidth) {
+        if (px == null || py == null || numPoints < 3) return;
+
+        int fill = (fillColorArgb != 0) ? fillColorArgb : 0xFFFFFFFF;
+
+        if (pattern != GocaConstants.PT_EMPTY) {
+            // Find polygon vertical bounds
+            int minY = py[0];
+            int maxY = py[0];
+            for (int i = 1; i < numPoints; i++) {
+                if (py[i] < minY) minY = py[i];
+                if (py[i] > maxY) maxY = py[i];
+            }
+            minY = Math.max(0, minY);
+            maxY = Math.min(canvasHeight - 1, maxY);
+
+            List<Integer> nodeX = new ArrayList<>();
+            byte[] patRows = (pattern >= 0 && pattern < PATTERN_DATA.length) ? PATTERN_DATA[pattern] : PATTERN_DATA[0];
+
+            for (int y = minY; y <= maxY; y++) {
+                nodeX.clear();
+                int j = numPoints - 1;
+                for (int i = 0; i < numPoints; i++) {
+                    if ((py[i] < y && py[j] >= y) || (py[j] < y && py[i] >= y)) {
+                        int x = px[i] + (int) Math.round((double) (y - py[i]) / (py[j] - py[i]) * (px[j] - px[i]));
+                        nodeX.add(x);
+                    }
+                    j = i;
+                }
+
+                Collections.sort(nodeX);
+
+                for (int i = 0; i < nodeX.size(); i += 2) {
+                    if (i + 1 >= nodeX.size()) break;
+                    int leftX = Math.max(0, nodeX.get(i));
+                    int rightX = Math.min(canvasWidth - 1, nodeX.get(i + 1));
+
+                    for (int x = leftX; x <= rightX; x++) {
+                        if (pattern == GocaConstants.PT_SOLID || pattern == GocaConstants.PT_DEFAULT || pattern > 16) {
+                            setPixel(x, y, fill);
+                        } else {
+                            int b = patRows[y & 7] & 0xFF;
+                            if (((b >> (7 - (x & 7))) & 1) != 0) {
+                                setPixel(x, y, fill);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (drawBoundary && boundaryColorArgb != 0) {
+            for (int i = 0; i < numPoints; i++) {
+                int next = (i + 1) % numPoints;
+                drawLine(px[i], py[i], px[next], py[next], boundaryColorArgb, lineType, lineWidth);
+            }
+        }
+        hasContent = true;
+    }
+
+    /**
+     * Draws a GOCA marker symbol (+, x, diamond, square, star, dot, circle).
+     */
+    public synchronized void drawMarker(int x, int y, int markerType, int size, int colorArgb) {
+        int color = (colorArgb != 0) ? colorArgb : 0xFFFFFFFF;
+        int s = Math.max(3, size > 0 ? size : 5);
+
+        switch (markerType) {
+            case GocaConstants.MK_CROSS: // x
+                drawLine(x - s, y - s, x + s, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s, y + s, x + s, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_PLUS: // +
+            case GocaConstants.MK_DEFAULT:
+                drawLine(x - s, y, x + s, y, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x, y - s, x, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_DIAMOND: // <>
+                drawLine(x, y - s, x + s, y, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x + s, y, x, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x, y + s, x - s, y, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s, y, x, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_SQUARE: // []
+                drawLine(x - s, y - s, x + s, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x + s, y - s, x + s, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x + s, y + s, x - s, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s, y + s, x - s, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_6STAR: // 6-point star
+                drawLine(x - s, y, x + s, y, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s / 2, y - s, x + s / 2, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s / 2, y + s, x + s / 2, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_8STAR: // 8-point star
+                drawLine(x - s, y, x + s, y, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x, y - s, x, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s, y - s, x + s, y + s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                drawLine(x - s, y + s, x + s, y - s, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                break;
+            case GocaConstants.MK_SDIAMOND: // solid diamond
+                fillArea(new int[]{x, x + s, x, x - s}, new int[]{y - s, y, y + s, y}, 4,
+                         color, GocaConstants.PT_SOLID, false, 0, 0, 0);
+                break;
+            case GocaConstants.MK_SSQUARE: // solid square
+                fillArea(new int[]{x - s, x + s, x + s, x - s}, new int[]{y - s, y - s, y + s, y + s}, 4,
+                         color, GocaConstants.PT_SOLID, false, 0, 0, 0);
+                break;
+            case GocaConstants.MK_DOT: // dot
+                for (int dy = -2; dy <= 2; dy++) {
+                    for (int dx = -2; dx <= 2; dx++) {
+                        if (dx * dx + dy * dy <= 4) {
+                            setPixel(x + dx, y + dy, color);
+                        }
+                    }
+                }
+                break;
+            case GocaConstants.MK_CIRCLE: // circle
+            default:
+                drawArc(x, y, s, s, 0.0, 360.0, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL, true);
+                break;
+        }
+        hasContent = true;
+    }
+
+    private static final int[] VSS_OFFSETS = new int[256];
+    static {
+        Arrays.fill(VSS_OFFSETS, -1);
+        int sym = VectorSymbolData.VSS_SYMBOL_START; // 33
+        if (sym < 256) {
+            VSS_OFFSETS[sym] = 0;
+        }
+        for (int i = 0; i < VectorSymbolData.vss_data.length; i++) {
+            if (VectorSymbolData.vss_data[i] == VectorSymbolData.END_DEFAULT) { // 0xFF
+                sym++;
+                if (sym < 256 && i + 1 < VectorSymbolData.vss_data.length) {
+                    VSS_OFFSETS[sym] = i + 1;
+                }
+            }
+        }
+    }
+
+    /**
+     * Draws stroked vector text using IBM Vector Symbol Set (VSS).
+     */
+    public synchronized void drawVectorText(int x, int y, String text, int colorArgb,
+                                           int cellWidth, int cellHeight, int dir, double angle) {
+        if (text == null || text.isEmpty()) return;
+        int color = (colorArgb != 0) ? colorArgb : 0xFFFFFFFF;
+
+        int curX = x;
+        int curY = y;
+        int cw = cellWidth > 0 ? cellWidth : 12;
+        int ch = cellHeight > 0 ? cellHeight : 20;
+
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            drawVssChar(curX, curY, c, color, cw, ch);
+
+            switch (dir) {
+                case GocaConstants.CD_TB: curY += ch; break;
+                case GocaConstants.CD_RL: curX -= cw; break;
+                case GocaConstants.CD_BT: curY -= ch; break;
+                case GocaConstants.CD_LR:
+                case GocaConstants.CD_DEFAULT:
+                default:
+                    curX += cw;
+                    break;
+            }
+        }
+        hasContent = true;
+    }
+
+    private void drawVssChar(int x, int y, char c, int color, int cw, int ch) {
+        int code = (int) c;
+        if (code < VectorSymbolData.VSS_SYMBOL_START || code >= 256) {
+            return;
+        }
+        int offset = VSS_OFFSETS[code];
+        if (offset < 0) {
+            return;
+        }
+
+        int ptr = offset;
+        while (ptr < VectorSymbolData.vss_data.length && VectorSymbolData.vss_data[ptr] != VectorSymbolData.END_DEFAULT) {
+            int order = VectorSymbolData.vss_data[ptr] & 0xFF;
+            if (order == 0xC1) {
+                int byteLen = VectorSymbolData.vss_data[ptr + 1] & 0xFF;
+                int numPoints = byteLen / 4;
+                int dataPtr = ptr + 2;
+
+                if (numPoints >= 2) {
+                    int prevVx = ((VectorSymbolData.vss_data[dataPtr] & 0xFF) << 8) | (VectorSymbolData.vss_data[dataPtr + 1] & 0xFF);
+                    int prevVy = ((VectorSymbolData.vss_data[dataPtr + 2] & 0xFF) << 8) | (VectorSymbolData.vss_data[dataPtr + 3] & 0xFF);
+                    int prevPx = x + (int) Math.round(((double) prevVx / VectorSymbolData.VSS_WIDTH) * cw);
+                    int prevPy = y + (int) Math.round(((double)(VectorSymbolData.VSS_HEIGHT - prevVy) / VectorSymbolData.VSS_HEIGHT) * ch);
+
+                    for (int p = 1; p < numPoints; p++) {
+                        int vx = ((VectorSymbolData.vss_data[dataPtr + p * 4] & 0xFF) << 8) | (VectorSymbolData.vss_data[dataPtr + p * 4 + 1] & 0xFF);
+                        int vy = ((VectorSymbolData.vss_data[dataPtr + p * 4 + 2] & 0xFF) << 8) | (VectorSymbolData.vss_data[dataPtr + p * 4 + 3] & 0xFF);
+                        int px = x + (int) Math.round(((double) vx / VectorSymbolData.VSS_WIDTH) * cw);
+                        int py = y + (int) Math.round(((double)(VectorSymbolData.VSS_HEIGHT - vy) / VectorSymbolData.VSS_HEIGHT) * ch);
+
+                        drawLine(prevPx, prevPy, px, py, color, GocaConstants.LT_SOLID, GocaConstants.LW_NORMAL);
+                        prevPx = px;
+                        prevPy = py;
+                    }
+                }
+                ptr += 2 + byteLen;
+            } else {
+                ptr++;
+            }
+        }
+    }
+
+    /**
+     * Draws raw image pixel bitmap.
+     */
+    public synchronized void drawImage(int x, int y, int width, int height, byte[] imageData, int fgColorArgb) {
+        if (imageData == null || width <= 0 || height <= 0) return;
+        int fgColor = (fgColorArgb != 0) ? fgColorArgb : 0xFFFFFFFF;
+
+        for (int row = 0; row < height; row++) {
+            for (int col = 0; col < width; col++) {
+                int bitIndex = row * width + col;
+                int byteIdx = bitIndex / 8;
+                if (byteIdx < imageData.length) {
+                    boolean bit = ((imageData[byteIdx] >> (7 - (bitIndex % 8))) & 1) != 0;
+                    if (bit) {
+                        setPixel(x + col, y + row, fgColor);
+                    }
+                }
+            }
+        }
+        hasContent = true;
+    }
+}

lib3270j/src/main/java/org/lib3270j/graphics/ProgramSymbolManager.java

@@ -0,0 +1,311 @@
+package org.lib3270j.graphics;
+
+import java.util.Arrays;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Manages IBM 3270 Programmed Symbols (PS / APL) character sets.
+ * Handles the Load Programmed Symbols (LOADPS structured field 0x0F).
+ */
+public class ProgramSymbolManager {
+
+    private static final Logger logger = Logger.getLogger(ProgramSymbolManager.class.getName());
+
+    public static final int NUMBER_SYMBOL_SETS = 10;
+    public static final int NUMBER_SINGLE_PLANE_PS_SETS = 2; // RWS 2..3 (Sets 0..1)
+    public static final int NUMBER_TRIPLE_PLANE_PS_SETS = 4; // RWS 4..7 (Sets 2..5)
+    public static final int NUMBER_GRAPHICS_SYMBOL_SETS = 4; // RWS 8..11 (Sets 6..9)
+
+    private int defaultCellWidth = 9;
+    private int defaultCellHeight = 12; // Standard IBM 3279 PS Slot Default Height (SDH = 0x0C = 12)
+
+    public void setDefaultCellDimensions(int width, int height) {
+        this.defaultCellWidth = (width > 0) ? width : 9;
+        this.defaultCellHeight = (height > 0) ? height : 12;
+    }
+
+    public int getDefaultCellWidth() {
+        return defaultCellWidth;
+    }
+
+    public int getDefaultCellHeight() {
+        return defaultCellHeight;
+    }
+
+    private final ProgramSymbolSet[] sets = new ProgramSymbolSet[NUMBER_SYMBOL_SETS];
+    private final ProgramSymbolSet[] stagingSets = new ProgramSymbolSet[NUMBER_SYMBOL_SETS];
+    private final ProgramSymbolSet[] lcidMap = new ProgramSymbolSet[256];
+
+    public ProgramSymbolManager() {
+        for (int i = 0; i < NUMBER_SYMBOL_SETS; i++) {
+            boolean isTriple = (i >= NUMBER_SINGLE_PLANE_PS_SETS && i < NUMBER_SINGLE_PLANE_PS_SETS + NUMBER_TRIPLE_PLANE_PS_SETS);
+            sets[i] = new ProgramSymbolSet(isTriple);
+            stagingSets[i] = new ProgramSymbolSet(isTriple);
+        }
+    }
+
+    /**
+     * Resets all symbol sets.
+     */
+    public synchronized void clearAll() {
+        Arrays.fill(lcidMap, null);
+        for (int i = 0; i < NUMBER_SYMBOL_SETS; i++) {
+            sets[i].clear();
+            sets[i].setLcid(0);
+            stagingSets[i].clear();
+            stagingSets[i].setLcid(0);
+        }
+    }
+
+    /**
+     * Commits all staged multi-plane symbol sets to the active presentation sets atomically.
+     */
+    public synchronized void commitStagedSymbols() {
+        for (int i = 0; i < NUMBER_SYMBOL_SETS; i++) {
+            int lcid = stagingSets[i].getLcid();
+            if (lcid > 0) {
+                ProgramSymbolSet staged = stagingSets[i];
+                ProgramSymbolSet active = sets[i];
+                active.setLcid(lcid);
+                for (int slot = 0; slot < ProgramSymbolSet.NUM_SLOTS; slot++) {
+                    active.setSlot(slot, staged.getSlot(slot));
+                }
+                if (lcid < 256) {
+                    lcidMap[lcid] = active;
+                }
+            }
+        }
+    }
+
+    /**
+     * Retrieves the symbol set corresponding to a given LCID (0x40 - 0xFE).
+     */
+    public ProgramSymbolSet getSymbolSet(int lcid) {
+        if (lcid <= 0 || lcid >= 256) {
+            return null;
+        }
+        ProgramSymbolSet set = lcidMap[lcid];
+        if (set == null) {
+            for (ProgramSymbolSet s : stagingSets) {
+                if (s.getLcid() == lcid) return s;
+            }
+        }
+        return set;
+    }
+
+    /**
+     * Retrieves a specific symbol glyph by LCID and character code point (0x40 - 0xFE).
+     */
+    public ProgramSymbolSet.SymbolSlot getSymbol(int lcid, int codePoint) {
+        if (lcid <= 0 || lcid >= 256) {
+            return null;
+        }
+        ProgramSymbolSet set = lcidMap[lcid];
+        if (set == null) {
+            for (ProgramSymbolSet s : stagingSets) {
+                if (s.getLcid() == lcid) {
+                    set = s;
+                    break;
+                }
+            }
+        }
+        if (set == null) {
+            return null;
+        }
+        int index = (codePoint >= 0x40) ? (codePoint - 0x40) : codePoint;
+        return set.getSlot(index);
+    }
+
+    /**
+     * Processes a Load Programmed Symbols (LOADPS structured field 0x0F) payload.
+     */
+    public synchronized void loadps(byte[] data) {
+        if (data == null || data.length < 4) {
+            logger.warning("LOADPS: Payload too short (" + (data == null ? 0 : data.length) + " bytes)");
+            return;
+        }
+
+        int flags = data[0] & 0xFF;
+        int loadFormat = flags & 0x1F;
+        boolean clearAll = (flags & 0x40) != 0;
+        boolean hasExtHeader = (flags & 0x80) != 0;
+
+        int lcid = data[1] & 0xFF;
+        int startCodePoint = data[2] & 0xFF;
+        int rws = data[3] & 0xFF;
+
+        int setIndex;
+        switch (rws) {
+            case 2:  setIndex = 0; break;
+            case 3:  setIndex = 1; break;
+            case 4:  setIndex = 2; break;
+            case 5:  setIndex = 3; break;
+            case 6:  setIndex = 4; break;
+            case 7:  setIndex = 5; break;
+            case 8:  setIndex = 6; break;
+            case 9:  setIndex = 7; break;
+            case 10: setIndex = 8; break;
+            case 11: setIndex = 9; break;
+            default:
+                logger.warning("LOADPS: Invalid RWS slot 0x" + Integer.toHexString(rws));
+                return;
+        }
+
+        boolean isTriplePlane = (rws >= 4 && rws <= 7);
+        ProgramSymbolSet set = isTriplePlane ? stagingSets[setIndex] : sets[setIndex];
+
+        int extHeaderLen = 0;
+        int cellWidth = defaultCellWidth;
+        int cellHeight = defaultCellHeight;
+        int colorPlane = 0; // 0 = all planes, 1 = Red, 2 = Green, 4 = Blue
+
+        if (hasExtHeader && data.length > 4) {
+            extHeaderLen = data[4] & 0xFF;
+            if (extHeaderLen > 3 && data.length > 6) {
+                int lw = data[6] & 0xFF;
+                if (lw > 0) cellWidth = lw;
+            }
+            if (extHeaderLen > 4 && data.length > 7) {
+                int lh = data[7] & 0xFF;
+                if (lh > 0) cellHeight = lh;
+            }
+            if (extHeaderLen >= 6 && data.length > 9) {
+                colorPlane = data[9] & 0xFF;
+            }
+        }
+
+        set.setLcid(lcid);
+        if (!isTriplePlane && lcid > 0 && lcid < 256) {
+            lcidMap[lcid] = set;
+        }
+
+        int offset = 4 + (hasExtHeader ? extHeaderLen : 0);
+        int remaining = data.length - offset;
+        int codeIndex = (startCodePoint >= 0x40) ? (startCodePoint - 0x40) : startCodePoint;
+
+        int bytesPerSymbol;
+        if (loadFormat == 1) {
+            bytesPerSymbol = 18; // 9x16 cell in standard transmission format
+        } else {
+            bytesPerSymbol = (cellWidth * cellHeight + 7) / 8;
+        }
+
+        if (bytesPerSymbol <= 0) {
+            bytesPerSymbol = 18;
+        }
+
+        while (remaining >= bytesPerSymbol && codeIndex < ProgramSymbolSet.NUM_SLOTS) {
+            byte[] pixelData = new byte[cellWidth * cellHeight];
+            ProgramSymbolSet.SymbolSlot existing = set.getSlot(codeIndex);
+            if (!clearAll && existing != null && existing.getWidth() == cellWidth && existing.getHeight() == cellHeight) {
+                System.arraycopy(existing.getPixelData(), 0, pixelData, 0, Math.min(existing.getPixelData().length, pixelData.length));
+            }
+
+            if (loadFormat == 1) {
+                unpackFormat1(data, offset, pixelData, cellWidth, cellHeight, isTriplePlane, colorPlane);
+            } else {
+                unpackFormat3(data, offset, pixelData, cellWidth, cellHeight, isTriplePlane, colorPlane);
+            }
+
+            set.setSlot(codeIndex, new ProgramSymbolSet.SymbolSlot(cellWidth, cellHeight, pixelData, isTriplePlane));
+
+            codeIndex++;
+            offset += bytesPerSymbol;
+            remaining -= bytesPerSymbol;
+        }
+
+        if (clearAll) {
+            for (int i = codeIndex; i < ProgramSymbolSet.NUM_SLOTS; i++) {
+                set.clearSlot(i);
+            }
+        }
+
+        if (logger.isLoggable(Level.FINE)) {
+            logger.fine(String.format("LOADPS: Loaded PS Set LCID=0x%02X (RWS=%d, %s, %dx%d, %d glyphs)",
+                    lcid, rws, isTriplePlane ? "Triple-Plane" : "Single-Plane",
+                    cellWidth, cellHeight, codeIndex - ((startCodePoint >= 0x40) ? (startCodePoint - 0x40) : startCodePoint)));
+        }
+    }
+
+    /**
+     * Unpacks Format 1 (9x16) symbol slice bit-pattern.
+     */
+    private void unpackFormat1(byte[] src, int srcOff, byte[] dst, int width, int height,
+                               boolean isTriplePlane, int colorPlane) {
+        // Format 1 transmits 18 bytes:
+        // Byte 0-1: contains column 0 for each of the 16 rows
+        // Bytes 2-17: contains columns 1-8 for each of the 16 rows
+        int planeMask = (colorPlane != 0) ? colorPlane : (isTriplePlane ? 7 : 1);
+
+        for (int row = 0; row < 16 && row < height; row++) {
+            // Column 0 bit from byte 0 or byte 1
+            int b0 = (row < 8) ? (src[srcOff] & 0xFF) : (src[srcOff + 1] & 0xFF);
+            int bitShift0 = 7 - (row % 8);
+            boolean bit0 = ((b0 >> bitShift0) & 1) != 0;
+
+            int dstIdx0 = row * width;
+            if (dstIdx0 < dst.length) {
+                if (!isTriplePlane) {
+                    dst[dstIdx0] = bit0 ? (byte) 1 : 0;
+                } else if (colorPlane == 0) {
+                    dst[dstIdx0] = bit0 ? (byte) 7 : 0;
+                } else {
+                    if (bit0) {
+                        dst[dstIdx0] |= (byte) colorPlane;
+                    } else {
+                        dst[dstIdx0] &= (byte) ~colorPlane;
+                    }
+                }
+            }
+
+            // Columns 1..8 from bytes 2..17
+            if (srcOff + 2 + row < src.length) {
+                int rowByte = src[srcOff + 2 + row] & 0xFF;
+                for (int col = 1; col < 9 && col < width; col++) {
+                    int dstIdx = row * width + col;
+                    if (dstIdx < dst.length) {
+                        boolean bit = ((rowByte >> (8 - col)) & 1) != 0;
+                        if (!isTriplePlane) {
+                            dst[dstIdx] = bit ? (byte) 1 : 0;
+                        } else if (colorPlane == 0) {
+                            dst[dstIdx] = bit ? (byte) 7 : 0;
+                        } else {
+                            if (bit) {
+                                dst[dstIdx] |= (byte) colorPlane;
+                            } else {
+                                dst[dstIdx] &= (byte) ~colorPlane;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Unpacks Format 3 variable dimension bit-pattern.
+     */
+    private void unpackFormat3(byte[] src, int srcOff, byte[] dst, int width, int height,
+                               boolean isTriplePlane, int colorPlane) {
+        int totalPixels = width * height;
+        for (int i = 0; i < totalPixels; i++) {
+            int byteIndex = srcOff + (i / 8);
+            if (byteIndex >= src.length) break;
+            int bitIndex = 7 - (i % 8);
+            boolean bit = ((src[byteIndex] >> bitIndex) & 1) != 0;
+
+            if (!isTriplePlane) {
+                dst[i] = bit ? (byte) 1 : 0;
+            } else if (colorPlane == 0) {
+                dst[i] = bit ? (byte) 7 : 0;
+            } else {
+                if (bit) {
+                    dst[i] |= (byte) colorPlane;
+                } else {
+                    dst[i] &= (byte) ~colorPlane;
+                }
+            }
+        }
+    }
+}

lib3270j/src/main/java/org/lib3270j/graphics/ProgramSymbolSet.java

@@ -0,0 +1,189 @@
+package org.lib3270j.graphics;
+
+/**
+ * Represents a set of up to 191 custom bitmapped symbols (LCID 0x40 - 0xFE).
+ * Supports both Single-Plane (monochrome) and Triple-Plane (7-color RGB composite).
+ */
+public class ProgramSymbolSet {
+
+    public static final int NUM_SLOTS = 191; // Code points 0x40 - 0xFE (0..190)
+
+    private int lcid = 0;
+    private final boolean isTriplePlane;
+    private final SymbolSlot[] slots = new SymbolSlot[NUM_SLOTS];
+
+    public ProgramSymbolSet(boolean isTriplePlane) {
+        this.isTriplePlane = isTriplePlane;
+    }
+
+    public int getLcid() {
+        return lcid;
+    }
+
+    public void setLcid(int lcid) {
+        this.lcid = lcid;
+    }
+
+    public boolean isTriplePlane() {
+        return isTriplePlane;
+    }
+
+    public void clear() {
+        for (int i = 0; i < NUM_SLOTS; i++) {
+            slots[i] = null;
+        }
+    }
+
+    public void clearSlot(int index) {
+        if (index >= 0 && index < NUM_SLOTS) {
+            slots[index] = null;
+        }
+    }
+
+    public void setSlot(int index, SymbolSlot slot) {
+        if (index >= 0 && index < NUM_SLOTS) {
+            slots[index] = slot;
+        }
+    }
+
+    public SymbolSlot getSlot(int index) {
+        if (index >= 0 && index < NUM_SLOTS) {
+            return slots[index];
+        }
+        return null;
+    }
+
+    /**
+     * Represents a single custom symbol bitmap.
+     */
+    public static class SymbolSlot {
+        private final int width;
+        private final int height;
+        private final byte[] pixelData; // 1 byte per pixel: 0 = background, 1..7 = color index (or 1 for monochrome)
+        private final boolean isTriplePlane;
+        private int[] cachedRgbArray;
+        private int cachedFgRgb = -1;
+        private int cachedBgRgb = -1;
+        private java.awt.image.BufferedImage cachedImage;
+        private java.awt.image.BufferedImage cachedScaledImage;
+        private int cachedTargetW = 0;
+        private int cachedTargetH = 0;
+        private int cachedScaledFgRgb = -1;
+        private int cachedScaledBgRgb = -1;
+
+        public SymbolSlot(int width, int height, byte[] pixelData, boolean isTriplePlane) {
+            this.width = width > 0 ? width : 9;
+            this.height = height > 0 ? height : 16;
+            this.pixelData = pixelData;
+            this.isTriplePlane = isTriplePlane;
+        }
+
+        public int getWidth() {
+            return width;
+        }
+
+        public int getHeight() {
+            return height;
+        }
+
+        public byte[] getPixelData() {
+            return pixelData;
+        }
+
+        public boolean isTriplePlane() {
+            return isTriplePlane;
+        }
+
+        /**
+         * Returns an image scaled directly to target dimensions (cellWidth x cellHeight).
+         * Enables unscaled 1:1 hardware blitting in Java2D.
+         */
+        public synchronized java.awt.image.BufferedImage getScaledImage(int targetW, int targetH, int fgArgb, int bgArgb) {
+            if (targetW <= 0 || targetH <= 0) {
+                return getImage(fgArgb, bgArgb);
+            }
+            if (targetW == width && targetH == height) {
+                return getImage(fgArgb, bgArgb);
+            }
+            if (cachedScaledImage != null && cachedTargetW == targetW && cachedTargetH == targetH
+                    && cachedScaledFgRgb == fgArgb && cachedScaledBgRgb == bgArgb) {
+                return cachedScaledImage;
+            }
+            int[] srcRgb = getRgbPixels(fgArgb, bgArgb);
+            java.awt.image.BufferedImage scaled = new java.awt.image.BufferedImage(targetW, targetH, java.awt.image.BufferedImage.TYPE_INT_ARGB);
+            int[] dstRgb = ((java.awt.image.DataBufferInt) scaled.getRaster().getDataBuffer()).getData();
+
+            for (int dy = 0; dy < targetH; dy++) {
+                int sy = dy * height / targetH;
+                int srcRowOffset = sy * width;
+                int dstRowOffset = dy * targetW;
+                for (int dx = 0; dx < targetW; dx++) {
+                    int sx = dx * width / targetW;
+                    dstRgb[dstRowOffset + dx] = srcRgb[srcRowOffset + sx];
+                }
+            }
+
+            this.cachedScaledImage = scaled;
+            this.cachedTargetW = targetW;
+            this.cachedTargetH = targetH;
+            this.cachedScaledFgRgb = fgArgb;
+            this.cachedScaledBgRgb = bgArgb;
+            return scaled;
+        }
+
+        /**
+         * Computes and returns the cached BufferedImage for this symbol glyph.
+         * Eliminates per-cell heap allocations during high frame rate rendering.
+         */
+        public synchronized java.awt.image.BufferedImage getImage(int fgArgb, int bgArgb) {
+            if (cachedImage != null && cachedFgRgb == fgArgb && cachedBgRgb == bgArgb) {
+                return cachedImage;
+            }
+            int[] rgb = getRgbPixels(fgArgb, bgArgb);
+            java.awt.image.BufferedImage img = new java.awt.image.BufferedImage(width, height, java.awt.image.BufferedImage.TYPE_INT_ARGB);
+            int[] imgData = ((java.awt.image.DataBufferInt) img.getRaster().getDataBuffer()).getData();
+            System.arraycopy(rgb, 0, imgData, 0, rgb.length);
+            this.cachedImage = img;
+            this.cachedFgRgb = fgArgb;
+            this.cachedBgRgb = bgArgb;
+            return img;
+        }
+
+        /**
+         * Computes and returns the 32-bit ARGB pixel array for this symbol.
+         * The returned array has length (width * height).
+         */
+        public synchronized int[] getRgbPixels(int fgArgb, int bgArgb) {
+            if (cachedRgbArray != null && cachedFgRgb == fgArgb && cachedBgRgb == bgArgb) {
+                return cachedRgbArray;
+            }
+
+            int[] rgbArray = new int[width * height];
+
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                    int idx = y * width + x;
+                    int val = (pixelData != null && idx < pixelData.length) ? (pixelData[idx] & 0xFF) : 0;
+
+                    if (val == 0) {
+                        rgbArray[idx] = bgArgb;
+                    } else if (!isTriplePlane) {
+                        rgbArray[idx] = fgArgb;
+                    } else {
+                        // Triple-Plane RGB composite:
+                        // val is bitmask: bit 0 (0x01) = Red, bit 1 (0x02) = Green, bit 2 (0x04) = Blue
+                        int r = (val & 0x01) != 0 ? 255 : 0;
+                        int g = (val & 0x02) != 0 ? 255 : 0;
+                        int b = (val & 0x04) != 0 ? 255 : 0;
+                        rgbArray[idx] = (0xFF << 24) | (r << 16) | (g << 8) | b;
+                    }
+                }
+            }
+
+            this.cachedRgbArray = rgbArray;
+            this.cachedFgRgb = fgArgb;
+            this.cachedBgRgb = bgArgb;
+            return rgbArray;
+        }
+    }
+}

lib3270j/src/main/java/org/lib3270j/input/InputProcessor.java

@@ -31,6 +31,12 @@ public class InputProcessor {
         this.fsm = fsm;
     }
 
+    private org.lib3270j.graphics.GraphicsPlane graphicsPlane;
+
+    public void setGraphicsPlane(org.lib3270j.graphics.GraphicsPlane gp) {
+        this.graphicsPlane = gp;
+    }
+
     public enum OiaStatus {
         NOT_CONNECTED("OFFLINE"),
         X_SYSTEM("X SYSTEM"),
@@ -146,6 +152,7 @@ public class InputProcessor {
         }
         screen.setCursorAddress(baddr);
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     /**
@@ -160,6 +167,9 @@ public class InputProcessor {
         if (aidCode == AID_CLEAR) {
             screen.clear();
             screen.markAllChanged();
+            if (graphicsPlane != null) {
+                graphicsPlane.clear();
+            }
             // Send just the AID
             byte[] data = new byte[] { (byte) aidCode };
             sendAidResponse(data);
@@ -197,6 +207,7 @@ public class InputProcessor {
             int nextRowAddr = ((row + 1) % screen.getRows()) * cols;
             screen.setCursorAddress(nextRowAddr);
             screen.markAllChanged();
+            screen.updateDisplaySnapshot();
             setKeyboardLocked(false);
             return;
         }
@@ -300,6 +311,7 @@ public class InputProcessor {
         addr -= screen.getCols();
         if (addr < 0) addr += screen.getRows() * screen.getCols();
         screen.setCursorAddress(addr);
+        screen.updateDisplaySnapshot();
     }
 
     public void cursorDown() {
@@ -307,18 +319,21 @@ public class InputProcessor {
         addr += screen.getCols();
         if (addr >= screen.getRows() * screen.getCols()) addr -= screen.getRows() * screen.getCols();
         screen.setCursorAddress(addr);
+        screen.updateDisplaySnapshot();
     }
 
     public void cursorLeft() {
         int addr = screen.getCursorAddress();
         addr = screen.decrementAddress(addr);
         screen.setCursorAddress(addr);
+        screen.updateDisplaySnapshot();
     }
 
     public void cursorRight() {
         int addr = screen.getCursorAddress();
         addr = screen.incrementAddress(addr);
         screen.setCursorAddress(addr);
+        screen.updateDisplaySnapshot();
     }
 
     public void cursorHome() {
@@ -327,11 +342,13 @@ public class InputProcessor {
         } else {
             screen.setCursorAddress(0);
         }
+        screen.updateDisplaySnapshot();
     }
 
     public void tab() {
         int addr = screen.findNextUnprotected(screen.getCursorAddress());
         screen.setCursorAddress(addr);
+        screen.updateDisplaySnapshot();
     }
 
     public int getLastAid() { return lastAid; }
@@ -339,6 +356,7 @@ public class InputProcessor {
 
     public void setCursorAddress(int baddr) {
         screen.setCursorAddress(baddr);
+        screen.updateDisplaySnapshot();
     }
 
     public void backTab() {
@@ -352,6 +370,7 @@ public class InputProcessor {
             if (screen.getCell(addr).isFieldAttribute()) {
                 if (!faIsProtected(screen.getCell(addr).fa & 0xFF)) {
                     screen.setCursorAddress(screen.incrementAddress(addr));
+                    screen.updateDisplaySnapshot();
                     return;
                 }
             }
@@ -368,6 +387,7 @@ public class InputProcessor {
                 ea.ucs4 = 0;
             }
             screen.markAllChanged();
+            screen.updateDisplaySnapshot();
             return;
         }
         int addr = screen.getCursorAddress();
@@ -389,6 +409,7 @@ public class InputProcessor {
             screen.getCell(faAddr).fa = (byte) (screen.getCell(faAddr).fa | FA_MODIFY);
         }
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     public void deleteChar() {
@@ -417,6 +438,7 @@ public class InputProcessor {
             screen.getCell(faAddr).fa = (byte) (screen.getCell(faAddr).fa | FA_MODIFY);
         }
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     public void backspace() {
@@ -430,6 +452,7 @@ public class InputProcessor {
         if (keyboardLocked) return;
         screen.eraseAllUnprotected();
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     /** Move cursor to first unprotected field on next line (Newline key in 3270). */
@@ -446,6 +469,7 @@ public class InputProcessor {
         }
         screen.setCursorAddress(target);
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     /** Insert Duplicate (DUP) code and advance to next field. */
@@ -463,6 +487,8 @@ public class InputProcessor {
             screen.getCell(faAddr).fa = (byte) (screen.getCell(faAddr).fa | FA_MODIFY);
         }
         tab();
+        screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     /** Insert Field Mark (FM) code. */
@@ -486,6 +512,7 @@ public class InputProcessor {
         }
         screen.setCursorAddress(baddr);
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
     }
 
     /** Attention key (sends Telnet IP). */
@@ -562,6 +589,7 @@ public class InputProcessor {
                 screen.getCell(i).ucs4 = 0;
             }
             screen.markAllChanged();
+            screen.updateDisplaySnapshot();
             return size;
         }
 
@@ -599,6 +627,7 @@ public class InputProcessor {
             screen.getCell(faAddr).fa = (byte) (screen.getCell(faAddr).fa | FA_MODIFY);
         }
         screen.markAllChanged();
+        screen.updateDisplaySnapshot();
         return fieldLen;
     }
 

lib3270j/src/main/java/org/lib3270j/protocol/DS3270Constants.java

@@ -208,10 +208,19 @@ public final class DS3270Constants {
     public static final int QR_COLOR        = 0x86;
     public static final int QR_HIGHLIGHTING = 0x87;
     public static final int QR_REPLY_MODES  = 0x88;
+    public static final int QR_SAVE_RESTORE = 0x8c;
     public static final int QR_DBCS_ASIA    = 0x91;
     public static final int QR_DDM          = 0x95;
+    public static final int QR_TRANSPARENCY = 0x99;
     public static final int QR_RPQNAMES     = 0xa1;
     public static final int QR_IMP_PART     = 0xa6;
+    public static final int QR_RPQ_NAMES    = 0xa8;
+    public static final int QR_GRAPHICS     = 0xb0; // 3270-PC Vector Graphics
+    public static final int QR_GIMAGE       = 0xb1; // Image / Graphics Planes
+    public static final int QR_AUX_DEV      = 0xb2; // Auxiliary Device
+    public static final int QR_OEM_FMT      = 0xb3; // OEM Format
+    public static final int QR_GCOLOR       = 0xb4; // Graphic Color Table
+    public static final int QR_GSYMBOLS     = 0xb6; // Graphic Symbol Sets
     public static final int QR_NULL         = 0xff;
 
     // ========== Screen model sizes ==========

lib3270j/src/main/java/org/lib3270j/screen/ScreenBuffer.java

@@ -36,8 +36,12 @@ public class ScreenBuffer {
     private byte defaultGr = 0x00;
     private byte defaultCs = 0x00;
     private byte defaultIc = 0x00;
-
     private final EbcdicTranslator translator;
+    private final Object renderLock = new Object();
+
+    public Object getRenderLock() {
+        return renderLock;
+    }
 
     public ScreenBuffer(TerminalModel model, EbcdicTranslator translator) {
         this.translator = translator;
@@ -56,6 +60,7 @@ public class ScreenBuffer {
         defaultFA.ic = 1;
 
         allocateBuffers();
+        updateDisplaySnapshot();
     }
 
     private void allocateBuffers() {
@@ -79,6 +84,50 @@ public class ScreenBuffer {
         return buffer[addr];
     }
 
+    private ExtendedAttribute[] displaySnapshot;
+    private int displayRows;
+    private int displayCols;
+    private int displayCursorAddress;
+
+    /**
+     * Atomically creates a snapshot of the current presentation buffer for tear-free rendering.
+     * Takes ~2 microseconds and eliminates mutual thread contention with the UI thread.
+     */
+    public synchronized void updateDisplaySnapshot() {
+        int size = rows * cols;
+        if (displaySnapshot == null || displaySnapshot.length < size) {
+            displaySnapshot = new ExtendedAttribute[size];
+            for (int i = 0; i < size; i++) {
+                displaySnapshot[i] = new ExtendedAttribute();
+            }
+        }
+        for (int i = 0; i < size; i++) {
+            displaySnapshot[i].copyFrom(buffer[i]);
+        }
+        this.displayRows = rows;
+        this.displayCols = cols;
+        this.displayCursorAddress = cursorAddress;
+    }
+
+    public synchronized ExtendedAttribute getDisplayCell(int addr) {
+        if (displaySnapshot == null || addr < 0 || addr >= displayRows * displayCols) {
+            return getCell(addr);
+        }
+        return displaySnapshot[addr];
+    }
+
+    public synchronized int getDisplayRows() {
+        return displayRows > 0 ? displayRows : rows;
+    }
+
+    public synchronized int getDisplayCols() {
+        return displayCols > 0 ? displayCols : cols;
+    }
+
+    public synchronized int getDisplayCursorAddress() {
+        return displayRows > 0 ? displayCursorAddress : cursorAddress;
+    }
+
     // ========== Dimension accessors ==========
     public int getRows()       { return rows; }
     public int getCols()       { return cols; }
@@ -91,7 +140,7 @@ public class ScreenBuffer {
     public boolean isScreenAlt() { return screenAlt; }
 
     /** Update alternate dimensions from BIND image. Re-allocates buffers if needed. */
-    public void setAlternateDimensions(int newAltRows, int newAltCols) {
+    public synchronized void setAlternateDimensions(int newAltRows, int newAltCols) {
         if (newAltRows == altRows && newAltCols == altCols) return;
         this.altRows = newAltRows;
         this.altCols = newAltCols;
@@ -101,11 +150,15 @@ public class ScreenBuffer {
             this.maxCols = Math.max(maxCols, newAltCols);
             allocateBuffers();
         }
+        updateDisplaySnapshot();
     }
 
     // ========== Cursor ==========
     public int getCursorAddress()                  { return cursorAddress; }
-    public void setCursorAddress(int addr)         { this.cursorAddress = addr; }
+    public synchronized void setCursorAddress(int addr) {
+        this.cursorAddress = addr;
+        this.displayCursorAddress = addr;
+    }
     public int getCursorRow()                      { return cursorAddress / cols; }
     public int getCursorCol()                      { return cursorAddress % cols; }
 
@@ -120,20 +173,22 @@ public class ScreenBuffer {
     /**
      * Perform an erase, optionally using the alternate screen size.
      */
-    public void erase(boolean alt) {
+    public synchronized void erase(boolean alt) {
         clear();
         int newRows = alt ? altRows : defRows;
         int newCols = alt ? altCols : defCols;
         if (alt == screenAlt && rows == newRows && cols == newCols) {
+            updateDisplaySnapshot();
             return;
         }
         rows = newRows;
         cols = newCols;
         screenAlt = alt;
+        updateDisplaySnapshot();
     }
 
     /** Clear the entire buffer. */
-    public void clear() {
+    public synchronized void clear() {
         for (ExtendedAttribute ea : buffer) {
             ea.clear();
         }
@@ -148,12 +203,13 @@ public class ScreenBuffer {
         defaultCs = 0x00;
         defaultIc = 0x00;
         replyMode = SF_SRM_FIELD;
+        updateDisplaySnapshot();
     }
 
     /**
      * Erase all unprotected fields.
      */
-    public void eraseAllUnprotected() {
+    public synchronized void eraseAllUnprotected() {
         int size = rows * cols;
         boolean inUnprotected = false;
 
@@ -181,6 +237,7 @@ public class ScreenBuffer {
         // Move cursor to first unprotected field
         cursorAddress = findNextUnprotected(0);
         screenChanged = true;
+        updateDisplaySnapshot();
     }
 
     // ========== Field attribute navigation ==========
@@ -274,7 +331,7 @@ public class ScreenBuffer {
 
     // ========== Setters for model reconfiguration ==========
 
-    public void setDimensions(int maxRows, int maxCols, int defRows, int defCols,
+    public synchronized void setDimensions(int maxRows, int maxCols, int defRows, int defCols,
                                int altRows, int altCols) {
         this.maxRows = maxRows;
         this.maxCols = maxCols;
@@ -285,6 +342,7 @@ public class ScreenBuffer {
         this.rows = defRows;
         this.cols = defCols;
         allocateBuffers();
+        updateDisplaySnapshot();
     }
 
     public void translateToUnicode() {

lib3270j/src/main/java/org/lib3270j/telnet/TelnetConnection.java

@@ -28,26 +28,42 @@ public class TelnetConnection {
     private final TelnetFSM fsm;
     private final ConnectionConfig config;
 
+    private javax.net.ssl.SSLSession sslSession;
+
     public TelnetConnection(ConnectionConfig config, TelnetFSM fsm) {
         this.config = config;
         this.fsm = fsm;
     }
 
+    public javax.net.ssl.SSLSession getSslSession() {
+        return sslSession;
+    }
+
     /**
      * Connect to the host. Blocks until connection is established or fails.
      */
     public void connect() throws IOException {
         if (config.isUseTls()) {
-            log.info("Connecting with TLS to " + config.getHost() + ":" + config.getPort());
-            javax.net.ssl.SSLSocketFactory ssf = (javax.net.ssl.SSLSocketFactory) javax.net.ssl.SSLSocketFactory.getDefault();
+            log.info("Connecting with TLS to " + config.getHost() + ":" + config.getPort() +
+                    " (verifyCert=" + config.isTlsVerifyCert() + ")");
+            try {
+                javax.net.ssl.SSLContext sslContext = org.lib3270j.tls.TlsTrustManager.createSSLContext(config);
+                javax.net.ssl.SSLSocketFactory ssf = sslContext.getSocketFactory();
                 javax.net.ssl.SSLSocket sslSocket = (javax.net.ssl.SSLSocket) ssf.createSocket();
                 sslSocket.setKeepAlive(true);
-            sslSocket.setOOBInline(true);
                 sslSocket.setTcpNoDelay(true);
                 sslSocket.connect(new InetSocketAddress(config.getHost(), config.getPort()),
                                config.getConnectTimeoutMs());
                 sslSocket.startHandshake();
                 socket = sslSocket;
+                sslSession = sslSocket.getSession();
+                log.info("TLS session active: protocol=" + sslSession.getProtocol() +
+                         " cipher=" + sslSession.getCipherSuite());
+            } catch (IOException e) {
+                throw e;
+            } catch (Exception e) {
+                throw new IOException("TLS setup failure: " + e.getMessage(), e);
+            }
         } else {
             log.info("Connecting to " + config.getHost() + ":" + config.getPort());
             socket = new Socket();
@@ -133,9 +149,7 @@ public class TelnetConnection {
                         log.fine("RCVD " + n + " bytes: " + formatHex(buf, 0, n));
                     }
                     try {
-                        for (int i = 0; i < n; i++) {
-                            fsm.feedByte(buf[i] & 0xFF);
-                        }
+                        fsm.feedBytes(buf, 0, n);
                         fsm.endOfNetworkData();
                     } catch (Throwable t) {
                         log.log(Level.SEVERE, "Exception processing incoming data stream", t);

lib3270j/src/main/java/org/lib3270j/telnet/TelnetFSM.java

@@ -58,6 +58,7 @@ public class TelnetFSM {
     private int eXmitSeq;
     private int responseRequired = RSF_NO_RESPONSE;
     private boolean deferredWillTtype;
+    private boolean tn3270eDeviceTypeSent;
 
     // Connection references
     private TelnetConnection connection;
@@ -103,6 +104,7 @@ public class TelnetFSM {
         java.util.Arrays.fill(hisOpts, false);
         java.util.Arrays.fill(eFuncs, false);
         tn3270eNegotiated = false;
+        tn3270eDeviceTypeSent = false;
         tn3270eSubmode = TN3270ESubmode.UNBOUND;
         tn3270eBound = false;
         eXmitSeq = 0;
@@ -118,6 +120,37 @@ public class TelnetFSM {
         changeState(ConnectionState.TELNET_PENDING);
     }
 
+    /**
+     * Feed a bulk buffer of bytes from the network into the FSM.
+     */
+    public void feedBytes(byte[] buf, int offset, int len) {
+        int end = offset + len;
+        int i = offset;
+        while (i < end) {
+            if (state == TNS_DATA) {
+                int start = i;
+                while (i < end && (buf[i] & 0xFF) != IAC) {
+                    i++;
+                }
+                if (i > start) {
+                    if (connectionState == ConnectionState.TELNET_PENDING) {
+                        changeState(ConnectionState.CONNECTED_NVT);
+                    }
+                    if (connectionState.is3270() || connectionState.isTn3270e() || connectionState == ConnectionState.TELNET_PENDING) {
+                        ibuf.write(buf, start, i - start);
+                    }
+                }
+                if (i < end) {
+                    state = TNS_IAC;
+                    i++;
+                }
+            } else {
+                feedByte(buf[i] & 0xFF);
+                i++;
+            }
+        }
+    }
+
     /**
      * Feed a single byte from the network into the FSM.
      */
@@ -172,8 +205,8 @@ public class TelnetFSM {
             changeState(ConnectionState.CONNECTED_NVT);
         }
 
-        // Accumulate data for 3270, TN3270E (including SSCP-LU and unbound states)
-        if (connectionState.is3270() || connectionState.isTn3270e()) {
+        // Accumulate data for 3270, TN3270E (including SSCP-LU and unbound states, and pending)
+        if (connectionState.is3270() || connectionState.isTn3270e() || connectionState == ConnectionState.TELNET_PENDING) {
             ibuf.write(c);
         }
         // NVT data would go to NVT processor (not implemented in initial version)
@@ -189,7 +222,7 @@ public class TelnetFSM {
                 break;
             case EOR: // End of record — process accumulated 3270 data
                 log.fine("RCVD EOR");
-                if (connectionState.is3270() || connectionState.isTn3270e()) {
+                if (connectionState.is3270() || connectionState.isTn3270e() || connectionState == ConnectionState.TELNET_PENDING) {
                     processEndOfRecord();
                 }
                 ibuf.reset();
@@ -235,7 +268,9 @@ public class TelnetFSM {
                 break;
 
             case TELOPT_TN3270E:
-                if (!hisOpts[opt]) {
+                if (!config.isTn3270eEnabled()) {
+                    sendCommand(DONT, opt);
+                } else if (!hisOpts[opt]) {
                     hisOpts[opt] = true;
                     sendCommand(DO, opt);
                 }
@@ -278,7 +313,7 @@ public class TelnetFSM {
             case TELOPT_TTYPE:
                 if (!myOpts[opt]) {
                     myOpts[opt] = true;
-                    if (hisOpts[TELOPT_TN3270E]) {
+                    if (config.isTn3270eEnabled() && hisOpts[TELOPT_TN3270E]) {
                         // Defer TTYPE response until TN3270E negotiation completes
                         deferredWillTtype = true;
                     } else {
@@ -288,11 +323,16 @@ public class TelnetFSM {
                 break;
 
             case TELOPT_TN3270E:
-                if (!myOpts[opt]) {
+                if (!config.isTn3270eEnabled()) {
+                    sendCommand(WONT, opt);
+                } else if (!myOpts[opt]) {
                     myOpts[opt] = true;
                     sendCommand(WILL, opt);
                     // Start TN3270E sub-negotiation: send device type request
+                    if (!tn3270eDeviceTypeSent) {
                         sendTN3270EDeviceTypeRequest();
+                        tn3270eDeviceTypeSent = true;
+                    }
                 }
                 break;
 
@@ -401,7 +441,7 @@ public class TelnetFSM {
             out.write(IAC);
             out.write(SE);
             sendBytes(out.toByteArray());
-            log.info("SENT SB TTYPE IS " + termType + " SE");
+            log.warning(">>> SENT SB TTYPE IS " + termType + " SE");
         }
     }
 
@@ -428,7 +468,10 @@ public class TelnetFSM {
         switch (op) {
             case OP_SEND:
                 // Host asks us to send device-type request
+                if (!tn3270eDeviceTypeSent) {
                     sendTN3270EDeviceTypeRequest();
+                    tn3270eDeviceTypeSent = true;
+                }
                 break;
 
             case OP_DEVICE_TYPE:
@@ -475,7 +518,7 @@ public class TelnetFSM {
         out.write(IAC);
         out.write(SE);
         sendBytes(out.toByteArray());
-        log.info("SENT SB TN3270E DEVICE-TYPE REQUEST " + termType +
+        log.warning(">>> SENT SB TN3270E DEVICE-TYPE REQUEST " + termType +
             (config.getLuName() != null ? " CONNECT " + config.getLuName() : "") + " SE");
     }
 
@@ -488,14 +531,19 @@ public class TelnetFSM {
             pos++;
         }
 
+        // Check if REJECT
         if (pos < data.length && (data[pos] & 0xFF) == OP_REJECT) {
-            // Rejection
             pos++;
-            int reason = -1;
-            if (pos < data.length && (data[pos] & 0xFF) == OP_REASON) {
-                pos++;
-                if (pos < data.length) {
-                    reason = data[pos] & 0xFF;
+            int reason = (pos < data.length) ? (data[pos] & 0xFF) : REASON_UNSUPPORTED_REQ;
+            if (reason == REASON_INV_DEVICE_TYPE || reason == REASON_UNSUPPORTED_REQ) {
+                // Try fallback model 2 if we were requesting something else
+                if (config.getModel() != TerminalModel.IBM_3278_2 &&
+                    config.getModel() != TerminalModel.IBM_3279_2) {
+                    log.warning("TN3270E device-type rejected (" +
+                        TN3270EConstants.reasonName(reason) + "), retrying with IBM-3278-2");
+                    config.setModel(TerminalModel.IBM_3278_2);
+                    sendTN3270EDeviceTypeRequest();
+                    return;
                 }
             }
             log.warning("TN3270E device-type rejected: " + TN3270EConstants.reasonName(reason));
@@ -563,33 +611,86 @@ public class TelnetFSM {
         log.info("SENT SB TN3270E FUNCTIONS REQUEST " + funcNames + " SE");
     }
 
-    private void handleTN3270EFunctions(byte[] data) {
-        // Parse: TN3270E FUNCTIONS IS [func...]
-        int pos = 2; // Skip TN3270E, FUNCTIONS
+    private void sendTN3270EFunctionsIs() {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        out.write(IAC);
+        out.write(SB);
+        out.write(TELOPT_TN3270E);
+        out.write(OP_FUNCTIONS);
+        out.write(OP_IS);
 
-        if (pos < data.length && (data[pos] & 0xFF) == OP_IS) {
-            pos++; // Skip IS
+        StringBuilder funcNames = new StringBuilder();
+        for (int i = 0; i < eFuncs.length; i++) {
+            if (eFuncs[i]) {
+                out.write(i);
+                if (funcNames.length() > 0) funcNames.append(" ");
+                funcNames.append(TN3270EConstants.functionName(i));
+            }
         }
 
-        // The remaining bytes are the agreed-upon functions
-        java.util.Arrays.fill(eFuncs, false);
-        StringBuilder funcNames = new StringBuilder();
+        out.write(IAC);
+        out.write(SE);
+        sendBytes(out.toByteArray());
+        log.info("SENT SB TN3270E FUNCTIONS IS " + funcNames + " SE");
+    }
+
+    private void handleTN3270EFunctions(byte[] data) {
+        // Parse: TN3270E FUNCTIONS REQUEST [func...] or TN3270E FUNCTIONS IS [func...]
+        int pos = 1;
+        boolean isRequest = false;
+
+        while (pos < data.length) {
+            int b = data[pos] & 0xFF;
+            if (b == OP_FUNCTIONS) {
+                pos++;
+            } else if (b == OP_REQUEST) {
+                isRequest = true;
+                pos++;
+                break;
+            } else if (b == OP_IS) {
+                isRequest = false;
+                pos++;
+                break;
+            } else {
+                pos++;
+            }
+        }
+
+        // The remaining bytes are the proposed/agreed functions
+        boolean[] hostFuncs = new boolean[8];
         while (pos < data.length) {
             int func = data[pos] & 0xFF;
             if (func <= FUNC_SNA_SENSE) {
-                eFuncs[func] = true;
-                if (funcNames.length() > 0) funcNames.append(" ");
-                funcNames.append(TN3270EConstants.functionName(func));
+                hostFuncs[func] = true;
             }
             pos++;
         }
 
+        if (isRequest) {
+            // Host sent FUNCTIONS REQUEST -> We reply with FUNCTIONS IS (intersection of functions)
+            for (int i = 0; i < eFuncs.length; i++) {
+                eFuncs[i] = eFuncs[i] && hostFuncs[i];
+            }
+            sendTN3270EFunctionsIs();
+        } else {
+            // Host sent FUNCTIONS IS -> Accept host's agreed function list
+            for (int i = 0; i < eFuncs.length; i++) {
+                eFuncs[i] = hostFuncs[i];
+            }
+        }
+
         tn3270eNegotiated = true;
-        log.info("TN3270E functions IS: " + funcNames);
+        log.info("TN3270E functions negotiated: " + getNegotiatedFunctionNames());
         log.info("TN3270E negotiation complete");
 
-        // Move to CONNECTED_UNBOUND or CONNECTED_SSCP
+        // RFC 2355: If BIND-IMAGE function is not negotiated, the emulation session is considered
+        // to be bound immediately upon completion of the FUNCTIONS negotiation.
+        if (eFuncs[FUNC_BIND_IMAGE]) {
             changeState(ConnectionState.CONNECTED_UNBOUND);
+        } else {
+            changeState(ConnectionState.CONNECTED_TN3270E);
+            tn3270eSubmode = TN3270ESubmode.E_3270;
+        }
 
         // Notify listeners
         for (ConnectionListener l : connectionListeners) {
@@ -597,12 +698,29 @@ public class TelnetFSM {
         }
     }
 
+    private String getNegotiatedFunctionNames() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < eFuncs.length; i++) {
+            if (eFuncs[i]) {
+                if (sb.length() > 0) sb.append(" ");
+                sb.append(TN3270EConstants.functionName(i));
+            }
+        }
+        return sb.length() > 0 ? sb.toString() : "<none>";
+    }
+
     // ========== End of Record processing ==========
 
     private void processEndOfRecord() {
         byte[] data = ibuf.toByteArray();
+        ibuf.reset();
         if (data.length == 0) return;
 
+        if (connectionState == ConnectionState.TELNET_PENDING && !tn3270eNegotiated) {
+            log.info("Received EOR during TELNET_PENDING - transitioning to plain TN3270 mode");
+            changeState(ConnectionState.CONNECTED_3270);
+        }
+
         if (tn3270eNegotiated) {
             // TN3270E mode: data starts with 5-byte header
             processTN3270ERecord(data);
@@ -701,11 +819,11 @@ public class TelnetFSM {
                                 bindRa = screenBuffer.getMaxRows();
                                 bindCa = screenBuffer.getMaxCols();
                                 break;
-                            case 0x7e:
+                            case 0x7E:
                                 // Both default and alternate = specified values
                                 bindRa = bindRd; bindCa = bindCd;
                                 break;
-                            case 0x7f:
+                            case 0x7F:
                                 // Default and alternate are both specified separately
                                 bindRa = data[EH_SIZE + BIND_OFF_RA] & 0xFF;
                                 bindCa = data[EH_SIZE + BIND_OFF_CA] & 0xFF;
@@ -767,7 +885,20 @@ public class TelnetFSM {
                 break;
 
             default:
+                // Check if the host sent a raw 3270 data stream (e.g. 0xF5 EraseWrite, 0x7E EW Alternate, 0xF1 Write, etc.)
+                // This happens when the server ignores or drops TN3270E framing and speaks plain 3270 data stream.
+                if (dataType == 0xF5 || dataType == 0x7E || dataType == 0xF1 || dataType == 0x6F ||
+                    dataType == 0x6E || dataType == 0xF2 || dataType == 0xF6 || dataType == 0x05 ||
+                    dataType == 0x0D || dataType == 0x01 || (data.length >= 2 && (data[0] & 0xFF) == 0x11)) {
+                    log.warning("Received plain 3270 command (0x" + Integer.toHexString(dataType) +
+                                ") in TN3270E mode — automatically switching to plain TN3270 mode");
+                    tn3270eNegotiated = false;
+                    changeState(ConnectionState.CONNECTED_3270);
+                    dsProcessor.processRecord(data, 0, data.length, true);
+                    notifyScreenUpdate();
+                } else {
                     log.info("Unhandled TN3270E data type: " + dataType);
+                }
                 break;
         }
     }
@@ -790,7 +921,7 @@ public class TelnetFSM {
         if (connectionState != ConnectionState.TELNET_PENDING) return;
 
         // For TN3270E, we wait for TN3270E negotiation to complete
-        if (myOpts[TELOPT_TN3270E] && hisOpts[TELOPT_TN3270E]) {
+        if (config.isTn3270eEnabled() && myOpts[TELOPT_TN3270E] && hisOpts[TELOPT_TN3270E]) {
             return; // TN3270E in progress
         }
 

lib3270j/src/main/java/org/lib3270j/tls/TlsCertificateVerifier.java

@@ -0,0 +1,22 @@
+package org.lib3270j.tls;
+
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+/**
+ * Callback interface for validating TLS server certificates.
+ * Used when standard certificate path validation fails or when custom verification is needed.
+ */
+@FunctionalInterface
+public interface TlsCertificateVerifier {
+
+    /**
+     * Determine whether to trust an unverified server certificate chain.
+     *
+     * @param chain     The peer certificate chain presented by the server.
+     * @param authType  The key exchange algorithm (e.g., "RSA", "ECDHE_RSA").
+     * @param exception The CertificateException thrown by standard validation (or null if called proactively).
+     * @return true to trust the certificate and proceed with the connection; false to abort.
+     */
+    boolean shouldTrust(X509Certificate[] chain, String authType, CertificateException exception);
+}

lib3270j/src/main/java/org/lib3270j/tls/TlsTrustManager.java

@@ -0,0 +1,114 @@
+package org.lib3270j.tls;
+
+import org.lib3270j.ConnectionConfig;
+
+import javax.net.ssl.*;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Custom X509TrustManager that supports:
+ * 1. Standard certificate verification using the JVM default TrustManager.
+ * 2. Unverified / trust-all mode when tlsVerifyCert is false.
+ * 3. Interactive/custom certificate verifier callbacks (e.g. GUI prompts for self-signed certificates).
+ */
+public class TlsTrustManager implements X509TrustManager {
+
+    private static final Logger log = Logger.getLogger(TlsTrustManager.class.getName());
+
+    private final ConnectionConfig config;
+    private X509TrustManager defaultTrustManager;
+
+    public TlsTrustManager(ConnectionConfig config) {
+        this.config = config;
+        try {
+            TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+            tmf.init((KeyStore) null);
+            for (TrustManager tm : tmf.getTrustManagers()) {
+                if (tm instanceof X509TrustManager) {
+                    this.defaultTrustManager = (X509TrustManager) tm;
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            log.log(Level.WARNING, "Failed to initialize default TrustManagerFactory", e);
+        }
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+        if (defaultTrustManager != null) {
+            defaultTrustManager.checkClientTrusted(chain, authType);
+        }
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+        if (config != null && !config.isTlsVerifyCert()) {
+            log.fine("Certificate verification bypassed (tlsVerifyCert=false)");
+            return;
+        }
+
+        if (chain == null || chain.length == 0) {
+            CertificateException ex = new CertificateException("null or zero-length certificate chain");
+            if (config != null && config.getCertificateVerifier() != null) {
+                if (config.getCertificateVerifier().shouldTrust(chain, authType, ex)) {
+                    log.info("Server certificate accepted via TlsCertificateVerifier callback");
+                    return;
+                }
+            }
+            throw ex;
+        }
+
+        try {
+            if (defaultTrustManager != null) {
+                defaultTrustManager.checkServerTrusted(chain, authType);
+            } else {
+                throw new CertificateException("No default X509TrustManager available");
+            }
+        } catch (Exception ex) {
+            CertificateException certEx = (ex instanceof CertificateException)
+                    ? (CertificateException) ex
+                    : new CertificateException("Certificate validation failed: " + ex.getMessage(), ex);
+
+            log.log(Level.FINE, "Standard certificate validation failed: " + certEx.getMessage(), certEx);
+
+            if (config != null && config.getCertificateVerifier() != null) {
+                boolean accepted = config.getCertificateVerifier().shouldTrust(chain, authType, certEx);
+                if (accepted) {
+                    log.info("Server certificate accepted via TlsCertificateVerifier callback");
+                    return;
+                } else {
+                    log.warning("Server certificate rejected by TlsCertificateVerifier callback");
+                    throw new CertificateException("Certificate rejected by user/verifier: " + certEx.getMessage(), certEx);
+                }
+            }
+            throw certEx;
+        }
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+        if (defaultTrustManager != null) {
+            return defaultTrustManager.getAcceptedIssuers();
+        }
+        return new X509Certificate[0];
+    }
+
+    /**
+     * Create an initialized SSLContext configured for the given ConnectionConfig.
+     */
+    public static SSLContext createSSLContext(ConnectionConfig config) throws Exception {
+        String protocol = (config != null && config.getSslProtocol() != null)
+                ? config.getSslProtocol()
+                : "TLS";
+        SSLContext sslContext = SSLContext.getInstance(protocol);
+        TlsTrustManager trustManager = new TlsTrustManager(config);
+        sslContext.init(null, new TrustManager[] { trustManager }, new SecureRandom());
+        return sslContext;
+    }
+}

lib3270j/src/test/java/org/lib3270j/datastream/QueryReplyBuilderTest.java

@@ -3,6 +3,7 @@ package org.lib3270j.datastream;
 import org.junit.jupiter.api.Test;
 import org.lib3270j.TerminalModel;
 import org.lib3270j.charset.EbcdicTranslator;
+import org.lib3270j.graphics.GraphicsMode;
 import org.lib3270j.screen.ScreenBuffer;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.lib3270j.protocol.DS3270Constants.*;
@@ -14,11 +15,108 @@ public class QueryReplyBuilderTest {
     private final QueryReplyBuilder qrBuilder = new QueryReplyBuilder(screen);
 
     @Test
-    public void testBuildAllQueryReplies() {
+    public void testBuildAllQueryRepliesDefaultBoth() {
+        assertEquals(GraphicsMode.BOTH, qrBuilder.getGraphicsMode());
         byte[] replies = qrBuilder.buildAllQueryReplies(80, 43, 80 * 43);
         assertNotNull(replies);
         assertTrue(replies.length > 0);
         assertEquals((byte) AID_SF, replies[0]);
+
+        // In GraphicsMode.BOTH, Vector Graphics QR 0xB0 must be present
+        boolean hasB0 = false;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GRAPHICS) {
+                hasB0 = true;
+                break;
+            }
+        }
+        assertTrue(hasB0);
+    }
+
+    @Test
+    public void testBuildAllQueryRepliesExplicitNone() {
+        qrBuilder.setGraphicsMode(GraphicsMode.NONE);
+        byte[] replies = qrBuilder.buildAllQueryReplies(80, 43, 80 * 43);
+        assertNotNull(replies);
+        assertTrue(replies.length > 0);
+        assertEquals((byte) AID_SF, replies[0]);
+
+        // In GraphicsMode.NONE, Vector Graphics QR 0xB0 must NOT be present
+        boolean hasB0 = false;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GRAPHICS) {
+                hasB0 = true;
+                break;
+            }
+        }
+        assertFalse(hasB0);
+    }
+
+    @Test
+    public void testBuildAllQueryRepliesWithVectorGraphics() {
+        qrBuilder.setGraphicsMode(GraphicsMode.VECTOR_GRAPHICS);
+        byte[] replies = qrBuilder.buildAllQueryReplies(80, 43, 80 * 43);
+        assertNotNull(replies);
+
+        // Vector Graphics QR 0xB0 and 0xB4 must be present
+        boolean hasB0 = false;
+        boolean hasB4 = false;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GRAPHICS) {
+                hasB0 = true;
+            }
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GCOLOR) {
+                hasB4 = true;
+            }
+        }
+        assertTrue(hasB0);
+        assertTrue(hasB4);
+    }
+
+    @Test
+    public void testBuildAllQueryRepliesWithBoth() {
+        qrBuilder.setGraphicsMode(GraphicsMode.BOTH);
+        byte[] replies = qrBuilder.buildAllQueryReplies(80, 43, 80 * 43);
+        assertNotNull(replies);
+
+        // Vector Graphics (0xB0) must be present and Charsets must have LoadPS (0x0A)
+        boolean hasB0 = false;
+        boolean hasCharsetsWithLoadPs = false;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GRAPHICS) {
+                hasB0 = true;
+            }
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_CHARSETS) {
+                if (i + 6 < replies.length && (replies[i + 6] & 0xFF) == 0x0A) {
+                    hasCharsetsWithLoadPs = true;
+                }
+            }
+        }
+        assertTrue(hasB0);
+        assertTrue(hasCharsetsWithLoadPs);
+    }
+
+    @Test
+    public void testBuildAllQueryRepliesWithProgrammedSymbols() {
+        qrBuilder.setGraphicsMode(GraphicsMode.PROGRAMMED_SYMBOLS);
+        byte[] replies = qrBuilder.buildAllQueryReplies(80, 43, 80 * 43);
+        assertNotNull(replies);
+
+        // Charsets with LoadPS (0x0A) must be present, and QR_GRAPHICS must NOT be present
+        boolean hasB0 = false;
+        boolean hasCharsetsWithLoadPs = false;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_GRAPHICS) {
+                hasB0 = true;
+            }
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_CHARSETS) {
+                if (i + 6 < replies.length && (replies[i + 6] & 0xFF) == 0x0A) {
+                    hasCharsetsWithLoadPs = true;
+                }
+            }
+        }
+        assertFalse(hasB0);
+        assertTrue(hasCharsetsWithLoadPs);
     }
 
     @Test
@@ -52,4 +150,86 @@ public class QueryReplyBuilderTest {
         assertEquals(0x81, replies[3] & 0xFF);
         assertEquals(QR_NULL, replies[4] & 0xFF);
     }
+
+    @Test
+    public void testImplicitPartitionModel4() {
+        byte[] requested = new byte[] { (byte) QR_IMP_PART };
+        byte[] replies = qrBuilder.buildQueryReplies(requested, 80, 43, 80 * 43);
+
+        assertNotNull(replies);
+        assertEquals((byte) AID_SF, replies[0]);
+        int len = ((replies[1] & 0xFF) << 8) | (replies[2] & 0xFF);
+        assertEquals(0x81, replies[3] & 0xFF); // SFID_QREPLY
+        assertEquals(QR_IMP_PART, replies[4] & 0xFF); // 0xA6
+
+        // Payload starts at index 5: 22 bytes total
+        // Default size = 80 x 24
+        int defCols = ((replies[10] & 0xFF) << 8) | (replies[11] & 0xFF);
+        int defRows = ((replies[12] & 0xFF) << 8) | (replies[13] & 0xFF);
+        assertEquals(80, defCols);
+        assertEquals(24, defRows);
+
+        // Alt size = 80 x 43
+        int altCols = ((replies[14] & 0xFF) << 8) | (replies[15] & 0xFF);
+        int altRows = ((replies[16] & 0xFF) << 8) | (replies[17] & 0xFF);
+        assertEquals(80, altCols);
+        assertEquals(43, altRows);
+    }
+
+    @Test
+    public void testProgrammedSymbolsDescriptorsSingleAndTriplePlane() {
+        qrBuilder.setGraphicsMode(GraphicsMode.PROGRAMMED_SYMBOLS);
+        byte[] requested = new byte[] { (byte) QR_CHARSETS };
+        byte[] replies = qrBuilder.buildQueryReplies(requested, 80, 43, 80 * 43);
+
+        assertNotNull(replies);
+        int offset = -1;
+        for (int i = 0; i < replies.length - 3; i++) {
+            if ((replies[i] & 0xFF) == 0x81 && (replies[i + 1] & 0xFF) == QR_CHARSETS) {
+                offset = i + 2;
+                break;
+            }
+        }
+        assertTrue(offset >= 0, "QR_CHARSETS must be present");
+
+        // QR_CHARSETS payload structure:
+        // Flags (2 bytes), SDW (1 byte), SDH (1 byte), Form (1 byte), DevType (2 bytes), Res (1 byte), DL (1 byte)
+        // DL is at offset + 8, and is 7 bytes per descriptor.
+        int dl = replies[offset + 8] & 0xFF;
+        assertEquals(7, dl);
+
+        int descOffset = offset + 9;
+
+        // Descriptor 1: SET 0 (Base) -> flags 0x10
+        assertEquals(0x00, replies[descOffset] & 0xFF);
+        assertEquals(0x10, replies[descOffset + 1] & 0xFF);
+
+        // Descriptor 2: SET 1 (APL) -> flags 0x00
+        assertEquals(0x01, replies[descOffset + 7] & 0xFF);
+        assertEquals(0x00, replies[descOffset + 7 + 1] & 0xFF);
+
+        // Descriptor 3: PSA (Single plane) -> flags 0x80 (Loadable, single-plane)
+        assertEquals(0x02, replies[descOffset + 14] & 0xFF);
+        assertEquals(0x80, replies[descOffset + 14 + 1] & 0xFF);
+
+        // Descriptor 4: PSB (Single plane) -> flags 0x80 (Loadable, single-plane)
+        assertEquals(0x03, replies[descOffset + 21] & 0xFF);
+        assertEquals(0x80, replies[descOffset + 21 + 1] & 0xFF);
+
+        // Descriptor 5: PSC (Triple plane) -> flags 0xC0 (Loadable | Triple-plane)
+        assertEquals(0x04, replies[descOffset + 28] & 0xFF);
+        assertEquals(0xC0, replies[descOffset + 28 + 1] & 0xFF);
+
+        // Descriptor 6: PSD (Triple plane) -> flags 0xC0 (Loadable | Triple-plane)
+        assertEquals(0x05, replies[descOffset + 35] & 0xFF);
+        assertEquals(0xC0, replies[descOffset + 35 + 1] & 0xFF);
+
+        // Descriptor 7: PSE (Triple plane) -> flags 0xC0 (Loadable | Triple-plane)
+        assertEquals(0x06, replies[descOffset + 42] & 0xFF);
+        assertEquals(0xC0, replies[descOffset + 42 + 1] & 0xFF);
+
+        // Descriptor 8: PSF (Triple plane) -> flags 0xC0 (Loadable | Triple-plane)
+        assertEquals(0x07, replies[descOffset + 49] & 0xFF);
+        assertEquals(0xC0, replies[descOffset + 49 + 1] & 0xFF);
+    }
 }

lib3270j/src/test/java/org/lib3270j/graphics/GocaDecoderTest.java

@@ -0,0 +1,237 @@
+package org.lib3270j.graphics;
+
+import org.junit.jupiter.api.Test;
+import java.io.ByteArrayOutputStream;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GocaDecoderTest {
+
+    @Test
+    public void testBasicLineAndColorOrders() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        assertFalse(plane.hasContent());
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // Set Color to Red (GOCA Color 2) - 2 bytes: order, color
+        out.write(GocaConstants.G_GSCOL);
+        out.write(0x02); // Red
+
+        // Line from (1000, 1000) to (2000, 2000) - long order: order, len, x1, y1, x2, y2
+        out.write(GocaConstants.G_GLINE);
+        out.write(0x08); // 8 bytes: (x1, y1, x2, y2)
+        out.write((1000 >> 8) & 0xFF); out.write(1000 & 0xFF);
+        out.write((1000 >> 8) & 0xFF); out.write(1000 & 0xFF);
+        out.write((2000 >> 8) & 0xFF); out.write(2000 & 0xFF);
+        out.write((2000 >> 8) & 0xFF); out.write(2000 & 0xFF);
+
+        byte[] stream = out.toByteArray();
+        decoder.decodeStream(stream, 0, stream.length);
+
+        assertTrue(plane.hasContent());
+    }
+
+    @Test
+    public void testAreaAndPatternFill() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // Set Pattern to Solid - 2 bytes: order, pattern
+        out.write(GocaConstants.G_GSPT);
+        out.write(GocaConstants.PT_SOLID);
+
+        // Begin Area - 2 bytes: order, flags
+        out.write(GocaConstants.G_GBAR);
+        out.write(0x00);
+
+        // Polyline forming a triangle: (500, 500) -> (1500, 500) -> (1000, 1500) -> (500, 500)
+        out.write(GocaConstants.G_GLINE);
+        out.write(0x10); // 4 points * 4 bytes = 16 bytes
+        out.write((500 >> 8) & 0xFF);  out.write(500 & 0xFF);
+        out.write((500 >> 8) & 0xFF);  out.write(500 & 0xFF);
+
+        out.write((1500 >> 8) & 0xFF); out.write(1500 & 0xFF);
+        out.write((500 >> 8) & 0xFF);  out.write(500 & 0xFF);
+
+        out.write((1000 >> 8) & 0xFF); out.write(1000 & 0xFF);
+        out.write((1500 >> 8) & 0xFF); out.write(1500 & 0xFF);
+
+        out.write((500 >> 8) & 0xFF);  out.write(500 & 0xFF);
+        out.write((500 >> 8) & 0xFF);  out.write(500 & 0xFF);
+
+        // End Area - 1 byte
+        out.write(GocaConstants.G_GEAR);
+
+        byte[] stream = out.toByteArray();
+        decoder.decodeStream(stream, 0, stream.length);
+
+        assertTrue(plane.hasContent());
+    }
+
+    @Test
+    public void testMarkerAndVectorText() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // Set Marker Type to Circle - 2 bytes: order, type
+        out.write(GocaConstants.G_GSMT);
+        out.write(GocaConstants.MK_CIRCLE);
+
+        // Draw Marker at (2000, 2000)
+        out.write(GocaConstants.G_GMRK);
+        out.write(0x04);
+        out.write((2000 >> 8) & 0xFF); out.write(2000 & 0xFF);
+        out.write((2000 >> 8) & 0xFF); out.write(2000 & 0xFF);
+
+        // Draw Vector Stroked Character String: "IBM" (EBCDIC: 0xC9, 0xC2, 0xD4)
+        out.write(GocaConstants.G_GCHST);
+        out.write(0x07); // 4 bytes pos + 3 bytes chars
+        out.write((1000 >> 8) & 0xFF); out.write(1000 & 0xFF);
+        out.write((1000 >> 8) & 0xFF); out.write(1000 & 0xFF);
+        out.write(0xC9); out.write(0xC2); out.write(0xD4);
+
+        byte[] stream = out.toByteArray();
+        decoder.decodeStream(stream, 0, stream.length);
+
+        assertTrue(plane.hasContent());
+    }
+
+    @Test
+    public void testProcedureOrdersAndErase() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        // Draw something first
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        out.write(GocaConstants.G_GLINE);
+        out.write(0x08);
+        out.write(0x00); out.write(0x00);
+        out.write(0x00); out.write(0x00);
+        out.write(0x00); out.write(0x64);
+        out.write(0x00); out.write(0x64);
+        byte[] drawStream = out.toByteArray();
+        decoder.decodeStream(drawStream, 0, drawStream.length);
+        assertTrue(plane.hasContent());
+
+        // Process procedure order 0x0A (Erase presentation space)
+        byte[] procOrders = new byte[] { (byte) GocaConstants.P_ERASE };
+        decoder.processProcedureOrders(procOrders, 0, procOrders.length);
+        assertFalse(plane.hasContent());
+    }
+
+    @Test
+    public void testSegmentAndRelativeLineOrders() {
+        GraphicsPlane plane = new GraphicsPlane(720, 688);
+        plane.setScreenDimensions(80, 43);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // 0x70: Begin Segment (14 bytes total)
+        out.write(GocaConstants.G_BEGSEGM);
+        out.write(0x0C);
+        out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x01); // Seg ID 1
+        out.write(0x74); out.write(0x70);
+        out.write(0x00); out.write(0x1E); out.write(0x00); out.write(0x00); out.write(0x00); out.write(0x00);
+
+        // 0x3E: End Prologue
+        out.write(GocaConstants.G_ENDPROLOGUE);
+        out.write(0x00);
+
+        // 0x0A: Color (7 = White)
+        out.write(GocaConstants.G_GSCOL);
+        out.write(0x07);
+
+        // 0xE1: Relative Line (Absolute Start (300, 200), deltas: (+10, -5), (-10, +5))
+        out.write(GocaConstants.G_GRLINE);
+        out.write(0x08); // 4 bytes start coord + 4 bytes (2 deltas) = 8 bytes
+        out.write(0x01); out.write(0x2C); // Start X = 300
+        out.write(0x00); out.write(0xC8); // Start Y = 200
+        out.write(0x0A); out.write(0xFB); // dx = +10, dy = -5
+        out.write(0xF6); out.write(0x05); // dx = -10, dy = +5
+
+        // 0x71: End Segment
+        out.write(GocaConstants.G_ENDSEGM);
+        out.write(0x00);
+
+        byte[] stream = out.toByteArray();
+        decoder.decodeStream(stream, 0, stream.length);
+        assertTrue(plane.hasContent());
+    }
+
+    @Test
+    public void testPartialOrderBufferingAcrossStreams() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        // First packet sends G_GLINE order code and half of its coordinates
+        ByteArrayOutputStream chunk1 = new ByteArrayOutputStream();
+        chunk1.write(GocaConstants.G_GLINE);
+        chunk1.write(0x08); // 8 bytes: 2 points
+        chunk1.write(0x00); chunk1.write(0x64); // x1 = 100
+        chunk1.write(0x00); chunk1.write(0x64); // y1 = 100
+
+        byte[] b1 = chunk1.toByteArray();
+        decoder.decodeStream(b1, 0, b1.length);
+        // Order is not complete yet, so no line drawn yet
+        assertFalse(plane.hasContent());
+
+        // Second packet sends the rest of the order: x2 = 200, y2 = 200
+        ByteArrayOutputStream chunk2 = new ByteArrayOutputStream();
+        chunk2.write(0x00); chunk2.write(0xC8); // x2 = 200
+        chunk2.write(0x00); chunk2.write(0xC8); // y2 = 200
+
+        byte[] b2 = chunk2.toByteArray();
+        decoder.decodeStream(b2, 0, b2.length);
+        // Now the combined order executes!
+        assertTrue(plane.hasContent());
+    }
+
+    @Test
+    public void testSetCurrentPositionAndRelativeLine() {
+        GraphicsPlane plane = new GraphicsPlane(400, 300);
+        GocaDecoder decoder = new GocaDecoder(plane);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // 0x21: Set Current Position to (50, 50)
+        out.write(GocaConstants.G_GSCP);
+        out.write(0x04); // len = 4
+        out.write(0x00); out.write(0x32); // x = 50
+        out.write(0x00); out.write(0x32); // y = 50
+
+        // 0xA1: Relative Line from Current Position: (+10, +20), (-5, -10)
+        out.write(GocaConstants.G_GCRLIN);
+        out.write(0x04); // len = 4 (2 steps)
+        out.write(0x0A); out.write(0x14); // dx = +10, dy = +20
+        out.write(0xFB); out.write(0xF6); // dx = -5, dy = -10
+
+        byte[] stream = out.toByteArray();
+        decoder.decodeStream(stream, 0, stream.length);
+
+        assertTrue(plane.hasContent());
+        assertEquals(55, decoder.getCurX());
+        assertEquals(60, decoder.getCurY());
+    }
+
+    @Test
+    public void test3179GCoordinateMapping() {
+        GraphicsPlane plane = new GraphicsPlane(720, 688);
+        plane.setScreenDimensions(80, 43);
+
+        // Screen center (0, 0) should map to canvas center (360, 343)
+        assertEquals(360, plane.mapX(0));
+        assertEquals(343, plane.mapY(0));
+
+        // Left edge (-360) should map to 0
+        assertEquals(0, plane.mapX(-360));
+        // Right edge (+359) should map to 719
+        assertEquals(719, plane.mapX(359));
+
+        // Top edge (+343) should map to 0
+        assertEquals(0, plane.mapY(343));
+        // Bottom edge (-344) should map to 687
+        assertEquals(687, plane.mapY(-344));
+    }
+}

lib3270j/src/test/java/org/lib3270j/graphics/GraphicsModeTest.java

@@ -0,0 +1,57 @@
+package org.lib3270j.graphics;
+
+import org.junit.jupiter.api.Test;
+import org.lib3270j.ConnectionConfig;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GraphicsModeTest {
+
+    @Test
+    public void testDefaultsAndParsing() {
+        assertEquals(GraphicsMode.NONE, GraphicsMode.fromString(null));
+        assertEquals(GraphicsMode.NONE, GraphicsMode.fromString(""));
+        assertEquals(GraphicsMode.NONE, GraphicsMode.fromString("NONE"));
+        assertEquals(GraphicsMode.NONE, GraphicsMode.fromString("off"));
+        assertEquals(GraphicsMode.NONE, GraphicsMode.fromString("false"));
+
+        assertEquals(GraphicsMode.PROGRAMMED_SYMBOLS, GraphicsMode.fromString("ps"));
+        assertEquals(GraphicsMode.PROGRAMMED_SYMBOLS, GraphicsMode.fromString("programmed_symbols"));
+        assertEquals(GraphicsMode.PROGRAMMED_SYMBOLS, GraphicsMode.fromString("apl"));
+
+        assertEquals(GraphicsMode.VECTOR_GRAPHICS, GraphicsMode.fromString("vector"));
+        assertEquals(GraphicsMode.VECTOR_GRAPHICS, GraphicsMode.fromString("goca"));
+        assertEquals(GraphicsMode.VECTOR_GRAPHICS, GraphicsMode.fromString("vector_graphics"));
+
+        assertEquals(GraphicsMode.BOTH, GraphicsMode.fromString("both"));
+        assertEquals(GraphicsMode.BOTH, GraphicsMode.fromString("all"));
+        assertEquals(GraphicsMode.BOTH, GraphicsMode.fromString("true"));
+        assertEquals(GraphicsMode.BOTH, GraphicsMode.fromString("on"));
+    }
+
+    @Test
+    public void testFlags() {
+        assertFalse(GraphicsMode.NONE.isProgrammedSymbolsEnabled());
+        assertFalse(GraphicsMode.NONE.isVectorGraphicsEnabled());
+
+        assertTrue(GraphicsMode.PROGRAMMED_SYMBOLS.isProgrammedSymbolsEnabled());
+        assertFalse(GraphicsMode.PROGRAMMED_SYMBOLS.isVectorGraphicsEnabled());
+
+        assertFalse(GraphicsMode.VECTOR_GRAPHICS.isProgrammedSymbolsEnabled());
+        assertTrue(GraphicsMode.VECTOR_GRAPHICS.isVectorGraphicsEnabled());
+
+        assertTrue(GraphicsMode.BOTH.isProgrammedSymbolsEnabled());
+        assertTrue(GraphicsMode.BOTH.isVectorGraphicsEnabled());
+    }
+
+    @Test
+    public void testConnectionConfigDefault() {
+        ConnectionConfig config = new ConnectionConfig();
+        assertEquals(GraphicsMode.BOTH, config.getGraphicsMode());
+
+        config.setGraphicsMode(GraphicsMode.NONE);
+        assertEquals(GraphicsMode.NONE, config.getGraphicsMode());
+
+        config.setGraphicsMode(null);
+        assertEquals(GraphicsMode.NONE, config.getGraphicsMode());
+    }
+}

lib3270j/src/test/java/org/lib3270j/graphics/ProgramSymbolManagerTest.java

@@ -0,0 +1,167 @@
+package org.lib3270j.graphics;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ProgramSymbolManagerTest {
+
+    @Test
+    public void testSetAllocationAndLookup() {
+        ProgramSymbolManager manager = new ProgramSymbolManager();
+        // Loadable set can be queried after loadps or clearAll
+        assertNull(manager.getSymbolSet(0x40));
+        assertNull(manager.getSymbol(0x40, 0x41));
+
+        manager.clearAll();
+        assertNull(manager.getSymbolSet(0x40));
+    }
+
+    @Test
+    public void testSinglePlaneLoadPsFormat1() {
+        ProgramSymbolManager manager = new ProgramSymbolManager();
+
+        // Build Format 1 Load PS payload for LCID 0x40, code point 0x41 ('A')
+        // Format 1 header:
+        // byte 0: flags (0x01: format 1, single plane)
+        // byte 1: LCID (0x40)
+        // byte 2: Start code point (0x41)
+        // byte 3: RWS (0x02: loadable slot 2)
+        // followed by 18 bytes per symbol for 9x16 cell:
+        // Byte 0-1: Col 0 for rows 0..15 (0x80 = bit for row 0 col 0)
+        // Bytes 2-17: Cols 1..8 for rows 0..15 (0xFF = bits for row 0 cols 1..8)
+        byte[] payload = new byte[4 + 18];
+        payload[0] = 0x01; // Format 1
+        payload[1] = 0x40; // LCID 0x40
+        payload[2] = 0x41; // Code point 0x41
+        payload[3] = 0x02; // RWS 2
+
+        payload[4] = (byte) 0x80; // Row 0 Col 0 bit
+        payload[5] = (byte) 0x00; // Rows 8..15 Col 0
+        for (int r = 0; r < 16; r++) {
+            payload[6 + r] = (byte) 0xFF; // Cols 1..8 on all rows
+        }
+
+        manager.loadps(payload);
+
+        ProgramSymbolSet set = manager.getSymbolSet(0x40);
+        assertNotNull(set);
+        assertEquals(0x40, set.getLcid());
+        assertFalse(set.isTriplePlane());
+
+        ProgramSymbolSet.SymbolSlot slot = manager.getSymbol(0x40, 0x41);
+        assertNotNull(slot);
+        assertEquals(9, slot.getWidth());
+        assertEquals(12, slot.getHeight());
+        assertFalse(slot.isTriplePlane());
+
+        // Verify pixel data (Row 0 Col 0 is 1)
+        byte[] pixels = slot.getPixelData();
+        assertNotNull(pixels);
+        assertEquals(1, pixels[0]); // Row 0 Col 0 is 1
+
+        // Test rendering into 32-bit ARGB pixels
+        int fg = 0xFF00FF00; // Green
+        int bg = 0xFF000000; // Black
+        int[] rgb = slot.getRgbPixels(fg, bg);
+        assertNotNull(rgb);
+        assertEquals(9 * 12, rgb.length);
+        assertEquals(fg, rgb[0]); // Row 0 Col 0 pixel should be foreground Green
+    }
+
+    @Test
+    public void testExplicitCellDimensions() {
+        ProgramSymbolManager manager = new ProgramSymbolManager();
+        manager.setDefaultCellDimensions(9, 16);
+
+        byte[] payload = new byte[4 + 18];
+        payload[0] = 0x01; // Format 1
+        payload[1] = 0x40; // LCID 0x40
+        payload[2] = 0x41; // Code point 0x41
+        payload[3] = 0x02; // RWS 2
+        payload[4] = (byte) 0x80;
+        payload[5] = (byte) 0x00;
+        for (int r = 0; r < 16; r++) {
+            payload[6 + r] = (byte) 0xFF;
+        }
+
+        manager.loadps(payload);
+        ProgramSymbolSet.SymbolSlot slot = manager.getSymbol(0x40, 0x41);
+        assertNotNull(slot);
+        assertEquals(9, slot.getWidth());
+        assertEquals(16, slot.getHeight());
+    }
+
+    @Test
+    public void testTriplePlaneMultiColorComposite() {
+        ProgramSymbolManager manager = new ProgramSymbolManager();
+
+        // Build Format 1 Load PS payload for LCID 0x42, triple plane
+        // flags = 0x01 (Format 1)
+        // RWS = 4 (Triple Plane)
+        byte[] payload = new byte[4 + 18];
+        payload[0] = 0x01; // Format 1
+        payload[1] = 0x42; // LCID 0x42
+        payload[2] = 0x45; // Code point 0x45
+        payload[3] = 0x04; // RWS 4 (Triple Plane)
+
+        // Set pixel at row 0 col 0
+        payload[4] = (byte) 0x80; // Row 0 Col 0
+        payload[5] = (byte) 0x00;
+        for (int r = 0; r < 16; r++) {
+            payload[6 + r] = (byte) 0x00;
+        }
+
+        manager.loadps(payload);
+
+        ProgramSymbolSet set = manager.getSymbolSet(0x42);
+        assertNotNull(set);
+        assertTrue(set.isTriplePlane());
+
+        ProgramSymbolSet.SymbolSlot slot = manager.getSymbol(0x42, 0x45);
+        assertNotNull(slot);
+        assertTrue(slot.isTriplePlane());
+
+        // When loaded with colorPlane=0 (default), all 3 planes are set (val 7 = white composite)
+        byte[] pixels = slot.getPixelData();
+        assertEquals(7, pixels[0] & 0xFF);
+
+        // Render ARGB pixels
+        int[] rgb = slot.getRgbPixels(0xFFFFFFFF, 0xFF000000);
+        assertNotNull(rgb);
+
+        // Pixel (0,0) should be white composite (0xFFFFFFFF)
+        int pixelArgb = rgb[0];
+        int r = (pixelArgb >> 16) & 0xFF;
+        int g = (pixelArgb >> 8) & 0xFF;
+        int b = pixelArgb & 0xFF;
+        assertEquals(255, r);
+        assertEquals(255, g);
+        assertEquals(255, b);
+    }
+
+    @Test
+    public void testFormat3Bitstream() {
+        ProgramSymbolManager manager = new ProgramSymbolManager();
+
+        // Format 3 payload
+        // byte 0: 0x03 (Format 3)
+        // byte 1: LCID (0x44)
+        // byte 2: code point (0x43)
+        // byte 3: RWS (2)
+        // followed by (9 * 16 + 7) / 8 = 18 bytes
+        byte[] payload = new byte[4 + 18];
+        payload[0] = 0x03; // Format 3
+        payload[1] = 0x44; // LCID 0x44
+        payload[2] = 0x43; // Code point 0x43
+        payload[3] = 0x02; // RWS 2
+        payload[4] = (byte) 0x80; // First pixel is set
+
+        manager.loadps(payload);
+
+        ProgramSymbolSet set = manager.getSymbolSet(0x44);
+        assertNotNull(set);
+        ProgramSymbolSet.SymbolSlot slot = manager.getSymbol(0x44, 0x43);
+        assertNotNull(slot);
+        assertEquals(1, slot.getPixelData()[0]);
+    }
+}

lib3270j/src/test/java/org/lib3270j/input/InputProcessorTest.java

@@ -44,10 +44,91 @@ public class InputProcessorTest {
 
         assertEquals('A', screen.getCell(1).ucs4);
         assertEquals('B', screen.getCell(2).ucs4);
+        assertEquals('A', screen.getDisplayCell(1).ucs4);
+        assertEquals('B', screen.getDisplayCell(2).ucs4);
 
         input.eraseInput();
 
         assertEquals(0, screen.getCell(1).ec);
         assertEquals(0, screen.getCell(2).ec);
+        assertEquals(0, screen.getDisplayCell(1).ec);
+        assertEquals(0, screen.getDisplayCell(2).ec);
+    }
+
+    @Test
+    public void testTypeCharacterUpdatesDisplaySnapshot() {
+        InputProcessor input = new InputProcessor(screen, translator, null);
+        screen.erase(false);
+        screen.setCellFA(0, (byte) FA_PRINTABLE); // Unprotected field starting at 1
+        screen.setCursorAddress(1);
+        screen.updateDisplaySnapshot(); // Initial snapshot
+
+        // Type "logon"
+        input.typeCharacter('l');
+        input.typeCharacter('o');
+        input.typeCharacter('g');
+        input.typeCharacter('o');
+        input.typeCharacter('n');
+
+        // Verify underlying buffer
+        assertEquals('l', screen.getCell(1).ucs4);
+        assertEquals('o', screen.getCell(2).ucs4);
+        assertEquals('g', screen.getCell(3).ucs4);
+        assertEquals('o', screen.getCell(4).ucs4);
+        assertEquals('n', screen.getCell(5).ucs4);
+
+        // Verify display snapshot (what TerminalPanel renders)
+        assertEquals('l', screen.getDisplayCell(1).ucs4);
+        assertEquals('o', screen.getDisplayCell(2).ucs4);
+        assertEquals('g', screen.getDisplayCell(3).ucs4);
+        assertEquals('o', screen.getDisplayCell(4).ucs4);
+        assertEquals('n', screen.getDisplayCell(5).ucs4);
+        assertEquals(6, screen.getDisplayCursorAddress());
+        assertEquals(6, screen.getCursorAddress());
+    }
+
+    @Test
+    public void testCursorMovementUpdatesDisplayCursorAddress() {
+        InputProcessor input = new InputProcessor(screen, translator, null);
+        screen.erase(false);
+        screen.setCursorAddress(10);
+        assertEquals(10, screen.getDisplayCursorAddress());
+
+        input.cursorRight();
+        assertEquals(11, screen.getDisplayCursorAddress());
+
+        input.cursorLeft();
+        assertEquals(10, screen.getDisplayCursorAddress());
+
+        screen.setCursorAddress(45);
+        assertEquals(45, screen.getDisplayCursorAddress());
+    }
+
+    @Test
+    public void testDeleteAndEraseEofUpdateDisplaySnapshot() {
+        InputProcessor input = new InputProcessor(screen, translator, null);
+        screen.erase(false);
+        screen.setCellFA(0, (byte) FA_PRINTABLE);
+        screen.setCellFA(10, (byte) (FA_PRINTABLE | FA_PROTECT));
+        screen.setCursorAddress(1);
+
+        input.typeCharacter('A');
+        input.typeCharacter('B');
+        input.typeCharacter('C');
+        assertEquals('A', screen.getDisplayCell(1).ucs4);
+        assertEquals('B', screen.getDisplayCell(2).ucs4);
+        assertEquals('C', screen.getDisplayCell(3).ucs4);
+
+        // Backspace over 'C'
+        input.backspace();
+        assertEquals(3, screen.getCursorAddress());
+        assertEquals(3, screen.getDisplayCursorAddress());
+        assertEquals(0, screen.getDisplayCell(3).ucs4);
+
+        // Erase EOF from position 2 ('B')
+        screen.setCursorAddress(2);
+        input.eraseEof();
+        assertEquals(0, screen.getDisplayCell(2).ucs4);
+        assertEquals('A', screen.getDisplayCell(1).ucs4);
     }
 }

lib3270j/src/test/java/org/lib3270j/telnet/TelnetFSMTest.java

@@ -0,0 +1,222 @@
+package org.lib3270j.telnet;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lib3270j.ConnectionConfig;
+import org.lib3270j.ConnectionState;
+import org.lib3270j.TerminalModel;
+import org.lib3270j.charset.EbcdicTranslator;
+import org.lib3270j.datastream.DataStreamProcessor;
+import org.lib3270j.protocol.TelnetConstants;
+import org.lib3270j.screen.ScreenBuffer;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TelnetFSMTest {
+
+    private ConnectionConfig config;
+    private ScreenBuffer screenBuffer;
+    private DataStreamProcessor dsProcessor;
+    private TelnetFSM fsm;
+    private MockConnection connection;
+
+    private static class MockConnection extends TelnetConnection {
+        final List<byte[]> sentData = new ArrayList<>();
+
+        MockConnection(ConnectionConfig config, TelnetFSM fsm) {
+            super(config, fsm);
+        }
+
+        @Override
+        public synchronized void sendRaw(byte[] data) {
+            sentData.add(data.clone());
+        }
+
+        @Override
+        public synchronized void sendRaw(byte[] data, int offset, int length) {
+            byte[] b = new byte[length];
+            System.arraycopy(data, offset, b, 0, length);
+            sentData.add(b);
+        }
+    }
+
+    @BeforeEach
+    public void setup() {
+        config = new ConnectionConfig("localhost", 23, TerminalModel.IBM_3279_4);
+        screenBuffer = new ScreenBuffer(TerminalModel.IBM_3279_4, new EbcdicTranslator());
+        dsProcessor = new DataStreamProcessor(screenBuffer, new EbcdicTranslator());
+        fsm = new TelnetFSM(config, screenBuffer, dsProcessor);
+        connection = new MockConnection(config, fsm);
+        fsm.setConnection(connection);
+    }
+
+    private void feedBytes(int... bytes) {
+        for (int b : bytes) {
+            fsm.feedByte(b & 0xFF);
+        }
+    }
+
+    @Test
+    public void testHostPrefixParsingPlainTn3270() {
+        ConnectionConfig c1 = ConnectionConfig.parseHostString("P:mainframe.example.com", 23, TerminalModel.IBM_3279_4);
+        assertFalse(c1.isTn3270eEnabled(), "P: prefix should disable TN3270E");
+        assertFalse(c1.isUseTls());
+        assertEquals("mainframe.example.com", c1.getHost());
+
+        ConnectionConfig c2 = ConnectionConfig.parseHostString("plain:zos.net:2323", 23, TerminalModel.IBM_3279_4);
+        assertFalse(c2.isTn3270eEnabled());
+        assertEquals("zos.net", c2.getHost());
+        assertEquals(2323, c2.getPort());
+
+        ConnectionConfig c3 = ConnectionConfig.parseHostString("L:P:secure.mainframe.com:992", 0, TerminalModel.IBM_3279_4);
+        assertTrue(c3.isUseTls(), "L: should enable TLS");
+        assertFalse(c3.isTn3270eEnabled(), "P: should disable TN3270E");
+        assertEquals("secure.mainframe.com", c3.getHost());
+        assertEquals(992, c3.getPort());
+
+        ConnectionConfig c4 = ConnectionConfig.parseHostString("non-e:vm.ibm.com", 23, TerminalModel.IBM_3279_4);
+        assertFalse(c4.isTn3270eEnabled());
+        assertEquals("vm.ibm.com", c4.getHost());
+    }
+
+    @Test
+    public void testPlainTn3270NegotiationRejectsTn3270E() {
+        config.setTn3270eEnabled(false);
+        fsm.onConnected();
+        assertEquals(ConnectionState.TELNET_PENDING, fsm.getConnectionState());
+
+        // Host offers DO TN3270E -> client must reply WONT TN3270E
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_TN3270E);
+        assertFalse(fsm.getMyOpts()[TelnetConstants.TELOPT_TN3270E]);
+
+        // Host offers WILL TN3270E -> client must reply DONT TN3270E
+        feedBytes(TelnetConstants.IAC, TelnetConstants.WILL, TelnetConstants.TELOPT_TN3270E);
+        assertFalse(fsm.getHisOpts()[TelnetConstants.TELOPT_TN3270E]);
+
+        // Host negotiates standard 3270 options: DO BINARY, WILL BINARY, DO EOR, WILL EOR, DO TTYPE
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_BINARY);
+        feedBytes(TelnetConstants.IAC, TelnetConstants.WILL, TelnetConstants.TELOPT_BINARY);
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_EOR);
+        feedBytes(TelnetConstants.IAC, TelnetConstants.WILL, TelnetConstants.TELOPT_EOR);
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_TTYPE);
+
+        // Client should have transitioned to CONNECTED_3270
+        assertEquals(ConnectionState.CONNECTED_3270, fsm.getConnectionState());
+
+        // Host asks for TTYPE
+        feedBytes(TelnetConstants.IAC, TelnetConstants.SB, TelnetConstants.TELOPT_TTYPE,
+                  TelnetConstants.TELQUAL_SEND, TelnetConstants.IAC, TelnetConstants.SE);
+
+        // Verify sent packets contain WONT TN3270E, DONT TN3270E, and TTYPE IS
+        boolean foundWontTn3270e = false;
+        boolean foundTtypeIs = false;
+        for (byte[] pkt : connection.sentData) {
+            if (pkt.length == 3 && (pkt[0] & 0xFF) == TelnetConstants.IAC &&
+                (pkt[1] & 0xFF) == TelnetConstants.WONT && (pkt[2] & 0xFF) == TelnetConstants.TELOPT_TN3270E) {
+                foundWontTn3270e = true;
+            }
+            if (pkt.length >= 4 && (pkt[0] & 0xFF) == TelnetConstants.IAC &&
+                (pkt[1] & 0xFF) == TelnetConstants.SB && (pkt[2] & 0xFF) == TelnetConstants.TELOPT_TTYPE) {
+                foundTtypeIs = true;
+            }
+        }
+        assertTrue(foundWontTn3270e, "Expected WONT TN3270E response");
+        assertTrue(foundTtypeIs, "Expected TTYPE IS response");
+    }
+
+    @Test
+    public void testTn3270eFunctionsNegotiationWithoutBindImageTransitionsToConnected() {
+        config.setTn3270eEnabled(true);
+        fsm.onConnected();
+        assertEquals(ConnectionState.TELNET_PENDING, fsm.getConnectionState());
+
+        // Host offers DO TN3270E -> client accepts with WILL TN3270E
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_TN3270E);
+        assertTrue(fsm.getMyOpts()[TelnetConstants.TELOPT_TN3270E]);
+
+        // Host responds with DEVICE-TYPE IS IBM-3279-4-E CONNECT LU01
+        byte[] devTypeIs = new byte[]{
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SB, (byte) TelnetConstants.TELOPT_TN3270E,
+            0x02, 0x04, // OP_DEVICE_TYPE, OP_IS
+            'I', 'B', 'M', '-', '3', '2', '7', '9', '-', '4', '-', 'E',
+            0x01, // OP_CONNECT
+            'L', 'U', '0', '1',
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SE
+        };
+        for (byte b : devTypeIs) fsm.feedByte(b & 0xFF);
+
+        // Host responds with FUNCTIONS REQUEST <empty> (e.g. pytn3270 / RFC 2355 server)
+        byte[] funcsReq = new byte[]{
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SB, (byte) TelnetConstants.TELOPT_TN3270E,
+            0x03, 0x07, // OP_FUNCTIONS, OP_REQUEST
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SE
+        };
+        for (byte b : funcsReq) fsm.feedByte(b & 0xFF);
+
+        // Per RFC 2355: Client must reply with FUNCTIONS IS, and without BIND-IMAGE, session is bound immediately
+        assertEquals(ConnectionState.CONNECTED_TN3270E, fsm.getConnectionState(),
+            "Expected CONNECTED_TN3270E when BIND-IMAGE is not negotiated");
+
+        // Verify that client sent SB TN3270E FUNCTIONS IS SE
+        boolean foundFunctionsIs = false;
+        for (byte[] pkt : connection.sentData) {
+            if (pkt.length >= 5 && (pkt[0] & 0xFF) == TelnetConstants.IAC &&
+                (pkt[1] & 0xFF) == TelnetConstants.SB && (pkt[2] & 0xFF) == TelnetConstants.TELOPT_TN3270E &&
+                (pkt[3] & 0xFF) == 0x03 && (pkt[4] & 0xFF) == 0x04) {
+                foundFunctionsIs = true;
+            }
+        }
+        assertTrue(foundFunctionsIs, "Expected FUNCTIONS IS reply from client upon receiving FUNCTIONS REQUEST");
+    }
+
+    @Test
+    public void testPlainDataStreamFallbackInTn3270eMode() {
+        config.setTn3270eEnabled(true);
+        fsm.onConnected();
+
+        // Negotiate TN3270E with empty functions
+        feedBytes(TelnetConstants.IAC, TelnetConstants.DO, TelnetConstants.TELOPT_TN3270E);
+        byte[] devTypeIs = new byte[]{
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SB, (byte) TelnetConstants.TELOPT_TN3270E,
+            0x02, 0x04, 'I', 'B', 'M', '-', '3', '2', '7', '9', '-', '4', '-', 'E',
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SE
+        };
+        for (byte b : devTypeIs) fsm.feedByte(b & 0xFF);
+
+        byte[] funcsReq = new byte[]{
+            (byte) TelnetConstants.IAC, (byte) TelnetConstants.SB, (byte) TelnetConstants.TELOPT_TN3270E,
+            0x03, 0x07, (byte) TelnetConstants.IAC, (byte) TelnetConstants.SE
+        };
+        for (byte b : funcsReq) fsm.feedByte(b & 0xFF);
+        assertEquals(ConnectionState.CONNECTED_TN3270E, fsm.getConnectionState());
+
+        // Now host sends raw 3270 data stream without 5-byte TN3270E header (e.g. EraseWrite 0xF5)
+        // 0xF5 = EraseWrite, 0xC3 = WCC, 0x11 = SBA, 0x40 0x40 = Pos 0, "HELLO"
+        EbcdicTranslator trans = new EbcdicTranslator();
+        String msg = "HELLO";
+        byte[] rawStream = new byte[3 + 2 + msg.length() + 2];
+        rawStream[0] = (byte) 0xF5; // EraseWrite
+        rawStream[1] = (byte) 0xC3; // WCC
+        rawStream[2] = 0x11;        // SBA
+        rawStream[3] = 0x40; rawStream[4] = 0x40; // addr 0
+        for (int i = 0; i < msg.length(); i++) {
+            rawStream[5 + i] = (byte) trans.unicodeToEbcdic(msg.charAt(i));
+        }
+        rawStream[rawStream.length - 2] = (byte) TelnetConstants.IAC;
+        rawStream[rawStream.length - 1] = (byte) TelnetConstants.EOR;
+
+        for (byte b : rawStream) fsm.feedByte(b & 0xFF);
+
+        // State must have automatically switched to CONNECTED_3270 and screen updated
+        assertEquals(ConnectionState.CONNECTED_3270, fsm.getConnectionState());
+        assertEquals('H', trans.ebcdicToUnicode(screenBuffer.getCellEC(0)));
+        assertEquals('E', trans.ebcdicToUnicode(screenBuffer.getCellEC(1)));
+        assertEquals('L', trans.ebcdicToUnicode(screenBuffer.getCellEC(2)));
+        assertEquals('L', trans.ebcdicToUnicode(screenBuffer.getCellEC(3)));
+        assertEquals('O', trans.ebcdicToUnicode(screenBuffer.getCellEC(4)));
+    }
+}

lib3270j/src/test/java/org/lib3270j/tls/TlsConfigTest.java

@@ -0,0 +1,108 @@
+package org.lib3270j.tls;
+
+import org.junit.jupiter.api.Test;
+import org.lib3270j.ConnectionConfig;
+import org.lib3270j.TerminalModel;
+
+import javax.net.ssl.SSLContext;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TlsConfigTest {
+
+    @Test
+    public void testConnectionConfigDefaults() {
+        ConnectionConfig config = new ConnectionConfig("localhost", 23);
+        assertFalse(config.isUseTls());
+        assertTrue(config.isTlsVerifyCert());
+        assertEquals("TLS", config.getSslProtocol());
+        assertNull(config.getCertificateVerifier());
+    }
+
+    @Test
+    public void testParseHostStringTlsPrefixes() {
+        // L: prefix
+        ConnectionConfig c1 = ConnectionConfig.parseHostString("L:mainframe.example.com", 0, TerminalModel.IBM_3279_4);
+        assertTrue(c1.isUseTls());
+        assertEquals("mainframe.example.com", c1.getHost());
+        assertEquals(992, c1.getPort());
+
+        // ssl: prefix with explicit port
+        ConnectionConfig c2 = ConnectionConfig.parseHostString("ssl:zos.local:2323", 0, TerminalModel.IBM_3279_2);
+        assertTrue(c2.isUseTls());
+        assertEquals("zos.local", c2.getHost());
+        assertEquals(2323, c2.getPort());
+
+        // y: prefix
+        ConnectionConfig c3 = ConnectionConfig.parseHostString("y:vm370.net:992", 23, TerminalModel.IBM_3279_4);
+        assertTrue(c3.isUseTls());
+        assertEquals("vm370.net", c3.getHost());
+        assertEquals(992, c3.getPort());
+
+        // Plain host
+        ConnectionConfig c4 = ConnectionConfig.parseHostString("plain.host.com", 23, TerminalModel.IBM_3279_4);
+        assertFalse(c4.isUseTls());
+        assertEquals("plain.host.com", c4.getHost());
+        assertEquals(23, c4.getPort());
+
+        // IPv6 host with brackets
+        ConnectionConfig c5 = ConnectionConfig.parseHostString("L:[2001:db8::1]:992", 0, TerminalModel.IBM_3279_4);
+        assertTrue(c5.isUseTls());
+        assertEquals("2001:db8::1", c5.getHost());
+        assertEquals(992, c5.getPort());
+    }
+
+    @Test
+    public void testTlsTrustManagerBypass() {
+        ConnectionConfig config = new ConnectionConfig("untrusted.host", 992);
+        config.setUseTls(true);
+        config.setTlsVerifyCert(false);
+
+        TlsTrustManager trustManager = new TlsTrustManager(config);
+        // With tlsVerifyCert=false, checkServerTrusted must not throw even with null/empty chain
+        assertDoesNotThrow(() -> trustManager.checkServerTrusted(new X509Certificate[0], "RSA"));
+    }
+
+    @Test
+    public void testTlsTrustManagerVerifierCallback() {
+        ConnectionConfig config = new ConnectionConfig("selfsigned.host", 992);
+        config.setUseTls(true);
+        config.setTlsVerifyCert(true);
+
+        AtomicBoolean verifierInvoked = new AtomicBoolean(false);
+        config.setCertificateVerifier((chain, authType, exception) -> {
+            verifierInvoked.set(true);
+            return true; // Accept certificate
+        });
+
+        TlsTrustManager trustManager = new TlsTrustManager(config);
+        // Standard verification will fail on empty cert chain, triggering our callback
+        assertDoesNotThrow(() -> trustManager.checkServerTrusted(new X509Certificate[0], "RSA"));
+        assertTrue(verifierInvoked.get(), "Expected verifier callback to be invoked");
+    }
+
+    @Test
+    public void testTlsTrustManagerVerifierRejection() {
+        ConnectionConfig config = new ConnectionConfig("badcert.host", 992);
+        config.setUseTls(true);
+        config.setTlsVerifyCert(true);
+
+        config.setCertificateVerifier((chain, authType, exception) -> false); // Reject certificate
+
+        TlsTrustManager trustManager = new TlsTrustManager(config);
+        assertThrows(CertificateException.class, () -> trustManager.checkServerTrusted(new X509Certificate[0], "RSA"));
+    }
+
+    @Test
+    public void testCreateSSLContext() throws Exception {
+        ConnectionConfig config = new ConnectionConfig("secure.host", 992);
+        config.setUseTls(true);
+
+        SSLContext context = TlsTrustManager.createSSLContext(config);
+        assertNotNull(context);
+        assertNotNull(context.getSocketFactory());
+    }
+}