Java LittleEndian.SHORT_SIZE属性代码示例

public ComplexFileTable(byte[] documentStream, byte[] tableStream, int offset, int fcMin) throws IOException
{
  //skips through the prms before we reach the piece table. These contain data
  //for actual fast saved files
      List<SprmBuffer> sprmBuffers = new LinkedList<SprmBuffer>();
      while ( tableStream[offset] == GRPPRL_TYPE )
      {
          offset++;
          int size = LittleEndian.getShort( tableStream, offset );
          offset += LittleEndian.SHORT_SIZE;
          byte[] bs = LittleEndian.getByteArray( tableStream, offset, size );
          offset += size;

          SprmBuffer sprmBuffer = new SprmBuffer( bs, false, 0 );
          sprmBuffers.add( sprmBuffer );
      }
      this._grpprls = sprmBuffers.toArray( new SprmBuffer[sprmBuffers.size()] );

  if(tableStream[offset] != TEXT_PIECE_TABLE_TYPE)
  {
    throw new IOException("The text piece table is corrupted");
  }
  int pieceTableSize = LittleEndian.getInt(tableStream, ++offset);
  offset += LittleEndian.INT_SIZE;
  _tpt = new TextPieceTable(documentStream, tableStream, offset, pieceTableSize, fcMin);
}
 

/**
 * Write this picture into <code>OutputStream</code>
 */
public void write(OutputStream out) throws IOException {
    byte[] data;

    data = new byte[LittleEndian.SHORT_SIZE];
    LittleEndian.putUShort(data, 0, getSignature());
    out.write(data);

    data = new byte[LittleEndian.SHORT_SIZE];
    LittleEndian.putUShort(data, 0, getType() + 0xF018);
    out.write(data);

    byte[] rawdata = getRawData();

    data = new byte[LittleEndian.INT_SIZE];
    LittleEndian.putInt(data, 0, rawdata.length);
    out.write(data);

    out.write(rawdata);
}
 

public void read(byte[] data, int offset){
    int pos = offset;
    int key = LittleEndian.getInt(data, pos); pos += LittleEndian.INT_SIZE; //header key
    if (key != APMHEADER_KEY) throw new HSLFException("Not a valid WMF file");

    handle = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    left = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    top = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    right = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    bottom = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;

    inch = LittleEndian.getUShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    reserved = LittleEndian.getInt(data, pos); pos += LittleEndian.INT_SIZE;

    checksum = LittleEndian.getShort(data, pos); pos += LittleEndian.SHORT_SIZE;
    if (checksum != getChecksum()){
        logger.log(POILogger.WARN, "WMF checksum does not match the header data");
    }
}
 

public void write(OutputStream out) throws IOException {
    byte[] header = new byte[22];
    int pos = 0;
    LittleEndian.putInt(header, pos, APMHEADER_KEY); pos += LittleEndian.INT_SIZE; //header key
    LittleEndian.putUShort(header, pos, 0); pos += LittleEndian.SHORT_SIZE; //hmf
    LittleEndian.putUShort(header, pos, left); pos += LittleEndian.SHORT_SIZE; //left
    LittleEndian.putUShort(header, pos, top); pos += LittleEndian.SHORT_SIZE; //top
    LittleEndian.putUShort(header, pos, right); pos += LittleEndian.SHORT_SIZE; //right
    LittleEndian.putUShort(header, pos, bottom); pos += LittleEndian.SHORT_SIZE; //bottom
    LittleEndian.putUShort(header, pos, inch); pos += LittleEndian.SHORT_SIZE; //inch
    LittleEndian.putInt(header, pos, 0); pos += LittleEndian.INT_SIZE;  //reserved

    checksum = getChecksum();
    LittleEndian.putUShort(header, pos, checksum);

    out.write(header);
}
 

