protected override Size ArrangeOverride(Size finalSize)
        {
            double newWidth, newHeight;
            newWidth = _borderContentContainer.ActualWidth + _contentMargin.Left + _contentMargin.Right;
            newHeight = _borderContentContainer.ActualHeight + _contentMargin.Top + _contentMargin.Bottom;

            newWidth = newWidth < _minSize.Width ? _minSize.Width : newWidth;
            newHeight = newHeight < _minSize.Height ? _minSize.Height : newHeight;
            return new Size(newWidth, newHeight);
        } 

        protected override Size MeasureOverride(Size availableSize)
        {
            Size contentSize = availableSize;
            contentSize.Width -= _contentMargin.Left + _contentMargin.Right;
            contentSize.Height -= _contentMargin.Top + _contentMargin.Bottom;

            //_borderContentContainer.Measure(contentSize);
            //_gridContainer.Measure(availableSize);


            double newWidth, newHeight;
            newWidth = _borderContentContainer.ActualWidth + _contentMargin.Left + _contentMargin.Right;
            newHeight = _borderContentContainer.ActualHeight + _contentMargin.Top + _contentMargin.Bottom;

            newWidth = newWidth < _minSize.Width ? _minSize.Width : newWidth;
            newHeight = newHeight < _minSize.Height ? _minSize.Height : newHeight;
            return new Size(newWidth, newHeight);
        }

        Point s = new Point();
        private void Window_MouseMove(object sender, MouseEventArgs e)
        {
            Point p = e.GetPosition(this);

            if (p != s)
            {
                imgCenter.MoveY(this, p.Y - imgCenter.Height / 2);
            }
        }
        public static void MoveY(this Image target, UIElement rel, double newY)
        {
            Point p = target.TranslatePoint(new Point(0, 0), rel);
            double top = p.Y;
            TranslateTransform trans = new TranslateTransform();
            target.RenderTransform = trans;
            DoubleAnimation anim = new DoubleAnimation(top, newY, TimeSpan.FromSeconds(2));
            trans.BeginAnimation(TranslateTransform.YProperty, anim);
        }    

                GetWindowThreadProcessId(GetClipboardOwner(), out pid);
                cpid = GetCurrentProcessId();

                if (pid != cpid)
                    OnClipboardChange();

    /// <summary>
    /// Clipboardformate.
    /// </summary>
    public enum CBDataType
    {
        /// <summary>
        /// Nicht untersüztes Clipboardformat
        /// </summary>
        Unsupported,
        
        /// <summary>
        /// Daten im Filelist-Format vorhanden.
        /// </summary>
        Files,

        /// <summary>
        /// Format im Audio-Format vorhanden.
        /// </summary>
        Audio,

        /// <summary>
        /// Format im Image-Format vorhanden.
        /// </summary>
        Image,

        /// <summary>
        /// Format im Text-Format vorhanden.
        /// </summary>
        Text,
    }

    public delegate void ClipboardWatcherOnChangeEventHandler(CBDataType type, object data);

    public class ClipboardWatcher
    {
        #region WIN API
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);
        [DllImport("user32.dll")]
        public static extern bool ChangeClipboardChain(IntPtr hWndRemove, IntPtr hWndNewNext);
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern int SendMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam);
        [DllImport("user32.dll")]
        static extern IntPtr GetClipboardOwner();
        [DllImport("user32.dll")]
        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
        [DllImport("kernel32.dll")]
        static extern uint GetCurrentProcessId();
        private const UInt32 WM_CHANGECBCHAIN       = 0x030D;
        private const UInt32 WM_DRAWCLIPBOARD       = 0x0308;
        private const UInt32 WM_CLOSE               = 0x0010;
        private const UInt32 WM_DESTROY             = 0x0002;
        #endregion

        private static bool _instance = false;
        private IntPtr _nextCBWatcher;
        private IntPtr _ownerWnd;
        private bool _wasReset;

        public event ClipboardWatcherOnChangeEventHandler ClipboardChange;
        
        public ClipboardWatcher(IntPtr OwnerWnd) 
        {
            ClipboardChange = null;
            _nextCBWatcher = IntPtr.Zero;
            _ownerWnd = OwnerWnd;
            _nextCBWatcher = SetClipboardViewer(_ownerWnd);

            if (_instance) throw new Exception("Only one instance at a time. TODO: Check SetData() triggering twice our MessageProc...");

            _instance = true;
            _wasReset = false;
        }

        public static void SetData(CBDataType type, object data) 
        {
            object dat;
            switch (type)
            {
                case CBDataType.Files:
                    dat = data as StringCollection;
                    if (dat == null) throw new Exception("Invalid data.");
                    Clipboard.SetFileDropList((StringCollection)dat);
                    break;

                case CBDataType.Audio:
                    dat = data as Stream;
                    if (dat == null) throw new Exception("Invalid data.");
                    Clipboard.SetAudio((Stream)dat);
                    break;

                case CBDataType.Image:
                    dat = data as Image;
                    if (dat == null) throw new Exception("Invalid data.");
                    Clipboard.SetImage((Image)dat);
                    break;

                case CBDataType.Text:
                    dat = data as string;
                    if (dat == null) throw new Exception("Invalid data.");
                    Clipboard.SetText((string)dat);
                    break;

                default: throw new Exception("Unsupported Clipboardformat.");
            }

        }

        public void SetClipboardViewer()
        {
            _wasReset = true;
            ChangeClipboardChain(_ownerWnd, _nextCBWatcher);
            _nextCBWatcher = SetClipboardViewer(_ownerWnd);
        }

        public void MessageProc(ref Message m) 
        {
            if (m.Msg == WM_CHANGECBCHAIN)
            {
                if (m.WParam == _nextCBWatcher)
                {
                    _nextCBWatcher = m.LParam;
                }
                else
                {
                    SendMessage(_nextCBWatcher, m.Msg, m.WParam, m.LParam);
                }
            }
            else if (m.Msg == WM_DRAWCLIPBOARD)
            {
                uint cpid = 0, pid = 0;

                if (_wasReset)
                {
                    _wasReset = false;
                    return;
                }
                
                GetWindowThreadProcessId(GetClipboardOwner(), out pid);
                cpid = GetCurrentProcessId();

                if (pid != cpid)
                    OnClipboardChange();

                if (_nextCBWatcher != IntPtr.Zero)
                    SendMessage(_nextCBWatcher, m.Msg, m.WParam, m.LParam);
            }
            else if (m.Msg == WM_DESTROY)
            {
                ChangeClipboardChain(_ownerWnd, _nextCBWatcher);
            }
        }

        protected virtual void OnClipboardChange() 
        {
            object obj = null;
            CBDataType objType = CBDataType.Unsupported;

            if (Clipboard.ContainsFileDropList())
            {
                obj = Clipboard.GetFileDropList();
                objType = CBDataType.Files;
            }
            else if (Clipboard.ContainsAudio())
            {
                obj = Clipboard.GetAudioStream();
                objType = CBDataType.Audio;
            }
            else if (Clipboard.ContainsImage())
            {
                obj = Clipboard.GetImage();
                objType = CBDataType.Image;
            }
            else if (Clipboard.ContainsText())
            {
                obj = Clipboard.GetText();
                objType = CBDataType.Text;
            }
            else
                obj = Clipboard.GetDataObject();

            Control ctrl = ClipboardChange.Target as Control;
            if (ClipboardChange != null)
            {
                if (ctrl != null && ctrl.InvokeRequired)
                    ClipboardChange.Invoke(objType, obj);
                else
                    ClipboardChange(objType, obj);
            }
        }
    }

