/*
 * Copyright (c) 2002-2016, the original author or authors.
 *
 * This software is distributable under the BSD license. See the terms of the
 * BSD license in the documentation provided with this software.
 *
 * http://www.opensource.org/licenses/bsd-license.php
 */
package jdk.internal.org.jline.terminal;

import java.util.EnumMap;
import java.util.EnumSet;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Attributes {

    
Control characters
/** * Control characters */
public enum ControlChar { VEOF, VEOL, VEOL2, VERASE, VWERASE, VKILL, VREPRINT, VINTR, VQUIT, VSUSP, VDSUSP, VSTART, VSTOP, VLNEXT, VDISCARD, VMIN, VTIME, VSTATUS }
Input flags - software input processing
/** * Input flags - software input processing */
public enum InputFlag { IGNBRK, /* ignore BREAK condition */ BRKINT, /* map BREAK to SIGINTR */ IGNPAR, /* ignore (discard) parity errors */ PARMRK, /* mark parity and framing errors */ INPCK, /* enable checking of parity errors */ ISTRIP, /* strip 8th bit off chars */ INLCR, /* map NL into CR */ IGNCR, /* ignore CR */ ICRNL, /* map CR to NL (ala CRMOD) */ IXON, /* enable output flow control */ IXOFF, /* enable input flow control */ IXANY, /* any char will restart after stop */ IMAXBEL, /* ring bell on input queue full */ IUTF8 /* maintain state for UTF-8 VERASE */ } /* * Output flags - software output processing */ public enum OutputFlag { OPOST, /* enable following output processing */ ONLCR, /* map NL to CR-NL (ala CRMOD) */ OXTABS, /* expand tabs to spaces */ ONOEOT, /* discard EOT's (^D) on output) */ OCRNL, /* map CR to NL on output */ ONOCR, /* no CR output at column 0 */ ONLRET, /* NL performs CR function */ OFILL, /* use fill characters for delay */ NLDLY, /* \n delay */ TABDLY, /* horizontal tab delay */ CRDLY, /* \r delay */ FFDLY, /* form feed delay */ BSDLY, /* \b delay */ VTDLY, /* vertical tab delay */ OFDEL /* fill is DEL, else NUL */ } /* * Control flags - hardware control of terminal */ public enum ControlFlag { CIGNORE, /* ignore control flags */ CS5, /* 5 bits (pseudo) */ CS6, /* 6 bits */ CS7, /* 7 bits */ CS8, /* 8 bits */ CSTOPB, /* send 2 stop bits */ CREAD, /* enable receiver */ PARENB, /* parity enable */ PARODD, /* odd parity, else even */ HUPCL, /* hang up on last close */ CLOCAL, /* ignore modem status lines */ CCTS_OFLOW, /* CTS flow control of output */ CRTS_IFLOW, /* RTS flow control of input */ CDTR_IFLOW, /* DTR flow control of input */ CDSR_OFLOW, /* DSR flow control of output */ CCAR_OFLOW /* DCD flow control of output */ } /* * "Local" flags - dumping ground for other state * * Warning: some flags in this structure begin with * the letter "I" and look like they belong in the * input flag. */ public enum LocalFlag { ECHOKE, /* visual erase for line kill */ ECHOE, /* visually erase chars */ ECHOK, /* echo NL after line kill */ ECHO, /* enable echoing */ ECHONL, /* echo NL even if ECHO is off */ ECHOPRT, /* visual erase mode for hardcopy */ ECHOCTL, /* echo control chars as ^(Char) */ ISIG, /* enable signals INTR, QUIT, [D]SUSP */ ICANON, /* canonicalize input lines */ ALTWERASE, /* use alternate WERASE algorithm */ IEXTEN, /* enable DISCARD and LNEXT */ EXTPROC, /* external processing */ TOSTOP, /* stop background jobs from output */ FLUSHO, /* output being flushed (state) */ NOKERNINFO, /* no kernel output from VSTATUS */ PENDIN, /* XXX retype pending input (state) */ NOFLSH /* don't flush after interrupt */ } final EnumSet<InputFlag> iflag = EnumSet.noneOf(InputFlag.class); final EnumSet<OutputFlag> oflag = EnumSet.noneOf(OutputFlag.class); final EnumSet<ControlFlag> cflag = EnumSet.noneOf(ControlFlag.class); final EnumSet<LocalFlag> lflag = EnumSet.noneOf(LocalFlag.class); final EnumMap<ControlChar, Integer> cchars = new EnumMap<>(ControlChar.class); public Attributes() { } public Attributes(Attributes attr) { copy(attr); } // // Input flags // public EnumSet<InputFlag> getInputFlags() { return iflag; } public void setInputFlags(EnumSet<InputFlag> flags) { iflag.clear(); iflag.addAll(flags); } public boolean getInputFlag(InputFlag flag) { return iflag.contains(flag); } public void setInputFlags(EnumSet<InputFlag> flags, boolean value) { if (value) { iflag.addAll(flags); } else { iflag.removeAll(flags); } } public void setInputFlag(InputFlag flag, boolean value) { if (value) { iflag.add(flag); } else { iflag.remove(flag); } } // // Output flags // public EnumSet<OutputFlag> getOutputFlags() { return oflag; } public void setOutputFlags(EnumSet<OutputFlag> flags) { oflag.clear(); oflag.addAll(flags); } public boolean getOutputFlag(OutputFlag flag) { return oflag.contains(flag); } public void setOutputFlags(EnumSet<OutputFlag> flags, boolean value) { if (value) { oflag.addAll(flags); } else { oflag.removeAll(flags); } } public void setOutputFlag(OutputFlag flag, boolean value) { if (value) { oflag.add(flag); } else { oflag.remove(flag); } } // // Control flags // public EnumSet<ControlFlag> getControlFlags() { return cflag; } public void setControlFlags(EnumSet<ControlFlag> flags) { cflag.clear(); cflag.addAll(flags); } public boolean getControlFlag(ControlFlag flag) { return cflag.contains(flag); } public void setControlFlags(EnumSet<ControlFlag> flags, boolean value) { if (value) { cflag.addAll(flags); } else { cflag.removeAll(flags); } } public void setControlFlag(ControlFlag flag, boolean value) { if (value) { cflag.add(flag); } else { cflag.remove(flag); } } // // Local flags // public EnumSet<LocalFlag> getLocalFlags() { return lflag; } public void setLocalFlags(EnumSet<LocalFlag> flags) { lflag.clear(); lflag.addAll(flags); } public boolean getLocalFlag(LocalFlag flag) { return lflag.contains(flag); } public void setLocalFlags(EnumSet<LocalFlag> flags, boolean value) { if (value) { lflag.addAll(flags); } else { lflag.removeAll(flags); } } public void setLocalFlag(LocalFlag flag, boolean value) { if (value) { lflag.add(flag); } else { lflag.remove(flag); } } // // Control chars // public EnumMap<ControlChar, Integer> getControlChars() { return cchars; } public void setControlChars(EnumMap<ControlChar, Integer> chars) { cchars.clear(); cchars.putAll(chars); } public int getControlChar(ControlChar c) { Integer v = cchars.get(c); return v != null ? v : -1; } public void setControlChar(ControlChar c, int value) { cchars.put(c, value); } // // Miscellaneous methods // public void copy(Attributes attributes) { setControlFlags(attributes.getControlFlags()); setInputFlags(attributes.getInputFlags()); setLocalFlags(attributes.getLocalFlags()); setOutputFlags(attributes.getOutputFlags()); setControlChars(attributes.getControlChars()); } @Override public String toString() { return "Attributes[" + "lflags: " + append(lflag) + ", " + "iflags: " + append(iflag) + ", " + "oflags: " + append(oflag) + ", " + "cflags: " + append(cflag) + ", " + "cchars: " + append(EnumSet.allOf(ControlChar.class), this::display) + "]"; } private String display(ControlChar c) { String value; int ch = getControlChar(c); if (c == ControlChar.VMIN || c == ControlChar.VTIME) { value = Integer.toString(ch); } else if (ch < 0) { value = "<undef>"; } else if (ch < 32) { value = "^" + (char) (ch + 'A' - 1); } else if (ch == 127) { value = "^?"; } else if (ch >= 128) { value = String.format("\\u%04x", ch); } else { value = String.valueOf((char) ch); } return c.name().toLowerCase().substring(1) + "=" + value; } private <T extends Enum<T>> String append(EnumSet<T> set) { return append(set, e -> e.name().toLowerCase()); } private <T extends Enum<T>> String append(EnumSet<T> set, Function<T, String> toString) { return set.stream().map(toString).collect(Collectors.joining(" ")); } }