/**
 * Inserts a paragraph into the front of this range. The paragraph will
 * contain one character run that has the default properties for the
 * paragraph's style.
 *
 * It is necessary for the text to end with the character '\r'
 *
 * @param props
 *            The paragraph's properties.
 * @param styleIndex
 *            The index of the paragraph's style in the style sheet.
 * @param text
 *            The text to insert.
 * @return A newly inserted paragraph.
    * @deprecated Use code shall not work with {@link ParagraphProperties}
 */
   @Deprecated
protected Paragraph insertBefore(ParagraphProperties props, int styleIndex, String text)
// throws UnsupportedEncodingException
{
	initAll();
	StyleSheet ss = _doc.getStyleSheet();
	ParagraphProperties baseStyle = ss.getParagraphStyle(styleIndex);
	CharacterProperties baseChp = ss.getCharacterStyle(styleIndex);

	byte[] grpprl = ParagraphSprmCompressor.compressParagraphProperty(props, baseStyle);
	byte[] withIndex = new byte[grpprl.length + LittleEndian.SHORT_SIZE];
	LittleEndian.putShort(withIndex, (short) styleIndex);
	System.arraycopy(grpprl, 0, withIndex, LittleEndian.SHORT_SIZE, grpprl.length);
	SprmBuffer buf = new SprmBuffer(withIndex, 2);

	_doc.getParagraphTable().insert(_parStart, _start, buf);
	insertBefore(text, baseChp);
	return getParagraph(0);
}
 

protected byte[] toByteArray()
{
  // set up the fc
  int tempFc = fc;
  if (!unicode)
  {
    tempFc *= 2;
    tempFc |= (0x40000000);
  }

  int offset = 0;
  byte[] buf = new byte[8];
  LittleEndian.putShort(buf, offset, descriptor);
  offset += LittleEndian.SHORT_SIZE;
  LittleEndian.putInt(buf, offset, tempFc);
  offset += LittleEndian.INT_SIZE;
  LittleEndian.putShort(buf, offset, prm.getValue());

  return buf;

}
 

public void addSprm(short opcode, byte operand)
{
  int addition = LittleEndian.SHORT_SIZE + LittleEndian.BYTE_SIZE;
  ensureCapacity(addition);
  LittleEndian.putShort(_buf, _offset, opcode);
  _offset += LittleEndian.SHORT_SIZE;
  _buf[_offset++] = operand;
}
 

public SectionDescriptor(byte[] buf, int offset)
{
  fn = LittleEndian.getShort(buf, offset);
  offset += LittleEndian.SHORT_SIZE;
  fcSepx = LittleEndian.getInt(buf, offset);
  offset += LittleEndian.INT_SIZE;
  fnMpr = LittleEndian.getShort(buf, offset);
  offset += LittleEndian.SHORT_SIZE;
  fcMpr = LittleEndian.getInt(buf, offset);
}
 

public byte[] serialize()
{
    byte[] buffer = new byte[getSize()];
    int offset = 0;

    _base.serialize( buffer, offset );
    offset += FFDataBase.getSize();

    offset += _xstzName.serialize( buffer, offset );

    if ( _base.getIType() == FFDataBase.ITYPE_TEXT )
    {
        offset += _xstzTextDef.serialize( buffer, offset );
    }

    if ( _base.getIType() == FFDataBase.ITYPE_CHCK
            || _base.getIType() == FFDataBase.ITYPE_DROP )
    {
        LittleEndian.putUShort( buffer, offset, _wDef );
        offset += LittleEndian.SHORT_SIZE;
    }

    offset += _xstzTextFormat.serialize( buffer, offset );
    offset += _xstzHelpText.serialize( buffer, offset );
    offset += _xstzStatText.serialize( buffer, offset );
    offset += _xstzEntryMcr.serialize( buffer, offset );
    offset += _xstzExitMcr.serialize( buffer, offset );

    if ( _base.getIType() == FFDataBase.ITYPE_DROP )
    {
        offset += _hsttbDropList.serialize( buffer, offset );
    }

    return buffer;
}
 

