示例#1
0
        /// <summary>
        /// Draw text without a glowing background, for use on a composition element.
        /// </summary>
        /// <param name="g">Graphics reference.</param>
        /// <param name="text">Text to be drawn.</param>
        /// <param name="font">Font to use for text.</param>
        /// <param name="bounds">Bounding area for the text.</param>
        /// <param name="state">State of the source element.</param>
        /// <param name="color"><see cref="Color"/> of the text.</param>
        /// <param name="copyBackground">Should existing background be copied into the bitmap.</param>
        /// <param name="sf">StringFormat of the memento.</param>
        public static void DrawCompositionText(Graphics g,
                                               string text,
                                               Font font,
                                               Rectangle bounds,
                                               PaletteState state,
                                               Color color,
                                               bool copyBackground,
                                               StringFormat sf)
        {
            // Get the hDC for the graphics instance and create a memory DC
            IntPtr gDC = g.GetHdc();

            try
            {
                IntPtr mDC = PI.CreateCompatibleDC(gDC);

                PI.BITMAPINFO bmi = new()
                {
                    biWidth       = bounds.Width,
                    biHeight      = -bounds.Height,
                    biCompression = 0,
                    biBitCount    = 32,
                    biPlanes      = 1
                };
                bmi.biSize = (uint)Marshal.SizeOf(bmi);

                // Create a device independent bitmap and select into the memory DC
                IntPtr hDIB = PI.CreateDIBSection(gDC, ref bmi, 0, out _, IntPtr.Zero, 0);
                PI.SelectObject(mDC, hDIB);

                if (copyBackground)
                {
                    // Copy existing background into the bitmap
                    PI.BitBlt(mDC, 0, 0, bounds.Width, bounds.Height,
                              gDC, bounds.X, bounds.Y, 0x00CC0020);
                }

                // Select the font for use when drawing
                IntPtr hFont = font.ToHfont();
                PI.SelectObject(mDC, hFont);

                // Get renderer for the correct state
                VisualStyleRenderer renderer = new(state == PaletteState.Normal ? VisualStyleElement.Window.Caption.Active :
                                                   VisualStyleElement.Window.Caption.Inactive);

                // Create structures needed for theme drawing call
                PI.RECT textBounds = new()
                {
                    left   = 0,
                    top    = 0,
                    right  = bounds.Right - bounds.Left,
                    bottom = bounds.Bottom - bounds.Top
                };
                PI.DTTOPTS dttOpts = new()
                {
                    dwSize  = Marshal.SizeOf(typeof(PI.DTTOPTS)),
                    dwFlags = PI.DTT_COMPOSITED | PI.DTT_TEXTCOLOR,
                    crText  = ColorTranslator.ToWin32(color)
                };

                // Always draw text centered
                TextFormatFlags textFormat = TextFormatFlags.SingleLine |
                                             TextFormatFlags.HorizontalCenter |
                                             TextFormatFlags.VerticalCenter;
                ////Seb   |  TextFormatFlags.EndEllipsis;


                // Perform actual drawing
                //PI.DrawThemeTextEx(renderer.Handle,
                //                   mDC, 0, 0,
                //                   text, -1, (int)StringFormatToFlags(sf),
                //                   ref textBounds, ref dttOpts);
                PI.DrawThemeTextEx(renderer.Handle,
                                   mDC, 0, 0,
                                   text, -1, (int)textFormat,
                                   ref textBounds, ref dttOpts);

                // Copy to foreground
                PI.BitBlt(gDC,
                          bounds.Left, bounds.Top,
                          bounds.Width, bounds.Height,
                          mDC, 0, 0, 0x00CC0020);

                // Dispose of allocated objects
                PI.DeleteObject(hFont);
                PI.DeleteObject(hDIB);
                PI.DeleteDC(mDC);
            }
            catch
            {
                // ignored
            }
            finally
            {
                // Must remember to release the hDC
                g.ReleaseHdc(gDC);
            }
        }
示例#2
0
        private void UpdateLayeredWindow(Rectangle rect)
        {
            // Cache the latest size and location
            _showRect = rect;

            // Must have a visible rectangle to render
            if ((rect.Width > 0) && (rect.Height > 0))
            {
                // Draw onto a bitmap that is then used as the window display
                Bitmap memoryBitmap = new Bitmap(rect.Width, rect.Height, PixelFormat.Format32bppArgb);
                using (Graphics g = Graphics.FromImage(memoryBitmap))
                {
                    // Perform actual painting onto the bitmap
                    Rectangle area = new Rectangle(0, 0, rect.Width, rect.Height);
                    using (RenderContext context = new RenderContext(null, g, area, _renderer))
                    {
                        _renderer.RenderGlyph.DrawDragDropDockingGlyph(context, _dragData, _paletteDragDrop, PaletteDragFeedback.Rounded);
                    }

                    // Get hold of the screen DC
                    IntPtr hDC = PI.GetDC(IntPtr.Zero);

                    // Create a memory based DC compatible with the screen DC
                    IntPtr memoryDC = PI.CreateCompatibleDC(hDC);

                    // Get access to the bitmap handle contained in the Bitmap object
                    IntPtr hBitmap = memoryBitmap.GetHbitmap(Color.FromArgb(0));

                    // Select this bitmap for updating the window presentation
                    IntPtr oldBitmap = PI.SelectObject(memoryDC, hBitmap);

                    // New window size
                    PI.SIZE ulwsize;
                    ulwsize.cx = rect.Width;
                    ulwsize.cy = rect.Height;

                    // New window position
                    PI.POINT topPos = new PI.POINT(rect.Left, rect.Top);
                    // Offset into memory bitmap is always zero
                    PI.POINT pointSource = new PI.POINT(0, 0);

                    // We want to make the entire bitmap opaque
                    PI.BLENDFUNCTION blend = new PI.BLENDFUNCTION
                    {
                        BlendOp             = PI.AC_SRC_OVER,
                        BlendFlags          = 0,
                        SourceConstantAlpha = 255,
                        AlphaFormat         = PI.AC_SRC_ALPHA
                    };

                    // Tell operating system to use our bitmap for painting
                    PI.UpdateLayeredWindow(Handle, hDC, ref topPos, ref ulwsize,
                                           memoryDC, ref pointSource, 0, ref blend,
                                           PI.ULW_ALPHA);

                    // Put back the old bitmap handle
                    PI.SelectObject(memoryDC, oldBitmap);

                    // Cleanup resources
                    PI.ReleaseDC(IntPtr.Zero, hDC);
                    PI.DeleteObject(hBitmap);
                    PI.DeleteDC(memoryDC);
                }
            }
        }