示例#1
0
 private void AdjustPositionByAnchor()
 {
     Win32.Point windowPos = _dockAnchor.GetWindowPosition();
     if (this.Top != windowPos.y)
     {
         this.Top = windowPos.y;
     }
     if (this.Left != windowPos.x)
     {
         this.Left = windowPos.x;
     }
 }
示例#2
0
 internal void SetAnchorPosition(int anchorX, int anchorY)
 {
     _dockAnchor.SetPosition(anchorX, anchorY);
     Win32.Point windowPos = _dockAnchor.GetWindowPosition();
     if (this.Top != windowPos.y)
     {
         this.Top = windowPos.y;
     }
     if (this.Left != windowPos.x)
     {
         this.Left = windowPos.x;
     }
 }
        /// <para>Changes the current bitmap with a custom opacity level.  Here is where all happens!</para>
        public void SetBitmap(Bitmap bitmap, byte opacity)
        {
            if (bitmap.PixelFormat != PixelFormat.Format32bppArgb)
            {
                throw new ApplicationException("The bitmap must be 32ppp with alpha-channel.");
            }

            if (this.IsDisposed)
            {
                return;
            }

            // The idea of this is very simple,
            // 1. Create a compatible DC with screen;
            // 2. Select the bitmap with 32bpp with alpha-channel in the compatible DC;
            // 3. Call the UpdateLayeredWindow.

            IntPtr screenDc  = Win32.GetDC(IntPtr.Zero);
            IntPtr memDc     = Win32.CreateCompatibleDC(screenDc);
            IntPtr hBitmap   = IntPtr.Zero;
            IntPtr oldBitmap = IntPtr.Zero;

            try
            {
                hBitmap   = bitmap.GetHbitmap(Color.FromArgb(0)); // grab a GDI handle from this GDI+ bitmap
                oldBitmap = Win32.SelectObject(memDc, hBitmap);

                Win32.Size          size        = new Win32.Size(bitmap.Width, bitmap.Height);
                Win32.Point         pointSource = new Win32.Point(0, 0);
                Win32.Point         topPos      = new Win32.Point(Left, Top);
                Win32.BLENDFUNCTION blend       = new Win32.BLENDFUNCTION();
                blend.BlendOp             = Win32.AC_SRC_OVER;
                blend.BlendFlags          = 0;
                blend.SourceConstantAlpha = opacity;
                blend.AlphaFormat         = Win32.AC_SRC_ALPHA;

                Win32.UpdateLayeredWindow(Handle, screenDc, ref topPos, ref size, memDc, ref pointSource, 0, ref blend, Win32.ULW_ALPHA);
            }
            finally
            {
                Win32.ReleaseDC(IntPtr.Zero, screenDc);
                if (hBitmap != IntPtr.Zero)
                {
                    Win32.SelectObject(memDc, oldBitmap);
                    //Windows.DeleteObject(hBitmap); // The documentation says that we have to use the Windows.DeleteObject... but since there is no such method I use the normal DeleteObject from Win32 GDI and it's working fine without any resource leak.
                    Win32.DeleteObject(hBitmap);
                }
                Win32.DeleteDC(memDc);
            }
        }
示例#4
0
        internal void Initialize(DockAnchor.Type type, double dx, double dy)
        {
            _anchorType = type;

            _anchorDx = 0.5 /*dx*/;
            _anchorDy = 0.5 /*dy*/;

            if ((_anchorType & DockAnchor.Type.Left) != 0)
            {
                _anchorDx = 0;
            }
            else if ((_anchorType & DockAnchor.Type.Right) != 0)
            {
                _anchorDx = 1;
            }
            else
            {
                _anchorDx = 0.5;
            }

            if ((_anchorType & DockAnchor.Type.Top) != 0)
            {
                _anchorDy = 0;
            }
            else if ((_anchorType & DockAnchor.Type.Bottom) != 0)
            {
                _anchorDy = 1;
            }
            else
            {
                _anchorDy = 0.5;
            }

            Win32.Point anchorPos = CalculatePositionFromWindow();
            _anchorX = anchorPos.x;
            _anchorY = anchorPos.y;
        }