public void writeTo( byte[] mainStream, HWPFOutputStream tableStream )
        throws IOException
{
    _cbRgFcLcb = _fieldHandler.getFieldsCount();

    _fibBase.serialize( mainStream, 0 );
    int offset = FibBase.getSize();

    LittleEndian.putUShort( mainStream, offset, _csw );
    offset += LittleEndian.SHORT_SIZE;

    _fibRgW.serialize( mainStream, offset );
    offset += FibRgW97.getSize();

    LittleEndian.putUShort( mainStream, offset, _cslw );
    offset += LittleEndian.SHORT_SIZE;

    ( (FibRgLw97) _fibRgLw ).serialize( mainStream, offset );
    offset += FibRgLw97.getSize();

    LittleEndian.putUShort( mainStream, offset, _cbRgFcLcb );
    offset += LittleEndian.SHORT_SIZE;

    _fieldHandler.writeTo( mainStream, offset, tableStream );
    offset += _cbRgFcLcb * LittleEndian.INT_SIZE * 2;

    LittleEndian.putUShort( mainStream, offset, _cswNew );
    offset += LittleEndian.SHORT_SIZE;
    if ( _cswNew != 0 )
    {
        LittleEndian.putUShort( mainStream, offset, _nFibNew );
        offset += LittleEndian.SHORT_SIZE;

        System.arraycopy( _fibRgCswNew, 0, mainStream, offset,
                _fibRgCswNew.length );
        offset += _fibRgCswNew.length;
    }
}
 

public static byte[] shortArrayToByteArray(short[] convert)
{
  byte[] buf = new byte[convert.length * LittleEndian.SHORT_SIZE];

  for (int x = 0; x < convert.length; x++)
  {
    LittleEndian.putShort(buf, x * LittleEndian.SHORT_SIZE, convert[x]);
  }

  return buf;
}
 

public void serialize( byte[] data, int startOffset )
{
    int offset = startOffset;

    LittleEndian.putUShort( data, offset, _cch );
    offset += LittleEndian.SHORT_SIZE;

    for ( char c : _rgtchar )
    {
        LittleEndian.putShort( data, offset, (short) c );
        offset += LittleEndian.SHORT_SIZE;
    }
}
 

public int getSize()
{
    int size = FFDataBase.getSize();

    size += _xstzName.getSize();

    if ( _base.getIType() == FFDataBase.ITYPE_TEXT )
    {
        size += _xstzTextDef.getSize();
    }

    if ( _base.getIType() == FFDataBase.ITYPE_CHCK
            || _base.getIType() == FFDataBase.ITYPE_DROP )
    {
        size += LittleEndian.SHORT_SIZE;
    }

    size += _xstzTextFormat.getSize();
    size += _xstzHelpText.getSize();
    size += _xstzStatText.getSize();
    size += _xstzEntryMcr.getSize();
    size += _xstzExitMcr.getSize();

    if ( _base.getIType() == FFDataBase.ITYPE_DROP )
    {
        size += _hsttbDropList.getSize();
    }

    return size;
}
 

public ParagraphHeight(byte[] buf, int offset)
{
  infoField = LittleEndian.getShort(buf, offset);
  offset += LittleEndian.SHORT_SIZE;
  reserved = LittleEndian.getShort(buf, offset);
  offset += LittleEndian.SHORT_SIZE;
  dxaCol = LittleEndian.getInt(buf, offset);
  offset += LittleEndian.INT_SIZE;
  dymLineOrHeight = LittleEndian.getInt(buf, offset);
}
 

public void writeTo( HWPFOutputStream tableStream ) throws IOException
  {
 byte[] buf = new byte[LittleEndian.SHORT_SIZE];
 LittleEndian.putShort(buf, _stringCount);
 tableStream.write(buf);
 LittleEndian.putShort(buf, _extraDataSz);
 tableStream.write(buf);

 for(int i = 0; i < _fontNames.length; i++)
 {
  tableStream.write(_fontNames[i].toByteArray());
 }

}