public QuadTreeLodDebugRenderer()
{
this.Visible = true;
this.DrawOrder = 0;
this.tilePatches = new List<PatchDescriptor>();
this.Components.Add(lineBuffer = new LineBuffer(8192));
this.Loading += QuadTreeLodDebugRenderer_Loading;
this.Unloading += QuadTreeLodDebugRenderer_Unloading;
}
private static long WriteToken(byte[] token, int tokenOffset, MimeStringLength tokenLength, System.IO.Stream stream, ref MimeStringLength currentLineLength, ref LineBuffer lineBuffer, ref bool autoAddedLastLWSP, bool allowUTF8)
{
var num1 = 0L;
var flag1 = token != null && tokenLength.InChars == 1 && MimeScan.IsFWSP(token[tokenOffset]);
if (!flag1 && currentLineLength.InChars + lineBuffer.Length.InChars + tokenLength.InChars > 78 && lineBuffer.LengthTillLastLWSP.InBytes >= 0) {
if (lineBuffer.LengthTillLastLWSP.InBytes > 0) {
stream.Write(lineBuffer.Bytes, 0, lineBuffer.LengthTillLastLWSP.InBytes);
num1 += lineBuffer.LengthTillLastLWSP.InBytes;
currentLineLength.IncrementBy(lineBuffer.LengthTillLastLWSP);
}
if (currentLineLength.InBytes > 0)
num1 += Header.WriteLineEnd(stream, ref currentLineLength);
if (autoAddedLastLWSP) {
autoAddedLastLWSP = false;
lineBuffer.LengthTillLastLWSP.IncrementBy(1);
}
if (lineBuffer.LengthTillLastLWSP.InBytes != lineBuffer.Length.InBytes) {
System.Buffer.BlockCopy(lineBuffer.Bytes, lineBuffer.LengthTillLastLWSP.InBytes, lineBuffer.Bytes, 0, lineBuffer.Length.InBytes - lineBuffer.LengthTillLastLWSP.InBytes);
lineBuffer.Length.DecrementBy(lineBuffer.LengthTillLastLWSP);
if (lineBuffer.Length.InBytes > 0 && MimeScan.IsFWSP(lineBuffer.Bytes[0]))
lineBuffer.LengthTillLastLWSP.SetAs(0);
else
lineBuffer.LengthTillLastLWSP.SetAs(-1);
} else {
lineBuffer.Length.SetAs(0);
lineBuffer.LengthTillLastLWSP.SetAs(-1);
}
var flag2 = false;
if (lineBuffer.Length.InBytes > 0) {
if (!MimeScan.IsFWSP(lineBuffer.Bytes[0]))
flag2 = true;
} else if (!flag1)
flag2 = true;
if (flag2) {
stream.Write(LineStartWhitespace, 0, LineStartWhitespace.Length);
num1 += LineStartWhitespace.Length;
currentLineLength.IncrementBy(LineStartWhitespace.Length);
}
}
if (currentLineLength.InBytes + lineBuffer.Length.InBytes + tokenLength.InBytes > 998) {
if (lineBuffer.Length.InBytes > 0) {
stream.Write(lineBuffer.Bytes, 0, lineBuffer.Length.InBytes);
num1 += lineBuffer.Length.InBytes;
currentLineLength.IncrementBy(lineBuffer.Length);
lineBuffer.Length.SetAs(0);
autoAddedLastLWSP = false;
lineBuffer.LengthTillLastLWSP.SetAs(-1);
}
if (token != null) {
while (currentLineLength.InBytes + tokenLength.InBytes > 998) {
var num2 = System.Math.Max(0, 998 - currentLineLength.InBytes);
var countInChars = 0;
var num3 = 0;
if (allowUTF8) {
var num4 = 0;
while (num4 < tokenLength.InBytes) {
var num5 = token[tokenOffset + num4];
var bytesUsed = 1;
if (num5 >= 128 && !MimeScan.IsUTF8NonASCII(token, tokenOffset + num4, tokenOffset + tokenLength.InBytes, out bytesUsed))
bytesUsed = 1;
if (num3 + bytesUsed <= num2) {
++countInChars;
num3 += bytesUsed;
num4 += bytesUsed;
} else
break;
}
} else {
countInChars = num2;
num3 = num2;
}
stream.Write(token, tokenOffset, num3);
var num6 = num1 + num3;
currentLineLength.IncrementBy(countInChars, num3);
tokenOffset += num3;
tokenLength.DecrementBy(countInChars, num3);
num1 = num6 + Header.WriteLineEnd(stream, ref currentLineLength);
if (!flag1) {
stream.Write(LineStartWhitespace, 0, LineStartWhitespace.Length);
num1 += LineStartWhitespace.Length;
currentLineLength.IncrementBy(LineStartWhitespace.Length);
}
}
}
}
if (token != null) {
System.Buffer.BlockCopy(token, tokenOffset, lineBuffer.Bytes, lineBuffer.Length.InBytes, tokenLength.InBytes);
if (flag1 && (lineBuffer.Length.InBytes == 0 || !MimeScan.IsFWSP(lineBuffer.Bytes[lineBuffer.Length.InBytes - 1]))) {
autoAddedLastLWSP = false;
lineBuffer.LengthTillLastLWSP.SetAs(lineBuffer.Length);
}
lineBuffer.Length.IncrementBy(tokenLength);
}
return num1;
}
internal static long QuoteAndFold(
System.IO.Stream stream, MimeStringList fragments, uint inputMask, bool quoteOutput, bool addSpaceAtStart, bool allowUTF8, int lastLineReserve, ref MimeStringLength currentLineLength, ref byte[] scratchBuffer)
{
var num = 0L;
var lineBuffer = new LineBuffer();
lineBuffer.Length = new MimeStringLength(0);
lineBuffer.LengthTillLastLWSP = new MimeStringLength(-1);
if (scratchBuffer == null || scratchBuffer.Length < 998)
scratchBuffer = new byte[998];
lineBuffer.Bytes = scratchBuffer;
var token = quoteOutput ? MimeScan.Token.Spec | MimeScan.Token.Fwsp : MimeScan.Token.Fwsp;
var autoAddedLastLWSP = false;
if (addSpaceAtStart && currentLineLength.InBytes != 0) {
num += Header.WriteToken(Space, 0, new MimeStringLength(1), stream, ref currentLineLength, ref lineBuffer, ref autoAddedLastLWSP, allowUTF8);
autoAddedLastLWSP = true;
}
if (quoteOutput)
num += Header.WriteToken(DoubleQuote, 0, new MimeStringLength(1), stream, ref currentLineLength, ref lineBuffer, ref autoAddedLastLWSP, allowUTF8);
for (var index = 0; index < fragments.Count; ++index) {
var mimeString = fragments[index];
var offset = 0;
var count = 0;
var data = mimeString.GetData(out offset, out count);
if (((int) mimeString.Mask & (int) inputMask) != 0) {
do {
var characterCount = 0;
var nextOf = MimeScan.FindNextOf(token, data, offset, count, out characterCount, allowUTF8);
if (nextOf > 0) {
num += Header.WriteToken(data, offset, new MimeStringLength(characterCount, nextOf), stream, ref currentLineLength, ref lineBuffer, ref autoAddedLastLWSP, allowUTF8);
offset += nextOf;
count -= nextOf;
}
if (count != 0) {
switch (data[offset]) {
case 34:
case 92:
if (((int) mimeString.Mask & -536870913) != 0) {
num += Header.WriteToken(
new byte[2] {
92,
data[offset]
},
0,
new MimeStringLength(2),
stream,
ref currentLineLength,
ref lineBuffer,
ref autoAddedLastLWSP,
allowUTF8);
++offset;
--count;
goto label_15;
}
break;
}
num += Header.WriteToken(
new byte[1] {
data[offset]
},
0,
new MimeStringLength(1),
stream,
ref currentLineLength,
ref lineBuffer,
ref autoAddedLastLWSP,
allowUTF8);
++offset;
--count;
}
label_15:
;
} while (count != 0);
}
}
if (quoteOutput)
num += Header.WriteToken(DoubleQuote, 0, new MimeStringLength(1), stream, ref currentLineLength, ref lineBuffer, ref autoAddedLastLWSP, allowUTF8);
if (lastLineReserve > 0)
num += Header.WriteToken(null, 0, new MimeStringLength(lastLineReserve), stream, ref currentLineLength, ref lineBuffer, ref autoAddedLastLWSP, allowUTF8);
if (lineBuffer.Length.InBytes > 0) {
stream.Write(lineBuffer.Bytes, 0, lineBuffer.Length.InBytes);
num += lineBuffer.Length.InBytes;
currentLineLength.IncrementBy(lineBuffer.Length);
}
return num;
}
/// <summary>
/// Initializes a new instance of the <see cref="Scanner"/> class.
/// </summary>
/// <param name="inp">The input text reader.</param>
/// <param name="prompt">The prompt.</param>
internal Scanner(TextReader inp, string prompt)
{
this.inp = inp;
this.lineBuffer = new LineBuffer(inp, prompt);
}
/// <summary>
/// Implements IDebugOutputCallbacks2::Output2
/// </summary>
public int Output2(DEBUG_OUTCB Which, DEBUG_OUTCBF Flags, UInt64 Arg, string Text)
{
var mask = (DEBUG_OUTPUT)Arg;
if (Which == DEBUG_OUTCB.EXPLICIT_FLUSH)
{
//Flush();
return(S_OK);
}
if (string.IsNullOrEmpty(Text))
{
return(S_OK);
}
bool textIsDml = (Which == DEBUG_OUTCB.DML);
if (OutputActive)
{
lock (this)
{
OutputActive = false;
PreviousTextWasDml = textIsDml;
PreviousDmlFlags = Flags;
DbgStringBuilder LineBuffer;
LineBuffers.TryGetValue(mask, out LineBuffer);
int LineInputPos = 0;
LineInputPositions.TryGetValue(mask, out LineInputPos);
bool waitForClosingDML = false;
if (LineBuffer == null)
{
LineBuffer = new DbgStringBuilder(ExecutionUtilities, 1024);
LineBuffers[mask] = LineBuffer;
}
for (int i = 0; i < Text.Length; ++i)
{
char c = Text[i];
if (c == '<')
{
waitForClosingDML = true;
}
if (waitForClosingDML)
{
if (c == '>')
{
waitForClosingDML = false;
}
}
if (c == '\n' && waitForClosingDML == false)
{
LineBuffer.AppendLine();
ProcessLine(mask, LineBuffer.ToString(), textIsDml, Flags);
LineBuffer.Clear();
LineInputPos = 0;
}
else if (c == '\r')
{
LineInputPos = 0;
}
else
{
if (LineInputPos >= LineBuffer.Length)
{
LineBuffer.Append(c);
}
else
{
LineBuffer[LineInputPos] = c;
}
++LineInputPos;
}
}
LineInputPositions[mask] = LineInputPos;
OutputActive = true;
}
}
return(S_OK);
}
public static bool ContainsLine(
this TextRange textRange,
LineBuffer lineBuffer,
int lineIndex,
out CharacterPosition beginCharacterPosition,
out CharacterPosition endCharacterPosition)
{
// If this is a single line, short cut the processing.
TextPosition firstTextPosition = textRange.FirstTextPosition;
TextPosition lastTextPosition = textRange.LastTextPosition;
int firstLineIndex = firstTextPosition.LinePosition.GetLineIndex(lineBuffer);
if (textRange.IsSameLine)
{
if (firstLineIndex == lineIndex)
{
beginCharacterPosition = firstTextPosition.CharacterPosition;
endCharacterPosition = lastTextPosition.CharacterPosition;
return(true);
}
beginCharacterPosition = CharacterPosition.Begin;
endCharacterPosition = CharacterPosition.End;
return(false);
}
// Figure out the line range index and see if the given line is with
// the range.
int lastLineIndex = lastTextPosition.LinePosition.GetLineIndex(lineBuffer);
if (lineIndex < firstLineIndex ||
lineIndex > lastLineIndex)
{
beginCharacterPosition = CharacterPosition.Begin;
endCharacterPosition = CharacterPosition.Begin;
return(false);
}
// If the line is the same, we just use the same line.
if (firstLineIndex == lastLineIndex)
{
beginCharacterPosition = firstTextPosition.CharacterPosition;
endCharacterPosition = lastTextPosition.CharacterPosition;
return(true);
}
// We have at least one additional line. If we are on the first,
// then it is everything to the right of the starting.
if (firstLineIndex == lineIndex)
{
beginCharacterPosition = firstTextPosition.CharacterPosition;
endCharacterPosition = CharacterPosition.End;
return(true);
}
// If we are on the last line, then it is everything before the index.
if (lastLineIndex == lineIndex)
{
beginCharacterPosition = CharacterPosition.Begin;
endCharacterPosition = lastTextPosition.CharacterPosition;
return(true);
}
// In all other cases, it is the entire line.
beginCharacterPosition = CharacterPosition.Begin;
endCharacterPosition = CharacterPosition.End;
return(true);
}
public unsafe void DrawBeamApp(PolylineRender poly, LineBuffer points, float globalTime, NodeReference reference, ParticleEffectInstance instance, ResourceManager res, Billboards billboards, ref Matrix4 transform, float sparam)
{
//TODO: Cross-plane not showing
//TODO: In some cases particles are going backwards? (Broken emitter or LineBuffer)
//TODO: See if z sorting can be better for Polyline
//TODO: Implement FLBeamAppearance properties
if (points.Count() < 2)
{
return;
}
//Get only active indices, alloc on stack for 0 GC pressure
//int* indices = stackalloc int[512];
var indices = new int[512];
var particles = new Particle[512];
for (int i = 0; i < 512; i++)
{
indices[i] = -1;
}
int ptCount = 0;
for (int i = 0; i < points.Count(); i++)
{
if (points[i].Active)
{
indices[ptCount++] = points[i].ParticleIndex;
}
}
if (ptCount < 2)
{
return;
}
for (int i = 0; i < ptCount; i++)
{
particles[i] = instance.Particles[indices[i]];
}
for (int i = 1; i < ptCount; i++)
{
if (particles[i - 1].TimeAlive > particles[i].TimeAlive)
{
Console.WriteLine("bad order");
}
}
var node_tr = GetAttachment(reference, transform);
Texture2D tex;
Vector2 tl, tr, bl, br;
HandleTexture(res, globalTime, sparam, ref instance.Particles[indices[0]], out tex, out tl, out tr, out bl, out br);
//Sorting hack kinda
var z = RenderHelpers.GetZ(billboards.Camera.Position, node_tr.Transform(Vector3.Zero));
for (int j = 0; j < 2; j++) //two planes
{
poly.StartLine(tex, BlendInfo);
bool odd = true;
Vector3 dir = Vector3.Zero;
for (int i = 0; i < ptCount; i++)
{
var pos = node_tr.Transform(instance.Particles[indices[i]].Position);
if (i + 1 < ptCount)
{
var pos2 = node_tr.Transform(instance.Particles[indices[i + 1]].Position);
var forward = (pos2 - pos).Normalized();
var toCamera = (billboards.Camera.Position - pos).Normalized();
var up = Vector3.Cross(toCamera, forward);
up.Normalize();
dir = up;
if (j == 1)
{
//Broken? Doesn't show up
var right = Vector3.Cross(up, forward).Normalized();
dir = right;
}
}
var time = instance.Particles[indices[i]].TimeAlive / instance.Particles[indices[i]].LifeSpan;
var w = Width.GetValue(sparam, time);
poly.AddPoint(
pos + (dir * w / 2),
pos - (dir * w / 2),
odd ? tl : bl,
odd ? tr : br,
new Color4(
Color.GetValue(sparam, time),
Alpha.GetValue(sparam, time)
)
);
odd = !odd;
}
poly.FinishLine(z);
}
}
private void openPGMfile(int fileNumber)
{
if (fileNumber == 0)
{
CurrentFilePath = open.FileNames[0].ToString(); //Пътят до файла;
}
else if (fileNumber == 1)
{
CurrentFilePath = open.FileNames[1].ToString(); //Пътят до файла;
}
StreamReader ImageStreamReader = new StreamReader(CurrentFilePath);
String LineBuffer;
//за запаметяване размерите на изображението дължина и ширина
String[] ExtractDimension;
PurgeGlobalData(); //Функция за нулиране на променливите, които се инизиализират в началото,
// използват се в случай, че се отвори следваща картинка;
LineBuffer = "#"; //Проверка дали файлът не започва с коментар "#";
do
{
LineBuffer = ImageStreamReader.ReadLine();
} while (LineBuffer.StartsWith("#"));
// Проверка дали файлът започва с подходяща информация за форматът си в
// противен случай се извежда подходящо съобщение
if (LineBuffer.StartsWith("P2"))
{
ImageType = "P2";
}
else
{
ImageStreamReader.Close();
MessageBox.Show("File error!");
PurgeGlobalData();
}
//Проверка за други коментари в файла и прочитане на размерите за изображението
LineBuffer = "#";
do
{
LineBuffer = ImageStreamReader.ReadLine();
} while (LineBuffer.StartsWith("#"));
// Прочетените размери на изображението се запаметяват в масива ExtractDimensions
// след което стойностите им се преобразуват в целочислен вид и се предават на
// Bitmap изображението
ExtractDimension = LineBuffer.Split(' ');
ImageHeight = int.Parse(ExtractDimension[1]);
finalImageHeight = ImageHeight;
ImageWidth = int.Parse(ExtractDimension[0]);
finalImageWidth = ImageWidth;
CurrentBitmap = new Bitmap(ImageWidth, ImageHeight);
CurrentBitmap2 = new Bitmap(ImageWidth, ImageHeight);
FinalBitmap = new Bitmap(finalImageWidth, finalImageHeight);
// Ако файлът започва с правилната първоначална информация "P2", прочитат се
// стойностите за сивия цвят от него, преобразуват се в целочислен вид и
// се предават на променливата ImageMaxGreyValue;
if (ImageType == "P2")
{
LineBuffer = "#";
do
{
LineBuffer = ImageStreamReader.ReadLine();
} while (LineBuffer.StartsWith("#"));
ImageMaxGreyValue = int.Parse(LineBuffer);
}
if (fileNumber == 0)
{
CurrentFile = ImageStreamReader.ReadToEnd();
CurrentFile = CurrentFile.Replace("\r", " ");
CurrentFile = CurrentFile.Replace("\n", " ");
}
else if (fileNumber == 1)
{
CurrentFile2 = ImageStreamReader.ReadToEnd();
CurrentFile2 = CurrentFile2.Replace("\r", " ");
CurrentFile2 = CurrentFile2.Replace("\n", " ");
}
//Затваряне на входния поток и извикане на функцията за изобразяване BiuldCanvas()
ImageStreamReader.Close();
if (fileNumber == 0)
{
BuildCanvas(0);
}
else if (fileNumber == 1)
{
BuildCanvas(1);
}
}
/// <inheritdoc />
/// <summary>
/// This section when called will read the data that is contained in
/// the list that was passed in from the constructor.
/// </summary>
public override void ReadSection()
{
// Iterate through the list of tagged data
for (var currentIndex = StartIndex;
currentIndex < DataList.Length;
++currentIndex)
{
// set the current data
var currentData = DataList.GetPair(currentIndex);
// Set the ending index of the file and break out of the loop
if (currentData.GroupCode == GroupCodesBase.EndSectionMarker)
{
EndIndex = currentIndex;
break;
}
// The master switch for the values
switch (currentData.Value)
{
/*
* All Entities Cases will follow the same formula:
* 1. Create a new Buffer class
* 2. pass the Data list to the buffer class with the starting
* index of the entity.
* 3. Add the entity to the entity list
*/
// LINE
case LineGroupCodes.StartMarker:
var lineBuffer = new LineBuffer();
lineBuffer.Parse(DataList, currentIndex);
Entities.Add(new Line(lineBuffer));
continue;
// LWPOLYLINE
case LwPolylineCodes.StartMarker:
var lwPolyLineBuffer = new LwPolyLineBuffer();
lwPolyLineBuffer.Parse(DataList, currentIndex);
Entities.Add(new LwPolyLine(lwPolyLineBuffer));
continue;
// HATCH
case HatchCodes.StartMarker:
var hatchBuffer = new HatchBuffer();
hatchBuffer.Parse(DataList, currentIndex);
Entities.Add(new Hatch(hatchBuffer));
continue;
// ARC
case CircularArcCodes.ArcStartMarker:
var arcBuffer = new CircularArcBuffer();
arcBuffer.Parse(DataList, currentIndex);
Entities.Add(new CircularArc(arcBuffer));
continue;
// TEXT
case TextCodes.StartMarker:
var textBuffer = new TextBuffer();
textBuffer.Parse(DataList, currentIndex);
Entities.Add(new Text(textBuffer));
continue;
// MTEXT
case MTextCodes.StartMarker:
var mTextBuffer = new MTextBuffer();
mTextBuffer.Parse(DataList, currentIndex);
Entities.Add(new MText(mTextBuffer));
continue;
// POINT
case PointCodes.StartMarker:
var pointBuffer = new PointBuffer();
pointBuffer.Parse(DataList, currentIndex);
Entities.Add(new Point(pointBuffer));
continue;
// CIRCLE
case CircularArcCodes.CircleStartMarker:
var circleBuffer = new CircularArcBuffer();
circleBuffer.Parse(DataList, currentIndex);
Entities.Add(new Circle(circleBuffer));
break;
// DEFAULT
default:
continue;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CachedTextRenderer"/> class.
/// </summary>
/// <param name="displayContext">The display context.</param>
/// <param name="lineBuffer">The line buffer.</param>
public CachedTextRenderer(
IDisplayContext displayContext,
LineBuffer lineBuffer)
: this(displayContext, new LineBufferRenderer(displayContext, lineBuffer))
{
}
public static void Copy(EditorViewController controller)
{
// If we don't have anything selected, we don't do anything.
IDisplayContext displayContext = controller.DisplayContext;
TextRange selection = displayContext.Caret.Selection;
if (selection.IsEmpty)
{
return;
}
// Go through the selection and figure out if we have a single-line
// copy.
LineBuffer lineBuffer = displayContext.LineBuffer;
int startLineIndex = selection.FirstLinePosition.GetLineIndex(lineBuffer);
int endLineIndex = selection.LastLinePosition.GetLineIndex(lineBuffer);
string firstLine = lineBuffer.GetLineText(
selection.FirstLinePosition, LineContexts.Unformatted);
if (endLineIndex == startLineIndex)
{
// Single-line copy is much easier since we just need a substring.
int startCharacterIndex =
selection.FirstTextPosition.GetCharacterIndex(lineBuffer);
int endCharacterIndex =
selection.FirstTextPosition.GetCharacterIndex(lineBuffer);
string singleLineText = firstLine.Substring(
startCharacterIndex, endCharacterIndex - startCharacterIndex);
// Set the clipboard's text and return.
displayContext.Clipboard.Text = singleLineText;
return;
}
// For multiple line copies, we need to copy every line from the first
// to the last. We already have the first, so just copy that.
var buffer = new StringBuilder();
int firstLineIndex =
selection.FirstTextPosition.CharacterPosition.GetCharacterIndex(firstLine);
buffer.Append(firstLine.Substring(firstLineIndex));
buffer.Append("\n");
// Loop through the second to just shy of the last line, adding
// each one as a full line.
for (int lineIndex = startLineIndex + 1;
lineIndex < endLineIndex;
lineIndex++)
{
buffer.Append(lineBuffer.GetLineText(lineIndex, LineContexts.Unformatted));
buffer.Append("\n");
}
// Add the last line, which is a substring, but we don't add a
// newline to the end of this one.
string lastLineText = lineBuffer.GetLineText(
endLineIndex, LineContexts.Unformatted);
int lastCharacterIndex =
selection.EndCharacterPosition.GetCharacterIndex(lastLineText);
buffer.Append(lastLineText.Substring(0, lastCharacterIndex));
// Set the clipboard value.
displayContext.Clipboard.Text = buffer.ToString();
}
/// <summary> /// Sets the line buffer since the renderer. /// </summary> /// <param name="value">The value.</param> public abstract void SetLineBuffer(LineBuffer value);
internal UidWriter(UidCollector collector, Stream source, Stream target)
{
_collector = collector;
_sourceReader = new StreamReader(source);
UTF8Encoding encoding = new UTF8Encoding(true);
_targetWriter = new StreamWriter(target, encoding);
_lineBuffer = new LineBuffer(_sourceReader.ReadLine());
}
public void TestEmptyLineWidth()
{
var l = new LineBuffer(null);
Assert.IsFalse(l.Match("bogus"));
}
public void EnumerateMetafile(Stream emf, float unitSize, PointF destination, DrawLineDelegate drawLine, FillPolygonDelegate fillPolygon)
{
Transform = new Matrix();
_drawLine = drawLine;
_fillPolygon = fillPolygon;
_zero = destination;
_lineBuffer = new LineBuffer(unitSize);
_objects = new System.Collections.Generic.Dictionary<uint, ObjectHandle>();
_brush = null;
using (var reader = new EmfTools.EmfReader(emf))
{
while (!reader.IsEndOfFile)
{
var record = reader.Read() as EmfTools.EmfUnknownRecord;
if (record == null)
continue;
switch (record.RecordType)
{
case EmfPlusRecordType.EmfHeader:
case EmfPlusRecordType.EmfEof:
case EmfPlusRecordType.EmfSaveDC:
case EmfPlusRecordType.EmfDeleteObject:
case EmfPlusRecordType.EmfExtCreatePen:
case EmfPlusRecordType.EmfCreatePen:
case EmfPlusRecordType.EmfRestoreDC:
case EmfPlusRecordType.EmfSetIcmMode:
case EmfPlusRecordType.EmfSetMiterLimit:
case EmfPlusRecordType.EmfSetPolyFillMode:
// Harmless records with no significant side-effects on the shape of the drawn outline
break;
case EmfPlusRecordType.EmfSelectObject:
ProcessSelectObject(record.Data);
break;
case EmfPlusRecordType.EmfCreateBrushIndirect:
ProcessCreateBrushIndirect(record.Data);
break;
case EmfPlusRecordType.EmfBeginPath:
ProcessBeginPath(record.Data);
break;
case EmfPlusRecordType.EmfEndPath:
// TODO:
break;
case EmfPlusRecordType.EmfStrokeAndFillPath:
ProcessStrokeAndFillPath(record.Data);
break;
case EmfPlusRecordType.EmfMoveToEx:
ProcessMoveToEx(record.Data);
break;
case EmfPlusRecordType.EmfModifyWorldTransform:
ProcessModifyWorldTransform(record.Data);
break;
case EmfPlusRecordType.EmfPolygon16:
ProcessPolygon16(record.Data);
break;
case EmfPlusRecordType.EmfPolyPolygon16:
ProcessPolyPolygon16(record.Data);
break;
case EmfPlusRecordType.EmfPolyline16:
ProcessPolyline16(record.Data);
break;
case EmfPlusRecordType.EmfPolylineTo16:
ProcessPolylineTo16(record.Data);
break;
case EmfPlusRecordType.EmfCloseFigure:
ProcessCloseFigure(record.Data);
break;
case EmfPlusRecordType.EmfPolyBezierTo16:
ProcessPolyBezierTo16(record.Data);
break;
default:
throw new NotImplementedException();
}
}
}
CommitLine();
}
