public static AspectSourceFlags AspectSourceFlags(MetafileReader reader, CommandHeader commandHeader)
{
// ASPECT SOURCE FLAGS: has up to 18 parameter-pairs, corresponding to each attribute that may be
// bundled; each parameter-pair contains the ASF type and the ASF value:
// (enumerated) ASF type; valid values are
// 0 line type ASF
// 1 line width ASF
// 2 line colour ASF
// 3 marker type ASF
// 4 markersizeASF
// 5 marker colour ASF
// 6 text font index ASF
// 7 text precision ASF
// 8 character expansion factor ASF
// 9 character spacing ASF
// 10 text colour ASF
// 11 interior style ASF
// 12 fill colour ASF
// 13 hatch index ASF
// 14 pattern index ASF
// 15 edge type ASF
// 16 edge width ASF
// 17 edge colour ASF
// (enumerated) ASF value; valid values are
// 0 individual
// 1 bundled
var asf = new Dictionary <AspectSourceFlagsType, AspectSourceFlagsValue>();
while (reader.HasMoreData(2))
{
asf[reader.ReadEnum <AspectSourceFlagsType>()] = reader.ReadEnum <AspectSourceFlagsValue>();
}
return(new AspectSourceFlags(asf));
}
public static BeginTileArray BeginTileArray(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (point) position
// P2: (enumerated) cell path direction: valid values are
// 0 0°
// 1 90°
// 2 180°
// 3 270°
// P3: (enumerated) line progression direction: valid values are
// 0 90°
// 1 270°
// P4: (integer) number of tiles in pth direction
// P5: (integer) number of tiles in line direction
// P6: (integer) number of cells/ tile in path direction
// P7: (integer) number of cells/ tile in line direction
// P8: (real) cell size in path direction
// P9: (real) cell size in line direction
// P10: (integer) image offset in path direction
// P11: (integer) image offset in line direction
// P12: (integer) image number of cells in path direction
// P13: (integer) image number of cells in line direction
return(new BeginTileArray(
reader.ReadPoint(),
reader.ReadEnum <CellPathDirection>(),
reader.ReadEnum <LineProgressionDirection>(),
reader.ReadInteger(), reader.ReadInteger(),
reader.ReadInteger(), reader.ReadInteger(),
reader.ReadReal(), reader.ReadReal(),
reader.ReadInteger(), reader.ReadInteger(),
reader.ReadInteger(), reader.ReadInteger()));
}
public static Transparency Transparency(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) on - off indicator: valid values are
// 0 off: auxiliary colour background is required
// 1 on: transparent background is required
return(new Transparency(reader.ReadEnum <OnOffIndicator>()));
}
public static InheritanceFilter InheritanceFilter(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated list) list of one or more of: (list omitted)
// P2: (enumerated) setting: valid values are
// 0 state list
// 1 segment
var items = new List <InheritanceFilterItem>();
while (reader.HasMoreData(4)) // 2 per enum
{
items.Add(new InheritanceFilterItem(
reader.ReadEnum <InheritanceFilterDesignator>(),
reader.ReadEnum <InheritanceFilterSetting>()));
}
return(new InheritanceFilter(items.ToArray()));
}
public static ClipInheritance ClipInheritance(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) clip inheritance: valid values are
// 0 state list
// 1 intersection
return(new ClipInheritance(reader.ReadEnum <ClipInheritanceType>()));
}
public static ColorSelectionMode ColorSelectionMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) colour selection mode:
// 0 indexed colour mode
// 1 direct colour mode
return(new ColorSelectionMode(reader.ReadEnum <ColorModeType>()));
}
public static EdgeVisibility EdgeVisibility(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) edge visibility: valid values are
// 0 off
// 1 on
return(new EdgeVisibility(reader.ReadEnum <OnOffIndicator>()));
}
public static VdcType VdcType(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) VDC TYPE: valid values are
// 0 VDC values specified in integers
// 1 VDC values specified in reals
return(new VdcType(reader.ReadEnum <VdcTypeSpecification>()));
}
public static ClipIndicator ClipIndicator(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) clip indicator: valid values are
// 0 off
// 1 on
return(new ClipIndicator(reader.ReadEnum <OnOffIndicator>()));
}
public static TextPrecision TextPrecision(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) text precision: valid values are
// 0 string
// 1 character
// 2 stroke
return(new TextPrecision(reader.ReadEnum <TextPrecisionType>()));
}
public static Message Message(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) action-required flag: valid values are
// 0 noaction
// 1 action
// P2: (string fixed) message string
return(new Message(reader.ReadEnum <ActionRequired>(), reader.ReadString()));
}
public static SegmentHighlighting SegmentHighlighting(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (name) segment identifier
// P2: (enumerated) highlighting: valid values are
// 0 normal
// 1 highlighted
return(new SegmentHighlighting(reader.ReadName(), reader.ReadEnum <Highlighting>()));
}
public static EdgeClippingMode EdgeClippingMode(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) clipping mode: valid values are
// 0 locus
// 1 shape
// 2 locus then shape
return(new EdgeClippingMode(reader.ReadEnum <ClippingMode>()));
}
public static GeneralizedTextPathMode GeneralizedTextPathMode(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) text path mode: valid values are
// 0 off
// 1 non - tangential
// 2 axis - tangential
return(new GeneralizedTextPathMode(reader.ReadEnum <TextPathMode>()));
}
public static AppendText AppendText(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) final / not - final flag: valid values are
// 0 not final
// 1 final
// P2: (string) text string
return(new AppendText(reader.ReadEnum <FinalFlag>(), reader.ReadString()));
}
public static TextPath TextPath(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) text path: valid values are:
// 0 right
// 1 left
// 2 up
// 3 down
return(new TextPath(reader.ReadEnum <TextPathType>()));
}
public static MarkerSizeSpecificationMode MarkerSizeSpecificationMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) marker size specification mode: valid values are
// 0 absolute
// 1 scaled
// 2 fractional
// 3 mm
return(new MarkerSizeSpecificationMode(reader.ReadEnum <WidthSpecificationModeType>()));
}
public static CharacterCodingAnnouncer CharacterCodingAnnouncer(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) character coding announcer: valid values are
// 0 basic 7 - bit
// 1 basic 8 - bit
// 2 extended 7 - bit
// 3 extended 8 - bit
return(new CharacterCodingAnnouncer(reader.ReadEnum <CharacterCodingAnnouncerType>()));
}
public static ProtectionRegionIndicator ProtectionRegionIndicator(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (index) region index
// P2: (index) region indicator: valid values are
// 1 off
// 2 clip
// 3 shield
return(new ProtectionRegionIndicator(reader.ReadIndex(), reader.ReadEnum <RegionIndicator>()));
}
public static InteriorStyleSpecificationMode InteriorStyleSpecificationMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) valid values are
// 0 absolute
// 1 scaled
// 2 fractional
// 3 mm
return(new InteriorStyleSpecificationMode(reader.ReadEnum <WidthSpecificationModeType>()));
}
public static TextCommand Text(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (point) text position
// P2: (enumerated) final / not - final flag: valid values are
// 0 not final
// 1 final
// P3: (string) text string
return(new TextCommand(reader.ReadPoint(), reader.ReadEnum <FinalFlag>(), reader.ReadString()));
}
public static VdcRealPrecision VdcRealPrecision(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) form of representation for real values: valid values are
// 0 floating point format
// 1 fixed point format
// P2: (integer) field width for exponent or whole part (including 1 bit for sign)
// P3: (integer) field width for fraction or fractional part
return(new VdcRealPrecision(reader.ReadEnum <RealRepresentation>(), reader.ReadInteger(), reader.ReadInteger()));
}
public static EdgeWidthSpecificationMode EdgeWidthSpecificationMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) edge width specification mode: valid values are
// 0 absolute
// 1 scaled
// 2 fractional
// 3 mm
return(new EdgeWidthSpecificationMode(reader.ReadEnum <WidthSpecificationModeType>()));
}
public static TextAlignment TextAlignment(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) horizontal alignment: valid values are:
// 0 normal horizontal
// 1 left
// 2 centre
// 3 right
// 4 continuous horizontal
// P2: (enumerated) vertical alignment
// 0 normal vertical
// 1 top
// 2 cap
// 3 half
// 4 base
// 5 bottom
// 6 continuous vertical
// P3: (real) continuous horizontal alignment
// P4: (real) continuous vertical alignment
return(new TextAlignment(reader.ReadEnum <HorizontalTextAlignment>(), reader.ReadEnum <VerticalTextAlignment>(), reader.ReadReal(), reader.ReadReal()));
}
public static InteriorStyle InteriorStyle(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) interior style: valid values are
// 0 hollow
// 1 solid
// 2 pattern
// 3 hatch
// 4 empty
// 5 geometric pattern
// 6 interpolated
return(new InteriorStyle(reader.ReadEnum <InteriorStyleType>()));
}
public static CopySegment CopySegment(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (name) segment identifier
// P2: The next 6 values are components of a transformation matrix consisting of a scaling and rotation portion
// (2 x 2 R) and a translation portion (2 x 1 VDC). In the binary encoding this is expressed as a 2 x 3 matrix of
// the form:
// a11: (real) x scale component
// a12: (real) x rotation component
// a21: (real) y rotation component
// a22: (real) y scale component
// a13: (vdc) x translation component
// a23: (vdc) y translation component
// P3: (enumerated) segment transformation application: valid values are
// 0: no
// 1: yes
return(new CopySegment(reader.ReadName(), reader.ReadMatrix(), reader.ReadEnum <SegmentTransformationApplication>()));
}
public static CharacterSetList CharacterSetList(MetafileReader reader, CommandHeader commandHeader)
{
// P1: (enumerated) CHARACTER SET TYPE: valid codes are
// 0 94 - character G - set
// 1 96 - character G - set
// 2 94 - character multibyte G-set
// 3 96 - character multibyte G-set
// 4 complete code
// P2: (string fixed) Designation sequence tail; see Part 1, subclause 7.3.14.
var entries = new List <CharacterSetListEntry>();
while (reader.HasMoreData(3)) // enums take up 2 bytes, strings at least 1 byte
{
entries.Add(new CharacterSetListEntry(reader.ReadEnum <CharacterSetType>(), reader.ReadString()));
}
return(new CharacterSetList(entries));
}
public static ScalingMode ScalingMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) scaling mode: valid values are
// 0 abstract scaling
// 1 metric scaling
// P2: (real) metric scaling factor, ignored if P1=0
//
// This parameter is always encoded as floating point, regardless of the value of the fixed/floating flag of
// REAL PRECISION. If a REAL PRECISION (floating, n, m) has preceded, then the precision used is n,m.
// If a REAL PRECISION element for floating point has not preceded, then a default precision of 9,23 (32-bit
// floating point) is used.
int numFloatBytes = 32 / 8;
if (reader.Descriptor.RealPrecision == RealPrecisionSpecification.FloatingPoint64Bit)
{
numFloatBytes = 64 / 8;
}
return(new ScalingMode(reader.ReadEnum <ScalingModeType>(), reader.ReadFloatingPoint(numFloatBytes)));
}
public static PolygonSet PolygonSet(MetafileReader reader, CommandHeader commandHeader)
{
// P(i): (point) (X,Y) polygon vertex
// P(i+1): (enumerated) edge out flag, indicating closures and edge visibility: valid values are
// 0 invisible
// 1 visible
// 2 close, invisible
// 3 close, visible
var points = new List <PointF>();
var flags = new List <EdgeOutFlags>();
// TODO: point is 2 VDCs, but that may range from 8 bits each until up to 64 bits for a single coordinate
// this should probably check for 2x VDC size instead of simply 2x minimum-possible VDC size
while (reader.HasMoreData(3))
{
points.Add(reader.ReadPoint());
flags.Add(reader.ReadEnum <EdgeOutFlags>());
}
return(new PolygonSet(points.ToArray(), flags.ToArray()));
}
public static DeviceViewportSpecificationMode DeviceViewportSpecificationMode(MetafileReader reader, CommandHeader header)
{
// P1: (enumerated) VC specifier: valid values are
// 0 fraction of drawing surface
// 1 millimetres with scale factor
// 2 physical device coordinates
// P2: (real) metric scale factor, ignored if P1=0 or P1=2
//
// This parameter is always encoded as floating point, regardless of the value of the fixed/floating flag of
// REAL PRECISION. If a REAL PRECISION (floating, n, m) has preceded, then the precision used is n,m.
// If a REAL PRECISION element for floating point has not preceded, then a default precision of 9,23 (32-bit
// floating point) is used.
int numFloatBytes = 32 / 8;
if (reader.Descriptor.RealPrecision == RealPrecisionSpecification.FloatingPoint64Bit)
{
numFloatBytes = 64 / 8;
}
return(new DeviceViewportSpecificationMode(reader.ReadEnum <DeviceViewportSpecificationModeType>(), reader.ReadFloatingPoint(numFloatBytes)));
}