if (selected)
    dc.DrawImage(selectedImages[idx])
else
    dc.DrawImage(itemImages[idx])

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using DrawingEx;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace substx
{
    class DesignListBox : ListBox
    {
        public DesignListBox()
        {
            base.SetStyle(ControlStyles.OptimizedDoubleBuffer |
                          ControlStyles.ResizeRedraw |
                          ControlStyles.AllPaintingInWmPaint,
                          true);

            // DoubleBuffered = true; <-- nutzt auch nix WAH!!!
            base.DrawMode = DrawMode.OwnerDrawFixed;
        }

        protected override void OnDrawItem(DrawItemEventArgs e)
        {

            Rectangle bnd = e.Bounds;
            Graphics dc = e.Graphics;
            ColorTable ct = (ColorTable)Items[e.Index];
            int pad = 6;
            int pwh = bnd.Height - 2 * pad;
            Rectangle pi0 = new Rectangle(bnd.X + pad, bnd.Y + pad, pwh, pwh);
            Rectangle pi1 = new Rectangle(bnd.X + pi0.Right + pad, bnd.Y + pad, pwh, pwh);
            Rectangle pi2 = new Rectangle(bnd.X + pi1.Right + pad, bnd.Y + pad, pwh, pwh);
            Rectangle pi3 = new Rectangle(bnd.X + pi2.Right + pad, bnd.Y + pad, pwh, pwh);

            if (ct == null)
            {
                #region Error
                dc.FillRectangle(new SolidBrush(BackColor), bnd);
                StringFormat sf = new StringFormat();
                sf.LineAlignment = StringAlignment.Center;
                sf.Alignment = StringAlignment.Center;
                dc.DrawString("Error Item.", Font, new SolidBrush(Color.Red), bnd, sf);
                #endregion
            }
            else
            {
                #region Preview
                dc.SetColorTableWindowsVista(ct);
                dc.FillRectangle(new SolidBrush(ct.Background), bnd);
                dc.DrawVistaButtonBackground(pi0, 2, true, false, false);
                dc.DrawVistaButtonBackground(pi1, 2, true, true, false);
                dc.DrawVistaButtonBackground(pi2, 2, true, false, true);
                dc.DrawVistaButtonBackground(pi3, 2, true, true, true);

                Rectangle capt = bnd; capt.X += 8; capt.Width -= 8;
                StringFormat sf = new StringFormat();
                sf.LineAlignment = StringAlignment.Center;
                dc.DrawString(ct.Name + ((ct == Design.ColorTable) ? " (Aktiv)" : ""), Font, new SolidBrush(ct.Text), capt, sf);
                #endregion
            }

            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
            {
                #region Selection
                Rectangle sel = bnd;
                Rectangle selhalf;
                Color selcl = Color.CornflowerBlue;

                sel.Inflate(-2, -2);
                using (GraphicsPath psel = RoundedRectangle.Create(sel, 2))
                {
                    using (Pen selouter = new Pen(Color.FromArgb(75, selcl)))
                    {
                        dc.DrawPath(selouter, psel);
                    }
                }
                sel.Inflate(-1, -1);
                selhalf = sel;
                selhalf.Height /= 2;
                using (GraphicsPath psel = RoundedRectangle.Create(selhalf, 2,
                    RoundedRectangle.RectangleCorners.TopLeft &
                    RoundedRectangle.RectangleCorners.TopRight))
                {
                    selhalf.Height++;
                    using (LinearGradientBrush lgb = new LinearGradientBrush(
                        selhalf, Color.FromArgb(150, selcl), Color.Transparent, 90f))
                    {
                        dc.FillPath(lgb, psel);
                    }
                }
                using (GraphicsPath psel = RoundedRectangle.Create(sel, 2))
                using (Pen selinner = new Pen(Color.FromArgb(150, selcl)))
                {
                    dc.DrawPath(selinner, psel);
                }
                #endregion
            }
        }
    }
}

        const int TV_FIRST = 0x1100;
        const int TVM_GETITEMRECT = (TV_FIRST + 4);
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);
        private void UpdateSingleNode(TreeNode node)
        {
            if (node.IsVisible)
            {

                RECT rc;
                unsafe
                {
                    *(void**)&rc = node.Handle.ToPointer();
                    SendMessage(Handle, TVM_GETITEMRECT, IntPtr.Zero, new IntPtr(&rc));
                }

                // dc der treeview holen
                using (Graphics dc = Graphics.FromHwnd(Handle))
                {
                    // erstelle set mit atm verarbeiteten states
                    TreeNodeStates states = TreeNodeStates.Default;
                    states |= node.IsSelected ? TreeNodeStates.Selected : TreeNodeStates.Default;

                    // sende ondrawnode 
                    OnDrawNode(new DrawTreeNodeEventArgs(dc, node, rc.ToRectangle(), states));
                }
            }
        }




        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            int _left;
            int _top;
            int _right;
            int _bottom;

            public RECT(global::System.Drawing.Rectangle rectangle)
                : this(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom)
            {
            }
            public RECT(int left, int top, int right, int bottom)
            {
                _left = left;
                _top = top;
                _right = right;
                _bottom = bottom;
            }

            public int X
            {
                get { return Left; }
                set { Left = value; }
            }
            public int Y
            {
                get { return Top; }
                set { Top = value; }
            }
            public int Left
            {
                get { return _left; }
                set { _left = value; }
            }
            public int Top
            {
                get { return _top; }
                set { _top = value; }
            }
            public int Right
            {
                get { return _right; }
                set { _right = value; }
            }
            public int Bottom
            {
                get { return _bottom; }
                set { _bottom = value; }
            }
            public int Height
            {
                get { return Bottom - Top; }
                set { Bottom = value - Top; }
            }
            public int Width
            {
                get { return Right - Left; }
                set { Right = value + Left; }
            }
            public global::System.Drawing.Point Location
            {
                get { return new global::System.Drawing.Point(Left, Top); }
                set
                {
                    Left = value.X;
                    Top = value.Y;
                }
            }
            public global::System.Drawing.Size Size
            {
                get { return new global::System.Drawing.Size(Width, Height); }
                set
                {
                    Right = value.Width + Left;
                    Bottom = value.Height + Top;
                }
            }

            public global::System.Drawing.Rectangle ToRectangle()
            {
                return new global::System.Drawing.Rectangle(this.Left, this.Top, this.Width, this.Height);
            }
            public static global::System.Drawing.Rectangle ToRectangle(RECT Rectangle)
            {
                return Rectangle.ToRectangle();
            }
            public static RECT FromRectangle(global::System.Drawing.Rectangle Rectangle)
            {
                return new RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
            }

        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.IO;
