home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / javax / swing / text / AbstractWriter.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  5.7 KB  |  378 lines
  1. package javax.swing.text;
  2.  
  3. import java.io.IOException;
  4. import java.io.Writer;
  5. import java.util.Enumeration;
  6.  
  7. public abstract class AbstractWriter {
  8.    // $FF: renamed from: it javax.swing.text.ElementIterator
  9.    private ElementIterator field_0;
  10.    private Writer out;
  11.    private int indentLevel;
  12.    private int indentSpace;
  13.    private Document doc;
  14.    private int maxLineLength;
  15.    private int currLength;
  16.    private int startOffset;
  17.    private int endOffset;
  18.    private int offsetIndent;
  19.    private String lineSeparator;
  20.    private boolean canWrapLines;
  21.    private boolean isLineEmpty;
  22.    private char[] indentChars;
  23.    private char[] tempChars;
  24.    private char[] newlineChars;
  25.    private Segment segment;
  26.    protected static final char NEWLINE = '\n';
  27.  
  28.    protected AbstractWriter(Writer var1, Document var2) {
  29.       this(var1, (Document)var2, 0, var2.getLength());
  30.    }
  31.  
  32.    protected AbstractWriter(Writer var1, Document var2, int var3, int var4) {
  33.       this.indentLevel = 0;
  34.       this.indentSpace = 2;
  35.       this.doc = null;
  36.       this.maxLineLength = 100;
  37.       this.currLength = 0;
  38.       this.startOffset = 0;
  39.       this.endOffset = 0;
  40.       this.offsetIndent = 0;
  41.       this.doc = var2;
  42.       this.field_0 = new ElementIterator(var2.getDefaultRootElement());
  43.       this.out = var1;
  44.       this.startOffset = var3;
  45.       this.endOffset = var3 + var4;
  46.       Object var5 = var2.getProperty("__EndOfLine__");
  47.       if (var5 instanceof String) {
  48.          this.setLineSeparator((String)var5);
  49.       } else {
  50.          String var6 = null;
  51.  
  52.          try {
  53.             var6 = System.getProperty("line.separator");
  54.          } catch (SecurityException var8) {
  55.          }
  56.  
  57.          if (var6 == null) {
  58.             var6 = "\n";
  59.          }
  60.  
  61.          this.setLineSeparator(var6);
  62.       }
  63.  
  64.       this.canWrapLines = true;
  65.    }
  66.  
  67.    protected AbstractWriter(Writer var1, Element var2) {
  68.       this(var1, (Element)var2, 0, var2.getEndOffset());
  69.    }
  70.  
  71.    protected AbstractWriter(Writer var1, Element var2, int var3, int var4) {
  72.       this.indentLevel = 0;
  73.       this.indentSpace = 2;
  74.       this.doc = null;
  75.       this.maxLineLength = 100;
  76.       this.currLength = 0;
  77.       this.startOffset = 0;
  78.       this.endOffset = 0;
  79.       this.offsetIndent = 0;
  80.       this.doc = var2.getDocument();
  81.       this.field_0 = new ElementIterator(var2);
  82.       this.out = var1;
  83.       this.startOffset = var3;
  84.       this.endOffset = var3 + var4;
  85.       this.canWrapLines = true;
  86.    }
  87.  
  88.    public int getStartOffset() {
  89.       return this.startOffset;
  90.    }
  91.  
  92.    public int getEndOffset() {
  93.       return this.endOffset;
  94.    }
  95.  
  96.    protected ElementIterator getElementIterator() {
  97.       return this.field_0;
  98.    }
  99.  
  100.    protected Writer getWriter() {
  101.       return this.out;
  102.    }
  103.  
  104.    protected Document getDocument() {
  105.       return this.doc;
  106.    }
  107.  
  108.    protected boolean inRange(Element var1) {
  109.       int var2 = this.getStartOffset();
  110.       int var3 = this.getEndOffset();
  111.       return var1.getStartOffset() >= var2 && var1.getStartOffset() < var3 || var2 >= var1.getStartOffset() && var2 < var1.getEndOffset();
  112.    }
  113.  
  114.    protected abstract void write() throws IOException, BadLocationException;
  115.  
  116.    protected String getText(Element var1) throws BadLocationException {
  117.       return this.doc.getText(var1.getStartOffset(), var1.getEndOffset() - var1.getStartOffset());
  118.    }
  119.  
  120.    protected void text(Element var1) throws BadLocationException, IOException {
  121.       int var2 = Math.max(this.getStartOffset(), var1.getStartOffset());
  122.       int var3 = Math.min(this.getEndOffset(), var1.getEndOffset());
  123.       if (var2 < var3) {
  124.          if (this.segment == null) {
  125.             this.segment = new Segment();
  126.          }
  127.  
  128.          this.getDocument().getText(var2, var3 - var2, this.segment);
  129.          if (this.segment.count > 0) {
  130.             this.write(this.segment.array, this.segment.offset, this.segment.count);
  131.          }
  132.       }
  133.  
  134.    }
  135.  
  136.    protected void setLineLength(int var1) {
  137.       this.maxLineLength = var1;
  138.    }
  139.  
  140.    protected int getLineLength() {
  141.       return this.maxLineLength;
  142.    }
  143.  
  144.    protected void setCurrentLineLength(int var1) {
  145.       this.currLength = var1;
  146.       this.isLineEmpty = this.currLength == 0;
  147.    }
  148.  
  149.    protected int getCurrentLineLength() {
  150.       return this.currLength;
  151.    }
  152.  
  153.    protected boolean isLineEmpty() {
  154.       return this.isLineEmpty;
  155.    }
  156.  
  157.    protected void setCanWrapLines(boolean var1) {
  158.       this.canWrapLines = var1;
  159.    }
  160.  
  161.    protected boolean getCanWrapLines() {
  162.       return this.canWrapLines;
  163.    }
  164.  
  165.    protected void setIndentSpace(int var1) {
  166.       this.indentSpace = var1;
  167.    }
  168.  
  169.    protected int getIndentSpace() {
  170.       return this.indentSpace;
  171.    }
  172.  
  173.    public void setLineSeparator(String var1) {
  174.       this.lineSeparator = var1;
  175.    }
  176.  
  177.    public String getLineSeparator() {
  178.       return this.lineSeparator;
  179.    }
  180.  
  181.    protected void incrIndent() {
  182.       if (this.offsetIndent > 0) {
  183.          ++this.offsetIndent;
  184.       } else if (++this.indentLevel * this.getIndentSpace() >= this.getLineLength()) {
  185.          ++this.offsetIndent;
  186.          --this.indentLevel;
  187.       }
  188.  
  189.    }
  190.  
  191.    protected void decrIndent() {
  192.       if (this.offsetIndent > 0) {
  193.          --this.offsetIndent;
  194.       } else {
  195.          --this.indentLevel;
  196.       }
  197.  
  198.    }
  199.  
  200.    protected int getIndentLevel() {
  201.       return this.indentLevel;
  202.    }
  203.  
  204.    protected void indent() throws IOException {
  205.       int var1 = this.getIndentLevel() * this.getIndentSpace();
  206.       if (this.indentChars == null || var1 > this.indentChars.length) {
  207.          this.indentChars = new char[var1];
  208.  
  209.          for(int var2 = 0; var2 < var1; ++var2) {
  210.             this.indentChars[var2] = ' ';
  211.          }
  212.       }
  213.  
  214.       int var4 = this.getCurrentLineLength();
  215.       boolean var3 = this.isLineEmpty();
  216.       this.output(this.indentChars, 0, var1);
  217.       if (var3 && var4 == 0) {
  218.          this.isLineEmpty = true;
  219.       }
  220.  
  221.    }
  222.  
  223.    protected void write(char var1) throws IOException {
  224.       if (this.tempChars == null) {
  225.          this.tempChars = new char[128];
  226.       }
  227.  
  228.       this.tempChars[0] = var1;
  229.       this.write(this.tempChars, 0, 1);
  230.    }
  231.  
  232.    protected void write(String var1) throws IOException {
  233.       int var2 = var1.length();
  234.       if (this.tempChars == null || this.tempChars.length < var2) {
  235.          this.tempChars = new char[var2];
  236.       }
  237.  
  238.       var1.getChars(0, var2, this.tempChars, 0);
  239.       this.write(this.tempChars, 0, var2);
  240.    }
  241.  
  242.    protected void writeLineSeparator() throws IOException {
  243.       String var1 = this.getLineSeparator();
  244.       int var2 = var1.length();
  245.       if (this.newlineChars == null || this.newlineChars.length < var2) {
  246.          this.newlineChars = new char[var2];
  247.       }
  248.  
  249.       var1.getChars(0, var2, this.newlineChars, 0);
  250.       this.output(this.newlineChars, 0, var2);
  251.       this.setCurrentLineLength(0);
  252.    }
  253.  
  254.    protected void write(char[] var1, int var2, int var3) throws IOException {
  255.       if (!this.getCanWrapLines()) {
  256.          int var4 = var2;
  257.          int var5 = var2 + var3;
  258.  
  259.          for(int var6 = this.indexOf(var1, '\n', var2, var5); var6 != -1; var6 = this.indexOf(var1, '\n', var4, var5)) {
  260.             if (var6 > var4) {
  261.                this.output(var1, var4, var6 - var4);
  262.             }
  263.  
  264.             this.writeLineSeparator();
  265.             var4 = var6 + 1;
  266.          }
  267.  
  268.          if (var4 < var5) {
  269.             this.output(var1, var4, var5 - var4);
  270.          }
  271.       } else {
  272.          int var13 = var2;
  273.          int var14 = var2 + var3;
  274.          int var15 = this.getCurrentLineLength();
  275.          int var7 = this.getLineLength();
  276.          if (var15 >= var7 && !this.isLineEmpty()) {
  277.             this.writeLineSeparator();
  278.          }
  279.  
  280.          while(var13 < var14) {
  281.             int var8 = this.indexOf(var1, '\n', var13, var14);
  282.             boolean var9 = false;
  283.             var15 = this.getCurrentLineLength();
  284.             if (var8 != -1 && var15 + (var8 - var13) < var7) {
  285.                if (var8 > var13) {
  286.                   this.output(var1, var13, var8 - var13);
  287.                }
  288.  
  289.                var13 = var8 + 1;
  290.                var9 = true;
  291.             } else if (var8 == -1 && var15 + (var14 - var13) < var7) {
  292.                if (var14 > var13) {
  293.                   this.output(var1, var13, var14 - var13);
  294.                }
  295.  
  296.                var13 = var14;
  297.             } else {
  298.                int var10 = -1;
  299.                int var11 = Math.min(var14 - var13, var7 - var15 - 1);
  300.  
  301.                for(int var12 = 0; var12 < var11; ++var12) {
  302.                   if (Character.isWhitespace(var1[var12 + var13])) {
  303.                      var10 = var12;
  304.                   }
  305.                }
  306.  
  307.                if (var10 != -1) {
  308.                   var10 += var13 + 1;
  309.                   this.output(var1, var13, var10 - var13);
  310.                   var13 = var10;
  311.                } else if (this.isLineEmpty()) {
  312.                   int var21 = Math.max(0, var11);
  313.  
  314.                   for(int var20 = var14 - var13; var21 < var20; ++var21) {
  315.                      if (Character.isWhitespace(var1[var21 + var13])) {
  316.                         var10 = var21;
  317.                         break;
  318.                      }
  319.                   }
  320.  
  321.                   if (var10 == -1) {
  322.                      this.output(var1, var13, var14 - var13);
  323.                      var10 = var14;
  324.                   } else {
  325.                      var10 += var13;
  326.                      if (var1[var10] == '\n') {
  327.                         this.output(var1, var13, var10++ - var13);
  328.                      } else {
  329.                         ++var10;
  330.                         this.output(var1, var13, var10 - var13);
  331.                      }
  332.                   }
  333.  
  334.                   var13 = var10;
  335.                }
  336.  
  337.                var9 = true;
  338.             }
  339.  
  340.             if (var9 || var13 < var14) {
  341.                this.writeLineSeparator();
  342.                if (var13 < var14) {
  343.                   this.indent();
  344.                }
  345.             }
  346.          }
  347.       }
  348.  
  349.    }
  350.  
  351.    protected void writeAttributes(AttributeSet var1) throws IOException {
  352.       Enumeration var2 = var1.getAttributeNames();
  353.  
  354.       while(var2.hasMoreElements()) {
  355.          Object var3 = var2.nextElement();
  356.          this.write(" " + var3 + "=" + var1.getAttribute(var3));
  357.       }
  358.  
  359.    }
  360.  
  361.    protected void output(char[] var1, int var2, int var3) throws IOException {
  362.       this.getWriter().write(var1, var2, var3);
  363.       this.setCurrentLineLength(this.getCurrentLineLength() + var3);
  364.    }
  365.  
  366.    private int indexOf(char[] var1, char var2, int var3, int var4) {
  367.       while(var3 < var4) {
  368.          if (var1[var3] == var2) {
  369.             return var3;
  370.          }
  371.  
  372.          ++var3;
  373.       }
  374.  
  375.       return -1;
  376.    }
  377. }
  378.