Write a character or its code to the console.

@param integer The charcode to be written to the log.
@param width The width of the charcode in bits.
426261
static void logchar(int integer, int width) {
        if (integer > ' ' && integer <= '}') {
            log("'" + (char) integer + "':" + width + " ");
        } else {
            log(integer, width);
        }
    }
978841
public void writeBegin(final OutputStream result) throws IOException {
        if(this.fontNumber != Font.UNDEFINED) {
            result.write(RtfFontList.FONT_NUMBER);
            result.write(intToByteArray(fontNumber));
        }
        if(this.fontSize != Font.UNDEFINED) {
            result.write(FONT_SIZE);
            result.write(intToByteArray(fontSize * 2));
        }
        if(this.fontStyle != UNDEFINED) {
            if((fontStyle & STYLE_BOLD) == STYLE_BOLD) {
                result.write(FONT_BOLD);
            }
            if((fontStyle & STYLE_ITALIC) == STYLE_ITALIC) {
                result.write(FONT_ITALIC);
            }
            if((fontStyle & STYLE_UNDERLINE) == STYLE_UNDERLINE) {
                result.write(FONT_UNDERLINE);
            }
            if((fontStyle & STYLE_STRIKETHROUGH) == STYLE_STRIKETHROUGH) {
                result.write(FONT_STRIKETHROUGH);
            }
            if((fontStyle & STYLE_HIDDEN) == STYLE_HIDDEN) {
                result.write(FONT_HIDDEN);
            }
            if((fontStyle & STYLE_DOUBLE_STRIKETHROUGH) == STYLE_DOUBLE_STRIKETHROUGH) {
                result.write(FONT_DOUBLE_STRIKETHROUGH);
                result.write(intToByteArray(1));
            }
            if((fontStyle & STYLE_SHADOW) == STYLE_SHADOW) {
                result.write(FONT_SHADOW);
            }
            if((fontStyle & STYLE_OUTLINE) == STYLE_OUTLINE) {
                result.write(FONT_OUTLINE);
            }
            if((fontStyle & STYLE_EMBOSSED) == STYLE_EMBOSSED) {
                result.write(FONT_EMBOSSED);
            }
            if((fontStyle & STYLE_ENGRAVED) == STYLE_ENGRAVED) {
                result.write(FONT_ENGRAVED);
            }
        }
        if(color != null) {
            color.writeBegin(result);
        }
    }
245149
public void writeChar(char value) throws UnsupportedEncodingException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "writeChar", Character.valueOf(value));
    getBodyList().add(Character.valueOf(value));
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "writeChar");
  }
38908
def write(self, string):
        """"""
        self._output += self._options.indentation_character * \
            self._indentation + string + '\n'
805213
@Override
	public void writeChar(char value) throws JMSException
    {
        try
        {
            getOutput().writeChar(value);
        }
        catch (IOException e)
        {
            throw new FFMQException("Cannot write message body","IO_ERROR",e);
        }
    }
1141828
private void write(int integer, int width) throws JSONException {
        try {
            this.bitwriter.write(integer, width);
            if (probe) {
                log(integer, width);
            }
        } catch (Throwable e) {
            throw new JSONException(e);
        }
    }
479549
private void write0(int b) throws IOException {
        if (this.currentChar != -1) {
            b &= 0xff;
            if (this.currentChar == b) {
                if (++this.runLength > 254) {
                    writeRun();
                    this.currentChar = -1;
                    this.runLength = 0;
                }
                // else nothing to do
            } else {
                writeRun();
                this.runLength = 1;
                this.currentChar = b;
            }
        } else {
            this.currentChar = b & 0xff;
            this.runLength++;
        }
    }
551208
@Override
  public void writeChar(int v) throws IOException {
    work[0] = (byte) (0xff & v);
    work[1] = (byte) (0xff & (v >> 8));
    write(work, 0, 2);
  }
568147
public void write(String s)
        throws IOException
    {
        int length=s.length();
        ensureSpareCapacity(length);
        for (int i=0;i<length;i++)
        {
            char c=s.charAt(i);
            if (c>=0x0&&c<=0x7f)
                _buf[_size++]=(byte)c;
            else
            {
                writeEncoded(s.toCharArray(),i,length-i);
                break;
            }
        }

        
    }
515139
public void write(int b) throws IOException {
        Boolean result = (Boolean) callback.call(consoleId.get(), String.valueOf((char) b));
        if (result) {
            out.write(b);
        }
    }
775518
public void write(int value, BitWriter bitwriter) throws JSONException {
        this.width = 0;
        write(this.symbols[value], bitwriter);
        tick(value);
        if (JSONzip.probe) {
            JSONzip.logchar(value, this.width);
        }
    }
1243990
@Override
  public void write(byte[] b, int off, int len) throws IOException {
    textArea.append(new String(b, off, len));
  }
1089126
public void setSpecifiedWidth(String width)
    {
        colwidth = width;
        try {
            content = new Dimension(0, 0);
            content.width = Integer.parseInt(width);
            bounds.width = content.width;
            abswidth = content.width;
            wset = true;
        } catch (NumberFormatException e) {
            if (!width.equals(""))
                log.warn("Invalid width value: " + width);
        }
    }
317730
@Override
    protected void write(EncodingState encodingState, char[] b, int off, int len) throws IOException {
        target.write(b, off, len);
    }
155110
public void writeText(char[] buf, int offset, int length)
  {
    closeElementIfNeeded(false);
    writeIndentIfNewLine();
    _strategy.writeText(this, buf, offset, length);
  }
506844
@Override
	public void write(final int c) {
		WhiteSpaceFilterStateMachine.StateChange change = stateMachine.nextState((char) c);

		if (change.getOutputBytes() != null) {
			for (int i = 0; i < change.getOutputBytes().length; i++) {
				super.write(change.getOutputBytes()[i]);
			}
		}

		if (!change.isSuppressCurrentChar()) {
			super.write(c);
		}
	}
509657
public void println(char c) throws IOException
    {  

        if(this._listener!= null &&  !checkIfCalledFromWLonError()){
            
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "non blocking println char , WriteListener enabled: " + this._listener);
            this.println_NonBlocking(Character.toString(c));
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "println char");
            super.println(c);
        }
    }