using System.Drawing;

namespace GamesVerwaltung
{
    class MultiIcon
    {
        private struct TIconHeader
        {
            public short res0;
            public short imgtype;
            public short imgcount;
        }
        private struct TIconData
        {
            public byte width;
            public byte height;
            public byte clcount;
            public byte res0;
            public short clplanes;
            public short bpp;
            public int imglen;
            public int imgadr;
        }

        private Bitmap[] bitmaps;
        private TIconData[] icondata;
        private TIconHeader iconheader;

        public MultiIcon()
        {
            bitmaps = new Bitmap[6];
            icondata = new TIconData[6];

            iconheader = new TIconHeader();
            iconheader.imgcount = 6;
            iconheader.imgtype = 1;
            iconheader.res0 = 0;
        }

        private void setImage(int idx, Bitmap bmp)
        {
            bitmaps[idx] = bmp;

            icondata[idx].bpp = 32;
            icondata[idx].clcount = 0;
            icondata[idx].clplanes = 0;
            icondata[idx].height = (byte)(bmp.Height == 256 ? 0 : bmp.Height);
            icondata[idx].width = (byte)(bmp.Width == 256 ? 0 : bmp.Width);
            icondata[idx].res0 = 0;
            icondata[idx].imgadr = -1;
            icondata[idx].imglen = -1;
        }

