WMF (Windows Metafile) is a relatively early vector image format introduced for Microsoft Windows in 1990.
Inside, it provides a serialized list of Windows GDI (Graphics Device Interface) function calls, which, if played back, result in an image being drawn on a given surface (display, off-screen buffer, printer, etc).
This page hosts a formal specification of Windows Metafile (WMF) vector image using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
import io.kaitai.struct.ByteBufferKaitaiStream;
import io.kaitai.struct.KaitaiStruct;
import io.kaitai.struct.KaitaiStream;
import java.io.IOException;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Objects;
import io.kaitai.struct.ConsistencyError;
import java.util.List;
import java.util.Arrays;
/**
* WMF (Windows Metafile) is a relatively early vector image format
* introduced for Microsoft Windows in 1990.
*
* Inside, it provides a serialized list of Windows GDI (Graphics
* Device Interface) function calls, which, if played back, result in
* an image being drawn on a given surface (display, off-screen buffer,
* printer, etc).
* @see <a href="https://www.loc.gov/preservation/digital/formats/digformatspecs/WindowsMetafileFormat(wmf)Specification.pdf">Source</a>
*/
public class Wmf extends KaitaiStruct.ReadWrite {
public static Wmf fromFile(String fileName) throws IOException {
return new Wmf(new ByteBufferKaitaiStream(fileName));
}
public enum BinRasterOp {
BLACK(1),
NOTMERGEPEN(2),
MASKNOTPEN(3),
NOTCOPYPEN(4),
MASKPENNOT(5),
NOT(6),
XORPEN(7),
NOTMASKPEN(8),
MASKPEN(9),
NOTXORPEN(10),
NOP(11),
MERGENOTPEN(12),
COPYPEN(13),
MERGEPENNOT(14),
MERGEPEN(15),
WHITE(16);
private final long id;
BinRasterOp(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, BinRasterOp> byId = new HashMap<Long, BinRasterOp>(16);
static {
for (BinRasterOp e : BinRasterOp.values())
byId.put(e.id(), e);
}
public static BinRasterOp byId(long id) { return byId.get(id); }
}
public enum Func {
EOF(0),
SAVEDC(30),
REALIZEPALETTE(53),
SETPALENTRIES(55),
CREATEPALETTE(247),
SETBKMODE(258),
SETMAPMODE(259),
SETROP2(260),
SETRELABS(261),
SETPOLYFILLMODE(262),
SETSTRETCHBLTMODE(263),
SETTEXTCHAREXTRA(264),
RESTOREDC(295),
INVERTREGION(298),
PAINTREGION(299),
SELECTCLIPREGION(300),
SELECTOBJECT(301),
SETTEXTALIGN(302),
RESIZEPALETTE(313),
DIBCREATEPATTERNBRUSH(322),
SETLAYOUT(329),
DELETEOBJECT(496),
CREATEPATTERNBRUSH(505),
SETBKCOLOR(513),
SETTEXTCOLOR(521),
SETTEXTJUSTIFICATION(522),
SETWINDOWORG(523),
SETWINDOWEXT(524),
SETVIEWPORTORG(525),
SETVIEWPORTEXT(526),
OFFSETWINDOWORG(527),
OFFSETVIEWPORTORG(529),
LINETO(531),
MOVETO(532),
OFFSETCLIPRGN(544),
FILLREGION(552),
SETMAPPERFLAGS(561),
SELECTPALETTE(564),
CREATEPENINDIRECT(762),
CREATEFONTINDIRECT(763),
CREATEBRUSHINDIRECT(764),
POLYGON(804),
POLYLINE(805),
SCALEWINDOWEXT(1040),
SCALEVIEWPORTEXT(1042),
EXCLUDECLIPRECT(1045),
INTERSECTCLIPRECT(1046),
ELLIPSE(1048),
FLOODFILL(1049),
RECTANGLE(1051),
SETPIXEL(1055),
FRAMEREGION(1065),
ANIMATEPALETTE(1078),
TEXTOUT(1313),
POLYPOLYGON(1336),
EXTFLOODFILL(1352),
ROUNDRECT(1564),
PATBLT(1565),
ESCAPE(1574),
CREATEREGION(1791),
ARC(2071),
PIE(2074),
CHORD(2096),
BITBLT(2338),
DIBBITBLT(2368),
EXTTEXTOUT(2610),
STRETCHBLT(2851),
DIBSTRETCHBLT(2881),
SETDIBTODEV(3379),
STRETCHDIB(3907);
private final long id;
Func(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, Func> byId = new HashMap<Long, Func>(70);
static {
for (Func e : Func.values())
byId.put(e.id(), e);
}
public static Func byId(long id) { return byId.get(id); }
}
public enum MixMode {
TRANSPARENT(1),
OPAQUE(2);
private final long id;
MixMode(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, MixMode> byId = new HashMap<Long, MixMode>(2);
static {
for (MixMode e : MixMode.values())
byId.put(e.id(), e);
}
public static MixMode byId(long id) { return byId.get(id); }
}
public enum PolyFillMode {
ALTERNATE(1),
WINDING(2);
private final long id;
PolyFillMode(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, PolyFillMode> byId = new HashMap<Long, PolyFillMode>(2);
static {
for (PolyFillMode e : PolyFillMode.values())
byId.put(e.id(), e);
}
public static PolyFillMode byId(long id) { return byId.get(id); }
}
public Wmf() {
this(null, null, null);
}
public Wmf(KaitaiStream _io) {
this(_io, null, null);
}
public Wmf(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public Wmf(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root == null ? this : _root;
}
public void _read() {
this.specialHeader = new SpecialHeader(this._io, this, _root);
this.specialHeader._read();
this.header = new Header(this._io, this, _root);
this.header._read();
this.records = new ArrayList<Record>();
{
Record _it;
int i = 0;
do {
Record _t_records = new Record(this._io, this, _root);
try {
_t_records._read();
} finally {
_it = _t_records;
this.records.add(_it);
}
i++;
} while (!(_it.function() == Func.EOF));
}
_dirty = false;
}
public void _fetchInstances() {
this.specialHeader._fetchInstances();
this.header._fetchInstances();
for (int i = 0; i < this.records.size(); i++) {
this.records.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this.specialHeader._write_Seq(this._io);
this.header._write_Seq(this._io);
for (int i = 0; i < this.records.size(); i++) {
this.records.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (!Objects.equals(this.specialHeader._root(), _root()))
throw new ConsistencyError("special_header", _root(), this.specialHeader._root());
if (!Objects.equals(this.specialHeader._parent(), this))
throw new ConsistencyError("special_header", this, this.specialHeader._parent());
if (!Objects.equals(this.header._root(), _root()))
throw new ConsistencyError("header", _root(), this.header._root());
if (!Objects.equals(this.header._parent(), this))
throw new ConsistencyError("header", this, this.header._parent());
if (this.records.size() == 0)
throw new ConsistencyError("records", 0, this.records.size());
for (int i = 0; i < this.records.size(); i++) {
if (!Objects.equals(this.records.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("records", _root(), this.records.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.records.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("records", this, this.records.get(((Number) (i)).intValue())._parent());
{
Record _it = this.records.get(((Number) (i)).intValue());
if ((_it.function() == Func.EOF) != (i == this.records.size() - 1))
throw new ConsistencyError("records", i == this.records.size() - 1, _it.function() == Func.EOF);
}
}
_dirty = false;
}
/**
* @see "section 2.2.1.7"
*/
public static class ColorRef extends KaitaiStruct.ReadWrite {
public static ColorRef fromFile(String fileName) throws IOException {
return new ColorRef(new ByteBufferKaitaiStream(fileName));
}
public ColorRef() {
this(null, null, null);
}
public ColorRef(KaitaiStream _io) {
this(_io, null, null);
}
public ColorRef(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ColorRef(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.red = this._io.readU1();
this.green = this._io.readU1();
this.blue = this._io.readU1();
this.reserved = this._io.readU1();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU1(this.red);
this._io.writeU1(this.green);
this._io.writeU1(this.blue);
this._io.writeU1(this.reserved);
}
public void _check() {
_dirty = false;
}
private int red;
private int green;
private int blue;
private int reserved;
private Wmf _root;
private Wmf.Record _parent;
public int red() { return red; }
public void setRed(int _v) { _dirty = true; red = _v; }
public int green() { return green; }
public void setGreen(int _v) { _dirty = true; green = _v; }
public int blue() { return blue; }
public void setBlue(int _v) { _dirty = true; blue = _v; }
public int reserved() { return reserved; }
public void setReserved(int _v) { _dirty = true; reserved = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
public static class Header extends KaitaiStruct.ReadWrite {
public static Header fromFile(String fileName) throws IOException {
return new Header(new ByteBufferKaitaiStream(fileName));
}
public enum MetafileType {
MEMORY_METAFILE(1),
DISK_METAFILE(2);
private final long id;
MetafileType(long id) { this.id = id; }
public long id() { return id; }
private static final Map<Long, MetafileType> byId = new HashMap<Long, MetafileType>(2);
static {
for (MetafileType e : MetafileType.values())
byId.put(e.id(), e);
}
public static MetafileType byId(long id) { return byId.get(id); }
}
public Header() {
this(null, null, null);
}
public Header(KaitaiStream _io) {
this(_io, null, null);
}
public Header(KaitaiStream _io, Wmf _parent) {
this(_io, _parent, null);
}
public Header(KaitaiStream _io, Wmf _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.metafileType = MetafileType.byId(this._io.readU2le());
this.headerSize = this._io.readU2le();
this.version = this._io.readU2le();
this.size = this._io.readU4le();
this.numberOfObjects = this._io.readU2le();
this.maxRecord = this._io.readU4le();
this.numberOfMembers = this._io.readU2le();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU2le(((Number) (this.metafileType.id())).intValue());
this._io.writeU2le(this.headerSize);
this._io.writeU2le(this.version);
this._io.writeU4le(this.size);
this._io.writeU2le(this.numberOfObjects);
this._io.writeU4le(this.maxRecord);
this._io.writeU2le(this.numberOfMembers);
}
public void _check() {
_dirty = false;
}
private MetafileType metafileType;
private int headerSize;
private int version;
private long size;
private int numberOfObjects;
private long maxRecord;
private int numberOfMembers;
private Wmf _root;
private Wmf _parent;
public MetafileType metafileType() { return metafileType; }
public void setMetafileType(MetafileType _v) { _dirty = true; metafileType = _v; }
public int headerSize() { return headerSize; }
public void setHeaderSize(int _v) { _dirty = true; headerSize = _v; }
public int version() { return version; }
public void setVersion(int _v) { _dirty = true; version = _v; }
public long size() { return size; }
public void setSize(long _v) { _dirty = true; size = _v; }
public int numberOfObjects() { return numberOfObjects; }
public void setNumberOfObjects(int _v) { _dirty = true; numberOfObjects = _v; }
public long maxRecord() { return maxRecord; }
public void setMaxRecord(long _v) { _dirty = true; maxRecord = _v; }
public int numberOfMembers() { return numberOfMembers; }
public void setNumberOfMembers(int _v) { _dirty = true; numberOfMembers = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf _parent() { return _parent; }
public void set_parent(Wmf _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.3.15 = params_polyline"
*/
public static class ParamsPolygon extends KaitaiStruct.ReadWrite {
public static ParamsPolygon fromFile(String fileName) throws IOException {
return new ParamsPolygon(new ByteBufferKaitaiStream(fileName));
}
public ParamsPolygon() {
this(null, null, null);
}
public ParamsPolygon(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsPolygon(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsPolygon(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.numPoints = this._io.readS2le();
this.points = new ArrayList<PointS>();
for (int i = 0; i < numPoints(); i++) {
PointS _t_points = new PointS(this._io, this, _root);
try {
_t_points._read();
} finally {
this.points.add(_t_points);
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.points.size(); i++) {
this.points.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeS2le(this.numPoints);
for (int i = 0; i < this.points.size(); i++) {
this.points.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (this.points.size() != numPoints())
throw new ConsistencyError("points", numPoints(), this.points.size());
for (int i = 0; i < this.points.size(); i++) {
if (!Objects.equals(this.points.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("points", _root(), this.points.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.points.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("points", this, this.points.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private short numPoints;
private List<PointS> points;
private Wmf _root;
private Wmf.Record _parent;
public short numPoints() { return numPoints; }
public void setNumPoints(short _v) { _dirty = true; numPoints = _v; }
public List<PointS> points() { return points; }
public void setPoints(List<PointS> _v) { _dirty = true; points = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.3.14"
*/
public static class ParamsPolyline extends KaitaiStruct.ReadWrite {
public static ParamsPolyline fromFile(String fileName) throws IOException {
return new ParamsPolyline(new ByteBufferKaitaiStream(fileName));
}
public ParamsPolyline() {
this(null, null, null);
}
public ParamsPolyline(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsPolyline(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsPolyline(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.numPoints = this._io.readS2le();
this.points = new ArrayList<PointS>();
for (int i = 0; i < numPoints(); i++) {
PointS _t_points = new PointS(this._io, this, _root);
try {
_t_points._read();
} finally {
this.points.add(_t_points);
}
}
_dirty = false;
}
public void _fetchInstances() {
for (int i = 0; i < this.points.size(); i++) {
this.points.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeS2le(this.numPoints);
for (int i = 0; i < this.points.size(); i++) {
this.points.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (this.points.size() != numPoints())
throw new ConsistencyError("points", numPoints(), this.points.size());
for (int i = 0; i < this.points.size(); i++) {
if (!Objects.equals(this.points.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("points", _root(), this.points.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.points.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("points", this, this.points.get(((Number) (i)).intValue())._parent());
}
_dirty = false;
}
private short numPoints;
private List<PointS> points;
private Wmf _root;
private Wmf.Record _parent;
public short numPoints() { return numPoints; }
public void setNumPoints(short _v) { _dirty = true; numPoints = _v; }
public List<PointS> points() { return points; }
public void setPoints(List<PointS> _v) { _dirty = true; points = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.5.15"
*/
public static class ParamsSetbkmode extends KaitaiStruct.ReadWrite {
public static ParamsSetbkmode fromFile(String fileName) throws IOException {
return new ParamsSetbkmode(new ByteBufferKaitaiStream(fileName));
}
public ParamsSetbkmode() {
this(null, null, null);
}
public ParamsSetbkmode(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsSetbkmode(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsSetbkmode(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.bkMode = Wmf.MixMode.byId(this._io.readU2le());
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU2le(((Number) (this.bkMode.id())).intValue());
}
public void _check() {
_dirty = false;
}
private MixMode bkMode;
private Wmf _root;
private Wmf.Record _parent;
/**
* Defines current graphic context background mix mode.
*/
public MixMode bkMode() { return bkMode; }
public void setBkMode(MixMode _v) { _dirty = true; bkMode = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.5.20"
*/
public static class ParamsSetpolyfillmode extends KaitaiStruct.ReadWrite {
public static ParamsSetpolyfillmode fromFile(String fileName) throws IOException {
return new ParamsSetpolyfillmode(new ByteBufferKaitaiStream(fileName));
}
public ParamsSetpolyfillmode() {
this(null, null, null);
}
public ParamsSetpolyfillmode(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsSetpolyfillmode(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsSetpolyfillmode(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.polyFillMode = Wmf.PolyFillMode.byId(this._io.readU2le());
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU2le(((Number) (this.polyFillMode.id())).intValue());
}
public void _check() {
_dirty = false;
}
private PolyFillMode polyFillMode;
private Wmf _root;
private Wmf.Record _parent;
/**
* Defines current polygon fill mode.
*/
public PolyFillMode polyFillMode() { return polyFillMode; }
public void setPolyFillMode(PolyFillMode _v) { _dirty = true; polyFillMode = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.5.22"
*/
public static class ParamsSetrop2 extends KaitaiStruct.ReadWrite {
public static ParamsSetrop2 fromFile(String fileName) throws IOException {
return new ParamsSetrop2(new ByteBufferKaitaiStream(fileName));
}
public ParamsSetrop2() {
this(null, null, null);
}
public ParamsSetrop2(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsSetrop2(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsSetrop2(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.drawMode = Wmf.BinRasterOp.byId(this._io.readU2le());
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU2le(((Number) (this.drawMode.id())).intValue());
}
public void _check() {
_dirty = false;
}
private BinRasterOp drawMode;
private Wmf _root;
private Wmf.Record _parent;
/**
* Defines current foreground binary raster operation mixing mode.
*/
public BinRasterOp drawMode() { return drawMode; }
public void setDrawMode(BinRasterOp _v) { _dirty = true; drawMode = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.5.30"
*/
public static class ParamsSetwindowext extends KaitaiStruct.ReadWrite {
public static ParamsSetwindowext fromFile(String fileName) throws IOException {
return new ParamsSetwindowext(new ByteBufferKaitaiStream(fileName));
}
public ParamsSetwindowext() {
this(null, null, null);
}
public ParamsSetwindowext(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsSetwindowext(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsSetwindowext(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.y = this._io.readS2le();
this.x = this._io.readS2le();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeS2le(this.y);
this._io.writeS2le(this.x);
}
public void _check() {
_dirty = false;
}
private short y;
private short x;
private Wmf _root;
private Wmf.Record _parent;
/**
* Vertical extent of the window in logical units.
*/
public short y() { return y; }
public void setY(short _v) { _dirty = true; y = _v; }
/**
* Horizontal extent of the window in logical units.
*/
public short x() { return x; }
public void setX(short _v) { _dirty = true; x = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.3.5.31"
*/
public static class ParamsSetwindoworg extends KaitaiStruct.ReadWrite {
public static ParamsSetwindoworg fromFile(String fileName) throws IOException {
return new ParamsSetwindoworg(new ByteBufferKaitaiStream(fileName));
}
public ParamsSetwindoworg() {
this(null, null, null);
}
public ParamsSetwindoworg(KaitaiStream _io) {
this(_io, null, null);
}
public ParamsSetwindoworg(KaitaiStream _io, Wmf.Record _parent) {
this(_io, _parent, null);
}
public ParamsSetwindoworg(KaitaiStream _io, Wmf.Record _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.y = this._io.readS2le();
this.x = this._io.readS2le();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeS2le(this.y);
this._io.writeS2le(this.x);
}
public void _check() {
_dirty = false;
}
private short y;
private short x;
private Wmf _root;
private Wmf.Record _parent;
/**
* Y coordinate of the window origin, in logical units.
*/
public short y() { return y; }
public void setY(short _v) { _dirty = true; y = _v; }
/**
* X coordinate of the window origin, in logical units.
*/
public short x() { return x; }
public void setX(short _v) { _dirty = true; x = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf.Record _parent() { return _parent; }
public void set_parent(Wmf.Record _v) { _dirty = true; _parent = _v; }
}
/**
* @see "section 2.2.1.12"
*/
public static class PointS extends KaitaiStruct.ReadWrite {
public static PointS fromFile(String fileName) throws IOException {
return new PointS(new ByteBufferKaitaiStream(fileName));
}
public PointS() {
this(null, null, null);
}
public PointS(KaitaiStream _io) {
this(_io, null, null);
}
public PointS(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public PointS(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.x = this._io.readS2le();
this.y = this._io.readS2le();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeS2le(this.x);
this._io.writeS2le(this.y);
}
public void _check() {
_dirty = false;
}
private short x;
private short y;
private Wmf _root;
private KaitaiStruct.ReadWrite _parent;
/**
* X coordinate of the point, in logical units.
*/
public short x() { return x; }
public void setX(short _v) { _dirty = true; x = _v; }
/**
* Y coordinate of the point, in logical units.
*/
public short y() { return y; }
public void setY(short _v) { _dirty = true; y = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class Record extends KaitaiStruct.ReadWrite {
public static Record fromFile(String fileName) throws IOException {
return new Record(new ByteBufferKaitaiStream(fileName));
}
public Record() {
this(null, null, null);
}
public Record(KaitaiStream _io) {
this(_io, null, null);
}
public Record(KaitaiStream _io, Wmf _parent) {
this(_io, _parent, null);
}
public Record(KaitaiStream _io, Wmf _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.size = this._io.readU4le();
this.function = Wmf.Func.byId(this._io.readU2le());
{
Func on = function();
if (on != null) {
switch (function()) {
case POLYGON: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsPolygon(_io__raw_params, this, _root);
((ParamsPolygon) (this.params))._read();
break;
}
case POLYLINE: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsPolyline(_io__raw_params, this, _root);
((ParamsPolyline) (this.params))._read();
break;
}
case SETBKCOLOR: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ColorRef(_io__raw_params, this, _root);
((ColorRef) (this.params))._read();
break;
}
case SETBKMODE: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsSetbkmode(_io__raw_params, this, _root);
((ParamsSetbkmode) (this.params))._read();
break;
}
case SETPOLYFILLMODE: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsSetpolyfillmode(_io__raw_params, this, _root);
((ParamsSetpolyfillmode) (this.params))._read();
break;
}
case SETROP2: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsSetrop2(_io__raw_params, this, _root);
((ParamsSetrop2) (this.params))._read();
break;
}
case SETWINDOWEXT: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsSetwindowext(_io__raw_params, this, _root);
((ParamsSetwindowext) (this.params))._read();
break;
}
case SETWINDOWORG: {
this._raw_params = this._io.readBytes((size() - 3) * 2);
KaitaiStream _io__raw_params = new ByteBufferKaitaiStream(this._raw_params);
this.params = new ParamsSetwindoworg(_io__raw_params, this, _root);
((ParamsSetwindoworg) (this.params))._read();
break;
}
default: {
this.params = this._io.readBytes((size() - 3) * 2);
break;
}
}
} else {
this.params = this._io.readBytes((size() - 3) * 2);
}
}
_dirty = false;
}
public void _fetchInstances() {
{
Func on = function();
if (on != null) {
switch (function()) {
case POLYGON: {
((ParamsPolygon) (this.params))._fetchInstances();
break;
}
case POLYLINE: {
((ParamsPolyline) (this.params))._fetchInstances();
break;
}
case SETBKCOLOR: {
((ColorRef) (this.params))._fetchInstances();
break;
}
case SETBKMODE: {
((ParamsSetbkmode) (this.params))._fetchInstances();
break;
}
case SETPOLYFILLMODE: {
((ParamsSetpolyfillmode) (this.params))._fetchInstances();
break;
}
case SETROP2: {
((ParamsSetrop2) (this.params))._fetchInstances();
break;
}
case SETWINDOWEXT: {
((ParamsSetwindowext) (this.params))._fetchInstances();
break;
}
case SETWINDOWORG: {
((ParamsSetwindoworg) (this.params))._fetchInstances();
break;
}
default: {
break;
}
}
} else {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4le(this.size);
this._io.writeU2le(((Number) (this.function.id())).intValue());
{
Func on = function();
if (on != null) {
switch (function()) {
case POLYGON: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsPolygon) (this.params))._write_Seq(_io__raw_params);
break;
}
case POLYLINE: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsPolyline) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETBKCOLOR: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ColorRef) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETBKMODE: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsSetbkmode) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETPOLYFILLMODE: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsSetpolyfillmode) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETROP2: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsSetrop2) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETWINDOWEXT: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsSetwindowext) (this.params))._write_Seq(_io__raw_params);
break;
}
case SETWINDOWORG: {
final KaitaiStream _io__raw_params = new ByteBufferKaitaiStream((size() - 3) * 2);
this._io.addChildStream(_io__raw_params);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + ((size() - 3) * 2));
final Record _this = this;
_io__raw_params.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_params = _io__raw_params.toByteArray();
if (((byte[]) (_this._raw_params)).length != (size() - 3) * 2)
throw new ConsistencyError("raw(params)", (size() - 3) * 2, ((byte[]) (_this._raw_params)).length);
parent.writeBytes(((byte[]) (((byte[]) (_this._raw_params)))));
}
});
}
((ParamsSetwindoworg) (this.params))._write_Seq(_io__raw_params);
break;
}
default: {
this._io.writeBytes(((byte[]) (((byte[]) (this.params)))));
break;
}
}
} else {
this._io.writeBytes(((byte[]) (((byte[]) (this.params)))));
}
}
}
public void _check() {
{
Func on = function();
if (on != null) {
switch (function()) {
case POLYGON: {
if (!Objects.equals(((Wmf.ParamsPolygon) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsPolygon) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsPolygon) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsPolygon) (this.params))._parent());
break;
}
case POLYLINE: {
if (!Objects.equals(((Wmf.ParamsPolyline) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsPolyline) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsPolyline) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsPolyline) (this.params))._parent());
break;
}
case SETBKCOLOR: {
if (!Objects.equals(((Wmf.ColorRef) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ColorRef) (this.params))._root());
if (!Objects.equals(((Wmf.ColorRef) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ColorRef) (this.params))._parent());
break;
}
case SETBKMODE: {
if (!Objects.equals(((Wmf.ParamsSetbkmode) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsSetbkmode) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsSetbkmode) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsSetbkmode) (this.params))._parent());
break;
}
case SETPOLYFILLMODE: {
if (!Objects.equals(((Wmf.ParamsSetpolyfillmode) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsSetpolyfillmode) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsSetpolyfillmode) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsSetpolyfillmode) (this.params))._parent());
break;
}
case SETROP2: {
if (!Objects.equals(((Wmf.ParamsSetrop2) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsSetrop2) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsSetrop2) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsSetrop2) (this.params))._parent());
break;
}
case SETWINDOWEXT: {
if (!Objects.equals(((Wmf.ParamsSetwindowext) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsSetwindowext) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsSetwindowext) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsSetwindowext) (this.params))._parent());
break;
}
case SETWINDOWORG: {
if (!Objects.equals(((Wmf.ParamsSetwindoworg) (this.params))._root(), _root()))
throw new ConsistencyError("params", _root(), ((Wmf.ParamsSetwindoworg) (this.params))._root());
if (!Objects.equals(((Wmf.ParamsSetwindoworg) (this.params))._parent(), this))
throw new ConsistencyError("params", this, ((Wmf.ParamsSetwindoworg) (this.params))._parent());
break;
}
default: {
if (((byte[]) (this.params)).length != (size() - 3) * 2)
throw new ConsistencyError("params", (size() - 3) * 2, ((byte[]) (this.params)).length);
break;
}
}
} else {
if (((byte[]) (this.params)).length != (size() - 3) * 2)
throw new ConsistencyError("params", (size() - 3) * 2, ((byte[]) (this.params)).length);
}
}
_dirty = false;
}
private long size;
private Func function;
private Object params;
private Wmf _root;
private Wmf _parent;
private byte[] _raw_params;
public long size() { return size; }
public void setSize(long _v) { _dirty = true; size = _v; }
public Func function() { return function; }
public void setFunction(Func _v) { _dirty = true; function = _v; }
public Object params() { return params; }
public void setParams(Object _v) { _dirty = true; params = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf _parent() { return _parent; }
public void set_parent(Wmf _v) { _dirty = true; _parent = _v; }
public byte[] _raw_params() { return _raw_params; }
public void set_raw_Params(byte[] _v) { _dirty = true; _raw_params = _v; }
}
public static class SpecialHeader extends KaitaiStruct.ReadWrite {
public static SpecialHeader fromFile(String fileName) throws IOException {
return new SpecialHeader(new ByteBufferKaitaiStream(fileName));
}
public SpecialHeader() {
this(null, null, null);
}
public SpecialHeader(KaitaiStream _io) {
this(_io, null, null);
}
public SpecialHeader(KaitaiStream _io, Wmf _parent) {
this(_io, _parent, null);
}
public SpecialHeader(KaitaiStream _io, Wmf _parent, Wmf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.magic = this._io.readBytes(4);
if (!(Arrays.equals(this.magic, new byte[] { -41, -51, -58, -102 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { -41, -51, -58, -102 }, this.magic, this._io, "/types/special_header/seq/0");
}
this.handle = this._io.readBytes(2);
if (!(Arrays.equals(this.handle, new byte[] { 0, 0 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 0, 0 }, this.handle, this._io, "/types/special_header/seq/1");
}
this.left = this._io.readS2le();
this.top = this._io.readS2le();
this.right = this._io.readS2le();
this.bottom = this._io.readS2le();
this.inch = this._io.readU2le();
this.reserved = this._io.readBytes(4);
if (!(Arrays.equals(this.reserved, new byte[] { 0, 0, 0, 0 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 0, 0, 0, 0 }, this.reserved, this._io, "/types/special_header/seq/7");
}
this.checksum = this._io.readU2le();
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.magic);
this._io.writeBytes(this.handle);
this._io.writeS2le(this.left);
this._io.writeS2le(this.top);
this._io.writeS2le(this.right);
this._io.writeS2le(this.bottom);
this._io.writeU2le(this.inch);
this._io.writeBytes(this.reserved);
this._io.writeU2le(this.checksum);
}
public void _check() {
if (this.magic.length != 4)
throw new ConsistencyError("magic", 4, this.magic.length);
if (!(Arrays.equals(this.magic, new byte[] { -41, -51, -58, -102 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { -41, -51, -58, -102 }, this.magic, null, "/types/special_header/seq/0");
}
if (this.handle.length != 2)
throw new ConsistencyError("handle", 2, this.handle.length);
if (!(Arrays.equals(this.handle, new byte[] { 0, 0 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 0, 0 }, this.handle, null, "/types/special_header/seq/1");
}
if (this.reserved.length != 4)
throw new ConsistencyError("reserved", 4, this.reserved.length);
if (!(Arrays.equals(this.reserved, new byte[] { 0, 0, 0, 0 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 0, 0, 0, 0 }, this.reserved, null, "/types/special_header/seq/7");
}
_dirty = false;
}
private byte[] magic;
private byte[] handle;
private short left;
private short top;
private short right;
private short bottom;
private int inch;
private byte[] reserved;
private int checksum;
private Wmf _root;
private Wmf _parent;
public byte[] magic() { return magic; }
public void setMagic(byte[] _v) { _dirty = true; magic = _v; }
public byte[] handle() { return handle; }
public void setHandle(byte[] _v) { _dirty = true; handle = _v; }
public short left() { return left; }
public void setLeft(short _v) { _dirty = true; left = _v; }
public short top() { return top; }
public void setTop(short _v) { _dirty = true; top = _v; }
public short right() { return right; }
public void setRight(short _v) { _dirty = true; right = _v; }
public short bottom() { return bottom; }
public void setBottom(short _v) { _dirty = true; bottom = _v; }
public int inch() { return inch; }
public void setInch(int _v) { _dirty = true; inch = _v; }
public byte[] reserved() { return reserved; }
public void setReserved(byte[] _v) { _dirty = true; reserved = _v; }
public int checksum() { return checksum; }
public void setChecksum(int _v) { _dirty = true; checksum = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public Wmf _parent() { return _parent; }
public void set_parent(Wmf _v) { _dirty = true; _parent = _v; }
}
private SpecialHeader specialHeader;
private Header header;
private List<Record> records;
private Wmf _root;
private KaitaiStruct.ReadWrite _parent;
public SpecialHeader specialHeader() { return specialHeader; }
public void setSpecialHeader(SpecialHeader _v) { _dirty = true; specialHeader = _v; }
public Header header() { return header; }
public void setHeader(Header _v) { _dirty = true; header = _v; }
public List<Record> records() { return records; }
public void setRecords(List<Record> _v) { _dirty = true; records = _v; }
public Wmf _root() { return _root; }
public void set_root(Wmf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}