CopyTo() public méthode

Copy the valid data section of 'this' to the destination BufferChunk overwriting dest's previous contents This method does not allow dest's valid data section to grow or shrink (i.e. treat valid data as a fixed buffer)
public CopyTo ( BufferChunk destination, int index ) : void
destination BufferChunk BufferChunk
index int offset in the destination BufferChunk's valid data
Résultat void
        public virtual void ReceiveData(BufferChunk aRecord)
        {
            // First read out the record type
            int recordType = aRecord.NextInt32();

            Console.WriteLine("SpaceCommandDecoder.ReceiveData: {0}", recordType);

            switch (recordType)
            {
                case SpaceControlChannel.SC_CreateSurface:
                    {
                        Guid uniqueID = CodecUtils.UnpackGuid(aRecord);
                        int x = aRecord.NextInt32();
                        int y = aRecord.NextInt32();
                        int width = aRecord.NextInt32();
                        int height = aRecord.NextInt32();

                        OnCreateSurface("title",new RECT(x,y,width,height), uniqueID);
                    }
                    break;

                case SpaceControlChannel.SC_InvalidateSurfaceRect:
                    {
                        Guid uniqueID = CodecUtils.UnpackGuid(aRecord);
                        int x = aRecord.NextInt32();
                        int y = aRecord.NextInt32();
                        int width = aRecord.NextInt32();
                        int height = aRecord.NextInt32();

                        OnInvalidateSurfaceRect(uniqueID, new RECT(x, y, width, height));
                    }
                    break;

                case SpaceControlChannel.SC_MouseEvent:
                    {
                        Guid sourceID = CodecUtils.UnpackGuid(aRecord);
                        uint mouseID = aRecord.NextUInt32();
                        MouseEventType eventType = (MouseEventType)aRecord.NextInt32();
                        MouseButtons buttons = (MouseButtons)aRecord.NextInt32();
                        int x = aRecord.NextInt32();
                        int y = aRecord.NextInt32();
                        int clicks = aRecord.NextInt32();
                        int delta = aRecord.NextInt32();

                        MouseEventArgs args = new MouseEventArgs(mouseID, eventType, buttons, clicks, x, y, delta, sourceID);
                        
                        OnMouseActivity(this, args);
                    }
                    break;

                case SpaceControlChannel.SC_KeyboardEvent:
                    break;

                //case SpaceControlChannel.SC_BitBlt:
                //  {
                //    // Get the X, Y
                //    int x = aRecord.NextInt32();
                //    int y = aRecord.NextInt32();
                //    int width = aRecord.NextInt32();
                //    int height = aRecord.NextInt32();

                //    // Now create a pixbuff on the specified size
                //    PixelBuffer pixBuff = new PixelBuffer(width, height);
                //    int dataSize = aRecord.NextInt32();

                //    // Copy the received data into it right pixel data pointer
                //    aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);

                //    // And finally, call the BitBlt function
                //    OnBitBlt(x,y,pixBuff);
                //}
                //  break;

                case SpaceControlChannel.SC_CopyPixels:
                  {
                      // Get the X, Y
                      int x = aRecord.NextInt32();
                      int y = aRecord.NextInt32();
                      int width = aRecord.NextInt32();
                      int height = aRecord.NextInt32();

                      // Now create a pixbuff on the specified size
                      PixelBuffer pixBuff = new PixelBuffer(width, height);
                      int dataSize = aRecord.NextInt32();

                      // Copy the received data into it right pixel data pointer
                      aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);

                      // And finally, call the BitBlt function
                      OnCopyPixels(x, y, width, height, pixBuff);
                  }
                  break;

                case SpaceControlChannel.SC_AlphaBlend:
                {
                    // Get the X, Y
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    int srcX = aRecord.NextInt32();
                    int srcY = aRecord.NextInt32();
                    int srcWidth = aRecord.NextInt32();
                    int srcHeight = aRecord.NextInt32();

                    byte alpha = aRecord.NextByte();

                    // Now create a pixbuff on the specified size
                    int buffWidth = aRecord.NextInt32();
                    int buffHeight = aRecord.NextInt32();
                    PixelBuffer pixBuff = new PixelBuffer(buffWidth, buffHeight);
                    int dataSize = aRecord.NextInt32();

                    // Copy the received data into it right pixel data pointer
                    aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);

                    // And finally, call the BitBlt function
                    OnAlphaBlend(x,y,width,height, pixBuff,srcX,srcY, srcWidth,srcHeight,alpha);
                }
                    break;

                case SpaceControlChannel.SC_ScaleBitmap:
                    break;

                case SpaceControlChannel.SC_None:
                default:
                    break;
            }
        }
    public virtual void ReceiveData(BufferChunk aRecord)
    {
        // First read out the record type
        int recordType = aRecord.NextInt32();

        // Then deserialize the rest from there
        switch (recordType)
        {
            case GDI32.EMR_HEADER:
                break;

            // Transform related
            case GDI32.EMR_SCALEVIEWPORTEXTEX:
            case GDI32.EMR_SCALEWINDOWEXTEX:
                break;

            case GDI32.EMR_SETWINDOWEXTEX:
                {
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    SetWindowExtent(width, height);
                }
                break;

            case GDI32.EMR_SETWINDOWORGEX:
                {
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();

                    SetWindowOrigin(x, y);
                }
                break;

            case GDI32.EMR_SETVIEWPORTEXTEX:
                {
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    SetViewportExtent(width, height);
                }
                break;

            case GDI32.EMR_SETVIEWPORTORGEX:
                {
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    
                    SetViewportOrigin(x, y);
                }
                break;

            case GDI32.EMR_SETWORLDTRANSFORM:
            case GDI32.EMR_MODIFYWORLDTRANSFORM:
                break;

            case GDI32.EMR_SETBRUSHORGEX:
                break;

            case GDI32.EMR_EOF:
                Flush();
                break;

            case GDI32.EMR_SETPIXELV:
                {
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    UInt32 colorref = aRecord.NextUInt32();

                    SetPixel(x, y, colorref);
                }
                break;

            case GDI32.EMR_SETMAPPERFLAGS:
                break;

            case GDI32.EMR_SETPOLYFILLMODE:
                SetPolyFillMode(aRecord.NextInt32());
                break;

            case GDI32.EMR_SETSTRETCHBLTMODE:
                break;

            case GDI32.EMR_SETMAPMODE:
                MappingModes aMode = (MappingModes)aRecord.NextInt32();
                SetMappingMode(aMode);
                break;


            case GDI32.EMR_SETTEXTCOLOR:
                SetTextColor(aRecord.NextUInt32());
                break;

            case GDI32.EMR_SETBKCOLOR:
                SetBkColor(aRecord.NextUInt32());
                break;

            case GDI32.EMR_SETDCBRUSHCOLOR:
                SetDefaultBrushColor(aRecord.NextUInt32());
                break;

            case GDI32.EMR_SETDCPENCOLOR:
                SetDefaultPenColor(aRecord.NextUInt32());
                break;

            case GDI32.EMR_SETBKMODE:
                SetBkMode(aRecord.NextInt32());
                break;

            case GDI32.EMR_SETROP2:
                SetROP2((BinaryRasterOps)aRecord.NextInt32());
                break;

            case GDI32.EMR_SETTEXTALIGN:
            case GDI32.EMR_SETCOLORADJUSTMENT:
                break;

            case GDI32.EMR_MOVETOEX:
                MoveTo(aRecord.NextInt32(), aRecord.NextInt32());
                break;

            case GDI32.EMR_OFFSETCLIPRGN:
            case GDI32.EMR_SETMETARGN:
            case GDI32.EMR_EXCLUDECLIPRECT:
            case GDI32.EMR_INTERSECTCLIPRECT:
                break;

            case GDI32.EMR_SAVEDC:
                SaveState();
                break;

            case GDI32.EMR_RESTOREDC:
                RestoreState(aRecord.NextInt32());
                break;

                // Creates a generic pen of any style
            case GDI32.EMR_CREATEPEN:
                {
                    int aStyle = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    uint colorref = aRecord.NextUInt32();
                    Guid uniqueID = this.UnpackGuid(aRecord);
                    CreateCosmeticPen((PenStyle)aStyle, colorref, uniqueID);
                }
                break;

            case GDI32.EMR_CREATECOSMETICPEN:
                {
                    int aStyle = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    uint colorref = aRecord.NextUInt32();
                    Guid uniqueID = this.UnpackGuid(aRecord);
                    CreateCosmeticPen((PenStyle)aStyle, colorref, uniqueID);
                }
                break;


            case GDI32.EMR_CREATEBRUSHINDIRECT:
                {
                    int aStyle = aRecord.NextInt32();   // chunk += aStyle;
                    int hatch = aRecord.NextInt32(); // chunk += hatch;
                    uint color = aRecord.NextUInt32(); // chunk += color;

                    Guid uniqueID = this.UnpackGuid(aRecord);
                    CreateBrush(aStyle, hatch, color, uniqueID);
                }
                break;

            case GDI32.EMR_SELECTOBJECT:
                break;

            case GDI32.EMR_DELETEOBJECT:
                break;

            case GDI32.EMR_SELECTSTOCKOBJECT:
                SelectStockObject(aRecord.NextInt32());
                break;

            case GDI32.EMR_SELECTUNIQUEOBJECT:
                {
                    Guid uniqueID = this.UnpackGuid(aRecord);
                    SelectUniqueObject(uniqueID);
                }
                break;

            case GDI32.EMR_ELLIPSE:
                {
                    int left = aRecord.NextInt32();
                    int top = aRecord.NextInt32();
                    int right = aRecord.NextInt32();
                    int bottom = aRecord.NextInt32();

                    Ellipse(left, top, right, bottom);
                }
                break;

            case GDI32.EMR_ROUNDRECT:
                {
                    int left = aRecord.NextInt32();
                    int top = aRecord.NextInt32();
                    int right = aRecord.NextInt32();
                    int bottom = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    RoundRect(left, top, right, bottom, width, height);
                }
                break;

            case GDI32.EMR_RECTANGLE:
                {
                    int left = aRecord.NextInt32();
                    int top = aRecord.NextInt32();
                    int right = aRecord.NextInt32();
                    int bottom = aRecord.NextInt32();

                    Rectangle(left, top, right, bottom);
                }
                break;

            case GDI32.EMR_GRADIENTFILL:    // Only rectangles at the moment
                {
                    // Unpack the vertices
                    TRIVERTEX[] pVertex = this.UnpackTRIVERTEX(aRecord);

                    // unpack the gradient mesh
                    GRADIENT_RECT[] pMesh = UnpackGRADIENT_RECT(aRecord);

                    // pack the mode
                    uint dwMode = aRecord.NextUInt32();

                    this.GradientRectangle(pVertex, pMesh, dwMode);
                }
                break;

            case GDI32.EMR_ARC:
            case GDI32.EMR_ARCTO:
            case GDI32.EMR_ANGLEARC:
            case GDI32.EMR_CHORD:
            case GDI32.EMR_PIE:
                break;

            case GDI32.EMR_SELECTPALETTE:
            case GDI32.EMR_CREATEPALETTE:
            case GDI32.EMR_SETPALETTEENTRIES:
            case GDI32.EMR_RESIZEPALETTE:
            case GDI32.EMR_REALIZEPALETTE:
                break;

            case GDI32.EMR_LINETO:
                LineTo(aRecord.NextInt32(), aRecord.NextInt32());
                break;

            case GDI32.EMR_EXTFLOODFILL:
                break;

            case GDI32.EMR_POLYDRAW:
                //EMRPOLYDRAW polydraw = (EMRPOLYDRAW)aRecord;
                //fRenderer.PolyDraw(polydraw.aptl, polydraw.abTypes);
                break;

            case GDI32.EMR_SETARCDIRECTION:
            case GDI32.EMR_SETMITERLIMIT:
                break;

            case GDI32.EMR_BEGINPATH:
                BeginPath();
                break;

            case GDI32.EMR_ENDPATH:
                EndPath();
                break;

            case GDI32.EMR_FILLPATH:
                FillPath();
                break;

            case GDI32.EMR_STROKEANDFILLPATH:
                DrawPath();
                break;

            case GDI32.EMR_STROKEPATH:
                FramePath();
                break;

            case GDI32.EMR_ABORTPATH:
            case GDI32.EMR_FLATTENPATH:
            case GDI32.EMR_WIDENPATH:
                break;

            case GDI32.EMR_CLOSEFIGURE:

            case GDI32.EMR_SELECTCLIPPATH:
                break;

            case GDI32.EMR_BITBLT:
                {
                    // Get the X, Y
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    // Now create a pixbuff on the specified size
                    PixelBuffer pixBuff = new PixelBuffer(width, height);
                    int dataSize = aRecord.NextInt32();

                    // Copy the received data into it right pixel data pointer
                    aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);

                    // And finally, call the BitBlt function
                    BitBlt(x,y,pixBuff);
                }
                break;


            case GDI32.EMR_POLYBEZIERTO:
                break;


            case GDI32.EMR_POLYBEZIER:
                {
                    Point[] points = UnpackPoints(aRecord);

                    // Now we have everything, so call the call
                    PolyBezier(points);
                }
                break;

            case GDI32.EMR_POLYGON:
                {
                    Point[] points = UnpackPoints(aRecord);

                    // Now we have everything, so call the call
                    Polygon(points);
                }
                break;

            case GDI32.EMR_POLYPOLYGON:
                break;


            case GDI32.EMR_POLYLINE:
                {
                    Point[] points = UnpackPoints(aRecord);

                    // Now we have everything, so call the call
                    PolyLine(points);
                }
                break;

            case GDI32.EMR_POLYLINETO:
                {
                    Point[] points = UnpackPoints(aRecord);

                    //PolyLineTo(points);
                }
                break;

            case GDI32.EMR_POLYPOLYLINE:
                break;

            case GDI32.EMR_POLYTEXTOUTA:
            case GDI32.EMR_POLYTEXTOUTW:
                break;


            case GDI32.EMR_EXTTEXTOUTA:
            case GDI32.EMR_EXTTEXTOUTW:
                {
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    int strLength = aRecord.NextInt32();
                    string text = (string)aRecord;
                    DrawString(x, y, text);
                }
                break;

            case GDI32.EMR_EXTCREATEFONTINDIRECTW:
                {
                    LOGFONT newFont = new LOGFONT();

                    int faceNameLength = aRecord.NextInt32();
                    newFont.lfFaceName = aRecord.NextUtf8String(faceNameLength);
                    newFont.lfHeight = aRecord.NextInt32();
                    newFont.lfCharSet = aRecord.NextByte();
                    newFont.lfClipPrecision = aRecord.NextByte();
                    newFont.lfEscapement = aRecord.NextInt32();
                    newFont.lfItalic = aRecord.NextByte();
                    newFont.lfOrientation = aRecord.NextInt32();
                    newFont.lfOutPrecision = aRecord.NextByte();
                    newFont.lfPitchAndFamily = aRecord.NextByte();
                    newFont.lfQuality = aRecord.NextByte();
                    newFont.lfStrikeOut = aRecord.NextByte();
                    newFont.lfUnderline = aRecord.NextByte();
                    newFont.lfWeight = aRecord.NextInt32();
                    newFont.lfWidth = aRecord.NextInt32();

                    Guid uniqueID = this.UnpackGuid(aRecord);

                    CreateFont(newFont.lfFaceName, newFont.lfHeight, uniqueID);
                }
                break;


            case GDI32.EMR_CREATEMONOBRUSH:
            case GDI32.EMR_EXTCREATEPEN:
            case GDI32.EMR_CREATEDIBPATTERNBRUSHPT:
                break;

            case GDI32.EMR_FILLRGN:
            case GDI32.EMR_FRAMERGN:
            case GDI32.EMR_INVERTRGN:
            case GDI32.EMR_PAINTRGN:
            case GDI32.EMR_EXTSELECTCLIPRGN:
                break;

            case GDI32.EMR_ALPHABLEND:
                {
                    // Get the X, Y
                    int x = aRecord.NextInt32();
                    int y = aRecord.NextInt32();
                    int width = aRecord.NextInt32();
                    int height = aRecord.NextInt32();

                    int srcX = aRecord.NextInt32();
                    int srcY = aRecord.NextInt32();
                    int srcWidth = aRecord.NextInt32();
                    int srcHeight = aRecord.NextInt32();

                    byte alpha = aRecord.NextByte();

                    // Now create a pixbuff on the specified size
                    int buffWidth = aRecord.NextInt32();
                    int buffHeight = aRecord.NextInt32();
                    PixelBuffer pixBuff = new PixelBuffer(buffWidth, buffHeight);
                    int dataSize = aRecord.NextInt32();

                    // Copy the received data into it right pixel data pointer
                    aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);

                    // And finally, call the BitBlt function
                    AlphaBlend(x,y,width,height, pixBuff,srcX,srcY, srcWidth,srcHeight,alpha);
                }
                break;

            case GDI32.EMR_STRETCHBLT:
            case GDI32.EMR_MASKBLT:
            case GDI32.EMR_PLGBLT:
            case GDI32.EMR_SETDIBITSTODEVICE:
            case GDI32.EMR_STRETCHDIBITS:
            case GDI32.EMR_TRANSPARENTBLT:
                break;


            case GDI32.EMR_GDICOMMENT:
            case GDI32.EMR_GLSRECORD:
            case GDI32.EMR_GLSBOUNDEDRECORD:
                break;

            case GDI32.EMR_SETLAYOUT:
                break;

            case GDI32.EMR_PIXELFORMAT:
                break;

            case GDI32.EMR_CREATECOLORSPACE:
            case GDI32.EMR_SETCOLORSPACE:
            case GDI32.EMR_DELETECOLORSPACE:
            case GDI32.EMR_COLORCORRECTPALETTE:
            case GDI32.EMR_SETICMMODE:
            case GDI32.EMR_SETICMPROFILEA:
            case GDI32.EMR_SETICMPROFILEW:
            case GDI32.EMR_COLORMATCHTOTARGETW:
            case GDI32.EMR_CREATECOLORSPACEW:
                break;

            case GDI32.EMR_RESERVED_105:            // These will likely never show up
            case GDI32.EMR_RESERVED_106:
            case GDI32.EMR_RESERVED_107:
            case GDI32.EMR_RESERVED_108:
            case GDI32.EMR_RESERVED_109:
            case GDI32.EMR_RESERVED_110:
            case GDI32.EMR_RESERVED_117:
            case GDI32.EMR_RESERVED_119:
            case GDI32.EMR_RESERVED_120:
            case GDI32.EMR_POLYBEZIER16:    // Probably no real need to implement these
            case GDI32.EMR_POLYBEZIERTO16:
            case GDI32.EMR_POLYGON16:
            case GDI32.EMR_POLYPOLYGON16:
            case GDI32.EMR_POLYLINE16:
            case GDI32.EMR_POLYLINETO16:
            case GDI32.EMR_POLYPOLYLINE16:
            case GDI32.EMR_POLYDRAW16:
            default:
                //if (CommandReceived != null)
                //    CommandReceived(aRecord);
                break;
        }
    }