        public void SetAll(Image img)
        {
            setImage(0, createHighRes(img, 16, 16));
            setImage(1, createHighRes(img, 24, 24));
            setImage(2, createHighRes(img, 32, 32));
            setImage(3, createHighRes(img, 48, 48));
            setImage(4, createHighRes(img, 128, 128));
            setImage(5, createHighRes(img, 256, 256));
        }

        public void Save(string file)
        {
            FileStream fstr = new FileStream(file, FileMode.Create, FileAccess.Write);
            writeIcon(fstr);
            fstr.Close();
            fstr.Dispose();
        }

        private void writeIcon(Stream str)
        {
            BinaryWriter bw = new BinaryWriter(str);

            bw.Write(iconheader.res0);
            bw.Write(iconheader.imgtype);
            bw.Write(iconheader.imgcount);

            int offset = 6 /*ANZAHL DER BILDER*/ * 16 /*BYTEGRÖßE ICONHEADER*/;
            int iconheader0offset = (int)str.Position;
            str.Position += offset;

            for (int i = 0; i < 6; i++)
            {
                Bitmap bmp = bitmaps[i];

                //MemoryStream mstr = new MemoryStream();
                icondata[i].imgadr = (int)str.Position;
                bmp.Save(str, System.Drawing.Imaging.ImageFormat.Png);
                icondata[i].imglen = (int)(str.Position - icondata[i].imgadr);
            }

            str.Position = iconheader0offset;

            for (int i = 0; i < 6; i++)
            {
                TIconData idat = icondata[i];
                /*
                    0 	1 	Specifies image width in pixels. Can be 0, 255 or a number between 0 to 255. Should be 0 if image width is 256 pixels.
                    1 	1 	Specifies image height in pixels. Can be 0, 255 or a number between 0 to 255. Should be 0 if image height is 256 pixels.
                    2 	1 	Specifies number of colors in the color palette. Should be 0 if the image is truecolor.
                    3 	1 	Reserved. Should be 0.[Notes 1]
                    4 	2 	In .ICO format: Specifies color planes. Should be 0 or 1.[Notes 2]
                    6 	2 	In .ICO format: Specifies bits per pixel. [Notes 3]
                    8 	4 	Specifies the size of the bitmap data in bytes
                    12 	4 	Specifies the offset of bitmap data address in the file
                */
                bw.Write(idat.width);
                bw.Write(idat.height);
                bw.Write(idat.clcount);
                bw.Write(idat.res0);
                bw.Write(idat.clplanes);
                bw.Write(idat.bpp);
                bw.Write(idat.imglen);
                bw.Write(idat.imgadr);
            }
        }

        private Bitmap createHighRes(Image img, int w, int h)
        {
            Bitmap bmp = new Bitmap(w, h);

            Graphics dc = Graphics.FromImage(bmp);
            dc.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
            dc.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
            dc.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            dc.DrawImage(img, 0, 0, w, h);
            dc.Dispose();

            return bmp;
        }
    }
}

uint wstyle = (uint)Win32.User32Api.GetWindowLong(hWin, Win32.User32Api.GWL_STYLE);
const uint ws_child = 0x40000000;
if ((ws_child & wstyle) == ws_child)
    return;